JavaScript
Strikt läge

Syntax

• "använda strikt";
• "använda strikt";
• "använd strikt";

Anmärkningar

För hela skript

Strikt läge kan tillämpas på hela skript genom att placera uttalandet "use strict"; före andra uttalanden.

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

Strikt läge är endast aktiverat i skript där du definierar "use strict" . Du kan kombinera skript med och utan strikt läge, eftersom det strikta tillståndet inte delas mellan olika skript.

För funktioner

Strikt läge kan också tillämpas på enstaka funktioner genom att förbereda "use strict"; uttalande i början av funktionsdeklarationen.

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
}

Strikt läge kommer också att gälla för alla inre scopedfunktioner.

Ändringar av globala egenskaper

I ett icke-strikt lägeomfång, när en variabel tilldelas utan att initialiseras med var , const eller let nyckelordet, deklareras den automatiskt i det globala omfånget:

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

I strikt läge kommer emellertid all åtkomst till en odeklarerad variabel att kasta ett referensfel:

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

Detta är användbart eftersom JavaScript har ett antal möjliga händelser som ibland är oväntade. I icke-strikt läge leder dessa händelser ofta till utvecklare att tro att de är buggar eller oväntat beteende, och genom att möjliggöra strikt läge tvingas alla fel som kastas veta exakt vad som görs.

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

Den här koden i strikt läge visar ett möjligt scenario: den kastar ett referensfel som pekar på uppdragets radnummer, vilket gör att utvecklaren omedelbart kan upptäcka misstypen i variabelns namn.

I icke-strikt läge, förutom det faktum att inget fel kastas och tilldelningen genomförs framgångsrikt, kommer den mistypedVaraible automatiskt att förklaras i den globala räckvidden som en global variabel. Detta innebär att utvecklaren måste leta upp manuellt denna specifika uppgift i koden.

Genom att tvinga deklaration av variabler kan utvecklaren dessutom inte av misstag deklarera globala variabler i funktioner. I icke-strikt läge:

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

I strikt läge är det nödvändigt att uttryckligen deklarera variabeln:

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

Variabeln kan också deklareras utanför och efter en funktion, vilket gör att den kan användas till exempel i det globala omfånget:

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

Ändringar av egenskaper

Strikt läge förhindrar också att du kan ta bort ej återställbara egenskaper.

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

Ovanstående uttalande skulle helt enkelt ignoreras om du inte använder strikt läge, men nu vet du varför det inte körs som förväntat.

Det förhindrar dig också att utöka en ej utvidgbar egenskap.

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
}

Beteende för en funktions argumentlista

arguments objekt uppför sig annorlunda i strikt och icke strikt läge. I icke-strikt läge kommer argument att återspegla förändringarna i värdet på de parametrar som finns, men i strikt läge kommer ändringar av parameterns värde inte att återspeglas i 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);

För ovanstående kod ändras arguments när vi ändrar värdet på parametrarna. Men för strikt läge kommer samma inte att återspeglas.

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
}

Det är värt att notera att om någon av parametrarna är undefined , och vi försöker ändra parameterns värde i både strikt läge eller icke-strikt läge, förblir arguments oförändrat.

Strikt läge

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

Icke-strikt läge

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

Duplicera parametrar

Strikt läge tillåter inte att du använder duplicerade funktionsparametrar namn.

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

Funktionsomfattning i strikt läge

I strikt läge är funktioner som deklarerats i ett lokalt block otillgängliga utanför blocket.

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

Omfattningsvis har funktionsdeklarationer i strikt läge samma typ av bindning som let eller const .

Icke-enkla parameterlistor

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

är ogiltigt JavaScript och kommer att kasta en SyntaxError eftersom du inte kan använda direktivet "use strict" i en funktion med icke-enkel parameterlista som den ovan - standardtilldelning x = 5

Icke-enkla parametrar inkluderar -

• Standardtilldelning

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

• destrukturering

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

• Vila params

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