JavaScript Function function understanding and practice

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 Function functions and explain their practical usage. This article mainly brings you a piece of basic teaching content about JavaScript, and about the training and understanding of Function functions. Let’s learn together.

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 The first N parameters default 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 to see from the above statement that the add variable points to a Function type Example, but this naming method is very cumbersome, 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, the first edition advocates using the second method to define functions. Regarding function declarations, a separate article is opened in advance

But The first definition method makes it very intuitive to see that add is 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 passed from The function returns.

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 After removing the reference to the function object, it points to a null reference. Therefore, the two functions add2 and add3 are not affected at all.

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

So the function can Returned as the return value of the function.

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. The last representation is still The same function.

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

Four more important attributes arguments , this , length , prototype

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

arguments.callee property stores a pointer. , the pointer points to the function entity with this arguments attribute (which is equivalent to the function name)

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

length attribute representation The current function receives the maximum number of parameters

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: same-name coverage, arguments objects, default return values wait.

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

Anonymous functions: Introducing the characteristics of anonymous functions: 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:

Detailed introduction of the register_shutdown_function function

javascript Function function understanding and Practical combat_Basic knowledge

Detailed explanation of how to use the function bind method in Javascript

The above is the detailed content of JavaScript Function function understanding and practice. For more information, please follow other related articles on the PHP Chinese website!