Важные заметки

null

В JavaScript кроме undefined существует null . Оно означает, что «значение отсутствует». Например, если создать переменную, но не задавать ей значения, то у нее будет значение undefined:

Let a; console.log(a); // undefined

Тут значения не оказалось ненамеренно. Видимо, просто еще не пришло время дать этой переменной значение.

null нужен для явного, намеренного указания, что значения нет. Можно сказать let a = null; . Например, вы попросили пользователя ввести информацию, но он ничего не ввел. В таком случае уместно записать в результат null .

null , в отличие от undefined , можно задавать вручную, передавать как аргумент в функцию и в целом использовать как любое другое явное значение.

(undefined тоже можно задавать вручную, но никогда не нужно этого делать: это значение семантически создано только для того, чтобы его генерировал компьютер, а не программист).

При сравнении null и undefined нужно быть осторожным:

Typeof null; // "object" (не "null" по историческим причинам) typeof undefined; // "undefined" null === undefined; // false null == undefined; // true null === null; // true null == null; // true !null; // true isNaN(1 + null); //false isNaN(1 + undefined); //true

Сравнение

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

A === b; 12 === 12;

Это сравнение прямое: являются ли эти данные абсолютно идентичными?

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

1 === "1"; // false 1 == "1"; // true true === 1; // false true == 1; // true

Конспект урока

Типизация в JavaScript

JavaScript имеет представление о типах: числах, строках, функциях, логических значениях и так далее. typeof возвращает строку, в которой записан тип:

NaN означает "не число", но тип этого значения - number .

Переменная без значения имеет специальное значение undefined . Тип такой переменной - undefined:

Динамическая и статическая типизация

Код конвертируется в другую форму, которую компьютер может запустить. Этот процесс называется компиляцией, а период времени, за который этот процесс происходит - стадией компиляции (compile time).

После того, как компиляция закончена, запускается программа и период, пока она запущена, называется стадией исполнения (run time).

Статически типизированные языки проверяют типы и ищут ошибки типизации на стадии компиляции.

Динамически типизированные языки проверяют типы и ищут ошибки типизации на стадии исполнения.

Иными словами: статическое типизирование означает проверку типов перед запуском программы; динамическое - проверку типов пока программа запущена.

Слабая и сильная типизация

JavaScript часто конвертирует типы автоматически:

JavaScript - это язык со слабой типизацией. У него есть представление о типах, но он расслаблено к ним относится и может оперировать значениями, можно сказать, произвольно. Чем сильнее система типизации, тем строже правила.

Явные конверсии в JavaScript

Опционально

Fun

Транскрипт урока

В одном из прошлых уроков мы говорили об ошибках и как с ними справляться. Есть несколько видов ошибок, и я хочу напомнить об одном конкретном виде. Вот небольшой фрагмент того урока:

Взгляните на этот код:

Const length = 12; const num = length(54);

Сначала мы создали константу. Помните, что это как давать чему-то название: в нашем случае - числу 12 даётся название length . В следующей строке мы вызываем функцию length и передаём ей аргумент - число 54. Но подождите! length - это не функция! Это всего лишь число. Числа - это не функции, не ящики, которые производят какие-то действия. И JavaScript пожалуется именно на это:

→ node test.js /Users/rakhim/test.js:2 const num = length(-54); ^ TypeError: length is not a function at Object. (/Users/rakhim/test.js:2:13) at Module._compile (module.js:571:32) at Object.Module._extensions..js (module.js:580:10) at Module.load (module.js:488:32) at tryModuleLoad (module.js:447:12) at Function.Module._load (module.js:439:3) at Module.runMain (module.js:605:10) at run (bootstrap_node.js:420:7) at startup (bootstrap_node.js:139:9) at bootstrap_node.js:535:3

Это Ошибка типизации : тип объекта, который вы использовали, неверный. Интерпретатор JavaScript не скажет чем что-то является , но точно скажет чем оно не является . length - это не функция.

Ошибка типизации - это как просить кошку постирать бельё. Возможно, вы хотели попросить об этом вашего друга.

В программировании "типизация" - это классификация информации. Это общий термин и разные языки программирования справляются с типизацией по-разному. Как вы уже знаете, JavaScript умеет отличать типы. Функция - это один тип, Число - другой, и вы не можете просто использовать число как функцию.

typeof - это специальный оператор, который возвращает строку, в которой написан тип.

Typeof 42; // "number" typeof 3.14; // "number" typeof NaN; // "number" typeof "Berry"; // "string" typeof true; // "boolean" typeof false; // "boolean"

42 и 3.14, очевидно, числа, несколько комбинаций букв в кавычках - строка, а true и false - булеан. Всё это - типы в JavaScript - число, строка и булеан.

NaN означает - "не число", но тип NaN - это "число". Да, я знаю. Еще одна странность JavaScript. Такие правила в этом языке.

Типизация полезна. Когда мы попытаемся запустить число, как будто это функция, JavaScript начнёт жаловаться и мы увидим ошибку и починим её. Если бы никакого обозначения типов в JavaScript не было, мы бы сталкивались либо с каким-нибудь аномальным поведением, либо с мистической ошибкой. Вместо чёткого "length - это не функция", мы бы видели что-то вроде "I"m sorry Dave, I"m afraid I can"t do that".

А что, если создать переменную, но не задать ей никакого значения? Какой в этом случае будет тип? Это ни число, ни строка, ничто... Потому что нет значения, правильно?

JavaScript в этом случае кое-что делает в тайне от вас. Переменная без значения на самом деле имеет специальное значение - "undefined". И тип такой переменной называется "undefined".

Let a; console.log(a); // undefined typeof a; // "undefined"

Например, тип number имеет множество потенциальных значений: 1, 2, -10, 69000 и другие числа. А тип undefined только одно - undefined .

