JavaScript
Tryb ścisły

Składnia

• „stosować ścisłe”;
• „użyj ścisłego”;
• „użyj ścisłego”;

Uwagi

Dla całych skryptów

Tryb "use strict"; można zastosować do całych skryptów, umieszczając instrukcję "use strict"; przed innymi oświadczeniami.

"use strict";
// strict mode now applies for the rest of the script

Tryb "use strict" jest włączony tylko w skryptach, w których zdefiniowano "use strict" . Możesz łączyć skrypty zi bez trybu ścisłego, ponieważ stan ścisły nie jest współużytkowany przez różne skrypty.

Dla funkcji

Tryb "use strict"; można również zastosować do pojedynczych funkcji, dodając "use strict"; instrukcja na początku deklaracji funkcji.

function strict() {
   "use strict";
   // strict mode now applies to the rest of this function
   var innerFunction = function () {
     // strict mode also applies here
   };
}

function notStrict() {
  // but not here
}

Tryb ścisły będzie również stosowany do wszystkich funkcji o zasięgu wewnętrznym.

Zmiany właściwości globalnych

W zakresie bez trybu ścisłego, gdy zmienna jest przypisywana bez inicjalizacji słowem kluczowym var , const lub let , jest ona automatycznie deklarowana w zakresie globalnym:

a = 12;
console.log(a); // 12

Jednak w trybie ścisłym każdy dostęp do niezadeklarowanej zmiennej spowoduje zgłoszenie błędu odniesienia:

"use strict";
a = 12; // ReferenceError: a is not defined
console.log(a);

Jest to przydatne, ponieważ JavaScript ma wiele możliwych zdarzeń, które czasem są nieoczekiwane. W trybie bez ścisłego zdarzenia te często prowadzą deweloperów do przekonania, że są to błędy lub nieoczekiwane zachowanie, dlatego też włączenie trybu ścisłego powoduje, że wszelkie zgłaszane błędy zmuszają ich do dokładnego zrozumienia, co się dzieje.

"use strict";
                       // Assuming a global variable mistypedVariable exists
mistypedVaraible = 17; // this line throws a ReferenceError due to the 
                       // misspelling of variable

Ten kod w trybie ścisłym wyświetla jeden możliwy scenariusz: zgłasza błąd odniesienia, który wskazuje na numer wiersza przypisania, umożliwiając programistom natychmiastowe wykrycie błędu w nazwie zmiennej.

W trybie innym niż ścisły, oprócz faktu, że nie zostanie zgłoszony żaden błąd, a przypisanie zostanie pomyślnie wykonane, mistypedVaraible zostanie automatycznie zadeklarowany w zakresie globalnym jako zmienna globalna. Oznacza to, że programista musi ręcznie wyszukać to konkretne zadanie w kodzie.

Co więcej, wymuszając deklarację zmiennych, programista nie może przypadkowo zadeklarować zmiennych globalnych wewnątrz funkcji. W trybie innym niż ścisły:

function foo() { 
   a = "bar"; // variable is automatically declared in the global scope
}
foo();
console.log(a); // >> bar

W trybie ścisłym konieczne jest jawne zadeklarowanie zmiennej:

function strict_scope() { 
   "use strict";
   var a = "bar"; // variable is local
}
strict_scope();
console.log(a); // >> "ReferenceError: a is not defined"

Zmienna może być również zadeklarowana na zewnątrz i po funkcji, co pozwala na jej użycie na przykład w zakresie globalnym:

function strict_scope() { 
   "use strict";
   a = "bar"; // variable is global
}
var a;
strict_scope();
console.log(a); // >> bar

Zmiany właściwości

Tryb ścisły zapobiega także usuwaniu nieodwracalnych właściwości.

"use strict";
delete Object.prototype; // throws a TypeError

Powyższe zdanie zostanie po prostu zignorowane, jeśli nie użyjesz trybu ścisłego, ale teraz wiesz, dlaczego nie działa zgodnie z oczekiwaniami.

Zapobiega także rozszerzaniu właściwości, których nie można rozszerzyć.

var myObject = {name: "My Name"}
Object.preventExtensions(myObject);

function setAge() {
    myObject.age = 25;   // No errors
}

function setAge() {
    "use strict";
    myObject.age = 25;  // TypeError: can't define property "age": Object is not extensible
}

Zachowanie listy argumentów funkcji

arguments obiekt zachowują się inaczej w trybie ścisłym i nie ścisłym . W trybie ścisłym obiekt argument będzie odzwierciedlał zmiany wartości obecnych parametrów, jednak w trybie ścisłym wszelkie zmiany wartości parametru nie zostaną odzwierciedlone w obiekcie argument .

function add(a, b){
    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 5,10
}

add(1, 2);

W powyższym kodzie obiekt arguments zmienia się, gdy zmieniamy wartość parametrów. Jednak w trybie ścisłym to samo nie zostanie odzwierciedlone.

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 1,2
}

Warto zauważyć, że jeśli jeden z parametrów jest undefined , a my staramy się zmienić wartość parametru w trybie zarówno surowe lub w trybie non-ścisłym te arguments obiekt pozostaje niezmieniona.

Tryb ścisły

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // undefined,undefined 
                                             // 1,undefined
    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // undefined,undefined
                                             // 1, undefined
}
add();
// undefined,undefined 
// undefined,undefined

add(1)
// 1, undefined
// 1, undefined

Tryb nieograniczony

function add(a,b) {

    console.log(arguments[0],arguments[1]);

    a = 5, b = 10;

    console.log(arguments[0],arguments[1]);
}
add();
// undefined,undefined 
// undefined,undefined

add(1);
// 1, undefined
// 5, undefined

Zduplikowane parametry

Tryb ścisły nie pozwala na używanie zduplikowanych nazw parametrów funkcji.

function foo(bar, bar) {}  // No error. bar is set to the final argument when called

"use strict";
function foo(bar, bar) {}; // SyntaxError: duplicate formal argument bar

Zakres funkcji w trybie ścisłym

W trybie ścisłym funkcje zadeklarowane w bloku lokalnym są niedostępne poza blokiem.

"use strict";
{
  f(); // 'hi'
  function f() {console.log('hi');}
}
f(); // ReferenceError: f is not defined

Pod względem zakresu deklaracje funkcji w trybie ścisłym mają ten sam rodzaj wiązania co let lub const .

Nieproste listy parametrów

function a(x = 5) {
  "use strict";
}

jest niepoprawny JavaScript i zgłosi błąd SyntaxError ponieważ nie można użyć dyrektywy "use strict" w funkcji z listą parametrów nieprostych, jak powyższa - domyślne przypisanie x = 5

Nieproste parametry obejmują -

• Domyślne przypisanie

function a(x = 1) {
  "use strict";
}

• Niszczenie

function a({ x }) {
  "use strict";
}

• Pozostałe parametry

function a(...args) {
  "use strict";
}