Js konvertēšana uz numuru. Datu konvertēšana uz JavaScript. JavaScript metodes virkņu pārvēršanai skaitļos

Ir divi galvenie veidi, kā javascript pārvērst virkni par skaitli. Viens veids ir to parsēt, bet otrs veids ir mainīt tā veidu uz numuru. Visas pārējās atbilžu viltības (piemēram, unārais pluss) ietver netiešu virknes veida piespiešanu skaitlim. To pašu var izdarīt arī, izmantojot funkciju Numurs.

Sintaktiskā

Var parsēts = parseInt("97", 10);

parseInt un parseFloat ir divas funkcijas, ko izmanto, lai parsētu virknes skaitļos. Parsēšana tiks pārtraukta klusi, ja tā saskarsies ar rakstzīmi, kuru tā neatpazīst. Tas var būt noderīgi, lai parsētu virknes, piemēram, "92px", taču tā ir arī zināmā mērā bīstama, jo tā neradīs kļūdu, ja ievade ir slikta, tā vietā jūs " atgriezīs NaN, ja virkne nesākas ar skaitli. Atstarpe virknes sākumā tiek ignorēta. Tālāk ir sniegts piemērs, ka tā veic kaut ko savādāk, kā jums nepieciešams, un nenorāda, ka kaut kas nogāja greizi:

Var logrīkiPārdots = parseInt("97 800", 10); // widgetsSold tagad ir 97

Laba prakse ir vienmēr norādīt to kā otro argumentu. Vecākās pārlūkprogrammās, ja virkne sākas ar 0, tā tiktu interpretēta kā oktāls, ja vien nebūtu norādīta radix vērtība, kas pārsteidza daudzus cilvēkus. Heksadecimālās aktivizēšanas darbība tiek aktivizēta, ja virkne sākas ar 0x, ja vien nav norādīta radiksa vērtība. 0xff. Standarts faktiski mainījās ar ecmascript 5, tāpēc mūsdienu pārlūkprogrammas vairs neaktivizē oktāļus, kad tiek norādīts sākuma 0, ja vien nav norādīta radix vērtība. parseInt saprot radikāļus līdz 36. bāzei, un tādā gadījumā gan lielie, gan mazie burti tiek uzskatīti par līdzvērtīgiem.

Virknes veida maiņa uz numuru

Visi citi iepriekš minētie triki, kas neizmanto parseInt, ietver netiešu virknes piespiešanu līdz skaitlim. Man labāk patīk to darīt skaidri

Var cast = Skaitlis("97");

Tas atšķiras no parsēšanas metodēm (lai gan joprojām tiek ignorētas atstarpes). Tas ir stingrāks: ja tas nesaprot visu virkni, tas atgriež NaN , tāpēc jūs nevarat to izmantot virknēm, piemēram, 97 pikseļi . Tā kā jums ir nepieciešams primitīvs skaitlis, nevis skaitļa iesaiņojuma objekts, pirms funkcijas Skaitlis nelieciet jaunu.

Acīmredzot, konvertējot uz skaitli, tiek iegūta vērtība, kas var būt peldošs, nevis vesels skaitlis, tādēļ, ja vēlaties veselu skaitli, tas ir jāmaina. Ir vairāki veidi, kā to izdarīt:

Var noapaļots = Math.floor(Numurs("97,654")); // citas opcijas ir Math.ceil, Math.round varfix = Number("97.654").toFixed(0); // noapaļots, nevis saīsināts var bitwised = Skaitlis("97.654")|0; // neizmantot lieliem skaitļiem

Jebkurš bitu operators (šeit es esmu bitu vai, bet jūs varat arī veikt dubultu noliegšanu, piemēram, iepriekšējā atbildē vai bitu nobīdē) pārveidos vērtību par 32 bitu veselu skaitli, un lielākā daļa no tiem tiks pārvērsti par veselu skaitli ar zīmi. Ņemiet vērā, ka tas nebūs vajadzīgs lieliem veseliem skaitļiem. Ja veselu skaitli nevar attēlot 32 bitos, tas tiks pārtraukts.

~~"3000000000.654" === -1294967296 // Tas ir tas pats Skaitlis("3000000000.654")|0 "3000000000.654" >>> 0 === 3000000000.654 > >> 0 === 3647256576 // bet tomēr neizdodas ar lielākiem skaitļiem

