Use strict javascript что это, ошибка ява скрипт. Как строгий режим "use strict" в JavaScript может сэкономить вам пару часов Что есть ложь в JavaScript

Строгий режим (директива "use strict") - очень хорошее явление в JavaScript и начать с ним работать очень просто!

Как его применить // file.js "use strict" function doStuff () { // строгий режим активирован }

В описанном выше примере строгий режим применяется по всему коду в файле file.js .

Если вы хотите подключить его только внутри функции, используйте следующий пример:

// file.js function a () { "use strict" ; // строгий режим активирован только для кода внутри функции function nestedFunction () { // и будет также применяться внутри вложенной функции } } Преимущества Продублированные ключи в объекте var zombie = { eyeLeft: 0 , eyeRight: 1 , // … много ключей … eyeLeft: 1 }

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

Переменные без var plane = 5 ;

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

Только представьте переменную i , объявленную глобально. Это может внести беспорядок во все вложенные циклы в приложении.

Продублированные аргументы {}

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

Чем чревата подобная ошибка:

function run (fromWhom, fromWhom ) {alert(fromWhom)} run(1 , 2 ); // alert: 2 Фиксация arguments внутри функции var run = function (fromWhom ) { arguments = "alien" ; alert(fromWhom); } run("zombie" ); // alert: "alien";

Если использовать строгий режим:

var run = function (fromWhom ) { "use strict" ; arguments = "alien" ; alert(fromWhom); } run("zombie" ); // alert: "zombie";

Насколько неочевидным является то, что при изменении аргументов (arguments = "alien") изменяется именованный аргумент fromWhom ? Директива "use strict" спасёт вас из этого затруднительного положения.

WoollyMittens , пользователь reddit в комментариях предложил:

Вместе со строгим режимом можно установить “linter” (http://www.jshint.com/), что бы избежать глупых ошибок даже до запуска кода. Для большинства редакторов есть соответствующий плагин. Вы можете считать это теми самыми красными волнистыми линиями, которыми подчеркиваются ваши грамматические ошибки, когда вы пишете email, но применительно к коду.

Скоро я поясню как можно это все автоматизировать с помощью grunt.

loz220 , пользователь reddit в

JavaScript - Strict mode

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

Иногда вы увидите нестандартный режим по умолчанию, называемый « sloppy mode » . Это не официальный термин, но помните об этом, на всякий случай.

(function() { "use strict"; false.true = ""; // TypeError (14).sailing = "home"; // TypeError "with".you = "far away"; // TypeError })();

Упрощение использования переменных

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

Во-первых, строгий режим запрещается. Проблема заключается в том, что любое имя внутри блока может отображать либо свойство переданного ему объекта, либо переменную в окружении (или даже глобальную) во время выполнения: это невозможно заранее узнать. Строгий режим выполняется with синтаксической ошибкой, поэтому нет возможности для имени в a, которое ссылается на неизвестное местоположение во время выполнения:

"use strict"; var x = 17; with (obj) { // !!! syntax error // If this weren"t strict mode, would this be var x, or // would it instead be obj.x? It"s impossible in general // to say without running the code, so the name can"t be // optimized. x; }

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

Во-вторых, . В обычном коде eval("var x;") вводится переменная x в окружающую функцию или глобальную область. Это означает, что, вообще говоря, в функции, содержащей вызов eval каждое имя, не относящееся к аргументу или локальной переменной, должно отображаться в конкретное определение во время выполнения (поскольку этот eval мог бы ввести новую переменную, которая скроет внешнюю переменную). В строгом режиме eval создает переменные только для оцениваемого кода, поэтому eval не может повлиять на то, ссылается ли имя на внешнюю переменную или на некоторую локальную переменную:

Var x = 17; var evalX = eval(""use strict"; var x = 42; x;"); console.assert(x === 17); console.assert(evalX === 42);

Если функция eval вызывается выражением формы eval(...) в коде строгого режима, код будет оцениваться как строгий код режима. Код может явно ссылаться на строгий режим, но это необязательно.

Function strict1(str) { "use strict"; return eval(str); // str will be treated as strict mode code } function strict2(f, str) { "use strict"; return f(str); // not eval(...): str is strict if and only // if it invokes strict mode } function nonstrict(str) { return eval(str); // str is strict if and only // if it invokes strict mode } strict1(""Strict mode code!""); strict1(""use strict"; "Strict mode code!""); strict2(eval, ""Non-strict code.""); strict2(eval, ""use strict"; "Strict mode code!""); nonstrict(""Non-strict code.""); nonstrict(""use strict"; "Strict mode code!"");

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

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

"use strict"; var x; delete x; // !!! syntax error eval("var y; delete y;"); // !!! syntax error

Упрощение eval и arguments

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

Во-первых, имена eval и arguments не могут быть связаны или назначены в синтаксисе языка. Все эти попытки - синтаксические ошибки:

"use strict"; eval = 17; arguments++; ++eval; var obj = { set p(arguments) { } }; var eval; try { } catch (arguments) { } function x(eval) { } function arguments() { } var y = function eval() { }; var f = new Function("arguments", ""use strict"; return 17;");

Во-вторых, строгий код режима не поддерживает свойства объектов arguments созданных в нем. В нормальном коде внутри функции, первым аргументом которой является arg , параметр arg также устанавливает arguments и наоборот (если аргументы не предоставлены или arguments удалены). объекты arguments для функций строгого режима хранят исходные аргументы при вызове функции. arguments[i] не отслеживает значение соответствующего именованного аргумента, равно как и именованный аргумент не отслеживает значение в соответствующих arguments[i] .

Function f(a) { "use strict"; a = 42; return ; } var pair = f(17); console.assert(pair === 42); console.assert(pair === 17);

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

"use strict"; var f = function() { return arguments.callee; }; f(); // throws a TypeError

«Защита» JavaScript

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

Во-первых, значение, переданное как функция функции в строгом режиме, не принудительно превращается в объект (он же «в коробке»). Для нормальной функции this всегда объект: либо предоставленный объект, если он вызван с объектно-значным; значение, в штучной упаковке, если вызывается с булевым, строковым или числом this ; или глобальный объект, если он вызван с undefined или null this . (Используйте call , apply или bind чтобы указать конкретное this .) Не только автоматический бокс для производительности, но и отображение глобального объекта в браузерах является угрозой безопасности, поскольку глобальный объект обеспечивает доступ к функциям, которые «защищают» среды JavaScript должны ограничить. Таким образом, для функции строгого режима указанное this не помещается в объект в объект, а если не указано, this будет undefined:

"use strict"; function fun() { return this; } console.assert(fun() === undefined); console.assert(fun.call(2) === 2); console.assert(fun.apply(null) === null); console.assert(fun.call(undefined) === undefined); console.assert(fun.bind(true)() === true);

Это означает, среди прочего, что в браузерах уже невозможно ссылаться на объект window через this внутри функции строгого режима.

Во-вторых, в строгом режиме уже невозможно «ходить» по стеклу JavaScript через общепринятые расширения в ECMAScript. В нормальном коде с этими расширениями, когда функция fun находится в середине fun.caller , fun.caller - это функция, которая в последнее время называется fun , а fun.arguments - это arguments для этого вызова fun . Оба расширения являются проблематичными для «безопасного» JavaScript, поскольку они позволяют «защищенному» коду получить доступ к «привилегированным» функциям и их (потенциально необеспеченным) аргументам. Если fun находится в строгом режиме, как fun.caller и fun.arguments - не fun.caller fun.arguments свойства, которые бросаются при установке или извлечении:

Function restricted() { "use strict"; restricted.caller; // throws a TypeError restricted.arguments; // throws a TypeError } function privilegedInvoker() { return restricted(); } privilegedInvoker();

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

"use strict"; function fun(a, b) { "use strict"; var v = 12; return arguments.caller; // throws a TypeError } fun(1, 2); // doesn"t expose v (or a or b)

Проложить путь для будущих версий ECMAScript

Будущие версии ECMAScript, скорее всего, введут новый синтаксис, а строгий режим в ECMAScript 5 применяет некоторые ограничения для облегчения перехода. Будет легче внести некоторые изменения, если основы этих изменений запрещены в строгом режиме.

Во-первых, в строгом режиме короткий список идентификаторов становится зарезервированными ключевыми словами. Эти слова являются implements , interface , let , package , private , protected , public , static и yield . В строгом режиме вы не можете назвать или использовать переменные или аргументы с этими именами.

Function package(protected) { // !!! "use strict"; var implements; // !!! interface: // !!! while (true) { break interface; // !!! } function private() { } // !!! } function fun(static) { "use strict"; } // !!!

Два предостережения, специфичные для Mozilla: во-первых, если ваш код равен 1,8 или более (например, в хром-коде или при использовании права ) и является строгим кодом режима, let и let функции, которые они имеют так как эти ключевые слова были впервые введены. Но строгий режимный код в Интернете, загруженный или ... , не сможет использовать let / yield качестве идентификаторов. Во-вторых, в то время как ES5 безоговорочно резервирует слова class , enum , export , extends , import и super , прежде чем Firefox 5 Mozilla зарезервирует их только в строгом режиме.

Во-вторых, . В нормальном режиме в браузерах операторы функций разрешены «везде». Это не часть ES5 (или даже ES3)! Это расширение с несовместимой семантикой в ​​разных браузерах. Обратите внимание, что в ES2015 допустимы утверждения функций за пределами верхнего уровня.

"use strict"; if (true) { function f() { } // !!! syntax error f(); } for (var i = 0; i < 5; i++) { function f2() { } // !!! syntax error f2(); } function baz() { // kosher function eit() { } // also kosher }

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

Строгий режим в браузерах

Основные браузеры теперь реализуют строгий режим. Тем не менее, не слепо зависеть от него, так как все еще существуют многочисленные версии браузера, используемые в дикой природе, которые имеют частичную поддержку строгого режима или вообще не поддерживают его (например, Internet Explorer ниже версии 10!). Строгий режим изменяет семантику. Опора на эти изменения приведет к ошибкам и ошибкам в браузерах, которые не реализуют строгий режим. Соблюдайте осторожность при использовании строгого режима и поддерживайте уверенность в строгом режиме с функциональными тестами, которые проверяют, применяются ли соответствующие части строгого режима. Наконец, обязательно проверьте свой код в браузерах, которые выполняют и не поддерживают строгий режим . Если вы тестируете только в браузерах, которые не поддерживают строгий режим, вы, скорее всего, будете иметь проблемы с браузерами, которые это делают, и наоборот.

В этой статье мы рассмотрим одну из важнейших функциональностей JavaScript , называемую "строгим режимом" (strict mode ).

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

Использование "strict mode "

Чтобы начать выполнять код в строгом режиме, нам нужно использовать директиву «use strict». Это просто выражение. Эта директива поддерживается в JavaScript 1.8.5 (ECMAScript 5 ) или выше.

Использование директивы «use strict»

Существует два способа использования директивы «use strict» . Мы можем использовать ее или внутри объявления функции в самом начале или в глобальном объявлении – в начале файла.
Когда мы используем режим «strict mode » как глобальную директиву, весь код javascript на странице выполняется в строгом режиме. Например:

Function print(value) {
console.log (value);
}

Когда мы используем «use strict» внутри объявления функции, весь код внутри функции выполняется в строгом режиме. Весь другой код вне функции выполняется в обычном режиме.
Например:

Function print(value) {
"use strict"
console.log (value);
}

Function print_twice(value) {
console.log (value);
console.log (value);
}

Что мы не можем сделать в строгом режиме: Использование необъявленной переменной

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

"use string"
a = 12; // выбрасывается исключение в строгом режиме. В нестрогом режиме создается новое свойство для объекта window.

Оператор delete

Оператор delete используется для удаления пользовательских свойств у объекта и элементов массива. Если мы попытаемся удалить что-либо, кроме определенных пользователем свойств объекта или элементов массива, мы получим исключение.

Var a = 78;
window.b = 34;

Function print () {}
window.c = function () {}

Delete a; // генерирует исключение в строгом режиме. В стандартном режиме он возвращает false и программа продолжает работу

Delete window.a; // генерирует исключение в строгом режиме. В нестандартном режиме он возвращает false и программа продолжается.

Delete window.b; // В обоих режимах свойство b удаляется
.
delete Math.PI; // В нестрогом режиме он возвращает false, поскольку PI предварительно определен. В строгом режиме - исключение.

Delete Object.prototype; // удаление встроенного свойства в нестрогом режиме возвращает false. Но в строгом режиме выбрасывается исключение.

Просто помните, что везде, где delete возвращает false в нестрогом режиме, он выдает исключение в строгом режиме.

Многократное объявление свойств

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

Var myObject = {property1: 1, property2: 2, property1: 1}; // генерирует исключение.

На этом все, а в следующей статье мы продолжим изучать директиву JavaScript "use strict".

Эта директива пишется в начале сценария или функции. Так и пишется:

И для чего же она нужна? Все что ниже директивы "use strict" , является строгим кодом. Строгий, это код, написанный по новому стандарту. Например, в старом стандарте можно было не объявлять переменную, а в новом нужно объявлять.

"use strict";
a = 10; // Ошибка: переменная не объявлена
document.write(a);

А так будет работать, если объявить переменную:

Var a;
"use strict";
a = 10;
document.write(a);

Эти пункты взяты из книги: "Дэвид Флэнаган - JavaScript. Подробное руководство (6-е издание)"

• В строгом режиме не допускается использование инструкции with .
• В строгом режиме все переменные должны объявляться: если попытаться присвоить значение идентификатору, который не является объявленной переменной, функцией, параметром функции, параметром конструкции catch или свойством глобального объекта, возбуждается исключение ReferenceError . (В нестрогом режиме такая попытка просто создаст новую глобальную переменную и добавит ее в виде свойства в глобальный объект.)
• В строгом режиме функции, которые вызываются как функции (а не как методы), получают в ссылке this значение undefined . (В нестрогом режиме функции, которые вызываются как функции, всегда получают в ссылке this глобальный объект.) Это отличие можно использовать, чтобы определить, поддерживает ли та или иная реализация строгий режим: var hasStrictMode = (function() { "use strict"; return this===undefined}()); Кроме того, когда функция вызывается в строгом режиме с помощью call() или apply() , значение ссылки this в точности соответствует значению, переданному в первом аргументе функции call() или apply() . (В нестрогом режиме значения null и undefined замещаются ссылкой на глобальный объект, а простые значения преобразуются в объекты.)
• В строгом режиме попытки присвоить значения свойствам, недоступным для записи, или создать новые свойства в нерасширяемых объектах порождают исключение TypeError . (В нестрогом режиме эти попытки просто игнорируются.)
• В строгом режиме программный код, передаваемый функции eval() , не может объявлять переменные или функции в области видимости вызывающего программного кода, как это возможно в нестрогом режиме. Вместо этого переменные и функции помещаются в новую область видимости, создаваемую для функции eval() . Эта область видимости исчезает, как только eval() вернет управление.
• В строгом режиме объект arguments в функции хранит статическую копию значений, переданных функции. В нестрогом режиме объект arguments ведет себя иначе – элементы массива arguments и именованные параметры функции ссылаются на одни и те же значения.
• В строгом режиме возбуждается исключение SyntaxError , если оператору delete передать неквалифицированный идентификатор, такой как имя переменной, функции или параметра функции. (В нестрогом режиме такое выражение delete не выполнит никаких действий и вернет false .)
• В строгом режиме попытка удалить ненастраиваемое свойство приведет к исключению TypeError . (В нестрогом режиме эта попытка просто завершится неудачей и выражение delete вернет false .)
• В строгом режиме попытка определить в литерале объекта два или более свойств с одинаковыми именами считается синтаксической ошибкой. (В нестрогом режиме ошибка не возникает.)
• В строгом режиме определение двух или более параметров с одинаковыми именами в объявлении функции считается синтаксической ошибкой. (В нестрогом режиме ошибка не возникает.)
• В строгом режиме не допускается использовать литералы восьмеричных целых чисел (начинающихся с 0, за которым не следует символ x). (В нестрогом режиме некоторые реализации позволяют использовать восьмеричные литералы.)
• В строгом режиме идентификаторы eval и arguments интерпретируются как ключевые слова, и вы не можете изменить их значения. Вы сможете присвоить значения этим идентификаторам, объявив их как переменные, использовав их в качестве имен функций, имен параметров функций или идентификаторов блока catch .
• В строгом режиме ограничивается возможность просмотра стека вызовов. Попытки обратиться к свойствам arguments.caller arguments.callee и в строгом режиме возбуждают исключение TypeError . Попытки прочитать свойства caller и arguments функций в строгом режиме также возбуждают исключение TypeError . (Некоторые реализации определяют эти свойства в нестрогих функциях.)

(далее в статье Strict Mode). Strict Mode накладывает слой ограничений на JavaScript, он отгораживает вас от опасных частей языка (те части, которые есть исторически, но лучше чтобы их не было) и позволяет снизить вероятность ошибки.

Пока читал эту статью я написал 38 тестов, покрывающих все правила Strict Mode, объявленные в спецификации ES5. Вы можете посмотреть насколько ваш браузер поддерживает эти справила .

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

Firefox 4 уже полностью поддерживает Strict Mode, а Chrome 11 практически полностью. Strict Mode уже не за горами - давайте изучим его подробнее!

Как включить Strict Mode? Если добавить "use strict" в начало вашего JavaScript кода, то Strict Mode будет применен для всего кода:
"use strict"; 012; //Восьмеричный литерал запрешен. Выбросит исключение SyntaxError в Strict Mode
В качестве альтернативы вы можете включить Strict Mode только в отдельной функции, добавив "use strict" в начало тела вашей функции:
012; //Нет ошибки (Strict Mode не включен глобально) function foo() { "use strict"; x=3; //Strict Mode выбросит исключение - запрещено неявно создавать глобальные переменные } foo(); //ReferenceError (Strict Mode включен для функции) Наследуют ли внутренние функции Strict Mode от внешних функций? Внутренняя функция, объявленная внутри внешней, в которой включен Strict Mode тоже будет иметь Strict Mode:
var wrapper = function(fn) { "use strict"; var deleteNonConfigurable = function () { var obj = {}; Object.defineProperty(obj, "name", { configurable: false }); delete obj.name; // Выбросит исключение TypeError в Strict Mode } return deleteNonConfigurable; } wrapper()(); //TypeError (Strict Mode включен)
Важно запомнить, что Strict Mode не распространяется на «нестрогие» (ориг. non-strict) функции, которые выполняются внутри строгой функции (или они отправлены в функцию в качестве аргументов или выполняются, используя call или apply):
var test = function(fn) { "use strict"; fn(); } var deleteNonConfigurable = function () { var obj = {}; Object.defineProperty(obj, "name", { configurable: false }); delete obj.name; // Выбросит исключение TypeError в Strict Mode } test(deleteNonConfigurable); //нет ошибки (Strict Mode не применялся) Почему я не могу включить Strict Mode в консоли моего браузера? Когда выполняешь код в консоли фаербага или в других консолях использование "use strict" вне функции не имеет силы. Это потому, что большинство консолей обрамляют ваш код в eval"ом, поэтому ваш "use strict" не является первым выражением. Это можно обойти, обрамив ваш код в замыкание (IIFE), в начало которого мы положим "use strict" (но, когда я тестировал такой способ включения Strict Mode я понял, что это довольно неудобно, особенно если работать в консоли webkit developer tools - лучше тестировать ваш код на странице):
(function() { "use strict"; var a; var b; function bar() { x = 5; //Strict Mode выбросит исключение за попытку создания глобальной переменной } bar(); // ReferenceError (Strict Mode включен) })(); Что произойдет если мой браузер не поддерживает Strict Mode? Ничего. Директива "use strict" это обычное строковое выражение, которое будет проигнорировано всеми движками JavaScript, которые не поддерживают Strict Mode. Это позволяет безопасно использовать синтаксис Strict Mode во всех браузерах без каких-либо опасений, в то время когда браузеры имеющие поддержку Strict Mode будут использовать его.Какие правила включены в Strict Mode? Правила определены в спецификации Strict Mode и включают в себя ограничения во время «компиляции» и интерпретации (выполнения скрипта). Это вводный обзор (каждое правило я описал с примерами в следующем параграфе): ecma262-5.com/ELS5_HTML.htm#Annex_C Синтаксические ошибки Syntax Errors В большинстве случаев Strict Mode предотвращает выполнение подозрительного или нелегального кода в процессе загрузки. Восьмеричные числа, дубли имен переменных, некорректное использование delete и попытки сделать что-нибудь этакие с eval и ключевым словом arguments, использование with приведет к исключению SyntaxError.Слово this В Strict Mode объект this не будет корректироваться. Это возможно самая интересная часть Strict Mode и самая тяжелая(шокирующая) для разработчиков. Все знают, что если первый аргумент call или apply - null или undefined, то значение this выполняемой функции будет преобразование в глобальный объект (для браузеров это window).Прямое создание глобальных переменных Не все согласятся с этим, но непрямое создание глобального объекта почти всегда является ошибкой. В Strict Mode вам выдадут красную карточку - ReferenceError.arguments.caller и arguments.callee Эти «полезные свойства» (от пер. никогда не применял их) запрещены в Strict Mode. Если вы используете их в вашем кода, то Strict Mode выбросит исключение.Объявление существующего имени объекта Когда вы создаете объект с двумя одинаковыми ключами, то Strict Mode выбросит исключение TypeError.Тесты Вот исходник моих Strict Mode тестов. Каждый набор тестов снабжен комментарием, ссылающемся на часть спецификации ECMAScript, которую он тестирует. Эта версия может быть выполнена в «режиме консоли». Т.е. вы можете скопировать тест, вставить в консоль и выполнить без изменений. Этот же код, работающий в режиме «HTML» я использовал для создания тестовой страницы, которую я представил вам в начале статьи. Этот исходник с дополнительными объектами в моем github репозитории . Я уверен, что там есть пара ошибок - не стесняйтесь присылать ошибки!

От переводчика: тут в статье шел огромный кусок кода, закинул его на pastebin

Заключение Запрещение обращение к некоторым возможностям языка для улучшения кода - вопрос спорный, давайте отложим эти споры. В защиту Strict Mode я хочу сказать, что это отличный компромисс между тотальными переменами (которые сломают обратную совместимость) и ничего не деланием (которое приведет к захламлению языка и научит разработчиков плохому). ECMA-262 5th Edition: The Strict Mode of ECMAScript
Asen Bozhilov: Strict tester
Таблица совместимости с ECMAScript 5, часть посвященная Strict mode . Это отличный источник, часть большой таблицы совместимости, разработанной Юрием Зайцевым (Juriy Zaytsev aka «kangax»)

От переводчика. Strict Mode поддерживают практически половина всех браузеров, кроме своих прекрасных ограничений и иммунитету к распространенным ошибкам Strict Mode дает и другие преимущества (статья mraleph). Скоро неиспользование Strict Mode станет плохим тоном (аналогично requestAnimationFrame vs setTimeout). Сейчас самое время начать эксперименты!