{"id":477316,"date":"2023-08-09T09:11:08","date_gmt":"2023-08-09T09:11:08","guid":{"rendered":""},"modified":"2023-09-05T11:14:30","modified_gmt":"2023-09-05T11:14:30","slug":"functional-programming","status":"publish","type":"wiki","link":"https:\/\/oneproxy.pro\/my\/wiki\/functional-programming\/","title":{"rendered":"Pengaturcaraan berfungsi"},"content":{"rendered":"

Pengaturcaraan fungsional (FP) ialah paradigma pengaturcaraan yang berpusat di sekitar penggunaan fungsi tulen, data tidak berubah, dan mengelakkan keadaan atau kesan sampingan yang dikongsi. FP berasaskan prinsip logik matematik, menghasilkan pendekatan berkaedah dan boleh diramal kepada pengaturcaraan yang boleh meningkatkan kejelasan kod, kebolehselenggaraan dan kebolehujian.<\/p>\n

Asal-usul dan Perkembangan Awal Pengaturcaraan Fungsian<\/h2>\n

Asal usul pengaturcaraan berfungsi kembali ke tahun 1930-an dan kerja Gereja Alonzo pada kalkulus lambda, sistem formal dalam logik matematik untuk menyatakan pengiraan. Walau bagaimanapun, pengaturcaraan berfungsi tidak benar-benar mendapat tempat dalam pengkomputeran sehingga tahun 1950-an dan 1960-an dengan pembangunan LISP, bahasa pengaturcaraan berfungsi pertama.<\/p>\n

LISP, singkatan untuk "LISt Processing", telah direka oleh John McCarthy di MIT untuk penyelidikan kecerdasan buatan. Bahasa ini memperkenalkan banyak konsep asas kepada pengaturcaraan berfungsi, seperti fungsi kelas pertama dan peringkat tinggi, rekursi, dan manipulasi simbol dan bukannya data berangka.<\/p>\n

Tahun 1970-an menyaksikan kemunculan bahasa pengaturcaraan berfungsi yang lebih berdedikasi, seperti ML dan Skim, dan tahun 1980-an membawa Miranda dan Haskell, yang terakhir ini sering dianggap sebagai bahasa pengaturcaraan fungsian yang utama.<\/p>\n

Memperluas Topik: Pengaturcaraan Fungsian<\/h2>\n

Pengaturcaraan fungsional dicirikan oleh tumpuannya pada fungsi dan kebolehubahan data. Dalam FP, fungsi dianggap sebagai warga kelas pertama, bermakna ia boleh dihantar sebagai argumen kepada fungsi lain, dikembalikan sebagai nilai dan disimpan dalam struktur data. Fungsi biasanya "tulen", bermakna ia tidak mempunyai kesan sampingan dan outputnya ditentukan semata-mata oleh inputnya.<\/p>\n

Penggunaan data tidak berubah adalah satu lagi tonggak pengaturcaraan berfungsi. Setelah data dibuat, ia tidak boleh diubah. Sebaliknya, sebarang transformasi menghasilkan data baharu. Pendekatan ini menyumbang kepada kebolehramalan dan kebolehpercayaan perisian.<\/p>\n

Bahasa pengaturcaraan berfungsi juga sangat bergantung pada rekursi sebagai struktur kawalan asas, disebabkan ketiadaan struktur kawalan imperatif biasa seperti gelung. Banyak bahasa berfungsi menggunakan penilaian malas, di mana ungkapan tidak dinilai sehingga keputusannya diperlukan, membolehkan ekspresi cekap struktur dan pengiraan data yang berpotensi tidak terhingga.<\/p>\n

Struktur Dalaman Pengaturcaraan Fungsian<\/h2>\n

Pengaturcaraan fungsional pada asasnya berbeza daripada paradigma arus perdana yang lain, seperti pengaturcaraan prosedural dan berorientasikan objek.<\/p>\n

Daripada menukar keadaan dan data boleh ubah, FP bertujuan untuk mengekalkan ketekalan dan kebolehramalan program dengan menggunakan fungsi tulen dan mengelakkan keadaan dikongsi. Fungsi tulen sentiasa menghasilkan hasil yang sama untuk input yang sama dan tidak menghasilkan sebarang kesan sampingan, iaitu perubahan dalam keadaan yang tidak berkaitan dengan nilai pulangan fungsi.<\/p>\n

FP juga sering menggunakan rekursi untuk aliran kawalan. Rekursi ialah proses fungsi yang memanggil dirinya sebagai subrutin. Ini boleh menjadi alat yang berkuasa untuk menyelesaikan masalah yang melibatkan struktur data yang kompleks atau memerlukan pengiraan berulang.<\/p>\n

Inti pengaturcaraan berfungsi ialah komposisi - membina fungsi kompleks dengan menggabungkan fungsi yang lebih mudah. Ini membawa kepada kod yang modular dan mudah untuk diuji, difahami dan nyahpepijat.<\/p>\n

Ciri-ciri Utama Pengaturcaraan Fungsian<\/h2>\n

Berikut ialah ciri utama pengaturcaraan berfungsi:<\/p>\n

    \n
  1. \n

    Fungsi Tulen<\/strong>: Fungsi dianggap tulen jika nilai pulangannya adalah sama untuk hujah yang sama dan ia tidak menghasilkan kesan sampingan.<\/p>\n<\/li>\n

  2. \n

    Data Tidak Boleh Berubah<\/strong>: Setelah struktur data dicipta dalam bahasa berfungsi, ia tidak boleh diubah.<\/p>\n<\/li>\n

  3. \n

    Fungsi kelas pertama dan lebih tinggi<\/strong>: Fungsi dalam FP boleh digunakan seperti mana-mana pembolehubah lain. Ia boleh ditakrifkan dalam mana-mana skop, diluluskan sebagai hujah, dan dikembalikan daripada fungsi lain.<\/p>\n<\/li>\n

  4. \n

    Rekursi<\/strong>: Penggunaan rekursi sebagai struktur kawalan utama untuk pengulangan.<\/p>\n<\/li>\n

  5. \n

    Ketelusan Rujukan<\/strong>: Ungkapan dikatakan telus secara rujukan jika ia boleh digantikan dengan nilainya tanpa mengubah tingkah laku program.<\/p>\n<\/li>\n

  6. \n

    Penilaian yang malas<\/strong>: Menilai ungkapan hanya apabila nilainya diperlukan untuk program diteruskan.<\/p>\n<\/li>\n<\/ol>\n

    Jenis Pengaturcaraan Fungsian<\/h2>\n

    Walaupun semua bahasa pengaturcaraan berfungsi mematuhi prinsip teras yang digariskan di atas, mereka sering berbeza dalam tahap ketegasan dan ciri yang mereka tawarkan. Berikut adalah tiga kategori untuk dipertimbangkan:<\/p>\n

      \n
    1. \n

      Bahasa Fungsian Tulen<\/strong>: Bahasa-bahasa ini mematuhi prinsip pengaturcaraan berfungsi dengan ketat dan tidak membenarkan sebarang bentuk keadaan boleh ubah atau kesan sampingan. Contohnya termasuk Haskell dan Elm.<\/p>\n<\/li>\n

    2. \n

      Bahasa Fungsian Tidak Tulen<\/strong>: Bahasa ini berfungsi terutamanya, tetapi ia membenarkan beberapa tahap kesan sampingan dan keadaan boleh ubah. Contohnya termasuk Lisp dan Skim.<\/p>\n<\/li>\n

    3. \n

      Bahasa Pelbagai paradigma dengan Elemen Fungsian<\/strong>: Banyak bahasa moden adalah pelbagai paradigma, bermakna ia membenarkan pengaturcaraan dalam beberapa gaya. Bahasa-bahasa ini selalunya menggabungkan unsur-unsur pengaturcaraan berfungsi. Contohnya termasuk JavaScript, Python, Ruby dan Scala.<\/p>\n<\/li>\n<\/ol>\n\n\n\n\n\n\n\n
      kategori<\/th>\nBahasa<\/th>\n<\/tr>\n<\/thead>\n
      Berfungsi Tulen<\/td>\nHaskell, Elm<\/td>\n<\/tr>\n
      Berfungsi Najis<\/td>\nLisp, Skim<\/td>\n<\/tr>\n
      Pelbagai paradigma dengan Elemen Fungsian<\/td>\nJavaScript, Python, Ruby, Scala<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

      Penggunaan Pengaturcaraan Fungsian dan Masalah dan Penyelesaian Berkaitan<\/h2>\n

      Pengaturcaraan fungsional boleh digunakan dalam pelbagai konteks, daripada pembangunan web bahagian hadapan (cth, menggunakan perpustakaan JavaScript seperti React dan Redux) kepada pembangunan sisi pelayan (cth, menggunakan Scala atau Elixir) kepada pemprosesan dan analisis data (cth, menggunakan Apache Spark atau Panda dengan Python).<\/p>\n

      Walaupun pengaturcaraan berfungsi membawa banyak faedah, ia juga datang dengan cabarannya sendiri. Beberapa cabaran biasa termasuk:<\/p>\n