Для чего нужен строгий режим в javascript

Строгий режим — «use strict»

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

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

Так было до 2009 года, когда появился ECMAScript 5 (ES5). Он добавил новые возможности в язык и изменил некоторые из существующих. Чтобы устаревший код работал, как и раньше, по умолчанию подобные изменения не применяются. Поэтому нам нужно явно их активировать с помощью специальной директивы: «use strict» .

«use strict»

Директива выглядит как строка: «use strict» или ‘use strict’ . Когда она находится в начале скрипта, весь сценарий работает в «современном» режиме.

"use strict"; // этот код работает в современном режиме . 

Совсем скоро мы начнём изучать функции (способ группировки команд), поэтому заранее отметим, что в начале большинства видов функций можно поставить «use strict» . Это позволяет включить строгий режим только в конкретной функции. Но обычно люди используют его для всего файла.

Убедитесь, что «use strict» находится в начале

Проверьте, что «use strict» находится в первой исполняемой строке скрипта, иначе строгий режим может не включиться.

Здесь строгий режим не включён:

alert("some code"); // "use strict" ниже игнорируется - он должен быть в первой строке "use strict"; // строгий режим не активирован

Над «use strict» могут быть записаны только комментарии.

Нет никакого способа отменить use strict

Нет директивы типа «no use strict» , которая возвращала бы движок к старому поведению.

Как только мы входим в строгий режим, отменить это невозможно.

Консоль браузера

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

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

Итак, как можно включить use strict в консоли?

Можно использовать Shift + Enter для ввода нескольких строк и написать в верхней строке use strict :

'use strict'; // . ваш код.

В большинстве браузеров, включая Chrome и Firefox, это работает.

Если этого не происходит, например, в старом браузере, есть некрасивый, но надежный способ обеспечить use strict . Поместите его в следующую обёртку:

(function() < 'use strict'; // . ваш код. >)()

Всегда ли нужно использовать «use strict»?

Вопрос кажется риторическим, но это не так.

Кто-то посоветует начинать каждый скрипт с «use strict» … Но есть способ покруче.

Современный JavaScript поддерживает «классы» и «модули» — продвинутые структуры языка (и мы, конечно, до них доберёмся), которые автоматически включают строгий режим. Поэтому в них нет нужды добавлять директиву «use strict» .

Подытожим: пока очень желательно добавлять «use strict»; в начале ваших скриптов. Позже, когда весь ваш код будет состоять из классов и модулей, директиву можно будет опускать.

Пока мы узнали о use strict только в общих чертах.

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

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

JavaScript strict mode (строгий режим)

Strict mode (в переводе с анг. — строгий режим) – это модель синтаксического анализа и выполнения JavaScript-кода, в которой используется более строгая проверка кода на ошибки и генерируются ошибки при небезопасных действиях.

Включение строгого режима

Чтобы включить строгий режим для всего сценария, добавьте в начало сценария следующую команду:

"use strict";

Хоть она и выглядит как строка, на самом деле это директива, переводящая JavaScript в строгий режим.

Строгий режим можно включить и для отдельной функции, добавив эту директиву в начало тела функции:

function foo()

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

"use strict"; // Правильное расположение a = 5; alert(a); b = 1; alert(b); a = 5; alert(a); "use strict"; // Неправильное расположение. Директива не будет работать b = 1; alert(b);

Выполнение JavaScript в строгом режиме

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

window.num = 10

"use strict"; function foo() < var a = 10; eval("var x = 10; alert(x + a);"); alert(x); // Ошибка. Такой переменной не существует >foo();

var a = b = 5; // Ошибка. Необъявленная переменная (b)

 < foo(); // 1 function foo () < alert(1); >> foo(); // Ошибка. Функция foo не объявлена.

Копирование материалов с данного сайта возможно только с разрешения администрации сайта
и при указании прямой активной ссылки на источник.
2011 – 2023 © puzzleweb.ru | razumnikum.ru

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

Директива «use strict»; указывает, что код JavaScript должен выполняться в «строгом режиме».

Директива «use strict» была добавлена в JavaScript 1.8.5 (ECMAScript версии 5).

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

Цель директивы «use strict» — указать, что код должен выполняться в, так называемом, «строгом режиме».

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

Строгий режим поддерживается в:

• IE с версии 10,
• Firefox с версии 4,
• Chrome с версии 13,
• Safari с версии 5.1,
• Opera с версии 12.

Декларирование строгого режима

Строгий режим декларируется путем добавления директивы «use strict»; в начало скрипта или функции.

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

 "use strict"; x = 3.14; // Ошибка, так как переменная x не декларирована myFunction(); function myFunction() < y = 3.14; // Ошибка, так как переменная y не декларирована >

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

 x = 3.14; // Ошибки не будет myFunction(); function myFunction() < "use strict"; y = 3.14; // Возникнет ошибка >

Синтаксис директивы «use strict»;

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

Компилирование числовых (4 + 5;) или строковых («John Doe»;) констант в программе JavaScript не имеет побочных эффектов. Они просто компилируются в несуществующую переменную и умирают.

Таким образом, строковая константа «use strict»; срабатывает только в новых компиляторах, которые «понимают» ее значение.

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

Благодаря строгому режиму проще писать «безопасный» JavaScript код.

В строгом режиме ранее вполне приемлемый «плохой синтаксис» превращается в реальные ошибки.

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

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

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

Ограничения в строгом режиме

Нельзя использовать переменные без декларирования:

 "use strict"; x = 3.14; // Это приведет к ошибке 

Внимание! Объекты тоже переменные.

Нельзя использовать объекты без декларирования:

 "use strict"; x = ; // Это приведет к ошибке 

Нельзя удалять переменную (или объект):

 "use strict"; var x = 3.14; delete x; // Это приведет к ошибке 

Нельзя удалять функцию:

 "use strict"; function x(p1, p2) <>; delete x; // Это приведет к ошибке 

Одинаковые имена параметров запрещены:

 "use strict"; function x(p1, p1) <>; // Это приведет к ошибке 

Восьмеричные числовые константы запрещены:

 "use strict"; var x = 010; // Это приведет к ошибке 

Восьмеричные экранированные символы запрещены:

 "use strict"; var x = "\010"; // Это приведет к ошибке 

Запись в свойства, предназначенные только для чтения, запрещено:

 "use strict"; var obj = <>; Object.defineProperty(obj, "x", ); obj.x = 3.14; // Это приведет к ошибке 

Запись в свойства, предназначенные только для возврата значения, запрещено:

 "use strict"; var obj = >; obj.x = 3.14; // Это приведет к ошибке 

Нельзя удалять неудаляемые свойства:

 "use strict"; delete Object.prototype; // Это приведет к ошибке 

Нельзя использовать строку «eval» в качестве имени переменной:

 "use strict"; var eval = 3.14; // Это приведет к ошибке 

Нельзя использовать строку «arguments» в качестве имени переменной:

 "use strict"; var arguments = 3.14; // Это приведет к ошибке 

Нельзя использовать выражение with:

 "use strict"; with (Math); // Это приведет к ошибке 

По соображениям безопасности, функции eval() запрещено создавать переменные в области видимости, где она была вызвана:

 "use strict"; eval ("var x = 2"); alert (x); // Это приведет к ошибке 

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

Задел на будущее

В строгом режиме нельзя использовать будущие зарезервированные слова. Это implements, interface, let, package, private, protected, public, static, yield.

 "use strict"; var public = 1500; // Это приведет к ошибке 

ВНИМАНИЕ!
Директива «use strict» распознается только в начале скрипта или функции.

Use strict, что это? Зачем в JavaScript нужен строгий режим?

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

Синтаксис «строгого режима» отличается от традиционного синтаксиса JavaScript. В нем не проходят многие ошибки, которые легко пройдут в стандартном. Поэтому очень часто стандартный синтаксис называют «грязным», от того что в нем многие мелкие ошибки игнорируются. Такое «игнорирование» — это не всегда плохо. В мелких проектах молодых разработчиков оно ни к чему плохому не приводит. Но если проект большой, то наличие в коде «мелких» ошибок иногда может привести к непредсказуемым результатам. И чтобы этого не произошло, разработчики применяют режим use strict при разработке на языке JavaScript.

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

Use strict в JavaScript

Use strict в JavaScript может применяться ко всему документу сразу или к отдельным его функциям. Для того чтобы включить этот режим в документе, необходимо в нужном месте разместить выражение «Use strict» в одинарных или двойных кавычках.

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

Когда нужно сделать отдельную функцию «строгой», то в ее верхней части тела нужно вписать «Use strict». При этом все , что входит в состав этой функции , будет в «строгом режиме», даже другие вложенные функции.

Отличия «use strict» и стандартный режим в JavaScript

1. При режиме «strict» к неопределенной переменной не присваивается значение.
2. Нельзя применить инструкцию «with».
3. Нет возможности добавить повторяющиеся свойства в литерале объекта.
4. Нет возможности добавить дополнительные параметры формальной функции.
5. Когда изменяется объект «arguments», не изменяются аргументы.
6. Когда аргумент является неизменяемым свойством объекта, то «delete» выдаст ошибку.
7. Нет возможности преобразовать «this» в объект.
8. Нет возможности изменять «eval» и «arguments», а также применять их в качестве имени.
9. Увеличенное количество слов, которые зарезервировали для будущего применения.
10. Нет возможности использовать восьмеричную систему.
11. Нет возможности применять конструкции кода, которые могут затруднить оптимизацию самого кода.
12. Нельзя объявить переменную в коде, который был передан методу «eval».
13. Нельзя удалить обычные переменные.
14. И др.

Заключение

Use strict в JavaScript — это то, что делает код чище и безопасней. Этот режим существует уже очень долго и поддерживается всеми современными браузерами. Проблемы с этим режимом могут возникнуть только в старых версиях Internet Explorer.

Use strict в JavaScript часто используется для лучшей оптимизации программы, а также для поиска «тихих» ошибок, которые могут давать неоднозначные результаты.

Часто спрашивают : «А всегда ли нужно использовать режим «use strict»? » Вообще это риторический вопрос , и однозначно на него не ответить. С одной стороны, этот режим улучшает код, но другой стороны, при кодировании в этом режиме увеличивается время разработки. Поэтому тут, скорее всего , будет зависеть от проекта и лично от вас как от разработчика : нужен он вам или нет .

Мы будем очень благодарны

если под понравившемся материалом Вы нажмёте одну из кнопок социальных сетей и поделитесь с друзьями.