Lecture ini membahas Strict Mode ("use strict") di JavaScript.

Konsep ini penting karena Strict Mode membantu JavaScript menjadi lebih ketat dalam mendeteksi kesalahan, terutama kesalahan yang dalam mode normal kadang dibiarkan begitu saja.

Kalau disederhanakan:

Strict Mode = “JavaScript, tolong lebih ketat. Kalau saya melakukan sesuatu yang berpotensi salah, kasih saya error supaya saya bisa memperbaikinya.”

1. Apa itu Strict Mode?

Untuk mengaktifkan Strict Mode, kita menulis:

"use strict";

Biasanya diletakkan di baris paling awal file JavaScript.

Contoh:

"use strict";

let name = "John";

console.log(name);

Dengan Strict Mode aktif, JavaScript akan menerapkan beberapa aturan tambahan.

Tujuannya bukan membuat JavaScript menjadi lebih sulit, tetapi:

• mendeteksi kesalahan lebih awal
• mencegah perilaku yang membingungkan
• membuat kode lebih aman
• membantu developer menemukan bug
• mencegah beberapa pola kode lama yang berisiko

2. Apa maksudnya “lebih ketat”?

Bayangkan kamu punya guru.

Guru pertama berkata:

“Kalau salah sedikit, saya diam saja.”

Guru kedua berkata:

“Kalau salah, saya langsung kasih tahu.”

Mode JavaScript biasa kurang lebih seperti guru pertama.

Strict Mode seperti guru kedua.

Contohnya:

user = "John";

Dalam kondisi tertentu, JavaScript tanpa Strict Mode bisa membiarkan ini.

Tetapi dengan:

"use strict";

user = "John";

JavaScript akan mengatakan:

ReferenceError: user is not defined

Dan ini justru bagus karena kita langsung tahu:

“Oh, saya lupa mendeklarasikan variable.”

3. Contoh pertama: membuat variable tanpa let, const, atau var

Normalnya kita sudah belajar bahwa variable dibuat menggunakan:

let
const
var

Misalnya:

let user = "John";

Tetapi JavaScript lama memiliki perilaku yang memungkinkan kode seperti ini:

user = "John";

Tidak ada:

let
const
var

Dalam mode non-strict, browser dapat memperlakukan user sebagai property pada global object.

Di browser, global object yang dibahas dalam lecture adalah:

window

Sehingga secara konseptual:

user = "John";

bisa membuat:

window.user

menjadi:

"John"

4. Kenapa ini berbahaya?

Bayangkan kamu tidak sengaja typo:

username = "John";

Padahal sebenarnya kamu bermaksud:

userName = "John";

Tanpa Strict Mode, kesalahan seperti ini pada kode lama bisa saja tidak langsung menghasilkan error.

Akibatnya program mungkin tetap berjalan, tetapi menghasilkan bug yang sulit dicari.

Dengan Strict Mode:

"use strict";

username = "John";

akan menghasilkan error jika username belum dideklarasikan.

Jadi kita dipaksa memperbaikinya:

"use strict";

let username = "John";

5. Contoh kedua: salah mengetik nama variable

Ini contoh yang sangat bagus untuk memahami manfaat Strict Mode.

Misalnya:

"use strict";

let isEligible = false;
let isFullAge = true;

if (isFullAge) {
    iseligible = true;
}

console.log(isEligible);

Perhatikan baik-baik.

Kita membuat:

isEligible

dengan huruf E besar.

Tetapi di dalam if, kita menulis:

iseligible

huruf e kecil.

JavaScript bersifat case-sensitive.

Artinya:

isEligible

dan:

iseligible

adalah dua nama yang berbeda.

6. Tanpa Strict Mode

Dalam mode non-strict, assignment seperti:

iseligible = true;

bisa membuat global variable/property baru dalam lingkungan tertentu.

Akibatnya:

console.log(isEligible);

tetap menghasilkan:

false

Padahal programmer sebenarnya bermaksud mengubah:

isEligible

menjadi:

true

Ini bug.

Yang lebih buruk:

JavaScript tidak memberitahu kita bahwa kita melakukan typo.

7. Dengan Strict Mode

Sekarang:

"use strict";

let isEligible = false;
let isFullAge = true;

if (isFullAge) {
    iseligible = true;
}

JavaScript akan menghasilkan error karena:

iseligible

belum dideklarasikan.

Ini sangat membantu.

Developer langsung tahu:

“Oh, ternyata saya salah mengetik nama variable.”

Lalu kita perbaiki:

if (isFullAge) {
    isEligible = true;
}

Sekarang benar.

8. Jadi Strict Mode membantu menangkap typo

Ini salah satu manfaat terpenting.

Tanpa Strict Mode:

let username = "John";

usernme = "Mark";

Bisa menjadi bug yang sulit ditemukan.

Dengan Strict Mode:

"use strict";

let username = "John";

usernme = "Mark";

langsung error.

Jadi pola pikirnya:

Tanpa Strict Mode
      ↓
Kesalahan
      ↓
JavaScript mungkin diam
      ↓
Bug bisa muncul belakangan

Sedangkan:

Dengan Strict Mode
      ↓
Kesalahan
      ↓
JavaScript memberi error
      ↓
Developer langsung memperbaiki

9. "use strict" sebenarnya apa?

Ini menarik.

"use strict";

terlihat seperti String biasa.

Kamu mungkin bertanya:

“Kenapa String bisa mengaktifkan mode JavaScript?”

Karena JavaScript mengenali directive prologue tertentu di awal script/function.

String literal seperti:

"use strict";

di posisi khusus tersebut memiliki arti khusus bagi JavaScript.

Jadi bukan berarti kita membuat variable bernama "use strict".

Ini adalah instruksi kepada JavaScript:

“Jalankan kode ini dalam Strict Mode.”

10. "use strict" harus berada di awal

Ini aturan penting dari lecture.

Yang benar:

"use strict";

console.log("Hello");

let x = 100;

Yang salah untuk mengaktifkan strict mode pada script:

console.log("Hello");

"use strict";

let x = 100;

Kenapa?

Karena "use strict" harus berada di awal bagian kode yang ingin dibuat strict.

Kalau ada statement executable sebelum itu, JavaScript tidak memperlakukannya sebagai directive untuk mengaktifkan Strict Mode pada script tersebut.

11. Contoh

❌ Tidak efektif sebagai Strict Mode untuk seluruh script:

console.log("Hello");

"use strict";

user = "John";

Jangan seperti ini.

✅ Benar:

"use strict";

console.log("Hello");

user = "John";

Sekarang assignment ke variable yang belum dideklarasikan akan menghasilkan error.

12. Jadi "use strict" seperti saklar

Bayangkan:

"use strict";

seperti saklar:

        STRICT MODE

             ↓

    ┌─────────────────┐
    │ JavaScript lebih│
    │    ketat         │
    └─────────────────┘
             ↓
    Kesalahan tertentu
    menjadi ERROR

Dan saklar ini harus dinyalakan di tempat yang benar, yaitu di awal.

13. Contoh ketiga: duplicate parameter

Lecture memberikan contoh lain.

Misalnya kita membuat function:

function greeting(x, x) {
    console.log("Hello");
}

Perhatikan:

(x, x)

Parameter yang sama digunakan dua kali.

Dalam JavaScript non-strict, ini secara historis bisa diterima.

Tetapi dalam Strict Mode:

"use strict";

function greeting(x, x) {
    console.log("Hello");
}

akan menghasilkan error karena terdapat duplicate parameter name.

Artinya:

Parameter x dideklarasikan dua kali.

Solusinya:

"use strict";

function greeting(x, y) {
    console.log("Hello");
}

Sekarang tidak masalah.

14. Kenapa duplicate parameter dianggap buruk?

Bayangkan:

function add(x, x) {
    return x + x;
}

Kemudian:

add(10, 20);

Pertanyaannya:

x yang mana?

10?

20?

Perilaku seperti ini membingungkan.

Strict Mode membantu mencegah pola kode seperti ini.

15. Contoh keempat: reserved words

JavaScript memiliki kata-kata tertentu yang digunakan sebagai keyword.

Contoh:

let
const
function
if
else
return
class

Ada juga kata-kata yang dicadangkan untuk kemungkinan penggunaan di masa depan atau memiliki status khusus dalam grammar tertentu.

Lecture memberikan contoh:

interface

Dalam konteks lecture tersebut, penggunaan nama seperti itu dalam Strict Mode ditolak sebagai reserved word.

Misalnya:

"use strict";

var interface = 100;

akan menghasilkan error pada lingkungan JavaScript yang menerapkan aturan tersebut.

16. Kenapa JavaScript melakukan ini?

Bayangkan hari ini kamu menulis:

var interface = 100;

Kemudian beberapa tahun kemudian JavaScript menggunakan:

interface

sebagai keyword.

Browser masa depan membaca:

interface = 100;

dan mungkin mengartikannya sebagai syntax khusus, bukan sebagai nama variable.

Akibatnya kode lama bisa bermasalah.

Strict Mode membantu menghindari penggunaan identifier tertentu yang dianggap reserved.

17. Hubungan Strict Mode dengan code lama

Ini alasan Strict Mode cukup penting secara historis.

JavaScript berkembang dari bahasa yang awalnya sangat fleksibel.

Beberapa perilaku lama:

"boleh saja"

kemudian dianggap:

"sebaiknya jangan"

Strict Mode membantu membuat aturan yang lebih ketat tanpa harus mengubah seluruh JavaScript normal secara langsung.

Jadi:

JavaScript lama
       ↓
banyak perilaku permisif
       ↓
Strict Mode
       ↓
lebih banyak kesalahan terdeteksi
       ↓
kode lebih mudah dipelihara

18. Strict Mode bukan “mode keamanan total”

Ada satu hal yang perlu diluruskan.

Lecture mengatakan Strict Mode membuat kode lebih secure/aman.

Boleh dipahami seperti itu dalam konteks lecture, tetapi jangan menganggap:

“use strict membuat aplikasi saya otomatis aman dari hacker.”

❌ Bukan begitu.

Strict Mode bukan security system seperti firewall atau encryption.

Manfaat utamanya adalah:

• mencegah beberapa kesalahan pemrograman
• mengurangi perilaku JavaScript yang membingungkan
• membuat bug tertentu lebih cepat terlihat
• menerapkan aturan bahasa yang lebih ketat

Jadi lebih tepat:

Strict Mode meningkatkan safety dan predictability dari kode JavaScript, bukan menjadi sistem keamanan aplikasi secara keseluruhan.

19. Strict Mode berlaku di mana?

Ada dua cara umum.

A. Seluruh script

"use strict";

let x = 100;

Directive di awal script membuat script tersebut strict.

B. Function tertentu

Strict Mode juga bisa diterapkan pada function:

function test() {
    "use strict";

    // kode di sini strict
}

Namun untuk kode modern, penggunaan module (import/export) secara default sudah berada dalam Strict Mode, sehingga kamu sering tidak perlu menulis "use strict" secara manual pada module.

Untuk materi course ini, fokus dulu pada bentuk:

"use strict";

di awal file.

20. Hubungkan dengan var, let, dan const

Lecture sebelumnya kita belajar:

var
let
const

Sekarang Strict Mode memberi kita perlindungan tambahan.

Misalnya:

"use strict";

username = "John";

❌ Tidak boleh.

Kita harus menulis:

"use strict";

let username = "John";

Ini juga memperkuat kebiasaan yang sudah kita pelajari:

Variable harus dideklarasikan secara jelas.

21. Strict Mode dan typo

Ini salah satu contoh paling gampang untuk diingat.

Tanpa Strict Mode:

let userName = "John";

usernme = "Mark";

Typo:

usernme
   ↑
salah

Bisa menghasilkan masalah yang tidak langsung terlihat.

Dengan:

"use strict";

JavaScript akan lebih cepat mengeluh.

Jadi Strict Mode seperti spell checker untuk beberapa kesalahan JavaScript.

Bukan spell checker sebenarnya, tetapi analoginya membantu.

22. Perbandingan sederhana

23. Jangan lupa istilah “sloppy mode”

Mode normal yang tidak menggunakan Strict Mode sering disebut:

sloppy mode

