Когда я впервые изучал JavaScript, одной из вещей, которая больше всего способствовала моим многочисленным ошибкам, было плохое понимание типов данных. Сейчас, когда я наставляю новых программистов, я стараюсь представить эти концепции как можно раньше, и мне сказали, что эта информация была для них действительно полезной, поэтому я решил поделиться ею здесь.

В настоящее время JavaScript имеет 7 встроенных типов данных:

  • количество
  • нить
  • логический
  • неопределенный
  • нулевой
  • объект
  • условное обозначение

Здесь я хочу сосредоточиться на четырех из них - number, boolean, undefined и null. Эти четыре - плюс строка и символ - также известны как примитивные значения или примитивы. Любой другой тип данных в JavaScript - это объект, о котором я расскажу в следующей статье. Тип данных symbol относительно новый, и я не буду его рассматривать. В следующей статье я более подробно рассмотрю тип данных строка.

Вы можете использовать встроенный оператор typeof для проверки значения:

typeof "hello";   // "string"
typeof 8;         // "number"
typeof true;      // "boolean"
typeof undefined; // "undefined"
typeof null;      // "object"

typeof null - это ошибка в JavaScript, так как она возвращает «объект». Это было уже некоторое время и не было исправлено, потому что это могло бы «сломать» существующий код, который полагается на его функционирование таким образом.

В то время как некоторые языки, такие как Java, имеют типизированные переменные, JavaScript имеет типизированные значения. Мы говорим, что JavaScript является «динамически типизированным», что означает, что вы можете изменить значение, и его тип данных изменится:

var x;    // data type is undefined
x = 25;   // data type is now number
x = '25'; // data type is now string
x = null; // data type is now null

Что такое примитив?

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

Например, если у нас есть строка:

var str = "hello";

мы не можем напрямую изменить эту строку на «Hello». Нам нужно будет присвоить новую строку той же переменной, чтобы обновить ее:

str = "Hello";

Опять же, я подробно расскажу о струнах в следующей статье.

Сравнение значений

В JavaScript есть несколько способов сравнения значений. Они есть:

  • Равенство (==) [также называемое «свободным» равенством]
  • Неравенство (! =)
  • Идентичность (===) [также называемое «строгим» равенством]
  • Неидентификационный (! ==)
  • Меньше, чем (<)
  • Меньше или равно (‹=)
  • Больше чем (>)
  • Больше или равно (›=)

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

Давайте посмотрим на пример:

var a = 3;
var b = "3";
a == b; // true

Здесь JavaScript увидит, что тип данных одного значения - number, а другого - string. Затем он попытается преобразовать строку в число. Если два числа совпадают с использованием строгого равенства (===), возвращается истина.

Однако, если мы используем оператор идентификации (===), он вернет false, потому что number 3 и string 3 не идентичны:

var a = 3;
var b = "3";
a === b; // false

Когда вы только начинаете работать с JavaScript, рекомендуется всегда использовать строгое равенство (===) вместо свободного равенства (==), так как это приведет к меньшему количеству ошибок в вашем коде.

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

Обратите внимание на некоторые из следующих вариантов поведения:

null < 0;  // false
null <= 0; // true
null > 0;  // false
null >= 0; // true
null == 0; // false

Null не меньше, больше и равно нулю, но он меньше или равен и больше или равно нулю!

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

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

Число

В JavaScript есть так называемые «объекты-оболочки» для примитивных типов данных number [Number ()], string [String ()], boolean [Boolean ()] и symbol [Symbol ()]. Объект-оболочка Number () может использоваться для явного приведения значения к числовому типу данных:

Number('3');       // 3
Number('');        // 0
Number('three');   // NaN
Number(true);      // 1
Number(false);     // 0
Number(undefined); // NaN
Number(null);      // 0

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

Числа в JavaScript могут быть целыми или числами с плавающей запятой, поэтому следующее также будет работать:

Number('3.14');    // 3.14

Однако предпочтительный способ преобразования строки в число - использовать parseInt() или parseFloat(), в зависимости от того, хотите ли вы получить целое число или число с плавающей запятой (т. Е. Число с десятичной запятой).

Логический

Тип данных boolean может иметь одно из двух значений: истина или ложь.

Явное приведение к логическому значению:

var age;
Boolean(age); // false, because 'age' is 'undefined' here
age = 25;
Boolean(age); // true

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

var age;
if (age) {
  console.log(age);
} else {
  console.log("There is no age.");
}
age = 25;
if (age) {
  console.log(age);
} else {
  console.log("There is no age.");
}

Что эти два оператора if выведут на консоль?

Правда и ложь

Как мы видели выше, когда не-логическое значение приводится к boolean, оно становится либо true, либо false. Мы называем эти значения истинными и ложными. Следующее всегда ложно:

  • null
  • undefined
  • 0 (и -0)
  • NaN
  • '’ (пустая строка)
  • false

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

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

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

  • все объявления функций будут сохранены в памяти, и они будут немедленно доступны для запуска
  • все переменные будут подняты в начало файла, однако им будет присвоено значение undefined: им будет присвоено свое значение только при запуске кода

undefined - это значение, которое, скорее всего, будет присвоено в JavaScript, а не то, что вы, как разработчик, назначите напрямую, в отличие от null, последнего типа данных, который мы здесь рассмотрим.

Нулевой

null - это тип данных и значение, которое не является «ничем». Он часто используется в качестве значения-заполнителя, например, когда функция вызывает определенное количество аргументов, но вам не нужны функциональные возможности определенного аргумента, вы можете передать null в качестве аргумента.

Более подробную информацию вы можете прочитать здесь.

Чтобы получить более подробное представление о строках в JavaScript, ознакомьтесь со второй частью этой серии здесь.

Вопросов? Комментарии? Вы можете связаться со мной по адресу [email protected]