Lua Academy · Pelajaran

Menggubah Fungsi

Rantaikan transformasi.

Pelajaran 4 daripada 413 langkah

Menggubah Fungsi ialah pelajaran Lua Academy percuma di CoddyKit. Ini ialah pelajaran 4 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 Komposisi?

Komposisi fungsi menggabungkan dua fungsi menjadi satu. Fungsi gubahan menghantar masukannya melalui fungsi pertama, kemudian menyerahkan hasil itu kepada fungsi kedua.

Dalam matematik, hal ini ditulis sebagai f(g(x)). Komposisi membolehkan Anda membina transformasi besar daripada fungsi kecil yang berfokus.

Menggubah Dua Fungsi

Pembantu compose menerima dua fungsi dan mengembalikan fungsi baharu. Memanggilnya menjalankan g dahulu, kemudian menghantar hasilnya kepada f.

Urutannya penting: fungsi dalaman dijalankan dahulu, manakala fungsi luaran dijalankan pada keluarannya.

local function compose(f, g)
  return function(x)
    return f(g(x))
  end
end

local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

local incThenDouble = compose(dbl, inc)
print(incThenDouble(3))

Urutan Itu Penting

Menukar kedudukan argumen mengubah hasilnya. compose(f, g) bermaksud gunakan g dahulu, kemudian f.

Contoh di bawah menunjukkan bahawa menggandakan kemudian menambah satu menghasilkan jawapan yang berbeza daripada menambah satu kemudian menggandakan.

local function compose(f, g) return function(x) return f(g(x)) end end
local function inc(n) return n + 1 end
local function dbl(n) return n * 2 end

print(compose(dbl, inc)(3))
print(compose(inc, dbl)(3))

Menggubah Fungsi Rentetan

Komposisi berfungsi dengan mana-mana fungsi satu argumen, termasuk transformasi rentetan. Rangkaikan pemangkasan, penukaran huruf besar-kecil atau pembalikan menjadi satu langkah yang boleh digunakan semula.

Di sini, pembalikan dijalankan dahulu, kemudian penukaran kepada huruf besar, lalu menghasilkan rentetan terbalik dalam huruf besar.

local function compose(f, g) return function(x) return f(g(x)) end end

local shout = compose(string.upper, string.reverse)
print(shout("lua"))

Menggubah Banyak Fungsi

Untuk merangkaikan lebih daripada dua fungsi, tulis composeAll yang menerima bilangan argumen berubah-ubah. Fungsi ini menggunakan fungsi dari kanan ke kiri, seperti panggilan bersarang.

Gelung itu melintasi senarai fungsi dari belakang sambil meneruskan nilai melalui setiap fungsi.

local function composeAll(...)
  local fns = {...}
  return function(x)
    for i = #fns, 1, -1 do
      x = fns[i](x)
    end
    return x
  end
end

local f = composeAll(function(n) return n + 1 end,
  function(n) return n * 2 end,
  function(n) return n - 3 end)
print(f(10))

Dari Kanan ke Kiri

Dalam composeAll(a, b, c), fungsi paling kanan c dijalankan dahulu, kemudian b, lalu a. Ini sepadan dengan bentuk bersarang a(b(c(x))).

Membaca urutan ini boleh menjadi rumit, sebab itu sesetengah orang lebih suka paip dari kiri ke kanan.

Paip dari Kiri ke Kanan

pipe membalikkan urutan bacaan: fungsi dijalankan dari kiri ke kanan, mengikut urutan penulisannya. Ramai mendapati cara ini lebih mudah diikuti untuk saluran paip data.

Gelung itu bergerak ke hadapan dan menggunakan setiap fungsi pada nilai semasa.

local function pipe(...)
  local fns = {...}
  return function(x)
    for i = 1, #fns do
      x = fns[i](x)
    end
    return x
  end
end

local process = pipe(function(n) return n + 1 end,
  function(n) return n * 2 end)
print(process(5))

Paip untuk Kebolehbacaan

Dengan pipe, langkah-langkah dibaca dari atas ke bawah mengikut urutan pelaksanaan. Hal ini menjadikan transformasi berbilang peringkat mudah difahami tanpa dokumentasi tambahan.

Di sini, awalan daripada rentetan dipangkas, rentetan itu ditukar kepada huruf kecil, kemudian diterbalikkan; setiap langkah disenaraikan mengikut urutan pelaksanaannya.

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end

local transform = pipe(string.lower, string.reverse,
  function(s) return "[" .. s .. "]" end)
print(transform("LUA"))

Komposisi dengan Penutupan

Anda boleh menggubah fungsi yang dibina melalui penggunaan separa atau penutupan. Bina fungsi kecil yang khusus, kemudian gabungkan semuanya.

Ini memastikan setiap bahagian boleh diuji, manakala komposisi menyatakan aliran keseluruhan.

local function pipe(...) local fns={...} return function(x) for i=1,#fns do x=fns[i](x) end return x end end
local function adder(n) return function(x) return x + n end end
local function muller(n) return function(x) return x * n end end

local calc = pipe(adder(3), muller(10))
print(calc(2))

Komposisi dan Saluran Paip

Komposisi ialah penghubung di sebalik saluran paip data. Daripada menyarang panggilan secara mendalam, Anda menamakan fungsi gubahan sekali dan menggunakannya pada banyak masukan.

Kaedah ini berfungsi dengan sangat baik bersama pemetaan: hantarkan fungsi gubahan sebagai transformasi bagi setiap unsur.

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function compose(f, g) return function(x) return f(g(x)) end end

local step = compose(function(n) return n + 1 end, function(n) return n * n end)
local r = map({1, 2, 3, 4}, step)
print(table.concat(r, ", "))

Kekalkan Fungsi Kecil

Komposisi menggalakkan fungsi kecil yang mempunyai satu tujuan. Setiap fungsi melakukan satu tugas, dan Anda menggabungkannya untuk membentuk tingkah laku yang kompleks tanpa menulis semula logik.

Inilah teras reka bentuk fungsian: bina kosa kata yang terdiri daripada fungsi kecil, kemudian gubahkannya untuk menyatakan idea yang lebih besar.

Semakan Pantas

Jejaki urutan dengan teliti sebelum menjawab.

Jawab dalam pelajaran interaktif

Imbas Kembali

Komposisi menggabungkan fungsi supaya keluaran satu fungsi menjadi masukan kepada fungsi seterusnya. compose(f, g) menjalankan g kemudian f, dari kanan ke kiri, manakala pipe berjalan dari kiri ke kanan demi kebolehbacaan.

Dengan composeAll dan pipe, Anda boleh merangkaikan banyak fungsi kecil menjadi saluran paip yang jelas, khususnya apabila digabungkan dengan pemetaan.

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 “Menggubah Fungsi” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Lua Academy, termasuk “Menggubah Fungsi”, 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 “Menggubah Fungsi”?

Rantaikan transformasi. 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 4 daripada 4.

Berapa lamakah pelajaran “Menggubah Fungsi” 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