Huling na-update: 11/1/2015

Kadalasan mayroong pangangailangan na baguhin ang isang data sa isa pa. Halimbawa:

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

Ang parehong mga variable ay kumakatawan sa mga string, o mas tiyak na mga string na representasyon ng mga numero. At sa huli ay makukuha natin hindi ang numerong 50, kundi ang string na 464. Ngunit mas maganda kung maaari rin silang idagdag, ibawas, at sa pangkalahatan ay gumana tulad ng mga ordinaryong numero.

Sa kasong ito maaari naming gamitin ang mga pagpapatakbo ng conversion. Upang i-convert ang isang string sa isang numero, gamitin ang parseInt() function:

Var number1 = "46"; var number2 = "4"; var resulta = parseInt(number1) + parseInt(number2); console.log(resulta); // 50

Upang i-convert ang mga string sa mga fractional na numero, gamitin ang parseFloat() function:

Var number1 = "46.07"; var number2 = "4.98"; var resulta = parseFloat(number1) + parseFloat(number2); console.log(resulta); //51.05

Sa kasong ito, ang linya ay maaaring may halo-halong nilalaman, halimbawa, "123hello", iyon ay, sa kasong ito ay may mga numero, ngunit mayroon ding mga regular na character. Ngunit ang parseInt() na pamamaraan ay susubukan pa ring gawin ang conversion:

Var num1 = "123hello"; var num2 = parseInt(num1); console.log(num2); // 123

Kung nabigo ang paraan na ma-convert, ibabalik nito ang NaN (Hindi Numero), na nagpapahiwatig na ang string ay hindi kumakatawan sa isang numero at hindi maaaring ma-convert.

Maaari mong gamitin ang espesyal na function na isNaN() upang suriin kung ang isang string ay kumakatawan sa isang numero. Kung ang string ay hindi isang numero, ang function ay nagbabalik ng true, kung ito ay isang numero, pagkatapos ay false:

Var num1 = "javascript"; var num2 = "22"; var resulta = isNaN(num1); console.log(resulta); // true - num1 is not a number result = isNaN(num2); console.log(resulta); // false - ang num2 ay isang numero

Sa itaas ay tiningnan namin ang pag-convert ng mga string sa mga numero sa decimal system. Gayunpaman, maaari naming i-convert ang mga numero sa anumang sistema. Bilang default, hinuhulaan mismo ng JavaScript interpreter kung aling sistema ng numero ang gusto naming i-convert ang string (kadalasan ang decimal system ang pinipili). Ngunit maaari naming gamitin ang pangalawang parameter upang tahasang ipahiwatig na gusto naming i-convert ang string sa isang numero sa isang partikular na system. Halimbawa, ang pag-convert sa isang numero sa binary:

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

Ang resulta ay 6, dahil ang 110 sa binary ay kapareho ng 6 sa decimal.

Ngayon magsulat tayo ng isang maliit na programa kung saan ginagamit natin ang mga operasyon na may mga variable:

JavaScript var strSum = prompt("Ipasok ang halaga ng deposito", 1000);

var strPercent = prompt("Ipasok ang rate ng interes", 10);

var sum = parseInt(strSum);

var percentage = parseInt(strPercent);

kabuuan = kabuuan + kabuuan * porsyento / 100;

alert("Pagkatapos kalkulahin ang interes, ang halaga ng deposito ay magiging: " + sum);

Ang prompt() function ay nagpapakita ng isang dialog box sa browser na humihiling sa iyo na magpasok ng isang halaga. Ang pangalawang argumento sa function na ito ay tumutukoy sa halaga na gagamitin bilang default.

Gayunpaman, ang prompt() function ay nagbabalik ng isang string. Samakatuwid, kailangan nating i-convert ang string na ito sa isang numero upang maisagawa ang mga operasyon dito.

Pagkatapos buksan ang pahina sa browser, makakakita kami ng prompt upang ipasok ang halaga ng deposito:

Ang parseInt(string[, radix]) function ay kumukuha ng string bilang unang argumento nito, pinapa-parse ito at nagbabalik ng integer (type integer). Sinusubukan ng function na suriin ang sistema ng numero kung saan nakasulat ang numero sa source string (halimbawa, decimal, octal o hexadecimal - ngunit hindi lamang ang mga ito). Maaari mo ring tukuyin ang sistema ng numero nang tahasan sa pamamagitan ng pagpasa nito bilang pangalawang parameter na radix. Ang parameter ng radix ay maaaring tumagal ng anumang numero mula 2 hanggang 36 (sa mga system na mas mataas sa 10, ang mga titik ng alpabetong Ingles ay ginagamit, mula A hanggang Z).

Ang function ay hindi nagpoproseso ng mga numero tulad ng 1.5e6 tulad ng parseFloat() .

Mangyaring basahin ang mga halimbawa sa ibaba upang hindi matisod sa mga pitfalls na nakatago sa pagpapatakbo ng parseInt() function.

ParseInt(""25"") // 25 parseInt(""-25"") // -25 parseInt(""45.12"") // 45 parseInt(""045"",10) // 45 parseInt( ""70"",8) // 56 (70 sa octal ay 56 sa decimal) parseInt(""070"") // 56 (MAHALAGA!!! zero muna ang magiging sanhi ng function na i-parse ang string bilang isang octal number ) parseInt(" "88"",8) // NaN (walang digit 8 sa octal system) parseInt(""a1"") // NaN (MAHALAGA!!! Hindi tinatrato ng default na function ang numero bilang hexadecimal kung hindi ito idinagdag sa mga simulang linya 0x) parseInt(""a1"",16) // 161 (ang sistema ng numero ay tahasang tinukoy dito) parseInt(""0xa1"") // 161 (tamang hexadecimal na format ng numero , hindi mo kailangang tukuyin ang pangalawang parameter) parseInt( ""099"") // 0 (MAHALAGA!!! Ang numero ay itinuturing bilang octal, ngunit naglalaman ng mga hindi wastong character) parseInt(""0.5e6"") / / 0 (MAHALAGA!!! ay hindi gumagana tulad ng parseFloat) parseInt("" ZZ"",36) // 1295 parseInt(""-FF"") // NaN parseInt(""-FF"",16) / / -255

Kung nagpoproseso ka ng data mula sa isang text field na ipinasok ng user, palaging gumamit ng parseInt() kasama ng pangalawang parameter ng radix, mapoprotektahan nito ang iyong code mula sa mga hindi inaasahang resulta.

Ang JavaScript ay isang wika na may dynamic na pag-type ng data. Nangangahulugan ito na ang mga halaga ng iba't ibang uri ay maaaring isulat sa parehong variable, ngunit ang uri ng variable mismo ay magbabago. Ang pag-uugali na ito ay kadalasang ginagawang posible na makalimutan ang tungkol sa iba't ibang pag-uugali ng mga variable na may iba't ibang uri, ngunit kinakailangan pa ring tandaan ang tampok na ito. Ipakita natin ito sa sumusunod na halimbawa.

console.log(sum(1, 2)); // 3 (ang lahat ay ok dito) console.log(sum(1, "2")); // 12 (at hindi masyado dito)

Tulad ng makikita mula sa halimbawa, ang function kabuuan kumikilos nang hindi tama kung ang isang hindi numero ay ipinasa bilang kahit isa sa mga argumento nito. Ang katotohanan ay kapag "nagdaragdag" ng isang numero sa isang string, ang numero ay na-convert sa isang string at ito ay pinagsama (nakadikit) sa pangalawang operand.

Upang maiwasan ang mga ganitong komplikasyon, maaari mong malaman ang uri ng isang variable sa panahon ng pagpapatupad ng script at ayusin ang pag-uugali nito, o maingat na subaybayan ang mga uri ng mga variable.

uri ng operator

Ang unary operator na ito ay ganap na kumukuha ng anumang halaga bilang isang operand at ibinabalik ang uri nito sa isang string variable.

Ang JavaScript ay may mga sumusunod na uri ng data:

// 1.) object console.log (typeof ( ) );

// object var p = ( x: 1 , y: 3 );

console.log(uri ng p); // object // 2.) function function sayHello() ( console.log ("Hello!"); ) console.log (typeof sayHello) ;// function // 3.) string console.log (typeof "JavaScript" );

// string // 4.) number console.log (typeof 3.1415 );

// number // 5.) boolean console.log (typeof true );
// boolean // 6.) undefined var notExistsOne; kabuuan console.log (typeof notExistsOne) ;

// undefined console.log (typeof notExistsTwo) ;

// hindi natukoy

var c = "hindi-isang-numero"; ++c; console.log(typeof c); // NaN

Kapansin-pansin na hindi na kailangang gumamit ng ganitong paraan ng pag-convert ng isang string sa isang numero dahil sa hindi magandang pagiging madaling mabasa at hindi malinaw. May mga built-in na function para sa gawaing ito sa js parseInt At parseFloat. Bilang unang argumento, kinukuha nila ang string na kailangang i-convert sa isang numero, at bilang isang opsyonal na pangalawang argumento, kinukuha nila ang base ng sistema ng numero kung saan ang numero ay nakasulat sa string na ipinasa bilang unang argumento. Kung ang pangalawang argumento ay hindi tinukoy, pagkatapos ay ipagpalagay na ang linya ay naglalaman ng isang numero sa sistema ng decimal na numero.

Function parseInt ay ginagamit upang i-convert ang isang string sa isang integer at ang function parseFloat upang i-convert sa fraction.

var a = parseInt("10" );

console.log ([ "a = " , a, "; typeof a:" , typeof a] .join ( " " ) );

// a = 10 ; typeof a: number var pi = parseInt("3.1415" );

console.log("pi = " + pi);

// pi = 3 pi = parseFloat("3.1415" );

console.log("pi = " + pi); parseInt At parseFloat// pi = 3.1415

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

Tandaan na ang string ay maaaring maglaman ng anumang literal na numeric na halaga, kabilang ang hexadecimal, octal, o scientific notation.

a = parseInt("010" ); parseInt At parseFloat ay kinuha bilang unang parameter, ay hindi isang literal na numero, kung gayon ang resulta ng pagpapatupad ng mga function na ito ay ang halaga NaN.

a = parseInt("hindi isang numero" );

console.log("a = " + a) ;

// a = NaN a = parseFloat("not a number" );

console.log("a = " + a) ;

// a = NaN

a = parseInt("hindi isang numero"); console.log("a = " + a); // a = NaN a = parseFloat("not a number"); console.log("a = " + a); // a = NaN

Pag-convert ng string Sa JavaScript, ang isang halaga ng anumang uri ay maaaring i-cast sa isang string. Nabanggit na sa itaas na kapag ang isang string ay pinagsama-sama sa isang numero, ang numero ay nababawasan sa string, at pagkatapos lamang ay nangyayari ang pagsasama-sama. Mangyayari ito sa isang halaga ng anumang uri. var str = "Bagay: " + ( );

console.log(str);

// Object: str = "Array: " + [ 1 , 2 , 3 ] ;

console.log(str);

// Array: 1,2,3 function sum(a, b) ( return a + b; ) str = "Function: " + sum; console.log(str);/* Function: function sum(a, b) ( return a + b; ) */ var str = "Bagay: " + (); console.log(str); // Object: str = "Array: " + ; console.log(str); // Array: 1,2,3 function sum(a, b) ( return a + b; ) str = "Function: " + sum; console.log(str); /* Function: function sum(a, b) ( return a + b; ) */.

Sa katunayan, kapag nag-cast ng isang bagay sa isang string, ang pamamaraan ay tahasang tinatawag

toString

, na maaari ding tawaging tahasan.

var p = ( x: 2 , y: 4 ), str;

Gaya ng nakikita mo, hindi palaging halata ang implicit type na conversion sa js, kaya dapat mong iwasan ito sa pamamagitan ng paggamit ng mga function para sa tahasang uri ng conversion, gaya ng parseInt, parseFloat At Sa JavaScript, ang isang halaga ng anumang uri ay maaaring i-cast sa isang string. Nabanggit na sa itaas na kapag ang isang string ay pinagsama-sama sa isang numero, ang numero ay nababawasan sa string, at pagkatapos lamang ay nangyayari ang pagsasama-sama. Mangyayari ito sa isang halaga ng anumang uri..

Iyon lang. Gaya ng lagi, good luck sa iyo!