Casta datatyper i javascript. JavaScript: Datatypkonvertering

Facebook

JavaScript tillhandahåller flera inbyggda datatyper. Utöver dessa täcker den här artikeln virtuella typer i jQuery såsom väljare, utökade pseudotyper som händelser och alla typer av funktioner.

Det är bäst om du provar de flesta av exemplen nedan. Detta kan enkelt göras genom att helt enkelt kopiera dessa exempel till Firebug-konsolen, en Firefox webbläsartillägg.

När exemplen utför operationer i ett booleskt sammanhang (som jämförelser), är det viktigt att veta hur varje datatyp beter sig i det sammanhanget:

Var x = "" if (x) console.log("x standard till true") else console.log("x standard till false")

I det här fallet kommer "x är lika med false" att skrivas ut.

För att minska längden på exempel används negationsoperatorn för att visa booleskt sammanhang:

X // sant

jQuery-datatyper

Strängar
- Inbyggda metoder för strängar
- längd egendom
- booleskt sammanhang
Tal
- booleskt sammanhang
- Analysera siffror
- Siffror till strängar
- NaN och Infinity
- Heltal
- Flyta
boolesk typ
Föremål
- Punktnotation
- Array Notation
- Iteration
- boolesk standard
- Prototyp
alternativ
Matriser
- Iteration
- Boolean Standard
- Array Notation
Funktioner
- Argument
- Sammanhang, ring och ansök
- Synlighetsområde
- Stängningar
- Proxymönster
Återuppringningsfunktioner
Väljare
evenemang
Element
jQuery typ
XMLHttpRequest-typ

Strängar

"Detta är en JavaScript-sträng!" "Och det här är också en rad!"

En sträng i JavaScript är ett oföränderligt objekt som innehåller noll, ett eller flera tecken.

Typen av strängar är "sträng". Du kan ta reda på typen av en sträng så här:

Typ av "någon sträng"; // "sträng"

Använda citattecken i strängar

En sträng kan definieras med enkla eller dubbla citattecken. Du kan fritt använda enstaka citattecken inom en sträng innesluten i dubbla citattecken och vice versa. För att använda dubbla citattecken i strängar med dubbla citattecken måste de escapes med ett omvänt snedstreck \ . Detta gäller även för enstaka citat.

"Du gör mig ledsen." "Heliga "veva" moses!" " Hem" "Hem"

Inbyggda metoder för strängar

JavaScript har flera inbyggda metoder för att manipulera strängar, vars resultat kan vara antingen en sträng eller till exempel en array:

"hello".charAt(0) // "h" - få in tecknet önskad position strängar "hello".toUpperCase() // "HELLO" - konverterar strängen till versaler "Hello".toLowerCase() // "hello" - konverterar strängen till gemener "hello".replace(/e|o/g, "x") // "hxllx" - ersätter en del av en sträng med en delsträng med det reguljära uttrycksmönstret "1,2,3".split(",") // ["1", "2", "3 "] - dela strängar till array efter specifik delsträng

längd egendom

Linjerna har längd egendom, som anger längden på strängen.

"Hello".length // 5 "".length // 0

booleskt sammanhang

En tom sträng utvärderas till false:

!"" // true ! "hej" // false ! "true" // false !new Boolean(false) // false

Tal

12 3.543

