Эй, ребята!

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

Давай займемся этим, ладно?

Что такое принуждение типов?

Приведение типов - это процесс неявного или явного преобразования значения из одного типа в другой, например,

Строка → Число и наоборот

Object → Boolean и т. Д.

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

Напомним, что примитивные типы следующие:

Строка, число, неопределенное, логическое, нулевое, BigInt, символ.

Вы знаете, что есть два типа принуждения?

Неявное приведение типов.

Явное приведение типов.

Итак, что есть явное и неявное?

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

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

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

Вот несколько примеров неявного принуждения:

[] == 0

[] + 1

истина + ложь

12 / “6”

«Число» + 15 + 3

15 + 3 + «число»

[1] ›ноль

«Фу» + + «бар»

‘True’ == true

false == «ложь»

null == ‘’

!! ”false” == !! ”true”

* Решения приведены в конце блога *

Да, это некоторые глупые вещи, которые вы можете делать как разработчик. Как говорится, в 90% случаев использования неявного приведения лучше избегать.

Теперь, когда мы часто слышим неявное выражение, мы увидим, чем оно отличается от явного.

Неявное и явное принуждение

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

Но если мы напишем код следующими способами,

1 == истина // правда

1 == null // ложь

2 / “5” // 0.4

25 — “10” // 15

25 + + “5” // 30

23 == «23» // верно

23 === ”23” // ложь

В приведенных выше примерах мы видим, что нет прямого преобразования данного ввода, как в (2 / «5»), поскольку мы делим число на строку, интерпретатор JavaScript преобразует эту строку в число и выдает результат в виде числа. . Этот процесс автоматического преобразования значений в разные типы называется неявным принуждением.

Кроме того, оператор (==) double equals сравнивает входные данные и при необходимости преобразует значение в другой тип, если необходимо. С другой стороны (===) triple equals - это строгий оператор, который строго сравнивает типы заданного ввода.

Что делать, если между числом и строкой числа стоит оператор (+)? Считать…

Ex:

123 + “456” // “12345” ☹

123 + + “456” // 579 😊

Потому что оператор (+) будет объединять (объединять), если есть одна строка и одно число, как в приведенном выше случае, а во втором случае первый оператор (+) указывает на конкатенацию, а второй (+) оператор указывает на унарный оператор, который преобразует предшествующий операнд числа, если это не так.

Пример унарного оператора:

+ “123” //123

+ ”-11” // -11

+ ”Hello” // NaN (не число), потому что это имеет смысл, как строку слова можно преобразовать в число? Без прав.

Типы конверсий

Первое правило, которое следует знать, в JavaScript есть только три типа конверсии:

1. натянуть

2. в Boolean

3. в номер

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

Чтобы явно преобразовать значения в строку, используйте функцию String (). Чтобы неявно преобразовать значения в строку, используйте двоичный оператор (+), когда любой операнд является строкой.

Ex:

String (123) // ”123” → Явный 😊

123 + ‘’ // «123» → Неявное ☹

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

Ex.

String (null) // ’null’

String (undefined) // «undefined»

String (true) // «правда»

String (false) // «ложь»

Строка (-22) // ‘-22’

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

Чтобы преобразовать значения в логические, используйте функцию Boolean ().

Ex.

Boolean (10) // true → явный

If (10) {…} // true → неявный

! 2 // истина à неявная

2 || «Привет» // 2 ☹

2 && «привет» // 2 ☹

Примечание. Помните, что логические операторы || и && выполняют логические преобразования внутри и возвращают значение фактического операнда вместо логического (истина или ложь).

Итак, вам может быть интересно, как запомнить все эти правдивые и ложные ценности? Не волнуйтесь, я сузил круг вопросов для вас. У меня есть список всех ложных значений 😊, и любое другое значение будет истинным, включая объекты, массивы, дату, пользовательский тип и т. Д.

Список:

Boolean('')                      // false
Boolean(0)                    // false
Boolean(-0)                    // false
Boolean(NaN)              // false
Boolean(null)                 // false
Boolean(undefined)     // false
Boolean(false)               // false

Легко, правда? 😊

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

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

Неявное преобразование сложно, потому что оно запускается в большем количестве случаев: ☹

  1. операторы сравнения (›,‹, ‹=,› =)
  2. побитовые операторы (| & ^ ~)
  3. арифметические операторы (- + * /%). Обратите внимание, что двоичный + не запускает числовое преобразование, если любой операнд является строкой.
  4. унарный + оператор
  5. оператор свободного равенства == (включая! =).
    Обратите внимание, что == не запускает числовое преобразование, если оба операнда являются строками.
Ø  Number('123')            //  123   à explicit
Ø  +'123'                         // 123     à Implicit
Ø  123 != '456'             //  true     à implicit        [Converted Internally]
Ø  4 > '5'                     //  false   à implicit           [Converted Internally]
Ø  5/null                   // Infinity  à implicit           [Converted Internally]

Решения приведены в комментариях (//):

Ø [] == 0                                    //true
Ø 1 + []                                           // ”1”
Ø  true + false                                       // 1
Ø  12 / "6"                                             // 2
Ø  "number" + 15 + 3                         // 'number153'
Ø  15 + 3 + "number"                        // '18number'
Ø  [1] > null                                          // true
Ø  "foo" + + "bar"                              // 'fooNaN'
Ø  'true' == true                                 // false
Ø  false == 'false'                               // false
Ø  null == ''                                         // false
Ø  !!"false" == !!"true"                    // true

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

Я надеюсь, что вы все ясно поняли концепцию приведения типов в приведенных выше примерах.

Увидимся, ребята, в следующем. 😊

Удачного кодирования !!