Aplikasi Separa
Isi awal argumen fungsi.
Aplikasi Separa ialah pelajaran Lua Academy percuma di CoddyKit. Ini ialah pelajaran 3 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.
Apakah Penggunaan Separa?
Penggunaan separa bermaksud menetapkan beberapa argumen fungsi sekarang dan membekalkan selebihnya kemudian. Anda akan mendapat fungsi baharu yang memerlukan lebih sedikit argumen.
Dengan cara ini, anda boleh menukar fungsi umum menjadi fungsi khusus dengan mengunci nilai yang sudah anda ketahui.
Contoh Manual
Andaikan anda mempunyai fungsi add. Anda boleh membina addFive dengan menulis penutupan yang menangkap 5 dan menunggu nombor kedua.
Nilai yang ditangkap kekal dalam fungsi yang dikembalikan, jadi setiap panggilan hanya memerlukan argumen yang selebihnya.
local function add(a, b)
return a + b
end
local function addFive(b)
return add(5, b)
end
print(addFive(10))
print(addFive(2))Mengikat Argumen Pertama
Kita boleh mengumumkan pola ini. Pembantu bind1 menerima fungsi dan argumen pertama yang tetap, lalu mengembalikan fungsi baharu yang menjangkakan argumen kedua.
Penutupan itu menangkap kedua-dua f dan nilai yang dikunci, kemudian meneruskan semuanya apabila dipanggil.
local function bind1(f, a)
return function(b)
return f(a, b)
end
end
local function mul(x, y) return x * y end
local double = bind1(mul, 2)
print(double(7))
print(double(50))Menggunakan Argumen Pelbagai
Untuk menetapkan sebarang bilangan argumen awal, gunakan sintaks argumen pelbagai Lua .... Tangkap argumen tetap, kemudian tambahkan argumen yang diberikan kemudian pada masa panggilan.
Fungsi table.pack dan table.unpack membantu menyimpan dan mengembangkan senarai argumen.
local function partial(f, ...)
local fixed = table.pack(...)
return function(...)
local rest = table.pack(...)
local args = {}
for i = 1, fixed.n do args[i] = fixed[i] end
for i = 1, rest.n do args[fixed.n + i] = rest[i] end
return f(table.unpack(args, 1, fixed.n + rest.n))
end
end
local function add3(a, b, c) return a + b + c end
local add10 = partial(add3, 10)
print(add10(2, 3))Menetapkan Beberapa Argumen
Oleh sebab partial menerima bilangan argumen yang berubah-ubah, Anda boleh menetapkan lebih daripada satu argumen pada satu masa. Fungsi yang dikembalikan kemudiannya hanya memerlukan argumen yang selebihnya.
Di sini, dua daripada tiga argumen diisi terlebih dahulu, lalu terhasil fungsi yang menerima satu argumen sahaja.
local function partial(f, ...)
local fixed = table.pack(...)
return function(...)
local rest = table.pack(...)
local args = {}
for i = 1, fixed.n do args[i] = fixed[i] end
for i = 1, rest.n do args[fixed.n + i] = rest[i] end
return f(table.unpack(args, 1, fixed.n + rest.n))
end
end
local function label(prefix, sep, value) return prefix .. sep .. value end
local tag = partial(label, "id", ":")
print(tag(42))Kegunaan Praktikal
Penggunaan separa sangat berguna dengan fungsi utiliti umum. Tetapkan konfigurasi sekali, kemudian gunakan semula fungsi khusus itu berkali-kali.
Di bawah, greet yang umum menjadi penyapa dengan bahasa tetap yang hanya memerlukan nama.
local function greet(lang, name)
if lang == "tr" then return "Merhaba, " .. name end
return "Hello, " .. name
end
local function bind1(f, a) return function(b) return f(a, b) end end
local greetTr = bind1(greet, "tr")
print(greetTr("Ada"))
print(greetTr("Lin"))Penggunaan Separa vs Pengkurian
Pengkurian menukar fungsi berbilang argumen menjadi rangkaian fungsi satu argumen, setiap satunya mengembalikan fungsi seterusnya. Penggunaan separa hanya menetapkan beberapa argumen dan mengekalkan argumen yang lain sebagai panggilan biasa.
Kedua-duanya berkaitan tetapi berbeza: pengkurian menetapkan satu demi satu, manakala penggunaan separa menetapkan sebahagian terlebih dahulu.
local function curryAdd(a)
return function(b)
return function(c)
return a + b + c
end
end
end
print(curryAdd(1)(2)(3))Mengkurikan Fungsi Dua Argumen
Pembantu kecil boleh mengkurikan mana-mana fungsi dua argumen secara automatik. Pembantu itu mengembalikan fungsi bagi argumen pertama, yang kemudiannya mengembalikan fungsi bagi argumen kedua.
Hasilnya ialah pembina boleh guna semula yang menerima satu argumen dan mudah dibaca dalam saluran paip.
local function curry2(f)
return function(a)
return function(b)
return f(a, b)
end
end
end
local function pow(base, exp) return base ^ exp end
local cpow = curry2(pow)
print(cpow(2)(10))Penutupan Menjadikannya Berfungsi
Setiap fungsi yang menggunakan penggunaan separa atau pengkurian bergantung pada penutupan. Argumen yang ditetapkan ialah pemboleh ubah setempat yang ditangkap dan diingati oleh fungsi yang dikembalikan.
Oleh sebab setiap fungsi yang dikembalikan mempunyai nilai tangkapannya sendiri, Anda boleh mencipta banyak varian khusus dengan selamat.
local function bind1(f, a) return function(b) return f(a, b) end end
local function sub(x, y) return x - y end
local from100 = bind1(sub, 100)
local from10 = bind1(sub, 10)
print(from100(40))
print(from10(3))Bila Perlu Menggunakannya
Gunakan penggunaan separa untuk mengurangkan pengulangan apabila Anda memanggil fungsi dengan argumen awal yang sama berulang kali.
Penggunaan ini juga membantu menyesuaikan fungsi dengan antara muka yang menjangkakan lebih sedikit argumen, seperti panggilan balik yang hanya menghantar satu nilai.
Panggilan Balik Berkonfigurasi
Penggunaan separa sesuai digabungkan dengan pemetaan dan penapisan. Anda boleh mengisi argumen konfigurasi terlebih dahulu supaya panggilan balik hanya menerima unsur senarai.
Ini memastikan saluran paip Anda kekal kemas sambil membolehkan Anda melaras tingkah lakunya.
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function bind1(f, a) return function(b) return f(a, b) end end
local function scale(factor, x) return factor * x end
local r = map({1,2,3,4}, bind1(scale, 10))
print(table.concat(r, ", "))Semakan Pantas
Ingat kembali perbezaan antara dua konsep yang berkaitan.
Imbas Kembali
Penggunaan separa menetapkan beberapa argumen dan mengembalikan fungsi baharu yang menjangkakan argumen yang selebihnya, dengan menggunakan penutupan yang menangkap nilai yang telah ditetapkan.
Pembantu partial berasaskan bilangan argumen yang berubah-ubah mengumumkan pendekatan ini, manakala pengkurian merangkaikan fungsi satu argumen. Kedua-duanya mengurangkan pengulangan dan menyesuaikan fungsi dengan panggilan balik.
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
Soalan Lazim
Adakah pelajaran “Aplikasi Separa” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Lua Academy, termasuk “Aplikasi Separa”, 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 “Aplikasi Separa”?
Isi awal argumen fungsi. 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 3 daripada 4.
Berapa lamakah pelajaran “Aplikasi Separa” 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
- Fungsi sebagai Nilai
- map, filter, reduce
- Aplikasi Separa
- Menggubah Fungsi