0Pricing
R Academy · Pelajaran

Aturan Lingkup Leksikal

Pahami cara R menemukan variabel dengan menelusuri environment induk.

Aturan Lingkup Leksikal adalah pelajaran R Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar R Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus R Academy mencakup 4 pelajaran total.

Apa Itu Lingkup Leksikal

Lingkup leksikal berarti fungsi mencari variabel di tempat fungsi tersebut didefinisikan, bukan di tempat fungsi tersebut dipanggil. R menggunakan lingkup leksikal. Perilaku ini mudah diprediksi: lingkungan yang dicari fungsi ditetapkan saat fungsi dibuat, bukan saat dipanggil.

x <- 'global'
f <- function() {
  cat('x =', x, '\n')  # looks where f was defined (global)
}
local({
  x <- 'local to local block'
  f()  # still prints global x, not the local one
})

Lingkup Leksikal vs Dinamis

Dalam lingkup dinamis (yang digunakan oleh beberapa bahasa lain), fungsi akan menemukan variabel di lingkungan pemanggil. Sebaliknya, R menggunakan lingkup leksikal: lingkungan yang melingkupi fungsi saat didefinisikan selalu digunakan. Hal ini membuat fungsi berperilaku konsisten, di mana pun fungsi tersebut dipanggil.

val <- 100
make_adder <- function(n) {
  # n is captured from the definition environment
  function(x) x + n
}
add10 <- make_adder(10)
add20 <- make_adder(20)
cat(add10(5), '\n')   # 15 — n=10 from definition
cat(add20(5), '\n')   # 25 — n=20 from definition

Variabel Bebas dan Closure

Variabel di dalam fungsi yang bukan parameter atau hasil penugasan lokal disebut variabel bebas. R mencarinya di lingkungan yang melingkupi fungsi tersebut. Fungsi yang menangkap variabel bebas disebut closure.

base_rate <- 0.05   # free variable captured by f
f <- function(principal, years) {
  principal * (1 + base_rate) ^ years
}
cat('5 yr return:', f(1000, 5), '\n')
# Even if we change base_rate later:
base_rate <- 0.08
cat('New rate return:', f(1000, 5), '\n')

Closure Menangkap Lingkungan

Setiap kali fungsi pabrik dipanggil, fungsi yang dikembalikan (closure) menangkap cuplikan lingkungan yang melingkupinya. Pemanggilan yang berbeda menghasilkan closure dengan nilai yang ditangkap berbeda — inilah dasar dari pabrik fungsi.

power_fn <- function(exp) {
  function(x) x ^ exp
}
square <- power_fn(2)
cube   <- power_fn(3)
cat('square(4) =', square(4), '\n')
cat('cube(3)   =', cube(3),   '\n')

Operator <<-

<<- (penugasan panah ganda) mencari binding yang sudah ada di sepanjang rantai induk dan mengubahnya langsung. Jika tidak ada binding yang ditemukan, operator ini membuatnya di lingkungan global. Operator ini digunakan untuk mengubah variabel di lingkup yang melingkupi fungsi dari dalam fungsi tersebut.

count <- 0
increment <- function() {
  count <<- count + 1
}
increment()
increment()
increment()
cat('count:', count, '\n')

<<- dengan Closure

Penggunaan <<- yang paling sesuai dengan gaya R adalah di dalam closure yang perlu memperbarui keadaan pada lingkungan yang melingkupinya. Dengan demikian, Anda dapat membuat fungsi berkeadaan — fungsi dengan memori yang bertahan di antara pemanggilan.

make_counter <- function() {
  n <- 0
  list(
    increment = function() n <<- n + 1,
    get       = function() n,
    reset     = function() n <<- 0
  )
}
ctr <- make_counter()
ctr$increment()
ctr$increment()
cat('Count:', ctr$get(), '\n')
ctr$reset()
cat('After reset:', ctr$get(), '\n')

Lingkup dalam Fungsi Bersarang

Ketika fungsi bersarang, fungsi bagian dalam dapat melihat variabel yang didefinisikan di fungsi bagian luar. Lingkungan fungsi bagian luar menjadi lingkungan yang melingkupi fungsi bagian dalam, sehingga terbentuk sebuah rantai.

outer <- function() {
  greeting <- 'Hello'
  inner <- function(name) {
    # greeting comes from outer's environment
    paste(greeting, name)
  }
  inner('World')
}
cat(outer(), '\n')

Mencari di Sepanjang Rantai Lingkup

Ketika R mencari variabel, R mencari lingkungan secara berurutan: milik fungsi sendiri → yang melingkupi → yang melingkupi lingkungan sebelumnya → ... → global → jalur pencarian → dasar → kosong. Kecocokan pertama yang ditemukan akan digunakan.

x <- 'global'
f <- function() {
  x <- 'local to f'
  g <- function() {
    # g has no x, so looks in f's env
    cat('g sees x =', x, '\n')
  }
  g()
}
f()

environment() dari suatu Fungsi

Anda dapat memeriksa lingkungan yang melingkupi fungsi apa pun dengan environment(f). Anda bahkan dapat mengaturnya dengan environment(f) <- e, yang mengubah tempat fungsi mencari variabel bebas — teknik yang ampuh, tetapi tingkat lanjut.

x <- 'global_x'
f <- function() x
cat('f sees:', f(), '\n')

# Change f's enclosing environment
my_env <- new.env(parent = emptyenv())
my_env$x <- 'env_x'
environment(f) <- my_env
cat('f now sees:', f(), '\n')

Closure Praktis: Memoisasi

Lingkup leksikal + <<- memungkinkan memoisisasi: simpan hasil fungsi yang mahal dalam tembolok di lingkungan closure. Tembolok tersebut bersifat pribadi bagi closure dan bertahan di antara pemanggilan.

make_memoized_fib <- function() {
  cache <- c()
  function(n) {
    if (!is.null(cache[n])) return(cache[n])
    if (n <= 1) { cache[n] <<- n; return(n) }
    result <- Recall(n-1) + Recall(n-2)
    cache[n] <<- result
    result
  }
}
fib <- make_memoized_fib()
cat(sapply(0:8, fib), '\n')

Jebakan Lingkup Leksikal: Variabel Perulangan

Jebakan klasik adalah membuat closure di dalam perulangan. Semua closure menangkap lingkungan yang sama, bukan cuplikan nilainya. Saat closure dipanggil, variabel perulangan mungkin sudah menyimpan nilai akhirnya.

fns <- vector('list', 3)
for (i in 1:3) {
  local({
    captured_i <- i
    fns[[captured_i]] <<- function() captured_i
  })
}
cat(fns[[1]](), fns[[2]](), fns[[3]](), '\n')

Pemeriksaan Singkat

Dalam lingkup leksikal R, di mana fungsi mencari variabel bebas (yang tidak didefinisikan di dalam fungsi itu sendiri)?

Lingkup Leksikal: Inti Pembelajaran

Inti pembelajaran tentang lingkup leksikal:

  • R menggunakan lingkup leksikal — fungsi mencari variabel di tempat variabel tersebut didefinisikan
  • Fungsi menangkap lingkungan yang melingkupinya sebagai closure
  • Variabel bebas ditentukan saat definisi, bukan saat pemanggilan
  • <<- mengubah binding dalam rantai induk (atau lingkungan global jika tidak ditemukan)
  • Closure + <<- = fungsi berkeadaan dengan keadaan pribadi yang bertahan
  • Jebakan closure dalam perulangan: gunakan local() untuk memaksa pembuatan lingkungan baru pada setiap iterasi
make_multiplier <- function(factor) {
  function(x) x * factor
}
double <- make_multiplier(2)
triple <- make_multiplier(3)
cat('double(7):', double(7), '\n')
cat('triple(7):', triple(7), '\n')
cat('double env factor:', get('factor', envir = environment(double)), '\n')

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Aturan Lingkup Leksikal” gratis?

Ya — teks lengkap “Aturan Lingkup Leksikal” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus R Academy, upgrade ke CoddyKit PRO. Kursus R Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Aturan Lingkup Leksikal”?

Pahami cara R menemukan variabel dengan menelusuri environment induk. Kamu berlatih R Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai R Academy?

Tidak diperlukan pengalaman sebelumnya. R Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Aturan Lingkup Leksikal” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran R Academy ini?

Ya. Setiap pelajaran R Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Apa Itu Environment dalam R?
  2. Aturan Lingkup Leksikal
  3. Lingkup Global vs Lokal
  4. Membuat dan Memeriksa Environment
← Kembali ke R Academy