¿Cuál es la diferencia entre splicey slice?

$scope.participantForms.splice(index, 1);
$scope.participantForms.slice(index, 1);

splice()cambia la matriz original, mientras slice()que no lo hace, pero ambas devuelven el objeto de matriz.

Vea los ejemplos a continuación:

var array=[1,2,3,4,5];
console.log(array.splice(2));

Esto devolverá [3,4,5]. La matriz original se ve afectada dando como resultado arrayser [1,2].

var array=[1,2,3,4,5]
console.log(array.slice(2));

Esto devolverá [3,4,5]. La matriz original NO se ve afectada con el resultado de arrayser [1,2,3,4,5].

A continuación se muestra un violín simple que confirma esto:

//splice
var array=[1,2,3,4,5];
console.log(array.splice(2));

//slice
var array2=[1,2,3,4,5]
console.log(array2.slice(2));


console.log("----after-----");
console.log(array);
console.log(array2);

Splice y Slice son funciones de matriz de Javascript.

Splice vs Slice

1. El método splice () devuelve los elementos eliminados en una matriz y el método slice () devuelve los elementos seleccionados en una matriz, como un nuevo objeto de matriz.

2. El método splice () cambia la matriz original y el método slice () no cambia la matriz original.

3. El método splice () puede tomar n cantidad de argumentos y el método slice () toma 2 argumentos.

Empalme con el ejemplo

Argumento 1: Índice, obligatorio. Un número entero que especifica en qué posición agregar / eliminar elementos. Utilice valores negativos para especificar la posición desde el final de la matriz.

Argumento 2: Opcional. El número de elementos que se eliminarán. Si se establece en 0 (cero), no se eliminarán elementos. Y si no se aprueba, se eliminarán todos los elementos del índice proporcionado.

Argumento 3 ... n: Opcional. Los nuevos elementos que se agregarán a la matriz.

var array=[1,2,3,4,5];
console.log(array.splice(2));
// shows [3, 4, 5], returned removed item(s) as a new array object.
 
console.log(array);
// shows [1, 2], original array altered.
 
var array2=[6,7,8,9,0];
console.log(array2.splice(2,1));
// shows [8]
 
console.log(array2.splice(2,0));
//shows [] , as no item(s) removed.
 
console.log(array2);
// shows [6,7,9,0]

Rebanada con ejemplo

Argumento 1: obligatorio. Un entero que especifica dónde comenzar la selección (el primer elemento tiene un índice de 0). Use números negativos para seleccionar desde el final de una matriz.

Argumento 2: Opcional. Un entero que especifica dónde finalizar la selección pero no incluye. Si se omite, se seleccionarán todos los elementos desde la posición inicial y hasta el final de la matriz. Use números negativos para seleccionar desde el final de una matriz.

var array=[1,2,3,4,5]
console.log(array.slice(2));
// shows [3, 4, 5], returned selected element(s).
 
console.log(array.slice(-2));
// shows [4, 5], returned selected element(s).
console.log(array);
// shows [1, 2, 3, 4, 5], original array remains intact.
 
var array2=[6,7,8,9,0];
console.log(array2.slice(2,4));
// shows [8, 9]
 
console.log(array2.slice(-2,4));
// shows [9]
 
console.log(array2.slice(-3,-1));
// shows [8, 9]
 
console.log(array2);
// shows [6, 7, 8, 9, 0]

El método slice () devuelve una copia de una parte de una matriz en un nuevo objeto de matriz.

$scope.participantForms.slice(index, 1);

Esto NO cambia la participantFormsmatriz, pero devuelve una nueva matriz que contiene el único elemento encontrado en la indexposición en la matriz original.

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

$scope.participantForms.splice(index, 1);

Esto eliminará un elemento de la participantFormsmatriz en la indexposición.

Estas son las funciones nativas de Javascript, AngularJS no tiene nada que ver con ellas.

Aquí hay un truco simple para recordar la diferencia entre slicevssplice

var a=['j','u','r','g','e','n'];

// array.slice(startIndex, endIndex)
a.slice(2,3);
// => ["r"]

//array.splice(startIndex, deleteCount)
a.splice(2,3);
// => ["r","g","e"]

Trick to remember:

Piense "spl" (first 3 letters of splice)en una abreviatura de "longitud específica", que el segundo argumento debe ser una longitud, no un índice

Empalme - referencia MDN - especificación ECMA-262

Sintaxis
array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

Parámetros

• start: requerido. Índice inicial
  Si startes negativo, se trata según las "Math.max((array.length + start), 0)"especificaciones (ejemplo proporcionado a continuación) efectivamente desde el final de array.
• deleteCount: Opcional. Número de elementos que se eliminarán (todos de startsi no se proporcionan).
• item1, item2, ...: Opcional. Elementos que se agregarán a la matriz desde el startíndice.

Devuelve : Una matriz con elementos eliminados (matriz vacía si no se eliminó ninguna)

Mutar matriz original : sí

Ejemplos:

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

// Remove first element
console.log('Elements deleted:', array.splice(0, 1), 'mutated array:', array);
// Elements deleted: [ 1 ] mutated array: [ 2, 3, 4, 5 ]

// array = [ 2, 3, 4, 5]
// Remove last element (start -> array.length+start = 3)
console.log('Elements deleted:', array.splice(-1, 1), 'mutated array:', array);
// Elements deleted: [ 5 ] mutated array: [ 2, 3, 4 ]

Más ejemplos en MDN Splice ejemplos

Slice - referencia MDN - espec. ECMA-262

Parámetros de sintaxis
array.slice([begin[, end]])

• begin: Opcional. Índice inicial (predeterminado 0).
  Si begines negativo, se trata según las "Math.max((array.length + begin), 0)"especificaciones (ejemplo proporcionado a continuación) efectivamente desde el final de array.
