Что выведет следующий код var 10 print var
Перейти к содержимому

Что выведет следующий код var 10 print var

  • автор:

Переменные: let и const

Материал на этой странице устарел, поэтому скрыт из оглавления сайта.

В ES-2015 предусмотрены новые способы объявления переменных: через let и const вместо var .

let a = 5;

let

У объявлений переменной через let есть три основных отличия от var :

    Область видимости переменной let – блок <. >. Как мы помним, переменная, объявленная через var , видна везде в функции. Переменная, объявленная через let , видна только в рамках блока <. >, в котором объявлена. Это, в частности, влияет на объявления внутри if , while или for . Например, переменная через var :

var apples = 5; if (true) < var apples = 10; alert(apples); // 10 (внутри блока) >alert(apples); // 10 (снаружи блока то же самое)

В примере выше apples – одна переменная на весь код, которая модифицируется в if . То же самое с let будет работать по-другому:

let apples = 5; // (*) if (true) < let apples = 10; alert(apples); // 10 (внутри блока) >alert(apples); // 5 (снаружи блока значение не изменилось)

Здесь, фактически, две независимые переменные apples , одна – глобальная, вторая – в блоке if . Заметим, что если объявление let apples в первой строке (*) удалить, то в последнем alert будет ошибка: переменная не определена:

if (true) < let apples = 10; alert(apples); // 10 (внутри блока) >alert(apples); // ошибка!
alert(a); // undefined var a = 5;

С переменными let всё проще. До объявления их вообще нет. Такой доступ приведёт к ошибке:

alert(a); // ошибка, нет такой переменной let a = 5;

Заметим также, что переменные let нельзя повторно объявлять. То есть, такой код выведет ошибку:

let x; let x; // ошибка: переменная x уже объявлена

Это – хоть и выглядит ограничением по сравнению с var , но на самом деле проблем не создаёт. Например, два таких цикла совсем не конфликтуют:

