Comprender el argumento y los atributos de destinatario

argumentos

　　La definición de la función en javascript no especifica el tipo del parámetro de la función, y la llamada a la función no realiza ninguna verificación de tipo en el valor del parámetro real entrante . De hecho, las llamadas a funciones de JavaScript ni siquiera verifican la cantidad de parámetros pasados ​​en

function add(x){
return x+1;
}
console.log(add(1));//2
console.log(add('1'));//'11'
console.log(add());//NaN
console.log(add(1,2));//2

homónimo

En el modo no estricto, los parámetros con el mismo nombre pueden aparecer en la función y solo se puede acceder al último parámetro con el mismo nombre

function add(x,x,x){
return x;
}
console.log(add(1,2,3));//3

　　而在严格模式下，出现同名形参会抛出语法错误

function add(x,x,x){
'use strict';
return x;
}
console.log(add(1,2,3));//SyntaxError

Número de parámetros

　　Cuando el número de parámetros formales especificados por la declaración de la función de referencia real es menor, los parámetros formales restantes se establecerán en valores indefinidos

function add(x,y){
console.log(x,y);//1 undefined
}
add(1);

　　常常使用逻辑或运算符给省略的参数设置一个合理的默认值

function add(x,y){
y = y || 2;
console.log(x,y);//1 2
}
add(1);

[Nota] En realidad, usar y || 2 no es riguroso, establecer explícitamente valores falsos (indefinido, nulo, falso, 0, -0, '', NaN) dará el mismo resultado. Por lo tanto, debe configurarse razonablemente de acuerdo con la escena real.

　　Cuando hay más parámetros reales que parámetros formales, los parámetros reales restantes no se pueden obtener directamente y se debe usar el objeto de argumentos que se mencionará.

　　Los parámetros en javascript están representados internamente por una matriz. La función siempre recibe esta matriz, independientemente de los parámetros contenidos en la matriz. En el cuerpo de la función, puede acceder a esta matriz de parámetros a través del objeto de argumentos, para obtener cada parámetro pasado a la función. El objeto arguments no es una instancia de Array, es un objeto similar a una matriz, y se puede acceder a cada elemento del mismo usando la sintaxis de corchetes

function add(x){
console.log(arguments[0],arguments[1],arguments[2])//1 2 3
return x+1;
}
add(1,2,3);

　　arguments对象的length属性显示实参的个数，函数的length属性显示形参的个数
	
function add(x,y){
console.log(arguments.length)//3
return x+1;
}
add(1,2,3);
console.log(add.length);//2

　　形参只是提供便利，但不是必需的

function add(){
return arguments[0] + arguments[1];
}
console.log(add(1,2));//3

parámetro de objeto

　　Cuando una función contiene más de 3 parámetros formales, es un dolor de cabeza recordar el orden correcto de los parámetros reales en la función de llamada.

function arraycopy(/*array*/from,/*index*/form_start,/*array*/to,/*index*/to_start,/*integer*/length){
//todo
}

Los parámetros se pasan como pares de nombre/valor para que el orden de los parámetros no importe. Al definir una función, todos los parámetros reales entrantes se escriben en un objeto separado, y se pasa un objeto al llamar, y el par de nombre/valor en el objeto son los datos de parámetros reales que realmente se necesitan.

function easycopy(args){
arraycopy(args.from,args.form_start || 0,args.to,args.to_start || 0, args.length);
}
var a = [1,2,3,4],b =[];
easycopy({form:a,to:b,length:4});

Sincronizar

　　Cuando el número de parámetros formales y parámetros reales es el mismo, el valor del objeto de argumentos y el valor del parámetro formal correspondiente se mantienen sincronizados.

function test(num1,num2){
console.log(num1,arguments[0]);//1 1
arguments[0] = 2;
console.log(num1,arguments[0]);//2 2
num1 = 10;
console.log(num1,arguments[0]);//10 10
}
test(1);

[Nota] Aunque los parámetros con nombre tienen el mismo valor que el objeto de argumentos correspondiente, no están en el mismo espacio de nombres. Sus espacios de nombres son independientes, pero los valores están sincronizados,
　　pero en modo estricto, los valores del objeto argumentos y los valores de los parámetros formales son independientes.

function test(num1,num2){
'use strict';
console.log(num1,arguments[0]);//1 1
arguments[0] = 2;
console.log(num1,arguments[0]);//1 2
num1 = 10;
console.log(num1,arguments[0]);//10 2
}
test(1);

　　当形参并没有对应的实参时，arguments对象的值与形参的值并不对应

function test(num1,num2){
console.log(num1,arguments[0]);//undefined,undefined
num1 = 10;
arguments[0] = 5;
console.log(num1,arguments[0]);//10,5
}
test();

propiedades internas

【llamada】

　　El objeto de argumentos tiene un atributo llamado callee, que es un puntero a la función que posee el objeto de argumentos.

　　Aquí está la función factorial clásica ( recursiva )

function factorial(num){
if(num <=1){
return 1;
}else{
return num* factorial(num-1);
}
} 
console.log(factorial(5));//120

Sin embargo, la ejecución de la función anterior está estrechamente relacionada con el nombre de la función, y arguments.callee se puede usar para eliminar el desacoplamiento de funciones.

function factorial(num){
if(num <=1){
return 1;
}else{
return num* arguments.callee(num-1);
}
} 
console.log(factorial(5));//120

　　但在严格模式下，访问这个属性会抛出TypeError错误

function factorial(num){
'use strict';
if(num <=1){
return 1;
}else{
return num* arguments.callee(num-1);
}
} 
//TypeError: 'caller', 'callee', and 'arguments' properties may not be accessed on strict mode functions or the arguments objects for calls to them
console.log(factorial(5));

En este caso, se puede usar una expresión de función con nombre

var factorial = function fn(num){

if (num <=1){

return 1;

} else {

return num*fn(num-1);

}

};

console.log(factorial(5)); //120