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

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

Проблема с символом строки 1: Отсутствует инструкция "use strict".

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

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

Может ли какой-либо из текущих браузеров отвечать на строку "use strict"; или использовать ее для использования в будущем?

6551
задан Mark Rogers 26 авг. '09 в 19:10
источник поделиться

27 ответов

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

Чтобы процитировать некоторые интересные части:

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

и

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

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

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

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

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

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

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

4296
ответ дан Pascal MARTIN 26 авг. '09 в 19:15
источник поделиться

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

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

"use strict";

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

1081
ответ дан seth 26 авг. '09 в 19:14
источник поделиться

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

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

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

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

  • Попытки удалить отказоустойчивые свойства будут бросать (delete Object.prototype)

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

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

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

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

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

  • Запрет удалять простые имена (delete x;)

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

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

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

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

488
ответ дан gprasant 25 нояб. '14 в 0:22
источник поделиться

Если люди обеспокоены использованием 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.
*/
354
ответ дан Jamie Hutber 16 июля '12 в 2:25
источник поделиться

Слово предостережения, все программисты с жесткой зарядкой: применение "use strict" к существующему коду может быть опасным! Эта вещь не какая-то приятная, счастливая наклейка, которую вы можете похлопать по коду, чтобы сделать ее "лучше". С помощью прагмы "use strict" браузер внезапно закроет исключения в случайных местах, которые он никогда не бросал раньше, просто потому, что в этом месте вы делаете то, что позволяет по умолчанию/свободно JavaScript, но строгий JavaScript не нравится! У вас могут быть нарушения строгости, скрывающиеся в редко используемых вызовах вашего кода, которые будут генерировать исключение только тогда, когда они в конечном итоге будут запущены - скажем, в производственной среде, которую используют ваши платежные клиенты!

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

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

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

174
ответ дан DWoldrich 03 марта '14 в 10:37
источник поделиться

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

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

'use strict';

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

Рассмотрим следующий пример:

var a = 365;
var b = 030;

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

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


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

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

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


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

  • Вставьте оператор 'use strict'; поверх script:

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

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

  • Или вставьте оператор 'use strict'; поверх своего тела функции:

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

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


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

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

Масштаб

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

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

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

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

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

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

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

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

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

восьмиштырьковый

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

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

Et cetera

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

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


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

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

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


Дополнительная литература

122
ответ дан Krumia 29 янв. '16 в 14:35
источник поделиться

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

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

Например,

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

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

119
ответ дан Pank 05 июля '13 в 22:38
источник поделиться

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

Дополнительную информацию можно найти в документации MDN.

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

Директивы аналогичны операторам, но разные.

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

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

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

  • Вы не можете использовать with -statement в строгом режиме.
  • В строгом режиме все переменные должны быть объявлены: если вы присваиваете значение идентификатору, который не был объявлен как переменная, функция, параметр функции, параметр catch-clause или свойство глобального Object, тогда вы будете получите ReferenceError. В нормальном режиме идентификатор объявляется неявно как глобальная переменная (как свойство глобального Object)
  • В строгом режиме ключевое слово this имеет значение undefined в функциях, которые вызывались как функции (а не как методы). (В нормальном режиме this всегда указывает на глобальный Object). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • Также, когда функция вызывается с call() или apply в строгом режиме, тогда this - это точно значение первого аргумента вызова call() или apply(). (В обычном режиме null и undefined заменяются глобальным Object, а значения, которые не являются объектами, преобразуются в объекты.)

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

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

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

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

Неподготовлено ReferenceError: nameoftree не определено

Sample

Устраняет оператор with:

Операторы

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

Sample

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

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

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

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

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

71
ответ дан Shubh 21 окт. '14 в 16:31
источник поделиться

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

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

52
ответ дан Stephen 10 марта '12 в 6:31
источник поделиться

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

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

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

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

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

46
ответ дан Renganathan M G 27 марта '14 в 15:18
источник поделиться

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

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

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

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

44
ответ дан user2436758 31 мая '13 в 21:29
источник поделиться

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

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

Источники:

38
ответ дан zangw 23 дек. '15 в 6:10
источник поделиться

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

37
ответ дан Placeholder 05 сент. '14 в 15:53
источник поделиться

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

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

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

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

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

Зачем нужен строгий режим?

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

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

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

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

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

Пожалуйста, обратитесь к...

http://www.w3schools.com/js/js_strict.asp

... узнать больше

29
ответ дан Mehul Singh 29 апр. '15 в 13:10
источник поделиться

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

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

26
ответ дан FutureNerd 29 марта '14 в 3:47
источник поделиться

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

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

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

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

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

Примеры использования "use strict" :
Строгий режим для функций: Аналогично, для вызова строгого режима для функцию, поставьте точное утверждение "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) цельный script строгий режим

'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

Для получения дополнительной информации посетите эту страницу здесь

19
ответ дан Alireza 22 мая '17 в 15:38
источник поделиться

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

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

  • Глобальный код - это строгий режимный код, если он начинается с директивы Prologue, содержащей директиву Use Strict (см. раздел 14.1.1).
  • Модуль кода всегда является строгим режимом режима.
  • Все части ClassDeclaration или ClassExpression являются строгим кодом режима.
  • Eval code - это строгий режимный код, если он начинается с директивного пролога, содержащего директиву Use Strict, или если вызов eval является прямым eval (см. 12.3.4.1), который содержится в коде строгого режима.
  • Код функции - это строгий режимный код, если связанное с ним FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition или ArrowFunction содержится в коде строгого режима, или если код, который генерирует значение внутреннего словаря [[ECMAScriptCode]], начинается с директивный пролог, содержащий директиву Use Strict.
  • Код функции, который предоставляется в качестве аргументов встроенным конструкторам Function и Generator, является строгим кодом режима, если последним аргументом является String, который при обработке является FunctionBody, который начинается с директивного пролога, содержащего директиву Use Strict.
15
ответ дан Oriol 12 апр. '16 в 3:25
источник поделиться

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

8
ответ дан Просто программист 18 мая '16 в 1:31
источник поделиться

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

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

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
8
ответ дан Tân Nguyễn 22 авг. '16 в 0:43
источник поделиться

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

8
ответ дан PippoApps.com 03 мая '16 в 15:59
источник поделиться

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

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

    function useStrictDemo(){
     'use strict';
     //works fine
     var a = 'No Problem';
    
     //does not work fine and throws error
     k = "problem"
    
     //even this will throw error
     someObject = {'problem': 'lot of problem'};
    }
    
  • N.B: Директива "use strict" распознается только в начале script или функции.
  • Строка "arguments" не может использоваться как переменная:

    "use strict";
    var arguments = 3.14;    // This will cause an error
    
  • Ограничит использование ключевых слов в качестве переменных. Попытка использовать их будет бросать ошибки.

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

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

8
ответ дан Pritam Banerjee 18 нояб. '16 в 12:53
источник поделиться

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

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

7
ответ дан Bikash Chapagain 20 нояб. '16 в 19:23
источник поделиться

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

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

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

  • Устраняет с помощью

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

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

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

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

7
ответ дан Wesam Ziadat 17 окт. '16 в 16:59
источник поделиться

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

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

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

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

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

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

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

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

6
ответ дан Rabin Pantha 11 нояб. '16 в 8:40
источник поделиться

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

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

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

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

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

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

  • В строгом режиме любое присвоение неписанному ресурсу, a свойство getter-only, несуществующее свойство, несуществующий переменная или несуществующий объект, выдает ошибку.

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

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

Объекты также являются переменными.

Использование объекта, не объявляя его, не допускается:

  "use strict";
  x = {p1:10, p2:20};      // This will cause an error

Удаление переменной (или объекта) не разрешено.

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

Из соображений безопасности eval() не может создавать переменные в области, из которой она была вызвана:

"use strict";
 eval ("var x = 2");
 alert (x);               // This will cause an error

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

"use strict" распознается только в начале script.

4
ответ дан Adds 20 февр. '17 в 22:58
источник поделиться

"use strict" - строгий режим javascript, представленный в ECMA5. Это необязательно. Режим javascript по умолчанию - режим sloopy. Строгий режим добавляет некоторые строгие правила в javascript, для exp.

  • декларация var обязательна после строгого использования.
  • октальная декларация не допускается, т.е. мы не можем объявлять числа, начинающиеся с 0, например, 010 не разрешено, но разрешено 10.
-1
ответ дан Avinash Malhotra 02 дек. '17 в 20:06
поделиться

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