Lai pareizi strādātu ar lieliem skaitļiem, jāizmanto noapaļošanas paņēmieni

Math.floor("3000000000.654") === 3000000000 // Tas ir tas pats, kas Math.floor(Number("3000000000.654"))

Ņemiet vērā, ka visas šīs metodes saprot eksponenciālo apzīmējumu, tāpēc 2e2 ir 200, nevis NaN. Turklāt numurs saprot "bezgalību", savukārt parsēšanas metodes to nesaprot.

Pielāgots

Tā nav taisnība, ka kāda no šīm metodēm dara tieši to, ko vēlaties. Piemēram, es parasti vēlos kļūdu, kas rodas, ja parsēšana neizdodas, un man nav nepieciešams Infinity atbalsts, eksponenti vai sākuma atstarpes. Atkarībā no lietošanas veida dažreiz ir lietderīgi uzrakstīt pielāgotu konvertēšanas funkciju.

Vienmēr pārbaudiet, vai numura numurs vai kāda no parsēšanas metodēm ir gaidītais skaitlis. Gandrīz noteikti vēlēsities izmantot isNaN, lai nodrošinātu, ka numurs nav NaN (parasti vienīgais veids, kā uzzināt, ka parsēšana neizdevās).

JavaScript nodrošina vairākus iebūvētus datu tipus. Papildus tiem šajā rakstā ir apskatīti jQuery virtuālie veidi, piemēram, atlasītāji, paplašināti pseidotipi, piemēram, notikumi, un visa veida funkcijas.

Vislabāk ir izmēģināt lielāko daļu tālāk norādīto piemēru. To var viegli izdarīt, vienkārši kopējot šos piemērus Firebug konsolē, Firefox pārlūkprogrammas paplašinājumā.

Ikreiz, kad piemēros tiek veiktas darbības Būla kontekstā (piemēram, salīdzinājumi), ir svarīgi zināt, kā katrs datu tips darbojas šajā kontekstā:

Var x = "" if (x) console.log("x noklusējuma vērtība ir patiesa") else console.log ("x noklusējuma vērtība ir false")

Šajā gadījumā tiks izdrukāts "x ir vienāds ar false".

Lai samazinātu piemēru garumu, nolieguma operators tiek izmantots, lai parādītu Būla kontekstu:

X // taisnība

jQuery datu tipi

Stīgas

• Iebūvētās metodes stīgām
• garuma īpašums
• Būla konteksts

Skaitļi

• Būla konteksts
• Skaitļu parsēšana
• Skaitļi uz virknēm
• NaN un Infinity
• Vesels skaitlis
• Pludiņš

Būla tips

Objekti

• Punktu apzīmējumi
• Masīva apzīmējums
• Iterācija
• Būla noklusējuma vērtība
• Prototips

Iespējas

Masīvi

• Iterācija
• Būla noklusējuma vērtība
• Masīva apzīmējums

Funkcijas

• Argumenti
• Konteksts, zvaniet un piesakieties
• Redzamības zona
• Slēgšanas
• Starpniekservera modelis

Atzvanīšanas funkcijas

Selektori

Pasākumi

Elementi

jQuery tips

XMLHttpPieprasījuma veids

Rindas "Šī ir JavaScript virkne!" "Un šī arī ir rinda!"

JavaScript virkne ir nemainīgs objekts, kurā ir nulle, viena vai vairākas rakstzīmes.

Stīgu veids ir "string". Virknes veidu varat uzzināt šādi:

"dažas virknes" veids; // "virkne"

Pēdiņu izmantošana virknēs

Virkni var definēt, izmantojot vienas vai dubultpēdiņas. Jūs varat brīvi izmantot vienas pēdiņas virknē, kas ievietota dubultpēdiņās, un otrādi. Lai izmantotu dubultpēdiņas virknēs ar dubultpēdiņām, tās ir jāatspoguļo ar atpakaļvērsto slīpsvītru \ . Tas attiecas arī uz atsevišķām pēdiņām.

"Tu padari mani bēdīgu." "Svētais "klauvēja" Mozus!" " mājas" "mājas"

Iebūvētās metodes stīgām

