Что делает “use strict” в JavaScript и каковы причины, стоящие за этим?

StackOverflow https://stackoverflow.com/questions/1335851

Вопрос

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

Проблема в строке 1 символ 1:Отсутствует инструкция "использовать строгий".

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

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

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

Это было полезно?

Решение

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

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

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

И:

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

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

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

// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code...

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

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

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

Внутри встроенные модули ECMAScript (с import и export заявления) и Классы ES6, строгий режим всегда включен и не может быть отключен.

Другие советы

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

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

"use strict";

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

Заявление "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 не поддерживается

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

Если люди беспокоятся об использовании 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" доступ к существующему коду может быть опасным!Эта штука - не какая-то приятная наклейка со счастливым лицом, которую вы можете наклеить на код, чтобы сделать его "лучше".С помощью "use strict" pragma, браузер внезапно будет выдавать исключения в случайных местах, которые он никогда раньше не выдавал, просто потому, что в этом месте вы делаете что-то, что по умолчанию / свободно разрешенный JavaScript счастливо разрешает, но строгий JavaScript не терпит!У вас могут быть нарушения строгости, скрывающиеся в редко используемых вызовах в вашем коде, которые будут выдавать исключение только тогда, когда они в конечном итоге будут запущены - скажем, в производственной среде, которую используют ваши платящие клиенты!

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

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

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

Используя '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. Вставить a 'use strict'; заявление поверх вашего сценария:

    // File: myscript.js

'use strict';
var a = 2;
....

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

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

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

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

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

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

Область применения

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

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

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

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

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

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

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

Шумный Сбой

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

Восьмеричное число

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

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

Et cetera

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

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

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

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

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

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

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

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

Например,

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

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

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

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

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

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

  • use strict не содержит ключевых слов:Директива представляет собой простой оператор expression, который состоит из специального строкового литерала (в одинарных или двойных кавычках).Движки JavaScript, которые не реализуют ECMAScript 5, просто видят оператор expression без побочных эффектов.Ожидается, что будущие версии стандартов 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-object функции содержит статическую копию значений, которые передаются этой функции.В обычном режиме arguments-object имеет несколько "волшебное" поведение:Элементы массива и именованные параметры функции ссылаются на одно и то же значение.
  • В строгом режиме вы получите SyntaxError когда в delete за оператором следует неквалифицированный идентификатор (переменная, функция или функциональный параметр).В обычном режиме delete выражение ничего бы не сделало и вычисляется как false.
  • В строгом режиме вы получите TypeError когда вы пытаетесь удалить не настраиваемое свойство.(В обычном режиме попытка просто завершается неудачей, и delete выражение вычисляется как false).
  • В строгом режиме это считается синтаксической ошибкой, когда вы пытаетесь определить несколько свойств с одинаковым именем для литерала объекта.(В обычном режиме ошибки нет.)
  • В строгом режиме считается синтаксической ошибкой, когда объявление функции содержит несколько параметров с одинаковым именем.(В обычном режиме ошибки нет.)
  • В строгом режиме восьмеричные литералы не допускаются (это литералы , начинающиеся с 0x.(В обычном режиме некоторые реализации допускают восьмеричные литералы.)
  • В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова.Вы не можете изменить их значение, не можете присвоить им значение и не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
  • В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызвать TypeError в функции в строгом режиме.Кроме того, некоторые свойства вызывающего объекта и аргументов функций в строгом режиме вызывают TypeError когда вы пытаетесь их прочитать.

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

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

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

Предотвращает объявление глобальной переменной:

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

function Tree(typeOfTree) {
    var age;
    var leafCount;

    age = typeOfTree.age;
    leafCount = typeOfTree.leafCount;
    nameoftree = typeOfTree.name;
};

var tree1 = new Tree(tree1Data);
console.log(window);

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

Неперехваченная ошибка ссылки:nameoftree не определено

Образец

Устраняет with заявление :

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

Образец

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

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

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

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

Есть еще несколько, но мне нужно получить больше знаний по этому вопросу.

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

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

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

  • Прокладывая путь для будущих версий 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).

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

    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() { }

Источники:

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

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

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

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

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

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

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

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

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

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

Цитирую из w3schools:

Директива "использовать строго"

Директива "использовать строго" является новой в JavaScript 1.8.5 (ECMAScript версия 5).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 был введен в ECMAScript 5 и хранился с тех пор.

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

  • Глобальный код является кодом строгого режима, если он начинается с пролога директивы, который содержит директиву Use Strict (см. 14.1.1).
  • Код модуля - это всегда код строгого режима.
  • Все части a Объявление класса или a Классовое выражение являются кодом строгого режима.
  • Код Eval является кодом строгого режима, если он начинается с пролога директивы, который содержит директиву Use Strict, или если вызов eval является прямым eval (см. 12.3.4.1), который содержится в коде строгого режима.
  • Код функции является кодом строгого режима, если связанный Объявление функции, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition или ArrowFunction содержится в коде строгого режима или если код, который выдает значение внутреннего слота функции [[ECMAScriptCode]], начинается с пролога директивы, который содержит директиву Use Strict.
  • Функциональный код, который предоставляется в качестве аргументов встроенным конструкторам функции и генератора, является кодом строгого режима, если последним аргументом является строка, которая при обработке является Функциональное тело это начинается с пролога директивы, который содержит директиву Use Strict.

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

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

    function useStrictDemo(){
 'use strict';
 //works fine
 var a = 'No Problem';

 //does not work fine and throws error
 k = "problem"

 //even this will throw error
 someObject = {'problem': 'lot of problem'};
}
  2. N.B:В "use strict" директива распознается только в начале скрипта или функции.

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

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

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

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

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

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

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

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

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

  1. показывает ошибку, если вы пытаетесь присвоить значение необъявленной переменной

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

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

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

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

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

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

  • Предотвращает случайные глобальные изменения

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

  • Устраняет с

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

  • Более безопасная оценка()

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

вы также можете прочитать это Статья для получения подробной информации

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

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

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

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

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

Недостаток

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

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

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

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

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

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

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

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

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

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

"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

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

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top