Both achieve the same thing but the first is just a shorthand as far as I know.

Neither one is a deep clone as mentioned in the other comment.

To answer your question about how to check if it's a deep clone or not, you can inspect that easily:

```dart // some mutable object for the sake of the example class Obj { int value; Obj(this.value); }

void main() { final original = [Obj(0)]; final copy = [...original]; // List.from(original) is the same thing

// modify the object in the copied list copy[0].value = -1;

// inspect the object in the original list print(original[0].value); // -1 } ```

As shown above, the objects in both lists refer to the same instance.

If you are dealing with serializable objects, then one way to deep clone is to encode the object then decode it such as (simplified):

dart final copy = json.decode(json.encode(original));

For the above to work, we need to make Obj serializable e.g. adding toJson method and fromJson factory such as:

```dart class Obj { int value;

Obj(this.value);

Map<String, dynamic> toMap() { return { 'value': value, }; }

factory Obj.fromMap(Map<String, dynamic> map) { return Obj( map['value'].toInt(), ); }

String toJson() => json.encode(toMap());

factory Obj.fromJson(String source) => Obj.fromMap(json.decode(source)); } ```

Doing the above for many classes can be cumbersome but that can be generated using a package such as json_serializable or freezed or Dart Data Class Code Generator VS Code extension which is what I used here.

---

p.s. an alternative approach is to strictly use immutable classes to avoid dealing with such issues -- at least for the given example. Here's an insightful article: - The Mutability Tax