Pasar argumentos a otra función de JavaScript

He intentado lo siguiente sin éxito:

function a(args){
    b(arguments);
}

function b(args){
    // arguments are lost?
}

a(1,2,3);

En la función a, puedo usar la palabra clave argumentos para acceder a una matriz de argumentos, en la función b se pierden. ¿Hay alguna forma de pasar argumentos a otra función de JavaScript como intento hacer?

Use .apply()para tener el mismo acceso a la argumentsfunción in b, así:

function a(){
    b.apply(null, arguments);
}
function b(){
   alert(arguments); //arguments[0] = 1, etc
}
a(1,2,3);​

Puedes probarlo aquí .

Operador extendido

El operador de propagación permite que una expresión se expanda en lugares donde se esperan múltiples argumentos (para llamadas a funciones) o múltiples elementos (para literales de matriz).

ECMAScript ES6 agregó un nuevo operador que le permite hacer esto de una manera más práctica: ... Operador extendido .

Ejemplo sin usar el applymétodo:

function a(...args){
  b(...args);
  b(6, ...args, 8) // You can even add more elements
}
function b(){
  console.log(arguments)
}

a(1, 2, 3)

Note Este fragmento devuelve un error de sintaxis si su navegador todavía usa ES5.

^{Nota del editor: Desde los usos de fragmento console.log(), debe abrir la consola JS de su navegador para ver el resultado - no habrá ninguna consecuencia en la página.}

Mostrará este resultado:

En resumen, el operador de propagación se puede usar para diferentes propósitos si está usando matrices, por lo que también se puede usar para argumentos de función, puede ver un ejemplo similar explicado en los documentos oficiales: parámetros de descanso

La explicación de que ninguna de las otras respuestas proporciona es que los argumentos originales todavía están disponibles, pero no en la posición original en el argumentsobjeto.

los arguments objeto contiene un elemento para cada parámetro real proporcionado a la función. Cuando se llama a austed suministra tres argumentos: los números 1, 2y, 3. Entonces, argumentscontiene [1, 2, 3].

function a(args){
    console.log(arguments) // [1, 2, 3]
    b(arguments);
}

Cuando llama b, sin embargo, pasa exactamente un argumento:a el argumentsobjeto de. Por lo tanto, argumentscontiene [[1, 2, 3]](es decir, un elemento, que es ael argumentsobjeto, que tiene propiedades que contienen los argumentos originales para a).

function b(args){
    // arguments are lost?
    console.log(arguments) // [[1, 2, 3]]
}

a(1,2,3);

Como demostró @Nick, puede usar applypara proporcionar un argumentsobjeto establecido en la llamada.

Lo siguiente logra el mismo resultado:

function a(args){
    b(arguments[0], arguments[1], arguments[2]); // three arguments
}

Pero apply es la solución correcta en el caso general.

prueba esto

function global_func(...args){
  for(let i of args){
    console.log(i)
  }
}


global_func('task_name', 'action', [{x: 'x'},{x: 'x'}], {x: 'x'}, ['x1','x2'], 1, null, undefined, false, true)




//task_name
//action
//(2) [{...},
//    {...}]
//    {
//        x:"x"
//    }
//(2) [
//        "x1",
//        "x2"
//    ]
//1
//null
//undefined
//false
//true
//func