Последна актуализация: 1.11.2015

Често има нужда от преобразуване на едни данни в други. Например:

varnumber1 = "46"; varnumber2 = "4"; varresult = номер1 + номер2; конзолен дневник (резултат); //464

И двете променливи представляват низове, по-точно низови представяния на числа. И в резултат ще получим не числото 50, а низа 464. Но би било хубаво, ако те също могат да се добавят, изваждат, като цяло, да работят като с обикновени числа.

В този случай можем да използваме операции за преобразуване. Функцията се използва за преобразуване на низ в число. parseInt():

varnumber1 = "46"; varnumber2 = "4"; променлив резултат = parseInt(номер1) + parseInt(номер2); конзолен дневник (резултат); // петдесет

За да конвертирате низове в дробни числаприложна функция parseFloat():

varnumber1 = "46.07"; varnumber2 = "4,98"; променлив резултат = parseFloat(номер1) + parseFloat(номер2); конзолен дневник (резултат); //51.05

В този случай низът може да има смесено съдържание, например "123hello", тоест в този случай има числа, но има и обикновени знаци. Но методът parseInt() все пак ще се опита да извърши преобразуването:

Varnum1 = "123здравей"; varnum2 = parseInt(num1); конзолен дневник (num2); // 123

Ако методът не успее да преобразува, той връща NaN (не е число), което показва, че низът не представлява число и не може да бъде преобразуван.

Със специална функция isNaN()можете да проверите дали даден низ представлява число. Ако низът не е число, тогава функцията връща true, ако е число, тогава false:

Var num1 = "javascript"; varnum2 = "22"; varresult = isNaN(num1); конзолен дневник (резултат); // вярно - num1 не е число резултат = isNaN(num2); конзолен дневник (резултат); // невярно - num2 е число

По-горе разгледахме превода на низове в числа в десетична система. Въпреки това можем да преведем числата във всяка система. По подразбиране интерпретаторът на JavaScript сам отгатва към коя бройна система искаме да конвертираме низа (обикновено се избира десетичната система). Но можем да използваме втория параметър, за да посочим изрично, че искаме да конвертираме низ в число на конкретна система. Например преобразуване в число в двоична система:

Varnum1 = "110"; varnum2 = parseInt(num1, 2); конзолен дневник (num2); // 6

Резултатът ще бъде 6, тъй като 110 в двоична система е числото 6 в десетична система.

Сега да пишем малка програма, в който използваме операции с променливи:

С помощта на функцията prompt() в браузъра се показва диалогов прозорец с молба да въведете някаква стойност. Вторият аргумент на тази функция указва стойността, която да се използва по подразбиране.

Функцията prompt() обаче връща низ. Следователно трябва да преобразуваме този низ в число, за да извършваме операции с него.

След като отворим страницата в браузъра, ще видим покана за въвеждане на сумата на депозита:

След това ще се покаже подобно съобщение за въвеждане на процента. И накрая, програмата ще получи данните, ще ги преобразува в числа и ще извърши изчислението.

JavaScript е език с динамично въвеждане на данни. Това означава, че можете да записвате стойности в една и съща променлива различни видове, докато типът на самата променлива ще се промени. Това поведение често прави възможно да се забрави различното поведение на променливите с различен тип, но все пак е необходимо да запомните тази функция. Нека покажем това в следния пример.

console.log(сума(1, 2)); // 3 (тук всичко е наред) console.log(sum(1, "2")); // 12 (и не толкова тук)

Както можете да видите от примера, функцията сумасе държи неправилно, ако поне един от аргументите му не е число. Факт е, че при „добавяне“ на число към низ, числото се преобразува в низ и се конкатенира (слепва) с втория операнд.

За да избегнете подобни усложнения, можете да разберете типа на променлива по време на изпълнение на скрипта и да коригирате поведението му или внимателно да наблюдавате типовете променливи.

тип оператор

Този унарен оператор приема абсолютно всяка стойност като операнд и връща нейния тип в низова променлива.

JavaScript има следните типове данни:

// 1.) обект console.log(typeof()); // обект var p = (x: 1, y: 3); console.log(typeofp); // обект // 2.) функция функция sayHello() ( console.log("Здравей!"); ) console.log(typeof sayHello); // функция // 3.) низ console.log(typeof "JavaScript"); // низ // 4.) номер console.log(typeof 3.1415); // номер // 5.) boolean console.log(typeof true); // boolean // 6.) undefined var notExistsOne; console.log(typeof notExistsOne); // undefined console.log(typeof notExistsTwo); // недефиниран

забележи, че недефинирантова също е тип данни, който се състои от една стойност.

Актьорски състав

Преобразуването на тип в програмирането е преобразуването на стойност на променлива от един тип в стойност от друг тип.
Често тази трансформация се случва без контрола на програмиста. Това се вижда в примера с функцията сума. Промяна на типа възниква, когато резултатът от извършване на операция върху променлива от оригиналния тип не е ясен. Например, невъзможно е да се каже точно какво ще се получи от добавянето на низ с число, но операцията за добавяне на две числа е очевидна и в този случай е логично числото да се приведе към низа.

Преобразуване на низ в число

Понякога самият програмист може да промени типа на променлива, като приложи някои операции към нея. Например, операциите за увеличаване или намаляване на низ ще го преобразуват в число.

var c = "не-число"; ++c; console.log(typeof c); // NaN

Струва си да се отбележи, че не е необходимо да прибягвате до този метод за преобразуване на низ в число поради лошата му четливост и неочевидност. В js има вградени функции за тази задача. parseIntи parseFloat. Те приемат като свой първи аргумент низ, който трябва да бъде преобразуван в число, а като незадължителен втори аргумент, те приемат основата на числовата система, която съдържа числото в низа, подаден като първи аргумент. Ако вторият аргумент не е зададен, тогава ще се счита, че низът съдържа число в десетичната бройна система.

функция parseIntсе използва за преобразуване на низ в цяло число, а функцията parseFloatза преобразуване в дробни.

var a = parseInt("10"); console.log(["a = ", a, "; typeof a:", typeof a].join(" ")); // a = 10 ; typeof a: номер var pi = parseInt("3.1415"); console.log("pi = " + pi); // pi = 3 pi = parseFloat("3.1415"); console.log("pi = " + pi); // pi = 3,1415

Имайте предвид, че низът може да съдържа произволна буквална числова стойност, включително шестнадесетична, осмична или експоненциална.

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)

Като втори параметър на функциите parseIntи parseFloatможете да посочите основата на бройната система.

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

Ако стойността е в низа, който функциите parseIntи parseFloatвземе като първи параметър, не е числов литерал, тогава резултатът от изпълнението на тези функции ще бъде стойността NaN.

a = parseInt("не е число"); console.log("a = " + a); // a = NaN a = parseFloat("не е число"); console.log("a = " + a); // a = NaN

Преобразуване на низове

AT JavaScript стойноствсеки тип може да бъде преобразуван в низ. Вече беше казано по-горе, че когато един низ се свърже с число, числото се редуцира до низ и едва тогава се извършва конкатенацията. Това ще се случи с всеки тип стойност.

var str = "Обект: " + (); конзолен дневник (str); // Обект: str = "Масив: " + ; конзолен дневник (str); // Масив: 1,2,3 function sum(a, b) ( return a + b; ) str = "Функция: " + sum; конзолен дневник (str); /* Функция: функция sum(a, b) ( return a + b; ) */

Всъщност, когато прехвърляте обект към низ, методът се извиква имплицитно toString, което може да се извика и изрично.

var p = (x: 2, y: 4), str; str = p.toString(); console.log(typeofstr); // низ console.log(str); // str = .toString(); console.log(typeofstr); // низ console.log(str); // 1,2,3

Числово преобразуване

Преобразуването в число става при изпълнение математически операциии при извършване на операция за сравнение с преобразуване на тип (==, !=), докато стойността невярнои празен масив се преобразуват в стойност от тип 0 номер.

var a = true + true + true; // 1 + 1 + 1 console.log(a); // 3

Непразният масив, обект и функция се преобразуват в низ, когато се използват в аритметични изрази.

var arr =; console.log(arr + 4); // 1,2,34 функция sum(a, b)(връщане a + b;) console.log(sum + 5); // функция sum(a, b)(връща a + b;)5

Както можете да видите, неявното преобразуване на тип в js далеч не винаги е очевидно, така че трябва да го избягвате, като използвате функции за явно преобразуване на тип, като например parseInt, parseFloatи toString.

Това е всичко. Както винаги, успех на теб!

Има два основни начина за преобразуване на низ в число в javascript. Един начин е да го анализирате, а друг начин е да промените типа му на число. Всички трикове в други отговори (напр. унарен плюс) предполагат имплицитно принуждаване на типа низ към число. Можете също да направите същото с функцията Number.

Синтактичен

Var parsed = parseInt("97", 10);

ParseInt и parseFloat са две функции, които се използват за анализиране на низове в числа. Анализът ще спре безшумно, ако удари знак, който не разпознава, което може да бъде полезно за анализиране на низове като „92px“, но също така е донякъде опасно, тъй като няма да ви даде грешка при лош вход, вместо това вие „ще върнете NaN, ако низът не започва с число. Интервалът в началото на низа се игнорира. Ето пример за нещо, което прави нещо друго, което искате, и не дава никаква индикация, че нещата са се объркали:

