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

Строгий режим (директива "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 через Crockford JSLint , и он дал следующую ошибку:

Problem at line 1 character 1: Missing "use strict" statement.

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

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

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

30 ответов

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

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

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

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

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

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

// Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code...

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

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

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

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

"use strict";

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

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

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

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

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

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

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

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

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

Запрещающий with ключевым словом

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

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

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

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

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

Если люди обеспокоены use strict возможно, стоит проверить эту статью:

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

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

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

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

Вставить "use strict"; в верхней части вашего скрипта:

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

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

Или вставьте "use strict"; утверждение сверху вашего тела функции:

Function doSomething() { "use strict"; ... }

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

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

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

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

Например,

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

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

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

"use strict" директиву, введенную в ECMAScript 5.

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

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

use strict директива use strict указывает, что следующий код (в скрипте или функции) является строгим кодом. Код на самом высоком уровне скрипта (код, который не находится в функции) считается строгим кодом, когда скрипт содержит use strict директиву use strict . Содержание функции считается строгим кодом, когда сама функция определена в строгом коде или когда функция содержит use strict директиву use strict . Код, передаваемый методу eval() считается строгим кодом, когда eval() вызывается из строкового кода или содержит use strict директиву 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 в функции в строгом режиме. Кроме того, некоторые свойства caller- и аргументы функций в строгом режиме вызывают 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.

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

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

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

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

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

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

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

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

Прокладывая путь к будущим версиям ECMAScript, используя одно из новых зарезервированных ключевых слов (в предвидении для ECMAScript 6): implements , interface , let , package , private , protected , public , static и yield .

Объявление функции в блоках

If(a