// каждый цикл имеет свою переменную i for(let i = 0; i for(let i = 0; i alert( i ); // ошибка: глобальной i нет
for(var i=0; i alert(i); // 10

С переменной let – всё по-другому. Каждому повторению цикла соответствует своя независимая переменная let . Если внутри цикла есть вложенные объявления функций, то в замыкании каждой будет та переменная, которая была при соответствующей итерации. Это позволяет легко решить классическую проблему с замыканиями, описанную в задаче Армия функций.

function makeArmy() < let shooters = []; for (let i = 0; i < 10; i++) < shooters.push(function() < alert( i ); // выводит свой номер >); > return shooters; > var army = makeArmy(); army[0](); // 0 army[5](); // 5

const

Объявление const задаёт константу, то есть переменную, которую нельзя менять:

const apple = 5; apple = 10; // ошибка

В остальном объявление const полностью аналогично let .

Заметим, что если в константу присвоен объект, то от изменения защищена сама константа, но не свойства внутри неё:

const user = < name: "Вася" >; user.name = "Петя"; // допустимо user = 5; // нельзя, будет ошибка

То же самое верно, если константе присвоен массив или другое объектное значение.

константы и КОНСТАНТЫ

Константы, которые жёстко заданы всегда, во время всей программы, обычно пишутся в верхнем регистре. Например: const ORANGE = «#ffa500» .

Большинство переменных – константы в другом смысле: они не меняются после присвоения. Но при разных запусках функции это значение может быть разным. Для таких переменных можно использовать const и обычные строчные буквы в имени.

Итого

  • Видны только после объявления и только в текущем блоке.
  • Нельзя переобъявлять (в том же блоке).
  • При объявлении переменной в цикле for(let …) – она видна только в этом цикле. Причём каждой итерации соответствует своя переменная let .

Переменная const – это константа, в остальном – как let .

Область видимости в JavaScript и «поднятие» переменных и объявлений функций

В этом случае браузер выведет «1». Так что, собственно, происходит? Хотя такое поведение кажется странным, опасным и сбивающим с толку, на самом деле это очень мощное и выразительное средство JavaScript. Я не знаю, есть ли официальное название для такого поведения, но мне нравится использовать термин «поднятие»(«hoisting»). В этой статье я попытаюсь пролить свет на этот механизм языка, но сначала давайте поговорим об области видимости в JavaScript.

Область видимости в JavaScript

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

#include int main() < int x = 1; printf("%d, ", x); // 1 if (1) < int x = 2; printf("%d, ", x); // 2 >printf("%d\n", x); // 1 > 

Эта программа выведет 1, 2, 1, потому что Си и все остальные Си-подобные языки реализуют области видимости на уровне блоков кода. Когда исполняется новый блок кода, например условие if, новые переменные, объявленные в нём, не повлияют на переменные внешней области видимости.
Но не в случае JavaScript. Попробуйте запустить вот этот код в Firebug:

var x = 1; console.log(x); // 1 if (true) < var x = 2; console.log(x); // 2 >console.log(x); // 2 

На этот раз будут выведены числа 1, 2, 2. Это связано с тем, что в JavaScript используется область видимости на уровне функций. Это совсем не то, что мы привыкли видеть в языках программирования, вроде Си. Блоки кода, вроде того, который у нас идёт сразу после if, не создают новую область видимости. Только функции создают новые области видимости.
Для многих программистов, привыкших к Си, C++, C# или Java такое поведение очень неожиданное и неприятное. К счастью, благодаря гибкости функций JavaScript, можно обойти эту проблему. Чтобы создать временную область видимости внутри функции, достаточно сделать следующее:

function foo() < var x = 1; if (x) < (function () < var x = 2; // какой-то код >()); > // x всё ещё 1. > 

Такой подход достаточно гибок и может быть использован везде, где вам нужна временная область видимости, не только внутри блоков кода. Но я настаиваю на том, чтобы вы всё-таки потратили своё время, чтобы понять реализацию области видимости в JavaScript. Это довольно мощная особенность языка, которая мне очень нравится. Если вы понимаете область видимости, вам проще будет разобраться в «поднятии» переменных и объявлений функций.

Объявления, именование и «поднятие» переменных и функций
  1. Внутренние механизмы языка: например, во всех областях видимости доступны this и arguments.
  2. Формальные параметры: у функций могут быть именованные формальные параметры, область видимости которых ограничена телом функции.
  3. Объявления функций: объявленные в виде function foo() <>.
  4. Объявления переменных: например, var foo;.
function foo()

на самом деле интерпретируется так:

function foo()

Оказывается, не важно, будет ли вообще выполнена строка, в которой происходит объявление. Следующие две функции эквивалентны:

function foo() < if (false) < var x = 1; >return; var y = 1; > function foo() < var x, y; if (false) < x = 1; >return; y = 1; > 

Обратите внимание, что присваивание значений переменным не поднимается вместе с их объявлением. Поднимаются только объявления переменных. В случае с функциями, поднимается вся функция целиком. Существуют два основных способа объявить функцию, давайте их рассмотрим:

function test() < foo(); // TypeError "foo is not a function" bar(); // "this will run!" var foo = function () < // функциональное выражение, присвоенное локальной переменной 'foo' alert("this won't run!"); >function bar() < // объявление функции с именем 'bar' alert("this will run!"); >> test(); 

в этом случае поднимается только функция bar. Идентификатор «foo» также поднимается, но не анонимная функция — она остаётся на месте.

Вот мы и описали основные моменты «поднятия» переменных и функций. Конечно, JavaScript не был бы сам собой, если бы не было особых случаев, в которых всё немного сложнее.

Разрешение имён
  • Встроенный идентификатор arguments ведёт себя странно. Он как будто объявляется сразу после формальных аргументов функции и перед объявлениями функций. Это означает, что если у функции есть формальный аргумент arguments, у него будет приоритет над встроенным, даже если его не передадут при вызове функции. Это плохая особенность JavaScript. Не используйте формальный аргумент с именем arguments.
  • Если вы попробуете использовать this в качестве идентификатора, произойдёт ошибка SyntaxError. Это хорошая особенность.
  • Если в списке формальных параметров функции несколько из них имеют одинаковое имя, тот параметр, который упоминается последним, имеет приоритет. Даже если его не передали при вызове функции.
Именованные функциональные выражения

Вы можете давать имена функциям, определённым с помощью функциональных выражений, используя синтаксис определения функций. Это не приводит к объявлению функции, а следовательно, имя функции ни добавляется в область видимости, ни поднимается вместе с телом функции в начало области видимости. Вот несколько строк, чтобы проиллюстрировать, что я имею в виду:

foo(); // TypeError "foo is not a function" bar(); // работает baz(); // TypeError "baz is not a function" spam(); // ReferenceError "spam is not defined" var foo = function () <>; // анонимное функциональное выражени (поднимается 'foo') function bar() <>; // объявление функции (поднимаются 'bar' и тело функции) var baz = function spam() <>; // именованное функциональное выражение (поднимается только 'baz') foo(); // работает bar(); // работает baz(); // работает spam(); // ReferenceError "spam is not defined" 
Как писать код, обладая такими знаниями

Итак, теперь вы понимаете область видимости и «поднятие» переменных и объявлений функций. Что это означает применительно к написанию кода на JavaScript? Самое главное — всегда объявлять ваши переменные, используя var. Я настаиваю на том, чтобы у вас был ровно один var на область видимости и чтобы он располагался в её начале. Если вы заставите себя так делать, у вас никогда не будет проблем, связанных с «поднятием». Тем не менее, это может привести к тому, что сложно следить за переменными, которые объявлены в текущей области видимости. Я рекомендую использовать JSLint с включённой опцией onevar, чтобы вынудить вас так делать. Если вы будете так всё делать, ваш код будет выглядеть примерно так:

/*jslint onevar: true [. ] */ function foo(a, b, c)
Что говорит стандарт

Достаточно полезно обращаться к стандарту ECMAScript напрямую, чтобы понять, как всё работает. Вот что в нём говорится про объявление переменных и область видимости(секция 12.2.2):

Если инструкция переменной встречается внутри ОбъявленияФункции, переменные объявляются внутри локальной области видимости для данной функции согласно описанию в разделе 10.1.3. В противном случае они объявляются в глобальной области видимости (т.е. создаются как поля глобального объекта согласно описанию в разделе 10.1.3) с использованием атрибутов свойств < DontDelete >. Переменные создаются, когда происходит вход в область выполнения. Блок не определяет новой области выполнения. Только Программа и ОбъявлениеФункции создают новую область видимости. Переменные инициализируются при создании значением undefined. Переменной, для которой определён Инициализатор, присваивается значение его ВыраженияПрисваивания в момент выполнения ИнструкцииПеременной, а не в момент создания переменной.

Я надеюсь, эта статья пролила немного света на особенность JavaScript, которая так часто многих приводит в замешательство. Я старался быть как можно более последовательным, чтобы не запутать вас ещё сильнее. Если я в чём-то ошибся или что-то пропустил, пожалуйста, дайте мне знать.

Python 3 — Функции

Утечка утверждает, что графические процессоры AMD RDNA 4 работают на частоте 3,3 ГГц, но мы все это слышали раньше

Favorite

Добавить в избранное

(2 оценок, среднее: 5,00 из 5)

Python 3 - Функции

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

Как вы уже знаете, Python предоставляет множество встроенных функций, таких как print() и т.д., но вы также можете создавать свои собственные функции. Эти функции называются определяемые пользователем функции.

Определение функции

Вы можете определить функции, чтобы обеспечить требуемую функциональность. Вот простые правила, чтобы определить функцию в Python.

  • Функциональные блоки начинаются с ключевым словом def следует имя функции и скобки (()).
  • Любые входные параметры или аргументы должны быть размещены в этих скобках. Вы также можете определить параметры внутри этих скобок.
  • Первый оператор функции может быть необязательным заявление — строкой документации функции или строкой документации.
  • Блочный код в пределах каждой функции начинается двоеточием (:) и с отступом.
  • Утверждение return [выражение] делает выход из функции, необязательно передавая обратно выражение для вызывающего. Ответное заявление без аргументов такого же, как возвратное none.

Синтаксис

def functionname( parameters ): "function_docstring" function_suite return [expression]

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

Пример

Следующая функция принимает строку в качестве входного параметра и выводит его на стандартный экран.

def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return

Вызов функции

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

После того, как основная структура функции завершена, вы можете выполнить его, вызвав его из другой функции или непосредственно из командной строки Python. Ниже приведен пример для вызова функции PrintMe():

#!/usr/bin/python3 # FЗдесь вызов функции def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return # Теперь вы можете вызвать функцию printme printme("Это первый вызов определяемой пользователем функции!") printme("Опять второй вызов той же функции")

Когда этот код выполниться, он выведет следующий результат:

Это первый вызов определяемой пользователем функции! Опять второй вызов той же функции

Передавать по ссылке против значения

Все параметры (аргументы) в языке Python передаются по ссылке. Это означает, что если вы измените то, к чему относится параметр в пределах функции, изменение также отражается в вызывающей функции. Например:

#!/usr/bin/python3 # Здесь определение функции def changeme( mylist ): "Это изменяет переданный список в эту функцию" print ("Значения внутри функции перед изменением: ", mylist) mylist[2]=31 print ("Значение внутри функции после изменения: ", mylist) return # Теперь можно вызвать функцию changeme mylist = [10,20,30] changeme( mylist ) print ("Значения вне функции: ", mylist)

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

Значения внутри функции перед изменением: [10, 20, 30] Значение внутри функции после изменения: [10, 20, 31] Значения вне функции: [10, 20, 31]

Существует еще один пример, в котором аргумент передается по ссылке, а ссылка перезаписи внутри вызываемой функции.

#!/usr/bin/python3 # Здесь определение функции def changeme( mylist ): "Это изменяет список в этой функции" mylist = [1,2,3,4] # This would new reference in mylist print ("Значения внутри функции: ", mylist) return # Теперь можно вызвать функцию changeme mylist = [10,20,30] changeme( mylist ) print ("Значения вне функции: ", mylist)

Параметр MyList является локальным по отношению к функции ChangeMe. Изменение MyList внутри функции не влияет на MyList. Функция ничего не выполняет, и, наконец, это произведет следующий результат:

Значения внутри функции: [1, 2, 3, 4] Значения вне функции: [10, 20, 30]

Аргументы функции

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

  • Необходимые аргументы
  • Ключевые аргументы
  • Аргументы по умолчанию
  • Аргументы переменной длины

Обязательные аргументы

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

Для вызова функции PrintMe(), вам обязательно нужно передать один аргумент, в противном случае она выдаст синтаксическую ошибку следующим образом:

#!/usr/bin/python3 # Здесь определение функции def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return # Теперь вы можете вызвать функцию printme printme()

Когда этот код выполниться, он выведет следующий результат:

Traceback (most recent call last): File "test.py", line 11, in printme(); TypeError: printme() takes exactly 1 argument (0 given)

Ключевое слово аргумент

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

Это позволяет пропускать аргументы или размещать их не по порядку, поскольку интерпретатор Python может использовать предоставленные ключевые слова для сопоставления значений с параметрами. Вы также можете сделать ключевые слова для функции printme () следующими способами:

#!/usr/bin/python3 # Здесь определение функции def printme( str ): "Это печатает переданную строку в эту функцию" print (str) return # Теперь вы можете вызвать функцию printme printme( str = "Моя строка")

Когда этот код выполниться, он выведет следующий результат:

Моя строка

Следующий пример дает более четкую картину. Обратите внимание, что порядок параметров не имеет значения.

#!/usr/bin/python3 # Здесь определение функции def printinfo( name, age ): "Это печатает переданную информацию в эту функцию" print ("Имя: ", name) print ("Возраст ", age) return # Теперь можно вызвать функцию printinfo printinfo( age = 31, name = "AndreyEx" )

Когда этот код выполниться, он выведет следующий результат:

Имя: AndreyEx Возраст 31

Аргументы по умолчанию

Аргументы по умолчанию является аргументами, которые принимают значение по умолчанию, если значение не предусмотрено в вызове функции для этого аргумента. Следующий пример дает представление о аргументах по умолчанию, он печатает по умолчанию возраст, если он не прошел:

#!/usr/bin/python3 # Здесь определение функции def printinfo( name, age = 35 ): "Это печатает переданную информацию в эту функцию" print ("Name: ", name) print ("Age ", age) return # Теперь можно вызвать функцию printinfo printinfo( age = 31, name = "AndreyEx" ) printinfo( name = "AndreyEx" )

Когда этот код выполниться, он выведет следующий результат:

Имя: AndreyEx Возраст 31 Имя: AndreyEx Возраст 35

Аргументы переменной длины

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

Синтаксис для функции с не-ключевыми словами переменными аргументами приводятся ниже:

def functionname([formal_args,] *var_args_tuple ): "function_docstring" function_suite return [expression]

Звездочкой (*) ставится перед именем переменной, которая содержит значения всех nonkeyword переменных аргументов. Этот кортеж остается пустым, если никакие дополнительные аргументы не указаны при вызове функции. Ниже приведен простой пример:

#!/usr/bin/python3 # Здесь определение функции def printinfo( arg1, *vartuple ): "Эта печать переменные аргументы" print ("Вывод: ") print (arg1) for var in vartuple: print (var) return # Теперь можно вызвать функцию printinfo printinfo( 10 ) printinfo( 70, 60, 31 )

Когда этот код выполниться, он выведет следующий результат:

Вывод: 10 Вывод: 70 60 31

Анонимная функция

Эти функции называются анонимными, потому что они не объявлены стандартным способом, используя ключевого слова def. Вы можете использовать ключевое слово lambda, чтобы создать небольшие анонимные функции.

  • Форма Lambda может принимать любое количество аргументов, но возвращать только одно значение в виде выражения. Они не могут содержать команды или несколько выражений.
  • Анонимная функция не может быть прямым вызовом для печати, потому что Lambda требует выражений.
  • Лямбда-функция имеет свои собственные локальное пространство имен и не может получить доступ к другим, чем в их списке параметров, и те, в глобальном пространстве имен переменных.
  • Хотя кажется, что Lambda являются разновидностью одной строки функции, они не эквивалентны встроенными операторов в C или C ++, чья цель состоит в том, чтобы стек распределялся путем передачи функции во время вызова по соображениям производительности.

Синтаксис

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

lambda [arg1 [,arg2. argn]]:expression

Ниже приведен пример, чтобы показать, как работает форма функции Lambda:

#!/usr/bin/python3 # Здесь определение функции sum = lambda arg1, arg2: arg1 + arg2 # Теперь вы можете вызвать sum как функцию print ("Общая стоимость : ", sum( 10, 20 )) print ("Общая стоимость : ", sum( 20, 20 ))

Когда этот код выполниться, он выведет следующий результат:

Общая стоимость : 30 VОбщая стоимость : 40

Заявление return

Заявление return [выражение] выводит из функции, необязательно передавая обратно выражение для вызывающего. Ответное заявление без аргументов такое же, как возвратный none.

Все примеры, приведенные ниже, не возвращает значение. Вы можете вернуть значение из функции следующим образом:

#!/usr/bin/python3 # Здесь определение функции def sum( arg1, arg2 ): # Добавьте оба параметра и верните их." total = arg1 + arg2 print ("Внутри функции : ", total) return total # Теперь можно вызвать функцию sum total = sum( 10, 20 ) print ("Вне функции : ", total )

Когда этот код выполниться, он выведет следующий результат:

Внутри функции : 30 Вне функции : 30

Область действия переменных

Все переменные в программе не могут быть доступны во всех местах, в этой программе. Это зависит от того, где вы объявили переменную.

Область видимости переменной определяет часть программы, где вы можете получить доступ к конкретному идентификатору. Есть две основные области видимости переменных в Python:

  • Глобальные переменные
  • Локальные переменные

Глобальные переменные против локальных переменных

Переменные, определенные внутри тела функции имеют локальную область видимости, а также те, которые определены вне имеют глобальный масштаб.

Это означает, что локальные переменные могут быть доступны только внутри функции, в которой они объявлены, в то время как глобальные переменные могут быть доступны по всему телу программы всеми функциями. При вызове функции, переменные, объявленные внутри него вводятся в сферу. Ниже приведен простой пример —

#!/usr/bin/python3 total = 0 # Это глобальная переменная. # Здесь определение функции def sum( arg1, arg2 ): # Add both the parameters and return them." total = arg1 + arg2; # Здесь локальная переменная как глобальная. print ("Итого локально внутри функции : ", total) return total # Теперь можно вызвать функцию sum sum( 10, 20 ) print ("Итого глобально вне функции : ", total )

Когда этот код выполниться, он выведет следующий результат:

Итого локально внутри функции : 30 Итого глобально вне функции : 0

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Что выведет следующий код var 10 print var

Оператор var объявляет переменную, инициализируя её, при необходимости.

Интерактивный пример

Синтаксис

var varname1 [= value1 [, varname2 [, varname3 . [, varnameN]]]];

Имя переменной. Может использоваться любой допустимый идентификатор.

Значение переменной. Любое допустимое выражение. По умолчанию значение undefined.

Описание

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

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

1. Объявленные переменные ограничены контекстом выполнения, в котором они были объявлены. Необъявленные переменные всегда глобальны.

function x()  y = 1; // возбудит ReferenceError в "строгом режиме" var z = 2; > x(); console.log(y); // выведет "1" console.log(z); // возбудит ReferenceError: z не определён вне x 

2. Объявленные переменные инициализируются до выполнения любого кода. Необъявленные переменные не существуют до тех пор, пока к ним не выполнено присваивание.

.log(a); // Возбудит ReferenceError. console.log("still going. "); // Не выполнится. 
var a; console.log(a); // Выведет "undefined" или "", в зависимости от браузера. console.log("still going. "); // Выведет "still going. ". 

3. Объявленные переменные, независимо от контекста выполнения, являются ненастраиваемыми свойствами. Необъявленные переменные это настраиваемые свойства (т.е. их можно удалять).

var a = 1; b = 2; delete this.a; // Возбудит TypeError в "строгом режиме". В "нестрогом режиме" будет ошибка без уведомления. delete this.b; console.log(a, b); // Возбудит ReferenceError. // Свойство 'b' было удалено и больше не существует. 

Из-за перечисленных различий, использование необъявленных переменных может привести к непредсказуемым последствиям. Рекомендовано всегда объявлять переменные, вне зависимости, находятся они внутри функции или в глобальном контексте. Присваивание значения необъявленной переменной в строгом режиме (en-US) ECMAScript 5 возбуждает ошибку.

Поднятие переменных

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

= 2; var bla; // . // читается как: var bla; bla = 2; 

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

Важно отметить, что подъем будет влиять на объявление переменной, но не на инициализацию её значения. Значение присваивается при выполнении оператора присваивания:

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 > 

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *