GRASP dalam pengaturcaraan berfungsi Javascript

Dalam dunia pembangunan perisian, corak reka bentuk berfungsi sebagai penyelesaian yang diuji masa untuk masalah biasa.
Salah satu set corak reka bentuk yang kurang dibincangkan tetapi sama pentingnya ialah GRASP (Corak Perisian Tugasan Tanggungjawab Am). Prinsip GRASP sering dikaitkan dengan prinsip SOLID dan corak reka bentuk OOP yang lain.
GRASP, atau Corak Perisian Tugasan Tanggungjawab Am, ialah koleksi garis panduan yang bertujuan untuk memberikan tanggungjawab kepada kelas dan objek dalam reka bentuk berorientasikan objek. Bagaimanakah kami boleh menggunakan corak ini dalam pembangunan Javascript (Node.js) kami? Sudah tentu, Javascript menyokong kelas, yang dibina secara asli pada prototaip, di mana kita boleh menggunakan GRASP dengan cara yang sama seperti yang kita lakukan di Java.
Walau bagaimanapun, pada pendapat saya, corak GRASP juga boleh digunakan untuk pengaturcaraan berfungsi.

Apa itu GRASP?

Sembilan corak GRASP ialah:

1. Pakar Maklumat
2. Pencipta
3. Pengawal
4. Gandingan Rendah
5. Kepaduan Tinggi
6. Polimorfisme
7. Fabrikasi Tulen
8. Larangan
9. Variasi Dilindungi

Pakar Maklumat

Tugaskan tanggungjawab kepada fungsi yang mempunyai data atau pengetahuan yang diperlukan untuk melaksanakan tugas. Dalam pengaturcaraan berfungsi, prinsip ini boleh digunakan dengan memberikan tanggungjawab kepada fungsi atau modul yang mempunyai data atau konteks yang diperlukan untuk melaksanakan tugas.

// User management module
const createUser = (name, email) => ({ name, email });

const getUserEmail = (user) => user.email;

const updateUserEmail = (user, newEmail) => ({
  ...user,
  email: newEmail,
});

const user = createUser('John Doe', 'john@example.com');
console.log(getUserEmail(user));  // 'john@example.com'

const updatedUser = updateUserEmail(user, 'john.doe@example.com');
console.log(getUserEmail(updatedUser));  // 'john.doe@example.com'

Pencipta

Gunakan fungsi kilang untuk mencipta struktur atau objek data yang kompleks. Dalam pengaturcaraan berfungsi, walaupun kami tidak berurusan dengan kelas dengan cara yang sama seperti dalam pengaturcaraan berorientasikan objek, kami boleh menggunakan prinsip Pencipta dengan memberikan tanggungjawab untuk mencipta struktur data atau memulakan objek kepada fungsi atau modul yang mempunyai maklumat yang diperlukan dan konteks.

const createUser = (name, email) => ({ name, email });

Pengawal

Gunakan fungsi tertib lebih tinggi untuk mengendalikan acara sistem dan mewakilkan tugas. Dalam pengaturcaraan berfungsi, pengawal sering mengambil bentuk fungsi yang mengatur aliran data dan tindakan antara bahagian sistem yang berlainan, memastikan tanggungjawab dipisahkan dengan jelas.

// Example of express.js controller
const handleRequest = (req, res, userService) => {
  const user = userService.createUser(req.body.name, req.body.email);
  res.send(user);
};

Gandingan Rendah

Pastikan fungsi adalah bebas dan hanya bergantung pada input eksplisit. Dalam pengaturcaraan berfungsi, gandingan rendah dicapai dengan mereka bentuk fungsi dan modul yang beroperasi secara berasingan antara satu sama lain, dengan pergantungan minimum pada butiran dalaman fungsi atau modul lain

const sendEmail = (emailService, email) => emailService.send(email);

Kesepaduan Tinggi

Kepaduan Tinggi merujuk kepada sejauh mana unsur-unsur dalam modul atau fungsi kepunyaan bersama. Dalam pengaturcaraan berfungsi, mencapai perpaduan yang tinggi bermakna mereka bentuk fungsi dan modul supaya mereka melaksanakan satu tugasan yang jelas atau set tugasan yang berkait rapat.

const createUser = (name, email) => ({ name, email });
const addUser = (users, user) => [...users, user];

const createAndAddUser = (users, name, email)=>{
  const user = createUser(name, email);
  return addUser(users, user)
}
// usage
const users = [
  { name: 'Alice', email: 'alice@example.com' },
  { name: 'Bob', email: 'bob@example.com' },
];

const newUsers = createAndAddUser(users, 'Charlie', 'charlie@example.com');

Polimorfisme

Gunakan fungsi tertib tinggi dan fungsi kelas pertama untuk mencapai polimorfisme. Dalam pengaturcaraan berfungsi, polimorfisme biasanya dicapai melalui fungsi tertib tinggi, fungsi generik dan sistem jenis seperti Typescript

const processPayment = (paymentMethod) => paymentMethod.process();

Fabrikasi Tulen

Buat fungsi utiliti yang tidak sepadan secara langsung dengan konsep domain tetapi menyediakan kefungsian yang diperlukan, apabila tiada fungsi atau kelas domain yang sesuai wujud.

const log = (message) => console.log(message);

tidak arah

Arahan dalam pengaturcaraan berfungsi merujuk kepada penggunaan fungsi perantaraan untuk mengurus interaksi antara bahagian sistem yang berlainan. Contoh yang baik dalam Node.js boleh menjadi Corak Middleware.

const withNumberFilterMiddleware = (data) => data.filter(item => !isNaN(Number(item)));

Variasi Dilindungi

Variasi yang Dilindungi dalam pengaturcaraan berfungsi bermakna mencipta reka bentuk yang tahan terhadap perubahan dengan merangkum bahagian yang berbeza-beza dan memastikan seluruh sistem dilindungi daripada variasi ini. Dalam pengaturcaraan berfungsi, prinsip ini boleh digunakan melalui penggunaan abstraksi, kebolehubahan dan enkapsulasi untuk mencipta kod yang teguh dan boleh diselenggara yang kurang terdedah kepada perubahan.

const processCreditCardPayment = (amount) => {
  console.log(`Processing credit card payment of ${amount}`);
  // Credit card payment logic
};

const processPayPalPayment = (amount) => {
  console.log(`Processing PayPal payment of ${amount}`);
  // PayPal payment logic
};

const processPayment = (paymentMethod, amount) => {
  paymentMethod(amount);
};

// Use different payment methods without changing the processPayment function
processPayment(processCreditCardPayment, 100);
processPayment(processPayPalPayment, 200);

Ringkasan

Seperti yang anda boleh lihat, prinsip GRASP berkait dengan banyak corak reka bentuk yang diketahui serta prinsip SOLID. Kesepaduan Tinggi hampir sama dengan prinsip Tanggungjawab Tunggal dan sebagainya.
Prinsip tersebut bukan sahaja prinsip OOP tetapi prinsip umum untuk pengaturcaraan kod bersih yang direka dengan baik, sama ada pengaturcaraan berfungsi atau OOP.

Atas ialah kandungan terperinci GRASP dalam pengaturcaraan berfungsi Javascript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!