javascript - into - Como inserir um item em uma matriz em um índice específico?




push items array javascript (8)

Eu estou procurando um método de inserção de matriz de JavaScript, no estilo de:

arr.insert(index, item)

De preferência em jQuery, mas qualquer implementação de JavaScript fará neste momento.


Métodos de insert matriz personalizada

1. Com vários argumentos e suporte de encadeamento

/* 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;
};

Pode inserir vários elementos (como faz a splice nativa) e suporta o encadeamento:

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

2. Com argumentos do tipo de matriz que mesclam e encadeamos o suporte

/* 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;
};

Ele pode mesclar matrizes dos argumentos com a matriz fornecida e também suporta encadeamento:

["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/


Além de splice, você pode usar essa abordagem que não irá alterar o array original, mas criará um novo array com o item adicionado. Você deve geralmente evitar a mutação sempre que possível. Estou usando o operador de espalhamento ES6 aqui.

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]

Isso pode ser usado para adicionar mais de um item, aprimorando um pouco a função para usar o operador de descanso para os novos itens e distribuindo isso também no resultado retornado.

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]


Eu tentei isso e está funcionando bem!

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

Índice é a posição em que você deseja inserir ou excluir o elemento. 0 ou seja, o segundo parâmetro define o número de elemento do índice a ser removido item são as novas entradas que você deseja fazer na matriz. Pode ser um ou mais de um.

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

Mesmo que isso já tenha sido respondido, estou adicionando esta nota para uma abordagem alternativa.

Eu queria colocar um número conhecido de itens em uma matriz, em posições específicas, como eles saem de um "array associativo" (ou seja, um objeto), que por definição não é garantido para estar em uma ordem classificada. Eu queria que a matriz resultante fosse uma matriz de objetos, mas os objetos estivessem em uma ordem específica na matriz, já que uma matriz garante sua ordem. Então eu fiz isso.

Primeiro o objeto de origem, uma string JSONB recuperada do PostgreSQL. Eu queria que ele fosse classificado pela propriedade "order" em cada objeto filho.

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

Como o número de nós no objeto é conhecido, primeiro crio um array com o tamanho especificado:

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

E, em seguida, iterar o objeto, colocando os objetos temporários recém-criados nos locais desejados na matriz sem realmente qualquer "ordenação" ocorrendo.

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

Outra solução possível, com 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);


Para fins de programação funcional adequada e encadeamento, uma invenção de Array.prototype.insert() é essencial. Na verdade, splice poderia ter sido perfeito se tivesse retornado o array mutado em vez de um array vazio totalmente sem sentido. Então aqui vai

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>");

Bem, ok o acima com o Array.prototype.splice() um muta a matriz original e alguns podem reclamar como "você não deve modificar o que não pertence a você" e que pode vir a estar certo também. Então, para o bem-estar público, gostaria de dar outro Array.prototype.insert() que não Array.prototype.insert() o array original. Aqui vai;

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


Você pode implementar o método Array.insert fazendo isso:

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

Então você pode usá-lo como:

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

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

Anexar um único elemento em um í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';

Anexar vários elementos em um í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




insert