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

Eliminar el primer elemento

Quiero eliminar el primer elemento de la matriz para que se convierta en:

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

Eliminar el segundo elemento

Para extender esta pregunta, ¿qué pasa si quiero eliminar el segundo elemento de la matriz para que se convierta en:

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

Para una solución más flexible, use la splice()función. Le permite eliminar cualquier elemento de una matriz según el valor del índice:

var indexToRemove = 0;
var numberToRemove = 1;

arr.splice(indexToRemove, numberToRemove);

shift()Es ideal para su situación. shift()elimina el primer elemento de una matriz y devuelve ese elemento. Este método cambia la longitud de la matriz.

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

array.shift(); // 1

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

El Array.prototype.shiftmétodo elimina el primer elemento de una matriz y lo devuelve. Modifica la matriz original.

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

arr.slice(begin[,end])

no es destructivo, el empalme y el cambio modificarán su matriz original

Escribió un pequeño artículo sobre la inserción y eliminación de elementos en posiciones arbitrarias en matrices Javascript.

Aquí está el pequeño fragmento para eliminar un elemento de cualquier posición. Esto extiende la clase Array en Javascript y agrega el método remove (index).

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

Entonces, para eliminar el primer elemento en su ejemplo, llame a arr.remove ():

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

Para eliminar el segundo elemento,

arr.remove(1);

Aquí hay un pequeño artículo con métodos de inserción y eliminación para la clase Array.

Esencialmente, esto no es diferente a las otras respuestas que usan el empalme, pero el nombre spliceno es intuitivo, y si tiene esa llamada en toda su aplicación, solo hace que el código sea más difícil de leer.

Tal vez algo como esto:

arr=arr.slice(1);

Otras respuestas son grandes, yo sólo quería añadir una solución alternativa con ES6la función de matriz: filter.

filter() crea una nueva matriz con elementos que caen bajo un criterio dado de una matriz existente.

Por lo tanto, puede usarlo fácilmente para eliminar elementos que no pasan los criterios. Las ventajas de esta función es que puede usarla en una matriz compleja, no solo en cadenas y números.

Algunos ejemplos :

Eliminar primer 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]

Eliminar segundo elemento :

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

Eliminar elemento impar :

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

Eliminar artículos no disponibles

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

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

Puede usar la función ES6 Destructuring Assignment con un operador de descanso. Una coma indica dónde desea eliminar el elemento y el operador rest (... arr) para proporcionarle los elementos restantes de la 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()tiene la propiedad interesante de que no se puede usar para eliminar el primer elemento. Entonces, necesitamos recurrir a

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

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

Solución mecanografiada que no muta la matriz original

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

Hay varias formas de eliminar un elemento de una matriz. Permítanme señalar las opciones más utilizadas a continuación. Estoy escribiendo esta respuesta porque no pude encontrar una razón adecuada sobre qué usar de todas estas opciones. La respuesta a la pregunta es la opción 3 ( Empalme () ).

1) SHIFT () - Eliminar el primer elemento de la matriz original y devolver el primer elemento

Ver referencia para Array.prototype.shift () . Use esto solo si desea eliminar el primer elemento, y solo si está de acuerdo con cambiar la 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 (): devuelve una copia de la matriz, separada por un índice inicial y un índice final

Consulte la referencia para Array.prototype.slice () . No puede eliminar un elemento específico de esta opción. Solo puede tomar una porción de la matriz existente y obtener una porción continua de la matriz. Es como cortar la matriz de los índices que especifique. La matriz original no se ve afectada.

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 el contenido de la matriz eliminando o reemplazando elementos en índices específicos.

Consulte la referencia de Array.prototype.splice () . El método splice () cambia el contenido de una matriz al eliminar o reemplazar elementos existentes y / o agregar nuevos elementos en su lugar. Devuelve una matriz actualizada. La matriz original se actualiza.

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

También puedes hacer esto con reduce:

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