Introduction to JavaScript strict mode use strict

1. Overview

1.1 What is strict mode?

Strict mode is a more restrictive variant of JavaScript . Strict mode is not a subset of JavaScript , it is semantically different from normal code.

Although most browsers now support strict mode, some older versions of browsers still do not support strict mode, so do not use strict mode without testing the strict mode features.

Strict mode and non-strict mode can coexist in JavaScript , so strict mode can be selectively added to the script.

1.2 Purpose of strict mode

The purpose of using strict mode is as follows:

First, strict mode turns JavaScript gotchas into obvious errors.
Secondly, strict mode fixes some errors that are difficult for the engine to optimize: the same code is sometimes faster in strict mode than in non-strict mode.
Strict mode disables some syntax that may be defined in future versions.

2. Enable strict mode

There are two ways to enable strict mode in JavaScript : globally enabling strict mode and locally enabling strict mode.

2.1 Enable strict mode globally

To enable global strict mode, you only need to enter a string before all the codes. The string is as follows:

"use strict"; // or 'use strict';

It should be noted that if the previous JavaScript code is in non-strict mode, it is recommended not to enable strict mode for this code, as this may cause problems. It is recommended to enable strict mode locally first and adjust the code step by step.

2.2 Locally enable strict mode

To enable strict mode locally, you can add the string " use strict " to the first line of a specified function; this string will keep the function in non-strict mode.

The example code for enabling strict mode is as follows:

//Globally enable strict mode //"use strict"
v = 100
console.log(v)

function fun() {
  // Locally enable strict mode 'use strict'
  vv = 200
  console.log(vv)
}
// fun() throws an exception vv is not defined

3. Variables in strict mode

3.1 Prevent accidental creation of variables

The so-called accidentally created variables are variables declared without using the var keyword. When in strict mode, if a global variable is accidentally created, an exception will be thrown.

The sample code is as follows:

'use strict'
// In non-strict mode, creating a variable like this will not report an error, but in strict mode, creating a variable like this will throw an exception v = 100
console.log(v)

3.2 Silent failure turns into exception

Silent failure means no error and no effect. In strict mode, it will be turned into an exception.

3.3 Disable the delete keyword

In non-strict mode, using the delete keyword on a global variable will fail silently, while in strict mode, an exception will be thrown. The sample code is as follows

'use strict'
var v = 100
delete v // SyntaxError: Deleteofanunqualifiedidentifierinstrictmode.
console.log(v)

3.4 Restrictions on variable names

In strict mode, JavaScript also has restrictions on variable names. In particular, reserved words cannot be used as variable names. Using reserved words as symbols as variable names will result in syntax errors.

4. Objects in strict mode

4.1 Non-deletable attributes

In non-strict mode, using the delete keyword on a non-deletable property will fail silently, while in strict mode, an exception will be thrown.

The sample code is as follows:

"use strict"
delete Object.prototype; //Throw an exception

4.2 Assignment of read-only properties

In non-strict mode, assigning a value to a read-only property will fail silently, but in strict mode an exception will be thrown. The sample code is as follows:

'use strict'

var obj = {}
Object.defineProperty(obj, 'name', {
  value: 'a bowl of porridge',
})
obj.name = 'Yiwan Zhou' //Throws an exception

4.3 Non-extensible objects

Adding new properties to a non-extensible object will fail silently in non-strict mode, but will throw an exception in strict mode.

The sample code is as follows:

// Enable global strict mode 'use strict'
var obj = {}
//Make it non-extensible Object.preventExtensions(obj)
//Extend the object attribute obj.name = 'Yiwan Zhou' //Throw an exception

5. Functions in strict mode

5.1 Parameter names must be unique

In non-strict mode, function parameters can be repeated, but in strict mode, if the function parameters are repeated, an exception will be thrown. The sample code is as follows:

'use strict'

function fun(a, a, b) {
  console.log(a + a + b)
}
/*
 *The result in non-strict mode is 7=2+2+3
 *An exception will be thrown in strict mode*/
fun(1, 2, 3)

5.2 Differences in arguments

arguments object behaves differently in strict mode and non-strict mode.

The differences are as follows:

• In non-strict mode, changes to the actual parameter values ​​will also be reflected in the arguments object.
• In strict mode, named parameters are completely separate from the ' arguments' object.
  

The sample code is as follows:

'use strict'

function fun(v) {
  v = '100'
  console.log(v)
  console.log(arguments[0])
}
/*
 * The result printed in non-strict mode is 100, 100
 *The results printed in strict mode are 100, 200
 */
fun(200)

5.3 arguments.callee property

In non-strict mode, you can use the arguments.callee property, which returns the current function name. In strict mode, using this property will throw an exception.

The sample code is as follows:

'use strict'

function fun(){
console.log(arguments.callee);
}
fun()//Throw an exception

5.4 Restrictions on Function Declarations

In strict mode, functions can only be declared in the global scope and local scope. It is an error to declare function syntax outside of these two scopes (such as if statement blocks).

The sample code is as follows:

'use strict'

function fun() {
  console.log(arguments.callee)
}
fun() //Throw an exception

6. Increase the scope of eval()

In strict mode, variables created with the eval() function can only be used inside the function.

An exception will be thrown when used externally. The sample code is as follows:

'use strict'
eval('var v=100')
console.log(v) //Throw an exception

7. Suppress this

When using the apply() or call() method of Fucntion in non-strict mode, null or undefined values ​​will be converted to the global object. In strict mode, this value of the function is always the specified value.

The sample code is as follows:

// Enable strict mode 'use strict'

var v = 100

function fn() {
  console.log(this.v)
}

var obj = {
  v: 200,
}

fn.call(obj) //this points to the global object

Conclusion:

This article basically introduces all the situations of strict mode, which is sufficient to solve the problems related to strict mode in daily development.

This is the end of this article about JavaScript strict mode use strict . For more information about JavaScript strict mode use strict, please search previous articles on 123WORDPRESS.COM or continue to browse the related articles below. I hope you will support 123WORDPRESS.COM in the future!