Implementé una lista vinculada de 2 maneras en Javascript, pero al hacerlo, me confundí mucho acerca de lo que realmente estaba sucediendo.
Estaba tratando de crear una imagen mental sobre lo que se está creando y qué apunta a qué dirección de memoria (según lo que aprendí sobre pasar por referencia), pero no puedo hacerlo.
Las diferencias están entre los métodos append() y prepend() .
Opción 1:
class myLinkedList { constructor(value) { this.head = { value: value, next: null } this.tail = this.head; } append(element){ this.tail.next = { value: element, next: null } this.tail = this.tail.next; } prepend(element) { const newObj = { value: element, next: this.head } this.head = newObj; } } const linkedList = new myLinkedList(1); linkedList.append(2); linkedList.prepend(0);Opcion 2:
class myLinkedList { constructor(value) { this.head = { value: value, next: null } this.tail = this.head; } append(element){ const newNode = { value: element, next: null } this.tail.next = newNode; this.tail = newNode; } prepend(element) { const newNode = { value: element, next: null } newNode.next = this.head; this.head = newNode; } } const linkedList = new myLinkedList(1); linkedList.append(2); linkedList.prepend(0);Aclaraste tu pregunta en los comentarios.
La respuesta tiene que ver con el enlace variable frente a los valores.
JavaScript tiene representaciones internas para valores como cadenas, números, objetos definidos por el usuario, etc. Esa representación es la misma ya sea que el valor se llame foo o no, o esté enterrado profundamente en alguna estructura de datos.
Los programas tienen variables. En cualquier momento en el tiempo, una variable dada está ligada a un valor dado. Esto les da a los programadores una forma de decirle a JavaScript qué debería pasar con los valores a los que están vinculados.
La asignación es vincular valores a las cosas. Cuando asignamos a una variable, ya no está vinculada a ningún valor antiguo al que haya estado vinculada. Ese valor antiguo aún puede existir en alguna estructura de datos, o puede convertirse en basura para limpiar. Pero ya no está asociado a esa variable.
Y esto es lo que realmente hace el código de muestra que diste.
-- Create a value and bind it to head. let head = { value: 2, next: null }; /* CURRENT BINDING: * * head ----> {value:2, next:null} */ -- Create a value and bind it to newObj let newObj = { value: 1, next: head }; /* CURRENT BINDING: * * newObj ----> {value:1, next: * head ----> {value:2, next:null} * } */ -- Bind the variable head to the value newObj is bound to. head = newObj; /* CURRENT BINDING: * * head,newObj * ----> {value:1, next: * {value:2, next:null} * } */ -- And see that it worked. console.log(head)¿Eso aclara su modelo de cómo los programas representan datos lo suficiente como para comprender por qué este código no crea una referencia circular?
Pero si tiene curiosidad, es posible crear referencias circulares.
let foo = {value:1}: foo['next'] = foo; console.log(foo);¿Cómo funcionó eso? ¿La asignación no es solo vincular valores a las cosas? Bueno, sí. Pero si la cosa a la que está vinculado está en algún lugar de una estructura de datos, entonces esa estructura de datos tuvo que cambiarse para permitir que se vinculara.
Lo que sucede después de crear referencias circulares varía según el idioma. En JavaScript, en algún momento después de que no esté vinculado a nada, el recolector de basura lo limpiará. En Python, cobra vida propia y se pierde memoria. Y así.