Siffror i JavaScript är i 64-bitars dubbelprecisionsformat enligt IEEE 754-standarden. De är också oföränderliga. För att arbeta med siffror finns alla operatorer tillgängliga, samma som i C-språket (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

Typen för siffror är "nummer". Du kan kontrollera typen av nummer så här:

Typ av 12 // "nummer" typ av 3,543 // "nummer"

booleskt sammanhang

Om talet är noll är det lika med false:

0 // sant !1 // falskt !-1 // falskt

På grund av det faktum att siffrorna är implementerade i dubbel precisionsformat blir resultatet följande exempelär inte felaktigt:

0.1 + 0.2 // 0.30000000000000004

Math objekt

JavaScript tillhandahåller funktioner för att arbeta med siffror i ett Math-objekt:

Math.PI // 3.141592653589793 Math.cos(Math.PI) // -1

Konvertera till siffror

Funktionerna parseInt och parseFloat konverterar strängar till tal. Båda funktionerna utför implicit konvertering om talsystemet inte är specificerat:

ParseInt("123") = 123 (implicit decimalkonvertering) parseInt("010") = 8 (implicit oktal omvandling) parseInt("0xCAFE") = 51966 (implicit hex-konvertering) parseInt("010", 10) = 10 ( explicit decimalkonvertering med radix 10) parseInt("11", 2) = 3 (explicit binär konvertering) parseFloat("10.10") = 10.1

Konvertera tal till strängar

Om du lägger till siffror i en sträng med "+"-operationen, blir resultatet alltid en sträng. För att utföra beräkningar innan du lägger till ett tal i en sträng, se till att omge beräkningarna inom parentes:

"" + 1 + 2; // "12" "" + (1 + 2); // "3" "" + 0,0000001; // "1e-7" parseInt(0,0000001); // 1 (obs!)

Du kan också använda klassen JavaScript String, som konverterar det skickade värdet till en sträng:

String(1) + String(2); // "12" String(1 + 2); // "3"

NaN och Infinity typer

Omvandling av värden som inte är siffror resulterar i NaN. Funktionen isNaN bestämmer om värdet som skickas till den är lika med NaN:

ParseInt("hej", 10) // NaN ärNaN(parseInt("hej", 10)) // sant

Att dividera med noll ger resultatet Infinity:

1 / 0 // Oändlighet

Både NaN- och Infinity-värdet är av typen "number":

Typ av NaN // "nummer" typ av oändlighet // "nummer"

Observera att jämförelse av NaN-värden sker på ett icke-standardiserat sätt:

NaN == NaN // falskt (!)

Oändlighet == Oändlighet // sant

Heltalstyp

Heltal är en heltalstyp.

Flyttyp

Float är en flyttalstyp.

boolesk typ

En boolesk typ i JavaScript kan vara sant eller falskt:

If (true) console.log("alltid!") if (false) console.log("aldrig!")

Till exempel ser en boolesk typ ut så här när du ställer in anslutningsinställningarna jQuery plugins:

$("...").somePlugin((hideOnStartup: true, onlyOnce: false ));

Föremål

Allt i JavaScript är ett objekt. Det enklaste sättet att skapa ett objekt är:

Var x = (); var y = (namn: "Pete", ålder: 15 );

Typen för objekt är "objekt":

Typeof() // "objekt"

Objektegenskaper

Du kan ändra och få egenskaper för ett objekt med hjälp av punktnotation:

Y.name // "Pete" y.age // 15 x.name = y.name + " Pan" // "Pete Pan" x.age = y.age + 1 // 16

Du kan också använda objektet som en array:

Var operationer = ( öka: "++", minska: "--" ) var operation = "öka"; operationer // "++"; operations["multiply"] = "*"; // "*"

Iterationer på föremål

Att iterera över objekt är mycket enkelt med for-in loop-operatorn:

Var obj = (namn: "Pete", ålder: 15 ); for(nyckel i obj) ( alert("nyckeln är "++", värdet är "+obj); )

jQuery tillhandahåller en funktion

för att iterera över objektegenskaper eller arrayelement:

JQuery.each(obj, funktion(nyckel, värde) (console.log("nyckel", nyckel, "värde", värde); ));

booleskt sammanhang

Ett objekt, oavsett om det har egenskaper eller inte, är alltid sant:

!() // falskt

Prototyper

Alla objekt har en prototypegenskap. Närhelst tolken letar efter en egenskap på ett objekt, kontrollerar den också dess prototyp. I jQuery används denna mekanism i stor utsträckning för att lägga till metoder till instanser av jQuery-objekt.

Var form = $("#myform"); form.clearForm; // odefinierad form.fn.clearForm = function() ( return this.find(":input").each(function() ( this.value = ""; )).end(); ); form.clearForm() // kan tillämpas på alla instanser av jQuery-objekt sedan ny metod lades till prototypen

JavaScript är ett oskrivet språk (mer exakt, svagt skrivet eller dynamiskt skrivet). Det betyder att vi inte ska specificera typen av en variabel när vi deklarerar den. Att vara oskriven ger JavaScript den flexibilitet och enkelhet som gynnas av ett skriptspråk (även om dessa funktioner kommer till priset av bristande noggrannhet, vilket är viktigt för lång eller längre tid komplexa program, som ofta är skrivna på mer rigorösa språk som C eller Java). En viktig egenskap Flexibelt arbete med datatyper i JavaScript tillhandahålls av automatiska datakonverteringar som utförs av tolken. Om du till exempel skickar ett nummer till metoden document.write() konverterar JavaScript det automatiskt till dess motsvarande strängrepresentation. På samma sätt, genom att testa ett strängvärde i tillståndet för en if-sats, konverterar JavaScript automatiskt den strängen till ett booleskt värde – falskt om strängen är tom och annars sant.

Grundregeln är att när ett värde av en typ påträffas i ett sammanhang som kräver ett värde av någon annan typ, kommer JavaScript automatiskt att försöka konvertera värdet på det sätt som krävs. Därför, till exempel, i ett sammanhang som involverar en boolesk variabel, omvandlas ett tal till ett booleskt värde.

Ett objekt i en strängkontext konverteras till en sträng. JavaScript försöker konvertera en sträng i ett numeriskt sammanhang till ett tal.

Objekt-elementär typkonverteringar
Till exempel, i en boolesk kontext, utvärderas alla följande objekt till sanna:

New Boolean(false) // Det interna värdet är false, men objektet
// konverterar till sant
nytt nummer (0)
ny sträng("")
new Array()

Att konvertera objekt till tal börjar med att anropa metoden valueOf() för det objektet. De flesta föremål ärver standardmetod valueOf() av klassen Object, som helt enkelt returnerar själva objektet. Eftersom standardmetoden valueOf() inte returnerar ett primitivt värde, försöker JavaScript sedan konvertera objektet till ett tal genom att anropa dess toString()-metod och konvertera den resulterande strängen till ett tal. För arrayer leder detta till intressanta resultat. Kom ihåg att metoden toString() konverterar arrayelement till strängar och sedan returnerar resultatet av att sammanfoga dessa strängar med kommatecken emellan. Därför konverteras en array utan element till en tom sträng, som konverteras till 0! Dessutom, om matrisen består av ett element, numret n, konverteras matrisen till en strängrepresentation av det numret, som sedan konverteras tillbaka till själva talet n.

Om arrayen innehåller mer än ett element, eller om dess enda element inte är ett tal, konverteras arrayen till NaN. I JavaScript är sammanhanget inte alltid klart definierat! Operatören + och jämförelseoperatorerna (och >=) fungerar med både tal och strängar, så när ett objekt används med en av dessa operatorer är det oklart om det ska konverteras till ett tal eller en sträng. I de flesta fall försöker JavaScript först konvertera objektet genom att anropa metoden valueOf(). Om denna metod returnerar ett primitivt värde (vanligtvis ett tal), används det värdet. Men ofta returnerar valueOf() helt enkelt objektet utan konvertering; i det här fallet försöker JavaScript sedan konvertera objektet till en sträng genom att anropa metoden toString(). Det finns bara ett undantag från denna konverteringsregel: när ett Date-objekt används med operatorn + utförs konverteringen med metoden toString() . Detta undantag finns eftersom Date har både en toString()-metod och en valueOf()-metod. När du använder Date med operatorn + behöver du nästan alltid utföra strängsammansättning. Men när Date är inblandat i jämförelseoperationer kräver det nästan alltid att en numerisk jämförelse utförs för att avgöra vilken av två tidpunkter som föregick den andra.

De flesta objekt har antingen inte en valueOf()-metod eller så returnerar metoden inte användbara resultat.

När operatorn + appliceras på ett objekt, sker vanligtvis strängsammansättning snarare än addition. När en jämförelseoperator tillämpas på ett objekt är det vanligtvis en strängjämförelse snarare än en numerisk jämförelse.

Objektdefinierande speciell metod valueOf() kan bete sig annorlunda. Genom att definiera en valueOf()-metod som returnerar ett tal, kan du tillämpa aritmetiska och andra operatorer på ditt objekt, men att lägga till ditt objekt i en sträng kommer inte att fungera som förväntat: metoden toString() anropas inte längre och sammanlänkningen involverar strängrepresentation av talet som returneras av metoden valueOf().

Slutligen, kom ihåg att metoden valueOf() inte kallas toNumber(); dess uppgift är att konvertera objektet till ett meningsfullt primitivt värde, så vissa objekt kan ha valueOf()-metoder som returnerar strängar.

Explicita typkonverteringar
Java-Script definierar inte en konverteringsoperatör som C, C++ och Java, men det tillhandahåller liknande faciliteter. I JavaScript 1.1 (och ECMA-262-standarden) kan Number(), Boolean(), String() och Object() anropas inte bara som konstruktörer utan också som funktioner. När de anropas på detta sätt försöker dessa funktioner konvertera sina
argument till lämplig typ. Till exempel kan du konvertera vilket x-värde som helst till en sträng med String(x) och vilket y-värde som helst till ett objekt med Object(y).

Det finns flera andra tekniker som kan vara användbara för att utföra explicita typkonverteringar. För att konvertera ett värde till en sträng, sammanfoga det med en tom sträng:

Var x_as_string = x + "";

För att konvertera ett värde till ett tal, subtrahera noll från det:

Var x_as_number = x - 0;

Du kan tvinga ett värde att konverteras till ett booleskt värde genom att använda operatorn!

Var x_as_boolean = !!x;

På grund av JavaScripts tendens att automatiskt konvertera data till det som krävs det här ögonblicket typ, krävs vanligtvis inte explicita omvandlingar. Men ibland visar de sig vara användbara och kan användas för att göra programmet tydligare och mer exakt.

Konvertera tal till strängar
Att konvertera siffror till strängar görs i JavaScript kanske oftare än andra. Även om detta vanligtvis sker automatiskt finns det flera användbara sätt explicit omvandling av detta slag. Vi har redan sett två:

Var string_value = String(nummer); // Använda String()-konstruktorn
// som en funktion
var string_value = nummer + ""; // Sammanfoga med en tom sträng

En annan möjlighet tillhandahålls av metoden toString():

String_value = number.toString();

Metoden toString() för Number-objektet (elementary numeriska värden konverteras till Number-objekt, så du kan anropa denna metod). valfritt argument, som anger basen för det talsystem till vilket omvandlingen kommer att utföras. Om inget argument anges utförs omvandlingen i bas 10. Men du kan konvertera tal i andra baser (mellan 2 och 36). Till exempel:

Varn = 17;
binär_sträng = n.toString(2); // Lika med "10001"
octal_string = "0" + n.toString(8); // Lika med "021"
hex_string = "0x" + n.toString(16); // Lika med "0x11"

Fel JavaScript-versioner upp till version 1.5 består av frånvaro standardmetod, som låter dig ange antalet decimaler i strängen som ett resultat av talkonverteringen, eller att kräva användning av vetenskaplig notation. Detta kan göra det svårt att visa siffror som har traditionella format, såsom monetära värden.

ECMAScript v3 och JavaScript 1.5 kommer runt detta hinder genom att lägga till tre nya metoder för att konvertera ett tal till en sträng till klassen Number. Metoden toFixed() konverterar ett tal till en sträng och matar ut det angivna antalet siffror efter decimalkomma, utan att använda vetenskaplig notation. Metoden toExponential() konverterar ett tal till en sträng och skriver det i exponentiell notation med en siffra före decimalkomma och det angivna antalet siffror efter det. Metoden toPrecision() matar ut ett tal med den angivna kvantiteten signifikanta siffror. Om detta antal signifikanta siffror inte räcker för att skriva ut hela delen av numret, skrivs det i vetenskaplig notation. Observera att alla tre metoderna avrundar de sista siffrorna i den resulterande strängen korrekt. Titta på följande exempel:

Var n = 123456,789;
n.toFixed(0); // "123457"
n.toFixed(2); // "123456.79"
n.toExponential(1); // "1.2e+5"
n.toExponential(3); // "1.235e+5"
n.toPrecision(4); // "1.235e+5"
n.toPrecision(7); // "123456.8"

Konvertera strängar till tal
Vi har sett att i ett numeriskt sammanhang omvandlas strängar som representerar tal automatiskt till reella tal. Som visas ovan kan denna omvandling göras explicit:

Var nummer = Number(string_value);
var nummer = strängvärde - 0;

Denna omvandling är obekväm på grund av dess överdrivna svårighetsgrad. Det fungerar bara med decimaltal, och även om konverteringen tillåter inledande och efterföljande mellanslag, tillåter den inte några icke-blanksteg efter numret i strängen. För mer flexibla transformationer kan du använda funktionerna parseInt() och parseFloat(). Dessa funktioner konverterar och returnerar alla tal som finns i början av strängen och ignorerar eventuella efterföljande icke-numeriska tecken. Funktionen parseInt() hanterar bara heltal, medan parseFloat() hanterar både heltal och flytande tal. Om strängen börjar med "0x" eller "0X", tolkar parseInt() den som hexadecimalt tal. Till exempel:

ParseInt("3 blinda möss"); // Returnerar 3
parseFloat("3,14 meter"); // Returnerar 3.14
parseInt("12.34"); // Returnerar 12
parseInt("0xFF"); // Returnerar 255

Funktionen parseInt() kan ha ett andra argument som indikerar radixen för talet som bearbetas. Giltiga värden– från 2 till 36. Till exempel:

ParseInt("11", 2); // Returnerar 3 (1*2 + 1)
parseInt("ff", 16); // Returnerar 255 (15*16 + 15)
parseInt("zz", 36); // Returnerar 1295 (35*36 + 35)
parseInt("077", 8); // Returnerar 63 (7*8 + 7)
parseInt("077", 10); // Returnerar 77 (7*10 + 7)

Om parseInt() och parseFloat() inte kan konvertera den angivna strängen till ett tal, returnerar de NaN.

ParseInt("elva"); // Returnera NaN
parseFloat("$72.47"); // Returnera NaN

JavaScript har 2 inbyggda funktioner för att konvertera strängar till tal: parseFloat() och parseInt() .

parseFloat() tar som argument en sträng som ska konverteras till en numerisk typ och returnerar ett flyttal. Numret måste stå i början av raden. Om det finns några andra tecken på raden efter numret skärs de av. Fraktion siffror måste skrivas åtskilda av en punkt (ett kommatecken uppfattas inte som ett avgränsare). Om parseFloat() inte kan konvertera strängen, returnerar den NaN.

Funktionen kan också bearbeta "talet n multiplicerat med 10 till x-potensen", vilket i programmering vanligtvis skrivs med bokstaven E, till exempel: 0,5E6 eller 0,5E+6. Graden kan också vara negativ: 0,5E-6, vilket är lika med 0,5*10^-6 eller 0,5/1000000.

ParseFloat(""3,78kg"") // 3,78 parseFloat(""kg33"") // NaN parseFloat(""0004.111"") // 4,111 parseFloat(""0x66"") // 0 parseFloat("". 5"") // 0.5 parseFloat(""-.5"") // -0.5 parseFloat(""0.5e6"") // 500000 parseFloat(""0.03E+2"") // 3 parseFloat(" "3E-4"") // 0,0003 parseFloat(""-3E-4") // -0,0003

Funktionen parseInt(string[, radix]) tar en sträng som sitt första argument, analyserar den och returnerar ett heltal (typ heltal). Funktionen försöker analysera det talsystem i vilket talet i källsträngen är skrivet (till exempel decimal, oktal eller hexadecimal - men inte bara dessa). Du kan också specificera talsystemet explicit genom att skicka det som den andra parametern radix. Radix-parametern kan ta vilket nummer som helst från 2 till 36 (i system högre än 10 används bokstäver i det engelska alfabetet, från A till Ö).

Funktionen bearbetar inte siffror som 1.5e6 som parseFloat() .

Vänligen läs exemplen nedan för att inte snubbla över fallgroparna som är gömda i driften av parseInt()-funktionen.

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70",8) // 56 (70 tum oktalt system detta är 56 i decimal) parseInt(""070"") // 56 (VIKTIGT!!! noll först kommer att få funktionen att analysera strängen som ett oktalt tal) parseInt(""88"",8) // NaN (det finns ingen siffra i oktal) 8) parseInt(""a1"") // NaN (VIKTIGT!!! Standardfunktionen behandlar inte talet som hexadecimalt om du inte lägger till 0x i början av raden) parseInt (""a1",16) // 161 (talsystemet anges uttryckligen här) parseInt(""0xa1"") // 161 ( rätt format hexadecimalt tal, du behöver inte ange den andra parametern) parseInt(""099"") // 0 (VIKTIGT!!! Talet uppfattas som oktalt, men innehåller ogiltiga tecken) parseInt(""0.5e6"" ) // 0 ( VIKTIGT!!! fungerar inte som parseFloat) parseInt(""ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16 ) // -255

Om du analyserar användarindata från ett textfält, använd alltid parseInt() tillsammans med en andra radix-parameter för att skydda din kod från oväntade resultat.

JavaScript har 2 inbyggda funktioner för att konvertera strängar till tal: parseFloat() och parseInt() .

parseFloat() tar som argument en sträng som ska konverteras till en numerisk typ och returnerar ett flyttal. Numret måste stå i början av raden. Om det finns några andra tecken på raden efter numret skärs de av. Bråkdelen av ett tal måste skrivas åtskilda av en punkt (ett kommatecken uppfattas inte som en avgränsare). Om parseFloat() inte kan konvertera strängen, returnerar den NaN.

Funktionen bearbetar inte siffror som 1.5e6 som parseFloat() .

Vänligen läs exemplen nedan för att inte snubbla över fallgroparna som är gömda i driften av parseInt()-funktionen.

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 i oktal är 56 i decimal) parseInt(""070"") // 56 (VIKTIGT!!! noll först kommer att få funktionen att analysera strängen som ett oktalt tal ) parseInt(" "88"",8) // NaN (det finns ingen siffra 8 i det oktala systemet) parseInt(""a1"") // NaN (VIKTIGT!!! Standardfunktionen behandlar inte talet som hexadecimalt om det inte läggs till på startraderna 0x) parseInt(""a1"",16) // 161 (talsystemet anges uttryckligen här) parseInt(""0xa1"") // 161 (korrekt hexadecimalt talformat , du behöver inte ange den andra parametern) parseInt( ""099"") // 0 (VIKTIGT!!! Numret behandlas som oktalt, men innehåller ogiltiga tecken) parseInt(""0.5e6"") / / 0 (VIKTIGT!!! fungerar inte som parseFloat) parseInt("" ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16) / / -255

