JavaScript variable declaration instance analysis

This article describes the method of javascript variable declaration. Share it for your reference. The specific analysis is as follows:

A variable should be declared before using js. Variables are declared using the keyword var.

If the initial value is not specified for the variable in the var declaration statement, the value of the variable is undefined.
You do not need to specify the variable type when declaring a variable, the js variable can be any data type.

It is legal and harmless to repeatedly declare variables using var statements. If the repeated declaration has an initializer, it is no different from a simple assignment statement.

If you try to read a variable that is not declared, js will report an error. In ECMAScript5 strict mode, assigning values ​​to an undeclared variable will also be an error; however, historically, in non-declared mode, if you assign values ​​to an undeclared variable, js will actually create a property of the same name to the global object, and it seems that it works like a correctly declared global variable. This means you can be lucky enough not to declare global variables, but this is a bad habit that can cause a lot of bugs, it is best to always use var to declare variables.

In the function body, local variables with the same name will override global variables.
Although you can write code in global scope without writing var statements, you must use var statements when declaring local variables. Please refer to the following code:

scope = "global";
function foo(){
  scope="local"
  //fk!  We just modified the global variable!  !  !}

In a programming language similar to C language, each piece of code in curly braces has its own scope, and variables are invisible outside of the declared code segment. We call it block scope; and js does not have block scope, but instead uses function scope: variables are defined in the function body that declares them and any function body nested in this function body (whether it is nested or outer nested?)
The function scope of js means that all variables declared within a function are always visible in the function body, which means that the variables can even be used before they are declared. This feature of js is informally called hoisting, that is, all variables declared in js function (but no assignment) are "advanced" to the top of the function body.

var scope = "global";
function f(){
  (scope);
  //Output "undefined" instead of "global"  var scope = "local";
  //The variables are assigned initial values ​​here, but the variables are defined anywhere in the function body.  (scope);
  //Output"local"

The above code is equivalent to:

function f(){
  var scope;
  (scope);
  scope = "local";
  (scope);
  }

When a js global variable is declared, an attribute of the global object is actually defined.
When a variable is declared with var, the created property cannot be configured, that is, it cannot be deleted with the delete operator; but when you do not use strict mode and assign a value to an undeclared variable, js will automatically create a global variable. The variables created in this way are normal configurable properties of the global object and can be deleted:

var x = 1; 
y = 2;
 = 3; //Same as abovedelete x; //Return false, variable cannot be deleteddelete y; //Return true, variable is deleteddelete  //Same as above

I hope this article will be helpful to everyone's JavaScript programming.