javascript displays the difference between global variables and implicit global variables

This article mainly introduces the difference between javascript display global variables and implicit global variables. Friends in need can refer to it

In JavaScript, there are two ways to declare global variables

• Use var to display declared global variables

• Do not use var to declare implicit global variables

The difference between the two It depends on whether it can be deleted through the delete operator

Let’s first look at a piece of code

var a = 'a'; // 显式声明的全局变量
b = 'b'; // 隐式声明的全局变量
 
console.log(a); // a
console.log(b); // b
console.log(window.a); // a
console.log(window.b); // b

In js, global variables are actually global objects (window) properties, so global variables declared in both ways can be obtained through window

Try to delete using delete

// 显式声明的全局变量不能被删除
delete a; // 返回 false 
 
// 隐式声明的全局变量可以被删除
delete b; // 返回 true 
 
// 删除情况
console.log(typeof a); // string
console.log(typeof b); // undefined

## The #delete operator can delete the attributes of an object, but if the attribute is a non-configurable attribute, it will return false when deleted (an exception will be thrown in strict mode)

This means using Variables declared with var are not configurable. Use getOwnPropertyDescriptor to obtain an object describing the property characteristics to verify this

Object.getOwnPropertyDescriptor(window, a); // {value: "a", writable: true, enumerable: true, configurable: false}
Object.getOwnPropertyDescriptor(window, b); // {value: "b", writable: true, enumerable: true, configurable: true}

The fundamental difference between the two is the explicit declaration The variables are not configurable and cannot be deleted through the delete operator

It should be noted that once the configurable value is false, the object describing the attribute characteristics cannot be modified, so the declared global variables cannot be displayed by modifying the attribute descriptor. Can be deleted by delete, but conversely, implicitly declared global variables cannot be deleted by delete

b = 'b';
var descriptor = Object.getOwnPropertyDescriptor(window, b);
descriptor.configurable = false;
Object.defineProperty(window, b, descriptor);
delete b; // 返回 false

The following are the additions of other netizens

JavaScript Global Variables and Implicit Global Variables

There is a small difference between implicit global variables and explicitly defined global variables, which is the ability to leave variables undefined through the delete operator.

1. Global variables created through var (created in any program other than functions) cannot be deleted.

2. Implicit global variables created without var (regardless of whether they are created in a function) can be deleted.

This shows that, technically, implicit global variables are not really global variables, but they are properties of the global object. Properties can be deleted through the delete operator, but variables cannot:

// 定义三个全局变量
var global_var = 1;
global_novar = 2; // 反面教材
(function () {
  global_fromfunc = 3; // 反面教材
}());
 
// 试图删除
delete global_var; // false
delete global_novar; // true
delete global_fromfunc; // true
 
// 测试该删除
typeof global_var; // "number"
typeof global_novar; // "undefined"
typeof global_fromfunc; // "undefined"

In the browser, the global object can be used in any part of the code through the window attribute. Positional access (unless you do something outrageous, like declaring a local variable named window). But in other contexts, this convenience property might be called something else (or even not available in the program). If you need to access the global object without a hard-coded window identifier, you can do the following in function scope at any level:

var global = (function () {
  return this;
}());

This This method can obtain the global object at any time, because it is called as a function in the function (not constructed through new), and this always points to the global object. Actually this bug doesn't apply to ECMAScript 5 strict mode, so you have to take a different form when in strict mode. For example, if you are developing a JavaScript library, you can wrap your code in an immediate function, and then pass a reference to this from the global scope as a parameter of your immediate function.

The above is the difference between javascript display global variables and implicit global variables. The fundamental difference between the two is that explicitly declared variables are not configurable and cannot be deleted through the delete operator

More javascript display For related articles on the difference between global variables and implicit global variables, please pay attention to the PHP Chinese website!