Var widgetsSold = parseInt("97 800", 10); // widgetsSold вече е 97

Добра практика е винаги да указвате decimal като втори аргумент. В по-старите браузъри, ако низ започва от 0, той ще се интерпретира като осмичен, освен ако не е посочена стойност на основата, което изненада много хора. Поведението за шестнадесетичен старт се задейства, ако низът започва с 0x, освен ако не е указана стойност на основа. 0xff. Стандартът всъщност се промени с ecmascript 5, така че модерни браузъривече не изпълнява осмици, когато има водеща 0, ако не е посочена причина. parseInt разбира радикали до основа 36, в който случай и главните, и малките букви се третират като еквивалентни.

Променете типа низ на число

Всички други трикове, споменати по-горе, които не използват ParseInt, включват имплицитно принуждаване на низ към число. Предпочитам да го направя изрично

Var cast = Number("97");

Това е различно от методите за анализ (въпреки че все още игнорира интервали). По-строг е: ако не разбира целия низ, тогава връща NaN, така че не можете да го използвате за низове като 97px. Тъй като искате примитивно число, а не обект за обвивка на Number, уверете се, че не предшествате функцията Number с new.

Очевидно преобразуването в число дава стойност, която може да бъде плаваща, а не цяло число, така че ако искате цяло число, трябва да го промените. Има няколко начина да направите това:

Varrounded = Math.floor(Number("97.654")); // други опции са Math.ceil, Math.round var fixed = Number("97.654").toFixed(0); // закръглено, а не съкратено var bitwised = Number("97.654")|0; // не използвайте за големи числа

Всеки побитов оператор (тук направих побитово или, но можете също да направите двойно отрицание, както в предишния отговор или Bitshift) ще преобразува стойността в 32-битово цяло число и повечето ще преобразуват в цяло число със знак. Моля, имайте предвид, че това няма да иска да търсите големи цели числа. Ако цяло число не може да бъде представено в 32 бита, то ще бъде завършено.

~~"3000000000.654" === -1294967296 // Това е същото като Number("3000000000.654")|0 "3000000000.654" >>> 0 === 3000000000 // неподписаното изместване надясно ви дава допълнителен бит "300000000000.654" > >> 0 === 3647256576 // но все още се проваля с по-големи числа

За да работите правилно с големи числа, трябва да използвате методите за закръгляване

Math.floor("3000000000.654") === 3000000000 // Това е същото като Math.floor(Number("3000000000.654"))

Имайте предвид, че всички тези методи разбират експоненциална нотация, така че 2e2 е 200, а не NaN. Освен това Number разбира „Infinity“, докато методите за анализиране не го правят.

Персонализиран

Малко вероятно е някой от тези методи да направи точно това, което искате. Например, обикновено искам грешка при неуспешен анализ и нямам нужда от поддръжка на Infinity, експоненти или водещи интервали. В зависимост от вашето използване понякога има смисъл да напишете персонализирана функция за преобразуване.

Винаги проверявайте дали изходът на числото или един от методите за анализ е вида на очакваното число. Почти със сигурност ще искате да използвате isNaN, за да сте сигурни, че числото не е NaN (обикновено единственият начин да разберете дали анализът е неуспешен).

Няма значение какъв тип променлива се използва в израза. Ако изразът е математически, всички негови променливи автоматично ще бъдат интерпретирани като числови. Ако се обработват низове, тогава всички "участници" в израза се третират като низове. Въпреки това, задачата за преобразуване на JavaScript "низ в число" съществува в много по-широк контекст.

JavaScript методи за конвертиране на низове в числа

Арсеналът от методи за преобразуване на низове в числа не е голям, но като цяло достатъчен прости случаи. Тук JavaScript (особено за начинаещи) е пътят от просто към сложно с практически примери.

Ще ви бъде интересно:

Примерът описва четири различни низа. В първия изходен блок, типът на всеки променлива функция typeof се дефинира като низ. След това всеки низ се преобразува много просто в число. Във втория изходен блок можете да видите промените в променливите след преобразуването, техният тип е станал число. Примерът за преобразуване на JavaScript parseFloat е особено показателен: беше "12e+3", сега е "12000".

Промените при преобразуване на низ в число могат да бъдат значителни! Но само първите знаци имат значение: те трябва да са цифри. Ако няма цифрови знаци, резултатът ще бъде NaN.

Обратното преобразуване на низ, който "се превръща" в число, не винаги е същият низ. Този момент може да се използва за проверка на правилността на въвеждане на цифрова информация.