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

Это новая функция ECMAScript 5. Джон Резиг написал хорошее резюме этого.

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

"use strict";

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

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

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

Если люди беспокоятся об использовании, 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.
*/

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

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

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

Современная практика JavaScript всегда должна вызывать «Use Strict»; Прагма. Единственная причина, по которой группа ECMA сделала необязательный режим «Строгий», заключается в том, чтобы предоставить менее опытным кодировщикам доступ к JavaScript и дать время для адаптации к новым и более безопасным методам кодирования.

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

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

Например,

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

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

Осторожно, всем вам, программистам с высокой нагрузкой: применение "use strict"к существующему коду может быть опасным! Это не какая-то приятная на ощупь наклейка с счастливым лицом, которую вы можете нанести на код, чтобы сделать его «лучше». С "use strict"прагмой, браузер внезапно будет БРОСАТЬ исключения в случайных местах, которые он никогда не генерировал раньше, просто потому, что в этот момент вы делаете что-то, что по умолчанию / свободный JavaScript разрешает, но строгий JavaScript не терпит! Вы можете иметь нарушения строгости, скрывающие редко используемые вызовы в вашем коде, которые будут вызывать исключение только тогда, когда они в конечном счете запускаются - скажем, в производственной среде, которую используют ваши платящие клиенты!

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

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

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

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

• устраняет некоторые тихие ошибки JavaScript, изменяя их на ошибки.

• исправляет ошибки, мешающие движкам JavaScript выполнять оптимизацию.

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

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

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

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

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

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

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

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

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

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

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

Их немного, но мне нужно больше узнать об этом.

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

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

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

2. Тихие неудачные задания приведут к ошибке в строгом режиме (назначение NaN = 5;)

3. Пытается удалить Undeletable свойства выбросит ( delete Object.prototype)

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

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

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

7. Запрещает withключевое слово

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

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

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

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

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

[Ссылка: строгий режим , Сеть разработчиков Mozilla ]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

"use strict" директива, введенная в ECMAScript 5.

Директивы похожи на заявления, но отличаются.

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

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

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

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

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

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

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

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

При добавлении "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качестве имени переменной или аргумента функции

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

Источники:

• Переход на строгий режим на MDN

• Строгий режим на MDN

• Строгий режим JavaScript и почему вы должны его использовать в блоге Колина Дж. Ирига (архивная версия)

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

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

'use strict';

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

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

var a = 365;
var b = 030;

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

Неисчерпывающий список специальностей в строгом режиме см. В этом ответе .

Где я должен использовать 'use strict';?

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

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

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

1. Вставьте 'use strict';оператор поверх вашего скрипта:

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

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

2. Или вставьте 'use strict';оператор поверх тела вашей функции:

   function doSomething() {
       'use strict';
       ...
   }

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

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

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

Объем

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

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

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

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

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

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

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

Шумный отказ

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

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

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

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

И так далее

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

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

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

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

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

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

• Строгий режим - JavaScript | MDN
• Поддержка браузера для строгого режима
• Переход в строгий режим

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

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

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

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

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

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

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

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

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

'use strict';
for (i of [1,2,3]) 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 используется для отображения распространенных и повторяющихся ошибок, так что они обрабатываются по-разному, и изменяет способ выполнения сценария Java, такие изменения:

• Предотвращает случайные глобалы

• Без дубликатов

• Устраняет с

• Устраняет это принуждение

• Более безопасный eval ()

• Ошибки для неизменяемых

Вы также можете прочитать эту статью для деталей

«Строгий» режим JavaScript был введен в ECMAScript 5.

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

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

1. выдает ошибку при попытке присвоить необъявленную переменную

2. останавливает перезапись ключевых системных библиотек JS

3. запрещает некоторые небезопасные или подверженные ошибкам языковые функции

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

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

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

3. Строка "arguments"не может быть использована в качестве переменной:

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

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

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

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

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

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

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

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

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

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

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

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

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 .

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

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

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

Недостаток

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

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

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

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

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

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

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

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

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

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