Transcript ini membahas const constructor di Dart, terutama hubungannya dengan immutable object, canonical instance, identical(), dan optimasi widget Flutter.

Ada beberapa bagian transcript yang benar, tetapi ada juga beberapa bagian yang perlu diluruskan karena penjelasannya agak terlalu disederhanakan, terutama soal development mode vs release mode, canonicalization, dan widget rebuild.

1. Apa itu const constructor?

Secara sederhana:

const constructor adalah constructor yang memungkinkan Dart membuat object yang nilainya bersifat konstan dan immutable.

Contoh:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Perhatikan:

const Point(this.x, this.y);

Keyword const di depan constructor membuat constructor tersebut menjadi const constructor.

Kemudian kita bisa membuat object seperti ini:

const p1 = Point(10, 20);

atau:

final p1 = const Point(10, 20);

atau bahkan:

Point p1 = const Point(10, 20);

Yang penting adalah saat object dibuat, kita menggunakan const jika ingin meminta instance const.

2. Bedakan const constructor dan const object

Ini sangat penting.

Misalnya:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Constructor-nya adalah:

const Point(...)

Ini disebut const constructor.

Tetapi:

const Point(10, 20)

adalah pemanggilan constructor dengan const, sehingga menghasilkan constant object.

Jadi:

const di constructor
        ↓
membuat constructor menjadi const constructor

const saat membuat object
        ↓
meminta Dart membuat constant object

3. Apa syarat utama const constructor?

Salah satu aturan paling penting:

Field instance yang harus diinisialisasi oleh constructor const harus bersifat final.

Contoh yang benar:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kenapa?

Karena object const harus immutable.

Artinya setelah object dibuat:

const p = Point(10, 20);

kita tidak boleh melakukan:

p.x = 50; // ❌

Selain itu, field-nya memang final.

4. Kenapa harus final?

Bayangkan kita punya:

class Person {
  String name;

  const Person(this.name);
}

Secara konsep, ini bermasalah karena:

Person("Budi")

memiliki field yang bisa berubah:

person.name = "Andi";

Padahal object const harus immutable.

Karena itu, gunakan:

class Person {
  final String name;

  const Person(this.name);
}

Sekarang:

const p = Person("Budi");

nilai name tidak dapat diubah.

5. late juga tidak bisa digunakan seperti itu

Misalnya:

class Point {
  late int x;
  late int y;

  const Point();
}

Ini tidak valid sebagai const constructor.

Kenapa?

Karena late berarti nilai akan diinisialisasi kemudian, sedangkan constant object harus dapat ditentukan nilainya pada saat constant construction.

Jadi secara praktis untuk beginner, ingat:

const constructor
      ↓
field instance harus bisa diinisialisasi secara immutable
      ↓
umumnya gunakan final

6. const constructor tidak boleh punya body

Ini juga aturan penting.

❌ Tidak boleh:

class Person {
  final String name;

  const Person(this.name) {
    print("Hello");
  }
}

Const constructor tidak boleh mempunyai constructor body.

Jadi:

class Person {
  final String name;

  const Person(this.name);
}

Benar.

Kalau membutuhkan initializer list, masih bisa digunakan selama sesuai aturan constant expression:

class Rectangle {
  final int width;
  final int height;
  final int area;

  const Rectangle(this.width, this.height)
      : area = width * height;
}

Jadi jangan memahami aturan transcript sebagai:

“Const constructor tidak boleh memiliki initialization sama sekali.”

Yang benar:

Const constructor tidak boleh memiliki body { ... }, tetapi dapat memiliki initializer list yang valid untuk constant evaluation.

7. const constructor tidak boleh factory

Misalnya:

class Person {
  final String name;

  const Person(this.name);
}

Ini adalah generative const constructor.

Tidak bisa:

class Person {
  final String name;

  const factory Person(this.name); // ❌
}

Karena factory dan const generative constructor memiliki mekanisme yang berbeda.

Ingat konsep sebelumnya:

Generative constructor

Person(this.name);

Constructor ini benar-benar melakukan proses pembentukan instance.

Factory constructor

factory Person.create() {
  return Person("Budi");
}

Factory bebas menentukan object mana yang akan dikembalikan.

Sementara const constructor memiliki aturan khusus agar object dapat dibuat sebagai constant.

8. Apa itu immutable?

Immutable berarti:

Setelah object dibuat, keadaan/nilai object tersebut tidak dapat diubah.

Contoh:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kemudian:

const p = Point(10, 20);

Nilainya:

x = 10
y = 20

Tidak bisa diubah menjadi:

x = 50
y = 100

Object const memang harus immutable.

9. Apa itu canonical instance?

Ini bagian transcript yang biasanya paling membingungkan.

Misalnya:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kemudian:

const p1 = Point(10, 20);
const p2 = Point(10, 20);

Secara kode kita seperti membuat dua object:

p1 → Point(10,20)

p2 → Point(10,20)

Tetapi karena keduanya adalah constant object dengan nilai yang sama, Dart dapat melakukan canonicalization.

Secara sederhana:

Point(10,20)
       ↓
"Apakah constant object dengan nilai ini
 sudah pernah dibuat?"
       ↓
      YA
       ↓
gunakan instance yang sama

Jadi:

identical(p1, p2)

dapat menghasilkan:

true

10. Apa itu identical()?

identical() digunakan untuk mengecek:

Apakah dua reference menunjuk ke object instance yang sama?

Contoh:

final p1 = const Point(10, 20);
final p2 = const Point(10, 20);

print(identical(p1, p2));

Hasilnya dapat:

true

Artinya bukan sekadar:

“Nilainya sama.”

Tetapi:

“Keduanya menunjuk ke instance yang sama.”

Ini berbeda dengan ==.

11. == vs identical()

Misalnya:

class Point {
  final int x;
  final int y;

  Point(this.x, this.y);
}

Kemudian:

final p1 = Point(10, 20);
final p2 = Point(10, 20);

Dua object berbeda bisa saja mempunyai nilai sama.

Secara identity:

identical(p1, p2)

biasanya:

false

Karena:

p1 → Object A

p2 → Object B

Walaupun:

Object A:
x = 10
y = 20

Object B:
x = 10
y = 20

Sedangkan == bergantung pada implementasi equality class tersebut.

12. Bagaimana dengan hashCode?

Transcript banyak menggunakan hashCode untuk menunjukkan apakah object sama.

Ini perlu diluruskan.

hashCode bukan identitas object dan bukan memory address.

Contoh:

print(p1.hashCode);
print(p2.hashCode);

Hash code yang sama tidak otomatis berarti object yang sama.

Untuk mengecek apakah dua reference benar-benar menunjuk object yang sama, gunakan:

identical(p1, p2)

Jadi:

hashCode
    ↓
nilai hash untuk kebutuhan hashing/equality

identical()
    ↓
cek identity object

Untuk pembelajaran const, identical() jauh lebih tepat.

13. Contoh lengkap canonicalization

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

void main() {
  const p1 = Point(10, 20);
  const p2 = Point(10, 20);

  print(identical(p1, p2));
}

Hasil yang diharapkan:

true

Karena kedua constant object mempunyai konfigurasi constant yang sama.

14. Kalau tidak menggunakan const bagaimana?

Sekarang:

final p1 = Point(10, 20);
final p2 = Point(10, 20);

Walaupun constructor-nya:

const Point(...)

kita tidak meminta constant construction karena tidak menulis const.

Akibatnya:

identical(p1, p2)

umumnya:

false

Secara mental:

final p1 = Point(10,20);

        ↓

buat instance biasa

dan:

final p2 = Point(10,20);

        ↓

buat instance biasa lainnya

Jadi:

p1 → Object A
p2 → Object B

15. Ini kesalahan pemahaman yang sering terjadi

Ada orang yang berpikir:

“Kalau constructor-nya const, semua object otomatis const.”

Tidak tepat.

Misalnya:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Constructor-nya memang const.

Tetapi:

final p1 = Point(10, 20);
final p2 = Point(10, 20);

bukan berarti otomatis kita sedang membuat constant object.

Untuk meminta constant object:

const p1 = Point(10, 20);
const p2 = Point(10, 20);

16. Jadi ada dua hal yang harus dibedakan

A. Const constructor

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Artinya:

Class ini menyediakan constructor yang dapat digunakan untuk constant construction.

B. Const object

const Point(10, 20);

Artinya:

Buat instance sebagai constant object.

17. Kenapa const penting di Flutter?

Nah, ini bagian yang sangat penting.

Di Flutter kita sering menulis:

Text("Hello")

Padding(...)

SizedBox(...)

Icon(...)

dan sebagainya.

Banyak widget Flutter bersifat immutable.

Flutter sangat sering menggunakan const untuk widget yang nilainya memang tidak berubah.

Contoh:

const Text("Hello")

dibanding:

Text("Hello")

Kalau widget tersebut benar-benar tidak membutuhkan nilai runtime yang berubah, const bisa membantu Flutter/Dart mengoptimalkan object tersebut.

18. Contoh sederhana di Flutter

Misalnya:

Column(
  children: [
    const Text("Hello"),
    const Text("Hello"),
    const Text("Hello"),
  ],
)

Ketiga widget Text tersebut memiliki konfigurasi constant yang sama.

Dengan constant construction, Dart dapat melakukan canonicalization.

Secara konsep:

const Text("Hello")
        ↓
cek constant instance
        ↓
sudah ada?
        ↓
gunakan instance yang sesuai

19. Tapi ada konsep yang jauh lebih penting: rebuild

Transcript kemudian masuk ke contoh:

MyTextOne
MyTextTwo

dengan counter.

Misalnya:

setState(() {
  counter++;
});

Ketika setState() dipanggil, Flutter melakukan rebuild pada bagian widget tree yang relevan.

Misalnya:

Column(
  children: [
    MyTextOne(text: "Flutter"),
    const MyTextTwo(text: "Teacher"),
  ],
)

Ketika state berubah:

counter = 0
       ↓
setState()
       ↓
counter = 1
       ↓
rebuild

Widget yang non-const dapat dibuat kembali dalam proses build.

Sedangkan constant widget bisa digunakan kembali.

20. Kenapa const widget bisa membantu?

Bayangkan:

Column(
  children: [
    MyWidget(),
    const MyWidget(),
  ],
)

Ketika parent melakukan rebuild:

Parent rebuild
      │
      ├── MyWidget biasa
      │       ↓
      │    bisa dibuat ulang
      │
      └── const MyWidget
              ↓
          instance const
          dapat digunakan kembali

Inilah salah satu alasan Flutter sangat sering menganjurkan penggunaan const ketika memungkinkan.

21. Tapi hati-hati: “const widget tidak pernah rebuild” terlalu disederhanakan

Ini penting untuk meluruskan transcript.

Transcript mengatakan kurang lebih:

“Widget created as const will never rebuild.”

Untuk pemula, kalimat ini sering dipakai sebagai shortcut, tetapi secara teknis lebih tepat mengatakan:

Const widget instance yang sama dapat digunakan kembali ketika parent melakukan rebuild, sehingga Flutter tidak perlu membuat instance widget baru untuk konfigurasi const tersebut.

Jadi bukan berarti:

“Flutter tidak pernah melakukan proses apa pun terhadap const widget.”

Lebih tepat:

const
 ↓
instance widget dapat direuse
 ↓
tidak perlu membuat instance baru dengan konfigurasi yang sama

22. Rebuild bukan berarti object selalu dibuat ulang

Ini juga konsep Flutter yang sangat penting.

Misalnya:

Widget build(BuildContext context) {
  return const Text("Hello");
}

build() bisa saja dipanggil lagi.

Tetapi karena:

const Text("Hello")

adalah constant instance, Flutter dapat memperoleh kembali instance yang sama.

Jadi:

build() dipanggil
       ↓
const Text("Hello")
       ↓
instance const yang sama dapat digunakan

Jangan menyamakan:

build dipanggil

dengan:

object pasti dibuat baru

Itu dua hal berbeda.

23. Contoh counter

Misalnya:

class MyText extends StatelessWidget {
  final String text;

  const MyText({
    super.key,
    required this.text,
  });

  @override
  Widget build(BuildContext context) {
    print("build MyText: $text");

    return Text(text);
  }
}

Kemudian:

Column(
  children: [
    const MyText(text: "Hello"),
  ],
)

Parent melakukan rebuild karena:

setState(() {
  counter++;
});

Const instance MyText("Hello") dapat tetap digunakan.

Ini membantu mengurangi pekerjaan pembuatan object widget yang sebenarnya tidak berubah.