Om du analyserar användarindata från ett textfält, använd alltid parseInt() tillsammans med en andra radix-parameter för att skydda din kod från oväntade resultat.

I JavaScript betydelser kan konverteras ganska fritt (explicit och implicit) från en typ till en annan. Till exempel, om en operatör förväntar sig att få ett värde av en viss typ och får ett värde av en annan typ, kommer tolken automatiskt att försöka utföra omvandlingar till önskad typ:

Console.log(10 + "maskiner"); // "10 bilar". Numret konverteras implicit till en sträng console.log("7" * "4"); // 28. Båda strängarna är implicit omvandlade till tal

Implicit konvertering- det är när tolken automatiskt utför typkonvertering, det vill säga utan medverkan av programmeraren. Explicit konvertering- det är när omvandlingen utförs av programmeraren själv. Explicit konvertering kallas också typ gjutning:

Console.log("7" * "4"); // 28. Implicit konvertering console.log(Number("7") * Number("4")); // 28. Explicit konvertering

Tabellen nedan beskriver hur JavaScript konverterar värden från en typ till en annan. Tomma celler motsvarar situationer där ingen konvertering krävs:

Menande	Konvertera till:
Menande	Sträng	siffra	Boolean	Ett objekt
odefinierad null	"odefinierad" "null"	NaN 0	falsk falsk	feltypError feltypError
Sann falsk	"Sann" "falsk"	1 0		new Boolean (true) ny boolesk (falsk)
"" (tom rad) "1.2" "ett" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	falsk Sann Sann Sann Sann Sann Sann	ny sträng("") new String("1.2") ny sträng ("ett") ny sträng ("-10") ny sträng ("+10") ny sträng ("011") new String("0xff")
0 -0 NaN Oändlighet -Oändlighet 3	"0" "0" "NaN" "Oändlighet" "-Oändlighet" "3"		falsk falsk falsk Sann Sann Sann	nytt nummer (0) nytt nummer (-0) nytt nummer(NaN) nytt nummer (oändlighet) nytt nummer (-oändlighet) nytt nummer(3)
() (vilket objekt som helst) (tom array) (1 numeriskt element) arr (vilken annan array som helst) function()() (valfri funktion)	se Konvertera objekt "" "9" se Konvertera objekt se Konvertera objekt	se Konvertera objekt 0 9 NaN NaN	Sann Sann Sann Sann Sann

