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

Объявление

Прежде чем использовать переменную, её необходимо объявить. Переменные объявляются с помощью ключевого слова 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); // Ошибка

В этом примере, x, y , и z , являются переменными:

Из приведенного выше примера, вы можете ожидать:

• x сохраняет значение 5
• y сохраняет значение 6
• z сохраняет значение 11

Так же, как алгебра

В этом примере, price1, price2 , и total , являются переменными:

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

В программировании, так же, как в алгебре, мы используем переменные в выражениях (total = price1 + price2) .

Из приведенного выше примера, вы можете рассчитать total быть 11.

переменные JavaScript являются контейнерами для хранения значений данных.

JavaScript Идентификаторы

Все переменные JavaScript должны быть идентифицированы с уникальными именами.

Эти уникальные имена называются идентификаторы.

Идентификаторы могут быть короткие имена (например, x и y ), или более описательные имена (age, sum, totalVolume) .

Общие правила построения имен для переменных (уникальными идентификаторами) являются:

• Имена могут содержать буквы, цифры, подчеркивания и знаков доллара.
• Имена должны начинаться с буквы
• Имена также могут начинаться с $ и _ (но мы не будем использовать его в этом руководстве)
• Имена чувствительны к регистру (у и Y являются различными переменными)
• Зарезервированные слова (например, ключевые слова JavaScript) не могут быть использованы в качестве имен

JavaScript идентификаторы чувствительны к регистру.

Оператор присваивания

В JavaScript, знак равенства (=) является "назначение" оператор, а не "равно".

Это отличается от алгебры. Ниже не имеет смысла в алгебре:

В JavaScript, однако, это имеет смысл: он присваивает значение х + 5 до х.

(Он вычисляет значение х + 5, и помещает результат в х. Величина х увеличивается на 5)

"Равно" оператор записывается как == в JavaScript.

Типы данных JavaScript

Переменные JavaScript может содержать цифры, как 100 и текстовые значения, как "John Doe" .

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

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

Строки написаны в двойные или одинарные кавычки. Числа записываются без кавычек.

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

Декларирование (Создание) Переменные JavaScript

Создание переменной в JavaScript называется "объявить" переменную.

Вы объявляете переменную JavaScript с var ключевым словом:

После объявления, переменная не имеет значения. (Технически это имеет значение не определено)

Для того, чтобы присвоить значение переменной, используйте знак равенства:

carName = "Volvo";

Можно также присвоить значение переменной при объявлении его:

var carName = "Volvo";

В приведенном ниже примере, мы создаем переменную с именем carName и присвоить значение "Volvo" к нему.

Тогда мы "выход" значение внутри HTML пункта с id="demo" :

пример

var carName = "Volvo";
document.getElementById("demo").innerHTML = carName;

Попробуй сам " Одно заявление, много переменных

Можно объявить много переменных в одном операторе.

Начните заявление с var и разделим переменные через запятую:

Объявление может занимать несколько строк:

Значение = не определено

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

Переменная, объявленная без значения будет иметь значениене определено.

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

Последнее обновление: 05.04.2018

Для хранения данных в программе используются переменные . Переменные предназначены для хранения каких-нибудь временных данных или таких данных, которые в процессе работы могут менять свое значение. Для создания переменных применяются ключевые слова var и let . Например, объявим переменную myIncome:

Var myIncome; // другой вариант let myIncome2;

Каждая переменная имеет имя. Имя представляет собой произвольный набор алфавитно-цифровых символов, знака подчеркивания (_) или знака доллара ($), причем названия не должны начинаться с цифровых символов. То есть мы можем использовать в названии буквы, цифры, подчеркивание. Однако все остальные символы запрещены.

Например, правильные названия переменных:

$commision someVariable product_Store income2 myIncome_from_deposit

Следующие названия являются некорректными и не могут использоваться:

222lol @someVariable my%percent

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

Var for;

Список зарезервированных слов в JavaScript:

abstract, boolean, break, byte, case, catch, char, class, const, continue, debugger, default, delete, do, double, else, enum, export, extends, false, final, finally, float, for, function, goto, if, implements, import, in, instanceof, int, inteface, long, native, new, null, package, private, protected, public, return, short, static, super, switch, synchronized, this, throw, throws, transient, true, try, typeof, var, volatile, void, while, with

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

Var myIncome; var MyIncome;

Через запятую можно определить сразу несколько переменных:

Var myIncome, procent, sum; let a, b, c;

С помощью знака равно (который еще называют оператором присваивания ) можно присвоить переменной какое-либо значение:

Var income = 300; let price = 76;

Процесс присвоения переменной начального значения называется инициализацией .

Теперь переменная income будет хранить число 300, а переменная price - число 76.

Отличительной чертой переменных является то, что мы можем изменить их значение:

Var income = 300; income = 400; console.log(income); let price = 76; price = 54; console.log(price);

Константы

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

Const rate = 10;

Если мы попробуем изменить ее значение, то мы столкнемся с ошибкой:

Const rate = 10; rate = 23; // ошибка, rate - константа, поэтому мы не можем изменить ее значение

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

Const rate; // ошибка, rate не инициализирована

Переменные служат "контейнерами" для хранения информации.

Вы Помните Школьную Алгебру?

Вы помните школьную алгебру? x=5, y=6, z=x+y

Вы помните, что буква (например x) могла бы использоваться для хранения значения (например 5), и что вы могли бы использовать информацию выше, чтобы вычислить, что значение z равно 11?

Эти буквы называются переменными , и переменные могут использоваться для хранения значений (x=5) или выражений (z=x+y).

Переменные JavaScript

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

Переменная может иметь короткое имя, например x, или более информативное имя, например carname (название автомобиля).

Правила для имен переменных JavaScript:

• Имена переменных чувствительны к регистру (y и Y это две разных переменных)
• Имена переменных должны начинаться с буквы или символа подчеркивания

Замечание: Поскольку JavaScript чувствителен к регистру, имена переменных также чувствительны к регистру.

Пример

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

Объявление (Создание) Переменных JavaScript

Создание переменных в JavaScript более часто называют "объявлением" переменных.

Вы объявляете переменные JavaScript с помощью ключевого слова var :

После выполнения предложений выше, переменная x будет содержать значение 5 , и carname будет содержать значение Мерседес .

Замечание: Когда вы присваиваете текстовое значение переменной, заключайте его в кавычки.

Замечание: Если вы объявляете переменную повторно, она не потеряет свое значение.

Локальные Переменные JavaScript

Переменная, объявленная внутри функции JavaScript становится ЛОКАЛЬНОЙ и будет доступна только в пределах этой функции. (переменная имеет локальную область видимости).

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

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

Вы узнаете больше о функциях в последующих уроках JavaScript.

Глобальные Переменные JavaScript

Переменные объявленные вне функции становятся ГЛОБАЛЬНЫМИ , и все скрипты и функции на странице могут к ним обращаться.

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

Если вы объявляете переменную, не используя "var", переменная всегда становится ГЛОБАЛЬНОЙ .

Присваивание Значений Необъявленным Переменным JavaScript

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

Эти предложения:

Вы узнаете больше об операторах в следующем уроке JavaScript.

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

Основы

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 . Например, var x = 42 . Данный синтаксис может быть использован для объявления как локальных, так и глобальных переменных.
• Просто присвоить переменной значение. Например, x = 42 . Переменные, объявленные данным способом, являются глобальными. Такое объявление генерирует строгое предупреждение (strict mode). Не рекомендуется использовать данный способ.
• Используя ключевое слово let . Например, let y = 13 . Данный синтаксис может быть использован для объявления локальной переменной в области видимости блока.

Присваивание значений

Переменная, объявленная через 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

Не обязательно указывать все элементы в литерале 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-7.
• Ведущие символы 0x (или 0X) указывают на то, что число шестнадцатеричное. Шестнадцатеричные целые числа могут состоять из цифр 0-9 и букв a-f и A-F.
• Ведущие символы 0b (или 0B) указывают на то, что число двоичное. Двоичные числа могут включать в себя только цифры 0 и 1.

Несколько примеров целочисленных литералов:

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 литерал

Литерал 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"

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

Специальные символы в JavaScript Символ Значение

\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, прочитайте:

В следующей главе рассматриваются управляющие конструкции и обработка ошибок.