javascript - ¿Cómo join() produce diferentes resultados dependiendo de los argumentos?

arrays function

Question

No puedo entender por qué la llamada join () a continuación produce resultados diferentes, dependiendo del tipo de argumento (s) proporcionado.

Esto es lo que encontré:

var test = function() {
var args = Array.prototype.join.call(arguments,"_");
return args
};
console.log(test([1,2,3])) // #1: returns 1,2,3
console.log(test(1,2,3)) // #2: returns 1_2_3

Dada la unión (argumentos, ''_''), ¿no debería producir una cadena delimitada por _ en las dos pruebas anteriores? ¿Por qué # 1 devuelve un valor delimitado por comas en su lugar?

Answer 1

Cuando se pasa una matriz para test , el objeto de arguments convierte en una matriz de matrices , no en una matriz simple de valores simples. Es la diferencia entre

arguments = [[1,2,3]];

y

arguments = [1,2,3];

Cuando se llama a .join en una matriz de matrices, cada matriz interna se convierte de forma implícita en una cadena, lo que da como resultado ''1,2,3'' : los valores de las matrices internas no se .join Los hijos inmediatos de la matriz externa se .join por el delimitador.

Answer 2

El primero, el primer argumento es [1,2,3] que se une con el segundo argumento, que no es nada -> la salida es [1,2,3].toString() .

La segunda llamada, en realidad está uniendo los 3 argumentos, dando como resultado una salida de 1_2_3 .

Answer 3

El resultado es diferente, porque los arguments son diferentes.

En la primera llamada ( test([1,2,3]) , tiene un argumento que es una matriz. En la segunda llamada, tiene 3 argumentos, cada uno de los cuales es un número.

Array.prototype.join está destinado a ser llamado sobre arreglos. Stringificará cada uno de los elementos de la matriz.

En su primer caso, sus argumentos "array" solo tienen un miembro, que es un array en sí mismo. Este argumento será stringfied. Un array stringfied se convierte exactamente en lo que se registra en su código.

Answer 4

En el primer ejemplo, no está llamando a .join en la matriz sino a los arguments . Esa variable se rellenará con un objeto similar a una matriz que tiene una matriz como primer índice, en esencia, está llamando al equivalente de:

let myArguments = [[1, 2, 3]];
console.log(myArguments.join("_"));

en lugar de lo que haces (el equivalente a) en el segundo ejemplo:

let myArguments = [1, 2, 3];
console.log(myArguments.join("_"));

Answer 5

En su código, solo tiene un argumento en el primer ejemplo, que es una matriz. Unir un solo elemento eliminará los paréntesis:

var test = function() {
var args = Array.prototype.join.call(arguments,"_");
return args
};
console.log(test([1,2,3])) // args = [[1,2,3]]
console.log(test(1,2,3)) // args = [1,2,3]
console.log([[1,2,3]].join(''_''))
console.log([1,2,3].join(''_''))

Otra forma de ver esto es proporcionar otra matriz como un argumento para test() :

var test = function() {
var args = Array.prototype.join.call(arguments,"_");
return args
};
console.log(test([1,2,3], [4,5,6]))

Answer 6

Porque está pasando un argumento que es una matriz, por lo que lo convierte en una cadena, luego intenta unirlo a los otros argumentos (no hay ninguno), por lo que simplemente devuelve la cadena.

var test = function() {
var args = Array.prototype.join.call(arguments, "_");
return args
};
console.log(test([1, 2, 3]));
console.log(test(1, 2, 3));

Puedes resolver esto comprobando si solo se ha pasado un argumento.

var test = function() {
var args = arguments.length == 1 ? arguments[0].join("_") : Array.prototype.join.call(arguments, "_");
return args;
};
console.log(test([1, 2, 3]));
console.log(test(1, 2, 3));