Lua Academy · Pelajaran

Menyusun Fungsi

Rangkai transformasi.

Menyusun Fungsi adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Lua Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Lua Academy mencakup 4 pelajaran total.

Apa Itu Komposisi?

Komposisi fungsi menggabungkan dua fungsi menjadi satu. Fungsi hasil komposisi meneruskan masukannya melalui fungsi pertama, lalu meneruskan hasil tersebut ke fungsi kedua.

Dalam matematika, hal ini ditulis sebagai f(g(x)). Komposisi memungkinkan Anda membangun transformasi besar dari fungsi-fungsi kecil yang berfokus pada satu tugas.

Mengomposisikan Dua Fungsi

Pembantu compose menerima dua fungsi dan mengembalikan fungsi baru. Saat dipanggil, pembantu ini menjalankan g terlebih dahulu, lalu meneruskan hasilnya ke f.

Urutannya penting: fungsi bagian dalam berjalan lebih dahulu, sedangkan fungsi bagian luar berjalan 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 argumen akan mengubah hasilnya. compose(f, g) berarti menerapkan g terlebih dahulu, lalu f.

Contoh di bawah menunjukkan bahwa menggandakan lalu menambahkan satu menghasilkan jawaban yang berbeda dari menambahkan satu lalu 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))

Mengomposisikan Fungsi String

Komposisi dapat digunakan dengan fungsi apa pun yang memiliki satu argumen, termasuk transformasi string. Anda dapat merangkai pemangkasan, perubahan huruf besar-kecil, atau pembalikan menjadi satu langkah yang dapat digunakan kembali.

Di sini, pembalikan dijalankan terlebih dahulu, lalu perubahan ke huruf besar, sehingga menghasilkan string terbalik dengan 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"))

Mengomposisikan Banyak Fungsi

Untuk merangkai lebih dari dua fungsi, tulislah composeAll variadik. Fungsi ini menerapkan fungsi-fungsi tersebut dari kanan ke kiri, seperti pemanggilan bersarang.

Perulangan berjalan mundur melalui daftar fungsi dan 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 berjalan lebih dahulu, kemudian b, lalu a. Urutan ini sesuai dengan bentuk bersarang a(b(c(x))).

Urutannya bisa sulit dibaca, sehingga sebagian orang lebih menyukai alur dari kiri ke kanan.

Alur dari Kiri ke Kanan

pipe membalik urutan pembacaan: fungsi berjalan dari kiri ke kanan, sesuai urutan penulisannya. Banyak orang menganggapnya lebih mudah diikuti untuk alur data.

Perulangan berjalan maju dan menerapkan setiap fungsi pada nilai yang sedang diproses.

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

Alur untuk Keterbacaan

Dengan pipe, langkah-langkah terbaca dari atas ke bawah sesuai urutan pelaksanaannya. Hal ini membuat transformasi bertahap dapat menjelaskan dirinya sendiri.

Di sini, sebuah string dipangkas untuk menghapus awalan, diubah menjadi huruf kecil, lalu dibalik; setiap langkah dicantumkan sesuai 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 dapat mengomposisikan fungsi yang dibuat melalui aplikasi parsial atau penutupan. Buat fungsi-fungsi kecil yang khusus, lalu gabungkan semuanya.

Dengan demikian, setiap bagian dapat diuji, sementara komposisinya menyatakan alur 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 Alur Data

Komposisi merupakan perekat di balik alur data. Alih-alih membuat pemanggilan yang sangat bersarang, Anda menamai fungsi hasil komposisi sekali lalu menerapkannya pada banyak masukan.

Cara ini bekerja sangat baik dengan pemetaan: teruskan fungsi hasil komposisi sebagai transformasi untuk setiap elemen.

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, ", "))

Pertahankan Fungsi Tetap Kecil

Komposisi menghargai fungsi-fungsi kecil dengan satu tujuan. Masing-masing melakukan satu tugas, lalu Anda menggabungkannya untuk membentuk perilaku yang kompleks tanpa menulis ulang logika.

Inilah inti rancangan fungsional: bangun kosakata dari fungsi-fungsi kecil, lalu komposisikan semuanya untuk menyatakan gagasan yang lebih besar.

Pemeriksaan Singkat

Telusuri urutannya dengan cermat sebelum menjawab.

Ringkasan

Komposisi menggabungkan fungsi sehingga keluaran salah satunya menjadi masukan bagi fungsi berikutnya. Komposisi dua fungsi menjalankan g lalu f, dari kanan ke kiri, sedangkan alur menjalankan fungsi dari kiri ke kanan agar mudah dibaca.

Dengan composeAll dan pipe, Anda dapat merangkai banyak fungsi kecil menjadi alur data yang jelas, terutama jika dipasangkan dengan pemetaan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menyusun Fungsi” gratis?

Ya — teks lengkap “Menyusun Fungsi” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Lua Academy, upgrade ke CoddyKit PRO. Kursus Lua Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menyusun Fungsi”?

Rangkai transformasi. Kamu berlatih Lua Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Lua Academy?

Tidak diperlukan pengalaman sebelumnya. Lua Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Menyusun Fungsi” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Lua Academy