JavaScript ir vairākas iebūvētas metodes virkņu manipulēšanai, kuru rezultāts var būt vai nu virkne, vai, piemēram, masīvs:

"hello".charAt(0) // "h" - rakstzīmes iegūšana vēlamajā pozīcijā virknē "hello".toUpperCase() // "HELLO" - virknes pārvēršana par lielajiem burtiem "Hello".toLowerCase() // "hello" - virknes pārvēršana par mazajiem burtiem "hello".replace(/e|o/g, "x") // "hxllx" - virknes daļas aizstāšana ar apakšvirkni, izmantojot regulārās izteiksmes modeli "1, 2,3".split(", ") // ["1", "2", "3"] — virknes sadalīšana masīvā ar noteiktu apakšvirkni

garuma īpašums

Virknēm ir garuma rekvizīts, kas norāda virknes garumu.

"Sveiki".garums // 5 "".garums // 0

Būla konteksts

Tukša virkne tiek novērtēta kā nepatiesa:

!"" // taisnība ! "sveiki" // false ! "patiess" // false !new Būla(false) // false

Skaitļi 12 3.543

JavaScript skaitļi ir 64 bitu dubultās precizitātes formātā saskaņā ar standartu IEEE 754. Tie ir arī nemainīgi. Lai strādātu ar cipariem, ir pieejami visi operatori, tādi paši kā C valodā (+, -, *, /, %, =, +=, -=, *=, /=, ++, --).

Ciparu veids ir "skaitlis". Varat pārbaudīt skaitļu veidus šādi:

12 tips // "skaitlis" 3.543 tips // "skaitlis"

Būla konteksts

Ja skaitlis ir nulle, tad tas ir vienāds ar nepatiesu:

0 // patiess !1 // nepatiess !-1 // nepatiess

Tā kā skaitļi ir ieviesti dubultās precizitātes formātā, šī piemēra izvade nav nepareiza:

0.1 + 0.2 // 0.30000000000000004

Matemātikas objekts

JavaScript nodrošina funkcijas darbam ar skaitļiem matemātikas objektā:

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

Konvertēt uz skaitļiem

Funkcijas parseInt un parseFloat pārvērš virknes skaitļos. Abas funkcijas veic netiešu konvertēšanu, ja skaitļu sistēma nav norādīta:

ParseInt("123") = 123 (netieša decimālā konversija) parseInt("010") = 8 (netiešā oktālā konversija) parseInt("0xCAFE") = 51966 (netieša heksadecimālā konversija) parseInt("010", 10) = 10 ( skaidra decimālā konversija ar radiksi 10) parseInt("11", 2) = 3 (skaidra binārā konversija) parseFloat("10.10") = 10.1

Skaitļu pārvēršana virknēs

Ja virknei pievienojat ciparus, izmantojot darbību “+”, rezultāts vienmēr būs virkne. Lai veiktu aprēķinus pirms skaitļa pievienošanas virknei, noteikti ievietojiet aprēķinus iekavās:

"" + 1 + 2; // "12" "" + (1 + 2); // "3" "" + 0,0000001; // "1e-7" parseInt(0.0000001); // 1 (piezīme!)

Varat arī izmantot JavaScript virknes klasi, kas pārveido nodoto vērtību virknē:

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

NaN un Infinity tipi

Pārvēršot vērtības, kas nav skaitļi, tiek iegūts NaN. Funkcija isNaN nosaka, vai tai nodotā ​​vērtība ir vienāda ar NaN:

ParseInt("sveiki", 10) // NaN isNaN(parseInt("sveiki", 10)) // patiess

Dalot ar nulli, iegūst bezgalību:

1 / 0 // Bezgalība

Gan NaN, gan Infinity vērtība ir "number" tipa:

Typeof NaN // "skaitlis" bezgalības tips // "skaitlis"

Lūdzu, ņemiet vērā, ka NaN vērtību salīdzināšana notiek nestandarta veidā:

NaN == NaN // viltus (!)

Bezgalība == Bezgalība // patiess

Vesela skaitļa veids

Vesels skaitlis ir vesela skaitļa veids.

Pludiņa veids

Pludiņš ir peldošā komata skaitļu veids.

Būla tips

Būla veids JavaScript var būt patiess vai nepatiess:

