Garbage Collection von JavaScript

[m1au]

Hallo

Mich würde interessieren, wie in JavaScript die Garbage Collection funktioniert.

Hier mal ein Beispiel:

<script>
   "use strict";
   
   class C {
      constructor(id) {
         this.id = id;
         this.next = null;
      }
      m(o) {
         this.next = o.clone(); // hier wird eine Kopie vom Objekt o erstellt
      }
      clone() {
         let o = new C();
         o.id = this.id;
         o.next = this.next;
         return o;
      }
   }
   
   let o0 = new C(0);
   
   {
      // eigener Gültigkeitsbereich für o1:
      let o1 = new C(1);
      o0.m(o1);
      
      // ab hier wird o1 im Hauptprogramm eigentlich nicht mehr verwendet
   }
   
   console.log(o0.next.id); // 1
</script>

In der Methode m übergebe ich ein Objekt. In dieser Methode arbeit ich dann aber nicht wirklich weiter mit diesem Objekt. Statt dessen lege ich keine Kopie davon an.

Hat jetzt die Garbage Collection eine Chance, o1 zu verwerfen, sobald dieser eigene Gültigkeitsbereich verlassen wird?

Oder würde das auch dann passieren, wenn ich in m gar keine Kopie vom übergebenen Objekt erzeuge?

 

[Dormilich]

Mich würde interessieren, wie in JavaScript die Garbage Collection funktioniert.

Garbage collection is a term used in computer programming to describe the process of finding and deleting objects which are no longer being referenced by other objects. In other words, garbage collection is the process of removing any objects which are not being used by any other objects. Often abbreviated "GC," garbage collection is a fundamental component of the memory management system used by JavaScript.

Quelle und weiterführende Links: https://developer.mozilla.org/en-US/docs/Glossary/Garbage_collection

 

[m1au]

Danke für den Link

Was ist denn mit dem letzten Absatz gemeint? https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management#Garbage_collection

Limitation: objects need to be made explicitly unreachable
Although this is marked as a limitation, it is one that is rarely reached in practice which is why no one usually cares that much about garbage collection.

Wann tritt denn dieser seltene Fall ein? Und wie muss man ein Objekt für die GC dann als nicht-mehr-erreichbar erkennbar machen?

 

[tsseh]

Wann tritt denn dieser seltene Fall ein?

würde o1.next auf ein o2 zeigen (im selben scope liegend wie o1) , könnte dieses lokale o2 nicht gelöscht werden, da nach der kopie von o1 nach o0 nun o2 immer noch über o0 erreichbar ist.

Und wie muss man ein Objekt für die GC dann als nicht-mehr-erreichbar erkennbar machen?

o0.next = null

 

[m1au]

würde o1.next auf ein o2 zeigen (im selben scope liegend wie o1) , könnte dieses lokale o2 nicht gelöscht werden, da nach der kopie von o1 nach o0 nun o2 immer noch über o0 erreichbar ist.

Das wäre dann wohl auch schon die Antwort auf meine usprüngliche Frage, oder? Das Kopieren bringt nichts, o1 ist via o0 weiterhin erreichbar. Richtig? Und dann dreht sich alles nur um den Scope? Wenn sich in dem Scope zumindest 1 erreichbares Objekt befindet, dann gelten alle anderen Objekte automatisch auch als erreichbar, und dürfen deshalb von der GC nicht gelöscht werden? Habe ich das so richtig verstanden?

 

[tsseh]

Das wäre dann wohl auch schon die Antwort auf meine usprüngliche Frage, oder? Das Kopieren bringt nichts, o1 ist via o0 weiterhin erreichbar. Richtig?

o1 nicht, da o0 ja keine referenz auf o1 hält, nur wenn irgendein member von o0 (next in diesem fall) o1 referenzieren würde, würde o1 überleben

Und dann dreht sich alles nur um den Scope?

nee, alles dreht sich um referenzen auf objekte, wenn irgendein objekt welches irgendwo (global, eventhandler, dom) liegt eine referenz auf ein anderes objekt hält, welches vom scope aber schon nicht mehr erreichbar ist (o1 im blockscope in deinem fall), dann kann dieses andere objekt erst dann gelöscht werden, wenn die referenz aufgelöst wird oder das objekt, welches die referenz hält, gelöscht wird
eigentlich logisch

 

[m1au]

würde o1.next auf ein o2 zeigen (im selben scope liegend wie o1) , könnte dieses lokale o2 nicht gelöscht werden, da nach der kopie von o1 nach o0 nun o2 immer noch über o0 erreichbar ist.

Ich komme mit dem hier irgendwie durcheinander. Dieses erwähnte o2 wird im blockscope erzeugt?

   let o0 = new C(0);
   
   {
      // eigener Gültigkeitsbereich für o1:
      let o1 = new C(1);
      o0.m(o1);
      
      let o2 = new C(2); // o2 im gleichen scope wie o1
      o1.m(o2);          // o1 verweist auf o2
      
      // ab hier wird o1 im Hauptprogramm eigentlich nicht mehr verwendet
   }

Oder ist das o2 die Kopie in der m-Methode?

   class C {
      constructor(id) {
         this.id = id;
         this.next = null;
      }
      m(o) {
         let o2 = o.clone(); // der Klon ist das o2
         this.next = o2;
      }
      clone() {
         let o = new C();
         o.id = this.id;
         o.next = this.next;
         return o;
      }
   }

 

[tsseh]

class C
{
  constructor(id)
  {
    this.id = id;
    this.next = null;
  }
  clone()
  {
    let o = new C();
    o.id = this.id;
    o.next = this.next;
    return o;
  }
}

let o0 = new C(0);
{
  let o1 = new C(1);
  let o2 = new C(2);
  o1.next = o2;
  o0 = o1.clone();
}
// ab hier kannst du nicht mehr auf o1 zugreifen => kann gelöscht werden
// über o0.next kannst du aber auf o2 zugreifen => o2 darf nicht gelöscht werden