Ho var ar = [1, 2, 3, 4, 5]e voglio qualche funzione getSubarray(array, fromIndex, toIndex), quel risultato di chiamata getSubarray(ar, 1, 3)è nuovo array [2, 3, 4].
Risposte:
Date un'occhiata al 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);arnon è modificato. console.log(ar); // -> [1, 2, 3, 4, 5]
Per un semplice utilizzo di slice, usa la mia estensione per la classe di array:
Array.prototype.subarray = function(start, end) {
if (!end) { end = -1; }
return this.slice(start, this.length + 1 - (end * -1));
};Poi:
var bigArr = ["a", "b", "c", "fd", "ze"];Test1 :
bigArr.subarray(1, -1);<["b", "c", "fd", "ze"]
test2:
bigArr.subarray(2, -2);<["c", "fd"]
test3:
bigArr.subarray(2);<["c", "fd", "ze"]
Potrebbe essere più facile per gli sviluppatori che provengono da un'altra lingua (ad esempio Groovy).
Array.prototype.containsin Array.prototype.includes.
subarraymetodo offre risultati inaspettati. bigArr.slice(1,-1)ritorna ['b','c','fd'], cosa che ti aspetteresti (-1 batte un elemento alla fine del nuovo array). Ma bigArr.subarray(1,-1)restituisce lo stesso di bigArr.subarray(1), vale a dire tutto dalla posizione 1 alla fine di bigArr. Stai anche forzando gli utenti a fornire sempre numeri negativi come endparametro. Qualsiasi end >= -1dà lo stesso risultato di quando end === undefined. D'altra parte, i bigArr.slice(1,3)ritorni ['b','c'], che è previsto di nuovo.
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 domanda è in realtà chiedere un nuovo array , quindi credo che una soluzione migliore sarebbe quella di combinare la risposta di Abdennour TOUMI con una funzione di clone:
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.slicerestituisce già una copia. Array.prototype.splicemodifica l'array originale.
slicegià detto, restituisce già una copia superficiale, rendendo subarraysuperflua questa implementazione. Ma vale anche la pena ricordare che hai riparato una scimmia con un oggetto incorporato, che è un grande no-no. Vedi i commenti sulla risposta di Abdennour TOUMI .