För explicit konvertering till enkla typer används följande funktioner: Boolean(), Number(), String(). För implicit konvertering använder tolken samma funktioner som används för explicit konvertering.

För explicit konvertering kan du använda operatorer istället för funktioner. Till exempel, om en av operanderna för operatorn + är en sträng, så konverteras även den andra operanden till en sträng. Operatorn unary + konverterar sin operand till ett tal. Unär operatör! konverterar operanden till ett booleskt värde och inverterar det. Allt detta blev orsaken till uppkomsten av följande unika metoder för typkonvertering som kan hittas i praktiken:

X + "" // Samma som String(x) +x // Samma som Number(x). Du kan också se x - 0 !!x // Samma som Boolean(x)

Konvertera till siffror

Funktionen Number() konverterar värden enligt följande regler:

De booleska värdena sant och falskt konverteras till 1 respektive 0.
Siffrorna returneras oförändrade.
Värdet null konverteras till 0 .
Det odefinierade värdet omvandlas till NaN.

Det finns särskilda regler för strängar:

Om en sträng endast innehåller siffror med ett inledande + eller - tecken, eller utan tecken, omvandlas den alltid till ett heltal decimal nummer. Inledande nollor ignoreras, till exempel konverteras "0011" till 11.
Om strängen är ett flyttal med ett inledande + eller - eller otecknat tecken, omvandlas den till motsvarande flyttal (inledande nollor ignoreras också).
Om strängen är ett hexadecimalt tal omvandlas den till motsvarande decimala heltal.
Om strängen är tom konverteras den till 0.
Om strängen innehåller något annat än de tidigare alternativen konverteras den till NaN.
Metoden valueOf() anropas på objekt, och värdet den returnerar konverteras automatiskt enligt de tidigare reglerna. Om denna omvandling resulterar i NaN anropas metoden toString() och reglerna för att konvertera strängar till tal tillämpas.

