una - pasar variables entre funciones javascript
¿Es posible enviar una cantidad variable de argumentos a una función de JavaScript? (10)
¿Es posible enviar una cantidad variable de argumentos a una función de JavaScript desde una matriz?
var arr = [''a'',''b'',''c'']
var func = function()
{
// debug
alert(arguments.length);
//
for(arg in arguments)
alert(arg);
}
func(''a'',''b'',''c'',''d''); // prints 4 which is what I want, then ''a'',''b'',''c'',''d''
func(arr); // prints 1, then ''Array''
Recientemente escribí una gran cantidad de Python y es un patrón maravilloso poder aceptar varargs y enviarlos. p.ej
def func(*args):
print len(args)
for i in args:
print i
func(''a'',''b'',''c'',''d''); // prints 4 which is what I want, then ''a'',''b'',''c'',''d''
func(*arr) // prints 4 which is what I want, then ''a'',''b'',''c'',''d''
¿Es posible en JavaScript enviar una matriz para ser tratado como la matriz de argumentos?
En realidad, puede pasar tantos valores como desee a cualquier función de JavaScript. Los parámetros nombrados explícitamente obtendrán los primeros valores, pero TODOS los parámetros se almacenarán en la matriz de argumentos.
Para pasar la matriz de argumentos en forma "desempaquetada", puede usar apply, como tal (cf Functional Javascript ):
var otherFunc = function() {
alert(arguments.length); // Outputs: 10
}
var myFunc = function() {
alert(arguments.length); // Outputs: 10
otherFunc.apply(this, arguments);
}
myFunc(1,2,3,4,5,6,7,8,9,10);
Este es un programa de ejemplo para calcular la suma de enteros para argumentos variables y la matriz en enteros. Espero que esto ayude.
var CalculateSum = function(){
calculateSumService.apply( null, arguments );
}
var calculateSumService = function(){
var sum = 0;
if( arguments.length === 1){
var args = arguments[0];
for(var i = 0;i<args.length; i++){
sum += args[i];
}
}else{
for(var i = 0;i<arguments.length; i++){
sum += arguments[i];
}
}
alert(sum);
}
//Sample method call
// CalculateSum(10,20,30);
// CalculateSum([10,20,30,40,50]);
// CalculateSum(10,20);
Hay dos métodos a partir de ES2015.
Los arguments Object
Este objeto está integrado en funciones, y se refiere apropiadamente a los argumentos de una función. Sin embargo, técnicamente no es una matriz, por lo que las operaciones de matriz típicas no funcionarán en ella. El método sugerido es usar Array.from o el operador de propagación para crear una matriz a partir de él.
He visto otras respuestas mencionar usando slice . No hagas eso. Impide optimizaciones (fuente: MDN ).
Array.from(arguments)
[...arguments]
Sin embargo, yo diría que los arguments son problemáticos porque esconden lo que una función acepta como entrada. Una función de arguments generalmente se escribe así:
function mean(){
let args = [...arguments];
return args.reduce((a,b)=>a+b) / args.length;
}
A veces, el encabezado de la función se escribe como el siguiente para documentar los argumentos en forma de C:
function mean(/* ... */){ ... }
Pero eso es raro
En cuanto a por qué es problemático, tome C, por ejemplo. C es retrocompatible con un antiguo dialecto pre-ANSI del lenguaje conocido como K & R C. K & R C permite a los prototipos de funciones tener una lista de argumentos vacía.
int myFunction();
/* This function accepts unspecified parameters */
ANSI C proporciona una función para varargs ( ... ) y void para especificar una lista de argumentos vacía.
int myFunction(void);
/* This function accepts no parameters */
Muchas personas declaran inadvertidamente funciones con una lista de argumentos unspecified ( int myfunction(); ), cuando esperan que la función tome cero argumentos. Esto es técnicamente un error porque la función aceptará argumentos. Cualquier número de ellos.
Una función varargs adecuada en C toma la forma:
int myFunction(int nargs, ...);
Y JavaScript realmente tiene algo similar a esto.
Operador de propagación / Parámetros de reposo
Ya te he mostrado el operador de propagación, en realidad.
...name
Es bastante versátil y también se puede usar en la lista de argumentos de una función ("parámetros de descanso") para especificar varargs de una manera muy bien documentada:
function mean(...args){
return args.reduce((a,b)=>a+b) / args.length;
}
O como una expresión lambda:
((...args)=>args.reduce((a,b)=>a+b) / args.length)(1,2,3,4,5); // 3
Yo prefiero el operador de propagación. Es limpio y autodocumentado.
La función apply toma dos argumentos; el objeto al que se vinculará, y los argumentos, representados con una matriz.
some_func = function (a, b) { return b }
some_func.apply(obj, ["arguments", "are", "here"])
// "are"
Los operadores splat y spread forman parte de ES6, la próxima versión planificada de Javascript. Hasta el momento, solo Firefox los admite. Este código funciona en FF16 +:
var arr = [''quick'', ''brown'', ''lazy''];
var sprintf = function(str, ...args)
{
for (arg of args) {
str = str.replace(/%s/, arg);
}
return str;
}
sprintf.apply(null, [''The %s %s fox jumps over the %s dog.'', ...arr]);
sprintf(''The %s %s fox jumps over the %s dog.'', ''slow'', ''red'', ''sleeping'');
Tenga en cuenta la sintaxis awkard para la propagación. La sintaxis habitual de sprintf(''The %s %s fox jumps over the %s dog.'', ...arr); aún no es compatible . Aquí puede encontrar una tabla de compatibilidad de ES6 .
Tenga en cuenta también el uso de for...of , otra adición de ES6. Usar for...in matrices es una mala idea .
Para aquellos que fueron redireccionados desde Pasar una cantidad variable de argumentos de una función a otra (que no debe marcarse como un duplicado de esta pregunta):
Si está intentando pasar una cantidad variable de argumentos de una función a otra, desde JavaScript 1.8.5 puede simplemente llamar a apply() en la segunda función y pasar el parámetro arguments :
var caller = function()
{
callee.apply( null, arguments );
}
var callee = function()
{
alert( arguments.length );
}
caller( "Hello", "World!", 88 ); // Shows "3".
Nota: El primer argumento es el this parámetro para usar. Pasar null llamará a la función desde el contexto global, es decir, como una función global en lugar del método de algún objeto.
De acuerdo con este documento , la especificación ECMAScript 5 redefinió el método apply() para tomar cualquier "objeto similar a una matriz genérica", en lugar de estrictamente una matriz. Por lo tanto, puede pasar directamente la lista de arguments a la segunda función.
Probado en Chrome 28.0, Safari 6.0.5 e IE 10. Pruébelo con este JSFiddle .
Sí, puede pasar la variable no. de argumentos a una función. Puede usar apply para lograr esto.
P.ej:
var arr = ["Hi","How","are","you"];
function applyTest(){
var arg = arguments.length;
console.log(arg);
}
testarr.apply(null,arr);
Se llama operador splat . Puedes hacerlo en JavaScript usando apply :
var arr = [''a'',''b'',''c'',''d''];
var func = function() {
// debug
console.log(arguments.length);
console.log(arguments);
}
func(''a'',''b'',''c'',''d''); // prints 4 which is what I want, then ''a'',''b'',''c'',''d''
func(arr); // prints 1, then ''Array''
func.apply(null, arr);
Uso de apply :
var arr = [''a'',''b'',''c''];
var func = function() {
alert(arguments.length);
for(var i = 0; i < arguments.length; i++) {
alert(arguments[i]);
}
};
func.apply(null, arr);
Observe que null se usa como el primer argumento de apply, que establecerá this palabra clave en el objeto Global (ventana) dentro de func .
También tenga en cuenta que el objeto arguments no es realmente una matriz, puede convertirlo por:
var argsArray = Array.prototype.slice.call(arguments);
Y tal vez sea útil para usted, que puede saber cuántos argumentos espera una función:
var test = function (one, two, three) {};
test.length == 3;
Pero de todos modos puede pasar una cantidad arbitraria de argumentos ...
(function(window) {
var proxied = window.alert;
window.alert = function() {
return proxied.apply(window, arguments);
};
}(this));
alert(13, 37);