Типы данных помогают построить классификацию данных в языках программирования. Например, число и строка символов представляют собой разные типы данных, которые JavaScript будет обрабатывать по-разному.
Это важно, потому что каждый тип данных может принимать определенные значения и выполнять определенные действия. Чтобы иметь возможность выполнять операции с переменными в JavaScript, важно понимать тип данных каждой заданной переменной.
Данный мануал ознакомит вас с типами данных JavaScript.
Примечание : Информация в руководстве не является исчерпывающей, но здесь вы сможете ознакомиться с основными опциями JavaScript.
Динамическая типизацияJavaScript является динамическим языком. Это значит, что проверка типа данных осуществляется во время запуска, а не компиляции.
В динамических языках одноименные переменные можно использовать для хранения разных типов данных.
Например, переменная t, определяемая ключевым словом var, может хранить разные типы данных; также ее можно инициализировать, но оставить неопределенной:
var t = 16; // t is a number
var t = "Teresa"; // t is a string
var t = true; // t is a Boolean
var t; // t is undefined
Все переменные t содержат разные типы данных JavaScript. В JavaScript не нужно явно указывать тип данных переменной до ее использования.
ЧислаJavaScript имеет единый числовой тип данных, не разделяя целые числа и числа с плавающей запятой. Потому числа в JavaScript можно писать с десятичными знаками или без них:
var num1 = 93;
var num2 = 93.00;
В вышеприведенном примере обе переменные содержат числа, вне зависимости от того, есть в нем запятая или нет.
Экспоненциальная нотация в JavaScript позволяет сокращать очень большие или маленькие числа:
var num3 = 987e8; // 98700000000
var num4 = 987e-8; // 0.00000987
В JavaScript числа считаются точными до 15 цифр. Это означает, что после достижения 16-й цифры числа будут округлены:
var num5 = 999999999999999; // remains as 999999999999999
var num6 = 9999999999999999; // rounded up to 10000000000000000
Также числа в JavaScript имеют три символических значения:
Infinity — числовое значение, которое представляет собой положительное число, приближающееся к бесконечности.
Infinity — числовое значение, которое представляет собой отрицательное число, приближающееся к бесконечности.
NaN – Not-а-Number, особое состояние числа с плавающей запятой.
Infinity и -Infinity возвращаются при подсчете числа за пределами максимально возможного числа, доступного в JavaScript. Они также появляются при подсчете неопределенных значений, например, при делении на ноль:
var num7 = 5 / 0; // Infinity
var num8 = -5 / 0; // -Infinity
Технически Infinity возвращается, если число превышает 1.797693134862315E+308, это верхний предел в JavaScript.
Аналогично, -Infinity будет отображаться, когда число выходит за нижний предел, -1.797693134862316E+308.
Число Infinity также можно использовать в циклах:
while (num9 != Infinity) {
// Code here will execute through num9 = Infinity
}
Для неопределенных чисел выводится NaN. Если вы попытаетесь выполнить математическую операцию над числом и нечисловым значением, вы получите NaN. Например:
var x = 20 / "Shark"; // x will be NaN
Поскольку 20 нельзя разделить на строку Shark, значение переменной х будет NaN.
Однако если строку можно оценить как числовое значение, JavaScript выполнит математическое выражение:
var y = 20 / "5"; // y will be 4
Поскольку JavaScript может рассмотреть 5 как числовое значение, 5 будет работать с математическим оператором деления.
Если одной переменной в выражении присвоено значение NaN, в результате будет NaN, даже если второй операнд является числом.
var a = NaN;
var b = 37;
var c = a + b; // c will be NaN
Итак, в JavaScript существует только один числовой тип данных. В JavaScript не нужно разделять числа на целые и числа с плавающей запятой, поскольку JavaScript является динамическим языком.
СтрокиСтрока – это последовательность из одного или нескольких символов (букв, цифр и других символов). Строки представляют собой текстовые данные.
В JavaScript строки бывают как в одиночных, так и в двойных кавычках. Чтобы создать строку, нужно заключить последовательность символов в кавычки:
var singleQuotes = "This is a string in single quotes.";
var doubleQuotes = "This is a string in double quotes.";
Вы можете использовать одинарные или двойные кавычки, но в коде одной программы нужно последовательно использовать один вид кавычек.
Программа «Hello, World!» демонстрирует, как используются строки в компьютерном программировании. По сути, в данном примере строка – это последовательность символов, которая составляет фразу «Hello, World!» в alert().
function helloFunction() {
alert("Hello, World!");
}
Click me
Запустив код и нажав кнопку Click me, вы увидите всплывающее окно с текстом:
Как и другие типы данных, строки можно хранить в переменных.
var hw = "Hello, World!";
Затем можно отобразить строку, вызвав переменную:
...
var hw = "Hello, World!";
function helloFunction() {
alert(hw);
}
...
Hello, World!
Строки позволяют передавать информацию пользователю и обратно в программу.
Логический тип данныхЛогический (или Булевый) тип данных состоит из двух значений – true и false.
Этот тип используется для представления значений истинности, связанных с логикой и алгоритмах в информатике.
Примечание : Этот тип данных назван в честь математика Джорджа Буля.
Многие операции в математике дают результаты, которые можно оценить как истинные или ложные:
Больше чем:
- 500 > 100 true
- 1 > 5 false
Меньше чем:
- 200 < 400 true
- 4 < 2 false
- 5 = 5 true
- 500 = 400 false
Как и другие типы, логический тип данных можно хранить в переменных.
var myBool = 5 > 8; // false
Поскольку 5 не больше 8, переменная myBool будет иметь значение false.
Разрабатывая код в JavaScript, вы познакомитесь с тем, как работают логические данные и как различные функции и операции, оценивающие истинность, могут изменить ход программы.
МассивыМассив может содержать несколько значений в пределах одной переменной. Это означает, что вы можете сохранить список значений внутри массива и итерировать их.
Каждое значение внутри массива называется элементом. Вы можете обратиться к элементам массива с помощью индекса.
Массивы определяются квадратными скобками .
Массив строк выглядит так:
var fish = ["shark", "cuttlefish", "clownfish", "eel"];
Вызывая переменную fish, вы получите результат:
["shark", "cuttlefish", "clownfish", "eel"]
Массивы – очень гибкий тип данных, поскольку они изменяемы: вы можете добавлять, удалять и изменять значения элементов.
ОбъектыОбъект в JavaScript состоит из пар «ключ: значение».
Синтаксис объекта состоит из пар «ключ: значение». Объект выделяется фигурными скобками с обеих сторон ({}).
Пары в объекте разделяются пробелами:
var sammy = {firstName:"Wally", lastName:"Shark", color:"blue", location:"ocean"};
Также объект можно записать в несколько строк (особенно это применимо к большим объектам).
var wally = {
firstName: "Wally",
lastName: "Shark",
color: "blue",
location: "Ocean"
};
Каждая создаваемая вами программа наверняка будет содержать несколько типов данных, однако операции обычно выполняются для одного типа данных. математические вычисления применяются к числам, а нарезка – к строкам.
Используя операторы, которые работают со всеми типами данных (например, оператор + может складывать числа или выполнять конкатенацию строк), вы можете получить неожиданный результат.
Если вы создадите переменную для конкатенации, JavaScript интерпретирует каждый элемент как строку.
var o = "Ocean" + 5 + 3;
Вызвав переменную о, вы получите такой результат:
Однако если в строке сначала будут идти числа, а затем строка, оператор + выполнит сложение, а затем конкатенацию:
var p = 5 + 3 + "Ocean";
8Ocean
Из-за непредсказуемости результатов выполнять операции и методы удобнее в одном типе данных. Однако JavaScript не возвращает ошибок при смешивании типов данных, как это делают некоторые другие языки программирования.
ЗаключениеТеперь вы знакомы с типами данных JavaScript. Каждый из перечисленных здесь типов важен при написании программ на языке JavaScript.
Tags:Начнем, как обычно, с определения того, с чем мы знакомимся. Что же такое типы данных? Это понятие относится ко всем языкам программирования и JavaScript здесь не уникален. Если мы обратимся к определению в Википедии, то узнаем, что типы данных — это множество значений и операций на этих значениях. Говоря проще, тип данных это, по сути, тип значений, которые мы можем сохранить в переменную и работать с ними.
В статье о переменных в JavaScript мы сравнили переменную с коробкой, в которую можно положить что угодно. Собственно, это что угодно и есть значение любого типа данных. Даже если вы не знакомы ни с одним языком программирования, интуитивно, думаю, вы уже сейчас сможете назвать как минимум два типа данных, которые есть в JavaScript. Правильно, это число и строка или строковый и числовой тип данных. Помните, мы записывали в переменную и строки, и числа? Разница лишь в том, что строку мы обязаны были заключить в кавычки.
Итак, в JavaScript можно выделить шесть типов данных:
JavaScript. Быстрый старт
логическое или булево значение
Давайте вкратце пройдемся по каждому из этих типов. Начнем со строкового типа данных. Строка, пожалуй, один из наиболее часто используемых типов данных. Со строками мы сталкиваемся сплошь и рядом: логин пользователя — строка, наименование товара — строка, название статьи — строка и т.д.
Как вы помните, строка должна заключаться в одинарные или двойные кавычки. Разницы между типами кавычек нет, в JavaScript и одинарные, и двойные кавычки выполняют одинаковую функцию и ничем не отличаются, в отличие, скажем от PHP, где в двойных кавычках имена переменных обрабатываются. Пример строк:
var name = "John", surname = "Doe";
var name = "John" , surname = "Doe" ; |
JavaScript. Быстрый старт
Изучите основы JavaScript на практическом примере по созданию веб-приложения
Со строками все понятно, идем дальше — число или числовой тип данных. В JavaScript целые числа и числа с плавающей точкой (дробные числа) относятся к одному типу — число. Для хранения и записи чисел кавычки не нужны, более того, они излишни и иногда могут привести к неожиданному результату в математических операциях. Пример записи чисел в JavaScript:
var num1 = 2, num2 = 3.4 num3 = -5;
var num1 = 2 , num2 = 3.4 num3 = - 5 ; |
Обратите внимание, дробная часть числа отделяется не запятой, а точкой (десятичная точка). Также число может быть со знаком: -5 в примере.
Строка и число — это понятные всем типы данных в JavaScript. Следующие четыре типа могут быть вам пока непонятны, но чуть позже, когда мы плотнее начнем работать с кодом, вы поймете на практике работу с оставшимися типами данных.
Итак, логический тип или булев тип данных. У него всего два возможных значения: true и false. Если упростить, то их можно сравнить с словами «да» и «нет» или «истина» и «ложь». Пример записи булевых значений в JavaScript:
var yes = true, no = false;
var yes = true , no = false ; |
Обратите внимание, значения true и false регистрозависимы. В PHP, к примеру, константы true и false не зависят от регистра.
Следующие два специальных значения — null и undefined. Они очень похожи и по сути обозначают одно и то же — отсутствие значения. undefined будет значением переменной, которая просто объявлена, но для нее не установлено значение, т.е. значение не определено. null же часто записывают в переменную, чтобы обнулить значение переменной, сделать его неизвестным, если можно так сказать. В следующих статьях мы детальнее увидим специфику работы с этими типами данных в JavaScript.
Ну и последний тип — это объект. Если переменную мы сравнивали с коробкой, то объект можно сравнить с комплектом коробок или, что более подойдет, с каталогом ящиков в библиотеке, к примеру. Каждый ящик подписан и в каждом находится что-то свое. Позже мы детальнее познакомимся с объектами, ну а пока посмотрим, как можно объявить объект и как обратиться к значениям, которые в него записаны.
// запись объекта var user = { name: "John", surname: "Doe", year: 2016 }; // обращение к свойствам объекта alert(user.name); alert(user.surname); alert(user.year);
Переменная – это именованный участок памяти, в который можно как сохранить некоторую информацию, так и получить её из неё.
Объявление (создание) переменных осуществляется с помощью ключевого слова 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 примитивных типов данных:
- число (number);
- строка (string);
- булевый тип (boolean);
- null;
- undefined.
Если одной переменной присвоить значение другой, которая содержит примитивный тип данных, то она получит собственную копию этого значения.
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 содержат ссылку на один и тот же объект
Число (number)Числовой тип в 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 (положительная бесконечность);
- -Infinity (отрицательная бесконечность);
- NaN (Not a Number – не число).
Специальное значения 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)Boolean – примитивный тип данных, который имеет всего два значения: true (истина) и false (ложь).
Var a = true; var b = false;
Строка (String)Строка (String) – это тип данных, который используется в JavaScript для представления текста.
Строка JavaScript может состоять из 0 или большего количества символов.
В качестве формата строки в JavaScript всегда использутся кодировка Unicode.
Создание строки (литерала строки) выполняется посредством заключения текста в одинарные или двойные кавычки .
"JavaScript"; "ECMAScript";
В JavaScript нет разницы между одинарными и двойными кавычками.
Но, в некоторых случаях есть смысл использовать именно одинарные кавычки, а не двойные и наоборот.
Например, когда строка содержит двойные кавычки, её более удобно заключить в одинарные. Это избавит от необходимости экранирования в ней двойных кавычек.
""ECMAScript""; // без экранирования (с использованием одинарных кавычек) "\"ECMAScript\""; // с экранированием
Строка в JavaScript может содержать специальные символы. Например, \n (перевод строки), \t (табуляция), \r (возврат каретки) и др.
"Это предложение.\nА это тоже предложение, но оно будет начинаться с новой линии.";
Со строками можно произовдить операцию сложения (объединения) или другими словами конкатенацию. Для этого используется оператор "+". Сымысл данной операции заключается в присоединении второй строки к концу первой.
"Я люблю " + "JavaScript"; // Я люблю JavaScript
Значение "undefined"undefined - специальный примитивный тип данных, который имеет одно значение, равное undefined .
Этот тип данных имеет объявленная переменная, которой ещё не присвоено значение.
Var num; // undefined
Значение undefined также будет возвращено при обращении к несуществующему свойству объекта.
Var obj = {}; // пустой объект obj.prop; // undefined
Значение "null"null - специальный примитивный тип данных, который имеет одно значение, равное null .
null - это просто специальное значение, которое имеет смысл «ничего» или «неизвестное значение», т.е. оно явно ничего не означает.
Объект (Object)Объект – это структура данных, состоящая из пар имя-значение.
Создание объекта с помощью нотации литерала объекта осуществляется следующим образом:
{ имя_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 (с использованием круглых скобок):
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";
Как и в любом другом языке программирования типы данный в JS делятся на:
–литералы и переменные
–массивы, функции и объекты
Литералы:
Литералами называются самые примитивные единицы в любом языке программирования, такие как числа и символы. В JavaScript литералы делятся на числовые и строковые:
Числовые литералы Строковые литералы
4.5e+2 "Типы данных в JavaScript"
Использовать литералы в коде JS можно для операций присваивания и сравнения:
var pi = "число ПИ";
if(q == "b") q = b + 1;
Переменные:
Ну и какой же язык программирования без переменных. Вообще переменные смело можно назвать основой любого языка программирования. Практически ни одна функция, ни один цикл или оператор не может быть выполнен без использования переменных.
JavaScript позволяет присвоить этому типу данных не только значения литералов, но также присвоить весь массив целиком, всю функцию или название объекта. Задавать переменные можно как просто так в любом месте программы, так и при помощи оператора var:
id = window.close();
var arr = new Array();
ob = document.forms;
В языке JavaScript существуют два основных вида массивов:
встроенные в интерпритатор (document.forms, document.images,...)
определяемые пользователем
Создается массив при помощи конструкции new Array();
a = new Array(); b = new Array(15); c = new Array(15,33,"значение 3");
В первом случае переменной a присваивается пустой массив, во втором переменной b присваивается массив, первым значением которого является число 15 и наконец, в третьем случае переменной c присваивается массив из 3х значений, третье из которых является строковым литералом.
Для обработки массивов в JS существует несколько основных методоов:
join(); reverse();sort();
Ниже представлен список основных операторов, которые мы с вами рассмотрим:
var; {...}; if; while; for; for ... in; break; continue; return.
3. Переменные и оператор присваивания в JavaScript.Базовый оператор присваивание - это обычное приравнивание =, которое дает левому операнду значение правого операнда.
Остальные операторы являются сокращениями следующих форм.Сокращенный оператор Значение
x += y x = x + y
x -= y x = x - y
x *= y x = x * y
x /= y x = x / y
x %= y x = x % y
x > y
x >>>= y x = x >>> y
x &= y x = x & y
x ^= y x = x ^ y
x |= y x = x | y
4. Операторы в JavaScript.Операторы служат для управления потоком команд в JavaScript. Один объект может быть разбит на несколько строк,или, наоборот в одной строке может бытьнесколько операторов.
Необходимо знать следующее, во-первых,блоки операторов, такие как определения функций, должны быть заключены в фигурные скобки. Во-вторых, точка с запятой служит разделителем отдельных операторов. Если пропустить точку с запятой, поведение программы станет непредсказуемым.
Так как JavaScript не имеет жестких требований к форматированию текста программы, можно вставлять символы перевода строки и отступа для лутшей читабельности текста.
Ниже описаны операторы, которые используются в JavaScript:
break, comment, continue , for , for...in , function , if...else
Последнее обновление: 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Тип Boolean представляет булевые или логические значения true и false (то есть да или нет):
Var isAlive = true; var isDead = false;
null и undefinedНередко возникает путаница между 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Тип 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С помощью оператора 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
