Поиск…


замечания

Некоторые языки требуют, чтобы вы заранее определили, какую переменную вы объявляете. JavaScript не делает этого; он попытается понять это самостоятельно. Иногда это может привести к неожиданному поведению.

Если мы используем следующий HTML-код

<span id="freezing-point">0</span>

И получить его содержимое через JS, он не будет преобразовывать его в число, хотя можно было бы ожидать этого. Если мы используем следующий фрагмент, можно ожидать, что boilingPoint будет равен 100 . Однако JavaScript будет преобразовывать moreHeat в строку и moreHeat две строки; результатом будет 0100 .

var el = document.getElementById('freezing-point');
var freezingPoint = el.textContent || el.innerText;
var moreHeat = 100;
var boilingPoint = freezingPoint + moreHeat;

Мы можем исправить это, явно преобразуя freezingPoint в число.

var el = document.getElementById('freezing-point');
var freezingPoint = Number(el.textContent || el.innerText);
var boilingPoint = freezingPoint + moreHeat;

В первой строке мы преобразуем "0" (строку) в 0 (число) перед ее сохранением. После выполнения добавления вы получите ожидаемый результат ( 100 ).

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

Number('0') === 0

Number('0') преобразует строку ( '0' ) в число ( 0 )

Более короткая, но менее ясная форма:

+'0' === 0

Оператор унарного + ничего не делает для чисел, но преобразует что-либо еще в число.
Интересно, что +(-12) === -12 .

parseInt('0', 10) === 0

parseInt('0', 10) преобразует строку ( '0' ) в число ( 0 ), не забывайте второй аргумент, который является radix. Если не задано, parseInt может преобразовать строку в неправильное число.

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

String(0) === '0'

String(0) преобразует число ( 0 ) в строку ( '0' ).

Более короткая, но менее ясная форма:

'' + 0 === '0'

Двойное отрицание (!! x)

Двойное отрицание !! не является отдельным оператором JavaScript или специальным синтаксисом, а скорее последовательностью из двух отрицаний. Он используется для преобразования значения любого типа в его соответствующее true или false логическое значение в зависимости от того, является ли оно правдивым или ложным .

!!1            // true
!!0            // false
!!undefined    // false
!!{}           // true
!![]           // true

Первое отрицание преобразует любое значение в значение false если оно является правдивым, а true если оно ложно . Второе отрицание действует на нормальное булево значение. Вместе они преобразуют любое истинное значение в true и любое значение ложности в false .

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

x !== 0        // instead of !!x in case x is a number
x != null      // instead of !!x in case x is an object, a string, or an undefined

Использование !!x считается плохой практикой по следующим причинам:

  1. Стилистически это может выглядеть как особый синтаксис, тогда как на самом деле он не делает ничего, кроме двух последовательных отрицаний с неявным преобразованием типов.
  2. Лучше предоставить информацию о типах значений, хранящихся в переменных и свойствах через код. Например, x !== 0 говорит, что x , вероятно, является числом, тогда как !!x не дает такого преимущества читателям кода.
  3. Использование Boolean(x) допускает аналогичную функциональность и является более явным преобразованием типа.

Неявное преобразование

JavaScript будет пытаться автоматически преобразовывать переменные в более подходящие типы при использовании. Обычно рекомендуется делать преобразования явно (см. Другие примеры), но все равно стоит знать, какие преобразования происходят неявно.

"1" + 5 === "15" // 5 got converted to string.
1 + "5" === "15" // 1 got converted to string.
1 - "5" === -4 // "5" got converted to a number.
alert({}) // alerts "[object Object]", {} got converted to string.
!0 === true // 0 got converted to boolean
if ("hello") {} // runs, "hello" got converted to boolean.
new Array(3) === ",,"; // Return true. The array is converted to string - Array.toString();

Некоторые из более сложных частей:

!"0" === false // "0" got converted to true, then reversed.
!"false" === false // "false" converted to true, then reversed.

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

Boolean(0) === false

Boolean(0) преобразует число 0 в логическое значение false .

Более короткая, но менее ясная форма:

!!0 === false

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

Чтобы преобразовать строку в логическое использование

Boolean(myString)

или более короткая, но менее ясная форма

!!myString 

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

Boolean('') === false   // is true
Boolean("") === false   // is true
Boolean('0') === false  // is false
Boolean('any_nonempty_string') === true // is true

Целое число для плавания

В JavaScript все числа внутренне представлены как float. Это означает, что простое использование целого числа как float - это все, что нужно сделать для его преобразования.

Float to Integer

Чтобы преобразовать float в целое число, JavaScript предоставляет несколько методов.

Функция floor возвращает первое целое число, меньшее или равное поплавку.

Math.floor(5.7); // 5

Функция ceil возвращает первое целое число, большее или равное поплавку.

Math.ceil(5.3); // 6

round функция округляет поплавок.

Math.round(3.2); // 3
Math.round(3.6); // 4
6

Усечение ( trunc ) удаляет десятичные знаки из поплавка.

Math.trunc(3.7); // 3

Обратите внимание на разницу между усечением ( trunc ) и floor :

Math.floor(-3.1); // -4
Math.trunc(-3.1); // -3

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

parseFloat принимает строку как аргумент, который он преобразует в float /

parseFloat("10.01") // = 10.01

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

Boolean(...) преобразует любой тип данных в true или false .

Boolean("true") === true
Boolean("false") === true
Boolean(-1) === true
Boolean(1) === true
Boolean(0) === false
Boolean("") === false
Boolean("1") === true
Boolean("0") === true
Boolean({}) === true
Boolean([]) === true

Пустые строки и число 0 будут преобразованы в false, а все остальные будут преобразованы в true.

Более короткая, но менее ясная форма:

!!"true" === true
!!"false" === true
!!-1 === true
!!1 === true
!!0 === false
!!"" === false
!!"1" === true
!!"0" === true
!!{} === true
!![] === true

Эта более короткая форма использует неявное преобразование типа, используя логический оператор NOT дважды, как описано в http://www.riptutorial.com/javascript/example/3047/double-negation----x-


Ниже приведен полный список логических преобразований из спецификации ECMAScript

  • если myArg типа undefined или null тогда Boolean(myArg) === false
  • если myArg типа boolean то Boolean(myArg) === myArg
  • если myArg number типа then Boolean(myArg) === false если myArg равно +0 , ‑0 или NaN ; в противном true
  • если myArg string типа then Boolean(myArg) === false если myArg - это пустая строка (ее длина равна нулю); в противном true
  • если myArg symbol или object then Boolean(myArg) === true

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

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

Array.join(separator) может использоваться для вывода массива в виде строки с настраиваемым разделителем.

По умолчанию (separator = ","):

["a", "b", "c"].join() === "a,b,c"

С разделителем строк:

[1, 2, 3, 4].join(" + ") === "1 + 2 + 3 + 4"

С пустым разделителем:

["B", "o", "b"].join("") === "Bob"

Массив в String с использованием методов массива

Этот способ может показаться размножающимся, потому что вы используете анонимную функцию, чтобы выполнить то, что вы можете сделать с помощью join (); Но если вам нужно что-то сделать для строк при преобразовании массива в String, это может быть полезно.

var  arr = ['a', 'á', 'b', 'c']

function upper_lower (a, b, i) {
  //...do something here
  b = i & 1 ? b.toUpperCase() : b.toLowerCase();
  return a + ',' + b
}
arr = arr.reduce(upper_lower); // "a,Á,b,C"

Таблица примитивов для примитива

Значение Преобразован в строку Преобразованный в номер Конвертировано в Boolean
undefinded «Неопределенные» NaN ложный
ноль "ноль" 0 ложный
правда "правда" 1
ложный "ложный" 0
NaN "NaN" ложный
"" пустой строки 0 ложный
"" 0 правда
«2,4» (числовое) 2,4 правда
«тест» (не числовой NaN правда
"0" 0 правда
"1" 1 правда
-0 "0" ложный
0 "0" ложный
1 "1" правда
бесконечность «Бесконечность» правда
-Infinity "-Infinity" правда
[] «» 0 правда
[3] "3" 3 правда
[ 'А'] «А» NaN правда
[ 'А', 'Ь'] «А, б» NaN правда
{} "[Объект Object]" NaN правда
функция () {} "Функция () {}" NaN правда

Жирные значения выделяют преобразование, которое программисты могут найти

Чтобы преобразовать явно значения, вы можете использовать String () Number () Boolean ()



Modified text is an extract of the original Stack Overflow Documentation
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow