Detailed explanation of Function in JavaScript_javascript skills

The keyword function is used to define functions.

Copy code The code is as follows:

//Function declarative definition:
function funcname([arg1[,args[...,argn]]]){
statements
}
//Function expression definition:
var funcname = function ([arg1[,args[...,argn]]]){
statements
};

Note that the curly braces in the function statement are required, even if the function body contains only one statement.

In JavaScript, a function is a specific instance of the Function class. And they all have the same properties and methods as other reference types.

The function name is actually a pointer to the function object, and the function can be used as a parameter to participate in parameter passing and return value.

Object properties of functions

Because the function is an instance of Function, and the function name is just a reference address of the instance. Therefore, it can participate in the parameter passing process of the function as parameters and return values.

Copy code The code is as follows:

function call_some_function(some_function, some_argument) {
Return some_function(some_argument);
}
function add_10(num) {
Return num 10;
}
console.log(call_some_function(add_10,20)); //30

Internal properties of functions

arguments | this
•The arguments object stores the parameters passed to the function
•arguments.length returns the number of parameters passed in
•Note: The length attribute indicates the default number of parameters received when the function is defined. arguments.length represents the number of arguments received when the function is actually executed.

Copy code The code is as follows:

function test_arguments() {
If (arguments.length == 2) {
console.log(arguments.length);
console.log(arguments);
} else {
console.log(arguments.length);
console.log(arguments);
arguments.callee(4, 5);
};
}(1, 2, 3)
/**
 3
{ '0': 1, '1': 2, '2': 3 }
2
{ '0': 4, '1': 5 }
 **/

•arguments.callee() is mainly used in situations where the function itself is called in a recursive function. The difference between js and other languages ​​is that the function name is just a pointer and can be changed at any time. Using the function name to call itself in a function is highly coupled and may cause problems. However, arguments.callee() calling itself will avoid this problem

Copy code The code is as follows:

function factorial(num) {
If (num <= 1) {
Return 1;
} else {
Return num * factorial(num - 1);
};
}
function callee_f(num) {
If (num <= 1) {
Return 1;
} else {
Return num * arguments.callee(num - 1);
};
}
factorial(10); //Run normally
f = factorial;
factorial = null;
f(10); //error
callee_f(10); //Run normally
f = callee_f;
callee_f = null;
f(10); //Run normally

•This is mainly used to help functions refer to objects in the scope of the function.

Copy code The code is as follows:

var color = 'red';
function syaColor() {
console.log(this.color);
}
syaColor(); //red
var o = new Object();
o.color = 'blue';
o.sayColor = sayColor;
o.sayColor(); //blue

call() and apply()

call() and apply() are its own methods included in every function. As mentioned before, functions are defined objects, so when calling a function, this in the function is a call to the current and next variables. If you want to change the domain space where the function is executed, you can use call() and apply() to achieve this.

Copy code The code is as follows:

color = 'red';
var o = {color: 'blue'};
function sayColor() {
console.log(this.color);
}
sayColor(); //red
sayColor.call(this); //red
sayColor.call(o); //blue

The functions of app() and call() are the same. The main difference lies in the parameters passed in.

call(this,para1,prar2,prar3) The first parameter is the scope in which the function is to be executed, and the following parameters are the input parameters of the function. Write as many as there are.

apply(this,[para1,para2,prara3]) The first parameter is also the scope where the function is to be executed, followed by an Array array object.

The biggest benefit of using call()/apply() to expand the scope is the decoupling of objects and methods.

Built-in Objects

Global object can be understood as the outermost object. All objects, as well as properties and methods that do not belong to other objects, are included in the Global object.
* isNaN(x) is used to check whether the parameter x is a number. Returns false if it is a number, otherwise returns true
* isFinite(x) is used to check whether the parameter x is infinite/small. If it is infinite/small, it returns true
* parseInt(x) is used to parse strings and return integers
* parseFloat(x) is used to parse strings and return floating point numbers
* encodeURI() and encodeURIComponent() will perform special UTF-8 encoding on the string to avoid some special characters so that the browser can understand it. The main difference between them is that encodeURI() will not encode special characters that are URIs themselves, while encodeURIComponent() will encode all non-standard characters it finds.

Copy code The code is as follows:

var uri = "http://www.wrox.com/illegal value.htm#start";
//http://www.wrox.com/illegal value.htm#start
console.log(encodeURI(uri))
//http://www.wrox.com/illegal value.htm#start
console.log(encodeURIComponent(uri))

•The corresponding decoding functions are decodeURI() and decodeURIComponent()
•eval(script) is used to execute the content of the script in the interpreter and return the corresponding results. Very powerful!

Note: In the browser, the windows object encapsulates the Global object and assumes many additional tasks and functions.

Math object is another built-in object. Provides mathematical calculation functions for JavaScript.

The above is the entire content of this article. I hope you guys like it and it can be helpful to you.