• end: Opcional. Último índice para extracción pero no incluido (matriz predeterminada. Longitud). Si endes negativo, se trata según las "Math.max((array.length + begin),0)"especificaciones (ejemplo proporcionado a continuación) efectivamente desde el final de array.

Devuelve : Una matriz que contiene los elementos extraídos.

Mutar original : No

Ejemplos:

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

// Extract first element
console.log('Elements extracted:', array.slice(0, 1), 'array:', array);
// Elements extracted: [ 1 ] array: [ 1, 2, 3, 4, 5 ]

// Extract last element (start -> array.length+start = 4)
console.log('Elements extracted:', array.slice(-1), 'array:', array);
// Elements extracted: [ 5 ] array: [ 1, 2, 3, 4, 5 ]

Más ejemplos en ejemplos de MDN Slice

Comparación de rendimiento

No tome esto como una verdad absoluta, ya que dependiendo de cada escenario, uno podría ser más eficaz que el otro.
Prueba de rendimiento

Splice y Slice son comandos Javascript integrados, no específicamente comandos AngularJS. Slice devuelve elementos de la matriz desde el "inicio" hasta justo antes de los especificadores "final". Splice muta la matriz real, comienza en el "inicio" y mantiene el número de elementos especificados. Google tiene mucha información sobre esto, solo busca.

El splice()método devuelve los elementos eliminados en una matriz. El slice()método devuelve los elementos seleccionados en una matriz, como un nuevo objeto de matriz.

El splice()método cambia la matriz original y el slice()método no cambia la matriz original.

• Splice() El método puede tomar n cantidad de argumentos:

  Argumento 1: Índice, obligatorio.

  Argumento 2: Opcional. El número de elementos que se eliminarán. Si se establece en 0 (cero), no se eliminarán elementos. Y si no se aprueba, se eliminarán todos los elementos del índice proporcionado.

  Argumento 3..n: Opcional. Los nuevos elementos que se agregarán a la matriz.

• slice() El método puede tomar 2 argumentos:

  Argumento 1: obligatorio. Un entero que especifica dónde comenzar la selección (el primer elemento tiene un índice de 0). Use números negativos para seleccionar desde el final de una matriz.

  Argumento 2: Opcional. Un entero que especifica dónde finalizar la selección. Si se omite, se seleccionarán todos los elementos desde la posición inicial y hasta el final de la matriz. Use números negativos para seleccionar desde el final de una matriz.

empalmar y eliminar elemento de matriz por índice

índice = 2

//splice & will modify the origin array
const arr1 = [1,2,3,4,5];
//slice & won't modify the origin array
const arr2 = [1,2,3,4,5]

console.log("----before-----");
console.log(arr1.splice(2, 1));
console.log(arr2.slice(2, 1));

console.log("----after-----");
console.log(arr1);
console.log(arr2);

let log = console.log;

//splice & will modify the origin array
const arr1 = [1,2,3,4,5];

//slice & won't modify the origin array
const arr2 = [1,2,3,4,5]

log("----before-----");
log(arr1.splice(2, 1));
log(arr2.slice(2, 1));

log("----after-----");
log(arr1);
log(arr2);

Otro ejemplo:

[2,4,8].splice(1, 2) -> returns [4, 8], original array is [2]

[2,4,8].slice(1, 2) -> returns 4, original array is [2,4,8]

la división no cambia la matriz original, devuelve una nueva matriz, pero el empalme cambia la matriz original.

example: var arr = [1,2,3,4,5,6,7,8];
         arr.slice(1,3); // output [2,3] and original array remain same.
         arr.splice(1,3); // output [2,3,4] and original array changed to [1,5,6,7,8].

El segundo argumento del método de empalme es diferente del método de corte. El segundo argumento en empalme representa el recuento de elementos para eliminar y en corte representa el índice final.

arr.splice(-3,-1); // output [] second argument value should be greater then 
0.
arr.splice(-3,-1); // output [6,7] index in minus represent start from last.

-1 representa el último elemento, por lo que comienza de -3 a -1. Arriba hay una gran diferencia entre el método de empalme y corte.

La diferencia entre las funciones incorporadas de JavaScript Slice () y Splice () es que Slice devuelve el elemento eliminado pero no cambió la matriz original; me gusta,

        // (original Array)
        let array=[1,2,3,4,5] 
        let index= array.indexOf(4)
         // index=3
        let result=array.slice(index)
        // result=4  
        // after slicing=>  array =[1,2,3,4,5]  (same as original array)

pero en el caso de splice () afecta la matriz original; me gusta,

         // (original Array)
        let array=[1,2,3,4,5] 
        let index= array.indexOf(4)
         // index=3
        let result=array.splice(index)
        // result=4  
        // after splicing array =[1,2,3,5]  (splicing affects original array)

Método de empalme de matriz de JavaScript () por ejemplo

Ejemplo1 por tutsmake -Eliminar 2 elementos del índice 1

  var arr = [ "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten" ]; 

 arr.splice(1,2);

 console.log( arr ); 

Ejemplo-2 Por tutsmake - Agregue un nuevo elemento del índice 0 JavaScript

  var arr = [ "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten" ]; 

 arr.splice(0,0,"zero");

 console.log( arr );  

Ejemplo-3 por tutsmake - Agregar y quitar elementos en JavaScript de matriz

var months = ['Jan', 'March', 'April', 'June'];

months.splice(1, 0, 'Feb'); // add at index 1

console.log(months); 

months.splice(4, 1, 'May'); // replaces 1 element at index 4

console.log(months);

https://www.tutsmake.com/javascript-array-splice-method-by-example/