JavaScript 'hoisting'

Я столкнулся с "подъемом" JavaScript, и я не понял, как этот фрагмент кода действительно функционирует:

var a = 1;

function b() {
    a = 10;
    return;

    function a() {}
}

b();
alert(a);

Я знаю, что объявление функции, подобное (function a() {}), будет поднято в верхней части области b, но не должно переопределять значение a (поскольку объявления функций переопределяют объявления переменных, но не переменные инициализация), поэтому я ожидал, что значение предупреждения будет 10 вместо 1!

Ответ 1

Глобальный a установлен на 1
b() называется
function a() {} создается и создает локальную переменную a, которая маскирует глобальный a
Локальный a установлен на 10 (перезаписывает функцию a)
Предупреждается глобальный a (еще 1)

Ответ 2

Это потому, что порядок компиляции/интерпретации в этом примере несколько вводит в заблуждение. Строка function a () {} интерпретируется до того, как выполняется любая из остальных функций, поэтому в самом начале функции a имеет значение function a () {}. Когда вы переназначаете его на 10, вы переназначаете значение a в локальной области функции b(), которое затем отбрасывается после возврата, оставляя исходное значение a = 1 в глобальной области.

Вы можете проверить это, поместив alert() или тому подобное в соответствующие места, чтобы увидеть, что значение a находится в разных точках.

Ответ 3

(1) JavaScript не имеет видимости блока блока; скорее, он будет локальным для кода, в котором находится блок.

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

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

код такой же, как: (читать комментарий)

<script>
var a = 1;          //global a = 1
function b() {
    a = 10;         
    var a = 20;     //local a = 20
}
b();
alert(a);           //global a  = 1
</script>

ссылка:
(1) Область видимости JavaScript:
(2) Опасный пример подъема Javascript
(3) Переменная область

Итак, в вашем коде:

var a = 1;          //global a = 1  
function b() {
    a = 10;         
    return;
    function a() {} //local 
}
b();
alert(a);           //global a = 1

Ответ 4

объявляется функция function a(){}, поэтому в локальной области a создается.
Если у вас есть две переменные с одинаковым именем (одно в глобальном другом в локальном), локальная переменная всегда получает приоритет над глобальной переменной.
Когда вы устанавливаете a=10, вы устанавливаете локальную переменную a, а не глобальную.

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

Ответ 5

Когда я прочитал ту же статью, вы сделали JavaScript Scoping and Hoisting, я тоже был смущен, потому что автор никогда не показывал, что два примера открытия коды интерпретируются как в компиляторе.

Вот пример, который вы предоставили, а второй на странице:

var a = 1;
function b() {
    function a() {} // declares 'a' as a function, which is always local
    a = 10;
    return;
}
b();
alert(a);

и вот первый пример на странице:

var foo = 1;
function bar() {
    var foo; // a new local 'foo' variable
    if (!foo) {
        foo = 10;
    }
    alert(foo);
}
bar();

Надеюсь, что это поможет