If (true) console.log("vienmēr!") if (false) console.log("nekad!")

Piemēram, Būla tips izskatās šādi, iestatot iestatījumus, pievienojot jQuery spraudņus:

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

Objekti

Viss JavaScript ir objekts. Vienkāršākais veids, kā izveidot objektu, ir:

Var x = (); var y = ( vārds: "Pīts", vecums: 15);

Objektu tips ir "objekts":

Typeof() // "objekts"

Objekta īpašības

Varat mainīt un iegūt objekta īpašības, izmantojot punktu apzīmējumu:

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

Varat arī izmantot objektu kā masīvu:

Var operācijas = ( pieaugums: "++", samazinājums: "--" ) var operation = "palielināt"; operācijas // "++"; operācijas ["reizināt"] = "*"; // "*"

Iterācijas uz objektiem

Objektu atkārtošana ir ļoti vienkārša, izmantojot for-in cilpas operatoru:

Var obj = ( vārds: "Pīts", vecums: 15 ); for(atslēga objektā obj) ( alert ("atslēga ir "++", vērtība ir "+obj); )

jQuery nodrošina funkciju

lai atkārtotu objekta īpašības vai masīva elementus:

JQuery.each(obj, funkcija(atslēga, vērtība) (console.log("atslēga", atslēga, "vērtība", vērtība); ));

Būla konteksts

Objektam, neatkarīgi no tā, vai tam ir īpašības vai nav, vienmēr ir taisnība:

!() // viltus

Prototipi

Visiem objektiem ir prototipa īpašums. Ikreiz, kad tulks meklē objekta īpašību, tas pārbauda arī tā prototipu. Programmā jQuery šis mehānisms tiek plaši izmantots, lai pievienotu metodes jQuery objektu gadījumiem.

Var forma = $("#mana forma"); forma.clearForm; // undefined form.fn.clearForm = function() ( return this.find(":input").each(function() ( this.value = ""; )).end(); ); form.clearForm() // var lietot visiem jQuery objektu gadījumiem, jo ​​prototipam tika pievienota jauna metode

Nav nozīmes, kāda veida mainīgais tiek izmantots izteiksmē. Ja izteiksme ir matemātiska, visi tās mainīgie tiks automātiski interpretēti kā skaitliski. Ja virknes tiek apstrādātas, tad visi izteiksmes “dalībnieki” tiek uzskatīti par virknēm. Tomēr izaicinājums, kas saistīts ar pārvēršanu no virknes uz numuru JavaScript programmā, pastāv daudz plašākā kontekstā.

JavaScript metodes virkņu pārvēršanai skaitļos

Metožu arsenāls virkņu pārvēršanai skaitļos nav liels, taču ar to pietiek visos vienkāršos gadījumos. Šeit JavaScript (īpaši iesācējiem) ir ceļš no vienkārša uz sarežģītu, izmantojot praktiskus piemērus.

Piemērā ir aprakstītas četras dažādas virknes. Pirmajā izvades blokā funkcija typeof definē katra mainīgā veidu kā virkni. Pēc tam katra virkne tiek ļoti vienkārši pārveidota par skaitli. Otrajā izvades blokā ir redzamas izmaiņas mainīgajos pēc konvertēšanas, to veids ir kļuvis par skaitli. JavaScript parseFloat konversijas piemērs ir īpaši ilustratīvs: tas bija "12e+3" un kļuva par "12000".

Izmaiņas, pārvēršot virkni par skaitli, var būt nozīmīgas! Bet nozīmes ir tikai pirmajām rakstzīmēm: tām jābūt cipariem. Ja nav ciparu rakstzīmju, rezultāts būs NaN.

Virknes apgrieztā pārveidošana, kas "kļūst" par skaitli, ne vienmēr ir tā pati virkne. Šo punktu var izmantot, lai pārbaudītu skaitliskās informācijas ievadīšanas pareizību.

Izplatītas konversijas metodes

Ir attiecīgi veseli skaitļi un daļskaitļi, JavaScript pārveido virkni par skaitli, izmantojot:

• parseInt;
• parseFloat.

Vispārējais gadījums tiek realizēts, izmantojot virkni vienkāršā matemātiskā izteiksmē.

Pietiek pirms rakstzīmju virknes ievietot zīmi “+” un, ja tajā ir skaitlis, tad izteiksmes rezultāts būs skaitlis. Mainīgā vērtība var mainīties, bet tips vienmēr mainīsies: typeof parādīs skaitli, nevis virkni. Ir svarīgi saprast, ka konvertēta mainīgā izmantošana virknes izteiksmē var radīt pilnīgi atšķirīgu rezultātu.

JavaScript iesācējiem šajā kontekstā ir ļoti vienkāršs. Vesela skaitļa konvertēšanas darbību ir grūtāk saprast, izmantojot metodi pasrseInt, jo tā automātiski darbojas decimālo skaitļu sistēmā, bet var interpretēt virkni kā oktālo vai heksadecimālo. Tomēr šis apstāklis ​​ne vienmēr ir atkarīgs no otrā parametra, kas norāda uz skaitļu sistēmu.

JavaScript vienmēr pārvērš virkni par skaitli, bet, ja virknei rindas sākumā nav nevienas ciparu rakstzīmes, rezultāts būs NaN.

Ir nepieciešama izpratne par skaitļu sistēmām, kā rakstīt heksadecimālos (skaitlis sākas ar "0x") un oktālos skaitļus (skaitlis sākas ar "0").

Lai saprastu JavaScript parseFloat metodes nianses, pietiek ar priekšstatu par to, kas ir reāla skaitļa matemātiskais apzīmējums.

Pārveidošana šķirošanas nolūkos

JavaScript ir pārlūkprogrammas valoda, tāpēc tā ir svarīgāka par citām valodām attiecībā uz rakstzīmēm, kas atrodas ārpus latīņu alfabēta un ciparu pamata kopas. Šķirošana ir populāra darbība. Taču ne vienmēr ir jēga sūtīt datus uz serveri šķirošanas nolūkos; vienkāršāk un praktiskāk ir darbu veikt lokāli, pārlūkprogrammā.

Lai atrisinātu šo problēmu, varat pārvērst virknes rakstzīmes to ciparu kodos vai piešķirt burtiem un cipariem sakārtotu ciparu secību. Virknei lietotā metode charCodeAt() piešķirs mainīgajam iB skaitlisko vērtību 98, tas ir, burta "b" kodu. Ņemot vērā, ka burta "a" koda vērtība ir 97, jūs varat iegūt visu latīņu alfabēta burtu numurus augošā secībā mazo un lielo burtu komplektos. Līdzīgi arī krievu alfabēta burtiem.

Mūsu pašu skaitļu šķirošanas versija ļauj izveidot nepieciešamos rakstzīmju komplektus. Varat, piemēram, “pārkārtot” kirilicas un latīņu alfabētu vai sajaukt tos, lai atstātu tikai pareizrakstībā atšķirīgus burtus, vai pievienot kopām tabulēšanas un atstarpes rakstzīmes.

Unikāla virknes numura veidošana

Ja burta "a" kods ir 97, tad starpība starp burtu un skaitli 97 dos unikālo burta numuru alfabētā. Summējot unikālos skaitļus katrai virknes rakstzīmei, ir grūti iegūt šīs virknes unikālo numuru.

Ja piešķirat svaru katrai burta pozīcijai virknē, piemēram, pozīcija:

• 0 svars 1;
• 1 svars 10;
• 2 svars 100;

tad, reizinot katras virknes rakstzīmes unikālo numuru ar tās pozīcijas svaru, kurā tā ir atrasta, un summējot visus skaitļus, jūs varat iegūt unikālu skaitli un izmantot to kā oriģināla atbilstību viens pret vienu virkne.

Šī virknes pārvēršana par skaitli ir atgriezeniska, tas ir, jūs vienmēr varat iegūt sākotnējo virkni no skaitļa. Šāda pārveidošana ir izdevīga, jo jebkuru darbību var droši veikt ar numuru kodēšanas, kirilicas un citu vietnes lapas lokālo funkciju, pielietojuma apgabala un apmeklētāja valsts kontekstā.

Vietnes lapu atlasītāji “Pieaug”.

Bieži vien rodas uzdevums vietņu lapās izveidot selektorus, kuru vērtības nevar iepriekš norādīt, bet laika gaitā tās tiek papildinātas. Jau pirmajā lietojumprogrammā ir pieejams tukšs atlasītājs, lai pirmais apmeklētājs varētu ievadīt informāciju.

Katra jauna informācijas virknes ievade atlasītājā (jebkurš apmeklētājs) tiek pārveidota par skaitli, kas kopā ar oriģinālu tiek nosūtīts uz serveri glabāšanai. Kad sākas jauna sesija vai ierodas jauns apmeklētājs, atlasītājs vairs nav tukšs. Kad lapa ir ielādēta, tā nonāk pārlūkprogrammā ar atlasītāju, kas nav tukšs.

Katrai jaunai atlasītāja vērtībai tikai vienu reizi tā tiek nosūtīta uz serveri glabāšanai, un tikai vienreiz tai tiek piešķirts unikāls ciparu kods.

Lai atrisinātu šo problēmu, nevar izmantot JavaScript virknes uz numuru metodi. Parastās metodes parseInt un parseFloat ir paredzētas citiem lietojumiem, taču jūs varat izdomāt algoritmu, lai nepārprotami pārvērstu virkni par skaitli, un ne vienmēr par apgriežamu. Pietiek ar to, ka konversijas algoritms netiks atkārtots dažādās virknes rakstzīmju kopās.

Satiksmes optimizācija un analītika

Veidojot lapu, izstrādātājs izmanto ievērojamu daudzumu informācijas. Ļaujot apmeklētājam ievadīt informāciju, tas ir labs veids, kā pazemināt vietnes rangu tās sliktās funkcionalitātes dēļ un nomākt apmeklētāju.

Apmeklētāja darbībām pie noteiktiem informācijas blokiem piešķirot notikumu apdarinātāju JavaScript funkcijas veidā, iespējams noformulēt filtru, kas ļaus apmeklētājam precīzi uzstādīt mērķi, atrast nepieciešamo informāciju un iegūt vēlamo risinājumu. .

Virknes informācijas transformācija šeit var būt patvaļīgi liela virknes daļā un ļoti maza skaitļa daļā. Citiem vārdiem sakot, izstrādātājs, izmantojot savu algoritmu, pārveido JavaScript virkni par skaitli. Apmeklētājs manipulē ar saprotamu informāciju, un serverim tiek nosūtīts minimālais datu apjoms – skaitlis.

Visu apmeklētāju skaitļu kopas dinamika precīzi zināmas informācijas kontekstā ļauj citai JavaScript funkcijai (nevis apdarinātājam), kas tiek izsaukta servera atbildē, izmantojot AJAX mehānismu, lai ātri sniegtu visiem apmeklētājiem nepieciešamo informāciju vienlaikus reāllaikā. . Sistēma darbojas šādi.

Šī opcija JavaScript virknes konvertēšanai par skaitli ir ļoti populāra tiešsaistes spēļu, interaktīvu konferenču, tūlītējās ziņojumapmaiņas un tā tālāk izstrādē.

Pārveidojumu instrumentāls pielietojums

JavaScript un CSS skaitliskās informācijas apstrādes kontekstā ļauj kontrolēt lapas rādīšanu bez servera iesaistes. CSS noteikumi tiek veidoti kā apakšvirknes rekursīvi. Parasti parametrs ir cipars, kam seko vairāki burti (piemēram, "px", "pt", "em", ...). Parametrs ir kārtulas apakšvirkne, un kārtula ir apakšvirkne klases vai identifikatora stilā.

JavaScript recursion.Substring.Substring... atrod vajadzīgo skaitli, pārvērš to no virknes par skaitli, modificē un ieraksta atpakaļ vēlamajā vietā. Noteikums mainās automātiski. Tas ir vienkārši un ērti, bez servera iesaistīšanās.

Laba diena visiem. Aleksejs Guļiņins sazinās. Pēdējā rakstā jūs uzzinājāt par Javascript datu veidiem. Šajā rakstā es vēlētos runāt par tipa konvertēšanu Javascript. Tipa konvertēšana Javascript un pat jebkurā programmēšanas valodā tiek veikta ļoti bieži. Vispirms es gribēju runāt par tipu konvertēšanu, salīdzinot mainīgos vai citus nosacījumus, kuru rezultāts ir patiess vai nepatiess. Salīdzinot dažāda veida mainīgos, tiek veikta fona konvertēšana. Galvenais šeit ir tas, ka šādu fona transformāciju laikā mainīgajā saglabātā vērtība nemainās. mainīgais tiek konvertēts uz datu tipu (tiek izveidota mainīgā pagaidu vērtība), kas nepieciešams darbības veikšanai. Es sniegšu jums piemēru:

Tiek salīdzināti virknes tipa un skaitliskā tipa mainīgie. Salīdzinot, šo mainīgo vērtības tiek samazinātas līdz tādam pašam datu tipam. Pēc tam salīdzinājums atgriež Būla vērtību, un konvertētās pagaidu vērtības tiek noņemtas. Visas transformācijas ir atkarīgas no konteksta – operatoriem, kas ar tiem veic darbības. koda paraugs:

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

Šajā gadījumā mainīgais b tiks pārveidots par skaitli (tika veikta String tipa fona konvertēšana uz Skaitļa tipu, un tiks iegūta mainīgā b tipa Skaitlis = 15 pagaidu vērtība, kas tiks dzēsta pēc tiek veikta salīdzināšanas darbība), un rezultāts būs tāds, ka a .

Tālāk ir parādīta tabula, kurā parādīts, kā viens datu tips tiek pārveidots par citu.

Vērtības veids	Konteksts, kurā vērtība tiek izmantota
	Stīga	Skaitlisks	Loģiski	Objekts
Nedefinēta vērtība	'nenoteikts'	NaN	viltus	Kļūda
null	'nulle'	0	viltus	Kļūda
Tukša rinda	Tukša rinda	0	viltus	Stīgu objekts
Netukša virkne	Netukša virkne	Skaitliskās virknes vērtība vai NaN	taisnība	Stīgu objekts
0	’0′	0	viltus	Skaitļa objekts
NaN	'NaN'	NaN	viltus	Skaitļa objekts
Bezgalība	"Bezgalība"	Bezgalība	taisnība	Skaitļa objekts
- Bezgalība	"-bezgalība"	- Bezgalība	taisnība	Skaitļa objekts
Jebkurš cits numurs	Skaitļa virknes attēlojums	Pats numurs	taisnība	Skaitļa objekts
taisnība	'patiesa'	1	taisnība	Būla objekts
viltus	'nepatiess'	0	viltus	Būla objekts
Objekts, funkcija	toString()	valueOf(), toString() vai NaN	taisnība	Objekts, funkcija

Datu tipu konversijas

Būla datu tipu var iegūt no jebkura datu veida. Tas tiek darīts, izmantojot noliegšanas operatoru vai dubulto noliegumu. Piemērs:

Var a = 20; var b = !a; //return false var c = !!a; //atgriezt patiesu

Virkni var iegūt no jebkura objekta. Piemērs:

Var a = 20; var b = a.toString(); //atgriež "20" var c = a + ""; //atgriezt "20" tipa b; //return string typeof c; //atgriešanas virkne

Skaitļa iegūšana no virknes. Piemērs:

Var a = "20"; var b = a * 1; //atgriezties 20 var c = + a; //atgriezt 20 typeof b; //atgriešanas numurs typeof c; //atgriešanas numurs

Tagad, pamatojoties uz iegūtajām zināšanām, analizēsim loģiskā “UN” (&&) un loģiskā “OR” (||) uzvedību:

Loģiskais "UN" (&&):

Lai šis operators darbotos pareizi, ir nepieciešams, lai visu operandu vērtības varētu pārvērst par patiesām. Ja visu operandu vērtības var pārvērst par patiesu, tad tiks atgriezta pēdējā salīdzinātā operanda sākotnējā vērtība. Ja vismaz viena operanda vērtība tiek pārvērsta par false, tiek atgriezta šī operanda sākotnējā vērtība. Piemērs:

Var a = 15; var b = "abc"; var c = 0; var rezultāts; resultat = a && b && c; //atgriež 0 resultat = c && b && a; //atgriež 0 rezultātu = 7 && a; //atgriež 15 rezultātu = 7 && b; //atgriezt "abc"

Loģisks "OR" (||):

Ļaujiet man nedaudz paskaidrot par operatoriem un operandiem. Analizēsim izteiksmi resultat = a && b && c . Šeit operatori ir "=" un "&&" , t.i. tās ir darbības. Operandi: rezultāts, a, b, c. Tā tiek veikta darbība.

Pēdējā atjaunināšana: 1.11.2015

Bieži vien ir nepieciešams pārveidot vienus datus citos. Piemēram:

Var skaitlis1 = "46"; var skaitlis2 = "4"; var rezultāts = skaitlis1 + skaitlis2; console.log(rezultāts); //464

Abi mainīgie apzīmē virknes vai precīzāk skaitļu virkņu attēlojumus. Un beigās mēs iegūsim nevis skaitli 50, bet virkni 464. Bet būtu jauki, ja tos varētu arī saskaitīt, atņemt un vispār strādāt kā ar parastajiem skaitļiem.

Šajā gadījumā mēs varam izmantot konvertēšanas darbības. Lai pārvērstu virkni par skaitli, izmantojiet funkciju parseInt():

Var skaitlis1 = "46"; var skaitlis2 = "4"; var rezultāts = parseInt(skaitlis1) + parseInt(skaitlis2); konsole.log(rezultāts); // 50

Lai pārvērstu virknes daļskaitļos, izmantojiet funkciju parseFloat():

Var number1 = "46,07"; var number2 = "4,98"; var rezultāts = parseFloat(skaitlis1) + parseFloat(skaitlis2); konsole.log(rezultāts); //51.05

Šajā gadījumā rindai var būt jaukts saturs, piemēram, “123hello”, tas ir, šajā gadījumā ir cipari, bet ir arī parastās rakstzīmes. Bet parseInt() metode joprojām mēģinās veikt konvertēšanu:

Var num1 = "123labdien"; var num2 = parseInt(num1); konsole.log(num2); // 123

Ja metodei neizdodas konvertēt, tā atgriež NaN (nav skaitlis), kas norāda, ka virkne neatspoguļo skaitli un to nevar konvertēt.

Varat izmantot īpašo funkciju isNaN(), lai pārbaudītu, vai virkne apzīmē skaitli. Ja virkne nav skaitlis, funkcija atgriež true, ja tas ir skaitlis, tad false:

Var num1 = "javascript"; var num2 = "22"; var rezultāts = isNaN(num1); konsole.log(rezultāts); // patiess - num1 nav skaitlis rezultāts = isNaN(num2); konsole.log(rezultāts); // false — num2 ir skaitlis

Iepriekš mēs apskatījām virkņu pārvēršanu skaitļos decimālajā sistēmā. Tomēr mēs varam pārvērst skaitļus jebkurā sistēmā. Pēc noklusējuma JavaScript tulks pats uzmin, uz kuru skaitļu sistēmu mēs vēlamies pārvērst virkni (parasti tiek atlasīta decimālā sistēma). Bet mēs varam izmantot otro parametru, lai skaidri norādītu, ka mēs vēlamies pārvērst virkni par skaitli noteiktā sistēmā. Piemēram, pārveidojot par bināro skaitli:

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

Rezultāts ir 6, jo 110 binārā ir tāds pats kā 6 decimāldaļā.

Tagad uzrakstīsim nelielu programmu, kurā mēs izmantojam darbības ar mainīgajiem:

JavaScript var strSum = prompt("Ievadiet depozīta summu", 1000); var strPercent = prompt("Ievadiet procentu likmi", 10); var summa = parseInt(strSum); var procents = parseInt(strPercent); summa = summa + summa * procenti / 100; alert("Pēc procentu aprēķināšanas depozīta summa būs: " + summa);

Funkcija prompt() pārlūkprogrammā parāda dialoglodziņu, kurā tiek prasīts ievadīt vērtību. Otrais šīs funkcijas arguments norāda vērtību, kas tiks izmantota kā noklusējuma vērtība.

Tomēr funkcija prompt () atgriež virkni. Tāpēc mums šī virkne ir jāpārvērš par skaitli, lai ar to veiktu darbības.

Pēc lapas atvēršanas pārlūkprogrammā mēs redzēsim uzvedni ievadīt depozīta summu:

Pēc tam parādīsies līdzīgs ziņojums procentu ievadīšanai. Un beigās programma saņems datus, pārveidos tos skaitļos un veiks aprēķinu.