Переменные JavaScript. Константы. Типы данных Как сохранить в переменных javascript c цифрами

Программист хочет создать глобальную переменную film и другую перемен­ную, которая называется так же, но действует только в функции showBadFilm() . Какое сообщение выведет alert из функции showGoodFilm() ? А какое сообщение будет выведено, если эту функцию вызвать повторно, но после вызова функции showBadFilm() ?

Хороший или плохой фильм? var film = "Калина красная"; function showGoodFilm() { alert(film + " - хороший фильм!"); } function showBadFilm() { film = "11 сентября"; alert(film + " - плохой фильм!"); } showGoodFilm(); // что выведет alert? showBadFilm(); // что выведет alert? showGoodFilm(); // что выведет alert?

Решение:

Обратите внимание на то, что в функции showBadFilm() перед переменной film отсут­ствует ключевое слово var . Поэтому JavaScript предполагает, что вы хотите переопределить зна­чение глобальной переменной, а не создать одноименную локальную переменную. Поэтому повторный вызов функции showGoodFilm() выведет: "11 сентября – хороший фильм!"

• Проверка типа данных

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

  Проверка типа данных var film = "Калина красная"; var 07_agent = "Агент"; var num = 10; var num1 = "10"; var u = true; var x; alert(typeof Film); //??? alert(typeof 07_agent); //??? alert(typeof num); //??? alert(typeof num1); //??? alert(typeof u); //??? alert(typeof x); //???

  Решение:

  Обратите внимание на то, что первая переменная объявлена под именем film , а в alert указана переменная Film . Это две разные переменные, поскольку JavaScript – регистрозависимый язык. Имя 07_agent начинается с цифры, а это вызовет синтаксическую ошибку и, как результат – скрипт не сработает.

The var statement declares a variable, optionally initializing it to a value.

The source for this interactive example is stored in a GitHub repository. If you"d like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

var declarations, wherever they occur, are processed before any code is executed. This is called hoisting, and is discussed further below.

The scope of a variable declared with var is its current execution context , which is either the enclosing function or, for variables declared outside any function, global. If you re-declare a JavaScript variable, it will not lose its value.

Assigning a value to an undeclared variable implicitly creates it as a global variable (it becomes a property of the global object) when the assignment is executed. The differences between declared and undeclared variables are:

1. Declared variables are constrained in the execution context in which they are declared. Undeclared variables are always global.

Function x() { y = 1; // Throws a ReferenceError in strict mode. var z = 2; } x(); console.log(y); // 1 console.log(z); // Throws a ReferenceError: z is not defined outside x.

2. Declared variables are created before any code is executed. Undeclared variables do not exist until the code assigning to them is executed.

Console.log(a); // "undefined" or "" depending on browser console.log("still going..."); // still going... var a = 1; console.log(a); // 1 console.log("still going..."); // still going...

3. Declared variables are a non-configurable property of their execution context (function or global). Undeclared variables are configurable (e.g. can be deleted).

Var a = 1; b = 2; delete this.a; // Throws a TypeError in strict mode. Fails silently otherwise. delete this.b; console.log(a, b); // Throws a ReferenceError. // The "b" property was deleted and no longer exists.

Because of these three differences, failure to declare variables will very likely lead to unexpected results. Thus it is recommended to always declare variables, regardless of whether they are in a function or global scope. And in ECMAScript 5 strict mode , assigning to an undeclared variable throws an error.

Because variable declarations (and declarations in general) are processed before any code is executed, declaring a variable anywhere in the code is equivalent to declaring it at the top. This also means that a variable can appear to be used before it"s declared. This behavior is called "hoisting", as it appears that the variable declaration is moved to the top of the function or global code.

Bla = 2; var bla; // ...is implicitly understood as: var bla; bla = 2;

For that reason, it is recommended to always declare variables at the top of their scope (the top of global code and the top of function code) so it"s clear which variables are function scoped (local) and which are resolved on the scope chain.

It"s important to point out that the hoisting will affect the variable declaration, but not its value"s initialization. The value will be indeed assigned when the assignment statement is reached:

Function do_something() { console.log(bar); // undefined var bar = 111; console.log(bar); // 111 } // ...is implicitly understood as: function do_something() { var bar; console.log(bar); // undefined bar = 111; console.log(bar); // 111 }

Be mindful of the order:

Var x = y, y = "A"; console.log(x + y); // undefinedA

Here, x and y are declared before any code is executed, but the assignments occur later. At the time " x = y " is evaluated, y exists so no ReferenceError is thrown and its value is undefined . So, x is assigned the undefined value. Then, y is assigned the value "A" . Consequently, after the first line, x === undefined && y === "A" , hence the result.

The same example as above but with a strict mode:

"use strict"; var x = 0; function f() { var x = y = 1; // Throws a ReferenceError in strict mode. } f(); console.log(x, y);

Variables that appear to be implicit globals may be references to variables in an outer function scope:

Var x = 0; // Declares x within file scope, then assigns it a value of 0. console.log(typeof z); // "undefined", since z doesn"t exist yet function a() { var y = 2; // Declares y within scope of function a, then assigns it a value of 2. console.log(x, y); // 0 2 function b() { x = 3; // Assigns 3 to existing file scoped x. y = 4; // Assigns 4 to existing outer y. z = 5; // Creates a new global variable z, and assigns it a value of 5. // (Throws a ReferenceError in strict mode.) } b(); // Creates z as a global variable. console.log(x, y, z); // 3 4 5 } a(); // Also calls b. console.log(x, z); // 3 5 console.log(typeof y); // "undefined", as y is local to function a

The compatibility table on this page is generated from structured data. If you"d like to contribute to the data, please check out https://github.com/mdn/browser-compat-data and send us a pull request.

Update compatibility data on GitHub

Для создания имён переменных в 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 = (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); // Ошибка