R Academy · Ders

Sözcüksel Kapsam Kuralları

Q: “Sözcüksel Kapsam Kuralları” dersi ücretsiz mi?

Evet — “Sözcüksel Kapsam Kuralları” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

Q: R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

Q: “Sözcüksel Kapsam Kuralları” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Q: Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

R'nin üst ortamları arayarak değişkenleri nasıl bulduğunu anlayın.

Sözcüksel Kapsam Kuralları, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

Sözlüksel Kapsam Nedir?

Sözlüksel kapsam, bir işlevin değişkenleri çağrıldığı yerde değil, tanımlandığı yerde araması anlamına gelir. R, sözlüksel kapsam kullanır. Bu yaklaşım öngörülebilirdir: bir işlevin aradığı ortam çağrı zamanında değil, oluşturulma zamanında sabitlenir.

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
})

Sözlüksel ve Dinamik Kapsam

Dinamik kapsamda (bazı diğer dillerde kullanılır) bir işlev, değişkeni çağıran ortamda bulur. R ise bunun yerine sözlüksel kapsam kullanır: tanımlama zamanındaki çevreleyen ortam her zaman önceliklidir. Bu, işlevlerin nereden çağrıldıklarından bağımsız olarak tutarlı davranmasını sağlar.

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

Serbest Değişkenler ve Kapanışlar

Bir işlevin içindeki parametre olmayan veya yerel olarak atanmamış değişken, serbest değişkendir. R bu değişkeni çevreleyen ortamda bulur. Serbest değişkenleri yakalayan işlevlere kapanış denir.

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')

Kapanışlar Ortamları Yakalar

Bir fabrika işlevi her çağrıldığında, döndürülen işlev (kapanış) çevreleyen ortamın bir anlık görüntüsünü yakalar. Farklı çağrılar, yakalanan değerleri farklı olan kapanışlar üretir — işlev fabrikalarının temeli budur.

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')

<<- İşleci

<<- (çift ok ataması), mevcut bir bağlamayı bulmak için üst ortam zincirinde arama yapar ve onu yerinde değiştirir. Hiçbir bağlama bulunamazsa genel ortamda yeni bir bağlama oluşturur. Bir işlevin içinden çevreleyen kapsamdaki bir değişkeni değiştirmek için kullanılan araçtır.

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

Kapanışlarla <<-

<<- kullanımının en deyimsel biçimi, çevreleyen ortamındaki durumu güncellemesi gereken kapanışların içindedir. Bu, çağrılar arasında kalıcı belleğe sahip, durum bilgili işlevler oluşturur.

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')

İç İçe İşlevlerde Kapsam

İşlevler iç içe olduğunda, iç işlev dış işlevde tanımlanan değişkenleri görebilir. Dış işlevin ortamı, iç işlevin çevreleyen ortamı olur ve bir zincir oluşturur.

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

Kapsam Zincirinde Arama

R bir değişkeni ararken ortamları şu sırayla tarar: işlevin kendi ortamı → çevreleyen ortam → çevreleyen ortamın çevreleyen ortamı → ... → genel ortam → arama yolu → temel ortam → boş ortam. İlk eşleşme kullanılır.

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()

Bir İşlevin environment() Ortamı

Herhangi bir işlevin çevreleyen ortamını environment(f) ile inceleyebilirsiniz. Hatta bunu environment(f) <- e ile ayarlayabilirsiniz; bu işlem, işlevin serbest değişkenleri nerede arayacağını değiştirir. Bu güçlü ancak ileri düzey bir tekniktir.

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')

Uygulama Kapanışı: Sonuçları Önbelleğe Alma

Sözlüksel kapsam + <<-, sonuçları önbelleğe almayı mümkün kılar: maliyetli işlev sonuçlarını kapanışın ortamında önbelleğe alın. Önbellek kapanışa özeldir ve çağrılar arasında varlığını sürdürür.

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')

Sözlüksel Kapsam Tuzağı: Döngü Değişkenleri

Klasik bir tuzak, döngü içinde kapanışlar oluşturmaktır. Tüm kapanışlar değerin anlık görüntüsünü değil, aynı ortamı yakalar. Çağrıldıkları zamana kadar döngü değişkeni son değerini almış olur.

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')

Kısa Denetim

R'nin sözlüksel kapsam modelinde bir işlev, serbest bir değişkeni (işlevin kendisinde tanımlanmamış olanı) nerede arar?

Sözlüksel Kapsam: Temel Çıkarımlar

Sözlüksel kapsam için temel çıkarımlar:

R sözlüksel kapsam kullanır — işlevler değişkenleri tanımlandıkları yerde arar
Bir işlev, çevreleyen ortamını kapanış olarak yakalar
Serbest değişkenler çağrı zamanında değil, tanımlama zamanında çözümlenir
<<-, üst ortam zincirindeki bir bağlamayı değiştirir (bulamazsa genelde oluşturur)
Kapanışlar + <<- = kalıcı özel duruma sahip, durum bilgili işlevler
Döngü kapanışı tuzağı: her yineleme için yeni bir ortam oluşturmayı zorlamak üzere local() kullanın

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')

Sıkça Sorulan Sorular