0Pricing
Lua Academy · Ders

Lua'da Değişken Tanımlama

Genel ve yerel değişkenleri ve adlandırma kurallarını anlayın.

Lua'da Değişken Tanımlama, CoddyKit'te ücretsiz bir Lua 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, Lua Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Lua Academy kursu toplamda 4 dersten oluşur.

Genel ve Yerel Değişkenler

Lua'da değişkenler varsayılan olarak geneldir. local anahtar sözcüğü olmadan x = 10 yazmak, her yerden erişilebilen bir genel değişken oluşturur. local x = 10 kullanmak ise değişkeni geçerli blok ve iç içe bloklarıyla sınırlar.

Performans ve güvenlik için her zaman local kullanmayı tercih edin. Yerel değişkene erişmek, genelden daha hızlıdır; çünkü genellerde _G tablosunda karma tablo araması gerekir.

x = 100          -- global variable
local y = 200    -- local variable

do
  local z = 300  -- block-local
  print(x, y, z) -- 100  200  300
end

print(x, y)      -- 100  200
print(z)         -- nil  (out of scope)

local Anahtar Sözcüğü

local anahtar sözcüğü, en yakın kapsayan blokla sınırlı bir değişken tanımlar: işlev gövdesi, do...end bloğu, döngü gövdesi veya dosya parçacığı. Yerel değişkenler tanımlandıkları satırda oluşturulur ve bloklarının sonunda varlıklarını yitirir.

Aynı satırda birden çok yerel değişken tanımlayıp bunlara aynı anda başlangıç değeri atayabilirsiniz. Başlangıç değeri atanmamış yerel değişkenlerin varsayılan değeri nil'dir.

local a, b, c = 1, 2, 3
print(a, b, c)    -- 1  2  3

local d, e = 10   -- e is nil
print(d, e)       -- 10  nil

local f           -- nil until assigned
f = 42
print(f)          -- 42

Değişken Adlandırma Kuralları

Lua tanımlayıcıları şu kurallara uyar: bir harf veya alt çizgiyle başlamalı, ardından harfler, rakamlar veya alt çizgiler gelmelidir. Lua büyük-küçük harfe duyarlıdır; bu nedenle Value, value ve VALUE üç farklı değişkendir.

Geleneksel olarak: normal değişkenler için camelCase veya snake_case, sabitler için UPPER_CASE kullanın ve özel modül alanlarının başına alt çizgi koyun. Döngü sayaçları dışında tek harfli adlardan kaçının.

local myVariable = 1     -- camelCase
local my_variable = 2    -- snake_case
local MAX_SIZE = 100     -- constant convention
local _private = "hidden" -- private convention

-- Case sensitivity demo
local lua = "lower"
local Lua = "upper"
print(lua, Lua)  -- lower  upper

_G Genel Tablosu

Lua'daki tüm genel değişkenler _G adlı özel bir tabloda bulunur. x = 10 yazmak, _G.x = 10 ile eşdeğerdir. _G üzerinde yineleme yaparak tüm genelleri inceleyebilirsiniz; bu, hata ayıklama için kullanışlı ancak üretim kodu için tehlikelidir.

Lua 5.2 ve sonraki sürümlerde _ENV gerçek ortam tablosudur ve _G bu tabloyu gösterecek şekilde başlatılır. Bunu anlamak, _ENV'yi değiştirerek kodu korumalı bir alana almanızı sağlar.

myGlobal = 42
print(_G.myGlobal)   -- 42

-- Setting via _G is the same as direct assignment
_G.another = "hello"
print(another)        -- hello

-- Counting globals (many built-ins exist)
local count = 0
for k in pairs(_G) do count = count + 1 end
print("Globals:", count)

Çoklu Atama

Lua çoklu atamayı destekler: tek bir ifadede birden çok değişkene değer atayabilirsiniz. Sağ taraf önce değerlendirilir, ardından değerler soldan sağa atanır. Değerlerden daha fazla değişken varsa fazlalıklara nil atanır. Değişkenlerden daha fazla değer varsa fazlalıklar atılır.

Bu özellik, geçici bir değişken kullanmadan değişkenlerin yerini değiştirmeyi kolaylaştırır.

-- Swap without temp variable
local a, b = 10, 20
a, b = b, a
print(a, b)   -- 20  10

-- More variables than values
local x, y, z = 1, 2
print(x, y, z)  -- 1  2  nil

-- More values than variables
local p, q = 1, 2, 3  -- 3 is discarded
print(p, q)   -- 1  2

Kapsam ve Blok Sınırları

Lua'nın blok sınırlayıcıları şunlardır: do...end, işlev gövdeleri, if/elseif/else...end, while...end, repeat...until ve for...end. Bunların her biri yeni bir kapsam düzeyi oluşturur. do...end blokları, başka bir mantık içermeden yalnızca kapsamı sınırlamak için kullanışlıdır.

Bir for döngüsünün başlığında tanımlanan yerel değişken, döngü gövdesiyle sınırlıdır; dışarı sızmaz.

for i = 1, 3 do
  local msg = "item " .. i
  print(msg)
end
-- print(i)   -- would be nil, i is gone
-- print(msg) -- would be nil, msg is gone

-- do...end for manual scoping
do
  local temp = expensive_computation or 0
  print(temp)
end
-- temp is nil here

