Detailed explanation of expressions and constructors in javascript basic tutorial

Function definition expression

A function defined in an expression, the name of the function is optional

var functionName = function([arg1 [,arg2 [...,argn]]]){
    statement;
}
var functionName = function funcName([arg1 [,arg2 [...,argn]]]){
    statement;
}

Anonymous function (anonymous function) is also called a lambda function, which is a function Functions without identifiers after keywords

Generally speaking, functions defined in expressions do not need names, which makes the code that defines them more compact. Function definition expressions are particularly suitable for defining functions that will only be used once

var tensquared = (function(x) {return x*x;}(10));

While a function definition expression contains a name, the local scope of the function will contain a name bound to the function object. In fact, the name of the function will become a local variable inside the function

var test = function fn(){
   return fn;
}
console.log(test);//fn(){return fn;}
console.log(test());//fn(){return fn;}
console.log(test()());//fn(){return fn;}

For named function expressions, the function name is equivalent to the formal parameter of the function object and can only be used inside the function; while the variable name Equivalent to the actual parameters of the function object, it can be used both inside and outside the function

var test = function fn(){   
  return fn === test;
}
console.log(test());//true
console.log(test === fn);//ReferenceError: fn is not defined

The function defines a non-standard name attribute, through which the name specified by the given function can be accessed. The name of this attribute The value is always equal to the identifier following the function keyword. The name attribute of the anonymous function is empty

//IE11-浏览器无效，均输出undefined
//chrome在处理匿名函数的name属性时有问题，会显示函数表达式的名字
function fn(){};
console.log(fn.name);//'fn'
var fn = function(){};
console.log(fn.name);//''，在chrome浏览器中会显示'fn'
var fn = function abc(){};
console.log(fn.name);//'abc'

Function constructor

The Function constructor accepts any number of parameters, but the last parameter is always are regarded as the function body, and the previous parameters enumerate the parameters of the new function

var functionName = new Function(['arg1' [,'arg2' [...,'argn']]],'statement;');

[Note] The Function constructor cannot specify a function name, it creates an anonymous function

Technically, this is a function expression. However, it is not recommended because this syntax causes the code to be parsed twice. The first time is to parse the regular javascript code, and the second time is to parse the string passed into the constructor, which affects performance

var sum = new Function('num1','num2','return num1 + num2');
//等价于
var sum = function(num1,num2){    
  return num1+num2;
}

Functions created by the Function() constructor will always be compiled globally executed within the scope. Therefore, the Function() constructor is similar to eval() executed in the global scope

var test = 0;
function fn(){
    var test = 1;
    return new Function('return test');
}
console.log(fn()());//0

[Note] Not all functions can become constructors

var o = new Math.min();//Uncaught TypeError: Math.min is not a constructor

The above is the detailed content of Detailed explanation of expressions and constructors in javascript basic tutorial. For more information, please follow other related articles on the PHP Chinese website!