24. Kenapa widget Flutter banyak menggunakan const?

Karena widget Flutter umumnya immutable.

Contohnya:

const Text("Hello")

Text "Hello" tidak berubah.

const SizedBox(height: 20)

tingginya tidak berubah.

const Icon(Icons.add)

icon-nya tidak berubah.

Maka kita bisa memberitahu Dart/Flutter:

“Widget ini adalah constant configuration. Tidak ada state mutable yang perlu berubah di dalam instance ini.”

25. Contoh yang tidak bisa menggunakan const

Misalnya:

final name = getName();

Kemudian:

const Text(name)

Ini tidak bisa jika name bukan constant expression.

Karena const membutuhkan nilai yang bisa diketahui secara compile-time/constant evaluation.

Misalnya:

const name = "Budi";

const Text(name);

bisa.

Sedangkan:

final name = getName();

const Text(name); // ❌

tidak bisa jika nilai name diperoleh saat runtime.

26. const vs final

Ini wajib benar-benar dipahami.

final

final name = getName();

Artinya:

Variable hanya boleh diisi sekali.

Nilainya bisa diketahui saat runtime.

const

const name = "Budi";

Artinya:

Nilai tersebut harus merupakan compile-time constant.

Secara sederhana:

final
→ tidak bisa di-assign ulang
→ boleh berasal dari runtime

const
→ constant
→ harus bisa dievaluasi sebagai constant

27. const object juga immutable

Misalnya:

class User {
  final String name;

  const User(this.name);
}

Kemudian:

const user = User("Budi");

Kita tidak bisa:

user.name = "Andi"; // ❌

Selain karena name final, constant object memang immutable.

28. Kenapa canonicalization bisa menghemat memory?

Bayangkan ada:

const Point(10, 20)

dipakai 100 kali.

Secara konseptual, tanpa reuse:

Object 1 → Point(10,20)
Object 2 → Point(10,20)
Object 3 → Point(10,20)
...
Object 100 → Point(10,20)

Dengan constant canonicalization:

              ┌─ Point(10,20)
              │
const Point ──┤
              │
              └─ reuse instance yang sama

Jadi tidak perlu membuat instance constant identik berkali-kali.

Ini salah satu manfaat const.

29. Tetapi jangan menganggap const selalu berarti “hemat memory sebanyak mungkin”

Ini juga perlu diluruskan.

const memang memungkinkan canonicalization dan reuse instance, tetapi jangan menjadikan:

“const selalu pasti membuat aplikasi jauh lebih cepat dan hemat memory”

sebagai aturan mutlak.

Manfaatnya tergantung situasi.

Dalam Flutter, const sangat berguna terutama karena widget bersifat immutable dan banyak bagian UI memiliki konfigurasi yang tidak berubah.

Jadi manfaat utamanya dapat berupa:

• menghindari pembuatan object yang tidak perlu,
• memungkinkan reuse instance constant,
• membantu Flutter mengenali widget yang sama,
• mengurangi pekerjaan saat rebuild dalam kasus tertentu.

30. Bagian development mode vs release mode

Transcript masuk ke bagian yang cukup membingungkan:

“Di development mode widget const tidak canonical, tetapi di release mode canonical.”

Ini jangan dihafalkan sebagai aturan Dart yang mutlak.

Ada detail implementasi runtime/compiler dan perbedaan target yang membuat perilaku identity bisa berbeda, terutama ketika contoh dijalankan melalui environment berbeda seperti DartPad/web, VM, atau Flutter development/release.

Yang paling aman untuk kamu pahami sebagai programmer Flutter adalah:

Jangan menulis kode berdasarkan asumsi bahwa identical() untuk semua const widget/object pasti menghasilkan perilaku yang sama di setiap runtime dan mode.

Untuk konsep bahasa Dart, yang penting:

const p1 = Point(10, 20);
const p2 = Point(10, 20);

adalah constant construction dan Dart memiliki konsep canonicalization untuk constant values.

Sedangkan detail implementasi bagaimana runtime tertentu merepresentasikan dan menginternalkan instance bukan sesuatu yang sebaiknya dijadikan fondasi logika aplikasi.

31. Kenapa DartPad bisa berbeda dengan VS Code?

Ini juga perlu hati-hati.

