Tengo var ar = [1, 2, 3, 4, 5]y quiero alguna función getSubarray(array, fromIndex, toIndex), ese resultado de la llamada getSubarray(ar, 1, 3)es una nueva matriz [2, 3, 4].
Respuestas:
Echa un vistazo a Array.slice(begin, end)
const ar = [1, 2, 3, 4, 5];
// slice from 1..3 - add 1 as the end index is not included
const ar2 = ar.slice(1, 3 + 1);
console.log(ar2);arno ha sido modificado. console.log(ar); // -> [1, 2, 3, 4, 5]
Para un uso simple de slice, use mi extensión a Array Class:
Array.prototype.subarray = function(start, end) {
if (!end) { end = -1; }
return this.slice(start, this.length + 1 - (end * -1));
};Luego:
var bigArr = ["a", "b", "c", "fd", "ze"];Prueba1 :
bigArr.subarray(1, -1);<["b", "c", "fd", "ze"]
Test2:
bigArr.subarray(2, -2);<["c", "fd"]
Test3:
bigArr.subarray(2);<["c", "fd", "ze"]
Podría ser más fácil para los desarrolladores que vienen de otro idioma (es decir, Groovy).
Array.prototype.containsa Array.prototype.includes.
subarraymétodo ofrece resultados inesperados. bigArr.slice(1,-1)devuelve ['b','c','fd'], lo que cabría esperar (el -1 elimina un elemento del final de la nueva matriz). Pero bigArr.subarray(1,-1)devuelve lo mismo que bigArr.subarray(1), es decir todo desde la posición 1 hasta el final de bigArr. También está obligando a los usuarios a dar siempre números negativos como endparámetro. Cualquiera end >= -1da el mismo resultado que cuando end === undefined. Por otro lado, bigArr.slice(1,3)regresa ['b','c'], lo que nuevamente se espera.
const array_one = [11, 22, 33, 44, 55];
const start = 1;
const end = array_one.length - 1;
const array_2 = array_one.slice(start, end);
console.log(array_2);La pregunta en realidad es pedir una nueva matriz , por lo que creo que una mejor solución sería combinar la respuesta de Abdennour TOUMI con una función de clonación:
function clone(obj) {
if (null == obj || "object" != typeof obj) return obj;
const copy = obj.constructor();
for (const attr in obj) {
if (obj.hasOwnProperty(attr)) copy[attr] = obj[attr];
}
return copy;
}
// With the `clone()` function, you can now do the following:
Array.prototype.subarray = function(start, end) {
if (!end) {
end = this.length;
}
const newArray = clone(this);
return newArray.slice(start, end);
};
// Without a copy you will lose your original array.
// **Example:**
const array = [1, 2, 3, 4, 5];
console.log(array.subarray(2)); // print the subarray [3, 4, 5, subarray: function]
console.log(array); // print the original array [1, 2, 3, 4, 5, subarray: function][ http://stackoverflow.com/questions/728360/most-elegant-way-to-clone-a-javascript-object]
Array.prototype.slicedevuelve una copia ya. Array.prototype.splicemodifica la matriz original.
sliceya devuelve una copia superficial, haciendo subarrayinnecesaria esta implementación. Pero también vale la pena mencionar que ha parcheado un mono un objeto incorporado, que es un gran no-no. Ver los comentarios sobre la respuesta de Abdennour TOUMI .