JavaScript Function Function Understanding and Practical Combination_Basic Knowledge

The editor brings you a piece of basic teaching content about javascript, about the training and understanding of the Function function in javascript, if you are interested in javascript Let’s study together with our classmates.

Function function is the foundation of JavaScript and a tipping point for realizing functions. Through example analysis, we will give you a deeper understanding of the Function function and explain its practical usage.

Function is indeed an object. And any function we define is actually an instance of the Function object, which can also be understood as pointing to an instance of the Function object.

Since it is an instance of the object instance, it must point to a reference of the Function type. Since it points to a memory address of a reference type, you can also simply understand the function we defined as a variable, which points to an address of a reference type. This address Points to an instance of the Function object.

Since the function we defined is actually a variable, this function instance address can point to multiple variables at the same time.

Look at the following code:

var add = new Function("n", "m", "return n + m");

The above is the standard function definition, which calls the constructor of the Function object, this constructor defaults the first N parameters to the parameters of the new function, until the last parameter is considered to be the function body of the new function.

It is very intuitive from the above statement You can see that the add variable points to an instance of Function type, but this naming method is very cumbersome and is equivalent to:

(1)Function expression

var add=function(n,m){
return n+m;
}

(2) Function declaration

function add(n,m){
return n+m;
}

Because The declaration in the JavaScript language is advanced, so the first edition advocates using the second method to define functions. There is a separate article about function declaration in advance

But the first definition method makes it very intuitive to see that add is a A variable pointing to a function instance.

Since it is a variable, it can be assigned to other variables, passed as a parameter in the function, or returned from the function.

So var add2=add3 =add; Now all three variables point to the reference of this instance, now add=null; In the future, the two functions add2 and add3 can be used without being affected, because add points to the reference of null after removing the reference of the function object. Therefore It does not affect the add2 and add3 functions at all.

So the function can be passed in as a parameter of other functions.

So the function can be used as the return value of the functionReturn.

Because the function name is just a variable pointing to the function instance, there will be no overloading of functions in JavaScript, because the same variable points to the same reference address. In the end, it still represents the same function.

Since a function is an instance of an object, it should have properties and methods. Therefore, functions in JavaScript have properties and methods.

The four more important properties are arguments, this, length, and prototype

arguments represents the parameter array of the current function. This attribute is very special. It also has an attribute called callee. The

arguments.callee attribute stores a pointer that points to the argument attribute that owns it. The function entity (which is equivalent to the function name)

this attribute is the current environment, similar to this in C#, indicating the current context

The length attribute indicates the maximum number of parameters received by the current function

prototype represents the prototype of the function, which means that the methods of the object instance are completely saved. In other words, all the methods on the prototype are inherited. For example, toString() valueOf(), etc.

Next, let’s take a look at the types of function functions

Ordinary functions: Introducing the characteristics of ordinary functions: overwriting with the same name, arguments objects, default return values, etc.

function ShowName(name) {
 alert(name);
}

##Anonymous function: Introduction to anonymous functions Features: variable anonymous functions, nameless anonymous functions.

//变量匿名函数，左侧可以为变量、事件等
var anonymousNormal = function (p1, p2) {
 alert(p1+p2);
}
anonymousNormal(3,6);//输出9

## Closure function: Introduce the characteristics of closure function.

function funA() {
 var i = 0;
 function funB() { //闭包函数funB
  i++;
  alert(i)
 }
 return funB;
}
var allShowA = funA(); //全局变量引用：累加输出1,2,3,4等
 
function partShowA() {
 var showa = funA();//局部变量引用：只输出1
 showa();
}

Related recommendations:

Explanation of passing by value of js function parameters

The above is the detailed content of JavaScript Function Function Understanding and Practical Combination_Basic Knowledge. For more information, please follow other related articles on the PHP Chinese website!