For array in javascript: for…of — JavaScript | MDN

Number

Проверка числа в JavaScript работает должным образом, typeof возвращает "number" :

 console.log(typeof 37) // "number"
console.log(typeof 2.71828) // "число"
console.log(typeof Math.E) // "число"
console.log(typeof Infinity) // "число"
// Тип NaN — «число», несмотря на то, что NaN означает «Не число»:
console.log(typeof NaN) // "число"
// Явный вызов номера — это один из способов анализа номера:
console. log(typeof Number(`1`)) // "число"
// Функции parseInt и parseFloat — это другие способы разбора:
console.log(typeof parseInt(`100`)) // "число"
console.log(typeof parseFloat(`100.01`)) // "число"
// Ошибки синтаксического анализа приводят к NaN, а NaN отравляет другую математику:
console.log(typeof (2 * parseInt(`invalid`))) // "число" 

Обратите внимание, что это означает, что проверка на NaN

 const mayBeNaN = NaN // NaN означает «Не-a- Число"
// Все сравнивается с ложью по сравнению с NaN:
console.log(37 === NaN) // ложь
console.log(mightBeNaN === NaN) // ложь
// NaN — единственное значение, которое не равно самому себе:
console.log(mightBeNaN !== mayBeNaN) // true
// Создание недопустимой даты приводит к значению NaN:
console.log(новая дата(`invalid`) !== новая дата(`invalid`)) // true
// Для улучшения читаемости кода некоторые разработчики предпочитают Number. isNan():
console.log(Number.isNan(mightBeNaN)) // true 

BigInt

Проверка примитивного типа BigInt работает должным образом; typeof для поддерживаемых браузеров вернет "bigint" :

 console.log(typeof 37n) // bigint 

что является наибольшим числом, которое JavaScript может надежно представить с помощью примитива Number. BigInt можно использовать для произвольно больших целых чисел», — говорится в веб-документации MDN.

Официально BigInt был добавлен в современный JavaScript как часть ES11 (ECMAScript 2020) и поддерживается Chrome и, следовательно, Node.js, Firefox и Edge.

String

Можно надеяться, что проверка строки в JavaScript довольно проста.

 console.log(typeof '37') // string
console.log(typeof "37") // строка
console.log(typeof `37`) // строка
// Обратите внимание, что typeof всегда возвращает строку:
console. log(typeof (typeof 37)) // строка
// Функция-оболочка String() преобразует что угодно в строку:
console.log(Строка(37)) 

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

Символ

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

«Значение символа может использоваться в качестве идентификатора свойств объекта; это единственная цель типа данных», — говорится в веб-документах MDN.

Как и следовало ожидать, тип Symbol() действительно "символ" :

 console.log(typeof Symbol()) // символ
console.log(typeof Symbol(37)) // символ
console.log(typeof Symbol.iterator) // символ
константный символUno = Символ()
const symbolDos = Symbol(37)
константный символTres = Символ("37")
console.log(typeof symbolUno) // символ
console.log(String(symbolTres)) // Символ(37)
// Каждое значение символа, возвращаемое функцией Symbol(), уникально:
console.  log(Символ() === Символ()) // ложь
console.log(Символ(37) === Символ(37)) // ложь
console.log(Symbol("37") === Symbol("37")) // false 

Функция

Функции легко проверяются на предмет использования ключевого слова typeof , которое работает полностью, как и ожидалось, возвращая "функция" :

 console.log(typeof function myFunction() {}) // function
console.log(тип класса myClass {}) // функция
console.log(typeof (() => {})) // функция
// Сюда входят встроенные функции, например Number.isNaN():
console.log(typeof Number.isNaN) // "функция"
// Но не свойства, конечно:
console.log(typeof "".length) // "число"
// И вызов функции проверит тип возвращаемого значения:
console.log(typeof Number.isNaN()) // "логическое"
console.log(typeof Number.isNaN(37)) // "логическое" 

Объект (означает объект или массив)

Пока рассматриваемое значение не равно нулю, typeof , возвращающее «объект» , означает, что значение JavaScript является объектом JavaScript.

Одним из типов объектов, встроенных в JavaScript, является массив, а typeof массива — это "object" : typeof [] === `object` // true .

ECMAScript 5 представил метод Array.isArray() для проверки наличия массива, поскольку typeof не сможет отличить массивы от других объектов.

Прототипы JavaScript

Вот как проверить тип объектов и массивов:

 const helloWorldObject = { hello: "world" }
console.log(typeof helloWorldObject) // 'объект'
// используем Array.isArray или Object.prototype.toString.call
// чтобы отличить обычные объекты от массивов
const fibonacciArray = [1, 1, 2, 3, 5, 8]
console.log(typeof fibonacciArray) // 'объект'
console. log(Array.isArray(helloWorldObject)) // ложь
console.log(Array.isArray(fibonacciArray)) // правда
// Есть еще одна вспомогательная функция, правда, немного длинная:
console.log(Object.prototype.toString.call(helloWorldObject)) // [объект Объект]
console.log(Object.prototype.toString.call(fibonacciArray)) // [массив объектов]
// Регулярное выражение имеет собственный объект, RegExp
const myRegExp = /поиск/
console.log(typeof myRegExp) // 'объект'
console.log(myRegExp instanceof RegExp) // true
console.log(Object.prototype.toString.call(myRegExp)) // [объект RegExp]
// Собственный объект Date встроен в JavaScript
const emptyDate = новая дата()
const invalidDate = новая дата («сбой»)
console.log(typeof emptyDate) // 'объект'
console.log(typeofvalidDate) // 'объект'
// Проверка даты немного сложнее
console.log(пустой экземпляр Dateof Date)
console.log(invalidDate instanceof Date)
console.log(Object.prototype.toString.call(invalidDate)) // [Дата объекта]
// Надежная проверка даты требует проверки NaN путем проверки NaN:
console. log(invalidDate instanceof Date && !Number.isNaN(invalidDate.valueOf())) // true 

Подробный оператор JavaScript Object.prototype.toString.call() может различать общие объекты, массивы и другие объекты, поскольку он возвращает строку, которая определяет тип объекта более подробно, чем typeof .

Аналогичным образом вспомогательный метод Array.isArray() или ключевое слово instanceof можно использовать для проверки массивов или объектов любого типа соответственно.

Объяснение типов и оболочек объектов

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

 // "Следующее сбивает с толку, опасно и расточительно. Избегайте их." -Документы MDN
typeof new Boolean(false) === 'объект'; // истинный
typeof new Number(37) === 'объект'; // истинный
typeof new String(`Hello World!`) === 'object'; // true 

Зачем существуют эти оболочки объектов, если их нельзя вызывать явно?

По сути, вызов свойства строки, такого как "". length , приводит к тому, что JavaScript создает объект-оболочку и интерпретирует код следующим образом:

 "".length === String("").length // true 

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

Почему не следует использовать объекты-оболочки

Подобным образом объекты-оболочки изменяют функцию == и === операторов равенства в JavaScript.

И поведение фактически меняется только тогда, когда ключевое слово new используется с вызовом оболочки объекта, как показано в следующем примере:

 const примитивная строка = `Hello world!` // строка примитивного типа
constwrappedString = new String(`Hello world!`) // объект-оболочка
console.log (тип примитивной строки) // "строка"
console.log(typeofwrappedString) // "объект"
console.log(primitiveString == wrapString) // правда
console.log(primitiveString === wrapString) // false
const почтиWrappedString = String(`Hello world!`) // вызов оболочки без нового
console. log(тип почтиWrappedString) // "строка"
console.log(primitiveString === почтиWrappedString) // true 

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

Typeof и объекты хоста в JavaScript

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

Другими словами, хост-объекты — это специальные объекты, выходящие за рамки стандартных встроенных объектов или нативных объектов, предоставляемых JavaScript.

Например, объект окна предоставляется средой браузера, в то время как среда node.js предоставляет другие объекты хоста.

Это означает, что ключевое слово typeof также зависит от реализации, по крайней мере, в случае объектов хоста.

При этом современные реализации, вероятно, будут возвращать «объект» как тип из хост-объектов. Например:

 typeof window // "object" 

Являются ли статические типы будущим в JavaScript?

Поскольку JavaScript является языком с динамической типизацией, но у typeof есть свои особенности, некоторые разработчики предпочитают автоматическую или статическую проверку типов с помощью таких языков, как TypeScript, или средств проверки статических типов, таких как Flow.

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

Несмотря на то, что это полезно, использование TypeScript или Flow добавит совершенно новый уровень сложности в ваше программирование на JavaScript.

Для ванильного JavaScript освоение typeof — это все, что вам нужно, чтобы проверять типы данных как чемпион.

Подробнее о JavaScript: Создание шага сборки только для Npm для JavaScript — простой способ

Преимущества Typeof в JavaScript

Ключевое слово typeof полезно для проверки типов в JavaScript, но у него есть некоторые предостережения, связанные с историческими ошибками.