Unära operatorerna + och - följer samma regler som Number()-funktionen.

Konvertera till booleska värden

Funktionen Boolean() konverterar ett värde till dess booleska motsvarighet:

Följande värden konverteras till false: undefined , null , 0 , -0 , NaN , "" .
False returneras oförändrat.
Alla andra värden konverteras till sant.

Konvertera till strängar

String()-funktionen konverterar värden enligt följande regler:

För alla andra värden än null och odefinierat anropas metoden toString() automatiskt och en strängrepresentation av värdet returneras.
För nollvärden strängen "null" returneras.
För värdet undefined returneras strängen "undefined".

Konvertera enkla typer till objekt

För att konvertera enkla värden till objekt används konstruktorerna Boolean() , Number() , String():

Var oNum = nytt nummer(3); var oStr = new String("1.2"); var oBool = new Boolean(true); alert(typ av oNum); // "objekt" alert(typeof oStr); // "objekt" alert(typ av oBool); // "objekt"

Konvertera objekt till enkla värden

Alla objekt ärver två konverteringsmetoder: toString() och valueOf() .

Metoden toString() returnerar strängrepresentationen av objektet. Som standard returnerar det inget intressant:

Alert((x: 1).toString()); // ""

Vissa typer har mer specialiserade versioner av metoden toString(). Till exempel, metoden toString() på en array konverterar alla dess element till strängar och sammanfogar dem sedan till en sträng och infogar kommatecken mellan dem:

Alert(.toString()); // "1,2,3"

Syftet med metoden valueOf() är mindre tydligt definierat: det är tänkt att konvertera ett objekt till det enkla värdet som representerar det, om ett sådant värde finns. Objekt är till sin natur sammansatta värden, och de flesta objekt kan inte representeras som en enda enkel betydelse, så som standard returnerar metoden valueOf() inte ett enkelt värde, utan en referens till det:

Alert(typeof (x:2).valueOf()); // "objekt"

När ett objekt konverteras till en sträng utför JavaScript-tolken följande åtgärder:

Om ett objekt har en toString()-metod anropar tolken den. Om det returnerar ett enkelt värde, konverterar tolken värdet till en sträng (om det inte är en sträng) och returnerar resultatet av konverteringen.
Om objektet inte har en toString()-metod eller om metoden inte returnerar ett enkelt värde, kontrollerar tolken om det finns en valueOf()-metod. Om denna metod är definierad, anropar tolken den. Om det returnerar ett enkelt värde, konverterar tolken det värdet till en sträng (om det inte är en sträng) och returnerar resultatet av konverteringen.

När man konverterar ett objekt till ett tal gör tolken samma sak, men försöker först med metoden valueOf():

Om ett objekt har en valueOf()-metod som returnerar ett enkelt värde, konverterar tolken (om nödvändigt) det värdet till ett tal och returnerar resultatet.
Om objektet inte har en valueOf()-metod eller om metoden inte returnerar ett enkelt värde, kontrollerar tolken om det finns en toString()-metod. Om objektet har en toString()-metod som returnerar ett enkelt värde, utför tolken konverteringen och returnerar det resulterande värdet.
Annars drar tolken slutsatsen att varken toString() eller valueOf() kan erhålla ett enkelt värde och höjer ett TypeError.

Metoderna toString() och valueOf() är läs/skriv, så du kan åsidosätta dem och uttryckligen ange vad som kommer att returneras vid konvertering:

Var obj = (); obj.toString = function() (retur "objekt"; ); alert("Detta är " + obj); // "Detta är ett objekt"

Casta datatyper i javascript. JavaScript: Datatypkonvertering

jQuery-datatyper

Strängar

Använda citattecken i strängar

Inbyggda metoder för strängar

längd egendom

booleskt sammanhang

Tal

booleskt sammanhang

Math objekt

Konvertera till siffror

Konvertera tal till strängar

NaN och Infinity typer

Heltalstyp

Flyttyp

boolesk typ

Föremål

Objektegenskaper

Iterationer på föremål

booleskt sammanhang

Prototyper

Konvertera till siffror

Konvertera till booleska värden

Konvertera till strängar

Konvertera enkla typer till objekt

Konvertera objekt till enkla värden

Populära artiklar

Senaste artiklarna

Avsnitt

Sidor

Specialprojekt

Kontakter