Что такое "строгий режим" и как он используется? Что делает "use strict" в JavaScript, и каковы причины этого? Javascript директива use strict поддерживается всеми браузерами

7 ответов

Его основная цель - сделать больше проверок.

Просто добавьте "use strict"; вверху вашего кода, прежде чем что-либо еще.

Например, blah = 33; действителен JavaScript. Это означает, что вы создаете полностью глобальную переменную blah .

Но в строгом режиме это ошибка, потому что вы не использовали ключевое слово "var" для объявления переменной.

В большинстве случаев вы не хотите создавать глобальные переменные в середине некоторой произвольной области, поэтому большую часть времени, когда blah = 33 записывается, это ошибка, и программист фактически не хотел, чтобы это было глобальная переменная, они хотели написать var blah = 33 .

Аналогичным образом запрещается много вещей, которые являются технически обоснованными. NaN = "lol" не вызывает ошибку. Он также не изменяет значение NaN. используя строгие эти (и подобные странные утверждения), вызывают ошибки. Большинство людей это ценят, потому что нет оснований когда-либо писать NaN = "lol" , поэтому, скорее всего, была опечатка.

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

Итак, подобные вещи

Function Obj() { this.a = 12; this.b = "a"; this.privilegedMethod = function () { this.a++; privateMethod(); }; function privateMethod() { this.b = "foo"; } }

приведет к ошибке при вызове privateMethod (поскольку вы не можете добавить свойство в undefined), вместо того, чтобы бесполезно добавлять свойство b к глобальному объекту.

Был добавлен строгий режим, чтобы было легко статически анализируемое подмножество EcmaScript, которое было бы хорошей мишенью для будущих версий языка. Строгий режим также был разработан в надежде, что разработчики, которые ограничиваются строгим режимом, будут делать меньше ошибок и что ошибки, которые они делают, будут проявляться более очевидными способами.

В ECMAScript 5 введена концепция строгой моды.

Вызов строгого режима в коде

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

Целый Script:

Скажем, мы создаем app.js, поэтому добавление использования первого выражения script приведет к строгому режиму для всего кода.

// app.js whole script in strict mode syntax "use strict"; // Now you can start writing your code

Строгий режим для функции:

Чтобы вызвать строгий режим для функции, поставьте точное утверждение "use strict"; в начале тела функции перед любым другим утверждением.

Function yourFunc(){ "use strict"; // Your function code logic }

Строгий режим включает несколько изменений в обычную семантику Javascript. Первый строгий режим устраняет некоторую ошибку JavaScript без изменений, изменяя их, чтобы выбросить ошибки.

Для экземпляра: код с использованием строгого режима

В приведенном выше примере кода без использования строгого режима в коде он не выдает ошибку. Поскольку мы обращаемся к переменной x , не объявляя ее. Поэтому в строгом режиме доступ к необъявленной переменной вызывает ошибку.

Теперь попробуйте обратиться к переменной x, не объявив ее без строгого режима.

(function(){ x = 3; })(); // Will not throw an error

Преимущество использования строгого режима:

• Устранить ошибки JavaScript без ошибок.
• Исправлена ​​ошибка, которая затрудняет выполнение JavaScript-движка.
• Сделать код быстрее, чем тот же код, который не работает в строгом режиме
• Запрещает некоторый синтаксис, который может быть определен в будущей версии ECMAScript.

Строгий режим (strict mode) — это особенность спецификации ECMAScript 5, позволяющая переключится в специальную, «ограниченную» версию JavaScript. Строгий режим накладывает ряд ограничений на языковые конструкции, тем самым исключая некоторые подводные камни и предотвращая ошибки. Также в строгом режиме выбрасывается больше исключений, как правило с более подробным описанием ошибки.

Включение strict mode осуществляется при помощи конструкции:

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

Обратите внимание, что для включения строго режима не добавлено каких-либо новых синтаксических конструкций. Строковая константа ‘use strict’ будет проигнорирована старыми браузерами, не поддерживающими строгий режим. Таким образом, вы можете использовать строгий режим, не беспокоясь о том, что в старых браузерах это вызовает ошибку.

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

При использовании use strict для всего скрипта нужно быть аккуратным с объединением файлов. При объединении скрипта в strict mode со скриптом в non-strict mode итоговый скрипт будет выполняться в строгом режиме. Это может вызвать некоторые ошибки, которые были не предусмотрены при написании второго скрипта. Поэтому рекомендуется код внутри каждого скрипта оборачивать анонимной функцией и для нее включать строгий режим.

Изменения в строгом режиме

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

Например, в строгом режиме невозможно работать с необъявленными переменными. Если в нестрогом режиме присвоение необъявленной переменной просто добавит свойство с таким именем глобальному объекту, то в строгом режиме это вызовет ошибку:

В строгом режиме в некоторых ситуациях, в которых в обычном режиме просто ничего не происходит, в строгом режиме бросаются исключения. Например, присваивание NaN в обычном режиме ничего не делает, присваивание не происходит, и разработчик не получает какой-либо информации об этом. В строгом режиме такое присваивание генерирует исключение. Аналогично любое другое присваивание, которое в обычном режиме «молча» не выполняется, в строгом режиме вызывает исключение.

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

Аналогично, параметры, передаваемые в функцию, также должны быть уникальны:

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

Еще одно отличие строго режима от нестрогого заключается в том, что в строгом режиме при передаче значения this в функцию c помощью call, apply или bind — это значение не оборачивается в объект. В нестрогом режиме, если в качестве this передается строка, число или логическое значение — оно оборачивается в соответствующий объект String, Number или Boolean. Если передается null или undefined — объектом this становится глобальный объект. В строгом режиме значение this передается «как есть»:

Заключение

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

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

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

&& — логическое И

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

Этот пример можно немного усложнить и записать операндами выражения сравнения.

Но на самом деле всё не так просто. В данном примере мы использовали операторы сравнения, они возвращают логические значения true / false. Но операндами логического И могут быть выражения с арифметическими операторами.

Давайте изменим пример:

В этом примере оператор && вернёт 11. Дело в том, что на самом деле оператор && возвращает последний операнд, если все операнды истинны.

Если хоть один из операндов равен лжи, то && возвратит первый операнд со значением ложь.

В этом примере оператор && вернёт цифру 0. Можно, для более глубокого понимания, усложнить пример.

Что есть ложь в JavaScript

Сейчас хороший повод повторить что есть ложь в JavaScript.

• Число 0 (ноль).
• Пустая строка «».
• Логическое значение false 🙂
• Значение null.
• Значение undefined.
• Значение NaN (Not a Number — не число).

Всё остальное в логическом контексте будет истиной.

|| — логическое ИЛИ

Оператор логического ИЛИ возвращает первое значение true (истина). А если истинных значений нет, то последнее ложное.

Логические выражения вычисляются слево направо. Как только оператор ИЛИ обнаружит значение true — он вернёт его, далее вычеслений не будет. Если не встретит ни одно значение true, то вернёт последнее значение, а оно точно будет false. Мы видим, ИЛИ вычисляет ровно столько значений, сколько необходимо.

!

Изучаем JavaScript «use strict». Часть 1

— логическое НЕ

Логическое НЕ — унарный оператор. Он принимает операнд и изменяет его значение истина/ложь на противоположное.

Также становится очевидно, при помощи двойного логического НЕ мы можем преобразовать литерал в тип Boolean.

Короткий цикл вычислений

Оператор || (ИЛИ)

Итак, логические выражения вычисляются слево направо. Например, когда оператор ИЛИ обнаружит значение true — он вернёт его, далее вычеслений не будет. Эту особенность можно использовать для поиска первого истинного выражения в списке.

Переменная result будет равна «Привет!». Постфиксный инкремент myVar++ сработает после вычисления выражения, а префиксный инкремент ++myVar не будет выполнен, так как ранее оператор || обнаружит истину.

Оператор && (И)

Вычисления слево направо, если аргумент - false, оператор && возвращает его и заканчивает вычисления. Иначе - вычисляет дальше, если false в списке нет, возвращает последний правый аргумент, а он будет true.

Вот пример:

Вычисления остановятся на переменной myStr, именно её значение «» и будет присвоено в переменную result.

&& вместо if

В простых случаях можно использовать оператор && вместо инструкции if:

В этом примере правый операнд выполнится только в том случае, если левый имеет логический тип истина.

The modern mode, «use strict»

var (справочник по C#)var (C# Reference)

Начиная с Visual C# 3.0, переменные, объявленные в области действия метода, получают неявный "тип" .Beginning in Visual C# 3.0, variables that are declared at method scope can have an implicit "type" .Неявно типизированные локальные переменные является строго типизированными, как если бы вы объявили тип самостоятельно, однако его определяет компилятор.An implicitly typed local variable is strongly typed just as if you had declared the type yourself, but the compiler determines the type.Следующие два объявления функционально эквивалентны:The following two declarations of are functionally equivalent:

Дополнительные сведения см. в разделах Неявно типизированные локальные переменные и Связи типов в операциях запроса LINQ.For more information, see Implicitly Typed Local Variables and Type Relationships in LINQ Query Operations.

ПримерExample

В следующем примере показаны два выражения запросов.The following example shows two query expressions.В первом выражении использование разрешено, но не является обязательным, поскольку тип результата запроса может быть задан явно как.In the first expression, the use of is permitted but is not required, because the type of the query result can be stated explicitly as an .Однако во втором выражении благодаря результат может быть коллекцией анонимных типов, и имя этого типа доступно только для компилятора.However, in the second expression, allows the result to be a collection of anonymous types, and the name of that type is not accessible except to the compiler itself.Использование делает создание нового класса для результата необязательным.Use of eliminates the requirement to create a new class for the result.Обратите внимание на то, что во втором примере переменная итерации также типизирована неявно.Note that in Example #2, the iteration variable must also be implicitly typed.

См. такжеSee Also

Справочник по C#C# Reference
Руководство по программированию на C#C# Programming Guide
Неявно типизированные локальные переменныеImplicitly Typed Local Variables

Узнайте, как можно исправить ошибки JavaScript кода с помощью консоли браузера и не только. Будем учиться на примерах, как бороться с js error и другими проблемами. А также поделимся своей практикой борьбы с ошибками в комментариях.

Что мы сегодня узнаем?

Визуализация ошибок в JavaScript

Примеры исправления ошибок с помощью консоли

Как исправить ошибку без консоли

Встречаем консоль!

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

Что-же, если вы еще не используете консоль для выявления а также исправления ошибок, советую попробовать прямо сейчас.

Визуализация при исправлении ошибок

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

Консоль браузера, это объект, который может быть использован для вывода информации об ошибках во время загрузки страницы. Для примера: вы можете добраться к любому DOM элементу, например, картинке которая имеет не правильный URL. Для этого нужно навести на элемент (картинку) и нажать правую кнопку мыши. Найти «Проинспектировать элемент » или что-то подобное. В Opera это выглядит так:

Вот мы и в консоле. Почти, остальось выбрать вкладку «консоль».

Консоль, в отличии от «исходного кода», способна видеть текущие изменения на странице, которые вызваны JavaScript кодом.

А вот доступ к консоли в Chrome браузере:

Простые примеры выявления ошибок

Консоль поддерживает множество опций, но можно обойтись 3-4, этого достаточно для выявления и дальнейшего исправления ошибки. Из моего собственного опыта, функция log() , наиболее удобная. Она выводит новые сообщения, DOM элементы, переменные в консоль, где мы можем их видеть. Примеры ниже показывают применение функций, которые я использую.

В этом скрипте, консоль выводит разные результаты в зависимости значения переменной full_name (пустая или нет).

if (full_name != «»){ console.log(‘The name \»‘ + full_name + ‘\» was entered’); }else{ console.error(‘No name was entered’); }

Для события jQuery click, консоль выведет информацию о нажатии элемента (трассировка):

Консоль это больше чем вывод сообщений, она также может принимать команды. Для примера, наберите «document» и нажмите Enter для получения информации о странице.

Как исправить ошибку без консоли?

Если вам сложно разобраться с функциями консоли, или ваш браузер не поддерживает данной функции. Советую воспользоваться простым и проверенным способом для исправления ошибки в коде javascript. По ходу программного кода, можно просто вставлять вывод сообщения alert();

Примеры выявления ошибок с помощью alert

Этот пример позволяет просто вывести значение переменной:

var e= 123; alert(e); // выведет 123

Также можно понять где значение, а где объект:

var e = document.getElementById(id_elementa); alert(e); // выведет сообщение, что выбран объект

Еще одно применение – это определение в какой строке кода произошла ошибка. Для этого вам просто нужно вставить сообщения типа alert(‘Здесь ошибка’); через каждую строку кода. Например:

alert(‘Hello’); var e = document.getElementByIds(‘id_elementa’); alert(‘Hello 2’);

В этом случае выведется только сообщение Hello. Потому-что на второй строке ошибка! Если ошибки не будет, выведутся 2 сообщения.

Строгий режим (strict mode) в JavaScript

Метод тупой, но срабатывает. Главное без использования консоли, скопировал -> вставил и определил где идет ошибка в коде. Если не надо, закомментировал.

Держите страницу в чистоте!

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

В этой статье мы рассмотрим одну из важнейших функциональностей JavaScript , называемую "строгим режимом" (strict mode ).

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

Использование "strict mode "

Чтобы начать выполнять код в строгом режиме, нам нужно использовать директиву «use strict». Это просто выражение. Эта директива поддерживается в JavaScript 1.8.5 (ECMAScript 5 ) или выше.

Использование директивы «use strict»

Существует два способа использования директивы «use strict» . Мы можем использовать ее или внутри объявления функции в самом начале или в глобальном объявлении – в начале файла.
Когда мы используем режим «strict mode » как глобальную директиву, весь код javascript на странице выполняется в строгом режиме. Например:

Function print(value) {
console.log (value);
}

Когда мы используем «use strict» внутри объявления функции, весь код внутри функции выполняется в строгом режиме. Весь другой код вне функции выполняется в обычном режиме.
Например:

Function print(value) {
"use strict"
console.log (value);
}

Function print_twice(value) {
console.log (value);
console.log (value);
}

Что мы не можем сделать в строгом режиме:

Использование необъявленной переменной

В строгом режиме мы не можем использовать необъявленную переменную.

"use string"
a = 12; // выбрасывается исключение в строгом режиме. В нестрогом режиме создается новое свойство для объекта window.

Оператор delete

Оператор delete используется для удаления пользовательских свойств у объекта и элементов массива. Если мы попытаемся удалить что-либо, кроме определенных пользователем свойств объекта или элементов массива, мы получим исключение.

Var a = 78;
window.b = 34;

Function print () {}
window.c = function () {}

Delete a; // генерирует исключение в строгом режиме. В стандартном режиме он возвращает false и программа продолжает работу

Delete window.a; // генерирует исключение в строгом режиме. В нестандартном режиме он возвращает false и программа продолжается.

Delete window.b; // В обоих режимах свойство b удаляется
.
delete Math.PI; // В нестрогом режиме он возвращает false, поскольку PI предварительно определен. В строгом режиме - исключение.

Delete Object.prototype; // удаление встроенного свойства в нестрогом режиме возвращает false. Но в строгом режиме выбрасывается исключение.

Просто помните, что везде, где delete возвращает false в нестрогом режиме, он выдает исключение в строгом режиме.

Многократное объявление свойств

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

Var myObject = {property1: 1, property2: 2, property1: 1}; // генерирует исключение.

На этом все, а в следующей статье мы продолжим изучать директиву JavaScript "use strict".

(далее в статье Strict Mode). Strict Mode накладывает слой ограничений на JavaScript, он отгораживает вас от опасных частей языка (те части, которые есть исторически, но лучше чтобы их не было) и позволяет снизить вероятность ошибки.

Пока читал эту статью я написал 38 тестов, покрывающих все правила Strict Mode, объявленные в спецификации ES5. Вы можете посмотреть насколько ваш браузер поддерживает эти справила .

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

Firefox 4 уже полностью поддерживает Strict Mode, а Chrome 11 практически полностью. Strict Mode уже не за горами - давайте изучим его подробнее!

Как включить Strict Mode?

Если добавить "use strict" в начало вашего JavaScript кода, то Strict Mode будет применен для всего кода:
"use strict"; 012; //Восьмеричный литерал запрешен. Выбросит исключение SyntaxError в Strict Mode
В качестве альтернативы вы можете включить Strict Mode только в отдельной функции, добавив "use strict" в начало тела вашей функции:
012; //Нет ошибки (Strict Mode не включен глобально) function foo() { "use strict"; x=3; //Strict Mode выбросит исключение - запрещено неявно создавать глобальные переменные } foo(); //ReferenceError (Strict Mode включен для функции)

Наследуют ли внутренние функции Strict Mode от внешних функций?

Внутренняя функция, объявленная внутри внешней, в которой включен Strict Mode тоже будет иметь Strict Mode:
var wrapper = function(fn) { "use strict"; var deleteNonConfigurable = function () { var obj = {}; Object.defineProperty(obj, "name", { configurable: false }); delete obj.name; // Выбросит исключение TypeError в Strict Mode } return deleteNonConfigurable; } wrapper()(); //TypeError (Strict Mode включен)
Важно запомнить, что Strict Mode не распространяется на «нестрогие» (ориг. non-strict) функции, которые выполняются внутри строгой функции (или они отправлены в функцию в качестве аргументов или выполняются, используя call или apply):
var test = function(fn) { "use strict"; fn(); } var deleteNonConfigurable = function () { var obj = {}; Object.defineProperty(obj, "name", { configurable: false }); delete obj.name; // Выбросит исключение TypeError в Strict Mode } test(deleteNonConfigurable); //нет ошибки (Strict Mode не применялся)

Почему я не могу включить Strict Mode в консоли моего браузера?

Когда выполняешь код в консоли фаербага или в других консолях использование "use strict" вне функции не имеет силы. Это потому, что большинство консолей обрамляют ваш код в eval"ом, поэтому ваш "use strict" не является первым выражением. Это можно обойти, обрамив ваш код в замыкание (IIFE), в начало которого мы положим "use strict" (но, когда я тестировал такой способ включения Strict Mode я понял, что это довольно неудобно, особенно если работать в консоли webkit developer tools - лучше тестировать ваш код на странице):
(function() { "use strict"; var a; var b; function bar() { x = 5; //Strict Mode выбросит исключение за попытку создания глобальной переменной } bar(); // ReferenceError (Strict Mode включен) })();

Что произойдет если мой браузер не поддерживает Strict Mode?

Ничего. Директива "use strict" это обычное строковое выражение, которое будет проигнорировано всеми движками JavaScript, которые не поддерживают Strict Mode. Это позволяет безопасно использовать синтаксис Strict Mode во всех браузерах без каких-либо опасений, в то время когда браузеры имеющие поддержку Strict Mode будут использовать его.

Какие правила включены в Strict Mode?

Правила определены в спецификации Strict Mode и включают в себя ограничения во время «компиляции» и интерпретации (выполнения скрипта). Это вводный обзор (каждое правило я описал с примерами в следующем параграфе): ecma262-5.com/ELS5_HTML.htm#Annex_C

Синтаксические ошибки Syntax Errors

В большинстве случаев Strict Mode предотвращает выполнение подозрительного или нелегального кода в процессе загрузки. Восьмеричные числа, дубли имен переменных, некорректное использование delete и попытки сделать что-нибудь этакие с eval и ключевым словом arguments, использование with приведет к исключению SyntaxError.

Слово this

В Strict Mode объект this не будет корректироваться. Это возможно самая интересная часть Strict Mode и самая тяжелая(шокирующая) для разработчиков. Все знают, что если первый аргумент call или apply - null или undefined, то значение this выполняемой функции будет преобразование в глобальный объект (для браузеров это window).

Прямое создание глобальных переменных

Не все согласятся с этим, но непрямое создание глобального объекта почти всегда является ошибкой. В Strict Mode вам выдадут красную карточку - ReferenceError.

arguments.caller и arguments.callee

Эти «полезные свойства» (от пер. никогда не применял их) запрещены в Strict Mode. Если вы используете их в вашем кода, то Strict Mode выбросит исключение.

Объявление существующего имени объекта

Когда вы создаете объект с двумя одинаковыми ключами, то Strict Mode выбросит исключение TypeError.

Тесты

Вот исходник моих Strict Mode тестов. Каждый набор тестов снабжен комментарием, ссылающемся на часть спецификации ECMAScript, которую он тестирует. Эта версия может быть выполнена в «режиме консоли». Т.е. вы можете скопировать тест, вставить в консоль и выполнить без изменений. Этот же код, работающий в режиме «HTML» я использовал для создания тестовой страницы, которую я представил вам в начале статьи. Этот исходник с дополнительными объектами в моем github репозитории . Я уверен, что там есть пара ошибок - не стесняйтесь присылать ошибки!

От переводчика: тут в статье шел огромный кусок кода, закинул его на pastebin

Заключение

Запрещение обращение к некоторым возможностям языка для улучшения кода - вопрос спорный, давайте отложим эти споры. В защиту Strict Mode я хочу сказать, что это отличный компромисс между тотальными переменами (которые сломают обратную совместимость) и ничего не деланием (которое приведет к захламлению языка и научит разработчиков плохому). ECMA-262 5th Edition: The Strict Mode of ECMAScript
Asen Bozhilov: Strict tester
Таблица совместимости с ECMAScript 5, часть посвященная Strict mode . Это отличный источник, часть большой таблицы совместимости, разработанной Юрием Зайцевым (Juriy Zaytsev aka «kangax»)

От переводчика. Strict Mode поддерживают практически половина всех браузеров, кроме своих прекрасных ограничений и иммунитету к распространенным ошибкам Strict Mode дает и другие преимущества (статья ). Скоро неиспользование Strict Mode станет плохим тоном (аналогично ). Сейчас самое время начать эксперименты!

Недавно я запустил код моего кода JavaScript через Crockford JSLint , и он дал следующую ошибку:

Problem at line 1 character 1: Missing "use strict" statement.

Выполняя некоторые поиски, я понял, что некоторые люди добавляют "use strict"; в свой код JavaScript. Как только я добавил выражение, ошибка перестала появляться. К сожалению, Google не раскрыл большую часть истории этого оператора строки. Конечно, это должно быть связано с тем, как JavaScript интерпретируется браузером, но я не знаю, каким будет эффект.

Итак, что такое "use strict"; все о том, что это подразумевает, и все еще актуально?

Любой из текущих браузеров реагирует на "use strict"; строка или это для будущего использования?

30 ответов

Эта статья о строгом режиме Javascript может вас заинтересовать: Джон Резиг - ECMAScript 5 Strict Mode, JSON и другие

Процитирую некоторые интересные части:

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

Строгий режим выручает несколькими способами:

• Он ловит некоторые распространенные ошибки кодирования, создавая исключения.
• Он предотвращает или выдает ошибки, когда предпринимаются относительно "небезопасные" действия (например, получение доступа к глобальному объекту).
• Это отключает функции, которые сбивают с толку или плохо продуманы.

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

// Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code...

Что может быть полезно, если вам нужно смешать старый и новый код;-)

Итак, я предполагаю, что это немного похоже на "use strict" вы можете использовать в Perl (отсюда и название?): Оно помогает вам делать меньше ошибок, обнаруживая больше вещей, которые могут привести к поломкам.

Это новая особенность ECMAScript 5. Джон Ресиг написал хорошее резюме .

Это просто строка, которую вы помещаете в свои файлы JavaScript (либо вверху вашего файла, либо внутри функции), которая выглядит так:

"use strict";

Включение этого кода теперь не должно вызывать проблем с текущими браузерами, поскольку это просто строка. Это может вызвать проблемы с вашим кодом в будущем, если ваш код нарушает прагму. Например, если у вас в настоящее время есть foo = "bar" не определяя сначала foo , ваш код начнет сбой... что, на мой взгляд, хорошо.

Утверждение "use strict"; инструктирует браузер использовать режим Strict, который является уменьшенным и более безопасным набором функций JavaScript.

Список функций (неисчерпывающий)

Запрещает глобальные переменные. (Убирает отсутствующие объявления var и опечатки в именах переменных)

Бесшумные неудачные задания будут вызывать ошибку в строгом режиме (назначая NaN = 5;)

Попытки удалить отказоустойчивые свойства будут вызывать (delete Object.prototype)

Требует, чтобы все имена свойств в объектном литерале были уникальными (var x = {x1: "1", x1: "2"})

Имена функциональных параметров должны быть уникальными (function sum (x, x) {...})

Forbids - восьмеричный синтаксис (var x = 023; некоторые разработчики ошибочно полагают, что предыдущий нуль не делает ничего, чтобы изменить число.)

Запрещающий with ключевым словом

eval в строгом режиме не вводит новые переменные

Запретить удаление простых имен (delete x;)

Запрет привязки или присвоения имен eval и arguments в любой форме

Строгий режим не поддерживает свойства объекта arguments с формальными параметрами. (т.е. в function sum (a,b) { return arguments + b;} Это работает, потому что arguments связаны с a и т.д.)

arguments.callee не поддерживается

Если люди обеспокоены use strict возможно, стоит проверить эту статью:

Слово предостережения, все, что вы программируете с жесткой зарядкой: применение "use strict" к существующему коду может быть опасным! Эта вещь не какая-то приятная, счастливая наклейка, которую вы можете похлопать по коду, чтобы сделать ее "лучше". При "use strict" правильной "use strict" прагмы браузер внезапно выбрасывает исключения в случайных местах, которые он никогда не бросал раньше, просто потому, что в этом месте вы делаете то, что позволяет по умолчанию/свободно JavaScript, но строгий JavaScript не нравится! У вас могут быть нарушения строгости, скрывающиеся в редко используемых вызовах вашего кода, которые будут генерировать исключение только тогда, когда они в конечном итоге будут запущены - скажем, в производственной среде, которую используют ваши платежные клиенты!

Если вы собираетесь сделать решительный шаг, рекомендуется применять "use strict" наряду с комплексными модульными тестами и строго сконфигурированной задачей сборки JSHint, которая даст вам уверенность в том, что нет темного угла вашего модуля, который взорвется ужасно, потому что вы включили строгий режим. Или, эй, вот еще один вариант: просто не добавляйте "use strict" к любому из ваших устаревших кодов, это, вероятно, безопаснее, честно. ОПРЕДЕЛЕННО НЕ добавляйте "use strict" для любых модулей, которые вы не владеете или не поддерживаете, например, сторонние модули.

Я думаю, что даже если это смертоносный живот в клетке, "use strict" может быть хорошим, но вы должны сделать это правильно. Лучшее время, чтобы идти строгим, - это когда ваш проект является новым, и вы начинаете с нуля. Настройте JSHint/JSLint со всеми предупреждениями и параметрами, сложенными так же сильно, как ваша команда может вздрагивать, получить хорошую систему сборки/тестирования/утверждения, которую можно настроить как Grunt+Karma+Chai , и только THEN начнет маркировать все ваши новые модули как "use strict" . Будьте готовы вылечить множество ошибок и предупреждений. Убедитесь, что все понимают гравитацию, настроив сборку на FAIL, если JSHint/JSLint вызывает какие-либо нарушения.

Мой проект не был новым проектом, когда я принял "use strict" . В результате моя IDE полна красных отметок, потому что у меня нет "use strict" на половине моих модулей, и JSHint жалуется на это. Это напоминание мне о том, какой рефакторинг я должен делать в будущем. Моя цель - быть красной отметкой бесплатно из-за всех моих отсутствующих "use strict" заявлений, но это уже много лет.

В моем новом приложении JavaScript: Абсолютно! Строгий режим можно использовать в качестве осведомителя, когда вы делаете что-то глупое с вашим кодом.

В моем существующем JavaScript-коде: Наверное, нет! Если в вашем существующем JavaScript-коде есть инструкции, которые запрещены в строгом режиме, приложение просто сломается. Если вам нужен строгий режим, вы должны быть готовы отлаживать и исправлять существующий код. Вот почему использование "use strict"; не делает ваш код лучше.

Как использовать строгий режим?

Вставить "use strict"; в верхней части вашего скрипта:

// File: myscript.js "use strict"; var a = 2; ....

Обратите внимание, что все в файле myscript.js будет интерпретироваться в строгом режиме.

Или вставьте "use strict"; утверждение сверху вашего тела функции:

Function doSomething() { "use strict"; ... }

Все в лексическом объеме функции doSomething будет интерпретироваться в строгом режиме. Здесь важна лексическая область слова. См. Этот ответ для лучшего объяснения.

Какие вещи запрещены в строгом режиме?

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

По-видимому, на начальном этапе будут ошибки, с которыми мы никогда не сталкивались раньше. Чтобы получить полную выгоду, нам нужно провести надлежащее тестирование после перехода в строгий режим, чтобы убедиться, что мы все поймали. Определенно, мы просто не use strict в нашем коде и считаем, что ошибок нет. Таким образом, оттока заключается в том, что его время для начала использования этой невероятно полезной языковой функции для написания лучшего кода.

Например,

Var person = { name: "xyz", position: "abc", fullname: function () { "use strict"; return this.name; } };

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

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

"use strict" директиву, введенную в ECMAScript 5.

Директивы похожи на утверждения, но разные.

• use strict не содержит ключевых слов: директива - это простой оператор выражения, который состоит из специального строкового литерала (в одиночных или двойных кавычках). Механизмы JavaScript, которые не реализуют ECMAScript 5, просто видят выражение без побочных эффектов. Ожидается, что будущие версии стандартов ECMAScript внедрят use в качестве реального ключевого слова; Таким образом, кавычки станут устаревшими.
• use strict может использоваться только в начале скрипта или функции, т.е. должно предшествовать любому другому (реальному) утверждению. Это не должно быть первой инструкцией в скрипте функции: ей могут предшествовать другие выражения операторов, которые состоят из строковых литералов (и реализации JavaScript могут рассматриваться как директивы, специфичные для реализации). Строковые литералы, которые следуют за первым реальным оператором (в скрипте или функции), являются простыми выражениями. Интерпретаторы не должны интерпретировать их как директивы, и они не имеют никакого эффекта.

use strict директива use strict указывает, что следующий код (в скрипте или функции) является строгим кодом. Код на самом высоком уровне скрипта (код, который не находится в функции) считается строгим кодом, когда скрипт содержит use strict директиву use strict . Содержание функции считается строгим кодом, когда сама функция определена в строгом коде или когда функция содержит use strict директиву use strict . Код, передаваемый методу eval() считается строгим кодом, когда eval() вызывается из строкового кода или содержит use strict директиву use strict .

Строгий режим ECMAScript 5 является ограниченным подмножеством языка JavaScript, что устраняет соответствующие недостатки языка и обеспечивает более строгую проверку ошибок и повышенную безопасность. Ниже перечислены различия между строгим режимом и нормальным режимом (из которых особенно важны первые три):

• Вы не можете использовать его with -statement в строгом режиме.
• В строгом режиме все переменные должны быть объявлены: если вы присваиваете значение идентификатору, который не был объявлен как переменная, функция, параметр функции, параметр catch-clause или свойство глобального Object , тогда вы получите ReferenceError . В нормальном режиме идентификатор объявляется неявно как глобальная переменная (как свойство глобального Object)
• В строгом режиме ключевое слово this имеет значение undefined функции, которые были вызываться как функции (а не как методы). (В нормальном режиме this всегда указывает на глобальный Object). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

Также, когда функция вызывается с call() или apply в строгом режиме, this точно значение первого аргумента call() или apply() . (В нормальном режиме null и undefined заменяются глобальным Object а значения, которые не являются объектами, преобразуются в объекты.)

В строгом режиме вы получите TypeError , когда вы пытаетесь назначить свойства readonly или определить новые свойства для не растяжимого объекта. (В обычном режиме оба просто обходятся без сообщения об ошибке.)

• В строгом режиме при передаче кода в eval() вы не можете объявлять или определять переменные или функции в области вызывающего (как это можно сделать в обычном режиме). Вместо этого для eval() создается новая область, и переменные и функции находятся в пределах этой области. Эта область уничтожается после того, как eval() завершает выполнение.
• В строгом режиме аргумент-объект функции содержит статическую копию значений, которые передаются этой функции. В нормальном режиме аргумент-объект имеет несколько "магическое" поведение: элементы массива и именованные функциональные параметры ссылаются на одно и то же значение.
• В строгом режиме вы получите SyntaxError когда за оператором delete следует неквалифицированный идентификатор (переменная, функция или параметр функции). В нормальном режиме выражение delete ничего не сделает и будет оценено как false .
• В строгом режиме вы получите TypeError при попытке удалить неконфигурируемое свойство. (В обычном режиме попытка просто терпит неудачу, а выражение delete - false).
• В строгом режиме это считается синтаксической ошибкой при попытке определить несколько свойств с тем же именем для литерала объекта. (В нормальном режиме ошибки нет.)
• В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с тем же именем. (В нормальном режиме ошибки нет.)
• В строгом режиме не допускаются восьмеричные литералы (это литералы, начинающиеся с 0x . (В нормальном режиме некоторые реализации позволяют делать восьмеричные литералы).
• В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение, и вы не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
• В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают TypeError в функции в строгом режиме. Кроме того, некоторые свойства caller- и аргументы функций в строгом режиме вызывают TypeError при попытке их прочитать.

Мои два цента:

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

Немного важных вещей, которые я узнал после use strict:

Предотвращает глобальную декларацию переменных:

Var tree1Data = { name: "Banana Tree",age: 100,leafCount: 100000}; function Tree(typeOfTree) { var age; var leafCount; age = typeOfTree.age; leafCount = typeOfTree.leafCount; nameoftree = typeOfTree.name; }; var tree1 = new Tree(tree1Data); console.log(window);

Теперь этот код создает nameoftree в глобальной области видимости, доступ к которому можно получить с помощью window.nameoftree . Когда мы реализуем use strict использование кода, код будет вызывать ошибку.

Uncaught ReferenceError: nameoftree не определен

Исключает with утверждением:

with утверждениями не могут быть уменьшены с помощью таких инструментов, как uglify-js . Они также устарели и удалены из будущих версий JavaScript.

Предотвращает дублирование:

Когда у нас есть свойство duplicate, оно выдает исключение

Uncaught SyntaxError: Дублирование свойства данных в объектном литерале не допускается в строгом режиме

"use strict"; var tree1Data = { name: "Banana Tree", age: 100, leafCount: 100000, name:"Banana Tree" };

Есть еще несколько, но мне нужно больше узнать об этом.

Если вы используете браузер, выпущенный в прошлом году или около того, он, скорее всего, поддерживает режим JavaScript Strict. Только старые браузеры до того, как ECMAScript 5 стал текущим стандартом, не поддерживают его.

Кавычки вокруг команды удостоверяются, что код по-прежнему будет работать и в старых браузерах (хотя вещи, которые генерируют синтаксическую ошибку в строгом режиме, как правило, просто приводят к тому, что скрипт будет работать некорректно в некоторых труднодоступных браузерах).

При добавлении "use strict"; , следующие случаи будут бросать SyntaxError перед выполнением скрипта:

Прокладывая путь к будущим версиям ECMAScript, используя одно из новых зарезервированных ключевых слов (в предвидении для ECMAScript 6): implements , interface , let , package , private , protected , public , static и yield .

Объявление функции в блоках

If(a

Восьмеричный синтаксис

Var n = 023;

this точка относится к глобальному объекту.

Function f() { "use strict"; this.a = 1; }; f();

Объявление дважды того же имени для имени свойства в объектном литерале

{a: 1, b: 3, a: 7}

Это больше не относится к ECMAScript 6 (ошибка 1041128).

Объявление двух аргументов функции с одинаковой функцией имени

F(a, b, b){}

Установка значения для необъявленной переменной

Function f(x){ "use strict"; var a = 12; b = a + x*35; // error! } f();

Использование delete для имени переменной delete myVariable;

Использование eval или arguments качестве имени arguments переменной или функции

"use strict"; arguments++; var obj = { set p(arguments) { } }; try { } catch (arguments) { } function arguments() { }

"Использовать строгий"; является страхованием, что программист не будет использовать свободные или плохие свойства JavaScript. Это руководство, точно так же, как правитель поможет вам сделать прямые линии. "Использовать Strict" поможет вам сделать "прямое кодирование".

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

Поверь мне. Накладные расходы незначительны по сравнению с плохо разработанным кодом. . Лично мне нравится постоянно возвращаться на его сайт, чтобы я не забыл свою хорошую практику.

Современная практика JavaScript всегда должна вызывать "Use Strict"; Прагма. Единственная причина, по которой ECMA Group сделала вариант "Строгий", - это разрешить доступ менее опытным кодовым машинам к JavaScript и дать время для адаптации к новым и более безопасным способам кодирования.

Директива "use strict" появилась в JavaScript 1.8.5 (ECMAScript версии 5).

Почему строгий режим?

Строгий режим облегчает написание "безопасного" JavaScript.

Строгий режим изменяет ранее принятый "плохой синтаксис" на реальные ошибки.

Например, в обычном JavaScript неправильный ввод имени переменной создает новую глобальную переменную. В строгом режиме это приведет к ошибке, из-за которой невозможно случайно создать глобальную переменную.

В обычном JavaScript разработчик не будет получать никаких сообщений об ошибках, присваивая значения свойствам, недоступным для записи.

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

"use strict" заставляет код JavaScript работать в строгом режиме, что в основном означает, что все должно быть определено перед использованием. Основная причина использования строгого режима состоит в том, чтобы избежать случайного глобального использования неопределенных методов.

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

"use strict" широко необходимо для использования в ECMA5, в ECMA6 это часть JavaScript по умолчанию , поэтому его не нужно добавлять, если вы используете ES6.

Посмотрите на эти заявления и примеры из MDN:

Директива об использовании строгих правил
Директива "use strict" появилась в JavaScript 1.8.5 (ECMAScript версии 5). Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript. Цель "использования строгого" - указать, что код должен выполняться в "строгом режиме". В строгом режиме нельзя, например, использовать необъявленные переменные.

Примеры использования "используйте строгий":
Строгий режим для функций: аналогично, чтобы вызвать строгий режим для функции, поместите точное выражение "use strict"; (или "используйте строгий";) в теле функции перед любыми другими утверждениями.

1) строгий режим в функциях

Function strict() { // Function-level strict mode syntax "use strict"; function nested() { return "And so am I!"; } return "Hi! I"m a strict mode function! " + nested(); } function notStrict() { return "I"m not strict."; } console.log(strict(), notStrict());

2) строгий режим всего сценария

"use strict"; var v = "Hi! I"m a strict mode script!"; console.log(v);

3) Присвоение неписываемым глобальным

"use strict"; // Assignment to a non-writable global var undefined = 5; // throws a TypeError var Infinity = 5; // throws a TypeError // Assignment to a non-writable property var obj1 = {}; Object.defineProperty(obj1, "x", { value: 42, writable: false }); obj1.x = 9; // throws a TypeError // Assignment to a getter-only property var obj2 = { get x() { return 17; } }; obj2.x = 5; // throws a TypeError // Assignment to a new property on a non-extensible object. var fixed = {}; Object.preventExtensions(fixed); fixed.newProp = "ohai"; // throws a TypeError

Там были хорошие разговоры некоторых людей, которые были в комитете ECMAScript: " Изменения в JavaScript, часть 1: ECMAScript 5" о том, как инкрементное использование переключателя "use strict" позволяет разработчикам JavaScript очищать множество опасных функций JavaScript без внезапно разбивая каждый сайт в мире.

Конечно, в нем также говорится о том, что такое много ошибок (и), и как ECMAScript 5 их исправляет.

Небольшие примеры для сравнения:

Нестрогий режим:

for (i of ) console.log(i) // output: // 1 // 2 // 3

Строгий режим:

"use strict"; for (i of ) console.log(i) // output: // Uncaught ReferenceError: i is not defined

Нестрогий режим:

String.prototype.test = function () { console.log(typeof this === "string"); }; "a".test(); // output // false

String.prototype.test = function () { "use strict"; console.log(typeof this === "string"); }; "a".test(); // output // true

Обратите внимание, что use strict было введено в EcmaScript 5 и хранилось с тех пор.

Ниже приведены условия для запуска строгого режима в ES6 и ES7 :

• Глобальный код - это строгий режимный код, если он начинается с директивного пролога, содержащего директиву Use Strict (см. 14.1.1).
• Код модуля всегда является строгим кодом режима.
• Все части ClassDeclaration или ClassExpression являются строгим кодом режима.
• Eval code - это строгий режимный код, если он начинается с директивы Prologue, которая содержит директиву Use Strict или если вызов eval является прямой оценкой (см. 12.3.4.1), которая содержится в коде строгого режима.
• Функциональный код - это строгий режимный код, если связанное с ним FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition или ArrowFunction содержится в коде строгого режима, или если код, который генерирует значение внутреннего слота функций [], начинается с директивы Prologue который содержит ссылку на использование Strict.
• Код функции, который поставляется в качестве аргументов встроенным конструкторам Function и Generator, является строгим кодом режима, если последним аргументом является String, который при обработке является FunctionBody, который начинается с директивы Prologue, которая содержит директиву Strict.

Основными причинами, по которым разработчики должны использовать "use strict" являются:

1. Предотвращает случайное объявление глобальных переменных. "use strict()" , убедитесь, что переменные объявлены с var перед использованием. Например:

   Function useStrictDemo(){ "use strict"; //works fine var a = "No Problem"; //does not work fine and throws error k = "problem" //even this will throw error someObject = {"problem": "lot of problem"}; }

2. NB: директива "use strict" распознается только в начале скрипта или функции.

Строковые "arguments" не могут использоваться как переменная:

"use strict"; var arguments = 3.14; // This will cause an error

Ограничит использование ключевых слов в качестве переменных. Попытки использовать их будут бросать ошибки.

Короче говоря, ваш код будет меньше подвержен ошибкам и, в свою очередь, заставит вас писать хороший код.

Чтобы узнать больше об этом, вы можете обратиться сюда .

источник

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

"use strict"; x = 3.14; // This will cause an error

Объекты также являются переменными.

Использование объекта, не объявляя его, не допускается:

"use strict"; x = {p1:10, p2:20}; // This will cause an error

Удаление переменной (или объекта) запрещено.

"use strict"; var x = 3.14; delete x; // This will cause an error

По соображениям безопасности eval() не может создавать переменные в области, из которой он был вызван:

"use strict"; eval ("var x = 2"); alert (x); // This will cause an error

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

"use strict" распознается только в начале скрипта.

"использовать строгое"; Определяет, что код JavaScript должен выполняться в "строгом режиме".

• Директива "Use strict" была впервые введена в ECMAScript версии 5.
• Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript.
• Цель "использования строгого" - указать, что код должен выполняться в "строгом режиме".
• В строгом режиме нельзя, например, использовать необъявленные переменные.

Все современные браузеры поддерживают "строгое использование", кроме Internet Explorer 9 и ниже.

Недостаток

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

Хуже того, поскольку разработчик находится в нормальном режиме, он не имеет преимуществ, связанных с дополнительными ошибками, поэтому ошибка может молча завершиться сбоем.

Пожалуйста, проверьте функцию ниже, написанную в нестрогом режиме:

Function getname(){ name = "Stack Overflow"; // Not using var keyword return name; } getname(); console.log(name); // Stack Overflow

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

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

Быть очень простым "использовать строгое"; в самом верху вашего JS файла включается строгая проверка синтаксиса.

Некоторые ситуации, которые выдают ошибку в строгом режиме:

• Установка функции с одинаковыми именами параметров.
• Создание объекта с одинаковыми ключами.
• Тихие провальные задания.
• Удаление простых имен или необратимых свойств
• Установка целого числа, начинающегося с нуля, переменной

Что касается того, использовать его или нет, важно помнить следующее:

Строгий режим в браузерах

Основные браузеры теперь реализуют строгий режим. Однако не стоит слепо зависеть от этого, поскольку все еще существует множество версий браузера, которые используются в дикой природе, которые имеют лишь частичную поддержку строгого режима или вообще не поддерживают его (например, Internet Explorer ниже версии 10!). Строгий режим меняет семантику. Использование этих изменений приведет к ошибкам и ошибкам в браузерах, которые не поддерживают строгий режим. Соблюдайте осторожность при использовании строгого режима и поддерживайте зависимость от строгого режима с помощью функциональных тестов, которые проверяют, реализованы ли соответствующие части строгого режима. Наконец, обязательно протестируйте свой код в браузерах, которые поддерживают строгий режим и не поддерживают его. Если вы тестируете только в браузерах, которые не поддерживают строгий режим, у вас, скорее всего, будут проблемы в браузерах, которые поддерживают, и наоборот.

поделиться