javascript use strict - Что делает «использование строгих» в JavaScript, и каковы причины этого?




13 Answers

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

Процитировать некоторые интересные части:

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

А также:

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

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

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

// Non-strict code...

(function(){
  "use strict";

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

// Non-strict code... 

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

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

В настоящее время он поддерживается всеми основными браузерами (панель IE 9 и ниже) .

node js

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

Проблема в строке 1 символ 1: Отсутствует инструкция «use strict».

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

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

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




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

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

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

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

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

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

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

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

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

  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 Developer Network ]




Слово предостережения, все, что вы программируете с жесткой зарядкой: применение "use strict" к существующему коду может быть опасным! Эта вещь не какая-то приятная, счастливая наклейка, которую вы можете похлопать по коду, чтобы сделать ее «лучше». При "use strict" правильной "use strict" прагмы браузер внезапно выбрасывает исключения в случайных местах, которые он никогда не бросал раньше, просто потому, что в этом месте вы делаете то, что позволяет по умолчанию / свободно JavaScript, но строгий JavaScript не нравится! У вас могут быть нарушения строгости, скрывающиеся в редко используемых вызовах вашего кода, которые будут генерировать исключение только тогда, когда они в конечном итоге будут запущены - скажем, в производственной среде, которую используют ваши платежные клиенты!

Если вы собираетесь сделать решительный шаг, рекомендуется применять "use strict" наряду с комплексными модульными тестами и строго сконфигурированной задачей сборки JSHint, которая даст вам уверенность в том, что нет темного угла вашего модуля, который взорвется ужасно, потому что вы включили строгий режим. Или, эй, вот еще один вариант: просто не добавляй "use strict" к любому из ваших устаревших кодов, это, наверное, безопаснее, честно. ОПРЕДЕЛЕННО НЕ добавляйте "use strict" для любых модулей, которые вы не владеете или не поддерживаете, например, сторонние модули.

Я думаю, что даже если это смертоносный живот в клетке, "use strict" может быть хорошим, но вы должны сделать это правильно. Лучшее время, чтобы идти строгим, - это когда ваш проект является новым, и вы начинаете с нуля. Настройте JSHint/JSLint со всеми предупреждениями и параметрами, сложенными так же сильно, как ваша команда может вздрагивать, получить хорошую систему сборки / тестирования / утверждения, которую можно настроить как Grunt+Karma+Chai , и только THEN начнет маркировать все ваши новые модули как "use strict" . Будьте готовы вылечить множество ошибок и предупреждений. Убедитесь, что все понимают гравитацию, настроив сборку на FAIL, если JSHint/JSLint вызывает какие-либо нарушения.

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




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

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

Например,

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

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




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

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

Sample

Исключает with утверждением:

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

Sample

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

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

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

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

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




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

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

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

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

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




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

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

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

Современная практика JavaScript всегда должна вызывать «Use Strict»; Прагма. Единственная причина, по которой ECMA Group сделала вариант «Строгий», - это разрешить доступ менее опытным кодовым машинам к JavaScript и дать время для адаптации к новым и более безопасным способам кодирования.




Цитата из w3schools :

Директива «Использовать строгую»

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

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

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

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

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

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

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

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

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

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

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




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

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

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

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

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

Примеры использования «use strict»:
Строгий режим для функций: Аналогично, чтобы вызвать строгий режим для функции, поставьте точное утверждение «use strict»; (или «использовать 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 .




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

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

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



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




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

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

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

  • Исключает

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

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

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

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




JavaScript «строгий» режим вводится в ECMAScript 5.

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

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

(i) показывает ошибку, если вы пытаетесь назначить необъявленную переменную

(ii) останавливает вас от перезаписи ключевых системных библиотек JS

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

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

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




Related