Когда дело касается типизации в программировании, важно различать две концепции: динамическая против статической и слабая против сильной.

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

Код, который вы пишите, обычно конвертируется в понятную для запуска компьютером форму. Этот процесс называется компиляцией, а промежуток времени, за который это происходит - "стадией компиляции" или compile time.

После того, как компиляция закончена и программа запущена, начинается отсчёт времени, который называется "стадией исполнения" или run time.

Некоторые языки проверяют типы и ищут ошибки типизации на стадии компиляции. У них статическая типизация.

Другие языки проверяют типы и ищут ошибки типизации на стадии исполнения. Такая типизация - динамическая.

Иными словами: статическая типизация означает проверку типов перед запуском программы, динамическая - проверку типов, когда программа запущена.

C#, C++, Java, Go - статически типизированные языки. Если в одном из этих языков вы создадите число и попытаетесь проводить с ним операции, как с функцией, вы получите ошибку во время компиляции, а программа не станет запускаться - она даже не дойдёт до этой стадии, потому что ошибка типизации будет обнаружена перед исполнением, в период компиляции.

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

Вообще-то, в JavaScript обычно нет никакой компиляции, но это тема другого урока.

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

Теперь давайте поговорим о слабой и сильной типизации. Посмотрите на этот JavaScript код:

4 + "7"; // "47" 4 * "7"; // 28 2 + true; // 3 false - 3; // -3

М-да… Это… Ок, что тут происходит? Сложение числа 4 со строкой "7" даёт нам строку "47". JavaScript конвертирует число 4 в строку "4" и конкатенирует две строки - склеивает их друг с другом. JavaScript просто берёт на себя ответственность предположить, что это то, что мы хотели. Глупо обвинять его - чего мы действительно хотели? Складывать число со строкой не имеет никакого смысла. Какой-нибудь другой язык, вроде Ruby или Python просто бы пожаловался и ничего не сделал.

Произведение числа 4 со строкой "7", это, как видите, 28, по мнению JavaScript. В этом случае он сконвертировал строку "7" в число 7 и произвёл обычное умножение.

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

У этой концепции нет ничего общего с динамической и статической типизацией, смысл которых - КОГДА проверять типы. Сильная против слабой - это НАСКОЛЬКО СЕРЬЁЗНО проверять типы.

В отличие от динамичности-статичности, сила типизации это спектр. У PHP типизация немного сильнее. У Python ещё сильнее. И все они динамически типизированные языки.

JavaScript делает множество неявных конверсий, но он так же даёт нам инструменты, чтобы мы могли делать явные конверсии сами. Мы можем конвертировать строки в числа, числа в строки, булевы в строки и так далее:

Number("590"); // 590 Number("aaa!!"); // NaN Boolean(1); // true Boolean(0); // false String(true); // "true" String(false); // "false" String(44843); // "44843"

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

→
→
→
→
→
→
→
→

Переменные

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

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

Прежде чем использовать переменную, её нужно объявить с использованием ключевого слова var или let . Если речь идёт о константе, применяется ключевое слово const . Объявить переменную и присвоить ей некое значение можно и не используя эти ключевые слова, но делать так не рекомендуется.

▍Ключевое слово var

До появления стандарта ES2015 использование ключевого слова var было единственным способом объявления переменных.

Var a = 0
Если в этой конструкции опустить var , то значение будет назначено необъявленной переменной. Результат этой операции зависит от того, в каком режиме выполняется программа.

Так, если включён так называемый строгий режим (strict mode), подобное вызовет ошибку. Если строгий режим не включён, произойдёт неявное объявление переменной и она будет назначена глобальному объекту. В частности, это означает, что переменная, неявно объявленная таким образом в некоей функции, окажется доступной и после того, как функция завершит работу. Обычно же ожидается, что переменные, объявляемые в функциях, не «выходят» за их пределы. Выглядит это так:

Function notVar() { bNotVar = 1 //лучше так не делать } notVar() console.log(bNotVar)
В консоль попадёт 1 , такого поведения от программы обычно никто не ждёт, выражение bNotVar = 1 выглядит не как попытка объявления и инициализации переменной, а как попытка обратиться к переменной, находящейся во внешней по отношению к функции области видимости (это - вполне нормально). Как результат, неявное объявление переменных сбивает с толку того, кто читает код и может приводить к неожиданному поведению программ. Позже мы поговорим и о функциях, и об областях видимости, пока же постарайтесь всегда, когда смысл некоего выражения заключается в объявлении переменной, пользоваться специализированными ключевыми словами. Если в этом примере тело функции переписать в виде var bNotVar = 1 , то попытка запустить вышеприведённый фрагмент кода приведёт к появлению сообщения об ошибке (его можно увидеть в консоли браузера).

Выглядеть оно, например, может так: Uncaught ReferenceError: bNotVar is not defined . Смысл его сводится к тому, что программа не может работать с несуществующей переменной. Гораздо лучше, при первом запуске программы, увидеть такое сообщение об ошибке, чем писать непонятный код, который способен неожиданно себя вести.

Если, при объявлении переменной, её не инициализируют, не присваивают ей какого-либо значения, ей автоматически будет присвоено значение undefined .

Var a //typeof a === "undefined"
Переменные, объявленные с помощью ключевого слова var , можно многократно объявлять снова, назначая им новые значения (но это может запутать того, кто читает код).

Var a = 1 var a = 2
В одном выражении можно объявить несколько переменных:

Var a = 1, b = 2
Областью видимости переменной (scope) называют участок программы, в котором доступна (видима) эта переменная.

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

Если в функции, с использованием var , объявлена переменная, имя которой совпадает с именем некоей переменной из глобальной области видимости, она «перекроет» глобальную переменную. То есть, при обращении к такой переменной внутри функции будет использоваться именно её локальный вариант.

Важно понимать, что блоки (области кода, заключённые в фигурные скобки) не создают новых областей видимости. Новая область видимости создаётся при вызове функции. Ключевое слово var имеет так называемую функциональную область видимости, а не блочную.

Если в коде функции объявлена некая переменная, она видна всему коду функции. Даже если переменная объявлена с помощью var в конце кода функции, обратиться к ней можно и в начале кода, так как в JavaScript работает механизм поднятия переменных (hoisting). Этот механизм «поднимает» объявления переменных, но не операции их инициализации. Это может стать источником путаницы, поэтому возьмите себе за правило объявлять переменные в начале функции.

▍Ключевое слово let

Ключевое слово let появилось в ES2015, его, упрощённо, можно назвать «блочной» версией var . Область видимости переменных, объявленных с помощью ключевого слова let , ограничивается блоком, оператором или выражением, в котором оно объявлено, а также вложенными блоками.

Если само слово «let» кажется не очень понятным, можно представить, что вместо него используется слово «пусть». Тогда выражение let color = "red" можно перевести на английский так: «let the color be red», а на русский - так: «пусть цвет будет красным».

При использовании ключевого слова let можно избавиться от неоднозначностей, сопутствующих ключевому слову var (например, не удастся два раза, используя let , объявить одну и ту же переменную). Использование let за пределами функции, скажем, при инициализации циклов, не приводит к созданию глобальных переменных.

Например, такой код вызовет ошибку:

For (let i = 0; i < 5; i++) { console.log(i) } console.log(i)
Если же, при инициализации цикла, счётчик i будет объявлен с использованием ключевого слова var , то i будет доступно и за пределами цикла, после того, как он завершит работу.

В наши дни, при разработке JS-программ на основе современных стандартов, вполне можно полностью отказаться от var и использовать только ключевые слова let и const .

▍Ключевое слово const

Значения переменных, объявленных с использованием ключевых слов var или let , могут быть перезаписаны. Если же вместо этих ключевых слов используется const , то объявленной и инициализированной с его помощью константе новое значение присвоить нельзя.

Const a = "test"
В данном примере константе a нельзя присвоить новое значение. Но надо отметить, что если a - это не примитивное значение, наподобие числа, а объект, использование ключевого слова const не защищает этот объект от изменений.

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

Ключевое слово const не делает объекты иммутабельными. Оно просто защищает от изменений ссылки на них, записанные в соответствующие константы. Вот как это выглядит:

Const obj = {} console.log(obj.a) obj.a = 1 //работает console.log(obj.a) //obj = 5 //вызывает ошибку
В константу obj , при инициализации, записывается новый пустой объект. Попытка обращения к его свойству a , несуществующему, ошибки не вызывает. В консоль попадает undefined . После этого мы добавляем в объект новое свойство и снова пытаемся обратиться к нему. В этот раз в консоль попадает значение этого свойства - 1 . Если раскомментировать последнюю строку примера, то попытка выполнения этого кода приведёт к ошибке.

Ключевое слово const очень похоже на let , в частности, оно обладает блочной областью видимости.

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

Типы данных

JavaScript иногда называют «нетипизированным» языком, но это не соответствует реальному положению дел. В переменные, и правда, можно записывать значения разных типов, но типы данных в JavaScript, всё-таки, есть. В частности, речь идёт о примитивных и об объектных типах данных.

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

▍Примитивные типы данных

Вот список примитивных типов данных JavaScript:

• number (число)
• string (строка)
• boolean (логическое значение)
• null (специальное значение null)
• undefined (специальное значение undefined)
• symbol (символ, используется в особых случаях, появился в ES6)

Здесь названия типов данных приведены в том виде, в котором их возвращает оператор typeof .

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

Тип number

Значения типа number в JavaScript представлены в виде 64-битных чисел двойной точности с плавающей запятой.

В коде числовые литералы представлены в виде целых и дробных чисел в десятичной системе счисления. Для записи чисел можно использовать и другие способы. Например, если в начале числового литерала имеется префикс 0x - он воспринимается как число, записанное в шестнадцатеричной системе счисления. Числа можно записывать и в экспоненциальном представлении (в таких числах можно найти букву e).

Вот примеры записи целых чисел:

10 5354576767321 0xCC // шестнадцатеричное число
Вот дробные числа.

3.14 .1234 5.2e4 //5.2 * 10^4
Числовые литералы (такое поведение характерно и для некоторых других примитивных типов), при попытке обращения к ним как к объектам, автоматически, на время выполнения операции, преобразуются в соответствующие объекты, которые называют «объектными обёртками». В данном случае речь идёт об объектной обёртке Number .

Вот, например, как выглядит попытка обратиться к переменной a , в которую записан числовой литерал, как к объекту, в консоли Google Chrome.

Подсказка по объектной обёртке Number

Если, например, воспользоваться методом toString() объекта типа Number , он возвратит строковое представление числа. Выглядит соответствующая команда, которую можно выполнить в консоли браузера (да и в обычном коде) так:

A.toString()
Обратите внимание на двойные скобки после имени метода. Если их не поставить, система не выдаст ошибку, но, вместо ожидаемого вывода, в консоли окажется нечто, совсем не похожее на строковое представление числа 5.

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

Тип string

Значения типа string представляют собой последовательности символов. Такие значения задают в виде строковых литералов, заключённых в одинарные или двойные кавычки.

"A string" "Another string"
Строковые значения можно разбивать на несколько частей, используя символ обратной косой черты (backslash).

"A \ string"
Строка может содержать так называемые escape-последовательности, интерпретируемые при выводе строки в консоль. Например, последовательность \n означает символ перевода строки. Символ обратной косой черты можно использовать и для того, чтобы добавлять кавычки в строки, заключённые в такие же кавычки. Экранирование символа кавычки с помощью \ приводит к тому, что система не воспринимает его как специальный символ.

"I\"m a developer"
Строки можно конкатенировать с использованием оператора + .

"A " + "string"

Шаблонные литералы

В ES2015 появились так называемые шаблонные литералы, или шаблонные строки. Они представляют собой строки, заключённые в обратные кавычки (`) и обладают некоторыми интересными свойствами.

`a string`
Например, в шаблонные литералы можно подставлять некие значения, являющиеся результатом вычисления JavaScript-выражений.

`a string with ${something}` `a string with ${something+somethingElse}` `a string with ${obj.something()}`
Использование обратных кавычек упрощает многострочную запись строковых литералов:

`a string with ${something}`

Тип boolean

В JavaScript есть пара зарезервированных слов, использующихся при работе с логическими значениями - это true (истина), и false (ложь). Операции сравнения, например, такие, как == , === , < , > , возвращают true или false .

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

При этом надо отметить, что там, где ожидается значение true или false , можно использовать и другие значения, которые автоматически расцениваются языком как истинные (truthy) или ложные (falsy).

В частности, ложными значениями являются следующие:

0 -0 NaN undefined null "" //пустая строка
Остальные значения являются истинными.

Тип null

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

Тип undefined

Значение undefined , записанное в некую переменную, указывает на то, что эта переменная не инициализирована и значение для неё отсутствует.

Это значение автоматически возвращается из функций, результат работы которых не возвращается явно, с использованием ключевого слова return . Если функция принимает некий параметр, который, при её вызове, не указан, он также устанавливается в undefined .

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

Typeof variable === "undefined"

▍Объекты

Все значения, не являющиеся примитивными, имеют объектный тип. Речь идёт о функциях, массивах, о том, что мы называем «объектами», и о многих других сущностях. В основе всех этих типов данных лежит тип object , и они, хотя и во многом друг от друга отличаются, имеют и много общего.

Выражения

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

Арифметические выражения

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

1 / 2 i++ i -= 2 i * 2

Строковые выражения

Результатом вычисления таких выражений являются строки.

"A " + "string" "A " += "string"

Первичные выражения

В эту категорию попадают литералы, константы, ссылки на идентификаторы.

2 0.02 "something" true false this //контекст выполнения, ссылка на текущий объект undefined i //где i является переменной или константой
Сюда же можно отнести и некоторые ключевые слова и конструкции JavaScript.

Function class function* //генератор yield //команда приостановки/возобновления работы генератора yield* //делегирование другому итератору или генератору async function* //асинхронное функциональное выражение await //организация ожидания выполнения асинхронной функции /pattern/i //регулярное выражение () //группировка

Выражения инициализации массивов и объектов

//литерал массива {} //объектный литерал {a: 1, b: 2} {a: {b: 1}}

Логические выражения

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

A && b a || b !a

Выражения доступа к свойствам

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

Object.property //обращение к свойству (или методу) объекта object object["property"]

Выражения создания объектов

new object() new a(1) new MyRectangle("name", 2, {a: 4})

Выражения объявления функций

function() {} function(a, b) { return a * b } (a, b) => a * b a => a * 2 () => { return 2 }

Выражения вызова

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

A.x(2) window.resize()

Работа с объектами

Выше мы уже сталкивались с объектами, говоря об объектных литералах, о вызове их методов, о доступе к их свойствам. Здесь мы поговорим об объектах подробнее, в частности, рассмотрим механизм прототипного наследования и использование ключевого слова class .

▍Прототипное наследование

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

У каждого JavaScript-объекта есть особое свойство (__proto__), которое указывает на другой объект, являющийся его прототипом. Объект наследует свойства и методы прототипа.

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

Const car = {}
Или мы создали объект, воспользовавшись конструктором Object .

Const car = new Object()
В любом из этих случаев прототипом объекта car будет Object.prototype .

Если создать массив, который тоже является объектом, его прототипом будет объект Array.prototype .

Const list = //или так const list = new Array()
Проверить это можно следующим образом.

Car.__proto__ == Object.prototype //true car.__proto__ == new Object().__proto__ //true list.__proto__ == Object.prototype //false list.__proto__ == Array.prototype //true list.__proto__ == new Array().__proto__ //true
Здесь мы пользовались свойством __proto__ , оно не обязательно должно быть доступно разработчику, но обычно обращаться к нему можно. Надо отметить, что более надёжным способом получить прототип объекта является использование метода getPrototypeOf() глобального объекта Object .

Object.getPrototypeOf(new Object())
Все свойства и методы прототипа доступны объекту, имеющему этот прототип. Вот, например, как выглядит их список для массива.

Подсказка по массиву

Базовым прототипом для всех объектов является Object.prototype .

Array.prototype.__proto__ == Object.prototype
У Object.prototype прототипа нет.

То, что мы видели выше, является примером цепочки прототипов.

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

Помимо создания объектов с использованием оператора new и применения объектных литералов или литералов массивов, создать экземпляр объекта можно с помощью метода Object.create() . Первый аргумент, передаваемый этому методу, представляет собой объект, который станет прототипом создаваемого с его помощью объекта.

Const car = Object.create(Object.prototype)
Проверить, входит ли некий объект в цепочку прототипов другого объекта, можно с использованием метода isPrototypeOf() .

Const list = Array.prototype.isPrototypeOf(list)

Функции-конструкторы

Выше мы создавали новые объекты, пользуясь уже имеющимися в языке функциями-конструкторами (при их вызове используется ключевое слово new). Такие функции можно создавать и самостоятельно. Рассмотрим пример.

Function Person(name) { this.name = name } Person.prototype.hello = function() { console.log(this.name) } let person = new Person("Flavio") person.hello() console.log(Person.prototype.isPrototypeOf(person))
Здесь мы создаём функцию-конструктор. При её вызове создаётся новый объект, на который указывает ключевое слово this в теле конструктора. Мы добавляем в этот объект свойство name и записываем в него то, что передано конструктору. Этот объект возвращается из конструктора автоматически. С помощью функции-конструктора можно создать множество объектов, свойства name которых будут содержать то, что передано при их создании конструктору.

После создания конструктора мы добавляем в его прототип функцию, которая будет выводить в консоль значение свойства name объекта, созданного с помощью этой функции. Все объекты, созданные с помощью этого конструктора, будут иметь один и тот же прототип, а значит и пользоваться одной и той же функцией hello() . Это несложно проверить, создав ещё один объект типа Person и сравнив его функцию hello() с функцией уже имеющегося в примере объекта (имя функции в таком случае записывают без скобок).

▍Классы

В стандарте ES6 в JavaScript пришло такое понятие как «класс».

До этого в JavaScript можно было пользоваться лишь вышеописанным механизмом прототипного наследования. Этот механизм непривычно выглядел для программистов, пришедших в JS из других языков. Поэтому в языке и появились классы, которые, по сути, являются «синтаксическим сахаром» для прототипного механизма наследования. То есть, и объекты, созданные традиционным способом, и объекты, созданные с использованием классов, имеют прототипы.

Объявление класса

Вот как выглядит объявление класса.

Class Person { constructor(name) { this.name = name } hello() { return "Hello, I am " + this.name + "." } }
У класса есть идентификатор, который можно использовать для создания новых объектов с применением конструкции new ClassIdentifier() .

При создании нового объекта вызывается метод constructor , ему передаются параметры.

В классе можно объявлять методы. В нашем случае hello() - это метод, который могут вызывать все объекты, созданные на основе класса. Вот как выглядит создание нового объекта с использованием класса Person .

Const flavio = new Person("Flavio") flavio.hello()

Наследование, основанное на классах

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

Если класс, расширяющий другой класс (наследник этого класса) имеет метод, имя которого совпадает с тем, который есть у класса-родителя, этот метод имеет преимущество перед исходным.

Class Programmer extends Person { hello() { return super.hello() + " I am a programmer." } } const flavio = new Programmer("Flavio") flavio.hello()
При вызове метода hello() в вышеприведённом примере будет возвращена строка Hello, I am Flavio. I am a programmer .

В классах не предусмотрено наличие переменных (свойств), свойства создаваемых с помощью классов объектов нужно настраивать в конструкторе.

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

Статические методы

Методы, описываемые в классе, можно вызывать, обращаясь к объектам, созданным на основе этого класса, но не к самому классу. Статические (static) методы можно вызывать, обращаясь непосредственно к классу.

Приватные методы

В JavaScript нет встроенного механизма, который позволяет объявлять приватные (частные, закрытые) методы. Это ограничение можно обойти, например, с использованием замыканий.

Геттеры и сеттеры

В классе можно описывать методы, предваряя их ключевыми словами get или set . Это позволяет создавать так называемые геттеры и сеттеры - функции, которые используются для управления доступом к свойствам объектов, созданных на основе класса. Геттер вызывается при попытке чтения значения псевдо-свойства, а сеттер - при попытке записи в него нового значения.

Class Person { constructor(name) { this.userName = name } set name(value) { this.userName = value } get name() { return this.userName } }

Итоги

В этом материале мы поговорили о переменных, о типах данных, о выражениях и о работе с объектами в JavaScript. Темой нашего следующего материала будут функции.

Уважаемые читатели! Если вы уже давно пишете на JS, просим рассказать о том, как вы относитесь к появлению в языке ключевого слова class.

В этом уроке мы познакомимся с очень важным понятием – типы данных JavaScript. Мы рекомендуем внимательно отнестись к данному понятию – если не осознать его с самого начала, то потом придется часто сталкиваться со странным поведением созданной вами программы.

Динамическая типизация

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

В JavaScript типы данных можно разделить на две категории: простые (их также называют примитивными) типы и составные (их также называют ссылочными или объекты).

JavaScript – это слабо типизированный или динамический язык программирования, который позволяет определять типы данных, осуществлять синтаксический анализ и компиляцию как говорится «на лету», на этапе выполнения программы. Это значит, что вам не нужно определять тип переменной заранее. Тип определится автоматически во время выполнения программы.
Таким образом, в различных участках программы одна и та же переменная может принимать значения разных типов:

Типы данных

Стандарт ECMAScript® определяет следующие типы данных:

• Простые (их также называют примитивными) типы:
  • логический (англ. Boolean) - может принимать два возможных значения, иногда называемых истиной (true) и ложью (false);
  • нулевой (англ. Null) – значение null представляет ссылку, которая указывает, обычно намеренно, на несуществующий или некорректный объект или адрес;
  • неопределённый (англ. Undefined) – обозначает предопределенную глобальную переменную, инициализированную неопределенным значением;
  • числовой (англ. Number) – числовой тип данных в формате 64-битного числа двойной точности с плавающей запятой;
  • строковый (англ. String) – представляет собой последовательность символов, используемых для представления текста;
  • символ (англ. Symbol​) - тип данных, экземпляры которого уникальны и неизменяемы. (новый в ECMAScript 6).
• Объектный (англ. Object) – это коллекция именованных значений, которые обычно называют свойствами (properties) объекта.

Разница между примитивными и составными типами

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

Сценарий в приведенном примере объявляет переменные, выполняет их инициализацию (присваивает значения), а затем выводит тип каждой переменной.

Разница между примитивными и составными типами данных проявляется при копировании их значений.

Когда переменной присваивается значение простого типа, то в переменную записывается само значение (например число). Когда мы присваиваем переменную простого типа в другую, она копирует значение . В результате каждая переменная будет иметь своё значение и изменения в одной из переменных никак не сказывается на значении другой переменной:

Когда переменной присваиваем значение составного (ссылочного) типа, то в переменную записывается ссылка на значение (ссылка на объект ). Когда мы присваиваем одну переменную (в значении которой ссылка на составное значение) другой переменной, то происходит копирование ссылки на составное значение. В результате обе переменные ссылаются на одно и то же составное значение и изменения в значении одной из переменных будут сказываться на другой переменной:

Примитивные типы

Все типы данных в JavaScript, кроме объектов, являются неизменяемыми или иммутабельными (англ. immutable). Это значит, что их значения не могут быть модифицированы, а только перезаписаны новым другим значением. Например, строки нельзя корректировать посимвольно – их можно переписать только полностью. Значения таких типов называются "примитивными".

Простейшие данные, с которыми может оперировать программа, называются литералами. Литералы - это числа или строки, которые используются для представления значений в JavaScript. Предоставляемая информация может быть самой разнообразной, а поэтому значения бывают различных типов. Простейшие типы данных в JavaScript называются основными типами данных: числа, строки и логические значения. Все они относятся к "примитивным".

Булевый (логический) тип «boolean»

Логические, или булевы значения (по фамилии их изобретателя - Буля), могут иметь лишь одно из двух значений: true (истина) или false (ложь). Значения true или false обычно появляются в операциях сравнения или логических операциях.

Приведенная ниже программа создает булеву переменную, а затем тестирует ее значение с использованием инструкции if/else:

В качестве сравнительного выражения можно использовать любое выражение. Любое выражение, которое возвращает значение 0, null, undefined или пустую строку, интерпретируется как false . Выражение, определяющее какое-либо другое значение, интерпретируется как true .

Примечание: При записи булевых значений их не заключают в кавычки: var myVar = true;
В то же время объявление var myVar = "true" создает строковую переменную.

Тип данных Number

В JavaScript, нет различия между целым числом и числом с плавающей точкой – по сути, JavaScript представляет все числа в качестве значения с плавающей точкой.

Для представления чисел в JavaScript используется 64-битный формат, определяемый стандартом IEEE-754 . Этот формат способен представлять числа в диапазоне от ±1,7976931348623157 × 10 308 до ±5 × 10 -324 .

Число, находящееся непосредственно в коде программы, называется числовым литералом. Помимо десятичных целых литералов JavaScript распознает шестнадцатеричные значения.
Числа в шестнадцатиричном формате могут включать любую последовательность цифр от 0 до 9 и буквы от a до f, которая обязательно начинается с последовательности символов «0x».

Var a = 255; var b = 0xFF; // Число 255 в шестнадцатеричной системе исчисления

Кроме того, JavaScript содержит специальные числовые значения:

• NaN (не число или ошибка вычислений). Является результатом некорректной математической операции над недопустимыми данными, такими как строки или неопределенное значение.
• Infinity (положительная бесконечность). Используется, если положительное число слишком велико и не может быть представлено в JavaScript.
• -Infinity (отрицательная бесконечность). Используется, если отрицательное число слишком велико и не может быть представлено в JavaScript.
• ±0 (положительный и отрицательный 0). JavaScript различает положительный и отрицательный ноль.

Тип данных String

Строковый тип (string) - это неизменяемая, упорядоченная последовательность 16-битных значений, каждое из которых представляет символ Unicode (буквы, цифры, знаки пунктуации, специальные символы и пробелы). Строки могут быть пустыми либо состоять из одного и более символов. Строки создаются при помощи двойных (") или одинарных (") кавычек. В строке, ограниченной парой одинарных кавычек, можно использовать двойные кавычки, и наоборот – одинарные кавычки можно использовать в строке, заключенной в пару двойных кавычек:

В JavaScript нет разницы между двойными и одинарными кавычками, но кавычки в начале и конце строки не должны различаться. Например, такое выражение вызовет синтаксическую ошибку:

var firstName = "Max"; //синтаксическая ошибка - разные кавычки

Примечание: В JavaScript нет специального типа данных для одного символа, такого как char в C, C++ и Java. Одиночный символ представлен строкой единичной длины.

Тип данных Null

Нулевой тип (null) содержит единственное специальное значение – null .

Ключевое слово null невозможно использовать в качестве имени функции или переменной. Значение null является ссылкой на «пустой» объект и имеет специальное назначение – обычно оно используется для инициализации переменной, которой впоследствии будет присвоено значение.

Оператор typeof для значения null возвращает строку «object», что свидетельствует о том, что значение null является специальным «пустым» объектом.

Тип данных Undefined

Неопределенный тип (undefined) образует свой собственный тип, который содержит единственное специальное значение – undefined . Такое значение имеет переменная, объявленная с помощью оператора var , но не инициализированная:

Значение undefined возвращается при обращении к переменной, которой никогда не присваивалось значение, а также к несуществующему свойству объекта или элементу массива.

Следует отметить, что переменная со значением undefined отличается от переменной, которая вообще не определена:

В этом примере метод alert() выводит значение переменной age , то есть undefined . Во втором случае в метод alert() передается необъявленная переменная car , что приводит к ошибке.

Следующй пример может несколько запутать начинающих программистов, т.к. оператор typeof и для неинициализированной, и для необъявленной переменной возвращает значение undefined:

В приведенном примере переменная age объявлена, но в неё ничего не записано, поэтому её значение как раз и есть undefined . Переменная car не объявлена – её, по сути, нет. Тем не менее, typeof возвращает строку undefined в обоих случаях. Некоторый смысл в этом, конечно, есть, потому что с любой из этих переменных невозможно выполнить никаких операций, хотя технически они совершенно разные.

Примечание: Рекомендуется всегда выполнять инициализацию объявленной пременной. В таком случае вы будете знать, что оператор typeof возвращает undefined из-за того, что переменная не была объявлена, а не потому, что она не инициализирована.

Значение undefined является производным от null , так что в ЕСМА-262 оператор эквивалентности == считает их равными:

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

Чтобы отличать null и undefined в программе можно использовать оператор идентичности === :

Тип данных Символ (Symbol)

Символ (symbol) является нововведением JavaScript начиная с ECMAScript версии 6. Символ – это уникальное, неизменяемое, примитивное значение, которое служит для создания уникальных идентификаторов.

Чтобы создать символ нужно вызвать функцию Symbol:

var mySymbol = Symbol();

Для определения символа можно использовать оператор typeof , в случае если значения является символом будет возвращена строка symbol:

У функции Symbol есть необязательный параметр - строка, которая служит для описания символа:

Важной особенностью символа также является то, что его значение уникально. Вы можете использовать символ как имя свойства, которое гарантированно не будет повторяться с любым другим свойством. Даже, если у двух символов одинаковое имя, то это не значит, что они равны:

Тип данных Object

В дополнение к рассмотренным выше примитивным типам данных JavaScript поддерживает составной тип данных – объект (object). Объект состоит из многих значений (либо элементарных, таких как числа и строки, либо сложных, например других объектов), которые называются свойствами объекта. Доступ к свойствам осуществляется по имени свойства (иногда говорят «по ключу»).

Имя свойства является строкой, поэтому можно считать, что объекты связывают строки со значе­ниями. Вместе эти фрагменты информации образуют пары «ключ-значение».

В JavaScript объекты можно создавать одним из двух синтаксисов:

1. var obj = {}; // с помощью объектного литерала 2. var obj = new Object(); // с помощью метода, называемого конструктором

Создание объекта с помощью объектного литерала начинается с определения обыч­ной переменной. В правой части этой инструкции записывается литерал объекта – это заключенный в фигурные скобки {} список разделенных запятой пар "имя-значение" , заключенный в фигурные скобки. Имя свойства и значение отделены друг от друга двоеточием:

var cat = { "legs": 4, "name": "Мурзик", "color": "Рыжий" }

Второй способ создания объектов связан с использованием конструктора Object() . При этом сначала используется выражение new Object() , а затем определяются и инициализируются свойства полученного объекта:

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

Любое выражение, которое возвращает значение 0, null, undefined или пустую строку, интерпретируется как false .

Строки создаются при помощи двойных (") или одинарных (") кавычек. В строке, ограниченной парой одинарных кавычек, можно использовать двойные кавычки, и наоборот – одинарные кавычки можно использовать в строке, заключенной в пару двойных кавычек.

Значение null является ссылкой на «пустой» объект и имеет специальное назначение – обычно оно используется для инициализации переменной, которой впоследствии будет присвоено значение.

Значение (undefined) имеет переменная, объявленная с помощью оператора var , но не инициализированная.

Решение:

JavaScript или JS (сокращенно) не простой язык и начинающие разработчики узнают об этом не сразу. По началу они узнают азы и все кажется красочным и прекрасным. Заходя чуть глубже, появляются JavaScript массивы, объекты, callback’и и все подобное, что часто выносит мозг.

В JavaScript важно правильно проверять тип переменной. Допустим вы хотите узнать является ли переменная массивом или объектом? Как это правильно проверить? В этом конкретном случае, есть хитрости во время проверки и именно о них будет эта запись. Давайте сразу приступим.

Проверка типа переменной

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

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

Var _comparison = { string: "строка", int: 99, float: 13.555, object: {hello: "привет"}, array: new Array(1, 2, 3) }; // Вернет массив с ключами объекта var _objKeys = Object.keys(_comparison); for(var i = 0; i <= _objKeys.length - 1; i++) { // выведем в консоль тип каждой переменной console.log(typeof _comparson[_objKeys[i]]); }

Результат выполнения кода:

String number number object object

Верно? — Нет, конечно. Есть две проблемы. Каждая из них будет подробно описана и предложено решение.

Первая проблема: float число, выводится как number

Comparison.float не является числом и вместо number должно быть float (число с плавающей точкой).Чтобы это исправить, можно создать функцию с проверкой как в коде ниже.

Var _floatNumber = 9.22; var _notFloatNumber = 9; console.log(isFloat(_floatNumber)); console.log(isFloat(_notFloatNumber)); console.log(isFloat("")); function isFloat(n){ return Number(n) === n && n % 1 !== 0; }

Функция isFloat() выполняет проверку всех значений на числа с плавающей точкой. Сначала проверяется равна ли переменная n числу (Number(n) === n) и если да, то делается еще одна проверка на деление с остатком и если остаток есть, то возвращается булевой (true или false ) результат (n % 1 !== 0).

В примере выше она возвращает true , false и false . Первое значение имеет float тип, второе нет — это обычное число и последнее всего лишь пустая строка, которая не подходит под правила.

Вторая проблема: массив определился как объект

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

Есть несколько способов для проверки переменной на тип массива.

Первый вариант (хороший вариант). Проверяем принадлежность data к массиву с помощью instanceof ().

Var data = new Array("hello", "world"); var isArr = data instanceof Array;

Второй вариант (хороший вариант). Метод Array.isArray() возвращает булевое значение, которе будет зависеть от того является ли переменная массивом или нет ().

Var data = new Array("hello", "world"); var isArr = Array.isArray(data);

Третий вариант (самый лучший, но длинный). Для удобности, вы можете сделать этот способ функцией. Используя Object, мы делаем . Если результат Object.prototype.toString.call(data) не равен значит переменная не массив ().

Var data = new Array("hello", "world"); var isArr = Object.prototype.toString.call(data) == ""; console.log(isArr);

Последний результат в виде удобной функции:

Function isArray(data) { return Object.prototype.toString.call(data) == "" }

Теперь вы можете вызвать функции isArray() и как аргумент задать массив или что-то иное и посмотреть результат.

Послесловие

Запись получилась достаточно большой, чем изначально задумывалась. Но я ей доволен, потому что она достаточно кратко и четко описывает затруднения при проверке переменных в JavaScript и как их обойти.

Если у вас остались какие-либо вопросы — пишите их ниже к этому записи. Я буду рад помочь.

Для создания имён переменных в JavaScript установлены правила синтаксиса:

• Для имён переменных используются символы: a-z, A-Z, цифры, символ $, символ знак подчёркивания (_).
• Имя переменной не может начинаться с цифры.
• JavaScript чувствителен к регистру, об этом нужно помнить при программировании. itcounter и itC ounter - это разные переменные.
• В JavaScript нет ограничений на длину имени переменной.

Примеры правильных имён переменных:

• itcounter
• $_itcounter
• it_counter

Ошибочные имена переменных:

• 9room
• it-counter
• #itcounter
• &itcounter

Переменные объявляются командой var .

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

Строковые переменные

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

Var $stroka_1 = "Привет!"; var $stroka_2 = "Осторожно!";

В строку, созданную одинарной кавычкой, можно включить двойную кавычку и наоборот.

Var $stroka_1 = ""Привет!" - это приветствие."; var $stroka_2 = ""Осторожно!" - это предупреждение."; document.write($stroka_1); document.write("

Чтобы вывести кавычку того же типа, её нужно экранировать символом обратного слэша. Всё просто:

"); document.write($stroka_2);

Значения переменных можно присваивать другим переменным:

Var $stroka_1 = "\"Привет!\" - это приветствие."; var $stroka_2 = "\"Осторожно!\" - это предупреждение."; document.write($stroka_1); document.write("
"); document.write($stroka_2); $stroka_2 = $stroka_1; document.write("
"); document.write($stroka_2);

В этом примере мы сначала в переменную $stroka_2 присвоили одно строковое значение, но потом присвоили ей значение переменной $stroka_1.

Объединение строк

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

Объединение (конкатенация) строк в JavaScript осуществляется с помощью знака + .

Для вывода на экран 2 строковых переменных разделённых тегом
переменных можно использовать одну команду document.write() .

Var $stroka_1 = ""Привет!" - это приветствие."; var $stroka_2 = ""Осторожно!" - это предупреждение."; document.write($stroka_1 + "
" + $stroka_2);

Оператор конкатенации + также можно использовать в переменных:

Var $stroka_1 = ""Привет!" - это приветствие."; var $stroka_2 = ""Осторожно!" - это предупреждение."; var $stroka_3 = $stroka_1 + "
" + $stroka_2; document.write($stroka_3);

Числовые переменные

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

Var $count_1 = 23; var $count_2 = 10.34; document.write($count_1 - $count_2);

Теперь другой пример:

Var $count_1 = 23; // Числовая переменная. var $stroka_1 = "57"; // Строковая переменная. document.write($stroka_1 + $count_1);

Видите, значение переменной $stroka_1 взято в кавычки, значит это текстовая переменная. Потом мы складываем текстовую и числовую переменную и получаем строку "5723", так работает JavaScript в таких случаях - превращает число в строку и добавляет к суммируемой строке.

Булевы переменные

Есть такой тип переменных - булевы. Всё просто, тут только два значения: истина и ложь, то есть true (истина) и false (ложь).

Этот тип данных используется в операциях сравнения. Вот простые примеры:

• 9 > 1 - это истина.
• 2 > 5 - это ложь.

var $count = 2

Теперь попробуем подставить булевы значения в арифметические действия. Суммируем две операции сравнения:

Var $count = (3 > 2) + (4 > 2); document.write($count);

Эта странная запись, я знаю. Но переменная $count будет равна 2. В математическом контексе значение true = 1, а значение false = 0.

Операции сравнения используются в часто применяемой инструкции if в JavaScript. Слово if по английски значит - если.

Var $count = 100; if ($count == 100) document.write("Переменная $count равна 100.");

В данном примере сообщение будет выведено на экран, так как условие инструкции if ($count == 100) равно истине (true). Если изменить значение переменной $count на 99, то условие ($count == 100) станет равно false (ложь) и на экран ничего не выведется.

Простые типы переменных

В JavaScript переменные классифицируются на несколько типов. Строковой, числовой и булевый (логический) типы мы уже рассмотрели. Вот более широкий список простых типов:

• string - строковая переменная.
• number - числовая переменная.
• boolean - булева переменная.
• null - специальное значение «ничто».
• undefined - тип «значение не присвоено».

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

Var $price = null; // это значит что цена не известна.

В JavaScript можно узнать тип переменных при помощи инструкции typeof .

Var $count; document.write(typeof $count + "
"); var $count = true; document.write(typeof $count + "
"); var $count = "true"; document.write(typeof $count + "
"); var $count = 100; document.write(typeof $count + "
"); var $count = null; document.write(typeof $count + "
");

Синтаксис инструкции typeof может быть таким:

• typeof $count
• typeof($count)

Итак, запустите код из последнего примера и посмотрите на результат. Тип переменной null будет object. Этот ошибка в языке, и она, вероятно, никогда не будет исправлена из-за необходимости сохранения совместимости уже написаных JavaScript сценариев с новыми версиями языка.

Тип object - это уже не примитивный тип, о нём мы будем говорить в других уроках.