Lua Academy · Pelajaran

Mengisytiharkan Pemboleh Ubah dalam Lua

Fahami pemboleh ubah global berbanding tempatan serta konvensyen penamaan.

Pelajaran 2 daripada 412 langkah

Mengisytiharkan Pemboleh Ubah dalam Lua ialah pelajaran Lua Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Lua Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Lua Academy merangkumi sejumlah 4 pelajaran.

Pemboleh Ubah Global berbanding Setempat

Dalam Lua, pemboleh ubah adalah global secara lalai. Menulis x = 10 tanpa kata kunci local akan mencipta pemboleh ubah global yang boleh dicapai dari mana-mana sahaja. Menggunakan local x = 10 mengehadkan pemboleh ubah kepada blok semasa dan blok bersarang di dalamnya.

Sentiasa utamakan local demi prestasi dan keselamatan. Mengakses pemboleh ubah setempat lebih pantas daripada mengakses pemboleh ubah global kerana global memerlukan carian jadual cincangan dalam jadual _G.

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)

Kata Kunci local

Kata kunci local mengisytiharkan pemboleh ubah yang mempunyai skop pada blok terdekat yang mengandunginya: badan fungsi, blok do...end, badan gelung atau cebisan fail. Pemboleh ubah setempat dicipta pada baris pengisytiharannya dan tidak lagi wujud apabila bloknya berakhir.

Anda boleh mengisytiharkan beberapa pemboleh ubah setempat pada satu baris dan memulakannya serentak. Pemboleh ubah setempat yang tidak dimulakan secara lalai mengandungi nil.

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

Konvensyen Penamaan Pemboleh Ubah

Pengecam Lua mengikut peraturan ini: pengecam mesti bermula dengan huruf atau garis bawah, diikuti huruf, digit atau garis bawah. Lua peka huruf besar-kecil, jadi Value, value dan VALUE ialah tiga pemboleh ubah yang berbeza.

Mengikut convention: gunakan camelCase atau snake_case untuk pemboleh ubah biasa, UPPER_CASE untuk pemalar dan awali medan modul peribadi dengan garis bawah. Elakkan nama satu huruf kecuali untuk pembilang gelung.

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

Jadual Global _G

Semua pemboleh ubah global dalam Lua berada dalam jadual khas yang dipanggil _G. Menulis x = 10 adalah setara dengan _G.x = 10. Anda boleh memeriksa semua global dengan melakukan lelaran terhadap _G, yang berguna untuk penyahpepijatan tetapi berbahaya dalam kod produksi.

Dalam Lua 5.2+, _ENV ialah jadual persekitaran sebenar dan _G dimulakan untuk menunjuk kepadanya. Memahami perkara ini membolehkan anda mengkotak pasirkan kod dengan menggantikan _ENV.

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)

Penugasan Berbilang

Lua menyokong penugasan berbilang: anda boleh memberikan nilai kepada beberapa pemboleh ubah dalam satu penyata. Bahagian kanan dinilai terlebih dahulu, kemudian diberikan dari kiri ke kanan. Jika terdapat lebih banyak pemboleh ubah daripada nilai, lebihan pemboleh ubah menerima nil. Jika terdapat lebih banyak nilai daripada pemboleh ubah, lebihan nilai dibuang.

Hal ini menjadikan pertukaran pemboleh ubah mudah tanpa pemboleh ubah sementara.

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

Skop dan Sempadan Blok

Pembatas blok Lua ialah: do...end, badan fungsi, if/elseif/else...end, while...end, repeat...until dan for...end. Setiap satunya mencipta aras skop baharu. Blok do...end berguna semata-mata untuk mengehadkan skop tanpa logik lain.

Pemboleh ubah setempat yang diisytiharkan dalam pengepala gelung for mempunyai skop pada badan gelung — pemboleh ubah itu tidak terkeluar ke luar gelung.

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

Pemalar: convention local

Lua tidak mempunyai kata kunci terbina dalam const. convention adalah menggunakan nama UPPER_CASE dan local untuk menandakan bahawa sesuatu nilai tidak sepatutnya berubah. Meletakkan pemalar sebagai pemboleh ubah setempat di bahagian atas modul juga memberikan petunjuk kepada pengompil JIT bahawa nilai-nilai ini stabil.

Untuk ketidakbolehubahan sebenar, anda boleh menggunakan jadual proksi dengan __newindex yang mencetuskan ralat apabila diubah suai — kita akan membincangkan perkara ini dalam pelajaran jadual meta.

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

Pembayangan Pemboleh Ubah

Pembayangan berlaku apabila skop dalaman mengisytiharkan pemboleh ubah setempat dengan nama yang sama seperti pemboleh ubah luar. Pengisytiharan dalaman mencipta pemboleh ubah baharu sepenuhnya yang menyembunyikan pemboleh ubah luar dalam skopnya. Pemboleh ubah luar tidak berubah dan kelihatan semula selepas skop dalaman berakhir.

Pembayangan boleh mengelirukan; utamakan nama yang unik merentasi skop bersarang, tetapi kadangkala perkara ini disengajakan (contohnya, menggunakan semula nama pemboleh ubah gelung dalam gelung bersarang).

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)

Mengelakkan Pencemaran Global

Global tidak sengaja ialah pepijat Lua yang biasa: tersalah taip nama pemboleh ubah setempat akan mencipta global baharu secara senyap. Modul strict.lua (yang lazimnya disertakan dalam projek) mengesan bacaan dan penulisan global yang tidak diisytiharkan dengan menambahkan jadual meta pada _G.

Pendekatan yang lebih mudah: sentiasa gunakan local dan jalankan luac -p atau pemeriksa kod seperti luacheck untuk mengesan global yang tercipta secara tidak sengaja sebelum masa jalan.

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

Penugasan Nil Memadamkan Global

Menetapkan global kepada nil akan membuangnya daripada _G, sekali gus membebaskan memori. Inilah cara yang betul untuk "memadamkan" global. Bagi pemboleh ubah setempat, membiarkannya keluar daripada skop akan mencapai kesan yang sama — pemungut sampah akan mendapatkan semula memori tersebut.

Berhati-hati apabila menghantar nil dalam penugasan berbilang: hal ini boleh memendekkan senarai argumen dalam sesetengah konteks, khususnya apabila terdapat panggilan fungsi di sebelah kanan.

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

Semakan Pantas

Apakah skop pemboleh ubah yang diisytiharkan dengan local x = 5 di dalam badan gelung for?

Jawab dalam pelajaran interaktif

Ulang Kaji: Mengisytiharkan Pemboleh Ubah dalam Lua

Perkara penting daripada pelajaran ini:

Pemboleh ubah adalah global secara lalai — sentiasa gunakan local
Pemboleh ubah setempat lebih pantas (tiada carian cincangan) dan lebih selamat
Penugasan berbilang: a, b = b, a menukar nilai dalam satu baris
Semua global berada dalam _G; menetapkannya kepada nil akan memadamkannya
Pembayangan: local dalaman menyembunyikan pemboleh ubah luar tanpa mengubahnya
Gunakan UPPER_CASE untuk pemalar mengikut convention

Seterusnya: operator aritmetik, hubungan dan logik.

Percuma untuk bermula

Pelajari Lua dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 40
Pelajaran: 159

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengisytiharkan Pemboleh Ubah dalam Lua” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Lua Academy, termasuk “Mengisytiharkan Pemboleh Ubah dalam Lua”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Lua Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengisytiharkan Pemboleh Ubah dalam Lua”?

Fahami pemboleh ubah global berbanding tempatan serta konvensyen penamaan. Anda berlatih Lua Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Lua Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Lua Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Mengisytiharkan Pemboleh Ubah dalam Lua” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Lua Academy