Passando argumentos adiante para outra função javascript

Eu tentei o seguinte sem sucesso:

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

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

a(1,2,3);

Na função a, posso usar a palavra-chave argumentos para acessar uma matriz de argumentos, na função b estes são perdidos. Existe uma maneira de passar argumentos para outra função javascript como eu tento fazer?

Use .apply()para ter o mesmo acesso à argumentsfunção in b, assim:

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

Você pode testá-lo aqui .

Operador de propagação

O operador de spread permite que uma expressão seja expandida em locais onde vários argumentos (para chamadas de função) ou vários elementos (para literais de matriz) são esperados.

O ECMAScript ES6 adicionou um novo operador que permite fazer isso de uma maneira mais prática: ... Operador de propagação .

Exemplo sem usar o 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 Esse trecho retorna um erro de sintaxe se o seu navegador ainda usa o ES5.

^{Nota do Editor: Uma vez que os usos do snippet console.log(), você deve abrir JS consola do seu navegador para ver o resultado - não haverá nenhum resultado na página.}

Ele exibirá este resultado:

Em resumo, o operador de dispersão pode ser usado para diferentes propósitos se você estiver usando matrizes; portanto, também pode ser usado para argumentos de função. Você pode ver um exemplo semelhante explicado nos documentos oficiais: Parâmetros de descanso

A explicação que nenhuma das outras respostas fornece é que os argumentos originais ainda estão disponíveis, mas não na posição original no argumentsobjeto.

O argumentsobjeto contém um elemento para cada parâmetro real fornecido para a função. Quando você liga para avocê fornecer três argumentos: os números 1, 2e,3 . Então, argumentscontém [1, 2, 3].

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

Quando você chama b, no entanto, passa exatamente um argumento: ao argumentsobjeto de. Então argumentscontém [[1, 2, 3]](ou seja, um elemento, que éa o argumentsobjeto de s , que possui propriedades que contêm os argumentos originais para a).

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

a(1,2,3);

Como o @Nick demonstrou, você pode usar applypara fornecer um argumentsobjeto definido na chamada.

O seguinte alcança o mesmo resultado:

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

Mas applyé a solução correta no caso geral.

tente isso

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