В чем разница между созданием scope переменных в JavaScript и Python?

Разница между созданием Scope переменных в JavaScript и Python

Одна из критических различий между JavaScript и Python заключается в том, как они управляют scope переменных. Эти различия могут привести к неожиданному поведению, если разработчик не осведомлен об особенностях языка.

Scope в JavaScript

JavaScript имеет lexical scope и различает три уровня области видимости:

1. Global Scope

var globalVar = 'global';

function test() {
  console.log(globalVar); // 'global'
}

test();

2. Function Scope

function outer() {
  var x = 1;  // Function scope
  
  function inner() {
    console.log(x);  // 1 (может обращаться)
  }
  
  inner();
}

console.log(x); // ReferenceError: x is not defined

3. Block Scope (let, const)

if (true) {
  var varVariable = 1;
  let letVariable = 2;
  const constVariable = 3;
}

console.log(varVariable);      // 1 (function scope)
console.log(letVariable);      // ReferenceError
console.log(constVariable);    // ReferenceError

// var "просачивается" через блоки, let/const нет

Ключевая особенность JavaScript - var hoisting:

console.log(x); // undefined (не ReferenceError!)
var x = 5;

// Интерпретируется как:
var x;          // hoisting
console.log(x); // undefined
x = 5;

Правильный способ (ES6+):

if (true) {
  let x = 1;    // Block scope
  const y = 2;  // Block scope
}

console.log(x); // ReferenceError
console.log(y); // ReferenceError

Scope в Python

Python использует другой подход — переменные определяются в function scope или global scope. Block scope НЕ существует.

1. Global Scope

x = 1  # global

def func():
    print(x)  # 1 (может читать global)

func()

2. Function Scope (Local)

def func():
    x = 1  # local scope
    print(x)  # 1

func()
print(x)  # NameError: name 'x' is not defined

3. НЕТ Block Scope (ключевое отличие!)

if True:
    x = 1  # Это переменная в текущей функции или global, не в блоке

print(x)  # 1 (переменная видна!)

for i in range(5):
    y = i

print(y)  # 4 (последнее значение из цикла)
print(i)  # 4 (переменная цикла существует после цикла)

Использование global и nonlocal:

x = 10  # global

def func():
    global x  # Явно говорим, что используем глобальную переменную
    x = 20    # Изменяем глобальную переменную
    
func()
print(x)  # 20

# Вложенные функции
def outer():
    x = 1
    
    def inner():
        nonlocal x  # Доступ к переменной из outer
        x = 2
    
    inner()
    print(x)  # 2

outer()

Сравнительная таблица

Практические примеры различий

Пример 1: Block Scope

JavaScript:

for (var i = 0; i < 5; i++) {
  // i в function scope, не block scope
}
console.log(i); // 5

for (let j = 0; j < 5; j++) {
  // j в block scope
}
console.log(j); // ReferenceError

Python:

for i in range(5):
    pass
print(i)  # 4 (переменная существует в текущем scope)

for j in range(5):
    pass
print(j)  # 4 (то же самое)

Пример 2: Замыкания с циклом

JavaScript (проблема с var):

const functions = [];

for (var i = 0; i < 3; i++) {
  functions.push(() => console.log(i));
}

functions[0](); // 3 (все ссылаются на одну переменную i)
functions[1](); // 3
functions[2](); // 3

// Решение с let
const functions = [];

for (let i = 0; i < 3; i++) {
  functions.push(() => console.log(i));
}

functions[0](); // 0 (каждая итерация создает новую переменную)
functions[1](); // 1
functions[2](); // 2

Python:

functions = []

for i in range(3):
    functions.append(lambda: print(i))

functions[0]()  # 2 (та же проблема!)
functions[1]()  # 2
functions[2]()  # 2

# Решение с default аргументом
functions = []

for i in range(3):
    functions.append(lambda x=i: print(x))

functions[0]()  # 0 (default аргумент захватывает значение)
functions[1]()  # 1
functions[2]()  # 2

Пример 3: Неявное создание переменных

JavaScript (non-strict):

function test() {
  x = 5;  // Создает глобальную переменную!
}

test();
console.log(window.x); // 5 (или globalThis.x)

// Решение: использовать strict mode
'use strict';

function test() {
  x = 5;  // ReferenceError: x is not defined
}

Python:

def test():
    x = 5  # Создает локальную переменную

test()
print(x)  # NameError: name 'x' is not defined

# Если нужна глобальная:
def test():
    global x
    x = 5

test()
print(x)  # 5

Разница в поведении: Shadowing

JavaScript:

let x = 1;  // global

function test() {
  let x = 2;  // block scope (shadows global)
  console.log(x); // 2
}

test();
console.log(x); // 1 (глобальная не изменена)

Python:

x = 1  # global

def test():
    x = 2  # local (shadows global)
    print(x)  # 2

test()
print(x)  # 1 (глобальная не изменена)

Поведение одинаковое, но в Python нет block scope, поэтому проблем меньше.

Таблица решений для распространённых ошибок

Практический совет для интервью

"В JavaScript используй let и const вместо var для избежания проблем с function scope и hoisting. В Python переменные всегда имеют function или global scope, нет block scope, поэтому используй global или nonlocal если нужно изменить переменную из внешней области.

Запомни: JavaScript имеет block scope (с let/const), Python не имеет."