Compartir tecnología

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

función

Cada función es una instancia del tipo Función, y la Función también tiene propiedades y métodos, al igual que otros tipos de referencia. Las funciones son objetos y el nombre de la función es un puntero al objeto de la función y no necesariamente está estrechamente vinculado a la función en sí.

Definición declarativa de función de definición de función

function sum (n1,n2){
return n1+n2;
}

Expresión de función de definición de función.

let sum = function(n1,n2){
return n1+n2;
};

función de definición de función función de flecha

let sum = (n1,n2)=>{
return n1+n2;
};

constructor de definición de función

let sum = new Function("n1","n2","return n1+n2");
/*这个构造函数接收任意多个字符串参数，
最后一个参数始终会被当成函数体，
而之前的参数都是新函数的参数*/

función de flecha

Las funciones de flecha se pueden usar en cualquier lugar donde se pueda usar una expresión de función.

let sum = (a,b)=>{
return a+b;
};
let sum1 = function(a,b){
return a+b;
};
//箭头函数适合嵌入函数的场景
let arr = [1,2,3];
console.log(arr.map(function(i) {return i+1;}));
console.log(arr.map((i)=>{return i+1;}));
//二者结果一样，但是箭头函数更为简洁
 
//如果只有一个参数，括号可以不用。只有没有参数，或者多个参数的情况下，才使用括号
 
let double = (x)=>{return 2*x;};
let triple = x => {return 3*x};
 
//箭头函数也可以不使用大括号，但这样会改变函数的行为。使用大括号就说明包含函数体，可以在一
//个函数中包含多条语句，跟常规函数一样。如果不使用，后面只能有一行代码。
 
let double = (x)=>{return 2*x;};
let triple = x=>3*x;
 

Aunque las funciones de flecha tienen una sintaxis simple, hay muchas situaciones en las que no son adecuadas. Las funciones de flecha no pueden usar argumentos, super, new.target, ni pueden usarse como constructores. Además, las funciones de flecha no tienen un atributo de prototipo.

Parámetros en funciones de flecha.

La función se define mediante la sintaxis de flechas, por lo que no se puede acceder a los parámetros pasados ​​a la función mediante la palabra clave argumentos, sino que solo se puede acceder a través de los parámetros con nombre definidos.

function foo() { 
 console.log(arguments[0]); 
} 
foo(5); // 5 
let bar = () => { 
 console.log(arguments[0]); 
}; 
bar(5); // ReferenceError: arguments is not defined

Nombre de la función

Una función puede tener varios nombres.

function sum(num1, num2) { 
 return num1 + num2; 
} 
console.log(sum(10, 10)); // 20 
let anotherSum = sum; 
console.log(anotherSum(10, 10)); // 20 
sum = null; 
console.log(anotherSum(10, 10)); // 20

Valor de parámetro predeterminado

Puede asignar un valor predeterminado a un parámetro usando = después del parámetro en la definición de la función.

function makeKing(name = 'Henry') { 
 return `King ${name} VIII`; 
} 
console.log(makeKing('Louis')); // 'King Louis VIII' 
console.log(makeKing()); // 'King Henry VIII'

Los valores de parámetros predeterminados no se limitan a valores primitivos o tipos de objetos; también se pueden usar los valores devueltos por la función de llamada

let romanNumerals = ['I', 'II', 'III', 'IV', 'V', 'VI']; 
let ordinality = 0; 
function getNumerals() { 
 // 每次调用后递增
 return romanNumerals[ordinality++]; 
} 
function makeKing(name = 'Henry', numerals = getNumerals()) { 
 return `King ${name} ${numerals}`; 
} 
console.log(makeKing()); // 'King Henry I'
console.log(makeKing('Louis', 'XVI')); // 'King Louis XVI' 
console.log(makeKing()); // 'King Henry II' 
console.log(makeKing()); // 'King Henry III'

Ampliación y recopilación de parámetros.

ES6 agrega un nuevo operador de extensión, que puede usarse para operar y combinar datos de recopilación de manera muy concisa. El escenario más útil para el operador de extensión es la lista de parámetros en una definición de función, donde puede aprovechar al máximo la tipificación débil y los parámetros de longitud variable del lenguaje. El operador de extensión se puede utilizar para pasar parámetros al llamar a una función o para definir parámetros de función.

Parámetros extendidos

let values = [1, 2, 3, 4]; 
function getSum() { 
 let sum = 0; 
 for (let i = 0; i < arguments.length; ++i) { 
 sum += arguments[i]; 
 } 
 return sum; 
} 
//不使用扩展操作符实现累加
console.log(getSum.apply(null,values));
 
//使用扩展操作符
console.log(getSum(...values));

Recopilar parámetros

Si hay parámetros con nombre delante de los parámetros recopilados, solo se recopilarán los parámetros restantes; de lo contrario, se obtendrá una matriz vacía; Debido a que el resultado de la recopilación de parámetros es variable, solo se puede utilizar como último parámetro.

 
function getProduct(...values,lastValue){}//不可以
function ignoreFirst(firstValue,...values){console.log(values)}//可以
ignoreFirst(); // [] 
ignoreFirst(1); // [] 
ignoreFirst(1,2); // [2] 
ignoreFirst(1,2,3); // [2, 3]

Declaración de función y expresión de función.

Antes de ejecutar cualquier código, el motor JavaScript lee la declaración de la función y genera la definición de la función en el contexto de ejecución. La expresión de la función debe esperar hasta que el código se ejecute en su línea antes de generar la definición de la función en el contexto de ejecución.

// 没问题 
console.log(sum(10, 10)); 
function sum(num1, num2) { 
 return num1 + num2; 
}
/*函数声明提升*/
 
 
// 会出错
console.log(sum(10, 10)); 
let sum = function(num1, num2) { 
 return num1 + num2; 
};