Viimati värskendatud: 1.11.2015

Sageli on vajadus ühed andmed teisendada. Näiteks:

Var number1 = "46"; var number2 = "4"; var tulemus = number1 + number2; konsool.log(tulemus); //464

Mõlemad muutujad tähistavad stringe või täpsemalt numbrite stringi esitusi. Ja lõpuks saame mitte numbri 50, vaid stringi 464. Aga oleks tore, kui neid saaks ka liita, lahutada ja üldiselt töötada nagu tavaliste numbritega.

Sel juhul saame kasutada teisendusoperatsioone. Stringi arvuks teisendamiseks kasutage funktsiooni parseInt().

Var number1 = "46"; var number2 = "4"; var tulemus = parseInt(arv1) + parseInt(arv2); konsool.log(tulemus); // 50

Stringide teisendamiseks murdarvudeks kasutage funktsiooni parseFloat().

Var number1 = "46,07"; var number2 = "4,98"; var tulemus = parseFloat(number1) + parseFloat(number2); konsool.log(tulemus); //51.05

Sel juhul võib rida olla segase sisuga, näiteks "123tere", see tähendab, et sel juhul on numbrid, kuid on ka tavalisi märke. Kuid meetod parseInt() proovib siiski teisendada:

Var num1 = "123tere"; var number2 = parseInt(arv1); konsool.log(arv2); // 123

Kui meetod ei õnnestu teisendada, tagastab see NaN (mitte arv), mis näitab, et string ei esinda arvu ja seda ei saa teisendada.

Spetsiaalse funktsiooni isNaN() abil saate kontrollida, kas string esindab arvu. Kui string ei ole arv, tagastab funktsioon tõene, kui see on arv, siis false:

Var num1 = "javascript"; var num2 = "22"; var tulemus = isNaN(arv1); konsool.log(tulemus); // tõsi - number1 ei ole arv tulemus = isNaN(arv2); konsool.log(tulemus); // false - number2 on arv

Eespool vaatlesime stringide teisendamist numbriteks kümnendsüsteemis. Kuid me saame teisendada numbreid mis tahes süsteemidesse. Vaikimisi arvab JavaScripti interpretaator ise, millisesse arvusüsteemi me stringi teisendada tahame (tavaliselt valitakse kümnendsüsteem). Kuid teise parameetri abil saame selgesõnaliselt näidata, et tahame stringi konkreetses süsteemis numbriks teisendada. Näiteks binaarses numbriks teisendamine:

Var num1 = "110"; var number2 = parseInt(arv1, 2); konsool.log(arv2); // 6

Tulemuseks on 6, kuna kahendarvuna 110 on sama kui 6 kümnendkohana.

Nüüd kirjutame väikese programmi, milles kasutame muutujatega toiminguid:

JavaScript var strSum = prompt("Sisesta sissemakse summa", 1000); var strPercent = prompt("Sisesta intressimäär", 10); var summa = parseInt(strSum); var protsent = parseInt(strProtsent); summa = summa + summa * protsent / 100; alert("Pärast intressi arvutamist on hoiuse summa: " + summa);

Funktsioon prompt() kuvab brauseris dialoogiboksi, milles palutakse sisestada väärtus. Selle funktsiooni teine ​​argument määrab väärtuse, mida kasutatakse vaikeväärtusena.

Funktsioon prompt() tagastab aga stringi. Seetõttu peame selle stringi teisendama arvuks, et sellega toiminguid teha.

Pärast lehe avamist brauseris näeme viipa sissemakse summa sisestamiseks:

Seejärel kuvatakse protsendi sisestamiseks sarnane teade. Ja lõpuks võtab programm andmed vastu, teisendab need numbriteks ja teostab arvutuse.

JavaScriptil on stringide numbriteks teisendamiseks kaks sisseehitatud funktsiooni: parseFloat() ja parseInt() .

parseFloat() võtab argumendina numbritüübiks teisendatava stringi ja tagastab ujukarvu. Number peab ilmuma rea ​​alguses. Kui pärast numbrit on real veel mingeid märke, lõigatakse need ära. Arvu murdosa tuleb kirjutada punktiga eraldatuna (koma eraldajana ei tajuta). Kui parseFloat() ei saa stringi teisendada, tagastab see NaN.

