Js string conversion. Pag-convert ng Mga Uri ng Data sa JavaScript

Sa JavaScript, ang mga halaga ay maaaring ma-convert nang malaya (hayagan at hindi malinaw) mula sa isang uri patungo sa isa pa. Halimbawa, kung inaasahan ng isang operator na makatanggap ng isang halaga ng isang partikular na uri, at ipinasa ang isang halaga ng isa pang uri, awtomatikong susubukan ng interpreter na magsagawa ng mga conversion sa nais na uri:

Console.log(10 + " machines"); // "10 kotse". Ang numero ay tahasang na-convert sa isang string console.log("7" * "4"); // 28. Ang parehong mga string ay implicitly na na-convert sa mga numero

Implicit na conversion- ito ay kapag ang interpreter ay awtomatikong nagsasagawa ng uri ng conversion, iyon ay, nang walang paglahok ng programmer. Tahasang conversion- ito ay kapag ang conversion ay ginawa ng programmer mismo. Ang tahasang conversion ay tinatawag din uri ng paghahagis:

Console.log("7" * "4"); // 28. Implicit conversion console.log(Number("7") * Number("4")); // 28. Tahasang pagbabalik-loob

Inilalarawan ng talahanayan sa ibaba kung paano kino-convert ng JavaScript ang mga halaga mula sa isang uri patungo sa isa pa. Ang mga walang laman na cell ay tumutugma sa mga sitwasyon kung saan walang kinakailangang conversion:

Para sa tahasang conversion sa mga simpleng uri, ginagamit ang mga sumusunod na function: Boolean(), Number(), String(). Para sa implicit na conversion, ginagamit ng interpreter ang parehong mga function na ginagamit para sa tahasang conversion.

Para sa tahasang conversion, maaari kang gumamit ng mga operator sa halip na mga function. Halimbawa, kung ang isa sa mga operand ng + operator ay isang string, ang isa pang operand ay mako-convert din sa isang string. Kino-convert ng unary + operator ang operand nito sa isang numero. Unary operator! kino-convert ang operand sa isang boolean na halaga at binabaligtad ito. Ang lahat ng ito ay naging dahilan para sa paglitaw ng mga sumusunod na natatanging paraan ng uri ng conversion na maaaring matagpuan sa pagsasanay:

X + "" // Pareho sa String(x) +x // Pareho sa Number(x). Maaari mo ring makita ang x - 0 !!x // Kapareho ng Boolean(x)

I-convert sa mga numero

Ang Number() function ay nagko-convert ng mga halaga ayon sa mga sumusunod na panuntunan:

• Ang mga halaga ng boolean na true at false ay na-convert sa 1 at 0 ayon sa pagkakabanggit.
• Ang mga numero ay ibinalik nang hindi nagbabago.
• Ang halaga na null ay na-convert sa 0 .
• Ang hindi natukoy na halaga ay na-convert sa NaN.

Mayroong mga espesyal na panuntunan para sa mga string:

• Kung ang isang string ay naglalaman lamang ng mga digit na may leading + o - sign, o walang sign, ito ay palaging kino-convert sa isang integer decimal number. Ang mga nangungunang zero ay binabalewala, halimbawa ang "0011" ay na-convert sa 11.
• Kung ang string ay isang floating-point na numero na may leading + o - o unsigned sign, ito ay iko-convert sa katumbas na floating-point na numero (ang mga nangungunang zero ay binabalewala din).
• Kung ang string ay isang hexadecimal na numero, ito ay iko-convert sa katumbas na decimal integer.
• Kung walang laman ang string, mako-convert ito sa 0.
• Kung ang string ay naglalaman ng isang bagay na naiiba mula sa mga nakaraang opsyon, ito ay na-convert sa NaN.
• Ang valueOf() na paraan ay tinatawag sa mga bagay, at ang halaga na ibinabalik nito ay awtomatikong kino-convert ayon sa mga nakaraang panuntunan. Kung ang conversion na ito ay nagreresulta sa NaN , ang toString() na paraan ay tinatawag at ang mga panuntunan para sa pag-convert ng mga string sa mga numero ay inilalapat.

Ang unary operator + at - ay sumusunod sa parehong mga patakaran tulad ng Number() function.

Pag-convert sa Boolean Values

Ang Boolean() function ay nagko-convert ng value sa Boolean na katumbas nito:

• Ang mga sumusunod na halaga ay na-convert sa false: undefined , null , 0 , -0 , NaN , "" .
• Ang mali ay ibinabalik nang hindi nababago.
• Ang lahat ng iba pang mga halaga ay na-convert sa true.

I-convert sa mga string

Ang String() function ay nagko-convert ng mga halaga alinsunod sa mga sumusunod na panuntunan:

• Para sa lahat ng mga halaga maliban sa null at hindi natukoy, ang toString() na pamamaraan ay awtomatikong tinatawag at isang string na representasyon ng halaga ay ibinalik.
• Para sa null, ang string na "null" ay ibinalik.
• Para sa value na hindi natukoy, ang string na "undefined" ay ibinalik.

Pag-convert ng mga Simpleng Uri sa Mga Bagay

Upang i-convert ang mga simpleng halaga sa mga bagay, ang Boolean() , Number() , String() constructors ay ginagamit:

Var oNum = bagong Numero(3); var oStr = bagong String("1.2"); var oBool = bagong Boolean(totoo); alerto(uri ng oNum); // "object" alert(typeof oStr); // "object" alert(typeof oBool); // "bagay"

Pag-convert ng mga bagay sa mga simpleng halaga

Ang lahat ng mga object ay nagmamana ng dalawang paraan ng conversion: toString() at valueOf() .

Ang toString() method ay nagbabalik ng string na representasyon ng object. Bilang default, hindi ito nagbabalik ng anumang kawili-wili:

Alert((x: 1).toString()); // ""

Ang ilang mga uri ay may mas espesyal na mga bersyon ng toString() na pamamaraan. Halimbawa, ang toString() na pamamaraan sa isang array ay nagko-convert ng lahat ng mga elemento nito sa mga string at pagkatapos ay pinagsama ang mga ito sa isang string, na naglalagay ng mga kuwit sa pagitan ng mga ito:

Alert(.toString()); // "1,2,3"

Ang layunin ng valueOf() na pamamaraan ay hindi gaanong malinaw na tinukoy: ito ay dapat na mag-convert ng isang bagay sa simpleng halaga na kumakatawan dito, kung mayroong ganoong halaga. Ang mga bagay ay likas na pinagsama-samang mga halaga, at karamihan sa mga bagay ay hindi maaaring katawanin bilang isang solong simpleng kahulugan, kaya bilang default ang valueOf() na pamamaraan ay hindi nagbabalik ng isang simpleng halaga, ngunit isang sanggunian dito:

Alert(typeof (x:2).valueOf()); // "bagay"

Kapag nagko-convert ng isang bagay sa isang string, ginagawa ng interpreter ng JavaScript ang sumusunod:

• Kung ang isang bagay ay may toString() na pamamaraan, tinatawag ito ng interpreter. Kung nagbabalik ito ng isang simpleng halaga, iko-convert ng interpreter ang halaga sa isang string (kung hindi ito isang string) at ibabalik ang resulta ng conversion.
• Kung ang object ay walang toString() na pamamaraan o ang pamamaraan ay hindi nagbabalik ng isang simpleng halaga, pagkatapos ay ang interpreter ay nagsusuri para sa pagkakaroon ng isang valueOf() na pamamaraan. Kung tinukoy ang pamamaraang ito, tatawagin ito ng interpreter. Kung nagbabalik ito ng isang simpleng halaga, iko-convert ng interpreter ang halagang iyon sa isang string (kung hindi ito isang string) at ibabalik ang resulta ng conversion.

Kapag nagko-convert ng isang bagay sa isang numero, ginagawa ng interpreter ang parehong bagay, ngunit sinusubukan muna ang valueOf() method:

• Kung ang isang object ay may valueOf() method na nagbabalik ng simpleng value, iko-convert ng interpreter (kung kinakailangan) ang value na iyon sa isang numero at ibabalik ang resulta.
• Kung ang object ay walang valueOf() method o ang method ay hindi nagbabalik ng simpleng value, ang interpreter ay magsusuri ng pagkakaroon ng toString() method. Kung ang object ay may toString() na paraan na nagbabalik ng isang simpleng halaga, ang interpreter ay nagsasagawa ng conversion at nagbabalik ng resultang halaga.
• Kung hindi, ang interpreter ay naghihinuha na alinman sa toString() o valueOf() ay hindi makakakuha ng isang simpleng halaga at magtataas ng TypeError.

Ang toString() at valueOf() na mga pamamaraan ay binabasa/isinulat, kaya maaari mong i-override ang mga ito at tahasang tukuyin kung ano ang ibabalik kapag nagko-convert:

Var obj = (); obj.toString = function() ( ibalik ang "object"; ); alert("Ito ay " + obj); // "Ito ay isang bagay"

Ang parseInt() function na nag-parse ng string argument at nagbabalik ng integer ng tinukoy na radix (ang base sa mathematical numeral system).

Ang pinagmulan para sa interactive na halimbawang ito ay naka-imbak sa isang GitHub repository. Kung gusto mong mag-ambag sa proyekto ng mga interactive na halimbawa, paki-clone ang https://github.com/mdn/interactive-examples at padalhan kami ng pull request.

Syntax

Mga Parameter

default sa 10 !

Ipinapaliwanag ng mas detalyado kung ano ang mangyayari kapag hindi ibinigay ang radix.

Ibalik ang halaga NaN Kung ang radix ay mas maliit sa 11 , at ang unang character na hindi whitespace ay hindi mako-convert sa isang numero,

Ang global NaN property ay isang value na kumakatawan sa Not-A-Number.

ay ibinalik.

Paglalarawan

Kino-convert ng parseInt function ang una nitong argumento sa isang string, pina-parse ang string na iyon, pagkatapos ay nagbabalik ng integer o NaN .

Kung hindi NaN , ang return value ay ang integer na unang argumento na kinuha bilang isang numero sa tinukoy na radix . (Halimbawa, isang radix ng 10 ang nagko-convert mula sa isang decimal na numero, 8 ang nagko-convert mula sa octal, 16 mula sa hexadecimal, at iba pa.)

Para sa mga lahi na higit sa 10, ang mga titik ng alpabetong Ingles ay nagpapahiwatig ng mga numerong higit sa 9. Halimbawa, para sa mga numerong hexadecimal (base 16), A hanggang F ang ginagamit. Kung ang parseInt ay nakatagpo ng isang character na hindi isang numeral sa tinukoy na radix , hindi nito pinapansin ito at ang lahat ng mga susunod na character at ibinabalik ang integer value na na-parse hanggang sa puntong iyon. Pinutol ng parseInt ang mga numero sa mga halaga ng integer. Pinahihintulutan ang mga puwang sa unahan at trailing. Dahil ginagamit ng ilang numero ang e character sa kanilang representasyon ng string (hal. radix Opsyonal Isang integer sa pagitan ng 2 at 36 na kumakatawan sa radix (ang base sa mathematical numeral system) ng string . Mag-ingat - ito ay gamitin bilang pamalit sa Math.floor().

Naiintindihan ng parseInt ang eksaktong dalawang palatandaan: + para sa positibo, at - para sa negatibo (mula noong ECMAScript 1). Ginagawa ito bilang paunang hakbang sa pag-parse pagkatapos alisin ang whitespace. Kung walang makikitang mga palatandaan, lilipat ang algorithm sa sumusunod na hakbang; kung hindi, inaalis nito ang sign at pinapatakbo ang number-parsing sa natitirang string.

Kung ang radix ay hindi natukoy , 0 , o hindi natukoy, ipinapalagay ng JavaScript ang sumusunod:

1. Kung ang input string ay nagsisimula sa "0x" o "0X" (isang zero, na sinusundan ng lowercase o uppercase X), ang radix ay ipinapalagay na 16 at ang natitirang string ay na-parse bilang isang hexidecimal number.
2. Kung ang input string ay nagsisimula sa "0" (isang zero), ang radix ay ipinapalagay na 8 (octal) o 10 (decimal). Eksakto kung aling radix ang napili ay nakasalalay sa pagpapatupad. Nililinaw ng ECMAScript 5 na 10 (decimal) dapat gamitin, ngunit hindi pa ito sinusuportahan ng lahat ng browser. Dahil dito, palaging tukuyin ang isang radix kapag gumagamit ng parseInt.
3. Kung ang input string ay nagsisimula sa anumang iba pang halaga, ang radix ay 10 (decimal).

Kung ang unang character ay hindi mako-convert sa isang numero, ibabalik ng parseInt ang NaN maliban kung ang radix ay mas malaki sa 10 .

Para sa mga layunin ng aritmetika, ang halaga ng NaN ay hindi isang numero sa anumang radix. Maaari mong tawagan ang isNaN function upang matukoy kung ang resulta ng parseInt ay NaN . Kung ang NaN ay ipapasa sa mga pagpapatakbo ng aritmetika, ang resulta ng operasyon ay magiging NaN .

Upang i-convert ang isang numero sa literal na string nito sa isang partikular na radix, gamitin iyonNumber .toString(radix) .

Mga halimbawa

Gamit ang parseInt

Ang mga sumusunod na halimbawa ay nagbabalik lahat ng 15:

ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // ngunit `parseInt(015, 10)` ay ibalik ang 13 parseInt(15.99, 10) parseInt("15,123", 10) parseInt("FXX123", 16) parseInt("1111", 2) parseInt("15 * 3", 10) parseInt("15e2", 10) parseInt("15px", 10) parseInt("12", 13)

Ang mga sumusunod na halimbawa ay nagbabalik lahat ng NaN:

ParseInt("Hello", 8) // Not a number at all parseInt("546", 2) // Ang mga digit maliban sa 0 o 1 ay hindi wasto para sa binary radix

Ang mga sumusunod na halimbawa ay nagbabalik lahat -15:

ParseInt("-F", 16) parseInt("-0F", 16) parseInt("-0XF", 16) parseInt(-15.1, 10) parseInt("-17", 8) parseInt("-15", 10) parseInt("-1111", 2) parseInt("-15e1", 10) parseInt("-12", 13)

Ang mga sumusunod na halimbawa ay nagbabalik lahat ng 4:

ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Ang napakalaking numero ay nagiging 4 parseInt(0.00000000000434, 10) // Ang napakaliit na numero ay nagiging 4

Ang sumusunod na halimbawa ay nagbabalik ng 224:

ParseInt("0e0", 16) parseInt("123_456") // 123

Mga interpretasyong octal na walang radix

Bagama't nasiraan ng loob ng ECMAScript 3 at ipinagbabawal ng ECMAScript 5, binibigyang-kahulugan ng maraming pagpapatupad ang isang numeric string na nagsisimula sa isang nangungunang 0 bilang octal. Ang mga sumusunod ay maaaring may octal na resulta, o maaari itong magkaroon ng decimal na resulta. Palaging tukuyin ang isang radix upang maiwasan ang hindi mapagkakatiwalaang pag-uugali.

ParseInt("0e0") // 0 parseInt("08") // 0, dahil ang "8" ay hindi isang octal digit.

Inaalis ng ECMAScript 5 ang octal na interpretasyon

Hindi na pinapayagan ng ECMAScript 5 na detalye ng function na parseInt ang mga pagpapatupad na ituring ang mga String na nagsisimula sa isang 0 na character bilang mga octal na halaga. Sinasabi ng ECMAScript 5:

Ang parseInt function ay gumagawa ng isang integer na halaga na idinidikta ng interpretasyon ng mga nilalaman ng string argument ayon sa tinukoy na radix. Binabalewala ang nangungunang puting espasyo sa string. Kung ang radix ay hindi natukoy o 0 , ito ay ipinapalagay na 10 maliban kung ang numero ay nagsisimula sa mga pares ng character na 0x o 0X , kung saan ang isang radix na 16 ay ipinapalagay.

Ito ay naiiba sa ECMAScript 3, na pinanghinaan ng loob ngunit pinapayagan ang octal na interpretasyon.

Maraming mga pagpapatupad ang hindi nagpatibay ng gawi na ito noong 2013, at dahil dapat na suportahan ang mga mas lumang browser, palaging tukuyin ang isang radix.

Isang mas mahigpit na function ng parse

Minsan ay kapaki-pakinabang na magkaroon ng mas mahigpit na paraan upang i-parse ang mga integer.

Makakatulong ang mga regular na expression:

Function filterInt(value) ( ​​​​if (/^[-+]?(\d+|Infinity)$/.test(value)) ( return Number(value) ) else ( return NaN ) ) console.log(filterInt( "421")) // 421 console.log(filterInt("-421")) // -421 console.log(filterInt("+421")) // 421 console.log(filterInt("Infinity")) // Infinity console.log(filterInt("421e+0")) // NaN console.log(filterInt("421hop")) // NaN console.log(filterInt("hop1.61803398875")) // NaN console .log (filterInt("1.61803398875")) // NaN

Mga pagtutukoy

Pagkatugma sa browser

Ang talahanayan ng compatibility sa page na ito ay nabuo mula sa structured data. Kung gusto mong mag-ambag sa data, pakitingnan ang https://github.com/mdn/browser-compat-data at padalhan kami ng pull request.

I-update ang data ng compatibility sa GitHub

Walang pagkakaiba kung anong uri ng variable ang ginagamit sa expression. Kung mathematical ang expression, ang lahat ng mga variable nito ay awtomatikong bibigyang-kahulugan bilang numeric. Kung pinoproseso ang mga string, ituturing na mga string ang lahat ng "kalahok" ng expression. Gayunpaman, ang JavaScript string-to-number na gawain ay umiiral sa isang mas malawak na konteksto.

Mga Paraan ng JavaScript para sa Pag-convert ng mga String sa Mga Numero

Ang arsenal ng mga pamamaraan para sa pag-convert ng mga string sa mga numero ay hindi malaki, ngunit ito ay sapat sa lahat ng mga simpleng kaso. Narito ang JavaScript (lalo na para sa mga nagsisimula) ay ang landas mula sa simple hanggang sa kumplikado gamit ang mga praktikal na halimbawa.

Ang halimbawa ay naglalarawan ng apat na magkakaibang mga string. Sa unang bloke ng output, ang uri ng bawat isa variable function typeof ay tinukoy bilang string. Ang bawat string ay napakasimpleng iko-convert sa isang numero. Sa pangalawang bloke ng output, ang mga pagbabago sa mga variable pagkatapos ng conversion ay makikita ang kanilang uri ay naging isang numero. Ang halimbawa ng conversion ng JavaScript parseFloat ay partikular na naglalarawan: ito ay "12e+3" at naging "12000".

Ang mga pagbabago kapag nagko-convert ng string sa isang numero ay maaaring maging makabuluhan! Ngunit ang mga unang character lang ang mahalaga: dapat ay numeric ang mga ito. Kung walang mga digit na character, ang magiging resulta ay NaN.

Ang reverse conversion ng isang string na "naging" isang numero ay hindi palaging parehong string. Maaaring gamitin ang puntong ito upang suriin ang kawastuhan ng pagpasok ng numerical na impormasyon.

Mga karaniwang paraan ng conversion

May mga integer at may mga fractional na numero, ayon sa pagkakabanggit, ang JavaScript ay nagko-convert ng string sa isang numero sa pamamagitan ng:

• parseInt;
• parseFloat.

Ang pangkalahatang kaso ay ipinatupad sa pamamagitan ng paggamit ng string sa isang simpleng mathematical expression.

Sapat na maglagay ng "+" sign sa harap ng string ng mga character at, kung naglalaman ito ng isang numero, kung gayon ang resulta ng expression ay isang numero. Ang halaga ng isang variable ay maaaring magbago, ngunit ang uri ay palaging magbabago: typeof ay magpapakita ng numero, hindi string. Mahalagang maunawaan na ang paggamit ng na-convert na variable sa isang string na expression ay maaaring magdulot ng ganap na kakaibang resulta.

Ang JavaScript para sa mga nagsisimula sa kontekstong ito ay napakasimple. Mas mahirap intindihin ang pagpapatakbo ng integer conversion gamit ang pasrseInt method, dahil awtomatiko itong gumagana sa decimal number system, ngunit maaaring bigyang-kahulugan ang string bilang octal o hexadecimal. Gayunpaman, ang sitwasyong ito ay hindi palaging nakasalalay sa pangalawang parameter, na nagpapahiwatig ng sistema ng numero.

Palaging gagawing numero ng JavaScript ang isang string, ngunit kung walang solong digital na character ang string sa simula ng linya, ang magiging resulta ay NaN.

Kinakailangang magkaroon ng pag-unawa sa mga sistema ng numero, kung paano sumulat ng hexadecimal (nagsisimula ang numero sa "0x") at mga octal na numero (nagsisimula ang numero sa "0").

Upang maunawaan ang mga nuances ng JavaScript parseFloat na pamamaraan, sapat na magkaroon ng ideya kung ano ang isang mathematical notation para sa isang tunay na numero.

Pagbabago para sa mga layunin ng pag-uuri

Ang JavaScript ay isang wika ng browser, kaya naman ito ay mas kritikal kaysa sa iba pang mga wika sa mga character sa labas ng pangunahing hanay ng Latin na alpabeto at mga numero. Ang pag-uuri ay isang popular na operasyon. Ngunit hindi palaging makatuwirang magpadala ng data sa server para sa mga layunin ng pag-uuri, mas madali at mas praktikal na gawin ang trabaho nang lokal, sa browser.

Upang malutas ang problemang ito, maaari mong i-convert ang mga character ng isang string sa kanilang mga numeric code o magtalaga ng isang nakaayos na pagkakasunud-sunod ng mga numero sa mga titik at numero. Ang charCodeAt() na pamamaraan na inilapat sa isang string ay magtatalaga ng numeric na halaga 98 sa variable na iB, iyon ay, ang code ng letrang "b". Isinasaalang-alang na ang halaga ng code ng titik na "a" ay 97, maaari mong makuha ang mga numero ng lahat ng mga titik ng alpabetong Latin sa pataas na pagkakasunud-sunod sa mga maliliit at malalaking titik. Katulad din para sa mga titik ng alpabetong Ruso.

Ang aming sariling bersyon ng pag-uuri sa mga numero ay nagbibigay-daan sa iyo upang lumikha ng mga kinakailangang hanay ng mga character. Maaari mong, halimbawa, "muling ayusin" ang Cyrillic at Latin na alpabeto o paghaluin ang mga ito upang mag-iwan lamang ng mga titik na naiiba sa pagbabaybay, o magdagdag ng mga tab at space na character sa mga set.

Pagbubuo ng isang natatanging string number

Kung ang code ng letrang "a" ay 97, ang pagkakaiba sa pagitan ng letra at ng numerong 97 ay magbibigay ng natatanging numero ng letra sa alpabeto. Sa pamamagitan ng pagbubuod ng mga natatanging numero para sa bawat karakter ng isang string, mahirap makuha ang natatanging numero ng string na iyon.

Kung magtatalaga ka ng timbang sa bawat posisyon ng titik sa isang string, halimbawa, posisyon:

• 0 timbang 1;
• 1 timbang 10;
• 2 timbang 100;

pagkatapos ay sa pamamagitan ng pagpaparami ng natatanging numero ng bawat karakter sa string sa bigat ng posisyon kung saan ito matatagpuan, at pagsasama-sama ng lahat ng mga numero, maaari kang makakuha ng isang natatanging numero at gamitin ito bilang isa-sa-isang sulat sa orihinal string.

Ang conversion na ito ng isang string sa isang numero ay nababaligtad, iyon ay, maaari mong palaging makuha ang orihinal na string mula sa numero. Ang ganitong conversion ay kapaki-pakinabang dahil ang anumang operasyon ay maaaring gawin nang ligtas sa isang numero sa konteksto ng pag-encode, Cyrillic at iba pang lokal na tampok ng pahina ng site, lugar ng aplikasyon, at bansa ng bisita.

"Lumalaki" na mga tagapili ng pahina ng site

Kadalasan ang gawain ay lumitaw sa paglikha ng mga tagapili sa mga pahina ng website, ang mga halaga na hindi maaaring tukuyin nang maaga, ngunit sa paglipas ng panahon sila ay pupunan. Sa pinakaunang aplikasyon, ang isang walang laman na tagapili ay magagamit para sa unang bisita na magpasok ng impormasyon.

Ang bawat bagong input ng isang string ng impormasyon sa tagapili (ng sinumang bisita) ay binago sa isang numero, na, kasama ang orihinal, ay ipinadala sa server para sa imbakan. Kapag nagsimula ang isang bagong session o may dumating na bagong bisita, wala nang laman ang selector. Kapag na-load ang page, darating ito sa browser na may walang laman na tagapili.

Para sa bawat bagong value ng selector, isang beses lang ito ipapadala sa server para sa storage, at isang beses lang ito magtatalaga ng natatanging numeric code.

Upang malutas ang problemang ito, hindi magagamit ang JavaScript string to number method. Ang mga karaniwang pamamaraan na parseInt at parseFloat ay idinisenyo para sa iba pang mga gamit, ngunit maaari kang makabuo ng isang algorithm para sa hindi malabo na pag-convert ng isang string sa isang numero, at hindi kinakailangang isang invertible. Sapat na na ang conversion algorithm ay hindi mauulit sa iba't ibang hanay ng mga character sa isang string.

Pag-optimize ng trapiko at analytics

Kapag gumagawa ng page, gumagamit ang developer ng malaking halaga ng impormasyon. Payagan ang bisita na magpasok ng impormasyon - magandang paraan babaan ang rating ng site dahil sa hindi magandang functionality nito at binigo ang bisita.

Sa pamamagitan ng pagtatalaga ng tagapangasiwa ng kaganapan sa anyo ng isang function ng JavaScript sa mga aksyon ng bisita para sa ilang partikular na bloke ng impormasyon, maaari kang bumuo ng isang filter na magbibigay-daan sa bisita na tumpak na magtakda ng layunin, hanapin ang kinakailangang impormasyon, at makuha ang nais na solusyon.

Ang pagbabago ng impormasyon ng string dito ay maaaring maging arbitraryong malaki sa bahagi ng string at napakaliit sa bahagi ng numero. Sa madaling salita, ang developer ay nagko-convert ng JavaScript string sa isang numero gamit ang kanyang sariling algorithm. Ang bisita ay nagmamanipula ng naiintindihan na impormasyon, at ang pinakamababang halaga ng data - isang numero - ay ipinadala sa server.

Ang dynamics ng isang hanay ng mga numero para sa lahat ng mga bisita sa konteksto ng tiyak na alam na impormasyon ay nagbibigay-daan sa isa pang function ng JavaScript (hindi isang handler), na tinawag ang tugon ng server sa pamamagitan ng mekanismo ng AJAX, upang mabilis na maibigay sa lahat ng mga bisita ang kinakailangang impormasyon nang sabay-sabay sa real time . Ito ay kung paano gumagana ang sistema.

Ang pagpipiliang ito para sa pag-convert ng JavaScript string sa isang numero ay napakapopular sa pagbuo ng mga online na laro, interactive na kumperensya, instant messaging, at iba pa.

Instrumental na aplikasyon ng mga pagbabago

Ang JavaScript at CSS sa konteksto ng pagpoproseso ng numeric na impormasyon ay nagbibigay-daan sa iyong kontrolin ang pagpapakita ng isang pahina nang walang paglahok sa server. Ang mga panuntunan ng CSS ay binuo bilang mga substring, nang paulit-ulit. Karaniwan ang parameter ay isang numero na sinusundan ng ilang mga titik (halimbawa, "px", "pt", "em", ...). Ang parameter ay isang substring sa panuntunan, at ang panuntunan ay isang substring sa klase o istilo ng identifier.

JavaScript recursion.Substring.Substring... hinahanap ang nais na numero, kino-convert ito mula sa isang string patungo sa isang numero, binabago ito at isinusulat ito pabalik sa tamang lugar. Awtomatikong nagbabago ang panuntunan. Ito ay simple at maginhawa, walang paglahok sa server.

Kamusta mahal na mga mambabasa. Ngayon ay isusulat ko kung paano ito na-convert sa javascript string sa numero. Ginagawa ito gamit ang function na Numero, ngayon ay ipapakita ko ang paggamit nito sa isang halimbawa.
Iminumungkahi ko ring panoorin ang bersyon ng video ng artikulong ito:

Kaunti tungkol sa mga uri ng data

Tulad ng alam mo, ang javascript ay may numeric at string na mga uri ng data. Subukan nating lumikha ng dalawang variable kung saan iimbak natin ang mga numero, at pagkatapos ay ipakita ang resulta sa screen.

Var a = 5; var b = 12; document.write(a + b);

Ano ang magiging resulta? 17, na ipinakita sa amin ng browser. Kaya ito ay numeric data, kaya matagumpay na naidagdag ito ng browser. Ngayon, lumikha tayo ng dalawang iba pang mga variable, kung saan ilalagay natin ang parehong mga halaga, ngunit sa mga panipi. Ipaalala ko sa iyo na ang lahat ng mga linya sa javascript ay nakasulat sa mga panipi.

Var c = "5"; var d = "12"; document.write("
" + c + d);

Ngayon ay isinasaalang-alang ng browser ang aming data bilang mga string at kung idagdag namin ang mga ito, pagkatapos ay dalawang linya ang idadagdag lamang at makakakuha tayo ng 512, na hindi ang tamang resulta kung ang mga numero ay idinagdag, ngunit tama kung pagsasamahin natin ang dalawang linya.

Paano i-convert ang isang string sa isang numero sa javascript?

Ang lahat ay simple dito, gumawa tayo ng susunod na dalawang variable, kung saan isusulat natin ang parehong halaga na tinukoy ng mga variable c at d , ngunit ipinapasa ang mga ito sa paraan ng Numero:

Var e = Numero(c); var f = Numero(d); document.write(e + f);

Kung susubukan mo na ngayong ipakita ang resulta ng karagdagan na ito sa screen, magpapakita ito ng 17. Ito ay dahil matagumpay na gumana ang aming pamamaraan at na-convert ang string sa isang numero. Nais kong ituro na kung isusulat mo ito tulad nito:

Document.write("
" + e + f);

Pagkatapos ay 512 ang ipapakita sa screen, dahil kapag nagdadagdag ng mga string at numero LAGI ang resulta ay na-convert sa isang string. Kung gusto mong magdagdag ng line break at panatilihin pa rin ang tamang resulta, maaari mong isulat ang lahat sa dalawang linya o isang tulad nito:

Document.write("
" + (e + f));

Kung maglalagay ka ng mga numero sa mga bracket, hindi ito mako-convert sa mga string at matagumpay na mapapanatili ang kanilang mga katangian. Ito ang aking maikling artikulo ngayon. Umaasa ako na ang javascript ay naging mas malinaw para sa iyo.