Var java что это

Устаревшее ключевое слово «var»

Информация, приведенная в этой статье, полезна для понимания старых скриптов.

Мы не пишем современный код таким образом.

В самой первой главе про переменные мы ознакомились с тремя способами объявления переменных:

let и const ведут себя одинаково по отношению к лексическому окружению, области видимости.

Но var – это совершенно другой зверь, берущий своё начало с давних времён. Обычно var не используется в современных скриптах, но всё ещё может скрываться в старых.

Если в данный момент вы не работаете с подобными скриптами, вы можете пропустить или отложить прочтение данной главы, однако, есть шанс, что вы столкнётесь с var в будущем.

На первый взгляд, поведение var похоже на let . Например, объявление переменной:

function sayHi() < var phrase = "Привет"; // локальная переменная, "var" вместо "let" alert(phrase); // Привет >sayHi(); alert(phrase); // Ошибка: phrase не определена

…Однако, отличия всё же есть.

Для «var» не существует блочной области видимости

Область видимости переменных var ограничивается либо функцией, либо, если переменная глобальная, то скриптом. Такие переменные доступны за пределами блока.

if (true) < var test = true; // используем var вместо let >alert(test); // true, переменная существует вне блока if

Так как var игнорирует блоки, мы получили глобальную переменную test .

А если бы мы использовали let test вместо var test , тогда переменная была бы видна только внутри if :

if (true) < let test = true; // используем let >alert(test); // Error: test is not defined

Аналогично для циклов: var не может быть блочной или локальной внутри цикла:

for (var i = 0; i < 10; i++) < // . >alert(i); // 10, переменная i доступна вне цикла, т.к. является глобальной переменной

Если блок кода находится внутри функции, то var становится локальной переменной в этой функции:

function sayHi() < if (true) < var phrase = "Привет"; >alert(phrase); // срабатывает и выводит "Привет" > sayHi(); alert(phrase); // Ошибка: phrase не определена (видна в консоли разработчика)

Как мы видим, var выходит за пределы блоков if , for и подобных. Это происходит потому, что на заре развития JavaScript блоки кода не имели лексического окружения. Поэтому можно сказать, что var – это пережиток прошлого.

«var» допускает повторное объявление

Если в блоке кода дважды объявить одну и ту же переменную let , будет ошибка:

let user; let user; // SyntaxError: 'user' has already been declared

Используя var , можно переобъявлять переменную сколько угодно раз. Повторные var игнорируются:

var user = "Pete"; var user; // ничего не делает, переменная объявлена раньше // . нет ошибки alert(user); // Pete

Если дополнительно присвоить значение, то переменная примет новое значение:

var user = "Pete"; var user = "John"; alert(user); // John

«var» обрабатываются в начале запуска функции

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

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

function sayHi() < phrase = "Привет"; alert(phrase); var phrase; >sayHi();

…Технически полностью эквивалентен следующему (объявление переменной var phrase перемещено в начало функции):

function sayHi() < var phrase; phrase = "Привет"; alert(phrase); >sayHi();

…И даже коду ниже (как вы помните, блочная область видимости игнорируется):

function sayHi() < phrase = "Привет"; // (*) if (false) < var phrase; >alert(phrase); > sayHi();

Это поведение называется «hoisting» (всплытие, поднятие), потому что все объявления переменных var «всплывают» в самый верх функции.

В примере выше if (false) условие никогда не выполнится. Но это никаким образом не препятствует созданию переменной var phrase , которая находится внутри него, поскольку объявления var «всплывают» в начало функции. Т.е. в момент присвоения значения (*) переменная уже существует.

Объявления переменных «всплывают», но присваивания значений – нет.

Это проще всего продемонстрировать на примере:

function sayHi() < alert(phrase); var phrase = "Привет"; >sayHi();

Строка var phrase = «Привет» состоит из двух действий:

Объявление переменной var
Присвоение значения в переменную = .

Объявление переменной обрабатывается в начале выполнения функции («всплывает»), однако присвоение значения всегда происходит в той строке кода, где оно указано. Т.е. код выполняется по следующему сценарию:

function sayHi() < var phrase; // объявление переменной срабатывает вначале. alert(phrase); // undefined phrase = "Привет"; // . присвоение - в момент, когда исполнится данная строка кода. >sayHi();

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

В обоих примерах выше вызов alert происходил без ошибки, потому что переменная phrase уже существовала. Но её значение ещё не было присвоено, поэтому мы получали undefined .

IIFE

В прошлом, поскольку существовал только var , а он не имел блочной области видимости, программисты придумали способ её эмулировать. Этот способ получил название «Immediately-invoked function expressions» (сокращенно IIFE).

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

IIFE выглядит следующим образом:

(function() < var message = "Hello"; alert(message); // Hello >)();

Здесь создаётся и немедленно вызывается Function Expression. Так что код выполняется сразу же и у него есть свои локальные переменные.

Function Expression обёрнуто в скобки (function <. >) , потому что, когда JavaScript встречает «function» в основном потоке кода, он воспринимает это как начало Function Declaration. Но у Function Declaration должно быть имя, так что такой код вызовет ошибку:

// Пробуем объявить и сразу же вызвать функцию function() < // ();

Даже если мы скажем: «хорошо, давайте добавим имя», – это не сработает, потому что JavaScript не позволяет вызывать Function Declaration немедленно.

// ошибка синтаксиса из-за скобок ниже function go() < >(); //


Так что скобки вокруг функции – это трюк, который позволяет объяснить JavaScript, что функция была создана в контексте другого выражения, а значит, что это Function Expression: ей не нужно имя и её можно вызвать немедленно.
Помимо круглых скобок существуют и другие способы сообщить JavaScript, что мы имеем в виду Function Expression:
// Способы создания IIFE (function() < alert("Круглые скобки вокруг функции"); >)(); (function() < alert("Круглые скобки вокруг всего выражения"); >()); !function() < alert("Выражение начинается с логического оператора НЕ"); >(); +function() < alert("Выражение начинается с унарного плюса"); >();
Во всех перечисленных случаях мы объявляем Function Expression и немедленно запускаем его. Ещё раз отметим: в настоящее время необходимости писать подобный код нет.
Итого
Существует 2 основных отличия var от let/const :

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

Есть ещё одно небольшое отличие, относящееся к глобальному объекту, мы рассмотрим его в следующей главе.
Эти особенности, как правило, не очень хорошо влияют на код. Блочная область видимости – это удобно. Поэтому много лет назад let и const были введены в стандарт и сейчас являются основным способом объявления переменных.
Var java что это
Для хранения данных в программе предназначены переменные . Переменная представляет именованную область памяти, которая хранит значение определенного типа. Каждая переменная имеет тип, имя и значение. Тип определяет, какую информацию может хранить переменная или диапазон допустимых значений.
Переменные объявляются следующим образом:
тип_данных имя_переменной;
Например, определим переменную, которая будет называться x и будет иметь тип int :
int x;
В этом выражении мы объявляем переменную x типа int . То есть x будет хранить некоторое число не больше 4 байт.
В качестве имени переменной может выступать любое произвольное название, которое удовлетворяет следующим требованиям:

имя может содержать любые алфавитно-цифровые символы, а также знак подчеркивания, при этом первый символ в имени не должен быть цифрой
в имени не должно быть знаков пунктуации и пробелов
имя не может быть ключевым словом языка Java

Кроме того, при объявлении и последующем использовании надо учитывать, что Java - регистрозависимый язык, поэтому следующие объявления int num; и int NUM; будут представлять две разных переменных.
Объявив переменную, мы можем присвоить ей значение:
int x; // объявление переменной x = 10; // присвоение значения System.out.println(x); // 10
Также можно присвоить значение переменной при ее объявлении. Этот процесс называется инициализацией :
int x = 10; // объявление и инициализация переменной System.out.println(x); // 10
Если мы не присвоим переменной значение до ее использования, то мы можем получить ошибку, например, в следующем случае:
int x; System.out.println(x);
Через запятую можно объявить сразу несколько переменных одного типа:
int x, y; x = 10; y = 25; System.out.println(x); // 10 System.out.println(y); // 25
Также можно их сразу инициализировать:
int x = 8, y = 15; System.out.println(x); // 8 System.out.println(y); // 15
Отличительной особенностью переменных является то, что мы можем в процессе работы программы изменять их значение:
int x = 10; System.out.println(x); // 10 x = 25; System.out.println(x); // 25
Ключевое слово var
Начиная с Java 10 в язык было добавлено ключевое слово var , которое также позволяет определять переменную:
var x = 10; System.out.println(x); // 10
Слово var ставится вместо типа данных, а сам тип переменной выводится из того значения, которое ей присваивается. Например, переменной x присваивается число 10, значит, переменная будет представлять тип int.
Но если переменная объявляется с помощью var, то мы обязательно должны инициализировать ее, то есть предоставить ей начальное значение, иначе мы получим ошибку, как, например, в следующем случае:
var x; // ! Ошибка, переменная не инициализирована x = 10;
Константы
Кроме переменных, в Java для хранения данных можно использовать константы . В отличие от переменных константам можно присвоить значение только один раз. Константа объявляется также, как и переменная, только вначале идет ключевое слово final :
final int LIMIT = 5; System.out.println(LIMIT); // 5 // LIMIT=57; // так мы уже не можем написать, так как LIMIT - константа
Как правило, константы имеют имена в верхнем регистре.
Константы позволяют задать такие переменные, которые не должны больше изменяться. Например, если у нас есть переменная для хранения числа pi, то мы можем объявить ее константой, так как ее значение постоянно.
Java 10: ключевое слово «var»
В Java 10 введен вывод типа локальной переменной с ключевым словом var . Это означает, что вместо записи:
Map> map = new HashMap<>();

for (Entry> dept : map.entrySet())

List employees = dept.getValue();
Вы можете использовать var чтобы уменьшить шаблон, следующим образом:
var map = new HashMap();

for (var dept : map.entrySet()) <
var employees = dept.getValue();


var устраняет необходимость написания явных типов в вашем коде. Это не только уменьшает количество повторений, но также облегчает поддержку вашего кода, потому что, если, например, вы решите изменить типы объектов, хранящихся на вашей карте в будущем, вам потребуется изменить только одну строку кода.
Полиморфизм:
Теперь давайте посмотрим, как var ведет себя с полиморфным кодом. Например, если у вас есть класс Shape с двумя подклассами, Square и Circle , какой тип будет выведен, если вы используете var v = new Circle() ? Давайте попробуем это в JShell :
Лишает ли var строгой типизации?
Ключевое слово var появилось в Java 10. Указание var вместо типа локальной переменной применяет к ней механизм вывода типов (type inference). Тип будет вычислен на этапе компиляции из того, чем переменная инициализируется.
Отсюда несколько выводов. Во-первых, нельзя использовать var в полях класса, параметрах метода, и где-либо еще кроме локальных переменных. Во-вторых, обязана быть инициализация с понятным типом – варианты var x; или var x = null; не скомпилируются.
И главное следствие – к концу компиляции у таких переменных фиксированный и известный тип, который не может быть изменен позднее. А это и есть определение строгой типизации.
Ответ: нет, выводимый тип – строгий. Более того, типизация остается статической.
Главное упущение – в инициализации разрешено использовать diamond operator. В обычных обстоятельствах в нём выведется правильный generic-тип, но в случае var информации недостаточно, и типом-параметром будет Object .
Читать:
Переименовала файл как вернуть обратно

Устаревшее ключевое слово «var»

Для «var» не существует блочной области видимости

«var» допускает повторное объявление

«var» обрабатываются в начале запуска функции

IIFE

Итого

Var java что это

Ключевое слово var

Константы

Java 10: ключевое слово «var»

Полиморфизм:

Лишает ли var строгой типизации?

Похожие записи