var arr = [1,2,3,5,6];

Rimuovi il primo elemento

Voglio rimuovere il primo elemento dell'array in modo che diventi:

var arr = [2,3,5,6];

Rimuovi il secondo elemento

Per estendere questa domanda, cosa succede se desidero rimuovere il secondo elemento dell'array in modo che diventi:

var arr = [1,3,5,6];

Per una soluzione più flessibile, utilizzare la splice()funzione. Ti consente di rimuovere qualsiasi elemento in una matrice in base al valore dell'indice:

var indexToRemove = 0;
var numberToRemove = 1;

arr.splice(indexToRemove, numberToRemove);

shift()è l'ideale per la tua situazione. shift()rimuove il primo elemento da un array e restituisce quell'elemento. Questo metodo modifica la lunghezza dell'array.

array = [1, 2, 3, 4, 5];

array.shift(); // 1

array // [2, 3, 4, 5]

Il Array.prototype.shiftmetodo rimuove il primo elemento da un array e lo restituisce. Modifica l'array originale.

var a = [1,2,3]
// [1,2,3]
a.shift()
// 1
a
//[2,3]

arr.slice(begin[,end])

non è distruttivo, splice e shift modificheranno l'array originale

Ha scritto un piccolo articolo sull'inserimento e l'eliminazione di elementi in posizioni arbitrarie negli array Javascript.

Ecco il piccolo frammento per rimuovere un elemento da qualsiasi posizione. Ciò estende la classe Array in Javascript e aggiunge il metodo remove (index).

// Remove element at the given index
Array.prototype.remove = function(index) {
    this.splice(index, 1);
}

Quindi, per rimuovere il primo elemento nell'esempio, chiama arr.remove ():

var arr = [1,2,3,5,6];
arr.remove(0);

Per rimuovere il secondo elemento,

arr.remove(1);

Ecco un piccolo articolo con i metodi insert ed delete per la classe Array.

Fondamentalmente questo non è diverso dalle altre risposte usando splice, ma il nome splicenon è intuitivo e se hai quella chiamata su tutta la tua applicazione, rende il codice più difficile da leggere.

Forse qualcosa del genere:

arr=arr.slice(1);

Altre risposte sono grandi, volevo solo aggiungere una soluzione alternativa con ES6la funzione Array: filter.

filter() crea un nuovo array con elementi che rientrano in un determinato criterio da un array esistente.

Quindi puoi usarlo facilmente per rimuovere elementi che non soddisfano i criteri. I vantaggi di questa funzione sono che è possibile utilizzarlo su array complessi non solo su stringa e numero.

Qualche esempio :

Rimuovi il primo elemento :

// Not very useful but it works
function removeFirst(element, index) {
  return index > 0;
}
var arr = [1,2,3,5,6].filter(removeFirst); // [2,3,4,5,6]

Rimuovi il secondo elemento :

function removeSecond(element, index) {
  return index != 1;
}
var arr = [1,2,3,5,6].filter(removeSecond); // [1,3,4,5,6]

Rimuovi elemento dispari :

function removeOdd(element, index) {
  return !(element % 2);
}
var arr = [1,2,3,5,6].filter(removeOdd); [2,4,6]

Rimuovi gli articoli non disponibili

const inventory = [
  {name: 'Apple', qty: 2},
  {name: 'Banana', qty: 0},
  {name: 'Orange', qty: 5}
];

const res = inventory.find( product => product.qty > 0);

È possibile utilizzare la funzione di assegnazione di destrutturazione ES6 con un operatore di riposo. Una virgola indica dove si desidera rimuovere l'elemento e l'operatore restante (... arr) per fornire gli elementi rimanenti dell'array.

const source = [1,2,3,5,6];

function removeFirst(list) {
   var  [, ...arr] = list;
   return arr;
}
const arr = removeFirst(source);
console.log(arr); // [2, 3, 5, 6]
console.log(source); // [1, 2, 3, 5, 6]

Array.splice()ha la proprietà interessante che non si può usare per rimuovere il primo elemento. Quindi, dobbiamo ricorrere a

function removeAnElement( array, index ) {
    index--;

    if ( index === -1 ) {
        return array.shift();
    } else {
        return array.splice( index, 1 );
    }
}

Soluzione dattiloscritta che non muta l'array originale

function removeElementAtIndex<T>(input: T[], index: number) {
  return input.slice(0, index).concat(input.slice(index + 1));
}

Esistono diversi modi per rimuovere un elemento da una matrice. Vorrei sottolineare le opzioni più utilizzate di seguito. Sto scrivendo questa risposta perché non sono riuscito a trovare una ragione adeguata su cosa usare da tutte queste opzioni. La risposta alla domanda è l'opzione 3 ( Splice () ).

1) MAIUSC (): rimuove il primo elemento dall'array originale e restituisce il primo elemento

Vedi riferimento per Array.prototype.shift () . Utilizzare questo solo se si desidera rimuovere il primo elemento e solo se si va bene con la modifica dell'array originale.

const array1 = [1, 2, 3];

const firstElement = array1.shift();

console.log(array1);
// expected output: Array [2, 3]

console.log(firstElement);
// expected output: 1

2) SLICE () - Restituisce una copia dell'array, separata da un indice Begin e un Index End

Vedi riferimento per Array.prototype.slice () . Non è possibile rimuovere un elemento specifico da questa opzione. È possibile prendere solo la sezione dell'array esistente e ottenere una parte continua dell'array. È come tagliare l'array dagli indici specificati. L'array originale non viene interessato.

const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

console.log(animals.slice(2));
// expected output: Array ["camel", "duck", "elephant"]

console.log(animals.slice(2, 4));
// expected output: Array ["camel", "duck"]

console.log(animals.slice(1, 5));
// expected output: Array ["bison", "camel", "duck", "elephant"]

3) SPLICE () - Cambia il contenuto dell'array rimuovendo o sostituendo gli elementi in indici specifici.

Vedi riferimento per Array.prototype.splice () . Il metodo splice () cambia il contenuto di un array rimuovendo o sostituendo elementi esistenti e / o aggiungendo nuovi elementi in atto. Restituisce l'array aggiornato. L'array originale viene aggiornato.

const months = ['Jan', 'March', 'April', 'June'];
months.splice(1, 0, 'Feb');
// inserts at index 1
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "June"]

months.splice(4, 1, 'May');
// replaces 1 element at index 4
console.log(months);
// expected output: Array ["Jan", "Feb", "March", "April", "May"]

Puoi anche farlo con riduci:

let arr = [1, 2, 3]

arr.reduce((xs, x, index) => {
        if (index == 0) {
            return xs
        } else {
            return xs.concat(x)
        }
    }, Array())

// Or if you like a oneliner
arr.reduce((xs, x, index) => index == 0 ? xs : xs.concat(x), Array())