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

Remova o primeiro elemento

Quero remover o primeiro elemento da matriz para que ele se torne:

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

Remova o segundo elemento

Para estender essa pergunta, e se eu quiser remover o segundo elemento da matriz para que ele se torne:

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

Para uma solução mais flexível, use a splice()função Ele permite remover qualquer item em uma matriz com base no valor do índice:

var indexToRemove = 0;
var numberToRemove = 1;

arr.splice(indexToRemove, numberToRemove);

shift()é ideal para a sua situação. shift()remove o primeiro elemento de uma matriz e retorna esse elemento. Este método altera o comprimento da matriz.

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

array.shift(); // 1

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

O Array.prototype.shiftmétodo remove o primeiro elemento de uma matriz e o retorna. Modifica a matriz original.

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

arr.slice(begin[,end])

não é destrutivo, a emenda e a mudança modificarão sua matriz original

Escreveu um pequeno artigo sobre como inserir e excluir elementos em posições arbitrárias em matrizes Javascript.

Aqui está o pequeno trecho para remover um elemento de qualquer posição. Isso estende a classe Array em Javascript e adiciona o método remove (index).

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

Portanto, para remover o primeiro item do seu exemplo, chame arr.remove ():

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

Para remover o segundo item,

arr.remove(1);

Aqui está um pequeno artigo com métodos de inserção e exclusão para a classe Array.

Essencialmente, isso não é diferente das outras respostas usando emenda, mas o nome splicenão é intuitivo e, se você tiver essa chamada em todo o aplicativo, isso dificulta a leitura do código.

Talvez algo parecido com isto:

arr=arr.slice(1);

Outras respostas são grandes, eu só queria acrescentar uma solução alternativa com ES6função de matriz: filter.

filter() cria uma nova matriz com elementos que se enquadram em um determinado critério a partir de uma matriz existente.

Portanto, você pode usá-lo facilmente para remover itens que não atendem aos critérios. Os benefícios desta função são que você pode usá-la em uma matriz complexa, não apenas em seqüência e número.

Alguns exemplos :

Remova o primeiro 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]

Remova o segundo elemento :

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

Remova o elemento ímpar :

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

Remover itens que não estão em estoque

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

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

Você pode usar o recurso de atribuição de reestruturação do ES6 com um operador restante. Uma vírgula indica onde você deseja remover o elemento e o operador restante (... arr) para fornecer os elementos restantes da matriz.

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()tem a propriedade interessante de que não se pode usá-lo para remover o primeiro elemento. Então, precisamos recorrer a

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

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

Solução datilografada que não altera a matriz original

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

Existem várias maneiras de remover um elemento de uma matriz. Deixe-me apontar as opções mais usadas abaixo. Estou escrevendo esta resposta porque não consegui encontrar um motivo adequado para o que usar em todas essas opções. A resposta para a pergunta é a opção 3 ( Emenda () ).

1) SHIFT () - Remova o primeiro elemento da matriz original e retorne o primeiro elemento

Consulte a referência para Array.prototype.shift () . Use isso somente se desejar remover o primeiro elemento e somente se estiver de acordo em alterar a matriz original.

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 () - Retorna uma cópia da matriz, separada por um índice inicial e um índice final

Consulte a referência para Array.prototype.slice () . Você não pode remover um elemento específico desta opção. Você pode cortar apenas a matriz existente e obter uma parte contínua da matriz. É como cortar a matriz dos índices que você especificar. A matriz original não é afetada.

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 () - Altere o conteúdo da matriz removendo ou substituindo elementos em índices específicos.

Consulte a referência para Array.prototype.splice () . O método splice () altera o conteúdo de uma matriz removendo ou substituindo elementos existentes e / ou adicionando novos elementos no local. Retorna uma matriz atualizada. A matriz original é atualizada.

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"]

Você também pode fazer isso com reduzir:

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())