Js konvertering til tall. Konvertering av data til JavaScript. JavaScript-metoder for å konvertere strenger til tall

Det er to hovedmåter å konvertere en streng til et tall i javascript. En måte er å analysere den, og en annen måte er å endre typen til nummer. Alle triksene i de andre svarene (som unært pluss) innebærer implisitt å tvinge typen streng til å nummerere. Du kan også gjøre det samme ved å bruke tallfunksjonen.

Syntaktisk

Var parsed = parseInt("97", 10);

parseInt og parseFloat er to funksjoner som brukes til å analysere strenger til tall. Parsing vil stoppe stille hvis den treffer et tegn den ikke gjenkjenner, noe som kan være nyttig for å analysere strenger som "92px", men det er også noe farlig siden det ikke gir deg noen feil hvis inndataene er dårlige, i stedet vil du " vil returnere NaN hvis strengen ikke starter med et tall. Et mellomrom i begynnelsen av strengen ignoreres. Her er et eksempel på at den gjør noe annerledes som du trenger, og indikerer ikke at noe gikk galt:

Var widgetsSold = parseInt("97,800", 10); // widgetsSold er nå 97

Det er god praksis å alltid spesifisere det som det andre argumentet. I eldre nettlesere, hvis en streng startet med 0, ville den bli tolket som oktal med mindre en radix-verdi ble spesifisert, noe som overrasket mange mennesker. Virkemåten for heksadesimal utløsning utløses hvis strengen starter med 0x med mindre en radiksverdi er spesifisert. 0xff. Standarden endret seg faktisk med ecmascript 5, så moderne nettlesere avfyrer ikke lenger oktal når en ledende 0 er spesifisert med mindre en radix-verdi er spesifisert. parseInt forstår radikaler opp til base 36, i så fall behandles både store og små bokstaver som likeverdige.

Endre strengtype til nummer

Alle de andre triksene nevnt ovenfor som ikke bruker parseInt involverer implisitt å tvinge strengen til et tall. Jeg foretrekker å gjøre det eksplisitt

Var cast = Tall("97");

Dette er forskjellig fra parsemetoder (selv om det fortsatt ignorerer mellomrom). Den er strengere: Hvis den ikke forstår hele strengen, returnerer den NaN , så du kan ikke bruke den til strenger som 97px . Siden du trenger et primitivt tall og ikke et Number wrapper-objekt, må du passe på at du ikke setter nytt før Number-funksjonen.

Å konvertere til et tall gir deg selvsagt en verdi som kan være en flytende i stedet for et heltall, så hvis du vil ha et heltall, må du endre det. Det er flere måter å gjøre dette på:

Var avrundet = Math.floor(Tall("97.654")); // andre alternativer er Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // avrundet i stedet for trunkert var bitvis = Number("97.654")|0; // ikke bruk for store tall

Enhver bitvis operator (her er jeg bitvis eller, men du kan også gjøre dobbel negasjon som i et tidligere svar eller bitshift) vil konvertere verdien til et 32-bits heltall, og de fleste av dem vil konvertere til et fortegnet heltall. Merk at denne ikke vil være nødvendig for store heltall. Hvis et heltall ikke kan representeres i 32 biter, vil det bli avsluttet.

~~ "3000000000.654" === -1294967296 // Dette er det samme som nummer ("3000000000.654") | 0 "3000000000.654" >>> 0 === 3000000000 // usignert høyre skift gir deg en ekstra bit " >> 0 === 3647256576 // men mislykkes fortsatt med større tall

For å jobbe riktig med store tall må du bruke avrundingsteknikker

Math.floor("3000000000.654") === 3000000000 // Dette er det samme som Math.floor(Number("3000000000.654"))

Husk at alle disse metodene forstår eksponentiell notasjon, så 2e2 er 200 og ikke NaN. Number forstår også "Infinity", mens parsingmetoder ikke gjør det.

Tilpasset

Det er ikke sant at noen av disse metodene gjør akkurat det du vil. For eksempel vil jeg vanligvis ha en feil som oppstår når parsing mislykkes, og jeg trenger ikke Infinity-støtte, eksponenter eller ledende mellomrom. Avhengig av bruken din, er det noen ganger fornuftig å skrive en tilpasset konverteringsfunksjon.

Sjekk alltid at utdataene til Number eller en av analysemetodene er tallet du forventer. Du vil nesten helt sikkert bruke isNaN for å sikre at nummeret ikke er NaN (vanligvis den eneste måten å vite at parsing mislyktes).

JavaScript gir flere innebygde datatyper. I tillegg til disse dekker denne artikkelen virtuelle typer i jQuery som velgere, utvidede pseudotyper som hendelser og alle slags funksjoner.

Det er best om du prøver de fleste eksemplene nedenfor. Dette kan enkelt gjøres ved å kopiere disse eksemplene inn i Firebug-konsollen, en Firefox-nettleserutvidelse.

Når eksemplene utfører operasjoner i en boolsk kontekst (som sammenligninger), er det viktig å vite hvordan hver datatype oppfører seg i den konteksten:

Var x = "" if (x) console.log("x standard til true") else console.log("x standard til usann")

I dette tilfellet vil "x er lik falsk" skrives ut.

For å redusere lengden på eksemplene brukes negasjonsoperatoren for å vise boolsk kontekst:

X // sant

jQuery-datatyper

Strenger

• Innebygde metoder for strenger
• lengde eiendom
• Boolsk kontekst

Tall

• Boolsk kontekst
• Parsing tall
• Tall til strenger
• NaN og Infinity
• Heltall
• Flyte

Boolsk type

Objekter

• Punktnotasjon
• Matrisenotasjon
• Iterasjon
• Boolsk standard
• Prototype

Alternativer

Matriser

• Iterasjon
• Boolsk standard
• Matrisenotasjon

Funksjoner

• Argumenter
• Kontekst, ring og søk
• Synlighetsområde
• Nedleggelser
• Proxy-mønster

Tilbakeringingsfunksjoner

Velgere

arrangementer

Elementer

jQuery type

XMLHttpRequest type

Linjene "Dette er en JavaScript-streng!" "Og dette er også en linje!"

En streng i JavaScript er et uforanderlig objekt som inneholder null, ett eller flere tegn.

Typen strenger er "streng". Du kan finne ut typen av en streng slik:

Type "noen streng"; // "streng"

Bruke anførselstegn i strenger

En streng kan defineres ved hjelp av enkle eller doble anførselstegn. Du står fritt til å bruke enkle anførselstegn inne i en streng omsluttet av doble anførselstegn og omvendt. For å bruke doble anførselstegn i strenger med doble anførselstegn, må de escapes med en omvendt skråstrek \ . Dette gjelder også enkeltsitater.

"Du gjør meg trist." "Hellige "svingende" Moses! " hjem" "hjem"

Innebygde metoder for strenger

JavaScript har flere innebygde metoder for å manipulere strenger, resultatet av disse kan være enten en streng eller for eksempel en matrise:

"hello".charAt(0) // "h" - får tegnet på ønsket posisjon i strengen "hello".toUpperCase() // "HELLO" - konverterer strengen til store bokstaver "Hello".toLowerCase() // "hello" - konvertere en streng til små bokstaver "hello".replace(/e|o/g, "x") // "hxllx" - erstatte en del av en streng med en understreng ved å bruke det regulære uttrykksmønsteret "1, 2,3".split(", ") // ["1", "2", "3"] - splitting av en streng i en matrise med en spesifikk delstreng

lengde eiendom

Strenger har en length-egenskap som spesifiserer lengden på strengen.

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

Boolsk kontekst

En tom streng evalueres til falsk:

!"" // sant ! "hei" // usant ! "true" // usant !new Boolean(false) // usant

Tall 12 3,543

Tall i JavaScript er i 64-bits dobbel presisjonsformat i henhold til IEEE 754-standarden. De er også uforanderlige. For å jobbe med tall er alle operatorer tilgjengelige, det samme som i C-språket (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

Typen for tall er "nummer". Du kan sjekke typen tall slik:

Type på 12 // "nummer" type på 3.543 // "nummer"

Boolsk kontekst

Hvis tallet er null, er det lik usann:

0 // sant !1 // usant !-1 // usant

Fordi tall er implementert i dobbel presisjonsformat, er utdataene fra følgende eksempel ikke feil:

0.1 + 0.2 // 0.30000000000000004

Matematisk objekt

JavaScript gir funksjoner for å arbeide med tall i et Math-objekt:

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

Konverter til tall

Funksjonene parseInt og parseFloat konverterer strenger til tall. Begge funksjonene utfører implisitt konvertering hvis tallsystemet ikke er spesifisert:

ParseInt("123") = 123 (implisitt desimalkonvertering) parseInt("010") = 8 (implisitt oktal konvertering) parseInt("0xCAFE") = 51966 (implisitt hex-konvertering) parseInt("010", 10) = 10 ( eksplisitt desimalkonvertering med radix 10) parseInt("11", 2) = 3 (eksplisitt binær konvertering) parseFloat("10.10") = 10.1

Konvertering av tall til strenger

Hvis du legger til tall i en streng ved å bruke "+"-operasjonen, vil resultatet alltid være en streng. For å utføre beregninger før du legger til et tall i en streng, sørg for å sette beregningene i parentes:

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

Du kan også bruke JavaScript String-klassen, som konverterer den beståtte verdien til en streng:

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

NaN og Infinity-typer

Konvertering av verdier som ikke er tall resulterer i NaN. IsNaN-funksjonen bestemmer om verdien som sendes til den er lik NaN:

ParseInt("hei", 10) // NaN erNaN(parseInt("hei", 10)) // sant

Deling på null gir resultatet Infinity:

1 / 0 // Uendelig

Både NaN- og Infinity-verdien er av typen "nummer":

Type NaN // "nummer" type Infinity // "nummer"

Vær oppmerksom på at sammenligning av NaN-verdier skjer på en ikke-standard måte:

NaN == NaN // usant (!)

Uendelig == Uendelig // sant

Heltallstype

Heltall er en heltallstype.

Flytetype

Float er en talltype med flytende komma.

Boolsk type

En boolsk type i JavaScript kan være sann eller usann:

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

For eksempel ser en boolsk type slik ut når du angir innstillingene når du kobler til jQuery-plugins:

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

Objekter

Alt i JavaScript er et objekt. Den enkleste måten å lage et objekt på er:

Var x = (); var y = (navn: "Pete", alder: 15 );

Typen for objekter er "objekt":

Typeof() // "objekt"

Objektegenskaper

Du kan endre og få egenskaper for et objekt ved å bruke punktnotasjon:

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

Du kan også bruke objektet som en matrise:

Var operasjoner = ( øke: "++", redusere: "--" ) var operasjon = "øke"; operasjoner // "++"; operasjoner["multiply"] = "*"; // "*"

Iterasjoner på objekter

Iterering over objekter er veldig enkelt ved å bruke for-in loop-operatoren:

Var obj = ( navn: "Pete", alder: 15 ); for(tast inn obj) ( alert("nøkkelen er "++", verdien er "+obj); )

jQuery gir en funksjon

for å iterere over objektegenskaper eller matriseelementer:

JQuery.each(obj, funksjon(nøkkel, verdi) (console.log("nøkkel", nøkkel, "verdi", verdi); ));

Boolsk kontekst

Et objekt, enten det har egenskaper eller ikke, er alltid sant:

!() // falsk

Prototyper

Alle objekter har en prototype-egenskap. Når tolken ser etter en egenskap på et objekt, sjekker den også prototypen. I jQuery er denne mekanismen mye brukt for å legge til metoder til forekomster av jQuery-objekter.

Var form = $("#myform"); form.clearForm; // udefinert form.fn.clearForm = function() ( return this.find(":input").each(function() ( this.value = ""; )).end(); ); form.clearForm() // kan brukes på alle forekomster av jQuery-objekter siden en ny metode ble lagt til prototypen

Det spiller ingen rolle hvilken type variabel som brukes i uttrykket. Hvis uttrykket er matematisk, vil alle variablene automatisk bli tolket som numeriske. Hvis strenger behandles, behandles alle "deltakere" i uttrykket som strenger. Utfordringen med streng-til-nummer-konvertering i JavaScript eksisterer imidlertid i en mye bredere kontekst.

JavaScript-metoder for å konvertere strenger til tall

Arsenalet av metoder for å konvertere strenger til tall er ikke stort, men det er tilstrekkelig i alle enkle tilfeller. Her er JavaScript (spesielt for nybegynnere) veien fra enkel til kompleks ved hjelp av praktiske eksempler.

Eksemplet beskriver fire forskjellige strenger. I den første utdatablokken definerer typefunksjonen typen for hver variabel som streng. Hver streng blir så veldig enkelt konvertert til et tall. I den andre utdatablokken er endringer i variablene etter konverteringen synlige; typen deres har blitt et tall. JavaScript parseFloat-konverteringseksemplet er spesielt illustrerende: det var "12e+3" og ble til "12000".

Endringene ved konvertering av en streng til et tall kan være betydelige! Men bare de første tegnene betyr noe: de må være numeriske. Hvis det ikke er noen siffertegn, vil resultatet være NaN.

Omvendt konvertering av en streng som "blir" til et tall, er ikke alltid den samme strengen. Dette punktet kan brukes til å kontrollere riktigheten av å legge inn numerisk informasjon.

Vanlige konverteringsmetoder

Det er henholdsvis heltall og det er brøktall, JavaScript konverterer en streng til et tall ved å:

• parseInt;
• parseFloat.

Det generelle tilfellet implementeres ved å bruke strengen i et enkelt matematisk uttrykk.

Det er nok å sette et "+"-tegn foran tegnstrengen, og hvis det inneholder et tall, vil resultatet av uttrykket være et tall. Verdien av en variabel kan endres, men typen vil alltid endres: typeof vil vise tall, ikke streng. Det er viktig å forstå at bruk av en konvertert variabel i et strenguttrykk kan gi et helt annet resultat.

JavaScript for nybegynnere i denne sammenhengen er ekstremt enkelt. Det er vanskeligere å forstå operasjonen til heltallskonverteringen ved å bruke passrseInt-metoden, siden den automatisk fungerer i desimaltallsystemet, men kan tolke strengen som oktal eller heksadesimal. Denne omstendigheten avhenger imidlertid ikke alltid av den andre parameteren, som indikerer tallsystemet.

JavaScript vil alltid gjøre en streng til et tall, men hvis strengen ikke har et eneste digitalt tegn på begynnelsen av linjen, vil resultatet være NaN.

Det er nødvendig å ha forståelse for tallsystemer, hvordan man skriver heksadesimale (tall starter med "0x") og oktale tall (tall starter med "0").

For å forstå nyansene til JavaScript-parseFloat-metoden, er det nok å ha en ide om hva en matematisk notasjon for et reelt tall er.

Transformasjon for sorteringsformål

JavaScript er et nettleserspråk, og derfor er det mer kritisk enn andre språk for tegn utenfor det grunnleggende settet av det latinske alfabetet og tall. Sortering er en populær operasjon. Men det er ikke alltid fornuftig å sende data til serveren for sorteringsformål; det er enklere og mer praktisk å gjøre jobben lokalt, i nettleseren.

For å løse dette problemet kan du konvertere tegnene i en streng til deres numeriske koder eller tilordne en ordnet rekkefølge av tall til bokstaver og tall. charCodeAt()-metoden brukt på en streng vil tildele den numeriske verdien 98 til variabelen iB, det vil si koden til bokstaven "b". Tatt i betraktning at kodeverdien til bokstaven "a" er 97, kan du få tallene til alle bokstavene i det latinske alfabetet i stigende rekkefølge i små og store sett. Tilsvarende for bokstavene i det russiske alfabetet.

Vår egen versjon av sortering gjennom tall lar deg lage de nødvendige settene med tegn. Du kan for eksempel "omorganisere" det kyrilliske og latinske alfabetet eller blande dem for å bare la bokstaver stå igjen med forskjellige stavemåter, eller legge til tabulator- og mellomromstegn i settene.

Dannelse av et unikt strengnummer

Hvis koden til bokstaven "a" er 97, vil forskjellen mellom bokstaven og tallet 97 gi det unike nummeret til bokstaven i alfabetet. Ved å summere de unike tallene for hvert tegn i en streng, er det vanskelig å få det unike nummeret til den strengen.

Hvis du tilordner en vekt til hver bokstavposisjon i en streng, for eksempel, posisjon:

• 0 vekt 1;
• 1 vekt 10;
• 2 vekt 100;

så ved å multiplisere det unike nummeret til hvert tegn i strengen med vekten av posisjonen der den er funnet, og summere alle tallene, kan du få et unikt tall og bruke det som en en-til-en korrespondanse til originalen streng.

Denne konverteringen av en streng til et tall er reversibel, det vil si at du alltid kan få den opprinnelige strengen fra tallet. En slik konvertering er fordelaktig fordi enhver operasjon kan utføres trygt med et tall i sammenheng med koding, kyrilliske og andre lokale funksjoner på siden, bruksområde og den besøkendes land.

"Voksende" sidevelgere for nettsteder

Ofte oppstår oppgaven med å lage velgere på nettsider, hvis verdier ikke kan spesifiseres på forhånd, men over tid blir de supplert. I den aller første applikasjonen er en tom velger tilgjengelig for den første besøkende til å legge inn informasjon.

Hver ny inntasting av en streng med informasjon i velgeren (av enhver besøkende) blir transformert til et nummer, som sammen med originalen sendes til serveren for lagring. Når en ny økt starter eller en ny besøkende kommer, er ikke lenger velgeren tom. Når siden er lastet inn, kommer den til nettleseren med en ikke-tom velger.

For hver ny velgerverdi sendes den bare én gang til serveren for lagring, og kun én gang blir den tildelt en unik numerisk kode.

For å løse dette problemet kan ikke JavaScript-streng til tall-metoden brukes. De vanlige metodene parseInt og parseFloat er designet for annen bruk, men du kan komme opp med en algoritme for entydig å konvertere en streng til et tall, og ikke nødvendigvis en inverterbar. Det er nok at konverteringsalgoritmen ikke gjentas på forskjellige sett med tegn i en streng.

Trafikkoptimalisering og analyser

Når du oppretter en side, bruker utvikleren betydelige mengder informasjon. Å la den besøkende legge inn informasjon er en god måte å senke nettstedets rangering på grunn av dets dårlige funksjonalitet og frustrere den besøkende.

Ved å tilordne en hendelsesbehandler i form av en JavaScript-funksjon til den besøkendes handlinger for bestemte informasjonsblokker, er det mulig å formulere et filter som lar den besøkende nøyaktig sette et mål, finne nødvendig informasjon og få ønsket løsning .

Transformasjonen av strenginformasjon her kan være vilkårlig stor i strengdelen og veldig liten i talldelen. Med andre ord, utvikleren konverterer en JavaScript-streng til et tall ved hjelp av sin egen algoritme. Den besøkende manipulerer forståelig informasjon, og minimumsmengden data - et tall - sendes til serveren.

Dynamikken til et sett med tall for alle besøkende i sammenheng med nøyaktig kjent informasjon gjør at en annen JavaScript-funksjon (ikke en behandler), som kalles på serverresponsen gjennom AJAX-mekanismen, raskt kan gi alle besøkende den nødvendige informasjonen samtidig i sanntid . Slik fungerer systemet.

Dette alternativet for å konvertere en JavaScript-streng til et tall er veldig populært i utviklingen av nettspill, interaktive konferanser, direktemeldinger og så videre.

Instrumentell anvendelse av transformasjoner

JavaScript og CSS i forbindelse med behandling av numerisk informasjon lar deg kontrollere visningen av en side uten serverinvolvering. CSS-regler er bygget som understrenger, rekursivt. Vanligvis er parameteren et tall etterfulgt av flere bokstaver (for eksempel "px", "pt", "em", ...). Parameteren er en understreng i regelen, og regelen er en understreng i klassen eller identifikatorstilen.

JavaScript recursion.Substring.Substring... finner det ønskede tallet, konverterer det fra en streng til et tall, modifiserer det og skriver det tilbake til ønsket sted. Regelen endres automatisk. Det er enkelt og praktisk, ingen serverinvolvering.

Ha en fin dag alle sammen. Alexey Gulynin er i kontakt. I den siste artikkelen lærte du om datatyper i Javascript. I denne artikkelen vil jeg snakke om typekonvertering i Javascript. Typekonverteringer i Javascript, og faktisk i alle programmeringsspråk, utføres veldig ofte. Først ønsket jeg å snakke om typekonvertering når man sammenligner variabler eller andre forhold som resulterer i sant eller usant. Ved sammenligning av variabler av ulike typer utføres bakgrunnskonverteringer. Hovedpoenget her er at under slike bakgrunnstransformasjoner endres ikke verdien som er lagret i variabelen. variabelen konverteres til datatypen (det opprettes en midlertidig verdi av variabelen) som er nødvendig for å utføre operasjonen. Jeg skal gi deg et eksempel:

Variabler av strengtype og numerisk type sammenlignes. Ved sammenligning reduseres verdiene til disse variablene til samme datatype. Sammenligningen returnerer deretter en boolsk verdi og de konverterte midlertidige verdiene fjernes. Alle transformasjoner avhenger av konteksten - operatørene som utfører handlinger på dem. eksempelkode:

Var a = 5; var b = "15"; hvis en< b) alert("a < b"); else alert("a >b");

