26 Вопрос: Что «использует строгий» делает в JavaScript, и каковы причины этого?

вопрос создан в Mon, Jan 23, 2017 12:00 AM

Недавно я выполнил часть своего кода JavaScript через JSLint Крокфорда и выдал следующую ошибку:

  

Проблема в строке 1, символ 1: отсутствует выражение "использовать строгий".

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

Так что же такое "use strict";, что это означает, и все еще актуально?

Отвечает ли текущий браузер строке "use strict"; или она предназначена для использования в будущем?

    
7164
26 ответов                              26                         

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

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

  

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

и

  

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

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

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

 
// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code... 

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

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

Строгий режим теперь поддерживается всеми основными браузерами . Если вы пишете свой JavaScript в нативных модулях ECMAScript (с операторами import и export), то строго режим всегда включен и не может быть отключен.

    
4703
2019-04-24 20: 14: 27Z
  1. Изменение значения по умолчанию через столько лет? Слишком поздно для этого: это сломало бы так много существующих сайтов /скриптов /приложений ... Единственное, что можно сделать, это помочь сделать вещи лучше в будущем.
    2010-03-04 21: 54: 49Z
  2. Я попробовал небольшой фрагмент кода, который был бы недействительным при использовании "use strict" в Firefox 3.6, Safari 5, Chrome 7 и Opera 10.6 (все Mac). Никаких ошибок, поэтому, я думаю, «использовать строгий» пока не поддерживается ни в одном браузере. Хотя не проверял в IE9;)
    2010-11-10 09: 54: 12Z
  3. Быстрое обновление: Firefox 4 полностью поддерживает строгий режим, и, насколько я могу судить, ни один другой браузер не поддерживает. Safari и Chrome имеют «частичную» поддержку, но я не знаю, что это значит.
    2011-02-08 02: 02: 24Z
  4. Похоже, что Chrome 11 проходит все эти тесты, как и IE10 ie.microsoft.com/testdrive/HTML5/TryStrict/Default.html#
    2011-05-13 17: 27: 29Z
  5. @ Julius - это нельзя было реализовать с помощью зарезервированного ключевого словапотому что тогда код, пытающийся вызвать строгий режим, сломался бы в старых браузерах. Добавление «случайного» строкового литерала ничего не нарушает.
    2014-03-05 11: 22: 51Z

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

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

 
"use strict";

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

    
1187
2014-10-26 10: 31: 59Z
  1. Быстрый сбой и громкий сбой.
    2013-01-29 22: 20: 19Z
  2. Если вы пишете встроенный Javascript в файлы HTML, начните каждый новый блок с <script>"use strict";. Флаг применяется только к блоку, в который он включен.
    2013-10-05 18: 50: 13Z
  3. Забавно, в результате строки должны иметь одинарные кавычки. Поэтому напишите 'use strict'; вместо этого
    2015-01-30 08: 49: 17Z
  4. тогда что будет с концепцией подъема javascript?
    2015-05-14 08: 33: 16Z
  5. @ SunilSharma Если вы попытаетесь поднять, но не получится, потому что переменная не определена, в данный момент она добавит ее в глобальный объект. С "use strict";, он потерпит неудачу. Это имеет больше смысла, потому что если он добавляет его к глобальному объекту, это означает, что он может не сработать в следующий раз, когда вы запустите функцию /сделаете что-то еще, что сбрасывает блок, как это будет в самом высоком блоке (глобальном).
    2017-02-16 21: 15: 04Z

    Оператор "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 ]

        
    602
    2016-01-22 18: 30: 33Z
    1. Примечание: глобальные переменные разрешены, просто должны быть явными (например, window.foo = bar).
      2016-06-20 09: 41: 03Z
    2. Требуется, чтобы все имена свойств в литерале объекта были уникальными (var x = {x1: "1", x1: "2"}), это допустимо
      2017-07-29 08: 26: 18Z
    3. В вашем примере в 11 отсутствует модификация a (иначе это не имеет смысла). И. е. сумма функций (a, b) {a = 0; вернуть аргументы [0] + b; } alert (sum (1, 2)) вернет 3 в строгом режиме и 2 без строгого режима из-за псевдонимов.
      2018-03-14 11: 04: 03Z

    Если люди беспокоятся об использовании 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.
    */
    
        
    392
    2018-01-22 11: 13: 12Z
    1. Я не согласен. Я думаю, что это показывает, почему это очень полезно. По сути это означает, что это возвращает свою функцию, а не window
      2013-02-26 15: 25: 21Z
    2. когда вам когда-нибудь понадобится окно с this, на которое вы не можете настроить таргетинг с window?
      2013-07-18 08: 34: 07Z
    3. Он ссылается на себя. this принадлежит своей собственной функции, а не глобальному окну
      2013-07-28 21: 17: 28Z
    4. Во втором this - это фактически undefined.
      2013-08-14 11: 40: 32Z
    5. Дело в том, что ваша JS-программа начнет сбой из-за доступа к свойству неопределенного, вместо того, чтобы молча делать неправильные действия с глобальным объектом. Упрощает отслеживание мелких ошибок.
      2015-07-31 05: 47: 55Z

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

        
    198
    2016-10-16 09: 10: 15Z
    1. ПОЧЕМУ разработчики в этой теме так недовольны "использовать строгий" ?? Ради бога, он бросает исключения в иначе работающий JavaScript ! Просто посыпьте его кодом, как сахар на кукурузных хлопьях, а? НЕТ! ПЛОХОЙ! «использовать строгое» следует использовать осторожно, желательно только в коде, которым вы управляете, который имеет модульные тесты, которые проходят во всех основных браузерах и которые выполняют все пути кода. У тебя есть тесты? Ладно, "используй строгий" - это хорошо для тебя, нокаути себя.
      2014-05-08 08: 38: 54Z
    2. Да. Очевидно, что «используйте строгий» может нарушить, казалось бы, действительный javascript, который раньше не нарушался. Но код, который ранее не был взломан, не равен правильному коду и выполнению того, для чего он предназначен. Обычно ссылка на необъявленные переменные сигнализирует об опечатке и т. Д. Использование строгого режима позволяет выявлять ошибки такого рода, и, надеюсь, перед отправкой рабочего кода.
      2015-03-09 07: 46: 42Z
    3. ... или просто примените «use strict» как часть последнего прохода по коду, исправьте все очевидные проблемы, пожмите плечами, скажите «достаточно хорошо», затем взять его на производство :)
      2015-11-10 08: 49: 11Z
    4. Лично я никогда /очень редко добавляю "use strict"; в существующий код. При этом я почти всегда буду использовать его, когда пишу новый код с нуля
      2016-03-25 20: 48: 41Z
    5. Если вы уже используете JSLint, вы, вероятно, исправили большинство мест, где «use strict» могло бы все испортить.
      2017-12-04 15: 22: 23Z

    Использование '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 будет интерпретироваться в строгом режиме. Слово лексическая область здесь важно. См. этот ответ для более подробного объяснения.

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

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

      

    Масштаб

         

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

         

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

         

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

         

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

         

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

         

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

         

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

         

    Шумная ошибка

         

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

         

    восьмиштырьковый

         

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

         

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

         

    и так далее

         

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

         

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

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

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

      

    implements, interface, let, package, private, protected, public, static и yield

    Дальнейшее чтение

    151
    2017-05-23 12: 02: 50Z
    1. это очень хорошее объяснение. Однако у меня есть одно сомнение в том, что я могу использовать «строгий» режим в сочетании с другими библиотеками java-скриптов, такими как Angular js?
      2016-08-05 03: 39: 33Z
    2. @ UVM: директива строгого режима влияет только на лексическую область видимости. т.е. только файл /функция, в которой он объявлен. Если у вас есть другой файл /функция, у которой нет директивы 'use strict', они будут выполняться в нестрогом режиме, даже если они вызваны из функции, работающей в строгом режиме. См. этот ответ для объяснения.
      2016-08-05 04: 11: 33Z
    3. Это не совсем правильно. 'use strict' меняет способ выполнения кода.
      2016-10-22 19: 04: 31Z
    4. При втором взгляде вы правы. Я думал, вы имели в виду, что он только генерирует исключения, но не меняет способ работы кода (например, изменение this). Теперь я вижу, что вы имели в виду вызов других функций.
      2016-10-23 03: 55: 08Z
    5. В некоторых случаях восьмеричное полезно. Синтаксис C для него ужасен, но мне бы хотелось, чтобы языки добавили новый восьмеричный синтаксис, который мог бы позволить исключить форму начального нуля. Конечно, для Javascript поддерживать форму с начальным нулем было просто глупо.
      2017-02-09 21: 08: 22Z

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

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

    Например,

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

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

        
    131
    2016-02-25 15: 54: 56Z
    1. 2014-01-18 13: 21: 12Z

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

    Вы можете обратиться к документации по 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() завершит выполнение.
    • В строгом режиме объект arguments объекта содержит статическую копию значений, которые передаются этой функции. В обычном режиме объект arguments имеет несколько «магическое» поведение: элементы массива и параметры именованной функции ссылаются на одно и то же значение.
    • В строгом режиме вы получите SyntaxError, когда за оператором delete следует неквалифицированный идентификатор (переменная, функция или параметр функции). В обычном режиме выражение delete ничего не делает и оценивается как false.
    • В строгом режиме вы получите TypeError при попытке удалить не настраиваемое свойство. (В обычном режиме попытка просто терпит неудачу, и выражение delete оценивается как false).
    • В строгом режиме это считается синтаксисомl ошибка при попытке определить несколько свойств с одинаковым именем для литерала объекта. (В обычном режиме ошибки нет.)
    • В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с одинаковым именем. (В обычном режиме ошибки нет.)
    • В строгом режиме восьмеричные литералы недопустимы (это литералы, начинающиеся с 0x. (В нормальном режиме некоторые реализации допускают восьмеричные литералы.)
    • В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение и не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
    • В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают TypeError в функции в строгом режиме. Кроме того, некоторые свойства вызывающих и аргументов функций в строгом режиме вызывают TypeError, когда вы пытаетесь их прочитать.
    92
    2015-07-12 20: 31: 23Z
    1. "В строгом режиме восьмеричные литералы не допускаются (это литералы, которые начинаются с 0x ...)" восьмеричные литералы начинаются с начального 0.
      2016-08-11 19: 52: 32Z

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

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

    Несколько важных вещей, которые я узнал после использования use strict:

    Предотвращает объявление глобальной переменной:

     
    var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};
    
    function Tree(typeOfTree) {
        var age;
        var leafCount;
    
        age = typeOfTree.age;
        leafCount = typeOfTree.leafCount;
        nameoftree = typeOfTree.name;
    };
    
    var tree1 = new Tree(tree1Data);
    console.log(window);
    

    Теперь этот код создает nameoftree в глобальной области видимости, доступ к которой можно получить с помощью window.nameoftree. Когда мы реализуем use strict, код выдаст ошибку.

      

    Uncaught ReferenceError: nameoftree не определено

    Образец

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

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

    Образец

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

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

      

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

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

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

        
    80
    2014-10-21 13: 31: 24Z

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

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

        
    59
    2012-03-10 03: 31: 15Z
    1. Тогда что он делает?
      2012-05-20 14: 47: 37Z
    2. ... это описывает частично совместимость, но не то, что на самом деле делает.
      2012-07-11 16: 04: 02Z

    При добавлении "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() { } 
      

    Источники:

    55
    2017-10-24 10: 50: 18Z

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

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

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

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

    для получения дополнительной информации посетите строгий режим - JavaScript

        
    51
    2014-10-29 17: 34: 22Z

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

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

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

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

    49
    2014-10-26 10: 34: 02Z
    1. Необязательный строгий режим не имеет ничего общего с тем, что вы заявили. Настоящая причина заключается в том, чтобы не нарушать существующий код, который может не соответствовать .
      2013-10-31 13: 34: 21Z
    2. Действительно, менее опытные кодировщики должны быть first , чтобы включить «use strict»;
      2014-08-19 05: 37: 20Z

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

        
    44
    2016-02-25 15: 55: 42Z

    Цитирование из w3schools :

      

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

         

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

         

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

         

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

         

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

         

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

         

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

         

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

         

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

         

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

         

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

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

        
    38
    2018-08-13 03: 15: 37Z

    "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 .     

    33
    2018-08-30 15: 16: 03Z

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

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

        
    29
    2014-03-29 19: 39: 26Z

    Маленькие примеры для сравнения:

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

    р>

     
    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
        
    20
    2018-11-18 16: 31: 07Z
    1. Обратите внимание, что приведенный выше код добавит переменную i в глобальную область видимости (как правило, это не лучшая практика и строгий режим помогает избежать этого).
      2017-02-18 12: 41: 13Z
    2. Может кто-нибудь объяснить второй пример? Я не понимаю Разве не this === 'a' в обоих примерах?
      2019-02-06 09: 24: 02Z

    Обратите внимание, что 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]] внутренний слот начинается с пролога директивы, который содержит директиву Use Strict.
    •   
    • Код функции, который предоставляется в качестве аргументов встроенным конструкторам Function и Generator, является кодом строгого режима, если последний аргумент является строкой, которая при обработке является FunctionBody , которая начинается с пролога директивы который содержит директиву об использовании строго
    •   
        
    18
    2016-04-12 00: 25: 07Z

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

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

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

        
    12
    2017-06-18 03: 14: 24Z

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

        
    11
    2016-06-14 23: 18: 44Z

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

        
    10
    2016-05-17 22: 31: 29Z

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

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

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

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

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

    • Безопасный eval ()

    • Ошибки для неизменяемых

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

        
    10
    2016-10-17 14: 09: 17Z

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

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

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

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

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

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

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

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

        
    10
    2019-02-06 09: 40: 32Z

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

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

        
    9
    2019-01-04 02: 04: 58Z
    1. хорошая работа, бикаш ....
      2019-06-04 06: 35: 30Z

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

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

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

    Неудобство

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

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

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

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

    3
    2019-01-28 10: 42: 25Z
источник размещен Вот
Другие вопросы