JavaScript
Переменное принуждение / преобразование

замечания

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

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

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

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

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

Math.trunc(3.7); // 3

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"

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

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

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