Для создания имён переменных в 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 - это уже не примитивный тип, о нём мы будем говорить в других уроках.
Переменная – это просто символьное имя для значения. Переменная даёт возможность обратиться к значению по имени, это означает, что, когда в программе указывается имя переменной, вместо неё подставляется значение.
Прежде чем использовать переменную, её необходимо объявить. Переменные объявляются с помощью ключевого слова var или let , за которым следует имя переменной:
Var num; let num2;
Один раз использовав ключевое слово var или let , можно объявить несколько переменных, перечислив их через запятую:
Var num, num2; let num3, num4;
Объявление переменных можно совмещать с их инициализацией. Инициализация - это присвоение начального значения переменной. Присвоить какое-либо значение переменной можно с помощью оператора присваивания , который обозначается символом равно (= ):
Var color = "чёрный"; let num = 10, num2 = 15;
Переменные в JavaScript не имеют типа, поэтому переменной может быть присвоено значение любого типа, а затем этой же переменной может быть присвоено значение другого типа:
Var a = 10; let b = 20; a = "текст"; b = "текст";
Если при объявлении переменной ей не было присвоено никакого значения, она будет иметь специальное значение undefined , до тех пор, пока ей не будет присвоено другое значение:
Var a; let b; console.log(a); // undefined console.log(b); // undefined
После того как переменная объявлена ключевое слово var или let при использовании переменной указывать не нужно. Чтобы в программе обратиться к значению переменной, надо просто написать имя переменной, интерпретатор JavaScript вместо неё подставит значение, которое хранится в переменной:
Var x = 10, msg = "Hello"; alert(x); document.write(msg); Попробовать »
Так как вместо имени переменной подставляется её значение, можно копировать значение из одной переменной в другую:
Var a = 10; let b; b = a; // Тоже самое, что и b = 10;
Если попытаться использовать необъявленную переменную, будет вызвана ошибка:
Console.log(x); // Ошибка
Как в любом другом языке программирования переменные являются очень важными. Благодаря переменным код становится универсальным, что позволяет решать больше задач. В двух словах, в программировании без использования переменных не обойтись.
Как Вы уже знаете из предыдущей статьи (Основы JavaScript), переменные объявляются с помощью ключевого слова var .
Здесь важно отметить, что регистр важен при объявлении и использовании переменной. То есть переменная var A и переменная var a , это две разные переменные. И то имя, которое задали переменной изначально, то и нужно использовать во всем скрипте.
Так как JavaScript является клиентским языком, то значения переменных хранятся в оперативную память пользователя. В языке PHP значения хранятся в оперативную память сервера.
В имена переменных нельзя использовать специальные символы, такие как #, $, дефис, пробел, точка и другие. Можно использовать только буквы (рекомендуется строчные), цифры и знак подчеркивания(_).
Нельзя чтобы первым символом в имени было число. Например, так назвать можно bmw_93 а так нельзя 123_opel.
Также нельзя назвать переменную зарезервированными словами языка, как например var, for, if.
| abstract | boolean | break |
| byte | case | catch |
| char | class | const |
| continue | default | do |
| double | else | extends |
| false | final | finally |
| float | for | function |
| goto | if | implements |
| import | in | instanceof |
| int | interface | long |
| native | new | null |
| package | private | protected |
| public | return | short |
| static | super | switch |
| synchronized | this | throw |
| throws | transient | true |
| try | var | void |
| while | with |
Рекомендуется наименовать переменные осмысленно, чтобы интуитивно было понятно, что за значение хранится в этой переменной, например для хранения количеств автомобилей можно использовать такое название count_cars а не abcsd.
Еще нельзя назвать переменную русскими буквами, только английскими. Также рекомендуется именовать переменные английскими словами, если Вы плохо владеете английским, то можете воспользоваться транслитом для русских слов.
Любая объявляемая переменная относится к определенному типу. В программировании существует несколько типов данных, из которых более важными являются следующие:
Переменные можно использовать напрямую в строку. Для примера создадим несколько переменных разных типов и выведем их всех сразу, одной строкой.
Хочу отметить, что переменные всегда выводятся без кавычек.
Var age = 47; var money = 50.5; var name = " Ральф "; document.write("
Меня зовут " + name + ".
Мне " + age + " лет и у меня есть " + money + " рублей
Булевские переменные (тип Boolean) редко когда используются напрямую в строке. Они больше предназначены для сохранения результата разных логических операций. Потом этот результат чаще всего используется для условного оператора if, которого изучим в другой статье.
Для примера все-таки, попробуем их вывести в браузер.
Объявим две булевские переменные, одна со значением true а другая со значением false. И используем их в качестве ответов на двух вопросов.
Var bool_1 = true; var bool_2 = false; document.write("
Вопрос: Вы хотите стать программистом? Ответ: " + bool_1 + " (Истина)
"); document.write("Вопрос: Мальчик сделал уроки? Ответ: " + bool_2 + " (Ложь)
");Сохраняем документ и открываем его в браузере.
Как видите в JavaScript, значения булевских переменных отображаются, как заданы. В PHP они отображаются иначе.
Можно объявить переменную изначально без присваивания значения, потом по необходимости сделать это.
Var mouse; //Некий код mouse = "мышь";
Еще можно объявить сразу несколько переменных через запятую, используя ключевое слово var только один раз.
Var comp, television, auto; var count = 5, current_year = 2016, phone;
Массивы и объекты являются сложными типами данных, поэтому мы рассмотрим их в других статьях.
Теперь приступим к арифметическим операциям. Тут есть пару нюансов, которых обязательно нужно учесть при написании кода, иначе получите неверный результат.
С начало объявим две переменные с произвольными числовыми значениями. Которые будем использовать в операциях.
И начнем мы с самой распространённой операции, со сложения.
Var x = - 8; var y = 14.7; //В переменную result вставляем результат сложения. var result = x + y; document.write(x + " + " + y + " = " + result);
В результате мы получим такое число 6.699999999999999.
Тоже сложение, можно сделать сразу при выводе переменных, но здесь есть один важный момент. Для того чтобы произвести арифметическую операцию с числами сразу при их выводе, нужно сделать это внутри круглых скобках. Иначе числа объединятся.
Убираем переменную result и попробуем сложить переменные сразу при выводе.
Var x = - 8; var y = 14.7; //В переменную result вставляем результат сложения. document.write("
Сохраняем документ и смотрим на результат: Правильный результат очевиден. Поэтому всегда, при любой арифметической операции используйте круглые скобки. Document.write(" " + x +" - "+ y +" = "+ (x-y) + " " + x +" * "+ y +" = "+ (x*y) + " " + x +" / "+ y +" = "+ (x/y) + " 
И вот результат:
В программировании существует еще один важный оператор, с которым Вы точно, встречались и на уроке математике. Речь едет об операторе "остаток деления", он обозначается знаком процента (%) .
Чтобы лучше понять, как работает данный оператор, приведу небольшой пример.
Var x = 20; var y = 6; document.write("
" + x +" % "+ y +" = "+ (x%y) + "
"); //Результат: 2Почему 20 % 6 равно 2 ? Потому что 6 * 3 равно 18 и до 20 остается 2. То есть 2 это остаток деления 20 / 6.
Данный оператор (%) чаще всего используется в циклах.
Инкремент - это увеличение значения переменной на единичку.
Например, есть какая-нибудь переменная x со значением 1. И мы хотим значение этой переменной увеличить на единичку. И вместо того чтобы написать так x = x + 1, лучше воспользоваться инкрементом и написать так x++, результатом будет 2.
Var x = 1; x++; //Вместо x = x + 1. document.write(" x = " + x); //Результат: x = 2.
Можно написать и так ++x, результатом тоже будет 2.
Var x = 1; ++x; //Вместо x = x + 1. document.write(" x = " + x); //Результат: x = 2
Если мы сделаем инкремент сразу при выводе, то в случае ++x, значение измениться, а в случае x++, нет, то есть значение останется той же.
Результат остается тот же.
Var x = 1; document.write(" x = " + (x++)); //Результат: x = 1
Значение увеличится на 1.
Var x = 1; document.write(" x = " + (++x)); //Результат: x = 2
Декремент – Это обратное операция инкремента. То есть уменьшение значение переменной на единичку.
Var x = 10; x--; //Вместо x = x - 1. document.write(" x = " + x); //Результат: x = 9
Все операции с инкрементом аналогичны и с декрементом.
Инкремент всегда используется в циклах. Декремент тоже используется, но намного реже.
Для всех арифметических операции существует и сокращенная запись. Оно действительно только когда хотим производить какую-то операцию только с одной переменной. Например:
Допустим, есть две переменные со строковыми значениями. Например, одна будет содержать слово ‘ша’ а другая ‘рик’. Мы хотим объединить эти слова, чтобы получилось слово ‘шарик’. Для этого воспользуемся операцией сложения.
Var slog_1 = "ша"; var slog_2 = "рик"; var word = slog_1 + slog_2; document.write(word); //Результат: шарик
Теперь обратим внимание на такой случай. Мы знаем, что в переменной можно записать и числа и строки, но также можно записать и строковые числа (например var = "64"). Допустим, у нас есть две таких переменных со строковыми числами и нам нужно сложить эти числа.
Если мы просто воспользуемся операцией сложения, то получим неправильный результат, так как числа объединятся, а не сложится.
Var x = "78"; var y = "90"; document.write("result = "+ (x + y));//Результат: result = 7890
Поэтому перед тем как сделать какую-то операцию со строковыми числами необходимо сначала их преобразовать из строки в число. Делается это с помощью функции Number() .
Var x = "78"; var y = "90"; x = Number(x); y = Number(y); document.write("result = "+ (x + y));//Результат: result = 168
Теперь приступим к логическим операциям. Здесь используются только булевские данные, true(истина) и false(ложь).
Например, после сравнения двух чисел получаем какой-то булевский результат, либо true, либо false.
Var count_ball = 16,
сount_players = 32,
compare;
compare = count_ball > count_players;
document.write(count_ball + " > " + count_players + " = " + compare + "
"); //false
compare = count_ball < count_players;
document.write(count_ball + " < " + count_players + " = " + compare + "
"); //true
Данные операции чаще всего используются в условных операторах if, else.
Для лучшего понимания, покажу Вам таблицу истинности. Ее Вы должны знать наизусть. Для этого достаточно ее понять.
Вместо true может быть 1, а вместо false 0.
&& - Это оператор AND, то есть И. Его можно понять как оператор умножения.
|| - Это оператор OR, то есть ИЛИ. Его можно понять как оператор сложение.
Символ "|" на клавиатуре печатается с помощью комбинации клавиш Shift + Back slesh(Обратный слеш \).
^ - Это оператор XOR, то есть Исключающее ИЛИ. Он используется редко. Но его нужно знать по любому, вдруг понадобится.
Вот и все о чем хотел Вам рассказать в этой статье. Теперь Вы знаете, какие типы переменных существуют в программировании и как использовать их в различных арифметических и логических операциях.
Переменные
Прежде чем использовать переменную в JavaScript, ее необходимо объявить. Переменные объявляются с помощью ключевого слова var следующим образом:
Var i; var sum;
Один раз использовав ключевое слово var, можно объявить несколько переменных:
Объявление переменных можно совмещать с их инициализацией:
Var message = "привет"; var i = 0, j = 0, k = 0;
Если начальное значение в инструкции var не задано, то переменная объявляется, но ее начальное значение остается неопределенным (undefined), пока не будет изменено программой.
Если вы имеете опыт использования языков программирования со статическими типами данных, таких как C# или Java, то можете заметить, что в объявлениях переменных в языке JavaScript отсутствует объявление типа. Переменные в языке JavaScript могут хранить значения любых типов. Например, в JavaScript допускается присвоить некоторой переменной число, а затем этой же переменной присвоить строку:
Var i = 10; i = "hello";
С помощью инструкции var можно объявить одну и ту же переменную несколько раз. Если повторное объявление содержит инициализатор, то оно действует как обычная инструкция присваивания.
Если попытаться прочитать значение необъявленной переменной, JavaScript сгенерирует ошибку. В строгом режиме, предусмотренном стандартом ECMAScript 5, ошибка также возбуждается при попытке присвоить значение необъявленной переменной. Однако исторически и при выполнении не в строгом режиме, если присвоить значение переменной, не объявленной с помощью инструкции var, то JavaScript создаст эту переменную как свойство глобального объекта, и она будет действовать практически так же, как корректно объявленная переменная. Это означает, что глобальные переменные можно не объявлять. Однако это считается дурной привычкой и может явиться источником ошибок, поэтому всегда старайтесь объявлять свои переменные с помощью var.
Область видимости (scope) переменной - это та часть программы, для которой эта переменная определена. Глобальная переменная имеет глобальную область видимости - она определена для всей JavaScript-программы. В то же время переменные, объявленные внутри функции, определены только в ее теле. Они называются локальными и имеют локальную область видимости. Параметры функций также считаются локальными переменными, определенными только в теле этой функции.
Внутри тела функции локальная переменная имеет преимущество перед глобальной переменной с тем же именем. Если объявить локальную переменную или параметр функции с тем же именем, что у глобальной переменной, то фактически глобальная переменная будет скрыта:
Var result = "global"; function getResult() { var result = "local"; return result; }; console.log(getResult()); // Отобразит "local"
Объявляя переменные с глобальной областью видимости, инструкцию var можно опустить, но при объявлении локальных переменных всегда следует использовать инструкцию var.
В данной главе рассматриваются базовая грамматика, объявление переменных, типы данных и литералы.
JavaScript заимствует большую часть синтаксиса из Java, но также испытал влияние таких языков, как Awk, Perl и Python.
JavaScript чувствителен к регистру и использует кодировку символов Unicode . Например, слово Früh ("рано" по-немецки) может использоваться в качестве имени переменной.
Var Früh = "foobar";
Но, переменная früh не то же самое что Früh потому что JavaScript чувствителен к регистру.
Синтаксис комментариев является таким же, как и в C++ и во многих других языках:
// Комментарий, занимающий одну строку. /* Комментарий, занимающий несколько строк. */ /* Нельзя вкладывать /* комментарий в комментарий */ SyntaxError * /В JavaScript существует три вида объявлений:
var Объявляет переменную, инициализация переменной значением является необязательной. let Объявляет локальную переменную в области видимости блока, инициализация переменной значением является необязательной. const Объявляет именованную константу, доступную только для чтения.Вы можете использовать переменные как символические имена для значений в вашем приложении. Имена переменных называются identifiers и должны соответствовать определенным правилам.
Идентификатор в JavaScript должен начинаться с буквы, нижнего подчеркивания (_) или знака доллара ($); последующие символы могут также быть цифрами (0-9). Поскольку JavaScript чувствителен к регистру, буквы включают символы от "A" до "Z" (верхний регистр) и символы от "a" до "z" (нижний регистр).
Вы можете использовать в идентификаторах буквы ISO 8859-1 или Unicode, например, å или ü. Вы также можете использовать как символы в идентификаторах.
Некоторые примеры корректных имен: Number_hits , temp99 , _name .
Вы можете объявить переменную тремя способами:
Переменная, объявленная через var или let без присвоения начального значения, имеет значение undefined .
При попытке доступа к необъявленной переменной или переменной до её объявления будет выброшено исключение ReferenceError :
Var a; console.log("The value of a is " + a); //Значение переменной a undefined console.log("The value of b is " + b); //Uncaught ReferenceError: b не определена console.log("The value of c is " + c); //Значение переменной c undefined var c; console.log("The value of x is " + x); //Uncaught ReferenceError: x не определена let x;
Вы можете использовать undefined , чтобы определить, имеет ли переменная значение. В следующем примере переменной input не присвоено значение, и оператор if будет вычислен как true:
var input; if (input === undefined) { doThis( ) ; } else { doThat( ) ; }Значение undefined ведет себя как false , когда используется в логическом контексте. Например, следующий код выполняет функцию myFunction , т.к. элемент myArray не определен:
var myArray = ; if (! myArray[ 0 ] ) { myFunction( ) ; }Значение undefined конвертируется в NaN , когда используется в числовом контексте:
var a; a + 2 ; // NaNЕсли массив создается с помощью литерала в скрипте верхнего уровня, то JavaScript интерпретирует массив каждый раз, когда вычисляет выражение, содержащее литерал. Кроме того, литерал, используемый в функции, создается каждый раз, когда вызывается функция.
Не обязательно указывать все элементы в литерале array. Если вы поставите две запятые подряд, то пропущенные элементы будут иметь значение undefined . Например:
var fish = [ "Lion" , , "Angel" ] ; // ["Lion", undefined, "Angel"]У этого массива есть 2 элемента со значениям и один пустой (fish - "Lion", fish - undefined , а fish - "Angel").
Если вы поставите запятую в конце списка элементов, то она будет проигнорирована. В следующем примере, длина массива равна 3. Нет myList . Все другие запятые в списке говорят о новом элементе.
Замечание: Лишние запятые могут вызывать ошибки в старых версиях браузеров, поэтому лучше избегать их использования.
var myList = [ "home" , , "school" , ] ; // ["home", undefined, "school"]В следующем примере длина массива равна четырем, элементы myList и myList имеют значение undefined:
var myList = [ , "home" , , "school" ] ; //В следующем примере длина массива равна четырем, элементы myList и myList имеют значение undefined . Игнорируется только последняя запятая.
var myList = [ "home" , , "school" , , ] ; // ["home", undefined, "school", undefined]Понимание поведения лишних запятых важно для понимания JavaScript как языка. Однако, когда будете писать свой собственный код, то имейте в виду, что явное объявление отсутствующих элементов как undefined улучшает ясность кода и лёгкость его поддержки.
Логический (Boolean) тип имеет два литеральных значения: true и false .
Не путайте примитивные логические значения true и false со значениями true и false объекта Boolean. Объект Boolean является объектом-обёрткой над примитивом логического типа. Чтобы получить более подробную информацию, прочитайте Boolean .
Целые числа могут быть записаны в десятичной, шестнадцатеричной, восьмеричной и двоичной системах счисления.
Несколько примеров целочисленных литералов:
0, 117 и -345 (десятичная система счисления) 015, 0001 и -077 (восьмеричная система счисления) 0x1123, 0x00111 и -0xF1A7 (шестнадцатеричная система счисления) 0b11, 0b0011 и -0b11 (двоичная система счисления)
Числа с плавающей точкой могут состоять из следующих частей:
Экспонента состоит из символа "e" или "E", за которым следует целое число, которое может иметь знак. Число с плавающей точкой должно состоять по крайней мере из одной цифры и либо десятичной точки, либо символа "e" (или "E").
В более сжатой форме синтаксис выглядит следующим образом:
[(+|-)][.digits][(E|e)[(+|-)]digits]
3.14 -3.1E+12 -.3333333333333333333 .1e-23
Литерал объекта - это список из нуля или более пар, состоящих из имен свойств и связанных с ними значений, заключенный в фигурные скобки ({}). Вам не следует использовать литерал объекта в начале выражения, т.к. это приведет к ошибке или к поведению, которого вы не ожидаете, потому что символ "{" будет интерпретироваться как начало блока.
В следующем примере свойству myCar объекта car присваивается строка "Saturn" , свойству getCar - результат вызова функции CarTypes("Honda") , свойству special - значение переменной Sales:
var Sales = "Toyota" ; function CarTypes( name) { if (name == "Honda" ) { return name; } else { return "Извините, мы не продаём " + name + "." ; } } var car = { myCar: "Saturn" , getCar: CarTypes( "Honda" ) , special: Sales } ; console. log( car. myCar) ; // Saturn console. log( car. getCar) ; // Honda console. log( car. special) ; // ToyotaКроме того, вы можете использовать числовой или строковой литералы в именах свойств или вкладывать один объект в другой. Например:
var car = { manyCars: { a: "Saab" , "b" : "Jeep" } , 7 : "Mazda" } ; console. log( car. manyCars. b) ; // Jeep console. log( car[ 7 ] ) ; // MazdaИменем свойства объекта может быть любая строка, в том числе пустая строка. Если имя свойства не является корректным JavaScript идентификатором, то оно должно быть заключено в кавычки. Для обращения к таким именам следует использовать квадратные скобки (), а не точку (.):
var unusualPropertyNames = { "" : "An empty string" , "!" : "Bang!" } console. log( unusualPropertyNames. "" ) ; // SyntaxError: Unexpected string console. log( unusualPropertyNames[ "" ] ) ; // "An empty string" console. log( unusualPropertyNames. ! ) ; // SyntaxError: Unexpected token ! console. log( unusualPropertyNames[ "!" ] ) ; // "Bang!"В ES2015 литералы объектов расширены до поддержки установки прототипа в конструкции короткой записи для foo: задание foo , определение методов, создание супер вызовов и вычисление имён свойств в выражениях. Вместе, они делают похожими объектные литералы и объявления классов, а также позволяют объектному дизайну получать выгоду одинаковых возможностей.
Var obj = { // __proto__ __proto__: theProtoObj, // Короткая запись для ‘handler: handler’ handler, // Методы toString() { // Супер вызовы return "d " + super.toString(); }, // Динамическое вычисление имён свойств [ "prop_" + (() => 42)() ]: 42 };
Обратите внимание на следующий пример:
var foo = { a: "alpha" , 2 : "two" } ; console. log( foo. a) ; // alpha console. log( foo[ 2 ] ) ; // two // console.log(foo.2); // SyntaxError: Unexpected number // console.log(foo[a]); // ReferenceError: a is not defined console. log( foo[ "a" ] ) ; // alpha console. log( foo[ "2" ] ) ; // twoЛитерал regexp - шаблон между слешами. Следующий пример литерал regex:
Var re = /ab+c/;
Строковый литерал - это ноль или более символов, заключенных в двойные (") или одинарные (") кавычки. Строка должна быть ограничена кавычками одного типа, т.е. либо обе одинарные, либо обе двойные. Например:
"foo" "bar" "1234" "one line \n another line" "John"s cat"
Вы можете вызвать любой из методов объекта String для строкового литерала: JavaScript автоматически преобразует строковой литерал во временный объект String , вызовет метод, а затем уничтожит временный объект String . Вы также можете использовать свойство String.length со строковым литералом:
Console. log( "John"s cat" . length); // Число символов в строке, включая пробел. // В данном случае длина строки равна 10.
В ES2015 также доступны шаблоны строк. Шаблоны строк представляют собой синтаксический сахар для конструирования строк. Это похоже на возможности интерполяции строк в Perl, Python и других. Дополнительно, может быть добавлен тег, позволяющий настраивать конструирование строк, избегая атак внедрения и построения структур данных высокого уровня из содержимого строки.
// Простое создание строки через литерал string `In JavaScript "\n" is a line-feed.` // Мультистроковые строки `In JavaScript this is not legal.` // Интерполяция строк var name = "Бобби", time = "сегодня"; `Привет ${name}, как ты ${time}?` // Строим префикс HTTP запроса, используемый для интерпретации замен и конструирования POST`http://foo.org/bar?a=${a}&b=${b} Content-Type: application/json X-Credentials: ${credentials} { "foo": ${foo}, "bar": ${bar}}`(myOnReadyStateChangeHandler);
Вам следует использовать строковые литералы до тех пор, пока вам специально не понадобится объект String . Чтобы получить более подробную информацию об объекте String , прочитайте String .
Кроме обычных символов вы также можете включать специальные символы в строки.
"one line \n another line"В следующей таблице перечислены специальные символы, которые вы можете использовать.
| Символ | Значение |
|---|---|
| \b | Возврат (Backspace) |
| \f | Перевод или прогон страницы (Form feed) |
| \n | Перевод строки (New line) |
| \r | Возврат каретки (Carriage return) |
| \t | Табуляция (Tab) |
| \v | Вертикальная табуляция (Vertical tab) |
| \" | Апостроф или одинарная кавычка |
| \" | Двойная кавычка |
| \\ | Обратная косая черта (Backslash) |
| \XXX |
Символ в кодировке Latin-1, представленный тремя восьмеричными числами XXX от 0 до 377. Например, \251 (символ ©). |
| \xXX |
Символ в кодировке Latin-1, представленный двумя шестнадцатеричными числами XX от 00 до FF. Например, \xA9 (символ ©). |
| \uXXXX |
Символ в Unicode, представленный четырьмя шестнадцатеричными числами XXXX . Например, \u00A9 (символ ©). |
| \u{XXXXX} | Символ в UTF-32BE. Например, \u{2F804} обозначает то же, что обычная запись \uD87E\uDC04. |
Для символов, не перечисленных в вышеприведенной таблице, предваряющая обратная косая черта игнорируется. Такое использование не является рекомендованным (deprecated) и вам следует избегать его.
Вы можете вставить кавычку в строку, если поставите перед ней обратную косую черту. Это называется экранированием кавычек. Например:
var quote = "He read \"The Cremation of Sam McGee\" by R.W. Service." ; console. log( quote) ; // He read "The Cremation of Sam McGee" by R.W. Service.Чтобы включить обратную косую черту в строку, перед ней нужно поставить еще одну обратную косую черту. Например:
var home = "c:\\temp" ; // c:\tempВы также можете экранировать перевод строки. Обратная косая черта и перевод строки будут удалены из содержимого строки. Например:
var str = "this string \ is broken \ across multiple\ lines. " console. log( str) ; // this string is broken across multiplelines.Хотя JavaScript не поддерживает синтаксис "heredoc" (форматированный текст в одной строковой переменной), но вы можете эмулировать его, добавив перевод строки и обратную косую черту в конец каждой строки:
var poem = "Roses are red, \n\ Violets are blue. \n\ I"m schizophrenic, \n\ And so am I. "Данная глава сфокусирована на базовом синтаксисе для объявлений и типов. Чтобы получить более подробную информацию о конструкциях JavaScript, прочитайте:
В следующей главе рассматриваются управляющие конструкции и обработка ошибок.