Funktsioon võib töödelda ka “arvu n korrutatuna 10-ga x astmega”, mis programmeerimisel kirjutatakse tavaliselt E-tähega, näiteks: 0,5E6 või 0,5E+6. Kraad võib olla ka negatiivne: 0,5E-6, mis võrdub 0,5*10^-6 või 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

Funktsioon parseInt(string[, radix]) võtab stringi esimese argumendina, analüüsib seda ja tagastab täisarvu (tüüp integer). Funktsioon püüab analüüsida arvusüsteemi, milles lähtestringis olev arv on kirjutatud (näiteks kümnend-, kaheksand- või kuueteistkümnendsüsteem, kuid mitte ainult need). Numbrisüsteemi saab ka selgesõnaliselt määrata, edastades selle teise parameetri radiksina. Radixi parameeter võib võtta mis tahes arvu vahemikus 2 kuni 36 (süsteemides, mille suurus on üle 10, kasutatakse ingliskeelset tähestikku A-st Z-ni).

Funktsioon ei töötle selliseid numbreid nagu 1.5e6 nagu parseFloat() .

Lugege allolevaid näiteid, et mitte komistada funktsiooni parseInt() töös peituvatele lõksudele.

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045",10) // 45 parseInt( ""70",8) // 56 (kaheksandikarvu 70 on kümnendkohana 56) parseInt(""070"") // 56 (TÄHTIS! null esimene paneb funktsioon stringi kaheksandarvuna sõeluma ) parseInt(" "88"",8) // NaN (kaheksandsüsteemis pole numbrit 8) parseInt(""a1"") // NaN (TÄHTIS!!! Vaikimisi funktsioon ei käsitle arvu kui kuueteistkümnendsüsteem, kui seda ei lisata algusridadele 0x) parseInt(""a1",16) // 161 (siin on selgesõnaliselt määratud numbrisüsteem) parseInt(""0xa1"") // 161 (õige kuueteistkümnendsüsteemi numbrivorming , ei pea teist parameetrit määrama) parseInt( ""099"") // 0 (TÄHTIS! Numbrit käsitletakse kaheksandarvuna, kuid see sisaldab kehtetuid märke) parseInt(""0.5e6"") / / 0 (TÄHTIS!!! ei tööta nagu parseFloat) parseInt("" ZZ",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF",16) / / -255

Kui sõelute kasutaja sisendit tekstiväljalt, kasutage koodi ootamatute tulemuste eest kaitsmiseks alati parseInt() koos teise radixi parameetriga.

JavaScript on dünaamilise andmete sisestamisega keel. See tähendab, et samale muutujale saab kirjutada erinevat tüüpi väärtusi, kuid muutuja enda tüüp muutub. Selline käitumine võimaldab sageli unustada erinevat tüüpi muutujate erineva käitumise, kuid siiski on vaja seda funktsiooni meeles pidada. Näitame seda järgmise näitega.

konsool.log(summa(1, 2)); // 3 (siin on kõik korras) console.log(sum(1, "2")); // 12 (siin pole eriti hea)

Nagu näitest näha, funktsioon summa käitub valesti, kui vähemalt üks selle argumentidest ei ole arv. Fakt on see, et stringile arvu “lisamisel” teisendatakse arv stringiks ja see ühendatakse (liimitakse) teise operandiga.

Selliste komplikatsioonide vältimiseks saate skripti täitmise ajal teada saada muutuja tüübi ja kohandada selle käitumist või jälgida hoolikalt muutujate tüüpe.

operaatori tüüp

See ühekordne operaator võtab operandiks absoluutselt mis tahes väärtuse ja tagastab selle tüübi stringi muutujas.

JavaScriptil on järgmised andmetüübid:

// 1.) objekt konsool.log (typeof ( ) ) ; // objekt var p = ( x: 1 , y: 3 ) ; console.log(typeof p) ; // objekt // 2.) function function sayHello() ( console.log ("Tere!" ) ; ) console.log (typeof sayHello) ; // funktsioon // 3.) string console.log (tüüp "JavaScript" ) ; // string // 4.) number console.log (typeof 3.1415 ) ; // number // 5.) Boolean console.log (typeof true ) ; // Boolean // 6.) undefined var notExistsOne; console.log (notExistsOne tüüp) ; // undefined console.log (typeof notExistsTwo) ; // määratlemata

// 1.) objekti konsool.log(typeof ()); // objekti vari p = (x: 1, y: 3); konsool.log(p tüüp); // objekt // 2.) function function sayHello() ( console.log("Tere!"); ) console.log(typeof sayHello); // funktsioon // 3.) string console.log(typeof "JavaScript"); // string // 4.) number console.log(typeof 3.1415); // number // 5.) tõeväärtus konsool.log(tõene tüüp); // Boolean // 6.) undefined var notExistsOne; console.log(tüüp notExistsOne); // undefined console.log(typeof notExistsTwo); // määratlemata

pane see tähele määratlemata See on ka andmetüüp, mis koosneb ühest väärtusest.

Cast

Tüübivalu tähendab programmeerimises ühte tüüpi muutuja väärtuse teisendamist teist tüüpi muutuja väärtuseks.
Sageli toimub selline teisendamine ilma programmeerija kontrollita. Seda võib näha funktsiooni näites summa. Tüübimuutus toimub siis, kui algset tüüpi muutujaga tehtava toimingu tulemus on ebaselge. Näiteks on võimatu täpselt öelda, mis saab numbrile stringi lisamisest, kuid kahe numbri liitmise toiming on ilmne ja sel juhul on loogiline arvu taandada stringiks.

Stringi teisendamine arvuks

Mõnikord saab programmeerija ise muutuja tüüpi muuta, rakendades sellele teatud toiminguid. Näiteks stringi suurendamise või vähendamise toimingud vähendavad selle arvuks.

var c = "mitte-arv"; ++c; konsool.log(tüüp c); // NaN

Väärib märkimist, et seda stringi arvuks teisendamise meetodit ei ole vaja kasutada selle halva loetavuse ja mitteilmsuse tõttu. Selle ülesande jaoks on js-is sisseehitatud funktsioonid parseInt Ja parseFloat. Esimese argumendina võtavad nad stringi, mis tuleb arvuks teisendada, ja valikulise teise argumendina numbrisüsteemi aluse, milles arv on kirjutatud esimese argumendina läbitud stringi. Kui teist argumenti ei täpsustata, siis eeldatakse, et rida sisaldab arvu kümnendarvusüsteemis.

Funktsioon parseInt kasutatakse stringi täisarvuks teisendamiseks ja funktsiooniks parseFloat murdarvuks teisendada.

var a = parseInt("10" ) ; console.log ([ "a = " , a, "; typeof a:" , typeof a] .join ( " " ) ); // a = 10 ; a tüüp: number var pi = parseInt("3.1415" ) ; console.log("pi = " + pi) ; // pi = 3 pi = parseFloat("3.1415" ) ; console.log("pi = " + pi) ; // pi = 3,1415

var a = parseInt("10"); console.log(["a = ", a, "; tüüp a:", tüüp a].join(" ")); // a = 10 ; a tüüp: number var pi = parseInt("3.1415"); console.log("pi = " + pi); // pi = 3 pi = parseFloat("3.1415"); console.log("pi = " + pi); // pi = 3,1415

Pange tähele, et string võib sisaldada mis tahes literaalset numbrilist väärtust, sealhulgas kuueteistkümnendsüsteemi, kaheksandsüsteemi või teaduslikku tähistust.

a = parseInt("010" ) ; console.log("a = " + a) ; // a = 8 a = parseInt("0xAA" ) ; console.log("a = " + a) ; // a = 170 a = parseFloat("1e-10" ) ; console.log("a = " + a) ; // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,0000000001)

a = parseInt("010"); console.log("a = " + a); // a = 8 a = parseInt("0xAA"); console.log("a = " + a); // a = 170 a = parseFloat("1e-10"); console.log("a = " + a); // a = 1e-10 (1e-10 = 1 * 10^-10 = 0,0000000001)

Funktsioonide teise parameetrina parseInt Ja parseFloat Saate määrata numbrisüsteemi aluse.

a = parseInt("10" , 8 ) ; console.log("a = " + a) ; // a = 8 a = parseInt("010" , 10 ) ; console.log("a = " + a) ; // a = 10 a = parseInt("ff" , 16 ) ; console.log("a = " + a) ; // a = 255

a = parseInt("10", 8); console.log("a = " + a); // a = 8 a = parseInt("010", 10); console.log("a = " + a); // a = 10 a = parseInt("ff", 16); console.log("a = " + a); // a = 255

Kui väärtus on funktsiooni stringis parseInt Ja parseFloat võetakse esimese parameetrina, ei ole numbriline literaal, siis on nende funktsioonide täitmise tulemuseks väärtus NaN.

a = parseInt("mitte arv" ) ; console.log("a = " + a) ; // a = NaN a = parseFloat("mitte arv" ) ; console.log("a = " + a) ; // a = NaN

a = parseInt("mitte arv"); console.log("a = " + a); // a = NaN a = parseFloat("mitte arv"); console.log("a = " + a); // a = NaN

Stringi teisendamine

JavaScriptis saab stringi üle kanda mis tahes tüüpi väärtuse. Eespool oli juba mainitud, et stringi aheldamisel arvuga taandatakse arv stringiks ja alles siis toimub konkatenatsioon. See juhtub mis tahes tüüpi väärtusega.

var str = "Objekt: " + ( ) ; console.log(str); // Objekt: str = "Massiiv: " + [ 1 , 2 , 3 ] ; console.log(str); // Massiiv: 1,2,3 funktsioon sum(a, b) ( return a + b; ) str = "Funktsioon: " + summa; console.log(str); /* Funktsioon: funktsioon summa(a, b) ( tagastab a + b; ) */

var str = "Objekt: " + (); console.log(str); // Objekt: str = "Massiiv: " + ; console.log(str); // Massiiv: 1,2,3 funktsioon sum(a, b) ( return a + b; ) str = "Funktsioon: " + summa; console.log(str); /* Funktsioon: funktsioon summa(a, b) ( tagastab a + b; ) */

Tegelikult nimetatakse objekti stringi valamisel meetodit kaudselt toString, mida võib ka selgesõnaliselt nimetada.

var p = ( x: 2 , y: 4 ), str; str = p.toString(); console.log(typeof str) ; // stringi konsool.log (str) ; // str = [ 1 , 2 , 3 ] .toString ( ); console.log(typeof str) ; // stringi konsool.log (str) ; // 1,2,3

var p = (x: 2, y: 4), str; str = p.toString(); konsool.log(tüüp str); // stringi konsool.log(str); // str = .toString(); console.log(typeof str); // stringi konsool.log(str); // 1,2,3

Numbrite teisendamine

Arvuks teisendamine toimub matemaatiliste toimingute tegemisel ja võrdlustehte tegemisel tüübivaluga (==, !=) ja väärtusega vale ja tühi massiiv teisendatakse väärtuse tüübiks 0 number.

var a = tõene + tõsi + tõene; // 1 + 1 + 1 konsool.log(a); // 3

Mittetühi massiiv, objekt ja funktsioon kantakse stringi, kui neid kasutatakse aritmeetilistes avaldistes.

var arr = [1, 2, 3]; konsool.log(arr + 4); // 1,2,34 funktsioon summa(a, b) ( return a + b; ) console.log (summa + 5 ) ; // funktsioon summa(a, b)(tagasi a + b;)5

var arr = ; konsool.log(arr + 4); // 1,2,34 funktsioon sum(a, b)(return a + b;) console.log(sum + 5); // funktsioon summa(a, b)(tagasi a + b;)5

Nagu näete, ei ole kaudne tüübi teisendamine js-is alati ilmne, seega peaksite seda vältima, kasutades eksplitsiitse tüübi teisendamiseks funktsioone, näiteks parseInt, parseFloat Ja toString.

See on kõik. Nagu alati, edu teile!