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

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

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

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

Так что же "use strict"; все о том, что это означает, и это все еще актуально?

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

Источник

34 ответа

Решение

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

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

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

А также:

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

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

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

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code...

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

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

В настоящее время он поддерживается всеми основными браузерами (панель IE 9 и ниже).

Источник

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

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

"use strict";

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

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

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

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

В Си было выбрано крайне неудачное представление восьмеричности: ведущий ноль. Так что в С, 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

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

Источник

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

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

Например,

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

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

Источник

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

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

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

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

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

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

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

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

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

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

Образец

Исключает with заявление:

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

Образец

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

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

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

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

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

Источник

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

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

Источник

При добавлении "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() { }

Источники:

Источник

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

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

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

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

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

Источник

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

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

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

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

Источник

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

Источник

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

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

Директива "use strict" появилась в 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:

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

Источник

Некоторые люди, которые были в комитете ECMAScript, хорошо говорят: " Изменения в JavaScript, часть 1: ECMAScript 5" о том, как постепенно использовать "use strict" Переключатель позволяет разработчикам 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:

  • Глобальный код - это код строгого режима, если он начинается с Пролога Директивы, который содержит Директиву Строгого Использования (см. 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.
Источник

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

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

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

Источник

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

Источник

JavaScript "строгий" режим вводится в ECMAScript 5.

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

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

(i) показывает ошибку, если вы пытаетесь присвоить необъявленную переменную

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

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

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

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

Источник

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

Источник

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

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

Источник

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

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

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

  • Устраняет с

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

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

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

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

Источник

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

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

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

Недостаток

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

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

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

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

Источник

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

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

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

      let o = {
  name: 'John Doe',
  sayName: function(){
    console.log(this.name);
  }
};

o.sayName(); // 'John Doe'

не имеет цели вне контекста метода, но все функции JavaScript имеют ключевое слово, независимо от того, являются они методами или нет:

      function run() {
  console.log(this);
}

run(); // Window

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

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

      "use strict"

function run() {
  console.log(this);
}

run(); // undefined

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

Источник

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

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

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

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

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

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

"use strict"
function getname(){
    name = "stackru"; // 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

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

Источник

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

Считается ли это одним из лучших практик?

Да, включение строгого режима считается частью лучших практик при работе с javascript. Это делается путем добавления следующей строки кода в ваш JS файл.

'use strict';

в вашем коде.

Что это значит для пользовательских агентов?

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

Например: рассмотрите в своем.js у вас есть следующий код:

Сценарий 1: [БЕЗ СТРОГОГО РЕЖИМА]

var city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

Сценарий 2: [БЕЗ СТРОГОГО РЕЖИМА]

city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

Так почему же имя переменной печатается в обоих случаях?

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

Сценарий 3: [СТРОГОЙ РЕЖИМ]

'use strict';

city = "Chicago"
console.log(city) // Reference Error: asignment is undeclared variable city.

Дополнительный совет: чтобы поддерживать качество кода в строгом режиме, вам не нужно писать это снова и снова, особенно если у вас несколько.jsфайл. Вы можете применить это правило глобально вeslint правила следующие:

Имя файла: .eslintrc.js

module.exports = {
    env: {
        es6: true
    },
    rules : {
        strict: ['error', 'global'],
        },
    };

Итак, что запрещено в строгом режиме?

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

  • Удаление переменной, функции или аргумента запрещено в строгом режиме.

    "use strict";
 function x(p1, p2) {}; 
 delete x; // This will cause an error

  • Дублирование имени параметра является не допускаются в строгом режиме.

     "use strict";
 function x(p1, p1) {};   // This will cause an error

  • Зарезервированные слова на языке Javascript не допускаются в строгом режиме. Слова - это интерфейс реализации, пусть, пакеты, частный, защищенный, общедоступный. static и yield

Для более полного списка ознакомьтесь с документацией MDN здесь: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode

Источник

Строгий режим включает строгие функции в движке v8. Краткий пример некоторых функций:

Вы можете включить его глобально, написав:

      'use strict'; // strict mode enabled!

Для каждой функции, которую вы просто включаете в функцию:

      let myfunc = () => {
  'use strict'; // strict mode enabled
  
   b = 0; // broke
}
  • Вы ДОЛЖНЫ объявить переменную перед ее использованием (в здравом уме):
        var x;
  x = '0'; // ok
  y = '';  // not ok

  • Функции es6 включены (это зависит от браузера), для узла v4+ это важно.

  • Производительность в некоторых случаях лучше.

Есть и другие функции, проверьте здесь , чтобы узнать больше!

Источник
Другие вопросы по тегам