Sabitler: local convention

Lua'da yerleşik bir const anahtar sözcüğü yoktur. Bir değerin değişmemesi gerektiğini belirtmek için UPPER_CASE adları ve local kullanmak convention'dır. Sabitleri bir modülün üst kısmına yerel değişkenler olarak yerleştirmek, JIT derleyicisine bu değerlerin sabit kaldığına dair bir ipucu da verir.

Gerçek değişmezlik için, değişiklik yapıldığında hata oluşturan __newindex metatablosuna sahip bir vekil tablo kullanabilirsiniz; bunu metatablolar dersinde ele alacağız.

local MAX_RETRIES = 3
local PI = 3.14159265358979
local APP_VERSION = "1.0.0"

-- Use them as read-only by convention
local area = PI * 5 * 5
print(area)           -- 78.539...
print(MAX_RETRIES)    -- 3

Değişken Gölgeleme

Gölgeleme, iç kapsam dış kapsamdaki bir değişkenle aynı ada sahip bir yerel değişken tanımladığında gerçekleşir. İçteki tanım, kendi kapsamında dıştaki değişkeni gizleyen tamamen yeni bir değişken oluşturur. Dıştaki değişken değişmez ve iç kapsam sona erdikten sonra yeniden görünür olur.

Gölgeleme kafa karıştırıcı olabilir; iç içe kapsamlarda benzersiz adlar kullanmayı tercih edin. Ancak bazen kasıtlıdır; örneğin iç içe döngülerde döngü değişkeni adlarını yeniden kullanmak gibi.

local x = "outer"
do
  local x = "inner"  -- shadows outer x
  print(x)            -- inner
end
print(x)              -- outer (unchanged)

local n = 10
for n = 1, 3 do       -- loop n shadows outer n
  print(n)            -- 1, 2, 3
end
print(n)              -- 10 (outer unchanged)

Genel Değişken Kirliliğini Önleme

Yanlışlıkla oluşturulan geneller, Lua'da sık görülen bir hatadır: yerel bir değişken adını yanlış yazmak sessizce yeni bir genel değişken oluşturur. Projelere genellikle dahil edilen strict.lua modülü, _G'ye bir metatablo ekleyerek bildirilmemiş genel değişken okumalarını ve yazmalarını yakalar.

Daha basit bir yaklaşım olarak her zaman local kullanın ve çalışma zamanından önce yanlışlıkla oluşturulan genelleri saptamak için luac -p veya luacheck gibi bir linter çalıştırın.

-- Dangerous: typo creates a global silently
local counter = 0
coutner = 5  -- typo! creates global 'coutner'
print(counter)  -- 0 (not 5!)
print(coutner)  -- 5 (the typo global)

-- Fix: always use local keyword
local score = 0
score = 10  -- assigns to existing local
print(score) -- 10

nil Ataması Genel Değişkenleri Siler

Bir geneli nil değerine ayarlamak, onu _G'den kaldırarak belleği serbest bırakır. Bir geneli "silmenin" doğru yolu budur. Yerel değişkenlerde ise kapsam dışına çıkmalarına izin vermek aynı etkiyi sağlar; çöp toplayıcı belleği geri kazanır.

Çoklu atamada nil aktarırken dikkatli olun: özellikle sağ tarafta işlev çağrıları bulunduğunda, bazı bağlamlarda bağımsız değişken listesini kısaltabilir.

myGlobal = "exists"
print(myGlobal)   -- exists
print(_G.myGlobal ~= nil)  -- true

myGlobal = nil
print(myGlobal)   -- nil
print(_G.myGlobal ~= nil)  -- false
-- The entry is removed from _G

Hızlı Kontrol

Bir for döngüsünün gövdesinde local x = 5 ile tanımlanan değişkenin kapsamı nedir?

Özet: Lua'da Değişken Tanımlama

Bu dersten çıkarılacak önemli noktalar:

  • Değişkenler varsayılan olarak geneldir — her zaman local kullanın
  • Yerel değişkenler daha hızlıdır (karma tablo araması yoktur) ve daha güvenlidir
  • Çoklu atama: a, b = b, a tek satırda yer değiştirmeyi sağlar
  • Tüm geneller _G'de bulunur; nil değerine ayarlamak onları siler
  • Gölgeleme: içteki local, dış değişkeni değiştirmeden gizler
  • Gelenek gereği sabitler için UPPER_CASE kullanın

Sıradaki konu: aritmetik, ilişkisel ve mantıksal işleçler.

Sıkça Sorulan Sorular

“Lua'da Değişken Tanımlama” dersi ücretsiz mi?

Evet — “Lua'da Değişken Tanımlama” 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 Lua Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Lua Academy kursu toplamda 4 dersten oluşur.

“Lua'da Değişken Tanımlama” dersinde ne öğreneceğim?

Genel ve yerel değişkenleri ve adlandırma kurallarını anlayın. Lua Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Lua Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Lua 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.

“Lua'da Değişken Tanımlama” 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.

Bu Lua Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Lua 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.

Bu kursun tüm dersleri

  1. Lua Veri Türlerine Genel Bakış
  2. Lua'da Değişken Tanımlama
  3. Aritmetik ve Karşılaştırma Operatörleri
  4. Tür Dönüştürme ve Çevirme
← Lua Academy Sayfasına Dön