Bukan berarti JavaScript benar-benar “ceroboh”, tetapi istilah ini digunakan untuk membedakannya dari Strict Mode.

Jadi:

"use strict";
      ↓
Strict Mode

Tidak ada:

"use strict";

maka pada script/function yang bukan module dan tidak berada di strict context:

Sloppy Mode

24. Kesalahan yang perlu kamu pahami dari lecture

Lecture memberikan beberapa contoh.

Contoh 1 — variable tidak dideklarasikan

❌

"use strict";

user = "John";

✅

"use strict";

let user = "John";

Contoh 2 — typo nama variable

❌

"use strict";

let isEligible = false;

iseligible = true;

Karena:

isEligible
iseligible

berbeda.

✅

"use strict";

let isEligible = false;

isEligible = true;

Contoh 3 — duplicate parameter

❌

"use strict";

function greeting(x, x) {
}

✅

"use strict";

function greeting(x, y) {
}

25. Hal yang sangat penting: Strict Mode tidak memperbaiki kode

Misalnya:

"use strict";

let age = 20;

Strict Mode tidak membuat kode ini “lebih pintar”.

Ia hanya membuat JavaScript mengatakan:

“Saya akan menerapkan aturan yang lebih ketat.”

Jadi kalau ada kesalahan:

"use strict";

user = "John";

Strict Mode tidak memperbaikinya otomatis.

Dia hanya memberi tahu:

❌ Error!

Kemudian kita sebagai developer yang harus memperbaikinya:

let user = "John";

26. Cara berpikir paling sederhana

Bayangkan ada dua mode:

Mode biasa

Kamu:
"Ups, saya salah tulis variable."

JavaScript:
"Ya sudah..."

😅

Strict Mode

Kamu:
"Ups, saya salah tulis variable."

JavaScript:
"ERROR! Perbaiki dulu."

😄

Itulah inti Strict Mode.

27. Hubungkan dengan debugging

Kita sebelumnya sudah belajar menggunakan Console untuk melihat error.

Strict Mode membuat Console menjadi lebih berguna karena kesalahan yang sebelumnya mungkin “diam” sekarang bisa muncul sebagai error.

Alurnya:

Kode JavaScript
      ↓
"use strict"
      ↓
JavaScript memeriksa aturan lebih ketat
      ↓
Ada kesalahan?
   ↙       ↘
 YA       TIDAK
 ↓           ↓
ERROR      lanjut
 ↓
Developer memperbaiki

Ini sangat membantu ketika debugging.

28. Cheat sheet

Simpan bagian ini karena kemungkinan akan berguna nanti:

"use strict";

Fungsi:

Mengaktifkan Strict Mode.

Posisi:

"use strict";

harus berada di awal script/function yang ingin dibuat strict.

Manfaat:

Strict Mode
├── mendeteksi kesalahan tertentu
├── mencegah undeclared assignment
├── mencegah duplicate parameter
├── lebih ketat terhadap reserved words
└── membuat kode lebih predictable

🎯 Kesimpulan besar

Lecture ini sebenarnya ingin kamu memahami satu ide sederhana:

JavaScript secara historis cukup permisif terhadap beberapa kesalahan. Strict Mode mengubah sebagian perilaku tersebut menjadi error sehingga developer bisa mengetahui dan memperbaikinya lebih awal.

Cara mengaktifkannya:

"use strict";

dan letakkan di awal.

Tiga contoh penting dari lecture:

"use strict";

// 1. Harus deklarasi variable
user = "John"; // ❌

"use strict";

// 2. Typo variable terdeteksi
let isEligible = false;

iseligible = true; // ❌

"use strict";

// 3. Duplicate parameter tidak boleh
function greeting(x, x) { // ❌
}

Jadi mental model yang paling mudah:

"use strict" = “JavaScript, jangan biarkan saya melakukan kesalahan secara diam-diam.”

Dan ini nyambung dengan lecture sebelumnya: kalau var, let, dan const membahas bagaimana variable dibuat dan bagaimana scope-nya bekerja, maka Strict Mode membahas seberapa ketat JavaScript memperlakukan beberapa kesalahan dalam kode kita.