How do we delete an object in Dart?

Question

I want to basically delete an object I created. How do we delete an object?

I checked Object definition here, but couldn't figure out way to do it. Also I am curious whether we can define destructors or not.

UPDATE The question is getting good answers. But I want to draw your attention to a case in which I want to delete my objects or call destructor. Let's say we want to create a pace using that you can connect rectangles via the ports placed on it. So the idea is to have an object that has a reference to the body of the rectangle and the ports placed at two ends. In fact, that object might need some other properties like [bool] selected or [bool] dragging or [List<RectElement>] connectedSquares. For example, when user selects the rectangle and hits backspace, I want to make sure the rectangles are gone and my object is properly deleted. So this use case may give some more insight into the question.

Answer 1

You don't need to actively delete objects in Dart.

Dart is a garbage-collected language, so any object that you don't hold any references to will eventually be garbage collected and freed by the runtime system.

So all you have to do is to clear any variables you have that reference the object.

Garbage collection is really implicit in the language specification. The specification doesn't say so that garbage collection exists (it doesn't even mention the concept), but the language and libraries are designed in such a way that garbage collection is possible: Objects that the program cannot find a reference to anywhere also can't affect the program's behavior any more, so it is undetectable that they are being collected and deleted by the garbage collector.

Answer 2

Make sure that you don't hold a reference to the object so it can be GCed.

x = null;

Answer 3

For the time being, Dart programs are deployed as JavaScripts, and are therefore limited to the JavaScript runtime model. Look for example at this question that clarifies that the only way to delete objects in JavaScript is by means of the garbage collector. If you call remove, or removeAt, etc. on your connectedSquares and don't hold any other references, this accomplishes what you are looking for.

As for destructors, the same limitations apply. If the object that holds references to "the body of the rectangle and the ports placed at two ends" becomes unreachable, everything it references becomes eligible for garbage collection as well - again, provided there are no other references.

In general, if you want a full understanding of the runtime semantics of Dart, it is (for now) necessary to understand JavaScript as well, look at compiled code, and learn by analogy.

Answer 4

Some additional note on deleting.

Limitations of JavaScript is affecting dart.

• No reference count available
  This is javascript feature and partly because of the way garbage collection works in browser: What is JavaScript garbage collection?
• No weak reference available(For the time being)
  Another Java-script limitation and because of the lack of access to reference count, self deleting is not an option either.
  Note:There is Expando and while it is useful, it's not a weak reference equivalent. Weak reference allows you to create ghost references that don't keep the object alive: https://en.wikipedia.org/wiki/Weak_reference.
• No destructor available
  javascript does not have it, thus neither does dart.

As the others pointed, the limitations above are usually nothing.
Since the main eventloop can keep objects alive, careless coding could spawn an zombie object though; without destructor or weakref, some references could escape your murderous hands by accident and keep the object alive.

import 'dart:html';
import 'dart:async';
import 'dart:developer';

void main() {
  var e = new XXX();
  var ce = new CustomEvent('custom-event');
  var s = new Stream.periodic(new Duration(microseconds: 10000),(count) {
    print(count);
    window.dispatchEvent(ce);
    return count;
  });
  StreamSubscription ss = s.listen((count){print('stream runnig; ${count}_th run');});
//  e.destroy();
//  ss.cancel();
  e = null;
  s = null;
}
class XXX{
  StreamSubscription subscription;
  XXX(){
    subscription = window.on['custom-event'].listen(event_handler);
  }
  void say_hi(){
    print('hi');
    print(this);
  }
  void event_handler(_){this.say_hi();}
  destroy(){
    subscription.cancel();
  }
}

The above code prints the below in forever loop(unless you uncomment the two lines):

 ....
hi
VM33:1 Instance of 'XXX'
VM34:1 stream runnig; 751_th run
VM34:1 752
VM33:1 hi
VM33:1 Instance of 'XXX'
VM34:1 stream runnig; 752_th run
......

I don't know if the object e would persist without print(this), maybe only related objects are kept from garbage collection.

In any case, with more complicated code, manual clean up is necessary and I wish one of the three missing features is there but there is not.

Deleting indeed can be hard.

Answer 5

To delete an object in Flutter, you don't explicitly call a destructor or delete the object like in some other programming languages. Dart, the language used in Flutter, has a garbage collector that automatically cleans up memory when objects are no longer reachable. When there are no more references to an object, it becomes eligible for garbage collection.

In your specific use case of deleting rectangles and ensuring that associated objects are properly deleted, you can follow these steps:

1. Create a class to represent the rectangle object, along with any additional properties and references you need. For example:

class Rectangle {
  // Properties and references of the rectangle object
}

2. Create an object that holds references to the rectangles and manages their deletion. You can use a list or another data structure to store the rectangles. For example:

class RectangleManager {
  List<Rectangle> rectangles = [];

  // Other methods and logic for managing the rectangles
}

3. When a rectangle is selected for deletion, remove it from the list or data structure:

// invoke this function when the user press back (like using GestureDetector)
void deleteRectangle(Rectangle rectangle) {
  rectangleManager.rectangles.remove(rectangle);
  // Perform any additional cleanup or actions associated with the deletion
}

4. Ensure that all references to the deleted rectangle are removed. This includes any other objects that hold references to the rectangle or its associated properties.

By removing the references to the rectangle object, you allow the Dart garbage collector to automatically clean up the memory associated with the deleted object when it determines that the object is no longer reachable.

Dart does not have explicit destructors like some other languages. The garbage collector handles the memory management, and you can rely on it to clean up objects that are no longer in use.

References:

• Dart Language Tour - Memory Management
• Dart Language Tour - Operators and Control Flow
• Dart Language Tour - Classes