objects - eliminar un elemento especifico de un array javascript

¿Cómo insertar un elemento en una matriz en un índice específico?

Question

Estoy buscando un método de inserción de matriz de Javascript, en el estilo de:

arr.insert(index, item)

Preferiblemente en jQuery, pero cualquier implementación de Javascript funcionará en este punto.

Answer 1

Métodos de insert matriz personalizados

1. Con múltiples argumentos y soporte de encadenamiento.

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    this.splice.apply(this, [index, 0].concat(
        Array.prototype.slice.call(arguments, 1)));
    return this;
};

Puede insertar varios elementos (como lo hace el splice nativo) y admite el encadenamiento:

["a", "b", "c", "d"].insert(2, "X", "Y", "Z").slice(1, 6);
// ["b", "X", "Y", "Z", "c"]

2. Con argumentos de tipo matriz, la fusión y el soporte de encadenamiento

/* Syntax:
   array.insert(index, value1, value2, ..., valueN) */

Array.prototype.insert = function(index) {
    index = Math.min(index, this.length);
    arguments.length > 1
        && this.splice.apply(this, [index, 0].concat([].pop.call(arguments)))
        && this.insert.apply(this, arguments);
    return this;
};

Puede combinar matrices de los argumentos con la matriz dada y también admite el encadenamiento:

["a", "b", "c", "d"].insert(2, "V", ["W", "X", "Y"], "Z").join("-");
// "a-b-V-W-X-Y-Z-c-d"

DEMO: http://jsfiddle.net/UPphH/

Answer 2

Aparte del empalme, puede utilizar este enfoque que no mutará la matriz original, pero creará una nueva matriz con el elemento agregado. Por lo general, debe evitar la mutación siempre que sea posible. Estoy usando el operador de propagación ES6 aquí.

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, newItem) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted item
  newItem,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10)

console.log(result)
// [1, 10, 2, 3, 4, 5]

Esto se puede usar para agregar más de un artículo al ajustar la función un poco para usar el operador de descanso para los nuevos artículos, y distribuirlo también en el resultado devuelto.

const items = [1, 2, 3, 4, 5]

const insert = (arr, index, ...newItems) => [
  // part of the array before the specified index
  ...arr.slice(0, index),
  // inserted items
  ...newItems,
  // part of the array after the specified index
  ...arr.slice(index)
]

const result = insert(items, 1, 10, 20)

console.log(result)
// [1, 10, 20, 2, 3, 4, 5]

Answer 3

Aunque esto ya ha sido respondido, estoy agregando esta nota para un enfoque alternativo.

Quería colocar un número conocido de elementos en una matriz, en posiciones específicas, ya que provienen de una "matriz asociativa" (es decir, un objeto) que, por definición, no se garantiza que esté en un orden ordenado. Quería que la matriz resultante fuera una matriz de objetos, pero que los objetos estuvieran en un orden específico en la matriz, ya que una matriz garantiza su orden. Así que hice esto.

Primero el objeto fuente, una cadena JSONB recuperada de PostgreSQL. Quería ordenarlo por la propiedad "orden" en cada objeto secundario.

var jsonb_str = ''{"one": {"abbr": "", "order": 3}, "two": {"abbr": "", "order": 4}, "three": {"abbr": "", "order": 5}, "initialize": {"abbr": "init", "order": 1}, "start": {"abbr": "", "order": 2}}'';

var jsonb_obj = JSON.parse(jsonb_str);

Dado que se conoce el número de nodos en el objeto, primero creo una matriz con la longitud especificada:

var obj_length = Object.keys(jsonb_obj).length;
var sorted_array = new Array(obj_length);

Y luego itere el objeto, colocando los objetos temporales recién creados en las ubicaciones deseadas en la matriz sin que realmente tenga lugar ningún "ordenamiento".

for (var key of Object.keys(jsonb_obj)) {
  var tobj = {};
  tobj[key] = jsonb_obj[key].abbr;

  var position = jsonb_obj[key].order - 1;
  sorted_array[position] = tobj;
}

console.dir(sorted_array);

Answer 4

Intenté esto y está funcionando bien!

var initialArr = ["India","China","Japan","USA"];
initialArr.splice(index, 0, item);

Índice es la posición en la que desea insertar o eliminar el elemento. 0, es decir, el segundo parámetro define la cantidad de elementos del índice que se eliminará, son las nuevas entradas que desea crear en la matriz. Puede ser uno o más de uno.

initialArr.splice(2, 0, "Nigeria");
initialArr.splice(2, 0, "Australia","UK");

Answer 5

Lo que desea es la función de splice en el objeto de matriz nativa.

arr.splice(index, 0, item); insertará el item en arr en el índice especificado (eliminando primero 0 elementos, es decir, es solo una inserción).

En este ejemplo, crearemos una matriz y le agregaremos un elemento en el índice 2:

var arr = [];
arr[0] = "Jani";
arr[1] = "Hege";
arr[2] = "Stale";
arr[3] = "Kai Jim";
arr[4] = "Borge";

console.log(arr.join());
arr.splice(2, 0, "Lene");
console.log(arr.join());

