Локальные переменные можно объявлять без указания конкретного типа. Ключевое слово var указывает, что компилятор должен вывести тип переменной из выражения справа от оператора инициализации. Выведенный тип может быть встроенным, анонимным, определяемым пользователем либо типом, определяемым в библиотеке классов .NET. Дополнительные сведения об инициализации массивов с var см. в разделе Неявно типизированные массивы.
В приведенных ниже примерах показаны различные способы объявления локальных переменных с помощью var :
// i is compiled as an int var i = 5; // s is compiled as a string var s = «Hello»; // a is compiled as int[] var a = new[] < 0, 1, 2 >; // expr is compiled as IEnumerable // or perhaps IQueryable var expr = from c in customers where c.City == «London» select c; // anon is compiled as an anonymous type var anon = new < Name = «Terry», Age = 34 >; // list is compiled as List var list = new List();
Важно понимать, что ключевое слово var не означает «variant» и не означает, что переменная является слабо типизированной или имеет позднее связывание. Он указывает только на то, что компилятор определяет и назначает наиболее подходящий тип.
Переменные в JAVASCRIPT. Константы. Ключевые слова LET CONST VAR. Уроки JAVASCRIPT с нуля 2020
Ключевое слово var можно использовать в следующих контекстах:
- С локальными переменными (переменными, объявленными в области метода), как показано в предыдущем примере.
- В операторе инициализации for.
for (var x = 1; x < 10; x++)
foreach (var item in list)
using (var file = new StreamReader(«C:\myfile.txt»))
Переменная var и анонимные типы
Во многих случаях переменная var не является обязательной и предназначена только для синтаксического удобства.
Тем не менее если переменная инициализируется с помощью анонимного типа и вам потребуется доступ к свойствам объекта на более позднем этапе, ее необходимо объявить как var . Это распространенный сценарий в выражениях запросов LINQ. Дополнительные сведения см. в статье Анонимные типы.
С точки зрения исходного кода анонимный тип безымянен. Таким образом, если переменная запроса инициализирована с помощью var , то единственный способ получить доступ к свойствам в возвращаемой последовательности объектов — это использовать var как тип переменной итерации в операторе foreach .
class ImplicitlyTypedLocals2 < static void Main() < string[] words = < «aPPLE», «BlUeBeRrY», «cHeRry» >; // If a query produces a sequence of anonymous types, // then use var in the foreach statement to access the properties. var upperLowerWords = from w in words select new < Upper = w.ToUpper(), Lower = w.ToLower() >; // Execute the query foreach (var ul in upperLowerWords) < Console.WriteLine(«Uppercase: , Lowercase: «, ul.Upper, ul.Lower); > > > /* Outputs: Uppercase: APPLE, Lowercase: apple Uppercase: BLUEBERRY, Lowercase: blueberry Uppercase: CHERRY, Lowercase: cherry */
Примечания
В объявлениям неявно типизированных переменных применяются следующие ограничения:
ЧТО ТАКОЕ VAR В ПРОГРАММИРОВАНИИ | КАК ИСПОЛЬЗОВАТЬ VAR В C# 😱
- var можно использовать только в том случае, если локальная переменная объявляется и инициализируется в одном и том же операторе; переменная не может инициализироваться в нулевое значение, в группу методов или в анонимную функцию.
- var нельзя применять к полям в области видимости класса.
- Переменные, объявленные с помощью var , нельзя использовать в выражении инициализации. Другими словами, это выражение является допустимым выражением: int i = (i = 20); , но вызывает ошибку времени компиляции: var i = (i = 20);
- Инициализировать сразу несколько неявно типизированных переменных в одном и том же операторе нельзя.
- Если тип с именем var входит в область видимости, то ключевое слово var разрешится в это имя типа и не будет обрабатываться как часть объявления неявно типизированной локальной переменной.
Неявное типизирование с ключевым словом var может применяться только к переменным в области локального метода. Неявное типизирование недоступно для полей класса C#, так как при обработке кода компилятор столкнется с логическим парадоксом: компилятор должен знать тип поля, но он не может определить тип, пока не проанализирует выражение присваивания, и не может вычислить выражение, не зная тип. Рассмотрим следующий код.
private var bookTitles;
bookTitles — это поле класса, которому присваивается тип var . Так как поле не имеет выражения для оценки, то компилятор не сможет вывести тип bookTitles . Кроме того, добавления выражения в поле (так же, как для локальной переменной) тоже недостаточно:
private var bookTitles = new List();
Когда компилятор обнаруживает поля во время компиляции кода, он записывает тип каждого поля перед обработкой любого выражения, связанного с ним. Компилятор обнаруживает тот же парадокс при попытке анализа bookTitles : он должен знать тип поля, но обычно он определяет тип var путем анализа выражения, который невозможно определить, если заранее не знать тип.
Переменную var можно также использовать в выражениях запросов, где точный сконструированный тип переменной запроса определить непросто. Подобная ситуация может возникнуть в операциях группировки и сортировки.
Кроме того, ключевое слово var может пригодиться, если конкретный тип переменной сложно набрать с клавиатуры, а также если он очевиден либо затрудняет чтение кода. Использовать var таким образом можно, например, с вложенными универсальными типами — подобные типы применяются в групповых операциях. В следующем запросе переменная запроса имеет тип IEnumerable> . Если вы и другие пользователи, которые работают с кодом, это понимаете, использовать неявный ввод для удобства и краткости кода можно без проблем.
// Same as previous example except we use the entire last name as a key. // Query variable is an IEnumerable> var studentQuery3 = from student in students group student by student.Last;
Ключевое слово var позволяет упростить код, однако его следует использовать только там, где оно действительно необходимо или где оно облегчает понимание кода. Дополнительные сведения о том, когда следует использовать ключевое слово var , см. в разделе Неявно типизированные локальные переменные в статье с рекомендациями по написанию кода C#.
См. также
- Справочник по C#
- Неявно типизированные массивы
- Практическое руководство. Использование неявно типизированных локальных переменных и массивов в выражении запроса
- Анонимные типы
- Инициализаторы объектов и коллекций
- var
- LINQ в C#
- Встроенный язык запросов LINQ
- Инструкции итерации
- Оператор using
Источник: learn.microsoft.com
FAQ по var в Java
Локальные переменные — это «рабочие лошадки» Java. Они используются для хранения промежуточных результатов вычислений. И, в отличие от полей, объявляются, инициализируются и используются в одном блоке. Для понимания кода часто более важны имя и инициализатор, чем тип локальной переменной. В имени и инициализаторе столько же информации, сколько и в типе:
Person person = new Person();
Вместо явного указания типа можно использовать var :
var person = new Person();
Компилятор определяет тип локальной переменной по инициализатору. Это особенно важно, когда тип параметризован wildcard , или упоминается в инициализаторе. Использование var может сделать код более кратким без ущерба для удобочитаемости, а в некоторых случаях может улучшить читаемость благодаря устранению избыточности.
Вопрос 2. Делает ли это Java динамически типизированным языком? Это то же самое, что и var в JavaScript?
Нет и нет. Java остается языком со статической типизацией, и появление var не изменяет этого. var используется в объявлении локальной переменной без явного указания типа. При использовании var компилятор Java определяет тип переменной во время компиляции, используя информацию о типе, полученную от инициализатора переменной. Далее выведенный тип используется как статический тип этой переменной. Как правило, будет тот же тип, который вы бы указали явно, поэтому переменная, объявленная с помощью var , ведет себя точно так же, как при явном указании типа.
В компиляторе Java выведение типов присутствует уже много лет. Например, параметры лямбда-выражения в Java 8 не нуждаются в явном указании типа, так как компилятор определяет их по тому, как используется лямбда-выражение:
List list = . list.stream().filter(p -> p.getAge() > 18) .
В приведенном выше фрагменте кода тип параметра p в лямбде выводится как Person . Если класс Person будет изменен так, что в нем больше не будет метода getAge , или в списке будет храниться что-то отличное от Person , то выведение типа завершится ошибкой при компиляции.
Вопрос 3. Переменная var неявно final?
Нет. Локальные переменные, объявленные с помощью var , по умолчанию не являются final . Однако к var можно добавить модификатор final :
final var person = new Person();
Для final var в Java нет никакого сокращения. Например, в Scala для объявления неизменяемых переменных используется val . В Scala это хорошо работает, потому что все переменные (и локальные, и поля) объявляются с помощью синтаксиса следующего вида.
val name : type
var name : type
Указывать » : type » в объявлении необязательно — это зависит от того, хотите ли вы использовать выведение типа или нет. В Scala выбор между изменяемостью и неизменяемостью ортогонален к выведению типов.
В Java var можно использовать только там, где требуется выведение типа. Его нельзя использовать, если тип объявлен явно. Если в Java добавить val , то его тоже можно было бы использовать только там, где используется выведение типов. В Java нельзя было бы использовать var или val для управления иммутабельностью при явном объявлении типа.
Кроме того, Java позволяет использовать var только для локальных переменных, но не для полей. Для полей иммутабельность более значима. Неизменяемые локальные переменные используются сравнительно редко.
Использование ключевых слов var/val для управления иммутабельностью — это то, что действительно стоит позаимствовать из Scala в Java. Однако в Java это было бы гораздо менее полезно, чем в Scala.
Вопрос 4. Не будут ли плохие разработчики злоупотреблять var, чтобы писать ужасный код?
Да, плохие разработчики будут писать ужасный код, что бы мы ни делали. Отказ от var не помешает им это сделать. Но при правильном применении выведение типов позволит писать более качественный код.
Один из моментов, благодаря которому var может побудить разработчиков писать более качественный код, заключается в том, что var снижает накладные расходы на объявление новой переменной. Разработчики часто избегают объявления новой переменной, если это требует больших затрат, и создают сложные конструкции, ухудшающие читаемость, только из-за того, чтобы избежать объявления дополнительных переменных. С var накладные расходы на извлечение части кода в именованную переменную уменьшаются, поэтому разработчики с большей вероятностью будут это делать, что приведет к более чистому коду.
Часто программисты начинают очень активно использовать новые возможности языка, возможно, злоупотребляя ими, и требуется некоторое время, чтобы сообщество выработало рекомендации по разумному использованию.
Начиная с выведения типа локальной переменной (Local Variable Type Inference, LVTI), мы публикуем материалы о назначении и рекомендации по использованию (например, данный FAQ и LVTI Style Guidelines) почти одновременно с появлением этой функциональности. Мы надеемся, что это ускорит понимание в сообществе, когда разумно использовать var , и поможет избежать злоупотребления.
Вопрос 5. Где можно использовать var?
var может использоваться при объявлении локальных переменных, включая индексные переменные цикла for и ресурсные переменные оператора try-with-resources .
var нельзя использовать для полей, параметров методов и возвращаемых типов методов. Причина заключается в том, что типы в этих местах явно присутствуют в class-файлах и в спецификациях Javadoc. При выведении типа изменение инициализатора может легко привести к изменению предполагаемого типа переменной. Для локальных переменных это не проблема, так как область видимости локальных переменных ограничена, и их типы напрямую не записываются в class-файлы. Однако для полей, параметров методов и типов, возвращаемых методом, выведение типа может легко вызвать проблему.
Например, возвращаемый тип метода был выведен из выражения в операторе return . Изменение реализации метода может привести к изменению типа выражения в return . Это, в свою очередь, может изменить тип возвращаемого значения. Что может привести к бинарной несовместимости или несовместимости в исходном коде. Такие несовместимые изменения не должны возникать из-за безобидных на вид изменений в реализации.
Предположим, что также будет выводиться тип поля. Тогда изменение инициализатора поля может привести к изменению типа поля, что может неожиданно нарушить рефлексивный код.
Выведение типа допустимо в реализации, но не в API. API-контракты должны быть объявлены явно.
Как насчет private-полей и методов, которые не являются частью API? Теоретически мы могли бы реализовать поддержку var для private-полей и возвращаемых типов для private-методов, не опасаясь, что это вызовет несовместимость из-за раздельной компиляции и динамической линковки. Но для простоты мы решили ограничить область выведения типов. Если расширить границы и включить отдельные виды полей и типы, возвращаемые некоторыми методами, то это сделает все значительно более сложным и трудным для понимания, и лишь незначительно более полезным.
Вопрос 6. Почему для var всегда нужен инициализатор в правой части?
Тип переменной вычисляется на основе инициализатора. Это означает, что var можно использовать только при наличии инициализатора. Можно было бы сделать выведение типа из присвоений переменной, но это значительно усложнило бы реализацию и потенциально могло привести к вводящим в заблуждение или трудно диагностируемым ошибкам. Для простоты мы определили var так, чтобы для выведения типа использовалась только локальная информация.
Допустим, мы разрешили выведение типа на основе присваивания в нескольких местах, отдельно от объявления переменной. Тогда рассмотрим следующий пример:
var order; . order = «first»; . order = 2;
Если тип был выбран на основе, например, первого присваивания, то это может привести к ошибке в другом операторе, весьма удаленном от местоположения настоящей ошибки. (Иногда это называют проблемой «дальнодействия».)
В качестве альтернативы можно выбрать тип, совместимый со всеми присваиваниями. И в этом случае можно ожидать, что выведенный тип будет Object , как общий суперкласс String и Integer . К сожалению, ситуация сложнее. Поскольку и String , и Integer являются Serializable и Comparable , общий супертип будет пересечением типов, что-то вроде
Serializable
Обратите внимание, что невозможно явно объявить переменную этого типа. Также это приводит к упаковыванию (boxing), когда order присваивается 2, что может быть неожиданным и нежелательным.
Чтобы избежать подобных проблем, проще потребовать вывод типа с использованием явного инициализатора.
Вопрос 7. Почему нельзя использовать var с null?
Посмотрите на такое объявление (оно некорректно):
var person = null; // ОШИБКА
Литерал null обозначает значение специального типа null (JLS 4.1), который является подтипом всех ссылочных типов в Java. Единственным значением типа null является сам null , поэтому единственное значение, которое может быть присвоено переменной типа null — это null . Это не очень полезно.
Можно ввести специальное правило, чтобы объявление var , инициализированное значением null , имело тип Object . Но возникает вопрос о намерениях программиста. Предположим, что переменная инициализируется значением null , чтобы позже ей присвоить какое-либо другое значение. Но в этом случае маловероятно, что определение типа переменной как Object будет правильным.
Вместо того чтобы создавать какие-то специальные правила для обработки этого случая, мы его запретили. Если вам нужна переменная типа Object , объявите ее явно.
Вопрос 8. Можно ли использовать var с diamond-оператором справа?
Да, это работает, но, скорее всего, не так, как вы ожидаете. Пример:
var list = new ArrayList<>();
Тип списка будет ArrayList . В общем, лучше указывать явный тип слева с diamond-оператором справа или использовать var слева с явным типом справа. См. особенности использования var с diamond-оператором и дженериками в LVTI Style Guidelines (Руководство по стилю LVTI).
Приглашаем всех желающих на открытое занятие «Реляционные базы данных для начинающих Java-разработчиков». Поговорим о месте реляционных баз данных в архитектуре информационных систем. Рассмотрим основные компоненты и возможности РСУБД на примере PostgreSQL. Сделаем обзор основных технологий по работе с реляционными БД в Java (JDBC, JPA/Hibernate, Spring Data и др.) Регистрация по ссылке.
- Блог компании OTUS
- Программирование
- Java
Источник: habr.com
Что в программе значит var
Что такое VAR в JavaScript?
Оператор var объявляет переменную. Переменные — это контейнеры для хранения информации. Создание переменной в JavaScript называется «объявлением» переменной: var carName; После объявления переменная пуста (не имеет значения).
Используется ли еще VAR в JavaScript?
Для вашего прямого вопроса var, вероятно, все еще используется по устаревшим причинам. Он поддерживается во всех версиях JavaScript, и было бы хлопотно менять каждый пример в Интернете. Единственным реальным преимуществом var является его совместимость.
Нужно ли вам говорить VAR в JavaScript?
Поскольку var объявляет переменную в текущей области видимости, нет никакой разницы между объявлением var внутри окна и отсутствием его объявления вообще. Разница появляется, когда вы не находитесь прямо внутри окна, например, внутри функции или внутри блока. Использование var позволяет скрыть внешние переменные с таким же именем.
Почему мы используем VAR в JS?
Ключевое слово var используется для объявления переменных в JavaScript.Прежде чем использовать переменную в программе JavaScript,ее необходимо объявить.Переменные объявляются с помощью ключевого слова var следующим образом.Хранение значения в переменной называется инициализацией переменной.
Когда следует использовать VAR?
Ключевое слово var позволяет нам объявить локальную переменную без информации о типе,поддерживаемую силой вывода типов компилятора Java.
Почему VAR устарел?
Еще одно устаревание, но опять же по уважительной причине: параметры var устарели, потому что они предлагают лишь незначительную полезность, и их часто путают с inout . Различия есть в первых двух строках: name теперь var name , и name преобразуется в верхний регистр, так что «TAYLOR» печатается пять раз.
Почему var избегается в JavaScript?
Ключевое слово Var Это означает,что если переменная определена в цикле или в операторе if,она может быть доступна вне блока и случайно переопределена,что приведет к ошибке в программе.Как правило,следует избегать использования ключевого слова var.
var объявляет функцию в области видимости или глобально-Scoped переменный, с возможностью его инициализации до значения.
Try it
Syntax
var varname1 [= value1] [, varname2 [= value2] . [, varnameN [= valueN]]];
Переменное имя.Это может быть любой юридический идентификатор.
Начальное значение переменной. Это может быть любое юридическое выражение. Значение по умолчанию не undefined .
Кроме того, для объявления переменных можно использовать синтаксис назначения деструктурирования .
var < bar >= foo; // где foo = ; / * Это создает переменную с именем ‘bar’, которая имеет значение 10 * /
Description
var , где бы они ни встречались, обрабатываются до выполнения любого кода. Это называется подъемом и обсуждается ниже.
Область видимости переменной, объявленной с помощью var , — это ее текущий контекст выполнения и его закрытия , который является либо включающей функцией и функциями, объявленными в ней, либо, для переменных, объявленных вне любой функции, глобальными. Повторяющиеся объявления переменных с использованием var не вызовут ошибки даже в строгом режиме, и переменная не потеряет свое значение, если не будет выполнено другое присвоение.
‘use strict’; function foo( ) < var x = 1; function bar( ) < var y = 2; console.log(x); // 1 (функция `bar` закрывается через` x`) console.log(y); // 2 (`y` находится в области видимости) > bar(); console.
log(x); // 1 (`x` находится в области видимости) console.log(y); // ReferenceError в строгом режиме, у `y` есть область видимости` bar` > foo();
Переменные, объявленные с помощью var , создаются до выполнения любого кода в процессе, известном как подъем. Их начальное значение не undefined .
‘use strict’; console.log(x); // не определено (примечание: не ReferenceError) console.log(‘still going. ‘); // продолжается. var x = 1; console.log(x); // 1 console.log(‘still going. ‘); // продолжается.
В глобальном контексте переменная, объявленная с помощью var , добавляется как ненастраиваемое свойство глобального объекта. Это означает, что его дескриптор свойства не может быть изменен и его нельзя удалить с помощью delete . Соответствующее имя также добавляется в список во внутреннем слоте [[VarNames]] записи глобальной среды (которая является частью глобальной лексической среды). Список имен в [[VarNames]] позволяет среде выполнения различать глобальные переменные и простые свойства глобального объекта.
Свойство, созданное в глобальном объекте для глобальных переменных, не настраивается, поскольку идентификатор должен рассматриваться как переменная, а не как простое свойство глобального объекта. В JavaScript есть автоматическое управление памятью, и было бы бессмысленно использовать оператор delete для глобальной переменной.
‘use strict’; var x = 1; Object.hasOwn(globalThis, ‘x’); // true delete globalThis.x; // Ошибка типа в строгом режиме. В противном случае молча терпит неудачу. delete x; // SyntaxError в строгом режиме. В противном случае молча терпит неудачу.
Обратите внимание, что как в модулях NodeJS CommonJS , так и в собственных модулях ECMAScript объявления переменных верхнего уровня относятся к модулю и, следовательно, не добавляются в качестве свойств к глобальному объекту.
Назначение неквалифицированных идентификаторов
Глобальный объект находится в верхней части цепочки областей видимости. При попытке разрешить имя в значение ищется цепочка областей видимости. Это означает, что свойства глобального объекта удобно видны из любой области, без необходимости globalThis. имена с помощью globalThis. или window. или global. .
Поскольку глобальный объект имеет свойство String ( Object.hasOwn(globalThis, ‘String’) ), вы можете использовать следующий код:
function foo( ) < String(‘s’) // Обратите внимание, что функция `String` неявно видна >
Таким образом, в конечном итоге глобальный объект будет искать неквалифицированные идентификаторы. Вам не нужно вводить globalThis.String , вы можете просто ввести неквалифицированную String . Следствием этого в нестрогом режиме является то, что при присвоении неквалифицированным идентификаторам, если в цепочке областей видимости не объявлена переменная с таким же именем, предполагается, что вы хотите создать свойство с этим именем в глобальном объекте.
foo = ‘f’ // В нестрогом режиме предполагается, что вы хотите создать свойство с именем `foo` для глобального объекта Object.hasOwn(globalThis, ‘foo’) // true
В строгом режиме присвоение неполного идентификатора в строгом режиме приведет к ошибке ReferenceError , чтобы избежать случайного создания свойств глобального объекта.
Обратите внимание,что из вышесказанного следует,что,вопреки распространенной дезинформации,в JavaScript нет неявных или необъявленных переменных,у него просто есть синтаксис,который выглядит так,как будто это так.
var hoisting
Поскольку объявления var обрабатываются до выполнения любого кода, объявление переменной в любом месте кода эквивалентно объявлению ее в начале. Это также означает, что переменная может казаться используемой до ее объявления. Такое поведение называется « подъемом », так как кажется, что объявление переменной перемещается в начало функции или глобального кода.
bla = 2; var bla;
Это неявно понимается как:
var bla; bla = 2;
Поэтому рекомендуется всегда объявлять переменные в верхней части их области видимости (вершина глобального кода и вершина кода функции),чтобы было понятно,какие переменные являются функцией scoped (локальными),а какие разрешаются в цепочке областей видимости.
Важно отметить, что поднимается только объявление переменной, а не ее инициализация. Инициализация происходит только при достижении оператора присваивания. До тех пор переменная остается undefined (но объявленной):
function do_something( ) < console.log(bar); // undefined var bar = 111; console.log(bar); // 111 >
Это неявно понимается как:
function do_something( ) < var bar; console.log(bar); // undefined bar = 111; console.log(bar); // 111 >
Источник: runebook.dev