→ → Javascript объявление переменной с условием. JavaScript - Переменные. Константы. Типы данных. Литерал числа с плавающей точкой

Javascript объявление переменной с условием. JavaScript - Переменные. Константы. Типы данных. Литерал числа с плавающей точкой

Честно сказать я с начала не хотел вводить эту тему. Что можно говорить о переменных, особенно в 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 являются контейнерами для хранения различной информации.

Переменные JavaScript

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

Каждая JavaScript переменная должна иметь собственное уникальное имя, которое может начинаться с латинской буквы или символа "_".

Обратите внимание: имя переменных в JavaScript не может начинаться с цифр.

Обратите внимание: так как JavaScript чувствителен к регистру, переменные с одинаковыми именами написанными в разном регистре (например var и VAR), будут являться разными переменными.

Создание переменных

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

Переменные в JavaScript объявляются с помощью команды var .

//Создаем переменную с именем ex1 var ex1; //Создаем переменную с именем ex2 var ex2;

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

Значения могут загружаться в контейнеры также прямо в момент создания как в примере ниже:

//Создаем переменную с именем ex1 содержащую значение 4 var ex1=4; //Создаем переменную с именем ex2 содержащую значение 5 var ex2=5;

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

В следующем примере мы будем извлекать содержимое переменных и сразу выводить его на страницу с помощью команды document.write.

//Запишем число 4 в переменную ex1 var ex1=4; //Запишем число 5 в переменную ex2 var ex2=5; //Выведем содержимое переменной ex1 на страницу document.write(ex1+"
"); //Выведем содержимое переменной ex2 document.write(ex2+"
"); //Изменим содержимое переменной ex2 ex2=200; //Выведем новое содержимое переменной ex2 document.write(ex2);

Быстрый просмотр

Строковые переменные

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

При записи текста в переменную обязательно заключайте его в двойные (") или одинарные кавычки (").

//Запишем в переменную ex строку "Привет всем!" var ex="Привет всем!"; //Выведем значение переменной ex на страницу document.write(ex);

Быстрый просмотр

Определение переменных с var и без него

В JavaScript Вы можете определять переменные с var и без него.

//Создадим новую переменную с var var ex=123; //Создадим новую переменную без var ex2=20;

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

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

Обратите внимание: мы подробнее поговорим о локальных и глобальных переменных далее в этом учебнике.

Об удалении и переопределении переменных

Переопределяя переменные Вы не стираете значение, которое хранятся в них.

Var ex=123; var ex; document.write(ex); // Выведет 123

Если Вы хотите удалить переменную в JavaScript и она не была объявлена с помощью var Вы можете использовать оператор delete .

Ex=123; delete ex;

Оператор delete не может удалить переменные объявленные с помощью var, поэтому если переменная была объявлена с помощью var, то единственный способ удалить ее - присвоить ей значение null или undefined.

Var ex=123; ex=null; // или ex=undefined

Сделайте сами

Задание 1 . Исправьте ошибки в коде ниже:

Задание 1

var 33var=33; document.write(33var); document.write("
"); var str1=Привет всем!; document.write(str1); document.write("
"); var vaR = 288; document.write(var); document.write("
");

Задание 2 . Во внешнем файле secred1.js содержится переменные sec1, sec2, sec3 и sec4, которые содержат буквы кодового слова (не по порядку). Подключите внешний файл и узнайте кодовое слово путем вывода значений переменных на страницу.

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

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

Вы помните школьную алгебру? 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), переменные объявляются с помощью ключевого слова 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 заимствует большую часть синтаксиса из 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, прочитайте:

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

 

 
Это интересно: