Js строку в число: JavaScript: преобразование строки в число – Преобразование число в строку JavaScript. Преобразование строка в число JavaScript.

Содержание

JavaScript - JavaScript: преобразовать строку в число

Функции parseFloat() и parseInt()

В JavaScript существуют 2 встроенные функции для преобразования строк в числа: parseFloat() и parseInt().

parseFloat() принимает аргументом строку, которую необходимо привести к численному типу, и возвращает число типа float. Число должно содержаться в начале строки. Если после числа в строке идут ещё какие-то символы, то они отсекаются. Дробная часть числа должна быть записана через точку (запятая не воспринимается как разделитель). В случае, если parseFloat() не может преобразовать строку, то она возвращает NaN.

Также функция может обработать «число n, умноженное на 10 в степени x», которое в программировании принято записывать через букву E, например: 0.5E6 или 0.5E+6. Степень может быть также отрицательная: 0.5E-6, что равно 0.5*10^-6 или 0.5/1000000.


parseFloat(''3.78kg'')   // 3.78
parseFloat(''kg33'')   // NaN
parseFloat(''0004.111'')   // 4.111
parseFloat(''0x66'')   // 0
parseFloat(''.5'')   // 0.5
parseFloat(''-.5'')   // -0.5
parseFloat(''0.5e6'')   // 500000
parseFloat(''0.03E+2'')   // 3
parseFloat(''3E-4'')   // 0.0003
parseFloat(''-3E-4'')   // -0.0003

Функция parseInt(string[, radix]) принимает в качестве первого аргумента строку, анализирует её и возвращает целое число (тип integer). Функция пытается анализировать систему счисления, в которой записано число в исходной строке (например, десятичная, восьмеричная или шестнадцатеричная — но не только эти). Также систему счисления можно указать явно, передав её вторым параметром radix. Параметр radix может принимать любое число от 2 до 36 (в системах выше 10-й используются буквы английского алфавита, от A до Z).

Числа типа 1.5e6 функция не обрабатывает так, как parseFloat().

Ознакомьтесь, пожалуйста, с примерами ниже, чтобы не наколоться на подводные камни, запрятаны в работе функции parseInt().


parseInt(''25'')   // 25
parseInt(''-25'')   // -25
parseInt(''45.12'')   // 45
parseInt(''045'',10)   // 45
parseInt(''70'',8)    // 56  (70 в восьмеричной системе это 56 в десятичной)
parseInt(''070'')     // 56 (ВАЖНО!!! нуль вначале заставит функцию проанализировать строку как восьмеричное число)
parseInt(''88'',8)   // NaN (в восьмеричной системе нет цифры 8)
parseInt(''a1'')   // NaN (ВАЖНО!!! Функция по умолчанию не воспринимает число как 16-ричное, если не дописать в начале строки 0x)
parseInt(''a1'',16)   // 161 (здесь явно указана система счисления)
parseInt(''0xa1'')   // 161 (правильный формат 16-ричного числа, можно не указывать второй параметр)
parseInt(''099'')   // 0 (ВАЖНО!!! Число воспринимается как восьмеричное, но содержащее недопустимые символы)
parseInt(''0.5e6'')   // 0 (ВАЖНО!!! не работает как parseFloat)
parseInt(''ZZ'',36)   // 1295
parseInt(''-FF'')   // NaN
parseInt(''-FF'',16)   // -255

Если Вы обрабатываете данные из текстового поля, которые вводит пользователь, всегда используйте parseInt() вместе со вторым параметром radix, это обезопасит Ваш код от неожиданных результатов.

Можете испробовать работу этих функций в примере ниже:

Javascript преобразование строки в число

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

Неявное преобразование – это когда интерпретатор автоматически выполняет преобразование типов, т. е. без участия программиста. Явное преобразование – это когда преобразование выполняет сам программист. Явное преобразование иначе называют приведением типов :

