Kod Bersih: Mengurus Kesan Sampingan dengan Pengaturcaraan Berfungsi

Kesan sampingan boleh menyebabkan kod tidak dapat diramalkan dan sukar untuk dikekalkan. Mari kita terokai cara pengaturcaraan berfungsi membantu kita mengendalikannya dengan berkesan.

Apakah Kesan Sampingan?

Fungsi mencipta kesan sampingan jika ia melakukan apa-apa selain daripada mengambil input dan mengembalikan output. Beberapa kesan sampingan yang biasa termasuk:

• Menukar pembolehubah global
• Mengubah suai parameter input
• Menulis ke fail atau pangkalan data
• Membuat panggilan API
• Mengemas kini DOM
• Melog masuk ke konsol

Mengapa Kesan Sampingan Boleh Menyebabkan Masalah

Berikut ialah contoh yang menunjukkan kesan sampingan yang bermasalah:

let userProfile = {
  name: "Alice Johnson",
  email: "alice@example.com",
  preferences: {
    theme: "dark",
    notifications: true
  }
};

function updateUserTheme(newTheme) {
  userProfile.preferences.theme = newTheme;
}

function toggleNotifications() {
  userProfile.preferences.notifications = !userProfile.preferences.notifications;
}

// Multiple functions modifying the same global state
updateUserTheme("light");
toggleNotifications();

console.log(userProfile); // State is unpredictable

Kod ini mempunyai beberapa isu:

1. Ia menggunakan keadaan global
2. Berbilang fungsi boleh menukar data yang sama
3. Perubahan menjadi sukar untuk dikesan
4. Ujian menjadi rumit

Penyelesaian yang Lebih Baik dengan Fungsi Tulen

Berikut ialah versi yang dipertingkat menggunakan prinsip pengaturcaraan berfungsi:

const createUserProfile = (name, email, theme, notifications) => ({
  name,
  email,
  preferences: {
    theme,
    notifications
  }
});

const updateTheme = (profile, newTheme) => ({
  ...profile,
  preferences: {
    ...profile.preferences,
    theme: newTheme
  }
});

const toggleNotifications = (profile) => ({
  ...profile,
  preferences: {
    ...profile.preferences,
    notifications: !profile.preferences.notifications
  }
});

// Usage
const initialProfile = createUserProfile(
  "Alice Johnson",
  "alice@example.com",
  "dark",
  true
);

const updatedProfile = updateTheme(initialProfile, "light");
const finalProfile = toggleNotifications(updatedProfile);

console.log(initialProfile); // Original state unchanged
console.log(finalProfile);   // New state with updates

Contoh Praktikal: Operasi Fail

Berikut ialah cara mengendalikan kesan sampingan yang diperlukan dalam operasi fail menggunakan pengaturcaraan berfungsi:

// Separate pure business logic from side effects
const createUserData = (user) => ({
  id: user.id,
  name: user.name,
  createdAt: new Date().toISOString()
});

const createLogEntry = (error) => ({
  message: error.message,
  timestamp: new Date().toISOString(),
  stack: error.stack
});

// Side effect handlers (kept at the edges of the application)
const writeFile = async (filename, data) => {
  const serializedData = JSON.stringify(data);
  await fs.promises.writeFile(filename, serializedData);
  return data;
};

const appendFile = async (filename, content) => {
  await fs.promises.appendFile(filename, content);
  return content;
};

// Usage with composition
const saveUser = async (user) => {
  const userData = createUserData(user);
  return writeFile('users.json', userData);
};

const logError = async (error) => {
  const logData = createLogEntry(error);
  return appendFile('error.log', JSON.stringify(logData) + '\n');
};

Mengendalikan Kesan Sampingan dengan Pengaturcaraan Berfungsi

1. Fungsi Tulen

   // Pure function - same input always gives same output
   const calculateTotal = (items) => 
     items.reduce((sum, item) => sum + item.price, 0);

   // Side effect wrapped in a handler function
   const processPurchase = async (items) => {
     const total = calculateTotal(items);
     await saveToDatabase(total);
     return total;
   };

1. Komposisi Fungsi

   const pipe = (...fns) => (x) => 
     fns.reduce((v, f) => f(v), x);

   const processUser = pipe(
     validateUser,
     normalizeData,
     saveUser
   );

1. Transformasi Data

   const transformData = (data) => {
     const addTimestamp = (item) => ({
       ...item,
       timestamp: new Date().toISOString()
     });

     const normalize = (item) => ({
       ...item,
       name: item.name.toLowerCase()
     });

     return data
       .map(addTimestamp)
       .map(normalize);
   };

Menguji Fungsi Tulen

Pengujian menjadi lebih mudah dengan fungsi tulen:

describe('User Profile Functions', () => {
  const initialProfile = createUserProfile(
    'Alice',
    'alice@example.com',
    'dark',
    true
  );

  test('updateTheme returns new profile with updated theme', () => {
    const newProfile = updateTheme(initialProfile, 'light');

    expect(newProfile).not.toBe(initialProfile);
    expect(newProfile.preferences.theme).toBe('light');
    expect(initialProfile.preferences.theme).toBe('dark');
  });

  test('toggleNotifications flips the notifications setting', () => {
    const newProfile = toggleNotifications(initialProfile);

    expect(newProfile.preferences.notifications).toBe(false);
    expect(initialProfile.preferences.notifications).toBe(true);
  });
});

Fikiran Akhir

Pengaturcaraan fungsional menawarkan alat yang berkuasa untuk menguruskan kesan sampingan:

• Pastikan logik teras tulen dan boleh diramal
• Kendalikan kesan sampingan di tepi aplikasi anda
• Gunakan gubahan untuk menggabungkan fungsi
• Kembalikan data baharu dan bukannya mengubah suai keadaan sedia ada

Amalan ini membawa kepada kod yang lebih mudah untuk diuji, difahami dan diselenggara.

---

Bagaimana anda mengendalikan kesan sampingan dalam kod fungsi anda? Kongsi pendekatan anda dalam ulasan!

Atas ialah kandungan terperinci Kod Bersih: Mengurus Kesan Sampingan dengan Pengaturcaraan Berfungsi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!