В предыдущем введении мы уже знаем, что JavaScript не имеет функции на уровне блока, только сфера действия функции.
Кода -копия выглядит следующим образом:
Function Test () {// Область применения
для (var i = 0; i <10; i ++) {// не область применения
// считать
}
console.log (i); // 10
}
В JavaScript также нет пространства имен, что означает, что все определено в глобальной области. Каждый раз, когда упоминается переменная, JavaScript будет проходить всю глобальную область, пока она не найдет. Если переменная до сих пор не найдена через полную глобальную область, ошибка ссылочной ошибки.
Пожалуйста, введите описание изображения
Неявные глобальные переменные
Кода -копия выглядит следующим образом:
// скрипт а
foo = '42';
// скрипт б
var foo = '42'
Вышеуказанные два примера имеют разные эффекты. Первый будет определять переменную FOO в глобальном объеме, в то время как вторая будет определять переменную Foo в текущей области.
Следует отметить, что если вы не используете ключевое слово var, оно окажет неожиданное влияние.
Кода -копия выглядит следующим образом:
// Глобальный объем
var foo = 42;
функциональный тест () {
// локальная сфера
foo = 21;
}
тест();
foo; // 21
Поскольку VAR не используется для определения переменной FOO в тесте функции, глобальная переменная FOO за пределами функции будет перезаписана. Хотя это не кажется большой проблемой, если есть тысячи строк кода, это будет сложная ошибка для отслеживания.
Кода -копия выглядит следующим образом:
// Глобальный объем
var elects = [/ * Некоторый список */];
для (var i = 0; i <10; i ++) {
subloop ();
}
функция subloop () {
// Область Subloop
for (i = 0; i <10; i ++) {// отсутствует оператор VAR
// делай удивительные вещи!
}
}
В приведенном выше примере внешний цикл остановится при выполнении первого выполнения, потому что переменная I внутри функции Subloop будет переоценить внешнюю глобальную переменную i. Нам нужно только добавить VAR в функцию, чтобы избежать этой ошибки, поэтому мы не должны забывать добавлять ключевое слово var при определении переменных. Если мы не хотим оказать влияние на внешние глобальные переменные.
Местные переменные
Локальные переменные в JavaScript могут быть сгенерированы только двумя способами, один объявляется через ключевое слово var, а другое используется в качестве формальных параметров функции.
Кода -копия выглядит следующим образом:
// Глобальный объем
var foo = 1;
var bar = 2;
var i = 2;
Функциональный тест (i) {
// локальный объем функционального теста
i = 5;
var foo = 3;
бар = 4;
}
тест (10);
В настоящее время переменные I и FOO внутри функционального теста являются локальными переменными, а полоса переопределяет внешнюю глобальную полосу переменной.
Подъем
JavaScript будет способствовать объявлениям переменных, что означает, что как выражения VAR, так и объявления функций будут способствовать вершине области.
Кода -копия выглядит следующим образом:
бар();
var bar = function () {};
var somevalue = 42;
тест();
Функциональный тест (данные) {
if (false) {
GOO = 1;
} еще {
var goo = 2;
}
для (var i = 0; i <100; i ++) {
var e = data [i];
}
}
До запуска вышеупомянутого кода, объявление VAR Expression и Function Test будет продвигаться вверху, поэтому программа будет работать нормально и не будет сообщать об ошибке.
Кода -копия выглядит следующим образом:
// операторы VAR были перенесены сюда
var bar, somevalue; // по умолчанию «неопределенное»
// Объявление функции тоже перенесено
Функциональный тест (данные) {
var goo, i, e; // отсутствующие блок -сфера перемещает их здесь
if (false) {
GOO = 1;
} еще {
GOO = 2;
}
for (i = 0; i <100; i ++) {
e = data [i];
}
}
бар(); // сбои с типами, так как бар все еще «не определен»
somevalue = 42; // назначения не влияют подъем
bar = function () {};
тест();
Поскольку JavaScript не имеет сферы на уровне блока, это не только улучшит выражение VAR, но и сделает структуру, если структура менее интуитивно понятна.
В приведенном выше примере, хотя кажется, что если работает на глобальной переменной GOO, фактически, поскольку продвигается переменная GOO, локальная переменная изменяется.
Если у вас нет никакого понимания правил возвышения, вы можете подумать, что следующий код принесет ошибку RESTERNERROR.
Кода -копия выглядит следующим образом:
// Проверьте, инициализировано ли какое -то какое -либо важное
if (! Quemportanting) {
var ComeImportanthing = {};
}
Конечно, приведенный выше код не ошибается, потому что выражение var было повышено до вершины до запуска кода.
Кода -копия выглядит следующим образом:
var Quemportanthing;
// другой код может инициализировать какое -либо важное здесь, или нет
// Убедитесь, что он там
if (! Quemportanting) {
Quemportanthing = {};
}
Здесь я хотел бы порекомендовать пост в блоге @Nightire Fan GE «Понимание JavaScript (II)», что очень тщательно объясняет улучшение.
Порядок разрешения имени
При попытке получить доступ к переменной Foo в области функции JavaScript будет искать ее в следующем порядке:
Есть ли определение Var foo в текущей области.
Есть ли переменная Foo в параметре функции.
Является ли сама функция foo.
Прыгните к домену внешнего определения и начните смотреть вверх с первой части.
Пространство имен
Одной из наиболее распространенных проблем является конфликты на наименовании, потому что у JavaScript есть только один глобальный объем. Но эта проблема может быть решена анонимными внешними функциями.
Кода -копия выглядит следующим образом:
(function () {
// самостоятельное "пространство имен"
window.foo = function () {
// открытое закрытие
};
}) (); // немедленно выполнить функцию
Анонимные функции в приведенном выше примере считаются выражениями, поэтому они выполняются.
Кода -копия выглядит следующим образом:
(// оценить функцию внутри родителей
function () {}
) // и вернуть объект функции
() // Вызов результат оценки
Конечно, мы также можем использовать другие методы для вызова выражений функции, разные структуры, но один и тот же эффект.
Кода -копия выглядит следующим образом:
// несколько других стилей для прямого вызова
! function () {} ()
+function () {} ()
(function () {} ());
// и так далее...
Суммировать
Рекомендуется использовать анонимные внешние функции для инкапсуляции кода в пространство, что не только решает конфликты пространства имен, но и облегчает модуляризацию программы.
Кроме того, использование глобальных переменных не является хорошей привычкой, которая принесет высокие затраты на техническое обслуживание и склонно к ошибкам.
Пространства имен имеют одинаковые типы, функции, переменные, шаблоны и т. Д., Все принадлежат сущности.
Основная общность сущности заключается в том, что он может иметь имя. (Кроме того, тег также может иметь имя, но это не сущность.)
Область пространства имен является общим термином в области объема, который параллельно блокируется область объема, объем класса, сферу прототипа функции и областью функции (только для меток). Имена, объявленные в пространстве имен, находятся в области пространства имен. Глобальные названия рассматриваются в неявном глобальном объеме пространства имен.
Функция пространства имен действительно - область применения, но она отличается от простой области. Вы можете объявить одно и то же пространство имен в нескольких местах несколько раз, но содержание внутри не может быть переопределено. Они в конечном итоге синтезируют пространство имен, как STD, макро -определения везде.