Типы данных в javascript кратко

Обновлено: 02.07.2024

В JavaScript существует 8 типов данных. Каждое значение, которые можно хранить в переменных и константах, соответствует одному из них.

Типы данных в JavaScript

Тип данных Описание Пример
String текстовая информация — набор символов 'Привет' , "Привет, мир!" и т.д.
Number целые числа или числа с плавающей точкой 3 , 3.234 , 3e-2 и т.д.
BigInt целые числа произвольной длины 900719925124740999n , 1n и т.д.
Boolean логическое значение true или false true , false
undefined тип неинициализированной переменной let a;
null только специальное значение null let a = null;
Object пары ключ-значение коллекции данных let student = < >;
Symbol используют для создания уникальных идентификаторов в объектах let value = Symbol("Привет")

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

Строки в JavaScript

В типе String хранится текст — набор символов. В JavaScript строки выделяются кавычками или обратными апострофами:

  • Одинарными кавычками: 'Привет' .
  • Двойными кавычками: "Привет" .
  • Обратными апострофами: `Привет` .

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

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

Числа в JavaScript

Для хранения числовых данных в JavaScript существует два типа: Number и BigInt .

Number

В типе Number хранятся целые числа (integer) и числа с плавающей точкой (float) от -25^3 - 1 до 25^3 - 1.

В этом типе также могут храниться значения Infinity (бесконечность), +Infinity (+бесконечность), -Infinity (-бесконечность), NaN (not a number, не число).

BigInt

В типе BigInt можно хранить числа неопределенного размера, то есть если они не влезают в промежуток допустимых значений Number: от -25^3 - 1 до 25^3 - 1.

Значения типа BigInt создаются добавлением n в конец числа.

Примечание. BigInt появился в новых версиях JavaScript относительно недавно, поэтому еще недоступен в некоторых браузерах, включая Safari. Проверить, поддерживает ли браузер тип BigInt можно на странице JavaScript BigInt support.

Логический тип в JavaScript

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

Значение undefined в JavaScript

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

Значение undefined можно присвоить переменной или константе и вручную.

Значение null в JavaScript

Код выше означает, что в переменной number — пусто.

Примечание. Не забывайте, что JavaScript чувствителен к регистру. Поэтому null — это не то же самое, что и Null или NULL.

Объекты в JavaScript

Тип Object хранит пары ключ-значение коллекции данных.

Здесь firstName , lastName , class — ключи, "Андрей" , null и 11 — соответствующие им значения.

Символы в JavaScript

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

Несмотря на то, что и value1 , и value2 хранят одинаковое описание "привет" , это разные символы — так работает тип Symbol .

В JS — динамическая типизация

JavaScript — это динамически типизированный язык, то есть:

  • JS автоматически определяет тип данных переменных за вас;
  • одной переменной можно присваивать разные значения.

Оператор typeof в JavaScript

Чтобы узнать тип переменной или константы используют оператор typeof() .

Примечание. Обратите внимание, что typeof возвращает "object" для типа null . Это давно известный баг, который присутствовует в JS с момента релиза. Этот баг, скорее всего, никогда не исправят из-за необходимости сохранять обратную совместимости существующего кода с новыми версиями языка.

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

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

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

Типы данных

Стандарт ECMAScript определяет 8 типов:

    6 типов данных являющихся примитивами:
      (Неопределённый тип) : typeof instance === "undefined" (Булев, Логический тип) : typeof instance === "boolean" (Число) : typeof instance === "number" (Строка) : typeof instance === "string" : typeof instance === "bigint" (в ECMAScript 6) : typeof instance === "symbol"

    И здесь нам необходимо сделать предостережение относительно использования оператора typeof для определения типа структур, т.к. все структуры будут возвращать "object" при его использовании, так как назначение typeof -- проверка типа данных, но не структур. Если проверить тип структуры всё же необходимо, то в этом случае желательно использовать оператор instanceof, так как именно он отвечает на вопрос о том, какой конструктор был использован для создания структуры.

    Стоит отметить два особых случая работы оператора typeof : возврат "object" для значения null и "function" для функций: первое принято считать ошибкой языка, сохраненной ради обратной совместимости, второе является условностью, удобной для проверки на принадлежность значения категории функций, где функция - это особый, "вызываемый", объект.

    Примитивные значения

    Булевый тип данных

    Булевый тип представляет логическую сущность и имеет два значения: true (истина) и false (ложь) . Смотрите Boolean и Boolean для получения подробностей.

    Этот тип данных имеет всего одно значение: null . Смотрите null и Null для получения подробностей.

    Undefined

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

    Числа

    В соответствии со стандартом ECMAScript, существует только один числовой тип, который представляет собой 64-битное число двойной точности согласно стандарту IEEE 754. Другими словами, специального типа для целых чисел в JavaScript нет. Это означает, что при числовых операциях вы можете получить неточное (округлённое) значение. В дополнение к возможности представлять числа с плавающей запятой, есть несколько символических значений: +Infinity (положительная бесконечность), -Infinity (отрицательная бесконечность), и NaN (не число).

    Для получения самого большого или самого меньшего доступного значения в пределах +/-Infinity , можно использовать константы Number.MAX_VALUE или Number.MIN_VALUE . А начиная с ECMAScript 2015, вы также можете проверить, находится ли число в безопасном для целых чисел диапазоне, используя метод Number.isSafeInteger() , либо константы Number.MAX_SAFE_INTEGER и Number.MIN_SAFE_INTEGER . За пределами этого диапазона операции с целыми числами будут небезопасными, и возвращать приближённые значения.

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

    Текстовые строки

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

    • Получить часть исходной строки выборкой отдельных символов, либо применением метода String.substr() .
    • Объединить две строки в одну, применив оператор ( + ) или метод String.concat() .

    Избегайте повсеместного использования строк в своём коде!

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

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

    Используйте строки только для текстовых данных. Для составных структур преобразуйте строки в подобающие конструкции.

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

    Символы являются нововведением JavaScript начиная с ECMAScript 2015. Символ — это уникальное и иммутабельное примитивное значение, которое может быть использовано как ключ для свойства объекта (смотрите ниже). В некоторых языках программирования символы называются атомами. Их также можно сравнить с именованными значениями перечисления (enum) в языке C. Подробнее смотрите Symbol и Symbol .

    Тип данных Большое целое (BigInt)

    BigInt является встроенным объектом, который предоставляет способ представления целых чисел, которые больше 2 53 , что является наибольшим числом, которое JavaScript может надёжно представить с помощью Number примитива.

    Объекты

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

    Свойства

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

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

    Свойство-значение

    Ассоциирует ключ со значением, и имеет следующие атрибуты:

    Атрибуты свойства-значения
    Атрибут Тип Описание Значение по умолчанию
    [[Value]] Любой тип JavaScript Значение, возвращаемое при обращении к свойству. undefined
    [[Writable]] Boolean Если false , то [[Value]] свойства не может быть изменено. false
    [[Enumerable]] Boolean Если true , свойство будет перечислено в цикле for. in. Смотрите подробнее Перечисляемость и владение свойствами. false
    [[Configurable]] Boolean Если false , то свойство не может быть удалено, а его атрибуты, кроме [[Value]] и [[Writable]] не могут быть изменены. false
    Устаревшие атрибуты (присутствуют в ECMAScript 3, но переименованы в ECMAScript 5)
    Атрибут Тип Описание
    Read-only Boolean Зарезервировано по атрибуту [[Writable]] ES5.
    DontEnum Boolean Зарезервировано по атрибуту [[Enumerable]] ES5.
    DontDelete Boolean Зарезервировано по атрибуту [[Configurable]] ES5.

    Свойство-акцессор

    Ассоциирует ключ с одной из двух функций-акцессоров (геттер и сеттер) для получения или изменения значения свойства, и имеет следующий атрибуты:

    Атрибуты свойства-акцессора
    Атрибут Тип Описание Значение по умолчанию
    [[Get]] Function или undefined Функция вызывается без параметров и возвращает значение свойства каждый раз, когда происходит чтение свойства. Смотрите также get (en-US). undefined
    [[Set]] Function или undefined Функция вызывается с одним аргументом, содержащим присваиваемое значение, каждый раз, когда происходит попытка присвоить свойству новое значение. Смотрите также set (en-US). undefined
    [[Enumerable]] Boolean Если true , свойство будет перечислено в цикле for. in. false
    [[Configurable]] Boolean Если false , то свойство не может быть удалено, и не может быть преобразовано в свойство-значение. false

    Примечание: Атрибуты обычно используются движком JavaScript, поэтому вы не можете обратиться к ним напрямую (смотрите подробнее Object.defineProperty()). Вот почему в таблицах выше они помещены в двойные квадратные скобки вместо одиночных.

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

    Функции — это обычные объекты, имеющие дополнительную возможность быть вызванными для исполнения.

    Для работы с датами служит встроенный глобальный объект Date .

    Массивы общие и типизированные

    Массив — это обычный объект с дополнительной связью между целочисленными ключами его свойств и специальным свойством length. Вдобавок ко всему, массивы наследуют Array.prototype , предоставляющий исчерпывающий набор методов для манипуляции массивами. Например, метод indexOf (служит для поиска значения в массиве), push (en-US) (добавляет элемент в конец массива) и т. д. Всё это делает массив идеальным кандидатом для представления списков и перечислений.

    Типизированный массив является новинкой ECMAScript Edition 6 и является массивоподобным представлением для лежащего в его основе бинарного буфера памяти. Следующая таблица поможет вам найти соответствующие типы языка C:

    Объекты TypedArray

    Коллекции: Maps, Sets, WeakMaps, WeakSets

    Эти наборы данных используют ссылку на объект в качестве ключа, и введены в JavaScript с приходом ECMAScript Edition 6. Set и WeakSet являют собой набор уникальных объектов, в то время как Map и WeakMap ассоциируют с объектом (выступающим в качестве ключа) некоторое значение. Разница между Map и WeakMap заключается в том, что только у Map ключи являются перечисляемыми. Это позволяет оптимизировать сборку мусора для WeakMap.

    Можно было бы написать собственную реализацию Map и Set на чистом ECMAScript 5. Однако, так как объекты нельзя сравнивать на больше или меньше, то производительность поиска в самодельной реализации будет вынужденно линейной. Нативная реализация (включая WeakMap) имеет производительность логарифмически близкую к константе.

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

    Структурированные данные: JSON

    JSON (JavaScript Object Notation) — это легковесный формат обмена данными, происходящий от JavaScript, но используемый во множестве языков программирования. JSON строит универсальные структуры данных. Смотрите JSON и JSON для детального изучения.

    Больше объектов и стандартная библиотека

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

    Определение типов оператором typeof

    Оператор typeof может помочь определить тип вашей переменной. Смотрите страницу документации, где приведены его детали и случаи использования.

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




    Переменные

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

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

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

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


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

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


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


    В одном выражении можно объявить несколько переменных:


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

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

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

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

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

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


    Если же, при инициализации цикла, счётчик i будет объявлен с использованием ключевого слова var , то i будет доступно и за пределами цикла, после того, как он завершит работу.

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

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

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


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

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

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


    В константу obj , при инициализации, записывается новый пустой объект. Попытка обращения к его свойству a , несуществующему, ошибки не вызывает. В консоль попадает undefined . После этого мы добавляем в объект новое свойство и снова пытаемся обратиться к нему. В этот раз в консоль попадает значение этого свойства — 1 . Если раскомментировать последнюю строку примера, то попытка выполнения этого кода приведёт к ошибке.

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

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

    Типы данных

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

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

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

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

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

    Тип number

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

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

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


    Вот дробные числа.

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


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

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


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

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

    Тип string

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


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


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


    Строки можно конкатенировать с использованием оператора + .

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

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


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


    Использование обратных кавычек упрощает многострочную запись строковых литералов:

    Тип boolean

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

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

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

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


    Остальные значения являются истинными.

    Тип null

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

    Тип undefined

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

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

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

    ▍Объекты

    Выражения

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

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

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

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

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

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

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


    Сюда же можно отнести и некоторые ключевые слова и конструкции JavaScript.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


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

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


    Проверить это можно следующим образом.


    Здесь мы пользовались свойством __proto__ , оно не обязательно должно быть доступно разработчику, но обычно обращаться к нему можно. Надо отметить, что более надёжным способом получить прототип объекта является использование метода getPrototypeOf() глобального объекта Object .


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


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

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


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

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

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

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


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

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

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


    Здесь мы создаём функцию-конструктор. При её вызове создаётся новый объект, на который указывает ключевое слово this в теле конструктора. Мы добавляем в этот объект свойство name и записываем в него то, что передано конструктору. Этот объект возвращается из конструктора автоматически. С помощью функции-конструктора можно создать множество объектов, свойства name которых будут содержать то, что передано при их создании конструктору.

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

    ▍Классы

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

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


    У класса есть идентификатор, который можно использовать для создания новых объектов с применением конструкции new ClassIdentifier() .

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

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

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

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

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


    При вызове метода hello() в вышеприведённом примере будет возвращена строка Hello, I am Flavio. I am a programmer .

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

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

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

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

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

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

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

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

    Итоги

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

    Осваивайте профессию, начните зарабатывать, а платите через год!


    Курсы Python Ак­ция! Бес­плат­но!


    Станьте хакером на Python за 3 дня


    Веб-вёрстка. CSS, HTML и JavaScript



    Курс Bootstrap 4


    Станьте веб-разработчиком с нуля

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

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

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

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

    Типы данных

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

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

      Типы данных JavaScript

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

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

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

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

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

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

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

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

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

      Логические, или булевы значения (по фамилии их изобретателя — Буля), могут иметь лишь одно из двух значений: 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 содержит специальные числовые значения:

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

      Тип данных String

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

      Читайте также: