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

Но исправление этих ошибок без создания альтернативной интерпретации нарушает обратную совместимость. Итак, директива "use strict" создает эту альтернативную интерпретацию кода при передаче его программисту.

Например, this ключевые слова относятся к объекту в определении метода, например, this или self на других языках.

let o = {
  name: 'John Doe',
  sayName: function(){
    console.log(this.name);
  }
};

o.sayName(); // 'John Doe'

this не имеет цели вне контекста метода, но все функции JavaScript имеют ключевое слово this независимо от того, являются они методами или нет:

function run() {
  console.log(this);
}

run(); // Window

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

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

"use strict"

function run() {
  console.log(this);
}

run(); // undefined

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

Строгий режим устраняет ошибки, которые игнорировались бы в нестрогом режиме, тем самым делая javascript «более защищенным».

Считается ли это одной из лучших практик?

Да, , включение строгого режима считается частью передовой практики при работе с javascript. Это делается путем добавления следующей строки кода в ваш JS-файл.

'use strict';

в вашем коде.

Что это означает для пользовательских агентов?

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

Например: Предположим, в вашем файле .js есть следующий код:

Сценарий 1: [БЕЗ СТРОГОГО РЕЖИМА]

var city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

Сценарий 2: [БЕЗ СТРОГОГО РЕЖИМА]

city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

Так почему же имя переменной печатается в обоих случаях?

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

Сценарий 3: [СТРОГОЙ РЕЖИМ]

'use strict';

city = "Chicago"
console.log(city) // Reference Error: asignment is undeclared variable city.

Дополнительный совет: Чтобы поддерживать качество кода в строгом режиме, вам не нужно писать это снова и снова, особенно если у вас несколько файлов .js. Вы можете применить это правило глобально в eslint правилах следующим образом:

Имя файла: .eslintrc.js

module.exports = {
    env: {
        es6: true
    },
    rules : {
        strict: ['error', 'global'],
        },
    };
    

Хорошо, а что запрещается в строгом режиме?

• Использование переменной без ее объявления вызовет ошибку в строгом режиме. Это сделано для предотвращения непреднамеренного создания глобальных переменных в вашем приложении. Пример с печатью Чикаго охватывает это, в частности.

• Удаление переменной, функции или аргумента запрещено в строгом режиме.

  "use strict";
   function x(p1, p2) {}; 
   delete x; // This will cause an error
  

• Дублирование имени параметра не разрешено в строгом режиме.

   "use strict";
   function x(p1, p1) {};   // This will cause an error
  

• Зарезервированные слова на языке Javascript не допускаются в строгом режиме. Слова - это интерфейс реализации, пусть, пакеты, частный, защищенный, общедоступный. static и yield

Для более полного списка ознакомьтесь с документацией MDN здесь: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode

Строгий режим может предотвратить утечку памяти.

Пожалуйста, проверьте функцию ниже, написанную в нестрогом режиме:

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

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

"использовать строгое"; Определяет, что код JavaScript должен выполняться в "строгий режим".

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

Все современные браузеры поддерживают использование строгого режима, кроме Internet Explorer 9 и ниже .

Недостаток

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

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

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

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

• Для базового примера и справки пройдите:

  https://www.tutorialsteacher.com/javascript/javascript-strict

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

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

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

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

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

Примеры использования "use strict":
Строгий режим для функций: аналогично, чтобы вызвать строгий режим для функция, поставьте точное выражение "использовать строго"; (или "использовать строгий";) в тело функции перед любыми другими операторами.

1) строгий режим в функциях

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) строгий режим всего скрипта

'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" код JavaScript должен следовать строгому набору правил, как и в других языках программирования, таких как использование терминаторов, объявление перед инициализацией и т. Д.

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

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

1. Предотвращает случайное объявление глобальных переменных. Использование "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'};
   }
   

2. Примечание: директива "use strict" распознается только в начале скрипта или функции.

3. Строку "arguments" нельзя использовать в качестве переменной:

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

4. Ограничит использование ключевых слов в качестве переменных. Попытка их использовать приведет к ошибкам.

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

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

«Строгий» режим JavaScript был введен в ECMAScript 5.

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

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

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

2. предотвращает перезапись ключевых системных библиотек JS

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

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

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

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

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

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

• Удаляется с помощью

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

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

• Ошибки для неизменяемых объектов

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

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

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

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

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

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

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

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

• Глобальный код является кодом строгого режима, если он начинается с пролога директивы, который содержит директиву строгого использования (см. 14.1.1).
• Код модуля всегда является кодом строгого режима.
• Все части ClassDeclaration или ClassExpression представляют собой код строгого режима.
• Код оценки является кодом строгого режима, если он начинается с пролога директивы, содержащего директиву Use Strict, или если вызов eval является прямым eval (см. 12.3.4.1), который содержится в коде строгого режима.
• Код функции является кодом строгого режима, если связанный FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition или ArrowFunction содержится в коде строгого режима или если код, который создает значение [[ECMAScriptCode функции ]] внутренний слот начинается с пролога директивы, который содержит директиву строгого использования.
• Код функции, который предоставляется в качестве аргументов встроенным конструкторам функций и генераторов, является кодом строгого режима, если последним аргументом является строка, которая при обработке является FunctionBody , которая начинается с пролога директивы, который содержит строгую директиву.

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

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

'use strict';

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

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

var a = 365;
var b = 030;

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

Неполный список специализаций в строгом режиме см. В этом ответе.

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

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

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

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

1. Вставьте инструкцию 'use strict'; поверх своего скрипта:

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

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

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

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

   Все, что находится в лексической области функции doSomething, будет интерпретироваться в строгом режиме. Здесь важно слово лексическая область . Например, если ваш код strict вызывает функцию библиотеки, которая not strict , в строгом режиме выполняется только ваш код, а не вызываемая функция. См. Этот ответ для лучшего объяснения.

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

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

Область действия

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

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

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

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

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

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

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

Шумный отказ

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

Восьмеричное число

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

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

И так далее

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

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

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

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

implements, interface, let, package, private, protected, public, <671265986525140> и <672586725>

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

• Строгий режим - JavaScript | MDN
• Поддержка браузером строгого режима
• Переход в строгий режим

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

• Прокладывая путь для будущих версий ECMAScript , используя одно из недавно зарезервированных ключевых слов (предварительно для ECMAScript 6 , ): 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).

• Объявление двух аргументов функции с одинаковым именем function

  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 и почему его следует использовать в блоге Колина Дж. Айрига (заархивированная версия)

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

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

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

Цитата из w3schools:

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

Директива use strict впервые появилась в JavaScript 1.8.5 (ECMAScript версия 5).

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

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

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

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

Строгий режим упрощает написание «безопасного» кода JavaScript.

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

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

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

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

Пожалуйста, обратитесь к http://www.w3schools.com/js/js_strict.asp, чтобы узнать больше

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

Список функций (неполный)

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

2. При автоматическом выполнении неудачных назначений в строгом режиме будет выдана ошибка (присвоение NaN = 5;)

3. Попытки удалить свойства, которые невозможно удалить, вызовут (delete Object.prototype)

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

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

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

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

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

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

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

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

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

[Ссылка: Строгий режим, Сеть разработчиков Mozilla ]

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

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

Неперехваченная ошибка ссылки: nameoftree не определено

Пример

Исключает with оператор:

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

Пример

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

Когда у нас есть повторяющееся свойство, генерируется исключение

Неперехваченная SyntaxError: свойство повторяющихся данных в литерале объекта отсутствует. разрешено в строгом режиме

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

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

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

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

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

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

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

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

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

для получения дополнительной информации посетите Strict Mode- Javascript

Предупреждение, все вы, усердные программисты: применение "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 в наш код и предполагаем, что ошибок нет. Итак, отток заключается в том, что пора начать использовать эту невероятно полезную языковую функцию для написания лучшего кода.

Например,

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

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

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

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

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

Современная практика JavaScript всегда должна вызывать «Строгое использование»; pragma. Единственная причина, по которой группа ECMA сделала "строгий" режим необязательным , - это предоставить менее опытным кодировщикам доступ к JavaScript и дать им время адаптироваться к новым и более безопасным методам кодирования.

Если люди беспокоятся об использовании 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.
*/

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

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

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

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

"use strict";

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