Javascript присвоение переменной значения. Грамматика и типы

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

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

Здесь важно отметить, что регистр важен при объявлении и использовании переменной. То есть переменная var A и переменная var a , это две разные переменные. И то имя, которое задали переменной изначально, то и нужно использовать во всем скрипте.

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

Как правильно задать имя переменной в JavaScript

В имена переменных нельзя использовать специальные символы, такие как #, $, дефис, пробел, точка и другие. Можно использовать только буквы (рекомендуется строчные), цифры и знак подчеркивания(_).

Нельзя чтобы первым символом в имени было число. Например, так назвать можно bmw_93 а так нельзя 123_opel.

Также нельзя назвать переменную зарезервированными словами языка, как например var, for, if.

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

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.

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

Типы переменных

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

• Integer – В этот тип входят целые числовые числа, как положительные так и отрицательные (например: 1,2,4, -8, -100).
• Double – В этот тип входят числа с плавающей точкой, они еще называются дробные числа (например 1.6, -9.8, 2.5). Они тоже могут быть и отрицательными.
• String – Это строковые значения. К этому типу относится любой символ, любая буква или же строка. Все строковые значения должны быть объявлены в одинарные либо двойные кавычки.
• Boolean – Данный тип является логическим. Он может иметь только одну из двух значений, это либо true (истина) либо false (ложь).
• Массив – это сбор данных, которые могут быть разных типов. Существует два типа массивов, это числовой, у которого индексы(ключи) числовые и ассоциативный, со строчными индексами.
• Объект – Может быть одним из двух типов данных, либо ассоциативный массив, либо экземпляр какого не будь класса.

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

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

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("

" + count_players + " = " + compare + "
"); //false compare = count_ball < count_players; document.write(count_ball + " < " + count_players + " = " + compare + "
"); //true

Данные операции чаще всего используются в условных операторах if, else.

Для лучшего понимания, покажу Вам таблицу истинности. Ее Вы должны знать наизусть. Для этого достаточно ее понять.

Вместо true может быть 1, а вместо false 0.

&& - Это оператор AND, то есть И. Его можно понять как оператор умножения.

• 0(false) && 0(false) = 0(false)
• 0(false) && 1(true) = 0(false)
• 1(true) && 0(false) = 0(false)
• 1(true) && 1(true) = 1(true)

|| - Это оператор OR, то есть ИЛИ. Его можно понять как оператор сложение.

• 0(false) || 0(false) = 0(false)
• 0(false) || 1(true) = 1(true)
• 1(true) || 0(false) = 1(true)
• 1(true) || 1(true) = 1(true)

Символ "|" на клавиатуре печатается с помощью комбинации клавиш Shift + Back slesh(Обратный слеш \).

^ - Это оператор XOR, то есть Исключающее ИЛИ. Он используется редко. Но его нужно знать по любому, вдруг понадобится.

• 0(false) ^ 0(false) = 0(false)
• 0(false) ^ 1(true) = 1(true)
• 1(true) ^ 0(false) = 1(true)
• 1(true) ^ 1(true) = 0(false)

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

Переменные

Объявление переменных

Прежде чем использовать переменную в 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? Но потом вспомнил, как иногда разбирался со сложными конструкциями и с трудом понимал некоторые, казалось бы недопустимые в других языках программирования выражения. Можно сказать так: здесь вам не будет ошибки "Неверный тип данных", а если и будет то очень редко. Если вы работали с другими языками программирования, тогда вспомните как часто у вас возникала ошибка о неверных типах данных. В языке JavaScript тип данных может с легкостью переопределяться, при этом вы можете и не заметить в каком месте, - вот в этом то и сложность. С другой стороны, если вы будете хорошо ориентироваться в принципах преобразований типов, знать все свойства переменных и массивов, эти возможности только принесут вам уверенность в написании программ.

Переменные языка JavaScript могут хранить значения различных типов:

• Строки - последовательность символов;
• Числовые значения- целые и действительные числа;
• Булевы значения- только два значения true или false;
• Массивы- множества однотипных переменных;
• Даты- значения даты и времени.

Время жизни переменной связано с окном, в котором они созданы и зависит от того, где они определены. JavaScript- программы содержатся в документах HTML, и при загрузке нового документа в браузер любые переменные, созданные в программе, будут удалены.
Чтобы сохранить какие-либо значения при загрузке нового документа в JavaScript имеются только 2 решения:

• путем создания переменных во фреймосодержащем документе верхнего уровня;
• путем использования "cookies";

Для сохранения переменных и функций с помощью фреймосодержащих документов эти переменные и функции неодходимо определить в документе верхнего уровня, а затем использовать свойства parent или top объекта window для обращения к ним из документов, загруженных в фреймы. ВАЖНО: такие переменные и функции нужно задавать в заголовке документа верхнего уровня между тегами . . . . Конечно, существует вероятность, что документ может быть загружен без фрейма и тогда обращение к неопределенному объекту вызовет ошибку, но можно предварительно проверить загружен ли документ в фрейм:

Cookies позволяют сохранять небольшие фрагменты информации на локальном диске пользователя. Устанавливая значения cookies и прореряя их на последующих стадиях работы, иожно восстанавливать необходимые значения. Более подробно о cookies будем говорить позже.

Имена переменных, создание переменных

В языке JavaScript создать переменную гораздо проще, чем в других языках программирования. Например, при создании переменной нет необходимости указывать ее тип. Переменные определяют как с начальными значениями, так и без них. В процессе выполнения программы уже созданные переменные можно даже приводить к различным типам данных. Имена переменных могут начинаться с любой буквы (от a до z, или A-Z) либо с символа подчеркивания (_), оставшаяся часть может содержать цифры, символы подчеркивания и буквы. Помните то, что в именах переменных различаются символы верхнего и нижнего регистра: например MyVariable - это не то же что myvariable.
Переменную можно создать одним из способов:

• при помощи оператора var и операции присваивания (=);
• при помощи операции присваивания (=).

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

Var MyVariable = 35

Создает переменную с именем MyVariable, содержащую числовое значение 35. Переменная существует до тех пор, пока загружен текущий документ. Если вы создаете эту переменную во фреймосодержащем документе верхнего уровня, к ней следует обращаться с помощью выражения top.MyVariable, а еще лучше parent.MyVariable для подстраховки от вложенных фреймов.

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

Var MyVariable = "35"

Переменная будет уже хранить строку "35". Подобные преобразования-то и приводят иногда к недоразумениям. Вот например:

Как вы думаете какое значение примет переменная "c" после выполнения программы? Если вы не знакомы с правилами преобразования переменных в JavaScript - не угадаете. Значение переменной "c" после завершения блока будет равным числовому значению 320. О принципах преобразования типов переменных будем говорить позже. Переменную можно определить и не используя оператор "Var", а просто достаточно присвоить значение, причем каков тип данных будет присвоен, того типа и окажется переменная. Оператор "Var" используется по большей части для читабельности JS-программы. Переменная может быть задана и без начальных значений, например:

Var MyVariable;

Создана переменная с именем MyVariable, не имеющая определенного типа данных и начального значения. Переменные, создаваемые при помощи таких описаний, известны как неопределенные (null variable). Например сравнивая такую переменную со значением null, можно узнать, определена ли переменная. Однако нельзя путать разные вещи: ""- пустая строка это строковый тип и вовсе не null-значение.

Тип переменной может быть установлен в любом месте JS-программы в отличие от других языков программирования, что дает дополнительную гибкость, но и возможность запутаться - помните это. К переменной, которая не создана, обратиться невозможно. Если нужно создать временную переменную, например счетчик цикла, нужно записать перед ней префикс var:
for (var i=0; i "10"); Самым простым и наиболее распространенным способом создания объекта String является использование таких операторов, как

Var myVariable = "Хорошее пиво";

Приведенный оператор присваивает строку "Хорошее пиво" строковой переменной myVariable. Переменная myVariable рассматривается как строковый объект и может использовать любой из стандартных методов объекта String языка JavaScript. Оператор Var можно пропустить, как и говорилось ранее он нужен в основном для читабельности программы.

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

Var myVariable = new String();

Этот оператор создает новый объект - пустую строку с именем myVariable. Изначально это пустая строка (""), а значение свойства myVariable.length равное 0.

Конструктор String() допускает передачу заданной строки в виде аргумента:

Var myVariable = new String("Правильное пиво");

Строковый объект может содержать специальные символы, управляющие форматированием строк:

• \n - символ новой строки;
• \r - символ возврата каретки;
• \f - код перехода на новую страницу;
• \xnn - представление символа в виде шестнадцатиричного ASCII-кода nn;
• \b - код клавиши .

эти символы будут правильно интерпретированы только в контейнерах и в методах "Alert". Форматирование же для document.write() осуществяется другими методами или тегами HTML.
Объект String имеет только одно свойство - length, значением которого является количество символов в строке, содержащейся в объекте. Методы объекта String можно разделить на две категории:

• методы форматирования HTML-документа;
• методы обработки строк.

Методы форматирования документа применяются для вывода строк в документ, а методы управления строками - для проверки и изменения содержимого объекта String.
Приведем перечень методов: (буква Ф - методы форматирования, а буква У - управления строками)

Метод		Описание
anchor()	У	Создает именованную метку, т.е. тег из содержимого объекта
big()	Ф	Заключает строку в контейнер . . . , для отображения крупным шрифтом
blink()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась мигающей.
bold()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась жирным шрифтом.
charAt()	У	Возвращает символ, находящийся в заданной позиции строки
fixsed()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась шрифтом постоянной ширины.
fontcolor()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась определенным цветом.
fontsize()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась шрифтом определенного размера.
IndexOf()	У	Возвращает индекс первого заданного символа, найденного в строке.
italics()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась курсивом.
lastIndexOf()	У	Возвращает индекс последнего заданного символа, найденного в строке.
link()	У	Создает тег гиперсвязи . . . и помещает в него содержимое объекта
small()	Ф	Заключает строку в тег . . . , чтобы она отображалась шрифтом меньшего размера.
strike()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась зачеркнутой.
sub()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась как нижний индекс.
substring()	У	Возвращает подстроку текстовой строки.
sup()	Ф	Заключает строку в контейнер . . . , чтобы она отображалась как верхний индекс.
toLowerCase()	У	Преобразует все буквы строки в строчные
toUpperCase()	У	Преобразует все буквы строки в прописные

Числовые переменные

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

• умножения (*);
• деления (/);
• сложения (+);
• вычитания (-);
• увеличения (++);
• уменьшения (--);

Кроме того, используют операции умножения, деления, сложения и вычитания в сочетании с присваиванием (*=, /=, +=, -=), а также методы объекта Math.

Булевы переменные

Булевы, или логические, переменные содержат только литеральные значкения - true и false - и используются в логических выражениях и операторах.
Для проверки значения булевой переменной используют и операцию логического равенства:
booleanVar == true
хотя в данном случае такая операция проверки излишняя. Для проверки значений, которые не являются истинными, используют знак логического отрицания (!). Например, выражение!booleanVar возвратит значение true, если значение booleanVar равно false. Вместо слов "true" и "false" можно использовать числовые значения "1" и "2", поскольку именно такбулевы значения представлены в памяти компьютера: 1==true и 0==false.

Переменные-массивы

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

ArrayName

Где arrayName - имя массива, а index - числовая переменная или число, задающее позицию элемента в массиве. Например, arrayName является первым элементом этого массива. Индексы элементов массива в языке JavaScript начинаются с нуля. Элементы массива могут быть любого типа, например строками или булевыми переменными. Кроме того, при определенных условиях массив может содержать элементы различных типов данных. В языке JavaScript массивы создаются при помощи:

• конструктора Array();
• конструктора Object();
• конструктора, определенного пользователем.

С помощью конструктора Array() не только создают объект array, но и присваивают начальные значения его элементам. Существует возможность добавлять элементы в массивдинамически - путем присваивания определенных значений элементам массива. Допускается также "пропускать" элементы массива и задавать их в любой последовательности. Для создания нового экземпляра объекта array конструктор Array() необходимо использовать с оператором new. Например, в седующем примере создается массив с именем arrayImg, содержащий два элемента, каждый из которых является объектом String

Var path = "c:/images/" ,
arrayImg = new Array();
arrayImg = path+"img1.gif";
arrayImg = path+"img2.gif";

При использовании конструктора Array() значение свойства length устанавливается автоматически. Поэтому после инициализации элементов массива в приведенном примере выражение arrayImg.length возвращает значение 2. Элементы массива также могут быть заданы как параметры конструктора:

Var path = "c:/images/" ,
arrayImg = new Array(path+"img1.gif", path+"img2.gif");

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

Var myArray = new Array(3.14, true, 85, date(), "word");

Создает массив, элемент myArray которого является числом с плавающей запятой, элемент myArray - булевым значением, элемент myArray - объектом Date.
Размер массива и, следовательно, значение свойства length объекта, создаваемого конструктором Array(), зависят от максимального значения индекса, который применялся для задания элемента массива. Например:

Var myArray = new Array;
myArray = "Это 21 элемент массива";

Двадцать первому элементу массива присваивается строковое значение "Это 21 элемент массива", а значение свойства myArray.length равно 21 независимо от того имеют ли значения элементы массива с индексом меньше 20.
Значение свойства length объекта Array автоматически устанавливается при явном указании количества элементов в конструкторе Array():

MyArray = new Array(10);

Оператор создает массив из 10-ти элементов от 0 до 9. Значение свойства length массива нельзя установить путем присваивания, так как length является свойством только для чтения. Например, чтобы задать значение 10 для свойства length нужно только определить значение последнего, в данном случае 9-го элемента массива:

MyArray = new Array();
myArray = 0;

Кроме того, существует возможность задать значения элементов массива при его конструировании:

MyArray = new Array(0,0,0,0,0,0);

Конструктор Object()

Понятия объект и массив равнозначны, хотя конструкторы Object() и Array() работают по-разному. Конструктору Object() невозможно передать несколько элементов массива, поэтому такое выражение
var myObj = new Object(value1, value2);
работать не будет. Массивы, создаваемые при помощи конструктора Object(), не имеют свойства length. Поэтому, создавая массив таким способом, следует либо организовывать обход этого массива посредством цикла for и подсчитать элементы массива, либо жестко задать длину массива как значение его первого элемента (обычно так поступают моделируя свойство length), а затем обращаться к нему по мере необходимости для проверки размера массива, увеличение значения при добавлении нового элемента, а также в качестве параметра цикла при циклическом считывании или изменения значений элементов. Такой объект часто бывает неприемлем для случаев, когда содержимое массива должно динамически изменяться, поэтому в большинстве случаев пользуются конструктором Array(). Значения индексов массивов, создаваемых в конструкторе Object(), также начинаются с нуля. Для создания массива при помощи конструктора Object() принято использовать запись вида:

Var myObj = new Object();
myObj = 2; // задаем размерность массива
myObj = "Первый элемент";
myObj = "Второй элемент";

Чтобы узнать размер массива, созданного подобным образом, необходимо обратиться к элементу myObj. Значением свойства myObj.length является null, так, как значение не определено.

Преобразование строк и чисел

Наконец подошли к самой интересной теме. Дело в том, что в языке JavaScript в отличие от других языков нет функций типа Val() и Str(). Однажды я видел программку на языке JavaScript, автора не буду называть, где при помощи всевозможных преобразований типов данных была попытка запутать программу для "непродвинутых" пользователей. Так вот, нужно запомнить два правила:

• Преобразование числа в строку символов производится путем сложение числового аргумента со строковым, независимо от перестановки слагаемых. Например если переменная varI=123, то преобразовать переменную и следовательно ее значение в строку символов можно: varI = varI + "" или наоборот: varI = "" + varI. Если сложить не с пустой строкой: varI = varI + "456", то результатом значения переменной varI станет "123456". Это же справедливо и наоборот: varI = "456" + varI - результат: "456123";
• Преобразование строки в число производится путем вычитания одного операнда из другого и также независимо от их позиции. Например если переменная varI = "123", то преобразовать ее в число можно если вычесть из нее значения 0: varI = varI - 0, и соответственно значение переменной из строкового типа преобразуется в числовой: 123. При перестановки операндов соответственно знак числового значения поменяется на противоположный. В отличие от преобразования числа в строку в действиях вычитания нельзя применять буквенные значения. Так если "JavaScript" + 10 превратится в varI == "JavaScript10", то операция типа varI = "JavaScript" - 10 выдаст значение "NON" - тоесть такая операция не допустима. И еще, при вычитании строкового значения из строкового же также происходит преобразование: varI = "20" - "15", значением переменной varI станет число 5.

Для создания имён переменных в JavaScript установлены правила синтаксиса:

• Для имён переменных используются символы: a-z, A-Z, цифры, символ $, символ знак подчёркивания (_).
• Имя переменной не может начинаться с цифры.
• JavaScript чувствителен к регистру, об этом нужно помнить при программировании. itcounter и itC ounter - это разные переменные.
• В JavaScript нет ограничений на длину имени переменной.

Примеры правильных имён переменных:

• itcounter
• $_itcounter
• it_counter

Ошибочные имена переменных:

• 9room
• it-counter
• #itcounter
• &itcounter

Переменные объявляются командой 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 (ложь).

Этот тип данных используется в операциях сравнения. Вот простые примеры:

• 9 > 1 - это истина.
• 2 > 5 - это ложь.

var $count = 2

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

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

• string - строковая переменная.
• number - числовая переменная.
• boolean - булева переменная.
• null - специальное значение «ничто».
• undefined - тип «значение не присвоено».

Значение переменной 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 может быть таким:

• typeof $count
• typeof($count)

Итак, запустите код из последнего примера и посмотрите на результат. Тип переменной 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); // Ошибка