В последнее время , я побежал некоторые из моего кода JavaScript через Крокфорд в JSLint , и он дал следующее сообщение об ошибке:
Проблема в строке 1, символ 1: отсутствует выражение «использовать строгий».
Сделав поиск, я понял, что некоторые люди добавляют "use strict";
в свой код JavaScript. Как только я добавил заявление, ошибка перестала появляться. К сожалению, Google не раскрыл большую часть истории этого строкового утверждения. Конечно, это как-то связано с тем, как браузер интерпретирует JavaScript, но я понятия не имею, каков будет эффект.
Так что же это такое "use strict";
, что это означает и все еще актуально?
Кто-нибудь из текущих браузеров отвечает на "use strict";
строку или это для будущего использования?
Эта статья о строгом режиме 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 (с операторами import
and export
) и классов ES6 строгий режим всегда включен и не может быть отключен.
"use strict"
в Firefox 3.6, Safari 5, Chrome 7 и Opera 10.6 (все Mac). Никаких ошибок, поэтому, я думаю, «использовать строгий» пока не поддерживается ни в одном браузере. Хотя в IE9 не тестировал;)Это новая функция ECMAScript 5. Джон Резиг написал хорошее резюме этого.
Это просто строка, которую вы помещаете в свои файлы JavaScript (либо вверху файла, либо внутри функции), которая выглядит следующим образом:
"use strict";
Размещение этого в вашем коде сейчас не должно вызывать никаких проблем с текущими браузерами, так как это всего лишь строка. Это может вызвать проблемы с вашим кодом в будущем, если ваш код нарушает прагму. Например, если у вас в данный момент нет foo = "bar"
определения foo
сначала, ваш код начнет давать сбой ... что на мой взгляд хорошо.
<script>"use strict";
. Флаг применяется только к блоку, в который он включен. 'use strict';
вместо"use strict";
, это не удастся вместо. Это имеет больше смысла, потому что если он добавляет его к глобальному объекту, это означает, что он может не сработать в следующий раз, когда вы запустите функцию / сделаете что-то еще, что сбрасывает блок, как это будет в самом высоком блоке (глобальном). Если вы используете браузер, выпущенный в прошлом году или около того, то, скорее всего, он поддерживает строгий режим JavaScript. Только старые браузеры до того, как ECMAScript 5 стал текущим стандартом, не поддерживают его.
Кавычки вокруг команды гарантируют, что код будет по-прежнему работать и в старых браузерах (хотя вещи, которые генерируют синтаксическую ошибку в строгом режиме, как правило, просто приводят к сбоям в работе сценария, что трудно обнаружить в старых браузерах).
Если люди беспокоятся об использовании, 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.
*/
window
this
которым вы не можете целиться window
? this
принадлежит своей функции, а не глобальному окнуthis
действительно есть undefined
. «Строгое использование»; это гарантия того, что программист не будет использовать плохие или плохие свойства JavaScript. Это руководство, так же как правитель поможет вам сделать прямые линии. «Use Strict» поможет вам сделать «прямое кодирование».
Те, кто предпочитает не использовать линейки для прямой обработки строк, обычно оказываются на тех страницах, где просят других отладить их код.
Поверь мне. Издержки незначительны по сравнению с плохо разработанным кодом. У Дуга Крокфорда, который несколько лет был старшим разработчиком JavaScript, есть очень интересный пост . Лично мне нравится все время возвращаться на его сайт, чтобы убедиться, что я не забыл свою хорошую практику.
Современная практика JavaScript всегда должна вызывать «Use Strict»; Прагма. Единственная причина, по которой группа ECMA сделала необязательный режим «Строгий», заключается в том, чтобы предоставить менее опытным кодировщикам доступ к JavaScript и дать время для адаптации к новым и более безопасным методам кодирования.
Я настоятельно рекомендую каждому разработчику начать использовать строгий режим сейчас. Существует достаточно браузеров, поддерживающих его, поэтому строгий режим на законных основаниях поможет нам уберечь нас от ошибок, о которых мы даже не подозревали в вашем коде.
По-видимому, на начальном этапе будут ошибки, с которыми мы никогда не сталкивались. Чтобы получить максимальную выгоду, мы должны провести надлежащее тестирование после перехода в строгий режим, чтобы убедиться, что мы все поймали. Определенно, мы не просто добавляем use strict
наш код и предполагаем, что ошибок нет. Таким образом, проблема в том, что пришло время начать использовать эту невероятно полезную языковую функцию для написания лучшего кода.
Например,
var person = {
name : 'xyz',
position : 'abc',
fullname : function () { "use strict"; return this.name; }
};
JSLint - это отладчик, написанный Дугласом Крокфордом. Просто вставьте ваш скрипт, и он быстро отыщет любые заметные проблемы и ошибки в вашем коде.
Осторожно, всем вам, программистам с высокой нагрузкой: применение "use strict"
к существующему коду может быть опасным! Это не какая-то приятная на ощупь наклейка с счастливым лицом, которую вы можете нанести на код, чтобы сделать его «лучше». С "use strict"
прагмой, браузер внезапно будет БРОСАТЬ исключения в случайных местах, которые он никогда не генерировал раньше, просто потому, что в этот момент вы делаете что-то, что по умолчанию / свободный JavaScript разрешает, но строгий JavaScript не терпит! Вы можете иметь нарушения строгости, скрывающие редко используемые вызовы в вашем коде, которые будут вызывать исключение только тогда, когда они в конечном счете запускаются - скажем, в производственной среде, которую используют ваши платящие клиенты!
Если вы собираетесь сделать решающий шаг, это хорошая идея применить "use strict"
наряду с комплексными модульными тестами и строго сконфигурированной задачей сборки JSHint, которая даст вам некоторую уверенность в том, что нет темного угла вашего модуля, который ужасно взорвется только потому, что вы включил строгий режим. Или, эй, вот еще один вариант: просто не добавляйте "use strict"
ни один из ваших устаревших кодов, это, честно говоря, возможно, безопаснее. Определенно НЕ добавляйте "use strict"
ни к каким модулям, которыми вы не владеете или не обслуживаете, например, к сторонним модулям.
Я думаю, что хотя это смертельно опасное животное, оно "use strict"
может быть хорошим, но вы должны делать это правильно. Лучшее время для строгой оценки - это когда ваш проект находится в стадии разработки, и вы начинаете с нуля. Сконфигурируйте JSHint/JSLint
все предупреждения и параметры, как можно более тесно связанные с вашей командой, получите хорошую систему сборки / тестирования / утверждения в виде фальшпола Grunt+Karma+Chai
, и только ТОГДА начните отмечать все ваши новые модули как "use strict"
. Будьте готовы вылечить множество ошибок и предупреждений. Убедитесь, что все понимают серьезность, настроив сборку на FAIL, если JSHint/JSLint
выдает какие-либо нарушения.
Мой проект не был новым проектом, когда я его принял "use strict"
. В результате моя среда IDE заполнена красными метками, потому что у меня нет "use strict"
половины моих модулей, и JSHint жалуется на это. Это напоминание мне о том, что рефакторинг я должен делать в будущем. Моя цель - освободиться от красной метки из-за всех моих пропущенных "use strict"
заявлений, но сейчас уже много лет.
"use strict";
в существующий код. При этом я почти всегда буду использовать его, когда пишу новый код с нуляСтрогий режим вносит несколько изменений в обычную семантику JavaScript:
устраняет некоторые тихие ошибки JavaScript, изменяя их на ошибки.
исправляет ошибки, мешающие движкам JavaScript выполнять оптимизацию.
запрещает некоторый синтаксис, который может быть определен в будущих версиях ECMAScript.
для получения дополнительной информации vistit строгий режим - Javascript
Некоторые люди, которые были в комитете ECMAScript, рассказали: « Изменения в JavaScript, часть 1: ECMAScript 5» о том, как постепенное использование "use strict"
переключателя позволяет разработчикам JavaScript очищать многие опасные функции JavaScript без внезапного взлома каждого веб-сайта. в мире.
Конечно, в нем также говорится о том, чем являются (были) многие из этих ошибок, и как ECMAScript 5 их исправляет.
Включение use strict
в начало всех ваших чувствительных файлов JavaScript с этой точки зрения - это небольшой способ стать лучшим программистом JavaScript и избежать случайного изменения глобальных переменных и изменения в молчании.
Мои два цента:
Одна из целей строгого режима - обеспечить более быструю отладку проблем. Это помогает разработчикам, создавая исключение, когда происходят определенные неправильные вещи, которые могут вызвать тихое и странное поведение вашей веб-страницы. В тот момент, когда мы используем use strict
код, он выдает ошибки, которые помогают разработчику заранее исправить это.
Несколько важных вещей, которые я узнал после использования use strict
:
Предотвращает объявление глобальной переменной:
var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};
function Tree(typeOfTree) {
var age;
var leafCount;
age = typeOfTree.age;
leafCount = typeOfTree.leafCount;
nameoftree = typeOfTree.name;
};
var tree1 = new Tree(tree1Data);
console.log(window);
Теперь этот код создается nameoftree
в глобальной области видимости, к которой можно получить доступ с помощью window.nameoftree
. Когда мы реализуем use strict
код будет выдавать ошибку.
Uncaught ReferenceError: nameoftree не определено
Исключает with
утверждение:
with
операторы не могут быть уменьшены с помощью таких инструментов, как uglify-js . Они также устарели и удалены из будущих версий JavaScript.
Предотвращает дубликаты:
Когда у нас есть повторяющееся свойство, оно выдает исключение
Uncaught SyntaxError: Дублирование свойства данных в литерале объекта не допускается в строгом режиме
"use strict";
var tree1Data = {
name: 'Banana Tree',
age: 100,
leafCount: 100000,
name:'Banana Tree'
};
Их немного, но мне нужно больше узнать об этом.
Этот оператор "use strict";
указывает браузеру использовать строгий режим, который представляет собой сокращенный и безопасный набор функций JavaScript.
Список функций (не исчерпывающий)
Запрещает глобальные переменные. (Ловит отсутствующие
var
объявления и опечатки в именах переменных)Тихие неудачные задания приведут к ошибке в строгом режиме (назначение
NaN = 5;
)Пытается удалить Undeletable свойства выбросит (
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 ]
window.foo = bar
). Директива об использовании строгих правил
Директива «use strict» появилась в JavaScript 1.8.5 (ECMAScript версии 5).
Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript.
Цель «использования строгого» - указать, что код должен выполняться в «строгом режиме».
В строгом режиме нельзя, например, использовать необъявленные переменные.
Почему строгий режим?
Строгий режим облегчает написание «безопасного» JavaScript.
Строгий режим изменяет ранее принятый «плохой синтаксис» на реальные ошибки.
Например, в обычном JavaScript неправильный ввод имени переменной создает новую глобальную переменную. В строгом режиме это приведет к ошибке, из-за которой невозможно случайно создать глобальную переменную.
В обычном JavaScript разработчик не будет получать никаких сообщений об ошибках, присваивая значения свойствам, недоступным для записи.
В строгом режиме любое присвоение недоступному для записи свойству, свойству только для получения, несуществующему свойству, несуществующей переменной или несуществующему объекту вызовет ошибку.
Пожалуйста, обратитесь к http://www.w3schools.com/js/js_strict.asp, чтобы узнать больше
Я хотел бы предложить несколько более обоснованный ответ, дополняющий другие ответы. Я надеялся отредактировать самый популярный ответ, но не смог. Я постарался сделать его как можно более полным и полным.
Вы можете обратиться к документации MDN для получения дополнительной информации.
"use strict"
директива, введенная в ECMAScript 5.
Директивы похожи на заявления, но отличаются.
use strict
не содержит ключевых слов: директива представляет собой простое выражение выражения, которое состоит из специального строкового литерала (в одинарных или двойных кавычках). Механизмы JavaScript, которые не реализуют ECMAScript 5, просто видят выражение-выражение без побочных эффектов. Ожидается, что будущие версии стандартов ECMAScript будут представленыuse
как реальное ключевое слово; таким образом, цитаты устаревают.use strict
может использоваться только в начале скрипта или функции, то есть оно должно предшествовать любому другому (реальному) утверждению. Это не обязательно должна быть первая инструкция в скрипте функции: ей могут предшествовать другие операторные выражения, состоящие из строковых литералов (и реализации JavaScript могут рассматривать их как директивы, специфичные для реализации). Операторы строковых литералов, которые следуют за первым реальным оператором (в скрипте или функции), являются простыми операторами выражения. Переводчики не должны интерпретировать их как директивы, и они не имеют никакого эффекта.
use strict
Директива указывает , что следующий код (в сценарии или функции) строгий код. Код на самом высоком уровне сценария (код, который отсутствует в функции) считается строгим кодом, когда сценарий содержит use strict
директиву. Содержимое функции считается строгим кодом, если сама функция определена в строгом коде или когда функция содержит use strict
директиву. Код, который передается eval()
методу, считается строгим кодом, когда вызывается eval()
из строгого кода или содержит use strict
саму директиву.
Строгий режим ECMAScript 5 является ограниченным подмножеством языка JavaScript, что устраняет соответствующие недостатки языка и обеспечивает более строгую проверку ошибок и более высокий уровень безопасности. Ниже перечислены различия между строгим режимом и обычным режимом (из которых первые три особенно важны):
- Вы не можете использовать
with
-statement в строгом режиме. - В строгом режиме все переменные должны быть объявлены: если вы присваиваете значение идентификатору, который не был объявлен как переменная, функция, параметр функции, параметр catch-clause или свойство global
Object
, то вы получите aReferenceError
. В обычном режиме идентификатор неявно объявляется как глобальная переменная (как свойство глобальнойObject
) - В строгом режиме ключевое слово
this
имеет значениеundefined
в функциях, которые вызывались как функции (а не как методы). (В обычном режимеthis
всегда указывает на глобальныйObject
). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
Кроме того, когда функция вызывается в строгом режиме
call()
илиapply
в строгом режиме,this
это в точности значение первого аргумента вызоваcall()
orapply()
. (В нормальном режимеnull
иundefined
заменяются глобальнойObject
и значениями, которые не являются объектами, отлиты в объекты.)В строгом режиме вы получите
TypeError
, когда вы попытаетесь присвоить только для чтения свойства или определить новые свойства для нерасширяемого объекта. (В обычном режиме оба просто терпят неудачу без сообщения об ошибке.)- В строгом режиме при передаче кода
eval()
вы не можете объявлять или определять переменные или функции в области действия вызывающей стороны (как вы можете сделать это в обычном режиме). Вместо этого создается новая область действия,eval()
а переменные и функции находятся в этой области. Эта область уничтожается послеeval()
завершения выполнения. - В строгом режиме объект arguments объекта содержит статическую копию значений, которые передаются этой функции. В обычном режиме объект arguments имеет несколько «магическое» поведение: элементы массива и параметры именованной функции ссылаются на одно и то же значение.
- В строгом режиме вы получите,
SyntaxError
когда заdelete
оператором следует неквалифицированный идентификатор (переменная, функция или параметр функции). В обычном режимеdelete
выражение ничего не делает и оценивается какfalse
. - В строгом режиме вы получите,
TypeError
когда вы попытаетесь удалить не настраиваемое свойство. (В обычном режиме попытка просто терпит неудачу, иdelete
выражение оценивается какfalse
). - В строгом режиме это считается синтаксической ошибкой, когда вы пытаетесь определить несколько свойств с одинаковым именем для литерала объекта. (В обычном режиме ошибки нет.)
- В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с одинаковым именем. (В обычном режиме ошибки нет.)
- В строгом режиме восьмеричные литералы не допускаются (это литералы, начинающиеся с
0x
. (В нормальном режиме некоторые реализации допускают восьмеричные литералы.) - В строгом режиме идентификаторы
eval
иarguments
обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение и не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch. - В строгом режиме больше ограничений на возможности изучения стека вызовов.
arguments.caller
иarguments.callee
вызватьTypeError
функцию в строгом режиме. Кроме того, некоторые свойства вызывающего и аргумента функций в строгом режиме вызывают,TypeError
когда вы пытаетесь их прочитать.
0
. При добавлении "use strict";
следующие случаи будут выдавать SyntaxError перед выполнением сценария:
Прокладывая путь для версий будущего ECMAScript , используя один из недавно зарезервированных ключевых слов (в предвидении для ECMAScript 6 ):
implements
,interface
,let
,package
,private
,protected
,public
,static
, иyield
.Объявление функции в блоках
if(a<b){ function f(){} }
Восьмеричный синтаксис
var n = 023;
this
указать на глобальный объект.function f() { "use strict"; this.a = 1; }; f();
Объявление дважды одинакового имени для имени свойства в литерале объекта
{a: 1, b: 3, a: 7}
Это больше не относится к ECMAScript 6 ( ошибка 1041128 ).
Объявление двух аргументов функции с одинаковым именем функции
f(a, b, b){}
Установка значения в необъявленную переменную
function f(x){ "use strict"; var a = 12; b = a + x*35; // error! } f();
Использование
delete
по имени переменнойdelete myVariable;
Использование
eval
или вarguments
качестве имени переменной или аргумента функции"use strict"; arguments++; var obj = { set p(arguments) { } }; try { } catch (arguments) { } function arguments() { }
Источники:
Переход на строгий режим на MDN
Строгий режим на MDN
Строгий режим JavaScript и почему вы должны его использовать в блоге Колина Дж. Ирига (архивная версия)
Использование 'use strict';
не делает ваш код лучше.
Строгий режим JavaScript особенность в ECMAScript 5 . Вы можете включить строгий режим, объявив это в верхней части скрипта / функции.
'use strict';
Когда механизм JavaScript видит эту директиву , он начинает интерпретировать код в специальном режиме. В этом режиме возникают ошибки, когда обнаруживаются определенные методы кодирования, которые могут оказаться потенциальными ошибками (что является причиной строгого режима).
Рассмотрим этот пример:
var a = 365;
var b = 030;
В своем стремлении выстроить числовые литералы разработчик непреднамеренно инициализировал переменную b
с восьмеричным литералом. Нестрогий режим интерпретирует это как числовой литерал со значением 24
(в базе 10). Однако строгий режим выдаст ошибку.
Неисчерпывающий список специальностей в строгом режиме см. В этом ответе .
Где я должен использовать '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
будет интерпретироваться в строгом режиме. Слово лексическая сфера важна здесь. Например, если ваш строгий код вызывает функцию библиотеки, которая не является строгой , в строгом режиме выполняется только ваш код, а не вызываемая функция. Смотрите этот ответ для лучшего объяснения.
Какие вещи запрещены в строгом режиме?
Я нашел хорошую статью, описывающую несколько вещей, которые запрещены в строгом режиме (обратите внимание, что это не эксклюзивный список):
Объем
Исторически JavaScript был сбит с толку о том, как функции ограничены. Иногда они кажутся статически ограниченными, но некоторые функции заставляют их вести себя так, как будто они динамически ограничены. Это сбивает с толку, затрудняя чтение и понимание программ. Непонимание вызывает ошибки. Это также является проблемой для производительности. Статическая область видимости позволила бы связывание переменных во время компиляции, но требование к динамической области означает, что связывание должно быть отложено до времени выполнения, что приводит к значительному снижению производительности.
Строгий режим требует статического связывания всех переменных. Это означает, что функции, которые ранее требовали динамического связывания, должны быть удалены или изменены. В частности, оператор with исключен, а способность функции eval вмешиваться в среду своего вызывающего объекта строго ограничена.
Одним из преимуществ строгого кода является то, что такие инструменты, как YUI Compressor, могут лучше обрабатывать его.
Подразумеваемые глобальные переменные
JavaScript подразумевает глобальные переменные. Если вы явно не объявляете переменную, глобальная переменная неявно объявляется для вас. Это облегчает программирование для начинающих, потому что они могут пренебречь некоторыми из своих основных дел по дому. Но это значительно усложняет управление большими программами и значительно снижает надежность. Таким образом, в строгом режиме подразумеваемые глобальные переменные больше не создаются. Вы должны явно объявить все ваши переменные.
Глобальная утечка
Существует ряд ситуаций, которые могут привести
this
к привязке к глобальному объекту. Например, если вы забудете предоставитьnew
префикс при вызове функции конструктора, конструкторthis
будет неожиданно привязан к глобальному объекту, поэтому вместо инициализации нового объекта он будет молча вмешиваться в глобальные переменные. В этих ситуациях строгий режим вместо этого будет привязыватьсяthis
кundefined
, что заставит конструктор вместо этого выдать исключение, что позволит обнаружить ошибку намного быстрее.Шумный отказ
JavaScript всегда имел свойства только для чтения, но вы не можете создавать их самостоятельно, пока
Object.createProperty
функция ES5 не продемонстрирует эту возможность. Если вы попытаетесь присвоить значение свойству только для чтения, оно молча завершится неудачей. Назначение не изменит значение свойства, но ваша программа будет работать так, как если бы это было. Это угроза целостности, которая может привести к тому, что программы перейдут в несовместимое состояние. В строгом режиме попытка изменить свойство только для чтения вызовет исключение.восьмеричный
Восьмеричное (или базовое 8) представление чисел было чрезвычайно полезно при программировании на уровне машины на машинах, у которых размеры слов были кратны 3. Вам нужно восьмеричное значение при работе с мэйнфреймом CDC 6600, который имел размер слова 60 бит. Если бы вы могли читать восьмеричное, вы могли бы смотреть на слово как 20 цифр. Две цифры представляют код операции, а одна цифра обозначает один из 8 регистров. Во время медленного перехода от машинных кодов к языкам высокого уровня считалось полезным предоставить восьмеричные формы в языках программирования.
В C было выбрано крайне неудачное представление восьмеричности: ведущий ноль. Таким образом, в C
0100
означает 64, а не 100, и08
является ошибкой, а не 8. Более того, к сожалению, этот анахронизм был скопирован почти на все современные языки, включая JavaScript, где он используется только для создания ошибок. У него нет другой цели. Так что в строгом режиме восьмеричные формы больше не разрешены.И так далее
Псевдомассив arguments становится более похожим на массив в ES5. В строгом режиме, она теряет свое
callee
иcaller
свойство. Это позволяет передать вашarguments
ненадежный код, не отказываясь от большого количества конфиденциального контекста. Такжеarguments
исключено свойство функций.В строгом режиме дубликаты ключей в функциональном литерале вызовут синтаксическую ошибку. Функция не может иметь два параметра с одинаковым именем. Функция не может иметь переменную с тем же именем, что и один из ее параметров. Функция не может иметь
delete
свои собственные переменные. Попыткаdelete
ненастраиваемого свойства теперь вызывает исключение. Примитивные значения не подразумеваются.
Зарезервированные слова для будущих версий JavaScript
ECMAScript 5 добавляет список зарезервированных слов. Если вы используете их как переменные или аргументы, строгий режим выдаст ошибку. Зарезервированные слова:
implements
,interface
,let
,package
,private
,protected
,public
,static
, Иyield
Дальнейшее чтение
'use strict'
директивы, они будут выполняться в нестрогом режиме, даже если они вызваны из функции, работающей в строгом режиме. Смотрите этот ответ для объяснения. this
). Теперь я вижу, что вы имели в виду вызов других функций. Обратите внимание, что use strict
был введен в EcmaScript 5 и сохранился с тех пор.
Ниже приведены условия для запуска строгого режима в ES6 и ES7 :
- Глобальный код - это код строгого режима, если он начинается с Пролога Директивы, который содержит Директиву Строгого Использования (см. 14.1.1).
- Код модуля - это всегда строгий код режима.
- Все части ClassDeclaration или ClassExpression являются строгим кодом режима.
- Eval-код - это код строгого режима, если он начинается с Пролога директивы, который содержит директиву Use Strict, или если вызов eval является прямым eval (см. 12.3.4.1), который содержится в коде строгого режима.
- Код функции - это код строгого режима, если связанный код FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition или ArrowFunction содержится в коде строгого режима или если код, который создает значение внутреннего слота функции [[ECMAScriptCode]], начинается с директивного пролога который содержит директиву об использовании строго.
- Код функции, который предоставляется в качестве аргументов для встроенных конструкторов Function и Generator, является кодом строгого режима, если последний аргумент является строкой, которая при обработке является FunctionBody, которая начинается с пролога директивы, содержащей директиву Use Strict.
«использовать строгое»; является попыткой ECMA сделать JavaScript немного более надежным. Это привносит в JS попытку сделать его хотя бы немного «строгим» (другие языки применяют строгие правила с 90-х годов). Это на самом деле «заставляет» разработчиков JavaScript следовать каким-то лучшим методам кодирования. Тем не менее, JavaScript очень хрупкий. Не существует таких вещей, как типизированные переменные, типизированные методы и т. Д. Я настоятельно рекомендую разработчикам JavaScript изучать более надежный язык, такой как Java или ActionScript3, и применять те же самые лучшие практики в своем коде JavaScript, это будет работать лучше и легче отладки.
use strict
это способ сделать ваш код более безопасным, потому что вы не можете использовать опасные функции, которые могут работать не так, как вы ожидаете. И, как было написано ранее, это делает код более строгим.
Небольшие примеры для сравнения:
Нестрогий режим:
for (i of [1,2,3]) console.log(i)
// output:
// 1
// 2
// 3
Строгий режим:
'use strict';
for (i of [1,2,3]) console.log(i)
// output:
// Uncaught ReferenceError: i is not defined
Нестрогий режим:
String.prototype.test = function () {
console.log(typeof this === 'string');
};
'a'.test();
// output
// false
String.prototype.test = function () {
'use strict';
console.log(typeof this === 'string');
};
'a'.test();
// output
// true
this === 'a'
в обоих примерах? Use Strict используется для отображения распространенных и повторяющихся ошибок, так что они обрабатываются по-разному, и изменяет способ выполнения сценария Java, такие изменения:
Предотвращает случайные глобалы
Без дубликатов
Устраняет с
Устраняет это принуждение
Более безопасный eval ()
Ошибки для неизменяемых
Вы также можете прочитать эту статью для деталей
«Строгий» режим JavaScript был введен в ECMAScript 5.
(function() {
"use strict";
your code...
})();
Запись "use strict";
в самом верху вашего JS-файла включает строгую проверку синтаксиса. Он выполняет следующие задачи для нас:
выдает ошибку при попытке присвоить необъявленную переменную
останавливает перезапись ключевых системных библиотек JS
запрещает некоторые небезопасные или подверженные ошибкам языковые функции
use strict
также работает внутри отдельных функций. Всегда лучше включать use strict
в свой код.
Проблема совместимости браузера: директивы use предназначены для обратной совместимости. Браузеры, которые их не поддерживают, просто увидят строковый литерал, на который нет дальнейших ссылок. Итак, они пройдут над ним и пойдут дальше.
Основные причины, по которым разработчики должны использовать "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'}; }
- NB.
"use strict"
Директива распознается только в начале скрипта или функции. Строка
"arguments"
не может быть использована в качестве переменной:"use strict"; var arguments = 3.14; // This will cause an error
Ограничит использование ключевых слов в качестве переменных. Попытка их использования приведет к ошибкам.
Короче говоря, ваш код будет менее подвержен ошибкам и, в свою очередь, заставит вас писать хороший код.
Чтобы узнать больше об этом вы можете обратиться сюда .
Обычно JavaScript не следует строгим правилам, что увеличивает вероятность ошибок. После использования "use strict"
код JavaScript должен следовать строгому набору правил, как и в других языках программирования, таких как использование терминаторов, объявление перед инициализацией и т. Д.
Если "use strict"
используется, код должен быть написан в соответствии со строгим набором правил, следовательно, уменьшается вероятность ошибок и неясностей.
"use strict"
заставляет код JavaScript работать в строгом режиме , что в основном означает, что все должно быть определено перед использованием. Основная причина использования строгого режима состоит в том, чтобы избежать случайного глобального использования неопределенных методов.
Также в строгом режиме все работает быстрее, некоторые предупреждения или тихие предупреждения приводят к фатальным ошибкам, лучше всегда использовать его для создания более аккуратного кода.
"use strict"
широко используется в ECMA5, в ECMA6 по умолчанию он является частью JavaScript , поэтому его не нужно добавлять, если вы используете ES6.
Посмотрите на эти заявления и примеры из MDN:
Директива «использовать строгое» Директива
«использовать строгое» появилась в JavaScript 1.8.5 (версия 5 ECMAScript). Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript. Цель «использования строгого» - указать, что код должен выполняться в «строгом режиме». В строгом режиме нельзя, например, использовать необъявленные переменные.Примеры использования «использования строгого»:
строгий режим для функций: аналогично, чтобы вызвать строгий режим для функции, поместите точное выражение «используйте строгий»; (или «используйте строгий»;) в теле функции перед любыми другими утверждениями.
1) строгий режим в функциях
function strict() {
// Function-level strict mode syntax
'use strict';
function nested() { return 'And so am I!'; }
return "Hi! I'm a strict mode function! " + nested();
}
function notStrict() { return "I'm not strict."; }
console.log(strict(), notStrict());
2) строгий режим всего сценария
'use strict';
var v = "Hi! I'm a strict mode script!";
console.log(v);
3) Присвоение неписываемым глобальным
'use strict';
// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError
// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError
// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError
// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError
Вы можете прочитать больше на MDN .
«использовать строгое»; Определяет, что код JavaScript должен выполняться в «строгом режиме».
- Директива «use strict» была впервые введена в ECMAScript версии 5.
- Это не утверждение, а буквальное выражение, игнорируемое более ранними версиями JavaScript.
- Цель «использования строгого» - указать, что код должен выполняться в «строгом режиме».
- В строгом режиме нельзя, например, использовать необъявленные переменные.
Все современные браузеры поддерживают «строгое использование», кроме Internet Explorer 9 и ниже .
Недостаток
Если разработчик использовал библиотеку, которая была в строгом режиме, но разработчик привык работать в обычном режиме, они могли бы вызвать некоторые действия с библиотекой, которые не работали бы так, как ожидалось.
Хуже того, поскольку разработчик находится в обычном режиме, он не имеет преимуществ, связанных с дополнительными ошибками, поэтому ошибка может молча завершиться сбоем.
Кроме того, как указано выше, строгий режим не позволяет вам делать определенные вещи.
Люди обычно думают, что вы не должны использовать эти вещи в первую очередь, но некоторым разработчикам не нравятся ограничения, и они хотят использовать все возможности языка.
Для базового примера и для справки пройдите:
https://www.tutorialsteacher.com/javascript/javascript-strict
Строгий режим может предотвратить утечки памяти.
Пожалуйста, проверьте функцию ниже, написанную в нестрогом режиме:
function getname(){
name = "Stack Overflow"; // Not using var keyword
return name;
}
getname();
console.log(name); // Stack Overflow
В этой функции мы используем переменную, вызываемую name
внутри функции. Внутренне компилятор сначала проверит, существует ли какая-либо переменная, объявленная с этим конкретным именем в этой конкретной области действия функции. Поскольку компилятор понял, что такой переменной нет, он проверит внешнюю область видимости. В нашем случае это глобальный охват. Опять же, компилятор понял, что в глобальном пространстве с таким именем также не объявлена переменная, поэтому он создает такую переменную для нас в глобальном пространстве. Концептуально эта переменная будет создана в глобальной области и будет доступна во всем приложении.
Другой сценарий состоит в том, что, скажем, переменная объявлена в дочерней функции. В этом случае компилятор проверяет допустимость этой переменной во внешней области видимости, то есть в родительской функции. Только тогда он проверит глобальное пространство и создаст для нас переменную. Это означает, что необходимо выполнить дополнительные проверки. Это повлияет на производительность приложения.
Теперь давайте напишем ту же функцию в строгом режиме.
"use strict"
function getname(){
name = "Stack Overflow"; // Not using var keyword
return name;
}
getname();
console.log(name);
Мы получим следующую ошибку.
Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5
Здесь компилятор выдает ошибку ссылки. В строгом режиме компилятор не позволяет нам использовать переменную без ее объявления. Таким образом, утечки памяти могут быть предотвращены. Кроме того, мы можем написать более оптимизированный код.
"use strict";
одного не делает JS лексически ограниченным. Объявление переменных сlet
иconst
должно использоваться тоже.