Answer 6

Otra posible solución, con el uso de Array#reduce .

var arr = ["apple", "orange", "raspberry"],
    arr2 = [1, 2, 4];

function insert(arr, item, index) {
    arr = arr.reduce(function(s, a, i) {
      i == index ? s.push(item, a) : s.push(a);
      return s;
    }, []);   
    console.log(arr);
}

insert(arr, "banana", 1);
insert(arr2, 3, 2);

Answer 7

Para una correcta programación funcional y propósitos de encadenamiento, una invención de Array.prototype.insert() es esencial. En realidad, el empalme podría haber sido perfecto si hubiera devuelto la matriz mutada en lugar de una matriz vacía totalmente sin sentido. Así que aquí va

Array.prototype.insert = function(i,...rest){
  this.splice(i,0,...rest)
  return this
}

var a = [3,4,8,9];
document.write("<pre>" + JSON.stringify(a.insert(2,5,6,7)) + "</pre>");

Bueno, ok, lo anterior con Array.prototype.splice() uno muta la matriz original y algunos podrían quejarse como "no deberías modificar lo que no te pertenece" y eso también podría resultar correcto. Entonces, para el bienestar público, me gustaría dar otro Array.prototype.insert() que no muta la matriz original. Aquí va;

Array.prototype.insert = function(i,...rest){
  return this.slice(0,i).concat(rest,this.slice(i));
}

var a = [3,4,8,9],
    b = a.insert(2,5,6,7);
console.log(JSON.stringify(a));
console.log(JSON.stringify(b));

Answer 8

Puedes implementar el método Array.insert haciendo esto:

Array.prototype.insert = function ( index, item ) {
    this.splice( index, 0, item );
};

Entonces puedes usarlo como:

var arr = [ ''A'', ''B'', ''D'', ''E'' ];
arr.insert(2, ''C'');

// => arr == [ ''A'', ''B'', ''C'', ''D'', ''E'' ]

Answer 9

Recomiendo usar JavaScript puro en este caso, además, no hay un método de inserción en JavaScript, pero tenemos un método que es un método de Array incorporado que hace el trabajo por usted, se llama empalme ...

Veamos que es el empalme () ...

El método splice () cambia el contenido de una matriz eliminando elementos existentes y / o agregando nuevos elementos.

OK, imagina que tenemos esta matriz a continuación:

const arr = [1, 2, 3, 4, 5];

Podemos eliminar 3 esta manera:

arr.splice(arr.indexOf(3), 1);

Devolverá 3, pero si comprobamos el arr ahora, tenemos:

[1, 2, 4, 5]

Hasta ahora, todo bien, pero ¿cómo podemos agregar un nuevo elemento a la matriz utilizando el empalme? Vamos a poner de nuevo 3 en el arr ...

arr.splice(2, 0, 3);

A ver que hemos hecho ...

Usamos splice nuevamente, pero esta vez para el segundo argumento, pasamos 0 , significa que no queremos eliminar ningún elemento, pero al mismo tiempo, agregamos el tercer argumento que es 3 que se agregará en el segundo índice ...

Debe tener en cuenta que podemos eliminar y agregar al mismo tiempo, por ejemplo, ahora podemos hacer:

arr.splice(2, 2, 3);

Lo que eliminará 2 elementos en el índice 2, luego agregará 3 en el índice 2 y el resultado será:

[1, 2, 3, 5];

Esto muestra cómo funciona cada elemento en el empalme:

array.splice (inicio, deleteCount, item1, item2, item3 ...)

Answer 10

Si desea insertar varios elementos en una matriz a la vez, consulte esta respuesta de desbordamiento de pila: una mejor manera de unir una matriz en una matriz en javascript

También aquí hay algunas funciones para ilustrar ambos ejemplos:

function insertAt(array, index) {
    var arrayToInsert = Array.prototype.splice.apply(arguments, [2]);
    return insertArrayAt(array, index, arrayToInsert);
}

function insertArrayAt(array, index, arrayToInsert) {
    Array.prototype.splice.apply(array, [index, 0].concat(arrayToInsert));
    return array;
}

Finalmente, aquí hay un jsFiddle para que puedas verlo por ti mismo: http://jsfiddle.net/luisperezphd/Wc8aS/

Y así es como usas las funciones:

// if you want to insert specific values whether constants or variables:
insertAt(arr, 1, "x", "y", "z");

// OR if you have an array:
var arrToInsert = ["x", "y", "z"];
insertArrayAt(arr, 1, arrToInsert);

Answer 11

Anexar elemento único en un índice específico

//Append at specific position(here at index 1)
arrName.splice(1, 0,''newName1'');
//1: index number, 0: number of element to remove, newName1: new element


//Append at specific position (here at index 3)
arrName[3] = ''newName1'';

Añadir elemento múltiple en un índice específico

//Append from index number 1
arrName.splice(1, 0,''newElemenet1'', ''newElemenet2'', ''newElemenet3'');
//1: index number from where append start, 
//0: number of element to remove, 
//newElemenet1,2,3: new elements