Type conversion in ECMAScript

En av de viktigaste egenskaperna hos alla programmeringsspråk är förmågan att utföra typkonverteringar.

ECMAScript erbjuder utvecklarna ett brett utbud av enkla typkonverteringsmetoder.

De flesta typer har metoder för enkel konvertering, och det finns också några globala metoder för mer komplexa konverteringar. I vilket fall som helst är typkonvertering i ECMAScript en kort och enkel åtgärd.

Konvertera till sträng

Det intressanta med ECMAScript Boolean-värden, tal och strängars ursprungliga värden är att de är pseudo-objekt, vilket innebär att de faktiskt har egenskaper och metoder.

Till exempel, för att få strängens längd kan du använda följande kod:

var sColor = "red";
alert(sColor.length); // Output "3"

Trots att "red" är en ursprunglig strängtyp, har den fortfarande en egenskap length som används för att lagra strängens storlek.

Sammanfattningsvis har de tre huvudsakliga ursprungliga typerna Boolean-värden, tal och strängar en toString() metod, som kan konvertera deras värden till strängar.

Tips:Du kanske frågar, "Har string en toString() metod, är det inte överflödigt?" Ja, det är verkligen så, eftersom ECMAScript definierar att alla objekt har en toString() metod, oavsett om det är ett pseudo-objekt eller ett riktigt objekt. Eftersom String-typen är ett pseudo-objekt, har den naturligtvis en toString() metod.

toString() -metoden för Boolean-typen skriver bara ut "true" eller "false", resultatet bestäms av variabelns värde:

var bFound = false;
alert(bFound.toString());	//Utskrift "false"

toString() -metoden för Number-typen är mycket speciell, den har två modeller, nämligenStandardmodellochBasmodell。Använd standardmodellen, toString() -metoden skriver bara ut det numeriska värdet i den motsvarande strängen (både heltal, flyttal och vetenskaplig notation), som visas nedan:

var iNum1 = 10;
var iNum2 = 10.0;
alert(iNum1.toString());	//Utskrift "10"
alert(iNum2.toString());	//Utskrift "10"

Kommentar:I standardmodellen returnerar toString() -metoden för Number-typen alltid tals tiodelade representation, oavsett vilket sätt som användes för att deklarera talet ursprungligen. Därför skrivs tal som deklareras som okطلاق

Genom att använda basmodellen för toString() -metoden i Number-typen kan man använda olikaBasUtskrift av tal, till exempel är basen för binär form 2, basen för oktal form 8, och basen för hexadecimal form 16.

BasDet är bara en annan addition för att konvertera till basen, som är parametern för toString() -metoden:

var iNum = 10;
alert(iNum.toString(2));	//Utskrift "1010"
alert(iNum.toString(8));	//Utskrift "12"
alert(iNum.toString(16));	//Utskrift "A"

I det tidigare exemplet skrevs talet 10 ut i tre olika former, nämligen binär form, oktal form och hexadecimal form. HTML använder hexadecimal form för att representera varje färg, vilket är mycket användbart när man hanterar tal i HTML.

Kommentar:Att anropa toString(10) på ett tal är lika med att anropa toString(), de returnerar båda tals tiodelade form.

Se:

Se JavaScript referenshandbokFördjupad information om toString() -metoden:

Konvertera till tal

ECMAScript erbjuder två metoder för att konvertera icke-numeriska ursprungliga värden till numeriska värden, nämligen parseInt() och parseFloat().

Som du kanske förväntar dig, konverterar den första metoden värden till heltal, medan den andra konverterar värden till flyttal. Dessa metoder fungerar endast när de anropas på String-typen; vid andra typer returneras alltid NaN.

parseInt()

Innan parseInt() och parseFloat() kontrollerar om en sträng är ett numeriskt värde, analyserar de noggrant strängen.

parseInt() metoden kontrollerar först tecknet vid position 0, för att avgöra om det är ett giltigt tal; om inte, returnerar metoden NaN och fortsätter inte med andra operationer. Men om tecknet är ett giltigt tal, kontrollerar metoden tecknet vid position 1, och gör samma test. Denna process fortsätter tills en ogiltig tecken hittas, då parseInt() konverterar strängen fram till denna tecken till ett tal.

Till exempel, om man vill konvertera strängen "12345red" till ett heltal, kommer parseInt() att returnera 12345, eftersom när den når tecknet r, kommer den att avbryta kontrollprocessen.

Numeriska konstanter som innehålls i strängen kommer att konverteras korrekt till numeriska värden, till exempel kommer "0xA" att konverteras korrekt till talet 10. Men strängen "22.5" kommer att konverteras till 22, eftersom punkt är en ogiltig tecken för heltal.

Några exempel nedan:

var iNum1 = parseInt("12345red");	//återger 12345
var iNum1 = parseInt("0xA");	//återger 10
var iNum1 = parseInt("56.9");	//återger 56
var iNum1 = parseInt("red");	//återger NaN

parseInt() metoden har också en basmod, som kan konvertera binära, oktala, tetradekimala eller andra valfria basers strängar till heltal. Basen specificeras av den andra parametern till parseInt() metoden, så för att解析 tetradekimala värden, måste man anropa parseInt() metoden på följande sätt:

var iNum1 = parseInt("AF", 16);	//återger 175

Naturligtvis, för binära, oktala och till och med tetradekimala (standardläge), kan man anropa parseInt() metoden på detta sätt:

var iNum1 = parseInt("10", 2);	//återger 2
var iNum2 = parseInt("10", 8);	//återger 8
var iNum3 = parseInt("10", 10);	//återger 10

