Looping durch Objekte und das Hinzufügen von Typen

Question

function arrayToList(array) { 
    var list = null; 
    for (var i = 0; i < array.length ; i++) 
    list = {value: array[i], rest: list}; 
    return list; 

} 

console.log(arrayToList([10,20])); 

Warum ist es, dass, wenn ich console.log dieses Array I value : 20, rest: object bin zu erhalten, und nicht value:10 und rest: null. Das verwirrte mich, da das erste Element meines Arrays 10 ist und ich gehe von . Jede Einsicht würde helfen. Vielen Dank.

Answer 1

Dies liegt daran, dass Sie das letzte Objekt zurückgeben, das auf list festgelegt wurde. Um die erste in der verknüpften Liste zurückzugeben, behalten Sie einen Verweis darauf vor der Schleife bei und geben Sie diese zurück.

Obwohl Ihre verknüpfte Liste umgekehrt als das Array ist. Ich bin mir nicht sicher, ob du das beabsichtigt hast.

Wenn Sie das Array spiegeln, und verknüpfen vorwärts, tun dies, um Fahndungsliste:

function arrayToList(array) { 
 
    var first = {value: array[0], rest: null}; 
 
    var prev = first; 
 
    for (var i = 1; i < array.length ; i++) 
 
    prev.rest = prev = {value: array[i], rest: null}; 
 

 
    return first; 
 
} 
 

 
console.log(arrayToList([10,20]));

---

Nehmen wir an, wir haben keine eine Schleife, und sind nur die ganze Sache inlining. So würde es aussehen. Ich werde es auch tun, als ob das Array [10, 20, 30] wäre.

function arrayToList(array) { 
    // Here `first` and `prev` reference the same object 
    var first = {value: array[0], rest: null}; 
    var prev = first; 

    // first = {value: 10, rest: null}; 
    // prev = {value: 10, rest: null}; 

    // Then we assign a new object to `prev.rest` as well as `prev`. 
    // Because the `prev` and `first` variables reference the same object, 
    // the mutation of `prev.rest` is also seen from `first.rest`. 

    // First iteration 
    prev.rest = prev = {value: array[1], rest: null}; 

    // now... 
    // first = {value: 10, rest: (reference to object with value: 20)}; 
    // prev = {value: 20, rest: null}; 

    // So it first changed `prev.rest` (and therefore `first.rest`) to point to 
    // the new object, but then it also updated `prev` to the same, new object. 

    // Take note that though we assigned the new object to `prev.rest`, after 
    // the assignment, `prev.rest` is actually `null`, because the `prev.rest` 
    // that we assigned to was the `.rest` of the *previous* `prev`, which was 
    // immediately updated to see the *new* object. 

    // Second iteration 
    prev.rest = prev = {value: array[2], rest: null}; 

    // now... 
    // first = {value: 10, rest: (reference to object with value: 20)}; 
    // prev = {value: 30, rest: null}; 

    // So now when we changed `prev.rest`, it had no impact on `first` because 
    // `prev` and `first` are referencing different objects. So `prev` sees the 
    // new object, but `first` does not. 

    return first; 
} 

Answer 2

Sie tun eine console.log() der zurückgegebenen "Liste" Wert. Sie werden in Ihrem list.rest keinen "Null" sehen, weil Ihr endgültiger Wert der Liste wie folgt aussehen würde: list = { value: 20, rest : { value : 10, rest : null } }; Wenn Sie das folgende hinter list = {value: array [i], rest: list}; Sie werden sehen, was ich meine:
console.log (list.rest)
oder
console.log (Liste), wenn Sie die ganze Sache sehen wollen.

Auch beantworten Sie beginnend mit dem ersten Element in Frage 10 und mehr ab i = 0:
das Array [10, 20] hat eine array.length = 2
array [0] = 10
array [1] = 20

aus diesem Grund, den letzten Wert in die „Liste“ eingetragen wird Wert = 20. Wenn Sie das tun, werden Sie auch den Wert der „Liste“ in „-Liste zu speichern. Rest ", die rekursiv speichert was auch immer Ihre letzte" Liste "JSON-Objekt war. Dies könnte sehr unordentlich werden, wenn Sie mehr als 2 Einträge in der Liste haben, denn mit 3, um zum ersten zu gelangen, müssten Sie list.rest.rest.value tun - Sie möchten wahrscheinlich überdenken, wie es Ihnen geht Speichern Sie Ihre Liste.

Answer 3

Sie überschreiben den Wert der Ruhe mit jeder Ihrer Traversalen. Ich denke, Sie sollten das Konzept der rekursiven Funktion verwenden, um es schnell und genau zu machen.

Bitte benutzen Sie den folgenden Code ein:

function arrayToList(array, i){ 
    if(i == array.length){ 
     return null ; 
    } 
    return { value: array[i], rest: arrayToList(array, i+1) }; 
} 
console.log(arrayToList([10,20,30], 0)); 

Hier i den Index in Array repräsentiert. Ich hoffe, das löst dein Problem. Es hat bei meinem System gut funktioniert.

Das Ergebnis was ich habe ist:

{ 
    value: 10, 
    rest: { 
     value: 20, 
     rest: { 
      value: 30, 
      rest:null 
     } 
    } 
}