Всего в JavaScript, существует 6 типов данных
:
— Число number ,
— Строка string ,
— Логический (булев) тип данных boolean ,
— Отсутствие значения undefined ,
— Пустота, ничто null ,
— Объект object .
Эти 6 типов данных, делятся на два вида, простые типы данных и составные (объектные) типы данных.
Простые (примитивные) типы данных:
number, string, boolean, undefined, null.
Составные (объектные) типы данных:
object
Составным типом данных являются: объект, функция, массив (см. в конце статьи).
Прежде чем рассмотреть каждый тип данных, познакомимся сначала с оператором typeof . Данный оператор позволяет узнать, какой тип данных у переменной, делается это так:
Var имяПеременной; имяПеременной = значение; alert(typeof имяПеременной);
Number — тип данных число. Числа могут быть как целыми так и с плавающей запятой (дробные, вещественные, действительные числа).
Var myNumber = 5; var myNumber2 = 5.5;
В JavaScript в числах с плавающей запятой, используются точки, а не запятые 🙂
Alert(typeof myNumber); alert(typeof myNumber2);
В обоих случаях, скрипт выдаст нам сообщение number .
String — тип данных строка. Чтобы превратить значение переменной в строку, её нужно обрамить кавычками: дойными «строка» или одинарными ‘строка’. Если число обрамить кавычками, то её тип данных из number превратится в string:
Var myString = "Привет я строка JavaScript"; var myString2 = "5";
Проверяем с помощью оператора typeof, тип данных наших переменных:
Alert(typeof myString); alert(typeof myString2);
В обоих случаях скрипт выдаст нам сообщение string .
Boolean — логический (булев) тип данных, он может иметь только одно их двух значений: true (правда) или false (ложь). Значения true или false обычно появляются в операциях сравнения или логических операциях.
Var myBoolean = true; var myBoolean2 = false;
Проверяем с помощью оператора typeof, тип данных наших переменных:
Alert(typeof myBoolean); alert(typeof myBoolean2);
В обоих случаях, скрипт выдаст нам сообщение boolean .
Если логический тип данных обрамить кавычками, то его тип данных из boolean превратится в string.
Undefined — тип данных который имеет всего одно значение undefined . Этот тип данных появляется тогда, когда переменная объявлена, но не инициализирована, т.е. когда у переменной (свойства объекта или элемента массива) отсутствует значение.
// Объявили переменную, но не присвоили ей значения var myUndefined; // Проверяем с помощью оператора typeof, тип данных нашей переменной alert(typeof myUndefined);
Функция alert() выдаст нам сообщение undefined .
Если переменной присвоить значение undefined , то её тип данных тоже будет undefined .
Var myUndefined2 = undefined; alert(typeof myUndefined2);
Если значение undefined обрамить кавычками, то его тип данных из undefined превратится в string.
Object — тип данных объект.
Var myObject; myObject = { svoistvo: "znachenie", svoistvo2: "znachenie2", };
Проверяем с помощью оператора typeof, тип данных нашего объекта:
Alert(typeof myObject);
Скрипт выдаст нам сообщение object . Так же оператор typeof, покажет object у массивов и функций (см. ниже).
Null — это специальный тип данных обозначающий пустоту (ничего). Null — это специальный пустой объект. Например null может появиться при нажатии на кнопку отмена при использовании функции promt() .
Var myNull = null; alert(typeof myNull);
Данный скрипт выдаст сообщение object , почему так происходит читайте ниже.
Если null обрамить кавычками, то его тип данных из null превратится в string.
Здесь сообщу о некоторых подводных камнях которые есть в операторе typeof, например при работе с null и с функциями он выдаёт не верный тип данных, что часто путает начинающих. Ниже я составил небольшую табличку, показывающую как работает
Переменная – это именованный участок памяти, в который можно как сохранить некоторую информацию, так и получить её из неё.
Объявление (создание) переменных осуществляется с помощью ключевого слова var .
// message - имя переменной var message;
При создании переменной ей сразу же можно присвоить значение.
Присвоение переменной значения осуществляется с помощью оператора «=».
// например, создадим переменную email и присвоим ей строку "[email protected]" var email = "[email protected]"; // установим переменной email новое значение email = "[email protected]";
Для того чтобы получить значение переменной достаточно просто обратиться к ней по имени.
// например, выведем в консоль браузера значение переменной email: console.log(email);
Для того чтобы объявить не одну, а несколько переменных с помощью одного ключевого слова var , необходимо использовать запятую.
Var price = 78.55, quantity = 10, message;
JavaScript является языком с динамической или слабой типизацией. Это означает, что при объявлении переменной ей не нужно указывать тип данных, который она может принимать. Следовательно, в переменную можно поместить сначала значение, имеющее один тип данных, а потом другой.
Var output = "успех"; // переменная имеет строковый тип данных output = 28; // эта же переменная, но уже имеющая тип данных «число» output = true; // эта же переменная, но уже хранящая булевское значение
Значение переменной можно изменять неограниченное количество раз.
// создана переменная age var age; // переменной age присвоено значения 67 age = 67; // переменной age установлено значение «Пенсионный возраст» age = "Пенсионный возраст"; // переменной age установлено число 55 age = 55;
Хорошей практикой при разработке клиентских считается использование в определённой переменной только одного типа данных, т.е. не записывать в переменную значения, имеющие различные типы данных. Чтобы понять какой тип данных стоит ожидать в переменной рекомендуется при создании переменной её сразу инициализировать определённым значением.
Имя переменной можно составлять из букв, цифр и символов $ и _. При этом первый символ переменной не должен быть цифрой. Кроме этого в качестве имени переменной нельзя использовать зарезервированные слова.
// создание двух переменных, первая переменная имеет имя phone, вторая - meassage; var phone, message;
Регистр букв в имени переменной имеет значение. Т.е., например, переменная phone и Phone - это две разные переменные.
Если строгий режим не используется, то создать переменную с первоначальным значением можно и без ключевого слова var.
Price = 250.00; // создали переменную и инициализировали её числом 250.00 percent = "20%"; // создали переменную и инициализировали её строкой «20%»
Но создавать, таким образом, переменные не рекомендуется.
В JavaScript типы данных можно разделить на примитивные и объектные.
Переменные, содержащие примитивные типы данных хранят значение явно.
В JavaScript выделяют 5 примитивных типов данных:
Если одной переменной присвоить значение другой, которая содержит примитивный тип данных, то она получит собственную копию этого значения.
Var x = 77, y = x; x = 55; y; // 77
Переменные, содержащие объект, на самом деле хранят не сам объект, а ссылку на него.
Если одной переменной присвоить значение другой, которая содержит объект (ссылку на него), то она тоже получит ссылку на него. В результате этой операции две эти переменные будут содержать ссылку на один и тот же объект.
// пример 1 (с типом данных «объект») var coord1 = {x: 77, y: 100}, coord2 = coord1; coord1.x = 55; // установим свойству x объекта новое значение coord2.x; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 2 (с типом данных «массив») var coord1 = , coord2 = coord1; coord1 = 55; // установим элементу с 0 индексом новое значение coord2; // 55, т.к. coord1 и coord2 содержат ссылку на один и тот же объект // пример 3 (с типом данных «дата») var date1 = new Date(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // увеличим дату на 7 дней date1; // 07.01.2018, т.к. date1 и date2 содержат ссылку на один и тот же объект
Числовой тип в JavaScript данных является универсальным . Он используется для представления, как целых , так и дробных чисел.
Var int = 5; // целое число var float = 5.98; // дробное число
Формат представления чисел в JavaScript осуществляется в соответствии со стандартом IEEE 754-2008.
Целые числа в JavaScript можно задавать не только в десятичной системе счисления, но и в восьмеричной (0) или шестнадцатеричной системе счисления (0x) с использованием префиксов, указанных в круглых скобках:
Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184
Записывать числа возможно в экспоненциальной форме :
Var num = 2e3; // экспоненциальная запись числа 2*10^3 (2000) num = 2e-3; // экспоненциальная запись числа 2*10^-3 (0,002) num = 3.2e3; // 3200 num = 1.5e-2; // 0.015
Числовой тип данных кроме чисел содержит ещё специальные числовые значения :
Специальное значения Infinity означает очень большое положительное число, т.е. число, которое не может быть представлено в JavaScript по причине того, что оно слишком велико.
Специальные значения -Infinity означает наоборот очень большое отрицательное число, т.е. число, которое не может быть представлено JavaScript по причине того, что оно тоже слишком велико.
Пример выражений в результате вычисления которых будет возвращены специальные числовые значения :
5/0; // Infinity -5/0; // -Infinity Math.pow(10,399); // Infinity (10 в степене 399) Math.pow(10,399); // -Infinity (-10 в степене 399)
Значение NaN возвращается в результате выполнения математических операций, которые JavaScript не может вычислить.
5 - "Hi"; // NaN (от числа 5 отнять строку) 1000 / "20px"; // NaN (число поделить на строку) true * "1rem"; // NaN (логическое значение true умножить на строку)
При этом очень интересным является то, что значение NaN в JavaScript не равно ничему включая себя.
NaN == NaN; // false NaN === NaN; //false
Boolean – примитивный тип данных, который имеет всего два значения: true (истина) и false (ложь).
Var a = true; var b = false;
Строка (String) – это тип данных, который используется в JavaScript для представления текста.
Строка JavaScript может состоять из 0 или большего количества символов.
В качестве формата строки в JavaScript всегда использутся кодировка Unicode.
Создание строки (литерала строки) выполняется посредством заключения текста в одинарные или двойные кавычки .
"JavaScript"; "ECMAScript";
В JavaScript нет разницы между одинарными и двойными кавычками.
Но, в некоторых случаях есть смысл использовать именно одинарные кавычки, а не двойные и наоборот.
Например, когда строка содержит двойные кавычки, её более удобно заключить в одинарные. Это избавит от необходимости экранирования в ней двойных кавычек.
""ECMAScript""; // без экранирования (с использованием одинарных кавычек) "\"ECMAScript\""; // с экранированием
Строка в JavaScript может содержать специальные символы. Например, \n (перевод строки), \t (табуляция), \r (возврат каретки) и др.
"Это предложение.\nА это тоже предложение, но оно будет начинаться с новой линии.";
Со строками можно произовдить операцию сложения (объединения) или другими словами конкатенацию. Для этого используется оператор "+". Сымысл данной операции заключается в присоединении второй строки к концу первой.
"Я люблю " + "JavaScript"; // Я люблю JavaScript
undefined - специальный примитивный тип данных, который имеет одно значение, равное undefined .
Этот тип данных имеет объявленная переменная, которой ещё не присвоено значение.
Var num; // undefined
Значение undefined также будет возвращено при обращении к несуществующему свойству объекта.
Var obj = {}; // пустой объект obj.prop; // undefined
null - специальный примитивный тип данных, который имеет одно значение, равное null .
null - это просто специальное значение, которое имеет смысл «ничего» или «неизвестное значение», т.е. оно явно ничего не означает.
Объект – это структура данных, состоящая из пар имя-значение.
Создание объекта с помощью нотации литерала объекта осуществляется следующим образом:
{ имя_1: значение_1, имя_2: значение_2, имя_3: значение_3, ... }
Как видно, имя от значения отделяется с помощью двоеточия, а пары между собой с помощью запятой.
При этом если в качестве значения пары выступает функция, то она называется методом этого объекта. Все остальные пары, т.е. пары в которых в качестве значения не используется функция, называются свойствами объекта.
Другими словами, объект - это структура данных, состоящая из свойств и методов.
Var person = { name: "Виталий", age: 27, getAge: function () { return "Возраст: " + this.age; } }
Обращение к свойствам объекта выполняется через точку или посредством скобочной записи.
// выведем значение свойства age в консоль браузера // 1 способ (через точку) console.log(person.age); // 2 способ (с помощью скобок) console.log(person["age"]); // вызовем метод getAge; значение, которое он вернет, выведем в консоль console.log(person.getAge());
Оператор typeof используется для получения информации о типе данных выражения в виде строки.
Синтаксис оператора typeof (вариант без круглых скобок):
Typeof выражение
Синтаксис оператора typeof (с использованием круглых скобок):
Typeof(выражение)
Var name, age = 37, email = "[email protected]", isLicense = true, interest: null, lastExperience: { period: "June 2011 - June 2018", place: "ISACA, Moscow", position: "Web designer" }, getExperience: function() { return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; }; typeof name; // "undefined" typeof age; // "number" typeof isLicense; // "boolean" typeof interest; // "object" (1) typeof lastExperience; // "object" typeof getExperience; // "function" (2) /* (1) - это ошибка, которая присутствует в языке, начиная с его первой реализации; она не была исправлена в целях сохранения совместимости и это необходимо учитывать, при написании сценариев; null - это примитивный тип данных, он не является объектом */ /* (2) - это очень удобно, что оператор typeof выделяет функции отдельно; но функция в JavaScipt - это тоже объект; в этом легко убедиться если выполнить следующую конструкцию: */ typeof getExperience.__proto__.__proto__ // "object" (прототипом функции является объект)
С выходом ECMAScript 6 появилось возможность создавать константы. Осуществляется это с помощью ключевого слова const.
Const COLOR_RED = "#ff0000";
Константа – это переменная, значение которой защищено от изменения. Т.е. при попытке поменять значение будет брошена ошибка.
Const COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // Uncaught TypeError: Assignment to constant variable.
Если, например, константа содержит объект, то он не может быть изменен, а точнее ссылка на него. Но свойства этого объекта могут быть изменены.
Const COLORS = { red: "#ff0000", green: "#00ff00", blue: "#00ff00" } COLORS = ["#ff0000","#00ff00","#00ff00"]; // Uncaught TypeError: Assignment to constant variable. COLORS.green = "#4caf50";
Переменная представляет собой идентификатор, которому присвоено некое значение. К переменной можно обращаться в программе, работая таким образом с присвоенным ей значением.Сама по себе переменная в JavaScript не содержит информацию о типе значений, которые будут в ней храниться. Это означает, что записав в переменную, например, строку, позже в неё можно записать число. Такая операция ошибки в программе не вызовет. Именно поэтому JavaScript иногда называют «нетипизированным» языком.
Прежде чем использовать переменную, её нужно объявить с использованием ключевого слова var или let . Если речь идёт о константе, применяется ключевое слово const . Объявить переменную и присвоить ей некое значение можно и не используя эти ключевые слова, но делать так не рекомендуется.
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 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 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 только в особых случаях. Почему? Всё дело в том, что лучше всего стремиться к использованию как можно более простых из доступных конструкций для того, чтобы не усложнять программы и избегать ошибок.
Для того чтобы определить тип данных некоего значения, можно воспользоваться оператором typeof . Он возвращает строку, указывающую тип операнда.
Поговорим о наиболее часто используемых типах данных из этого списка.
В коде числовые литералы представлены в виде целых и дробных чисел в десятичной системе счисления. Для записи чисел можно использовать и другие способы. Например, если в начале числового литерала имеется префикс 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.
"A string"
"Another string"
Строковые значения можно разбивать на несколько частей, используя символ обратной косой черты (backslash).
"A \
string"
Строка может содержать так называемые escape-последовательности, интерпретируемые при выводе строки в консоль. Например, последовательность \n означает символ перевода строки. Символ обратной косой черты можно использовать и для того, чтобы добавлять кавычки в строки, заключённые в такие же кавычки. Экранирование символа кавычки с помощью \ приводит к тому, что система не воспринимает его как специальный символ.
"I\"m a developer"
Строки можно конкатенировать с использованием оператора + .
"A " + "string"
`a string`
Например, в шаблонные литералы можно подставлять некие значения, являющиеся результатом вычисления JavaScript-выражений.
`a string with ${something}`
`a string with ${something+somethingElse}`
`a string with ${obj.something()}`
Использование обратных кавычек упрощает многострочную запись строковых литералов:
`a string with ${something}`
Логические выражения используются в конструкциях наподобие if и while , помогая управлять ходом выполнения программы.
При этом надо отметить, что там, где ожидается значение true или false , можно использовать и другие значения, которые автоматически расцениваются языком как истинные (truthy) или ложные (falsy).
В частности, ложными значениями являются следующие:
0
-0
NaN
undefined
null
"" //пустая строка
Остальные значения являются истинными.
Это значение автоматически возвращается из функций, результат работы которых не возвращается явно, с использованием ключевого слова return . Если функция принимает некий параметр, который, при её вызове, не указан, он также устанавливается в undefined .
Для того чтобы проверить значение на undefined , можно воспользоваться следующей конструкцией.
Typeof variable === "undefined"
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 && b a || b !a
Object.property //обращение к свойству (или методу) объекта object object["property"]
A.x(2) window.resize()
У каждого 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)
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() с функцией уже имеющегося в примере объекта (имя функции в таком случае записывают без скобок).
До этого в 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 .
Class Person { constructor(name) { this.userName = name } set name(value) { this.userName = value } get name() { return this.userName } }
Уважаемые читатели! Если вы уже давно пишете на JS, просим рассказать о том, как вы относитесь к появлению в языке ключевого слова class.
Последнее обновление: 26.03.2018
Все используемые данные в javascript имеют определенный тип. В JavaScript имеется пять примитивных типов данных:
String : представляет строку
Number : представляет числовое значение
Boolean : представляет логическое значение true или false
undefined : указывает, что значение не установлено
null : указывает на неопределенное значение
Все данные, которые не попадают под вышеперечисленные пять типов, относятся к типу object
Числа в JavaScript могут иметь две формы:
Целые числа, например, 35. Мы можем использовать как положительные, так и отрицательные числа. Диапазон используемых чисел: от -2 53 до 2 53
Дробные числа (числа с плавающей точкой), например, 3.5575. Опять же можно использовать как положительные, так и отрицательные числа. Для чисел с плавающей точкой используется тот же диапазон: от -2 53 до 2 53
Например:
Var x = 45; var y = 23.897;
В качестве разделителя между целой и дробной частями, как и в других языках программирования, используется точка.
Тип string представляет строки, то есть такие данные, которые заключены в кавычки. Например, "Привет мир" . Причем мы можем использовать как двойные, так и одинарные кавычки: "Привет мир" и "Привет мир" . Единственно ограничение: тип закрывающей кавычки должен быть тот же, что и тип открывающей, то есть либо обе двойные, либо обе одинарные.
Если внутри строки встречаются кавычки, то мы их должны экранировать слешем. Например, пусть у нас есть текст "Бюро "Рога и копыта"" . Теперь экранируем кавычки:
Var companyName = "Бюро \"Рога и копыта\"";
Также мы можем внутри стоки использовать другой тип кавычек:
Var companyName1 = "Бюро "Рога и копыта""; var companyName2 = "Бюро "Рога и копыта"";
Тип Boolean представляет булевые или логические значения true и false (то есть да или нет):
Var isAlive = true; var isDead = false;
Нередко возникает путаница между null и undefined. Итак, когда мы только определяем переменную без присвоения ей начального значения, она представляет тип undefined:
Var isAlive; console.log(isAlive); // выведет undefined
Присвоение значение null означает, что переменная имеет некоторое неопределенное значение (не число, не строка, не логическое значение), но все-таки имеет значение (undefined означает, что переменная не имеет значения):
Var isAlive; console.log(isAlive); // undefined isAlive = null; console.log(isAlive); // null isAlive = undefined; // снова установим тип undefined console.log(isAlive); // undefined
Тип object представляет сложный объект. Простейшее определение объекта представляют фигурные скобки:
Var user = {};
Объект может иметь различные свойства и методы:
Var user = {name: "Tom", age:24}; console.log(user.name);
В данном случае объект называется user, и он имеет два свойства: name и age. Это краткое описание объектов, более подробное описание приводится в соответствующей главе.
JavaScript является языком со слабой типизацией. Это значит, что переменные могут динамически менять тип. Например:
Var xNumber; // тип undefined console.log(xNumber); xNumber = 45; // тип number console.log(xNumber); xNumber = "45"; // тип string console.log(xNumber);
Несмотря на то, что во втором и третьем случае консоль выведет нам число 45, но во втором случае переменная xNumber будет представлять число, а в третьем случае - строку.
Это важный момент, который надо учитывать и от которого зависит поведение переменной в программе:
Var xNumber = 45; // тип number var yNumber = xNumber + 5; console.log(yNumber); // 50 xNumber = "45"; // тип string var zNumber = xNumber + 5 console.log(zNumber); // 455
Выше в обоих случая к переменной xNumber применяется операция сложения (+). Но в первом случае xNumber представляет число, поэтому результатом операции xNumber + 5 будет число 50.
Во втором случае xNumber представляет строку. Но операция сложения между строкой и числом 5 невозможна. Поэтому число 5 будет преобразовываться к строке, и будет происходить операция объединения строк. И результатом выражения xNumber + 5 будет стока "455".
С помощью оператора typeof можно получить тип переменной:
Var name = "Tom"; console.log(typeof name); // string var income = 45.8; console.log(typeof income); // number var isEnabled = true; console.log(typeof isEnabled); // boolean var undefVariable; console.log(typeof undefVariable); // undefined
Для создания имён переменных в JavaScript установлены правила синтаксиса:
Примеры правильных имён переменных:
Ошибочные имена переменных:
Переменные объявляются командой 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 (ложь).
Этот тип данных используется в операциях сравнения. Вот простые примеры:
Теперь попробуем подставить булевы значения в арифметические действия. Суммируем две операции сравнения:
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 переменные классифицируются на несколько типов. Строковой, числовой и булевый (логический) типы мы уже рассмотрели. Вот более широкий список простых типов:
Значение переменной 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 может быть таким:
Итак, запустите код из последнего примера и посмотрите на результат. Тип переменной null будет object. Этот ошибка в языке, и она, вероятно, никогда не будет исправлена из-за необходимости сохранения совместимости уже написаных JavaScript сценариев с новыми версиями языка.
Тип object - это уже не примитивный тип, о нём мы будем говорить в других уроках.