Numero ng Mga Paraan ng JavaScript. Pag-convert ng mga Variable ayon sa numero

Kapag nagsusulat ako sa javascript, madalas kong kailangang bumaling sa mga search engine upang linawin ang syntax ng mga pamamaraan (at ang pagkakasunud-sunod, kahulugan ng mga argumento) na gumagana sa mga string.

Sa artikulong ito susubukan kong magbigay ng mga halimbawa at paglalarawan ng mga pinakakaraniwang pamamaraan ng javascript na may kaugnayan sa mga string. Ang pinakasikat na mga pamamaraan ay matatagpuan sa tuktok ng artikulo para sa kaginhawahan.

I-convert sa string

Maaari kang mag-convert ng numero, boolean, o object sa isang string.

Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"

Maaari ka ring magsagawa ng katulad na pagmamanipula gamit ang string() function.

Var myNumber = 24; // 24 var myString = String(myNumber); // "24"

Sinabi ni Nicholas Zakas: "Kung hindi ka sigurado tungkol sa halaga (null o hindi natukoy), pagkatapos ay gamitin ang String() function, dahil nagbabalik ito ng string anuman ang uri ng variable."

hindi natukoy ay nangangahulugan na ang variable ay hindi itinalaga ng anumang halaga, at ang null ay nangangahulugan na ito ay itinalaga ng isang walang laman na halaga (masasabi nating ang null ay tinukoy bilang isang walang laman na bagay).

Hatiin ang isang string sa mga substring

Upang hatiin ang isang string sa isang hanay ng mga substring maaari mong gamitin ang split() na paraan:

Var myString = "coming,apart,at,the,comma";

var substringArray = myString.split(","); // ["coming", "apart", "at", "the", "commas"] var arrayLimited = myString.split(",", 3); // ["darating", "hiwalay", "sa"]

Tulad ng iminumungkahi ng huling linya, tinutukoy ng halaga ng pangalawang opsyonal na argumento ang bilang ng mga elemento sa ibinalik na array.

Kunin ang haba ng string

Gamit ang property na haba mahahanap mo ang bilang ng mga Unicode na character sa isang string:

Var myString = "Ikaw ay isang character."; var stringLength = myString.length; // 25

Tukuyin ang isang substring sa isang string

Mayroong dalawang paraan upang makamit ang iyong plano:

Gamitin ang indexOf() :

Var stringOne = "Johnny Waldo Harrison Waldo";

var wheresWaldo = stringOne.indexOf("Waldo"); // 7

Ang paraan ng indexOf() ay naghahanap ng isang substring (naipasa ang unang argumento) sa isang string (mula sa simula ng string) at ibinabalik ang posisyon ng unang character kung saan nagsimulang lumitaw ang substring sa string.

Gamitin ang lastIndexOf() :

Kung ang substring ay hindi natagpuan, ang parehong mga pamamaraan ay bumalik -1. Ang pangalawang opsyonal na argumento ay tumutukoy sa posisyon sa string kung saan mo gustong simulan ang paghahanap. Kaya, kung ang pangalawang argumento sa paraan ng indexOf() ay 5, magsisimula ang paghahanap mula sa ika-5 character, at ang mga character na 0-4 ay hindi papansinin. Para sa lastIndexOf() , kung ang pangalawang argumento ay 5, ang paghahanap ay magsisimula sa kabaligtaran na direksyon, na ang mga character na ika-6 at mas mataas ay hindi papansinin.

Paano palitan ang bahagi ng isang string

Upang palitan ang bahagi (o kahit lahat) ng isang string, gamitin ang replace() na paraan.

Var slugger = "Josh Hamilton";

var betterSlugger = slugger.replace("h Hamilton", "e Bautista");

console.log(betterSlugger); // "Jose Bautista"

Ang unang argumento ay naglalaman ng bahagi ng substring na papalitan; ang pangalawang argumento ay ang string na papalit sa substring na papalitan. Ang unang instance lang ng substring ang papalitan.

Upang palitan ang lahat ng paglitaw ng isang substring, gumamit ng regular na expression na may flag na "g".

Var myString = "Nagbebenta siya ng mga automotive shell sa automotive shore";

var newString = myString.replace(/automotive/g, "dagat");

console.log(newString); // "Nagbebenta siya ng mga sea shell sa baybayin ng dagat"

Maaaring kasama sa pangalawang argumento ang substring o function na papalitan.

Maghanap ng isang character sa isang naibigay na posisyon

Upang malaman kung aling karakter ang nasa isang partikular na posisyon, maaari mong gamitin ang charAt() na paraan:

Var myString = "Mga Ibon ng Balahibo";

var whatsAtSeven = myString.charAt(7); // "f"

Tulad ng madalas na kaso sa javascript, ang unang posisyon ay nagsisimula sa 0, hindi 1.

Bilang kahalili, maaari mong gamitin ang charCodeAt() na paraan, ngunit sa halip na ang karakter mismo, matatanggap mo ang code nito.

Var myString = "Mga Ibon ng Balahibo";

Var stringOne = "Knibb";

var stringTwo = "Mataas";

var stringThree = "football";

var stringFour = "mga panuntunan.";

var finalString = stringOne.concat(stringTwo, stringThree, stringFour);

console.log(finalString); // "Knibb high football rules."

Bahagi ng isang string (i-extract ang substring sa javascript)

Mayroong tatlong magkakaibang paraan upang lumikha ng bagong string sa pamamagitan ng "paghila" ng bahagi ng isang substring mula sa isang umiiral na string.

Gamit ang slice() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz";

var stringTwo = stringOne.slice(5, 10); // "fghij"

Gamit ang substring() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz";

var stringTwo = stringOne.substring(5, 10); // "fghij"

Para sa parehong (slice() at substring()) na mga pamamaraan, ang unang argumento ay ang posisyon ng character kung saan nagsisimula ang substring (nagbibilang mula sa 0), ang pangalawang argumento ay ang posisyon ng character kung saan nagtatapos ang substring, at ang ang character na itinalaga sa pangalawang argumento ay hindi kasama sa ibinalik na substring.

Gamit ang substr():

Var stringOne = "abcdefghijklmnopqrstuvwxyz";

var stringTwo = stringOne.substr(5, 10); // "fghijklmno"

Maaari mong suriin ang pagkakaroon ng isang pattern sa isang string gamit ang 2 pamamaraan.

Ang pamamaraan ng match() ay tinatawag sa isang string object, na nagpapasa ng isang regular na expression bilang argumento sa match() na paraan.

Var myString = "Gaano karaming kahoy ang maaaring i-chuck ng isang kahoy";

var myPattern = /.ood/;

var myResult = myString.match(myPattern); // ["wood"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // "Gaano karaming kahoy ang maaaring i-chuck ng isang wood chuck"

At ang exec() na pamamaraan ay tinatawag sa RegExp object, na nagpapasa sa string bilang argumento:

Var myString = "Gaano karaming kahoy ang maaaring i-chuck ng isang wood chuck";

var myPattern = /.huck/;

var myResult = myPattern.exec(myString); // ["chuck"] var patternLocation = myResult.index; // 27 var originalString = myResult.input // "Magkano ang wood chuck chuck"

Ang parehong mga pamamaraan ay nagbabalik sa unang paglitaw na tumutugma. Kung walang mahanap na tugma, NULL ay ibabalik. Kung ang regular na expression ay may flag na "g", ang resulta ay isang array na naglalaman ng lahat ng mga tugma.

Maaari mo ring gamitin ang search() na paraan, na kumukuha ng regular na expression bilang argumento at ibinabalik ang panimulang posisyon ng unang pattern na tumugma.

Var myString = "Ipagpalagay";

var patternLocation = myString.search(/ume/); // 3

Kung walang nakitang mga tugma, ang pamamaraan ay magbabalik -1.

Paghahambing ng dalawang string para sa kasunod na pag-uuri

Upang ihambing ang dalawang string batay sa pagkakasunud-sunod ng pag-uuri sa lokal, maaari mong gamitin ang pamamaraang localeCompare. Ang localeCompare method ay nagbabalik ng tatlong posibleng halaga.

MyString = "manok"; var myStringTwo = "itlog"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (maliban sa Chrome, na nagbabalik -2) whichCameFirst = myString.localeCompare("manok"); // 0 whichCameFirst = myString.localeCompare("mansanas"); // 1 (Nagbabalik ang Chrome ng 2)

Tulad ng ipinapakita sa itaas, isang negatibong halaga ang ibabalik kung ang orihinal na string ay pinagbukud-bukod bago ang string ng argumento kung ang string na argumento ay pinagbukud-bukod pagkatapos ng orihinal na string, +1 ay ibinalik. Kung ang null ay ibinalik, ang dalawang string ay katumbas.

Ngunit bilang isang patakaran, ang una, mas maikling paraan ay ginagamit. Sa unang kaso, awtomatikong kino-convert ng JavaScript ang primitive na uri ng variable sa isang String object kung kinakailangan.

Ang String object ay may malaking hanay ng mga katangian at pamamaraan kung saan maaari nating manipulahin ang mga string.

Ang pag-aari ng haba ay nagpapahiwatig ng haba ng string:

Var hello = "hello world"; console.log("Sa linyang "" + hello + "" " + hello.length + " characters");

Ang paraan ng repeat() ay nagbibigay-daan sa iyo na lumikha ng isang string sa pamamagitan ng pag-uulit ng isa pang string nang paulit-ulit. Ang bilang ng mga pag-uulit ay ipinasa bilang argumento:

Let hello = "hello"; console.log(hello.repeat(3)); // hello hello hello

Mga pattern ng hilera

Pinapayagan ka ng mga template ng string na magpasok ng iba't ibang mga halaga sa isang string. Upang gawin ito, ang mga linya ay nakapaloob sa mga pasulong na panipi:

Let name = "Tom"; let hello = `Hello $(pangalan)`; console.log(hello); // Hello Tom let age = 23; let info = `$(pangalan) ay $(edad) taong gulang`; console.log(impormasyon); // Si Tom ay 23 taong gulang

Upang magpasok ng isang halaga sa isang string, ito ay nakapaloob sa mga kulot na brace, na pinangungunahan ng isang dollar sign.

Gayundin, sa halip na mga halaga ng scalar, maaaring idagdag ang mga katangian ng mga kumplikadong bagay o mga resulta ng mga expression:

Let tom =( name: "Tom", edad: 25 ) let info = `$(tom.name) is $(tom.age) years old`; console.log(impormasyon); // Tom is 23 years old function sum(x, y)( return x + y; ) let a = 5, b = 4; hayaan ang resulta = `$(a) + $(b) = $(sum(a, b))`; console.log(resulta); // 5 + 4 = 9

Maghanap sa isang string

Upang maghanap ng mga string para sa isang partikular na substring, ginagamit ang indexOf() (index ng unang paglitaw ng substring) at lastIndexOf() (index ng huling paglitaw ng substring). Ang mga pamamaraang ito ay tumatagal ng dalawang parameter:

    Substring upang mahanap

    Isang opsyonal na parameter na tumutukoy sa kung aling character ang hahanapin ng isang substring sa isang string

Ang parehong mga pamamaraan ay nagbabalik ng index ng character kung saan nagsisimula ang substring sa string. Kung hindi natagpuan ang substring, ibabalik ang numero -1.

Let hello = "hello world. Bye peace"; let key = "mundo"; let firstPos = hello.indexOf(key); let lastPos = hello.lastIndexOf(key); console.log("Unang pangyayari: ", firstPos); // 7 console.log("Huling pangyayari: ", lastPos); // 17

Ang isa pang paraan - kasama ang() ay nagbabalik ng true kung ang string ay naglalaman ng isang tiyak na substring.

Let hello = "hello world. Bye peace"; console.log(hello.includes("world")); // true console.log(hello.includes("sandali")); // mali

Gamit ang pangalawang karagdagang parameter, matutukoy mo ang index kung saan magsisimula ang paghahanap para sa substring:

Let hello = "hello world. Bye peace"; console.log(hello.includes("world", 5)); // true console.log(hello.includes("hello", 6)); // mali

Pagpili ng substring

Upang i-cut ang isang substring mula sa isang string, gamitin ang substr() at substring() na mga pamamaraan.

Ang substring() na pamamaraan ay tumatagal ng dalawang parameter:

    index ng character sa string, simula kung saan dapat i-trim ang string

    index kung saan dapat putulin ang string

let hello = "hello world. Bye peace"; let world = hello.substring(7, 10); // mula ika-7 hanggang ika-10 index console.log(world); // mundo

Ang pamamaraang substr() ay tumatagal din ng panimulang index ng substring bilang unang parameter, at ang haba ng substring na puputulin bilang pangalawang parameter:

Let hello = "hello world. Bye peace"; let bye = hello.substr(12, 4); console.log(bye); // Bye

Kung ang pangalawang parameter ay hindi tinukoy, ang natitirang linya ay pinutol:

Let hello = "hello world. Bye peace"; let bye = hello.substr(12); console.log(bye); // bye peace

Pamamahala ng pagpaparehistro

Para palitan ang case, may mga paraan saLowerCase() (para sa pag-convert sa lower case) at sa UpperCase() (para sa pag-convert sa upper case).

Let hello = "Hello Tom"; console.log(hello.toLowerCase()); // hello Tom console.log(hello.toUpperCase()); // HI TOM

Pagkuha ng simbolo sa pamamagitan ng index

Upang makakuha ng isang partikular na character sa isang string ayon sa index, maaari mong gamitin ang charAt() at charCodeAt() na mga pamamaraan. Pareho sa mga pamamaraang ito ang index ng character bilang isang parameter:

Let hello = "Hello Tom"; console.log(hello.charAt(2)); // at console.log(hello.charCodeAt(2)); // 1080

Ngunit kung ibinalik ng charAt() method ang karakter mismo bilang resulta, ibinabalik ng charCodeAt() method ang numeric code ng character na ito.

Pag-alis ng mga puwang

Upang alisin ang mga puwang sa unahan at trailing mula sa isang string, gamitin ang trim() na paraan:

Let hello = "Hello Tom"; let beforeLength = hello.length; hello = hello.trim(); let afterLength = hello.length; console.log("Haba ng linya hanggang sa: ", beforeLength); // 15 console.log("Line length after: ", afterLength); // 10

Pinagsasama-samang Strings

Ang concat() na pamamaraan ay nagsasama-sama ng dalawang string:

Let hello = "Hello"; let world = "mundo"; hello = hello.concat(world); console.log(hello); // Hello World

Pagpapalit ng substring

Pinapalitan ng paraan ng replace() ang unang paglitaw ng isang substring sa isa pa:

Let hello = "Magandang hapon"; hello = hello.replace("araw", "gabi"); console.log(hello); // Magandang gabi

Ang unang parameter ng pamamaraan ay tumutukoy kung aling substring ang dapat palitan, at ang pangalawang parameter ay tumutukoy kung aling substring ang dapat palitan.

Paghati ng string

Ang split() na paraan ay hinahati ang isang string sa isang hanay ng mga substring gamit ang isang tinukoy na delimiter. Ang separator ay isang string na ipinapasa sa pamamaraan:

Var message = "Maganda ang panahon ngayon"; var stringArray = message.split(" "); para sa(var str sa stringArray) console.log(stringArray);

Output ng browser

Ang ganda ng panahon ngayon

Sinusuri ang simula at dulo ng isang linya

Ang startsWith() method ay nagbabalik ng true kung ang string ay magsisimula sa isang partikular na substring. At ang endsWith() method ay nagbabalik ng true kung ang string ay nagtatapos sa isang partikular na substring.

Let hello = "hayaan mo akong magsalita mula sa aking puso"; console.log(hello.startsWith("hayaan")); // true console.log(hello.startsWith("Hayaan")); // false console.log(hello.startsWith("lets")); // false console.log(hello.endsWith("puso")); // true console.log(hello.startsWith("bart")); // mali

Ang kaso ay gumaganap ng isang papel dito, at mula sa halimbawa sa itaas ay makikita natin na ang "hayaan" ay hindi katumbas ng "Hayaan".

Pinapayagan ka ng karagdagang pangalawang parameter na tukuyin ang index (para sa startsWith - ang index mula sa simula, at para sa endsWith - ang index mula sa dulo ng string) na nauugnay kung saan gagawin ang paghahambing:

Let hello = "hayaan mo akong magsalita mula sa aking puso"; console.log(hello.startsWith("ako", 4)); // true, "me" - 4th index mula sa simula ng line console.log(hello.startsWith("my", hello.length-8)); // true, "my" - ika-8 na index mula sa dulo

Ang Number object ay isang wrapper object na nagbibigay-daan sa iyo upang gumana sa mga numeric na halaga bilang mga bagay. Ang isang Number object ay nilikha gamit ang Number() constructor.

Sa konteksto ng isang regular na function (iyon ay, nang walang bagong operator), ang Number object ay maaaring gamitin upang magsagawa ng isang tahasang uri ng cast:

Var num = Numero("32");

Syntax var foo = bagong Numero(halaga); Mga Parameter: foo Variable kung saan itinalaga ang Number object.
value Ang numeric na halaga (o iba pang maaaring i-cast sa isang numero) na dadalhin ng bagay sa paggawa. Kung hindi mako-convert ang argumento sa isang numero, ibinabalik ang NaN.Mga Katangian ng Pamamaraan
Paglalarawan ng Ari-ariantagabuo
Tumutukoy sa function ng constructor na ginamit upang lumikha ng object.MAX_VALUE
Kinakatawan ang pinakamalaking kinakatawan na positibong numero.MIN_VALUE
Kinakatawan ang pinakamaliit na kinakatawan na positibong numero - iyon ay, ang positibong numero na pinakamalapit sa zero (iyon ay hindi pa zero).Partikular na nangangahulugang "Not-a-Number" (hindi isang numero).
POSITIVE_INFINITYEspesyal na kahulugan upang kumatawan sa positibong infinity. Ibinalik kapag ang kinakalkula na halaga ay mas malaki kaysa sa pinakamalaking pinapayagang halaga.
prototypeTumutukoy sa isang bagay na isang prototype para sa mga bagay na may uri ng Numero. Ang property na ito ay ginagamit ng interpreter kapag ang isang function ay ginagamit bilang isang constructor upang lumikha ng isang bagong object. Ang anumang bagay na nilikha gamit ang isang constructor ay nagmamana ng lahat ng mga katangian ng bagay na isinangguni ng prototype property.

Ang isNaN function ay nagbabalik lamang ng dalawang halaga: alinman sa True - true o False - false .

Kung ang variable ay hindi naglalaman ng isang numero, ang isNaN function ay magbabalik ng True - dapat mong bigyang-pansin ito (NOT A NUMBER is TRUE. isNaN translates as not a number). Kung ang variable ay naglalaman ng isang numero, ito ay magbabalik ng Mali.

var name = "Anton" ; /* string object */
var edad = 35 ; /* numeric object */

if(isNaN (name )) /* Kung ang variable ng pangalan ay hindi isang numero, ito ay True */
{
document.write(pangalan + " ay hindi isang numero")
}
else /* otherwise - Mali */
{
document.write(pangalan + " ay isang numero")
}

Tandaan na ang isNaN ay isang built-in na javascript function.

, salamat sa kung saan, at gamit ang isNaN function, isang pagsusuri ay isinagawa: kung ang halaga ng variable ay isang numero o hindi.

Bilang karagdagan, dito kakailanganin mong tandaan ang paksa ng mga array at loop at mga function sa javascript.

var randSimbol = ["Gatas" , 77 , 11 , "Honey" , - 88 ];

function number (randSimbol)
{
para sa(i = 0 ; i< randSimbol .length ; i ++ ) /* Составляем цикл для перебора всех элементов масива */
{
if(isNaN (randSimbol )) /* Kung ang array element ay hindi isang numero (ito ay True), kung gayon... */
{
document.write(randSimbol + " ay hindi isang numero

" )
}
else /* Kung hindi, ang array element ay isang numero (at ito ay False).... */
{
document.write(randSimbol + " ay isang numero

" )
}
}
}

numero(randSimbol); /* Tawagan ang function */

Ito ay kung paano gumagana ang isNaN function kapag inilapat sa numeric Number object sa Javascript.

Ang mga paraan ng numero ay makakatulong sa iyo na magtrabaho sa mga numero.

Bilang ng mga pamamaraan at katangian

Ang mga primitive na halaga (halimbawa, 3.14 o 2014) ay hindi maaaring magkaroon ng mga katangian at pamamaraan (dahil hindi sila bagay).

Ngunit sa JavaScript, ang mga pamamaraan at katangian ay magagamit din sa mga primitive na halaga dahil tinatrato ng JavaScript ang mga primitive na halaga bilang mga bagay kapag nagsasagawa ng mga pamamaraan at katangian.

toString() Paraan

toString() ay nagbabalik ng isang numero bilang isang string.

Maaaring gamitin ang lahat ng paraan ng numero sa anumang uri ng numero (mga literal, variable o expression):

halimbawa

var x = 123;
x.toString(); // nagbabalik ng 123 mula sa variable x
(123).toString(); // nagbabalik ng 123 mula sa literal na 123
(100 + 23).toString(); // nagbabalik ng 123 mula sa expression na 100 + 23

Subukan ito sa iyong sarili " toExponential() Method

toExponential() ay nagbabalik ng isang string na may numerong bilugan at nakasulat gamit ang exponential notation.

Tinutukoy ng parameter ang bilang ng mga character pagkatapos ng decimal point:

Opsyonal ang parameter. Kung hindi mo ito tinukoy, hindi ibi-round ng JavaScript ang numero.

toFixed() Method

Ang toFixed() ay nagbabalik ng string na may nakasulat na numero na may tinukoy na bilang ng mga decimal na lugar:

Ang toFixed(2) ay mainam para sa pagtatrabaho gamit ang pera.

Paraan ng toPrecision().

toPrecision() ay nagbabalik ng isang string na may isang numero na nakasulat mula sa isang tiyak na haba:

halimbawa

var x = 9.656;
x.toPrecision(); // nagbabalik ng 9.656
x.toPrecision(2); // nagbabalik 9.7
x.toPrecision(4); // nagbabalik ng 9.656
x.toPrecision(6); // nagbabalik ng 9.65600

Subukan ito sa iyong sarili " valueOf() Method

valueOf() ay nagbabalik ng numero bilang isang numero.

halimbawa

var x = 123;
x.valueOf(); // nagbabalik ng 123 mula sa variable x
(123).valueOf(); // nagbabalik ng 123 mula sa literal na 123
(100 + 23).valueOf(); // nagbabalik ng 123 mula sa expression na 100 + 23

Subukan mo sarili mo"

Sa JavaScript, ang isang numero ay maaaring isang elemental na halaga (typeof = number) o isang object (typeof = object).

Ang valueOf() na paraan ay ginagamit sa loob ng JavaScript upang i-convert ang mga numero ng object sa mga primitive na halaga.

Walang dahilan para gamitin ito sa iyong code.

Ang lahat ng uri ng data ng JavaScript ay may valueOf() at toString() na pamamaraan.

Pag-convert ng mga Variable ayon sa numero

Mayroong 3 pamamaraan ng JavaScript na maaaring magamit upang i-convert ang mga variable sa mga numero:

  • Number() na paraan
  • parseInt() na pamamaraan
  • parseFloat() na pamamaraan

Ang mga pamamaraang ito ay hindi mga paraan ng numero, ngunit mga pangkalahatang pamamaraan ng JavaScript.

Mga Pandaigdigang Pamamaraan

Maaaring gamitin ang mga pangkalahatang pamamaraan ng JavaScript sa lahat ng uri ng data ng JavaScript.

Ito ang mga pinaka-angkop na pamamaraan kapag nagtatrabaho sa mga numero:

Paraan ng Numero ().

Number() ay maaaring gamitin upang i-convert ang mga variable ng JavaScript sa mga numero:

halimbawa

x = totoo;
Numero(x); // nagbabalik 1
x = mali;
Numero(x); // nagbabalik ng 0
x = bagong Petsa();
Numero(x); // nagbabalik 1404568027739
x = "10"
Numero(x); // nagbabalik 10
x = "10 20"
Numero(x); // nagbabalik ng NaN

Subukan mo sarili mo"

Ginamit sa Date() , ibinabalik ng Number() method ang bilang ng mga millisecond na lumipas mula noong 1/1/1970.

parseInt() Paraan

parseInt() parses ang string at nagbabalik ng isang integer. Pinapayagan ang mga puwang. Ang unang numero lamang ang ibinalik:

halimbawa

parseInt("10"); // nagbabalik 10
parseInt("10.33"); // nagbabalik 10
parseInt("10 20 30"); // nagbabalik 10
parseInt("10 taon"); // nagbabalik 10
parseInt("10 taon"); // nagbabalik ng NaN

Subukan ito sa iyong sarili " parseFloat() Method

parseFloat() parses ang string at nagbabalik ng isang numero. Pinapayagan ang mga puwang. Ang unang numero lamang ang ibinalik:

halimbawa

parseFloat("10"); // nagbabalik 10
parseFloat("10.33"); // nagbabalik 10.33
parseFloat("10 20 30"); // nagbabalik 10
parseFloat("10 taon"); // nagbabalik 10
parseFloat("10 taon"); // nagbabalik ng NaN

Subukan mo sarili mo"

Kung hindi ma-convert ang numero, ibabalik ang NaN (hindi numero).

Mga Katangian ng Numero

Ang pag-aari ng numero ay nabibilang sa isang bilang ng mga bagay sa wrapper ng JavaScript na tinatawag na Number .

Maa-access lang ang mga property na ito bilang Numero .MAX_VALUE .

Gamit myNumber.MAX_VALUE, kung saan myNumber ang isang variable, expression o halaga, ay magbabalik ng hindi natukoy:

Buong JavaScript Number Reference

Para sa kumpletong tulong, pumunta sa aming Complete JavaScript reference number.



MGA KAUGNAY NA ARTIKULO