DartPad dapat menjalankan kode Dart pada environment yang berbeda dari aplikasi Flutter mobile yang kamu jalankan melalui VM/JIT dalam development atau AOT dalam release.

Jadi ketika transcript menunjukkan:

DartPad:
identical(p1, p2) → true

kemudian environment lain menunjukkan perilaku berbeda, jangan langsung mengambil kesimpulan:

“Const hanya canonical di DartPad.”

Bukan begitu.

Ada perbedaan runtime/compiler/environment yang memengaruhi bagaimana object identity direpresentasikan.

Jadi untuk belajar Flutter, fokus utama sebaiknya:

const constructor
      ↓
immutable object
      ↓
constant construction
      ↓
canonicalization/reuse
      ↓
berguna untuk optimasi

bukan menghafal hasil hashCode atau identical() pada setiap environment.

32. Bagian AOT dan snapshot

Transcript juga membahas:

AOT → constant objects dievaluasi → canonicalized → masuk snapshot.

Ini berhubungan dengan cara runtime Dart menyiapkan program untuk dijalankan.

Secara sederhana:

Development

Biasanya Flutter menggunakan mode yang mendukung iterasi cepat dan debugging.

source code
    ↓
compile/execute dalam environment development
    ↓
aplikasi berjalan

Release

Flutter menggunakan AOT compilation untuk menghasilkan aplikasi yang siap didistribusikan.

Secara sederhana:

Dart code
    ↓
AOT compilation
    ↓
native machine code / compiled artifacts
    ↓
aplikasi release

Constant values dapat diproses secara compile-time dan menjadi bagian dari hasil kompilasi/runtime representation.

Namun jangan terlalu mengikat konsep:

“semua const pasti dimuat ke memory sejak aplikasi mulai dan tidak pernah garbage collected”

sebagai aturan universal yang harus kamu gunakan dalam pemrograman Dart. Detail representasi runtime, snapshot, dan lifetime dapat bergantung pada runtime/compiler.

33. Hal yang jauh lebih penting untuk Flutter: const pada widget

Misalnya:

Scaffold(
  body: Center(
    child: Text("Hello"),
  ),
)

Bisa menjadi:

Scaffold(
  body: Center(
    child: const Text("Hello"),
  ),
)

Atau kalau seluruh bagian memungkinkan:

const Scaffold(
  body: Center(
    child: Text("Hello"),
  ),
)

Tentu hanya jika semua argumen di dalamnya memenuhi syarat constant expression.

34. Kenapa const sering muncul di Flutter?

Karena Flutter menggunakan widget sebagai immutable configuration.

Contoh:

class MyWidget extends StatelessWidget {
  final String title;

  const MyWidget({
    super.key,
    required this.title,
  });

  @override
  Widget build(BuildContext context) {
    return Text(title);
  }
}

Perhatikan:

final String title;

dan:

const MyWidget(...)

Ini memungkinkan:

const MyWidget(title: "Hello")

35. Kenapa constructor widget harus const?

Misalnya kita membuat custom widget:

class MyText extends StatelessWidget {
  final String text;

  const MyText(this.text);

  @override
  Widget build(BuildContext context) {
    return Text(text);
  }
}

Sekarang kita bisa:

const MyText("Hello")

Kalau constructor tidak diberi const:

class MyText extends StatelessWidget {
  final String text;

  MyText(this.text);

  @override
  Widget build(BuildContext context) {
    return Text(text);
  }
}

maka:

const MyText("Hello");

akan error.

36. Pola yang sering kamu lihat di Flutter

Kamu akan sering melihat:

const MyWidget({
  super.key,
  required this.title,
});

Kenapa?

Karena widget:

MyWidget

memiliki field:

final String title;

dan tidak perlu mutable state di dalam widget tersebut.

Maka constructor-nya dapat dibuat const.

37. StatelessWidget dan const

Ini pola penting:

class MyButton extends StatelessWidget {
  final String text;

  const MyButton({
    super.key,
    required this.text,
  });

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: () {},
      child: Text(text),
    );
  }
}

Kemudian:

const MyButton(text: "Login")

bisa menjadi constant widget.

38. Bagaimana setState() berhubungan dengan ini?

Misalnya:

int counter = 0;

kemudian:

setState(() {
  counter++;
});

setState() memberi tahu Flutter bahwa state berubah.

Akibatnya Flutter dapat menjalankan proses rebuild.

Misalnya:

Column(
  children: [
    Text("$counter"),
    const Text("Hello"),
  ],
)

Ketika:

counter = 0

menjadi:

counter = 1

bagian:

Text("$counter")

jelas perlu berubah.

Tetapi:

const Text("Hello")

tidak berubah.

Maka constant widget dapat digunakan kembali.

39. Gambaran visualnya

Bayangkan:

             setState()
                 ↓
          Parent melakukan build
                 ↓
        ┌────────┴────────┐
        ↓                 ↓
 Text("$counter")    const Text("Hello")
        ↓                 ↓
 konfigurasi berubah   konfigurasi tetap
        ↓                 ↓
 perlu widget baru?     dapat reuse

Inilah ide utama yang ingin ditunjukkan oleh contoh dalam video.

40. Tetapi const bukan pengganti setState()

Jangan sampai salah memahami:

const = mencegah rebuild seluruh widget tree

❌ Bukan begitu.

const bukan mekanisme state management.

setState() tetap bisa menyebabkan rebuild.

const hanya membantu ketika ada object/widget yang memang constant dan dapat digunakan kembali.

41. const juga bukan berarti “build method tidak pernah dipanggil”

Ini sangat penting.

Misalnya:

const MyText("Hello")

kemudian parent rebuild.

Jangan menyimpulkan:

const → build() tidak pernah dipanggil

Secara teknis, mekanisme rebuild Flutter lebih kompleks daripada itu.

Yang lebih tepat:

Const memungkinkan Flutter menggunakan kembali instance widget yang immutable daripada membuat instance baru dengan konfigurasi yang sama.

Jadi fokus pada reuse instance, bukan menghafal kalimat “build tidak dipanggil”.

42. Contoh sederhana untuk memahami semuanya

Kita buat class Dart biasa:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kemudian:

void main() {
  const p1 = Point(10, 20);
  const p2 = Point(10, 20);

  print(identical(p1, p2));
}

Konsepnya:

const Point(10,20)
        ↓
constant object
        ↓
canonicalization
        ↓
Point(10,20) instance yang dapat direuse

43. Bandingkan dengan object biasa

Const

const p1 = Point(10, 20);
const p2 = Point(10, 20);

Konsep:

p1 ─────┐
        ↓
   Point(10,20)
        ↑
p2 ─────┘

Non-const

final p1 = Point(10, 20);
final p2 = Point(10, 20);

Konsep:

p1 ──→ Point(10,20) #1

p2 ──→ Point(10,20) #2

Walaupun nilainya sama, instance-nya berbeda.

44. Constructor biasa vs const constructor

Constructor biasa

class Point {
  final int x;
  final int y;

  Point(this.x, this.y);
}

Bisa:

final p = Point(10, 20);

Tetapi:

const p = Point(10, 20); // ❌

karena constructor bukan const.

Const constructor

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Sekarang:

const p = Point(10, 20);

bisa.

Dan constructor tersebut juga tetap bisa dipanggil tanpa const:

final p = Point(10, 20);

Ini poin penting.

45. Jadi const constructor tidak memaksa semua pemanggilan menjadi const

Misalnya:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kita bisa:

const Point(10, 20);

tetapi juga:

Point(10, 20);

Yang kedua adalah object biasa.

Jadi:

const constructor
      ↓
memberikan kemampuan membuat const object

bukan
      ↓
semua object otomatis menjadi const

46. Ringkasan aturan const constructor

Untuk pemahaman beginner, simpan aturan berikut.

1. Gunakan keyword const

const Point(this.x, this.y);

2. Field yang relevan harus immutable

Biasanya:

final int x;
final int y;

3. Tidak boleh punya constructor body

❌

const Point(this.x) {
  print(x);
}

4. Bukan factory constructor

❌

const factory Point(this.x);

5. Bisa menggunakan initializer list yang valid untuk constant evaluation

const Point(int x) : value = x * 2;

6. Untuk mendapatkan constant object, gunakan const saat pemanggilan jika diperlukan

const Point(10);

47. Tiga istilah yang jangan tertukar

Ini bagian paling penting dari materi.

const constructor

class Point {
  const Point(this.x);
}

Artinya constructor bisa digunakan untuk constant construction.

const object

const Point(10)

Artinya kita sedang membuat object melalui constant construction.

canonical instance

Ketika constant object dengan konfigurasi constant yang sama dapat direpresentasikan sebagai instance yang sama/reusable.

48. Hubungan ketiganya

Pikirkan seperti ini:

const constructor
       ↓
memungkinkan
       ↓
const object
       ↓
constant/canonical representation
       ↓
instance dapat direuse
       ↓
potensi optimasi

49. Kesalahan dalam transcript yang perlu kamu ingat

Ada beberapa poin transcript yang sebaiknya jangan kamu hafalkan mentah-mentah.

❌ “Semua const object pasti tidak pernah rebuild.”

Lebih tepat:

Const widget instance dapat digunakan kembali karena immutable dan constant.

❌ “HashCode menunjukkan object yang sama.”

Tidak tepat.

Gunakan:

identical(a, b)

untuk identity.

❌ “Const constructor harus tidak punya initializer list.”

Tidak tepat.

Initializer list masih bisa digunakan jika memenuhi aturan constant construction.

❌ “Kalau constructor const, semua object yang dibuat otomatis canonical.”

Tidak.

const Point(...)

dan:

Point(...)

berbeda.

❌ “Development mode pasti tidak melakukan canonicalization, release pasti melakukan.”

Terlalu menyederhanakan detail runtime/compiler.

Jangan jadikan itu aturan programming.

50. Hubungannya dengan Flutter sehari-hari

Ketika kamu menulis:

return Scaffold(
  body: Center(
    child: Text("Hello"),
  ),
);

biasakan mengenali bagian yang tidak berubah.

Misalnya:

return Scaffold(
  body: const Center(
    child: Text("Hello"),
  ),
);

atau:

return const Scaffold(
  body: Center(
    child: Text("Hello"),
  ),
);

jika seluruh subtree memenuhi syarat const.

Flutter bahkan biasanya memberikan warning/lint seperti:

Use 'const' with the constructor to improve performance.

Kalau memungkinkan, gunakan const.

51. Analogi paling gampang

Bayangkan kamu punya cetakan barang.

Constructor biasa:

buat barang
buat barang
buat barang

Setiap kali meminta, bisa dibuat instance baru.

Sedangkan constant construction:

"Barang dengan spesifikasi ini sudah ada."
             ↓
"Gunakan yang sudah ada."

Karena barang tersebut tidak boleh diubah.

Jadi:

const
 ↓
immutable
 ↓
nilai tetap
 ↓
bisa dikenali sebagai constant yang sama
 ↓
bisa direuse

52. Cheat sheet

53. Kalimat inti yang perlu kamu hafalkan

Kalau seluruh video ini harus diringkas menjadi beberapa kalimat:

const constructor adalah constructor yang memungkinkan sebuah class digunakan untuk membuat constant object.

Constant object harus immutable, sehingga field instance yang diinisialisasi harus dapat dibuat immutable, umumnya menggunakan final.

Jika object dibuat menggunakan const dan memiliki konfigurasi constant yang sama, Dart dapat melakukan canonicalization sehingga instance dapat direuse.

Di Flutter, const sangat berguna untuk widget yang tidak berubah karena Flutter dapat menggunakan kembali instance widget tersebut ketika terjadi rebuild.

Dan yang paling penting:

class Point {
  final int x;
  final int y;

  const Point(this.x, this.y);
}

Kemudian:

const p1 = Point(10, 20);
const p2 = Point(10, 20);

secara konsep:

            const constructor
                   ↓
          constant construction
                   ↓
          immutable object
                   ↓
           canonicalization
                   ↓
          instance dapat direuse

Sedangkan:

final p1 = Point(10, 20);
final p2 = Point(10, 20);

adalah pemanggilan biasa, meskipun constructor-nya dideklarasikan dengan const.

Inti terbesar materi ini untuk Flutter: jangan menganggap const sebagai sekadar “keyword supaya kode bagus”. const memberi informasi bahwa object/widget tersebut merupakan konfigurasi immutable yang bisa diperlakukan sebagai constant, dan ini dapat membantu Dart serta Flutter menghindari pekerjaan yang tidak diperlukan.