Om ett decimaltal innehåller prefix 0 är det bättre att använda bas 10, så att man inte oavsiktligt får ett oktalt värde. Till exempel:

var iNum1 = parseInt("010");	//återger 8
var iNum2 = parseInt("010", 8);	//återger 8
var iNum3 = parseInt("010", 10);	//återger 10

I denna kodrad tolkar de två raderna tecknet "010" som ett nummer. Första raden tolkar strängen som ett oktalt värde, på samma sätt som den andra raden (deklarerar bas till 8). Sista raden deklarerar bas till 10, så iNum3 slutar med 10.

Se

Se JavaScript referenshandbokFöljande är detaljerad information om parseInt() metoden:parseInt().

parseFloat()

parseFloat() metoden behandlar på samma sätt som parseInt() metoden, från position 0 granskar varje tecken tills den hittar den första ogiltiga tecknen, och konverterar strängen innan tecknet till ett heltal.

Men för denna metod är den första punktmarkören en giltig tecken. Om det finns två punktmarkörer betraktas den andra som ogiltig. parseFloat() konverterar tecknen före punktmarkören till ett nummer. Detta innebär att strängen "11.22.33" tolkas som 11.22.

En annan skillnad med parseFloat() metoden är att strängen måste representera ett flyttal i decimalform, inte i oktalt eller hexadecimalt. Denna metod ignorerar prefix 0, så oktalt nummer 0102 kommer att tolkas som 102. För hexadecimaltal 0xA kommer metoden att returnera NaN, eftersom x inte är en giltig tecken i flyttal. (Kommentar:Testat, den specifika webbläsarimplementeringen returnerar 0, inte NaN.)

Dessutom har parseFloat() metoden ingen basmodell.

Nedan är några exempel på användning av parseFloat() metoden:

var fNum1 = parseFloat("12345red");	//återger 12345
var fNum2 = parseFloat("0xA");	//återger NaN
var fNum3 = parseFloat("11.2");	//återger 11.2
var fNum4 = parseFloat("11.22.33");	//återger 11.22
var fNum5 = parseFloat("0102"); //returnerar 102
var fNum1 = parseFloat("red"); //returnerar NaN

Prova det själv

Se

Se JavaScript referenshandbokFöljande är detaljer om parseFloat() metoden:parseFloat().

Tvärgenomskiftning

Du kan också användaTvärgenomskiftning (type casting)För att hantera typen på värden som ska konverteras. Genom att använda tvångskonvertering kan du komma åt specifika värden även om de är av en annan typ.

Författarens anmärkning:Cast har betydelsen "gjuta" och passar bra med betydelsen av "tvångskonvertering".

Följande tre typer av tvångskonverteringar är tillgängliga i ECMAScript:

  • Boolean(value) - konverterar det givna värdet till Boolean-typ;
  • Number(value) - konverterar det givna värdet till ett tal (kan vara heltal eller flyttal);
  • String(value) - konverterar det givna värdet till en sträng;

Att använda en av dessa tre funktioner för att konvertera ett värde skapar ett nytt värde som lagrar värdet som konverterats direkt från det ursprungliga värdet. Detta kan leda till oväntade konsekvenser.

Boolean() funktionen

När värdet att konvertera är en sträng med minst en tecken, ett icke-0-tal eller ett objekt, returnerar Boolean-funktionen true. Om värdet är en tom sträng, 0, undefined eller null, returnerar den false.

Du kan testa konverteringen av Boolean-typ med följande kod:

var b1 = Boolean(""); //false - tom sträng
var b2 = Boolean("hello"); //true - icke-tom sträng
var b1 = Boolean(50); //true - icke-nolltal
var b1 = Boolean(null); //false - null
var b1 = Boolean(0); //false - noll
var b1 = Boolean(new object()); //true - objekt

Number() funktionen

Konverteringen av Number() funktionen är lik den för parseInt() och parseFloat() metoder, men den konverterar hela värdet, inte bara en del av det.

Kom ihåg, att parseInt() och parseFloat() metoder konverterar endast den del av strängen som ligger före den första ogiltiga tecknet, så "1.2.3" kommer att konverteras till "1" och "1.2" respektive.

Genom att använda Number() för forcerad typkonvertering kommer "1.2.3" att returnera NaN, eftersom den hela strängvärdet inte kan konverteras till ett nummer. Om strängvärdet kan konverteras helt, kommer Number() att avgöra om det är parseInt() -metoden eller parseFloat() -metoden som anropas.

Tabellen nedan förklarar vad som händer när Number() -metoden anropas för olika värden:

Användning Resultat
Number(false) 0
Number(true) 1
Number(undefined) NaN
Number(null) 0
Number("1.2") 1.2
Number("12") 12
Number("1.2.3") NaN
Number(new object()) NaN
Number(50) 50

String() funktionen

Det sista sättet att genomföra forcerad typkonvertering är String() som är det enklaste, eftersom det kan konvertera vilket värde som helst till en sträng.

För att utföra denna forcerade typkonvertering behöver man bara anropa toString() -metoden för värdet som överförts som parameter, dvs. konvertera 12 till "12", konvertera true till "true", konvertera false till "false" och så vidare.

Den enda skillnaden mellan att forcera typkonvertering till sträng och att anropa toString() -metoden är att forcerad typkonvertering av null- och undefined-värden kan generera en sträng utan att orsaka ett fel:

var s1 = String(null);	//"null"
var oNull = null;
var s2 = oNull.toString();	//kommer att orsaka ett fel

När man hanterar svaga typspråk som ECMAScript är forcerad typkonvertering mycket användbar, men det bör säkerställas att använda värden korrekt.