В таблице ниже описывается, как в JavaScript выполняется преобразование значений из одного типа в другой. Пустые ячейки соответствуют ситуациям, когда преобразование не требуется:

Значение Преобразование в:
Строку Число Булево Объект
undefined
null
"undefined"
"null"
NaN
false
false
ошибка typeError
ошибка typeError
true
false
"true"
"false"
1
new Boolean(true)
new Boolean(false)
"" (пустая строка)
"1.2"
"one"
"-10"
"+10"
"011"
"0xff"

1.2
NaN
-10
10
11
255
false
true
true
true
true
true
true
new String("")
new String("1.2")
new String("one")
new String("-10")
new String("+10")
new String("011")
new String("0xff")

-0
NaN
Infinity
-Infinity
3
"0"
"0"
"NaN"
"Infinity"
"-Infinity"
"3"
false
false
false
true
true
true
new Number(0)
new Number(-0)
new Number(NaN)
new Number(Infinity)
new Number(-Infinity)
new Number(3)
<> (любой объект)

[] (пустой массив)
[9] (1 числовой элемент)
arr (любой другой массив)
function()<> (любая функция)

см. Преобразование объектов

""
"9"
см. Преобразование объектов
см. Преобразование объектов

см. Преобразование объектов

9
NaN
NaN

true

true
true
true
true

Для явного преобразования в простые типы используются следующие функции: Boolean() , Number() , String() . При неявном преобразования интерпретатор использует те же функции, что используются для явного преобразования.

Для явного преобразования можно использовать операторы вместо функций. Например, если один из операндов оператора + является строкой, то другой операнд также преобразуется в строку. Унарный оператор + преобразует свой операнд в число. Унарный оператор ! преобразует операнд в логическое значение и инвертирует его. Всё это стало причиной появления следующих своеобразных способов преобразования типов, которые можно встретить на практике:

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

Функция Number() преобразует значения по следующим правилам:

  • Логические значения true и false преобразуются в 1 и 0 соответственно.
  • Числа возвращаются без изменения.
  • Значение null преобразуется в 0 .
  • Значение undefined преобразуется в NaN .

Для строк действуют особые правила:

  • Если строка содержит только цифры с начальным знаком + или — либо без знака, она всегда преобразуется в целое десятичное число. Начальные нули игнорируются, например "0011" преобразуется в 11.
  • Если строка представляет собой число с плавающей точкой с начальным знаком + или — либо без знака, она преобразуется в соответствующее число с плавающей точкой (начальные нули также игнорируются).
  • Если строка представляет собой число в шестнадцатеричном формате, она преобразуется в соответствующее целое десятичное число.
  • Если строка пустая, она преобразуется в 0 .
  • Если строка содержит что-то отличное от предыдущих вариантов, она преобразуется в NaN .
  • Для объектов вызывается метод valueOf() , а возвращаемое им значение автоматически преобразуется по предыдущим правилам. Если это преобразование даёт в результате NaN , вызывается метод toString() и применяются правила преобразования строк в числа.

Унарные операторы + и — работают по тем же правилам, что и функция Number() .

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

Функция Boolean() преобразует значение в его логический эквивалент:

  • Следующие значения в результате преобразования дают значение false : undefined , null , 0 , -0 , NaN , "" .
  • Значение false возвращается без изменения.
  • Все остальные значения в результате преобразования дают значение true .

Преобразование в строки

Функция String() преобразует значения по следующим правилам:

  • Для всех значений кроме null и undefined автоматически вызывается метод toString() и возвращается строковое представление значения.
  • Для значения null возвращается строка "null" .
  • Для значения undefined возвращается строка "undefined" .

Преобразование простых типов в объекты

Для преобразования простых значений в объекты используются конструкторы Boolean() , Number() , String() :

Преобразование объектов в простые значения

Все объекты наследуют два метода преобразования: toString() и valueOf() .

Метод toString() возвращает строковое представление объекта. По умолчанию он ничего интересного не возвращает:

Некоторые типы имеют более специализированные версии метода toString() . Например, метод toString() у массива преобразует все его элементы в строки и затем объединяет их в одну строку, вставляя запятые между ними:

Задача метода valueOf() определена не так чётко: предполагается, что он должен преобразовать объект в представляющее его простое значение, если такое значение существует. Объекты по своей сути являются составными значениями, и большинство объектов не могут быть представлены в виде единственного простого значения, поэтому по умолчанию метод valueOf() возвращает не простое значение, а ссылку на него:

При преобразовании объекта в строку интерпретатор JavaScript выполняет следующие действия:

  • Если объект имеет метод toString() , интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует значение в строку (если оно не является строкой) и возвращает результат преобразования.
  • Если объект не имеет метода toString() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода valueOf() . Если этот метод определён, интерпретатор вызывает его. Если он возвращает простое значение, интерпретатор преобразует это значение в строку (если оно не является строкой) и возвращает результат преобразования.
  • В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

При преобразовании объекта в число интерпретатор выполняет те же действия, но первым пытается применить метод valueOf() :

  • Если объект имеет метод valueOf() , возвращающий простое значение, интерпретатор преобразует (при необходимости) это значение в число и возвращает результат.
  • Если объект не имеет метода valueOf() или этот метод не возвращает простое значение, то интерпретатор проверяет наличие метода toString() . Если объект имеет метод toString() , возвращающий простое значение, интерпретатор выполняет преобразование и возвращает полученное значение.
  • В противном случае интерпретатор делает вывод, что ни toString() ни valueOf() не позволяют получить простое значение и возбуждает ошибку TypeError .

Методы toString() и valueOf() доступны для чтения и записи, поэтому их можно переопределить и явно указать, что будет возвращаться при преобразовании:

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

Более новая информация по этой теме находится на странице https://learn.javascript.ru/type-conversions.

Система преобразования типов в JavaScript очень проста, но отличается от других языков. Поэтому она часто служит «камнем преткновения» для приходящих из других языков программистов.

Всего есть три преобразования:

  1. Строковое преобразование.
  2. Численное преобразование.
  3. Преобразование к логическому значению.

Эта глава описывает преобразование только примитивных значений, объекты разбираются далее.

Строковое преобразование

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

Можно также осуществить преобразование явным вызовом String(val) :

Как видно из примеров выше, преобразование происходит наиболее очевидным способом, «как есть»: false становится "false" , null – "null" , undefined – "undefined" и т.п.

Также для явного преобразования применяется оператор "+" , у которого один из аргументов строка. В этом случае он приводит к строке и другой аргумент, например:

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

Численное преобразование происходит в математических функциях и выражениях, а также при сравнении данных различных типов (кроме сравнений === , !== ).

Для преобразования к числу в явном виде можно вызвать Number(val) , либо, что короче, поставить перед выражением унарный плюс "+" :

Значение Преобразуется в.
undefined NaN
null
true / false 1 / 0
Строка Пробельные символы по краям обрезаются.
Далее, если остаётся пустая строка, то 0 , иначе из непустой строки "считывается" число, при ошибке результат NaN .

Сравнение разных типов – значит численное преобразование:

При этом строка "
0" преобразуется к числу, как указано выше: начальные и конечные пробелы обрезаются, получается строка "0" , которая равна 0 .

С логическими значениями:

Здесь сравнение "==" снова приводит обе части к числу. В первой строке слева и справа получается 0 , во второй 1 .

Специальные значения

Посмотрим на поведение специальных значений более внимательно.

Интуитивно, значения null/undefined ассоциируются с нулём, но при преобразованиях ведут себя иначе.

Специальные значения преобразуются к числу так:

Значение Преобразуется в.
undefined NaN
null

Это преобразование осуществляется при арифметических операциях и сравнениях > >= , но не при проверке равенства == . Алгоритм проверки равенства для этих значений в спецификации прописан отдельно (пункт 11.9.3). В нём считается, что null и undefined равны "==" между собой, но эти значения не равны никакому другому значению.

Это ведёт к забавным последствиям.

Например, null не подчиняется законам математики – он «больше либо равен нулю»: null>=0 , но не больше и не равен:

Значение undefined вообще «несравнимо»:

Для более очевидной работы кода и во избежание ошибок лучше не давать специальным значениям участвовать в сравнениях > >= .

Используйте в таких случаях переменные-числа или приводите к числу явно.

Логическое преобразование

Преобразование к true/false происходит в логическом контексте, таком как if(value) , и при применении логических операторов.

Все значения, которые интуитивно «пусты», становятся false . Их несколько: 0 , пустая строка, null , undefined и NaN .

Остальное, в том числе и любые объекты – true .

Полная таблица преобразований:

Значение Преобразуется в.
undefined , null false
Числа Все true , кроме 0 , NaN — false .
Строки Все true , кроме пустой строки "" — false
Объекты Всегда true

Для явного преобразования используется двойное логическое отрицание !!value или вызов Boolean(value) .

В отличие от многих языков программирования (например PHP), "0" в JavaScript является true , как и строка из пробелов:

Функция Number() преобразует в тип Number, String() в тип String, Boolean() в тип Boolean.

Типы данных в JavaScript

В JavaScript существует 5 типов данных, которые могут содержать значения:

Есть 3 типа объектов:

И 2 типа данных, которые не могут содержать значения:

Оператор typeof

Чтобы определить тип переменной JavaScript, используется оператор typeof.

  • У NaN тип number
  • У массива тип object
  • У даты тип object
  • У null тип object
  • У неопределенной переменной тип undefined *
  • У переменной, которой не присвоено значение, тоже тип undefined *

Нельзя при помощи оператора typeof определить, является ли объект JavaScript массивом (или датой).

Оператор typeof это не переменная. Это оператор. У операторов ( + — * / ) нет типов. Однако оператор typeof всегда возвращает строку (содержащую тип операнда).

Свойство constructor

Свойство constructor возвращает функцию-конструктор у всех переменных JavaScript.

Вы можете проверить свойство constructor, чтобы определить, является ли объект массивом (содержит слово "Array"):

Или еще проще, вы можете проверить, является ли объект функцией Array:

Аналогичным образом можно проверить является ли переменная объектом Date.

Преобразование типов в JavaScript

Переменные JavaScript могут быть преобразованы в новые переменные и другие типы данных:

  • при помощи функции JavaScript
  • автоматически самим JavaScript

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

Глобальный метод String() позволяет преобразовывать числа в строки.

Его можно использовать с любыми видами чисел — константами, переменными или выражениями:

Метод toString() объекта Number делает то же самое.

В главе Методы объекта Number вы найдете другие методы, которые можно использовать для преобразования чисел в строки:

Метод Описание
toExponential() Возвращает строку с округленным числом, записанным в экспоненциальной нотации.
toFixed() Возвращает строку с числом, записанным с заданным количеством цифр после десятичной точки.
toPrecision() Возвращает строку с числом заданной длины.

Преобразование логических значений (тип Boolean) в строку

Глобальный метод String() позволяет преобразовывать логические значения в строки.

Метод toString() объекта Boolean делает то же самое.

Преобразование даты (тип Date) в строку

Глобальный метод String() позволяет преобразовывать дату (тип Date) в строку.

Метод toString() объекта Date делает то же самое.

В главе Методы объекта Date вы найдете другие методы, которые можно использовать для преобразования даты в строку:

Метод Описание
getFullYear() Получить год в формате четырех цифр (гггг)
getMonth() Получить номер месяца (0-11)
getDate() Получить число месяца (1-31)
getHours() Получить час (0-23)
getMinutes() Получить минуты (0-59)
getSeconds() Получить секунды (0-59)
getMilliseconds() Получить миллисекунды (0-999)
getTime() Получить время (количество миллисекунд, прошедших с 1 января 1970)
getDay() Получить номер дня недели (0-6)

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

Глобальный метод Number() позволяет преобразовывать строки в числа.

Строки, содержащие числа (как "3.14"), преобразовываются в числа (как 3.14). Пустые строки преобразовываются в 0. Все остальные строки преобразовываются в NaN (Не число).

В главе Методы объекта Number вы найдете другие методы, которые можно использовать для преобразования строк в числа:

Метод Описание
parseFloat() Парсит строку и возвращает число с плавающей точкой.
parseInt() Парсит строку и возвращает целое число.

Унарный оператор +

Унарный оператор + также можно использовать для преобразования переменных в числовой тип:

Если переменная не может быть преобразована, то она все равно станет числом, но со значением NaN (Не число):

Преобразование логических значений (тип Boolean) в число

Глобальный метод Number() позволяет преобразовывать логические значения в числа.

Преобразование даты (тип Date) в число

Глобальный метод Number() позволяет преобразовывать значения даты (тип Date) в числа.

Метод getTime() объекта Date делает то же самое.

Автоматическое преобразование типов

Когда JavaScript приходится оперировать с "неправильным" типом данных, интерпретатор попытается преобразовать тип этого значения в "правильный".

Результат получается не всегда таким, как вы ожидаете:

Автоматическое преобразование строк

JavaScript автоматически вызывает метод переменной toString(), когда вы пытаетесь "вывести" объект или переменную:

Числа и логические значения также преобразуются, но это не так заметно:

Таблица преобразования типов JavaScript

В следующей таблице показаны результаты преобразования различных значений JavaScript в типы Number, String и Boolean:

Оригинальное значение Преобразованное в Number Преобразованное в String Преобразованное в Boolean
false "false" false
true 1 "true" true
"0" false
1 1 "1" true
"0" "0" true
"000" "000" true
"1" 1 "1" true
NaN NaN "NaN" false
Infinity Infinity "Infinity" true
-Infinity -Infinity "-Infinity" true
"" "" false
"20" 20 "20" true
"twenty" NaN "twenty" true
[] "" true
[20] 20 "20" true
[10,20] NaN "10,20" true
["twenty"] NaN "twenty" true
["ten","twenty"] NaN "ten,twenty" true
function()<> NaN "function()<>" true
NaN "[object Object]" true
null "null" false
undefined NaN "undefined" false

Значения в кавычках показывают строковые значения.

Красным цветом выделены значения, которые не всегда ожидаемы.

Рекомендуем к прочтению

Базовые типы: Строки, Числа, Boolean

В этой статье собраны особенности базовых типов данных, которые важны для программистов из других областей.

В Javascript есть и объектные типы данных и элементарные, которые можно интерпретировать как объекты.

Элементарные - создаются простым указанием данных:

var orange = "Апельсин"

Объектные - например, через оператор new:

var orange = new String("Апельсин")

На практике, хотя для каждого элементарного типа есть соответствующий объект, использовать их не рекомендуется. Это - отмершая часть языка.

var ok = new Boolean(true) // не надо

Элементарные типы автоматически интерпретируются как объекты при вызовах методов, поэтому можно, определять длину строки как:

alert("Апельсин".length)

Поэтому иногда говорят, что в javascript - все объекты. Так удобно думать, но определенная разница все же есть.

Например, typeof выдаст разный результат:

alert(typeof "test")
alert(typeof new String("test"))

Это - еще одна причина избегать использования объектов там, где существует элементарный тип: меньше путаницы.

Преобразование типа можно явным образом сделать через его название:

var test = Boolean("something") // true

Кроме всем известных типов данных - в javascript есть специальное значение undefined, которое, условно говоря, обозначает что "данных нет". Не null, а данных нет. Понимайте как хотите.

Далее рассмотрим особенности каждого из этих типов.

Все числа хранятся в формате float64, т.е 8 байт с плавающей точкой. В этом формате не всегда возможны точные вычисления.

Например,

alert(0.1+0.2)  // выведет не 0.3!

JS JavaScript Преобразование типов



Число () преобразуется в число, String () преобразуется в строку, логическое () преобразуется в логическое значение.


Типы данных JavaScript

В JavaScript существует 5 различных типов данных, которые могут содержать значения:

  • Строка
  • Номер
  • Логических
  • Объекта
  • Функции

Существует 3 типа объектов:

  • Объекта
  • Дата
  • Массива

И 2 типа данных, которые не могут содержать значения:

  • Null
  • Неопределенный

Оператор typeof

Для поиска типа данных переменной JavaScript можно использовать оператор typeof .

Пример

typeof "John"                 // Returns "string"
typeof 3.14                   // Returns "number"
typeof NaN                    // Returns "number"
typeof false                  // Returns "boolean"
typeof [1,2,3,4]              // Returns "object"
typeof {name:'John', age:34}  // Returns "object"
typeof new Date()             // Returns "object"
typeof function () {}         // Returns "function"
typeof myCar                  // Returns "undefined" *
typeof null                   // Returns "object"

Пожалуйста, обратите внимание:

  • Тип данных NaN — Number
  • Типом данных массива является Object
  • Типом данных даты является Object
  • Типом данных null является Object
  • Тип данных неопределенной переменной не определен *
  • Тип данных переменной, которой не назначено значение, также не определен *

Нельзя использовать typeof , чтобы определить, является ли объект JavaScript массивом (или датой).



Тип данных typeof

Оператор typeof не является переменной. Это оператор. Операторы (+-*/) не имеют какого-либо типа данных.

Но оператор typeof всегда возвращает строку (содержащую

(Встроенный) способ в JavaScript, чтобы проверить, является ли строка допустимым числом

Чтобы проверить, является ли переменная (включая строку) числом, проверьте, не является ли она числом:

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

isNaN(num)         // returns true if the variable does NOT contain a valid number

Примеры

isNaN(123)         // false
isNaN('123')       // false
isNaN('1e10000')   // false (This translates to Infinity, which is a number)
isNaN('foo')       // true
isNaN('10px')      // true

Конечно, вы можете отрицать это, если вам нужно. Например, чтобы реализовать пример IsNumeric вы дали:

function isNumeric(num){
  return !isNaN(num)
}

Чтобы преобразовать строку, содержащую число, в число:

работает только в том случае, если строка содержит только числовые символы, иначе она возвращает NaN.

+num               // returns the numeric value of the string, or NaN 
                   // if the string isn't purely numeric characters

Примеры

+'12'              // 12
+'12.'             // 12
+'12..'            // Nan
+'.12'             // 0.12
+'..12'            // Nan
+'foo'             // NaN
+'12px'            // NaN

Свободно преобразовать строку в число

полезно для преобразования 12px в 12, например:

parseInt(num)      // extracts a numeric value from the 
                   // start of the string, or NaN.

Примеры

parseInt('12')     // 12
parseInt('aaa')    // NaN
parseInt('12px')   // 12
parseInt('foo2')   // NaN      These last two may be different
parseInt('12a5')   // 12       from what you expected to see. 

Поплавки

Имейте в виду, что, в отличие от +num, parseInt (как следует из названия) преобразует число с плавающей точкой в целое число, отсекая все после десятичной точки (если вы хотите использовать parseInt() из-за этого поведения, вы, вероятно, лучше использовать другой метод):

+'12.345'          // 12.345
parseInt(12.345)   // 12
parseInt('12.345') // 12

Пустые строки

Пустые строки могут быть немного нелогичными. +num преобразует пустые строки в ноль, а isNaN() предполагает то же самое:

+''                // 0
isNaN('')          // false

Но parseInt() не согласен:

parseInt('')       // NaN

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *