Что делает "use strict" в JavaScript, и каковы причины этого?

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

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

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

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

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

Ответы

Ответ 1

Эта статья о строгом режиме 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 (с операторами import и export) и классов ES6 строгий режим всегда включен и не может быть отключен.

Ответ 2

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

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

"use strict";

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

Ответ 3

Утверждение "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[0] + b;} Это работает, потому что arguments[0] связаны с a и т.д.)
arguments.callee не поддерживается

[Ссылка: Строгий режим, Mozilla Developer Network]

Ответ 4

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

Поддержка ECMAScript 5 "Строгий режим" в браузерах. Что это значит?
NovoGeek.com - блог Кришны

В нем говорится о поддержке браузеров, но что еще более важно, как с этим справиться:

function isStrictMode(){
    return !this;
} 
/*
   returns false, since 'this' refers to global object and 
   '!this' becomes false
*/

function isStrictMode(){   
    "use strict";
    return !this;
} 
/* 
   returns true, since in strict mode the keyword 'this'
   does not refer to global object, unlike traditional JS. 
   So here, 'this' is 'undefined' and '!this' becomes true.
*/

Ответ 5

Слово предостережения, все, что вы программируете с жесткой зарядкой: применение "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" заявлений, но это уже много лет.

Ответ 6

Использование `'use strict';` не делает ваш код лучше.

Строгий режим JavaScript - это функция в ECMAScript 5. Вы можете включить строгий режим, объявив это в верхней части вашего скрипта/функции.

'use strict';

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

Рассмотрим этот пример:

var a = 365;
var b = 030;

В своей одержимости, чтобы выстроить числовые литералы, разработчик непреднамеренно инициализировал переменную b восьмым литералом. Нестрогий режим будет интерпретировать это как числовой литерал со значением 24 (в базе 10). Однако строгий режим вызовет ошибку.

Для не исчерпывающего списка специальностей в строгом режиме см. Этот ответ.

Где я должен использовать `'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 будет интерпретироваться в строгом режиме. Здесь важна лексическая область слова. См. Этот ответ для лучшего объяснения.

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

Я нашел хорошую статью, описывающую несколько вещей, которые запрещены в строгом режиме (обратите внимание, что это не эксклюзивный список):

Объем

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

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

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

Подразумеваемые глобальные переменные

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

Глобальный утечек

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

Шумная ошибка

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

восьмеричный

8-разрядное представление чисел было чрезвычайно полезным при выполнении машинного программирования на машинах, размер слов которых был кратным 3. При работе с мэйнфреймом CDC 6600, имеющим размер слова 60 бит, вам понадобилось восьмеричное. Если бы вы могли читать восьмеричные, вы могли бы посмотреть на слово как на 20 цифр. Две цифры представляли op-код, а одна цифра идентифицировала один из 8 регистров. Во время медленного перехода от машинных кодов к языкам высокого уровня считалось полезным обеспечить восьмеричные формы на языках программирования.

В C было выбрано крайне неудачное представление о октальности: ведущий ноль. Так что в C 0100 означает 64, а не 100, а 08 - ошибка, а не 8. Еще более, к сожалению, этот анахронизм был скопирован почти на все современные языки, включая JavaScript, где он используется только для создания ошибок. Это не имеет другой цели. Таким образом, в строгом режиме восьмеричные формы больше не допускаются.

Et cetera

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

В строгом режиме дублирующиеся ключи в литерале функции выдают синтаксическую ошибку. Функция can not имеет два параметра с тем же именем. Функция can not имеет переменную с тем же именем, что и один из ее параметров. Функция can not delete свои собственные переменные. Попытка delete неконфигурируемое свойство теперь выдает исключение. Примитивные значения не неявно завернуты.

Зарезервированные слова для будущих версий JavaScript

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

implements, interface, let, package, private, protected, public, static, and yield

Дальнейшее чтение

Ответ 7

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

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

Например,

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

JSLint - отладчик, написанный Дугласом Крокфордом. Просто вставьте в свой скрипт, и он быстро сканирует любые заметные проблемы и ошибки в вашем коде.

Ответ 8

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

Для получения дополнительной информации вы можете обратиться к документации 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 при попытке их прочитать.

Ответ 9

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

Одна из целей строгого режима - обеспечить более быструю отладку проблем. Это помогает разработчикам, бросая исключение, когда происходят некоторые неправильные вещи, которые могут вызвать тихое и странное поведение вашей веб-страницы. В тот момент, когда мы используем 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 не определен

Sample

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

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

Sample

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

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

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

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

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

Ответ 10

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

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

Ответ 11

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

Прокладывая путь к будущим версиям ECMAScript, используя одно из новых зарезервированных ключевых слов (в предвидении для ECMAScript 6): implements, interface, let, package, private, protected, public, static и yield.
Объявление функции в блоках
```
if(a<b){ function f(){} }
```
Восьмеричный синтаксис
```
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() { } 
```

Источники:

Переход в строгий режим MDN
Строгий режим MDN
JavaScripts Strict Mode и почему вы должны использовать его в блоге Colin J. Ihrig (в архиве)

Ответ 12

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

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

для получения дополнительной информации vistit Strict Mode- Javascript

Ответ 13

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

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

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

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

Ответ 14

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

Ответ 15

Цитирование из w3schools:

Директива об использовании строгих правил

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

Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript.

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

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

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

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

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

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

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

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

Пожалуйста, обратитесь к http://www.w3schools.com/js/js_strict.asp, чтобы узнать больше

Ответ 16

"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

Вы можете прочитать больше на MDN.

Ответ 17

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

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

Ответ 18

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

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

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

Ответ 19

Обратите внимание, что 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 содержится в коде строгого режима, или если код, который генерирует значение внутреннего слота функций [[ECMAScriptCode]], начинается с директивы Prologue который содержит ссылку на использование Strict.

Код функции, который поставляется в качестве аргументов встроенным конструкторам Function и Generator, является строгим кодом режима, если последним аргументом является String, который при обработке является FunctionBody, который начинается с директивы Prologue, которая содержит директиву Strict.

Ответ 20

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

Предотвращает случайное объявление глобальных переменных. "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'};
}
```
NB: директива "use strict" распознается только в начале скрипта или функции.
Строковые "arguments" не могут использоваться как переменная:
```
"use strict";
var arguments = 3.14;    // This will cause an error
```
Ограничит использование ключевых слов в качестве переменных. Попытки использовать их будут бросать ошибки.

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

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

Ответ 21

"использовать строгую"; это стремление ECMA сделать JavaScript немного более надежным. Это приносит JS попытку сделать его хотя бы немного "строгим" (другие языки применяют строгие правила с 90-х годов). Это на самом деле "заставляет" разработчиков JavaScript следовать некоторым передовым методам кодирования. Тем не менее, JavaScript очень хрупкий. Нет такой вещи, как типизированные переменные, типизированные методы и т.д. Я настоятельно рекомендую разработчикам JavaScript изучить более надежный язык, такой как Java или ActionScript3, и реализовать те же самые лучшие практики в вашем JavaScript-коде, он будет работать лучше и будет проще отлаживать.

Ответ 22

JavaScript "строгий" режим был введен в ECMAScript 5.

(function() {
  "use strict";
  your code...
})();

Написание "use strict"; в самом верху вашего JS файла включается строгая проверка синтаксиса. Он выполняет следующие задачи для нас:

показывает ошибку, если вы пытаетесь присвоить необъявленную переменную
останавливает перезапись ключевых системных библиотек JS
запрещает некоторые небезопасные или подверженные ошибкам языковые функции

use strict также работает внутри отдельных функций. Лучше всегда включать в свой код use strict.

Проблема совместимости браузера: директивы use предназначены для обратной совместимости. Браузеры, которые их не поддерживают, просто увидят строковый литерал, на который больше нет ссылок. Итак, они пройдут над ним и пойдут дальше.

Ответ 23

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

Ответ 24

Использование Strict используется для отображения общих и повторяющихся ошибок, так что оно обрабатывается по-разному и изменяет способ запуска java-скрипта, такие изменения:

Предотвращает случайные глобальные переменные
Нет дубликатов
Исключает
Устраняет это принуждение
Более безопасный eval()
Ошибки для непременных

вы также можете прочитать эту статью за подробностями

Ответ 25

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

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

Ответ 26

Просто хотел добавить еще несколько очков.

Причина использования строгого Mode--->

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

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

"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" распознается только в начале скрипта.

Ответ 27

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

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

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

Недостаток

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

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

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

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

Для базового примера и для справки:

https://www.tutorialsteacher.com/javascript/javascript-strict

Ответ 28

Строгий режим может предотвратить утечки памяти.

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

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

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

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

Теперь давайте напишем ту же функцию в строгом режиме.

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

Мы получим следующую ошибку.

Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5

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

Ответ 29

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

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

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

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

Согласно ссылке MDN ниже:

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Strict_mode

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

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

Ответ 30