I dette tilfellet vil variabelen b bli konvertert til et tall (bakgrunnskonverteringen av String-typen til Number-typen ble utført, og den midlertidige verdien av variabelen b av typen Number = 15 vil bli oppnådd, som vil bli slettet etter sammenligningsoperasjonen utføres), og resultatet vil være at en .

Nedenfor er en tabell som viser hvordan en datatype konverteres til en annen:

Verditype	Konteksten som verdien brukes i
	String	Numerisk	Logisk	Gjenstand
Udefinert verdi	'udefinert'	NaN	falsk	Feil
null	'null'	0	falsk	Feil
Tom linje	Tom linje	0	falsk	Strengeobjekt
Ikke-tom streng	Ikke-tom streng	Numerisk strengverdi eller NaN	ekte	Strengeobjekt
0	’0′	0	falsk	Nummerobjekt
NaN	'NaN'	NaN	falsk	Nummerobjekt
evighet	'Evighet'	evighet	ekte	Nummerobjekt
-Evighet	'-Evighet'	-Evighet	ekte	Nummerobjekt
Et hvilket som helst annet nummer	Strengrepresentasjon av et tall	Selve nummeret	ekte	Nummerobjekt
ekte	'ekte'	1	ekte	boolsk objekt
falsk	'falsk'	0	falsk	boolsk objekt
Objekt, funksjon	toString()	valueOf(), toString() eller NaN	ekte	Objekt, funksjon

Datatypekonverteringer

Du kan få en boolsk datatype fra alle datatyper. Dette gjøres ved å bruke negasjonsoperatoren eller dobbel negasjon. Eksempel:

Var a = 20; var b = !a; //retur falsk var c = !!a; //retur true

En streng kan hentes fra ethvert objekt. Eksempel:

Var a = 20; var b = a.toString(); //retur "20" var c = a + ""; //retur "20" type b; //retur streng type c; //returstreng

Få et tall fra en streng. Eksempel:

Var a = "20"; var b = a * 1; //retur 20 var c = + a; //retur 20 type b; //returnummertype av c; //returnummer

La oss nå, basert på kunnskapen vi har oppnådd, analysere oppførselen til logisk "AND" (&&) og logisk "ELLER" (||):

Logisk "AND" (&&):

For at denne operatøren skal utføres riktig, er det nødvendig at verdiene til alle operandene kan konverteres til sanne. Hvis verdiene til alle operandene kan konverteres til sanne, vil den opprinnelige verdien til den siste operanden som ble sammenlignet returneres. Hvis verdien av minst én operande konverteres til usann, returneres den opprinnelige verdien til den operanden. Eksempel:

Var a = 15; var b = "abc"; var c = 0; var resultat; resultat = a && b && c; //retur 0 resultat = c && b && a; //retur 0 resultat = 7 && a; //retur 15 resultat = 7 && b; //retur "abc"

Logisk "ELLER" (||):

La meg forklare litt om operatører og operander. La oss analysere uttrykket resultat = a && b && c . Her er operatørene "=" og "&&" , dvs. dette er handlinger. Operander: resultat, a, b, c. Det er dette som blir iverksatt.

Sist oppdatert: 1.11.2015

Ofte er det behov for å transformere en data til en annen. For eksempel:

Var nummer1 = "46"; var nummer2 = "4"; var resultat = tall1 + tall2; console.log(resultat); //464

Begge variablene representerer strenger, eller mer presist strengrepresentasjoner av tall. Og til slutt får vi ikke tallet 50, men strengen 464. Men det ville vært fint om de også kunne legges til, trekkes fra og generelt fungere som med vanlige tall.

I dette tilfellet kan vi bruke konverteringsoperasjoner. For å konvertere en streng til et tall, bruk funksjonen parseInt():

Var nummer1 = "46"; var nummer2 = "4"; var resultat = parseInt(tall1) + parseInt(nummer2); console.log(resultat); // 50

For å konvertere strenger til brøktall, bruk funksjonen parseFloat():

Var nummer1 = "46.07"; var nummer2 = "4.98"; var resultat = parseFloat(nummer1) + parseFloat(nummer2); console.log(resultat); //51.05

I dette tilfellet kan linjen ha blandet innhold, for eksempel "123hello", det vil si i dette tilfellet er det tall, men det er også vanlige tegn. Men parseInt()-metoden vil fortsatt prøve å utføre konverteringen:

Var num1 = "123hei"; var num2 = parseInt(tall1); console.log(tall2); // 123

Hvis metoden ikke klarer å konvertere, returnerer den NaN (Not a Number), som indikerer at strengen ikke representerer et tall og ikke kan konverteres.

Du kan bruke spesialfunksjonen isNaN() for å sjekke om en streng representerer et tall. Hvis strengen ikke er et tall, returnerer funksjonen sant, hvis det er et tall, deretter usant:

Var num1 = "javascript"; var num2 = "22"; var resultat = erNaN(tall1); console.log(resultat); // sant - tall1 er ikke et tallresultat = erNaN(tall2); console.log(resultat); // false - num2 er et tall

Ovenfor så vi på å konvertere strenger til tall i desimalsystemet. Imidlertid kan vi konvertere tall til et hvilket som helst system. Som standard gjetter JavaScript-tolken selv hvilket tallsystem vi vil konvertere strengen til (vanligvis er desimalsystemet valgt). Men vi kan bruke den andre parameteren til å eksplisitt indikere at vi ønsker å konvertere strengen til et tall i et spesifikt system. For eksempel, konvertering til et tall i binær:

Var num1 = "110"; var num2 = parseInt(tall1, 2); console.log(tall2); // 6

Resultatet er 6, siden 110 i binær er det samme som 6 i desimal.

La oss nå skrive et lite program der vi bruker operasjoner med variabler:

JavaScript var strSum = prompt("Skriv inn innskuddsbeløpet", 1000); var strPercent = prompt("Skriv inn renten", 10); var sum = parseInt(strSum); var prosent = parseInt(strPersent); sum = sum + sum * prosent / 100; alert("Etter at renten er beregnet, vil innskuddsbeløpet være: " + sum);

Prompt()-funksjonen viser en dialogboks i nettleseren som ber deg angi en verdi. Det andre argumentet til denne funksjonen spesifiserer verdien som skal brukes som standard.

Imidlertid returnerer prompt()-funksjonen en streng. Derfor må vi konvertere denne strengen til et tall for å utføre operasjoner på den.

Etter å ha åpnet siden i nettleseren, vil vi se en melding om å angi innskuddsbeløpet:

En lignende melding vil da vises for å legge inn prosentandelen. Og på slutten vil programmet motta dataene, konvertere dem til tall og utføre beregningen.