Что делает «use strict» в JavaScript и что за этим стоит?

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

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

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

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

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

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

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

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

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

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

• Устраняет с

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

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

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

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

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

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

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

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

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

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

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

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

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

Обратите внимание, что 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]] внутренний слот начинается с пролога директивы, который содержит директиву Use Strict.
• Код функции, который предоставляется в качестве аргументов для встроенных конструкторов Function и Generator, является кодом строгого режима, если последний аргумент является строкой, которая при обработке является FunctionBody , которая начинается с пролога директивы который содержит директиву об использовании строго

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

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

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

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

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

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

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

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

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

Директива "использовать строгое"
Директива "использовать строгое" является новой JavaScript 1.8.5 (ECMAScript версия 5). Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вы можете обратиться к документации по 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 в строгом режиме.
• В строгом режиме все переменные должны быть объявлены: если вы присваиваете значение идентификатору, который не был объявлен как переменная, функция, параметр функции, параметр 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, когда попытаетесь назначить свойства только для чтения или определить новые свойства для нерасширяемого объекта. (В обычном режиме оба просто терпят неудачу без сообщения об ошибке.)

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

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

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

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

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

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

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

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

3. Попытки удалить неотменяемые свойства будут сброшены (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 не поддерживается

[Ref: Строгий режим, Разработчик Mozilla Сеть ]

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

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

"use strict";

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