Abrufen des Ergebnisarrays vor und nach der Verwendung von splice()

Question

Ich habe eine Demo geschrieben, um ein bestimmtes Element über Index aus einem Array zu entfernen.

var splice_a = function (array, index) { 
 
    array.splice(index, 1); 
 
    return array 
 
}; 
 

 
var splice_b = function (array, index) { 
 
    return array.splice(index, 1) 
 
}; 
 

 
var test = function() { 
 
    var array = [1, 2, 3]; 
 
    
 
    alert(splice_a(array, 1)); 
 
    alert(splice_b(array, 1)); 
 
};

<button onclick="test()">Click me</button>

Array.prototype.splice() sagt über die return value:

Ein Array die gelöschten Elemente enthalten. Wenn nur ein Element entfernt wird, wird ein Array mit einem Element zurückgegeben. Wenn keine Elemente entfernt sind, wird ein leeres Array zurückgegeben.

Es wird nicht erwähnt: Wenn ich das Ergebnis Array erhalten möchte, sollte ich es mit Keyword return kombinieren?

Es soll ein Fall sein, weil ich 2 Unterschied Erzielen von Ergebnissen:

1,3

Meine Frage: Was ist mit return array.splice(index, 1) in diesem Fall passieren?

Answer 1

Hier ist ein abstraktes Beispiel dafür, was passiert ist:

// a function that removes the last element from an array, and returns 1 
Array.prototype.foo = function() { 
    this.pop() 
    return 1 
} 

// a function that removes the last element from an array, and returns the array 
Array.prototype.bar = function() { 
    this.pop() 
    return this 
} 

Wenn Sie arr.foo() oder arr.bar() die gleiche Sache zu arr passieren würde, nennen wären, aber der Rückgabewert der Funktion rufen Sie ist anders. Nicht jede Array.prototype Methode gibt das Array zurück. splice zum Beispiel gibt das ursprüngliche Array nicht zurück. Dies ist analog zu dem, was Sie versuchen zu tun:

function foo_a(arr) { 
    // call foo, removes element from arr. 
    arr.foo() // We do not return here so the fact that foo returns 1 is not used. 
    return arr 
} 

function foo_b(arr) { 
    // call foo, removes element from arr. 
    return arr.foo() // We return the return value of foo here, which is 1 
} 

var arr = [1, 2, 3, 4]; 

foo_a(arr) // [1, 2, 3] 
foo_b(arr) // 1 

tl; dr return arr.foo() ist im Grunde sagen „den Rückgabewert von foo zurückkehren“, die immer 1 unabhängig davon, was auch immer sonst tut es dem Array .

Answer 2

Das resultierende Array ist Ihr eigenes Array. Muss nicht zurückgeben. So wäre es nur sein:

var splice_a = function (array, index) { 
    array.splice(index, 1); 
    return array 
}; 
var array = [1, 2, 3, 4]; 

splice_a(array, 1); 
alert(array) //will show 1,3,4; 

splice_a(array, 1); 
alert(array) //will show 1,4; 

Answer 3

Array.prototype.splicen Daten aus m Index des Arrays und kehrt entfernt Wert als Array entfernen wird:

var m = 2, 
 
    n = 3; 
 
var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]; 
 
var removedValues = arr.splice(m, n); 
 

 
console.log(arr, removedValues);

So in Ihrer Situation es entfernt ein Element aus dem Array (Wert im Index) und gibt dieses im neuen Array zurück.

Answer 4

Ich habe Ihre Funktionen geändert, um den Unterschied in den Rückgabewerten zu zeigen. Sie werden beide ändern die in Array in der gleichen Weise übergeben. Die einzige Sache, die sich ändert, ist der Rückgabewert. Dies könnte sein, wo du verwirrt bist.Beachten Sie, dass die Variable array durch splice_a geändert wird, bevor Sie splice_b durchlaufen.

var splice_a = function (array, index) { 
 
    var removed = array.splice(index, 1); 
 
    console.log(` Removed = ${removed}`); 
 
    console.log(` Array = ${array}`); 
 
    
 
    return array; 
 
}; 
 

 
var splice_b = function (array, index) { 
 
    var removed = array.splice(index, 1) 
 
    console.log(` Removed = ${removed}`); 
 
    console.log(` Array = ${array}`); 
 
    
 
    return removed; 
 
}; 
 

 
var array = [1, 2, 3]; 
 

 
console.log(`Array before splice_a: ${array}`); 
 
splice_a(array, 1); 
 

 
console.log(`Array before splice_b: ${array}`); 
 
splice_b(array, 1); 
 

 
console.log(`Final value of array: ${array}`);

Was, warum Sie den Wert zurück, wenn es trotzdem ändert sich wünschen würde. Dies dient hauptsächlich der Bequemlichkeit beim Verketten von Befehlen. Betrachten wir nur die erste Funktion:

var splice_a1 = function (array, index) { 
 
    var removed = array.splice(index, 1); 
 
    return array; 
 
}; 
 
var splice_a2 = function (array, index) { 
 
    var removed = array.splice(index, 1); 
 
}; 
 

 

 
var array = [1, 2, 3]; 
 
// This will run, because splice_a1 returns an array 
 
splice_a1(array, 1).forEach(_ => console.log(_)) 
 

 
// This will throw an error, because <undefined> does not have a forEach() 
 
splice_a2(array, 1).forEach(_ => console.log(_))