Đã đăng vào thg 10 4, 8:43 SA 6 phút đọc

Pure Functions (Hàm thuần túy) : Nền tảng của Lập trình hàm

1. Giới thiệu

Trong thế giới của lập trình hàm, hàm thuần túy (Pure Functions) đóng vai trò như những viên gạch nền tảng. Chúng không chỉ là một khái niệm đơn giản, mà còn là một triết lý lập trình mạnh mẽ có thể cách mạng hóa cách chúng ta viết và suy nghĩ về code. Trong bài viết này, chúng ta sẽ đi sâu vào khái niệm, ứng dụng, và tầm quan trọng của hàm thuần túy trong lập trình hiện đại.

2. Định nghĩa Hàm thuần túy

Một hàm thuần túy là một hàm có hai đặc điểm chính:

Tính xác định (Deterministic): Với cùng một đầu vào, hàm luôn trả về cùng một kết quả.
Không có tác dụng phụ (No Side Effects): Hàm không thay đổi bất kỳ trạng thái nào bên ngoài phạm vi của nó.

Ví dụ đơn giản bằng JavaScript:

// Hàm thuần túy
function add(a, b) {
    return a + b;
}

// Hàm không thuần túy
let total = 0;
function addToTotal(value) {
    total += value;
    return total;
}

3. Đặc điểm chi tiết của Hàm thuần túy

3.1 Tính xác định

Tính xác định đảm bảo rằng hàm luôn trả về cùng một kết quả cho cùng một đầu vào. Điều này có những ưu điểm sau:

Dễ dàng dự đoán: Behavior của hàm luôn nhất quán.
Dễ dàng cache: Kết quả có thể được lưu trữ và tái sử dụng.
Dễ dàng test: Không cần phải lo lắng về trạng thái bên ngoài.

Ví dụ về tính xác định:

# Python
import random

# Hàm không xác định
def random_add(a, b):
    return a + b + random.randint(0, 10)

# Hàm xác định (thuần túy)
def add(a, b):
    return a + b

3.2 Không có tác dụng phụ

Tác dụng phụ là bất kỳ thay đổi nào đối với trạng thái của chương trình bên ngoài hàm. Hàm thuần túy không gây ra các tác dụng phụ như:

Thay đổi biến toàn cục
Thay đổi tham số đầu vào
Thực hiện I/O operations
Gọi API bên ngoài

Ví dụ về hàm không có tác dụng phụ:

// JavaScript
// Hàm có tác dụng phụ
const user = { name: 'Alice', age: 30 };
function celebrateBirthday(user) {
    user.age += 1;
}

// Hàm thuần túy, không có tác dụng phụ
function getNextAge(user) {
    return user.age + 1;
}

4. Lợi ích của Hàm thuần túy

4.1 Dễ dàng test

Hàm thuần túy chỉ phụ thuộc vào đầu vào của chúng, làm cho việc viết unit tests trở nên đơn giản và hiệu quả.

# Python
def multiply(a, b):
    return a * b

# Test
def test_multiply():
    assert multiply(2, 3) == 6
    assert multiply(0, 5) == 0
    assert multiply(-1, 4) == -4

4.2 Dễ dàng suy luận và debug

Vì hàm thuần túy không phụ thuộc vào hoặc thay đổi trạng thái bên ngoài, chúng dễ dàng hiểu và debug hơn.

4.3 Tính module hóa và khả năng tái sử dụng

Hàm thuần túy có thể dễ dàng được tách ra và sử dụng lại trong các ngữ cảnh khác nhau.

4.4 Hỗ trợ lập trình song song

Vì không có tác dụng phụ và không phụ thuộc vào trạng thái chia sẻ, hàm thuần túy có thể dễ dàng chạy song song mà không cần lo lắng về race conditions.

5. Thách thức khi sử dụng Hàm thuần túy

5.1 Xử lý I/O và side effects

Trong thực tế, chúng ta không thể tránh khỏi các tác dụng phụ như I/O. Giải pháp là cô lập các tác dụng phụ và giữ phần còn lại của code thuần túy.

-- Haskell
main :: IO ()
main = do
    input <- getLine
    let result = pureFunction input
    putStrLn result

pureFunction :: String -> String
pureFunction s = "You entered: " ++ s

5.2 Hiệu suất

Trong một số trường hợp, việc tạo bản sao mới của dữ liệu thay vì thay đổi trực tiếp có thể ảnh hưởng đến hiệu suất.

5.3 Thay đổi tư duy lập trình

Chuyển từ lập trình mệnh lệnh sang lập trình hàm thuần túy đòi hỏi một sự thay đổi đáng kể trong cách tiếp cận vấn đề.

6. Kỹ thuật và Pattern với Hàm thuần túy

6.1 Curry và Partial Application

Curry là kỹ thuật chuyển đổi một hàm nhận nhiều tham số thành một chuỗi các hàm, mỗi hàm nhận một tham số.

// JavaScript
const curry = (f) => (a) => (b) => f(a, b);
const add = (a, b) => a + b;
const curriedAdd = curry(add);
console.log(curriedAdd(2)(3)); // 5

6.2 Function Composition

Kết hợp các hàm thuần túy để tạo ra các hàm phức tạp hơn.

# Python
def compose(f, g):
    return lambda x: f(g(x))

def double(x):
    return x * 2

def increment(x):
    return x + 1

double_then_increment = compose(increment, double)
print(double_then_increment(3))  # 7

6.3 Recursion thay vì Loops

Sử dụng đệ quy thay vì vòng lặp để duy trì tính thuần túy.

-- Haskell
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

7. Hàm thuần túy trong các ngôn ngữ lập trình khác nhau

7.1 JavaScript

JavaScript không bắt buộc lập trình hàm, nhưng nó hỗ trợ việc viết hàm thuần túy.

const pureIncrement = (num) => num + 1;
const purePush = (arr, item) => [...arr, item];

7.2 Python

Python cũng hỗ trợ lập trình hàm và hàm thuần túy.

def pure_increment(num):
    return num + 1

def pure_append(lst, item):
    return lst + [item]

7.3 Haskell

Haskell là một ngôn ngữ lập trình hàm thuần túy, nơi mọi hàm đều là thuần túy theo mặc định.

increment :: Int -> Int
increment x = x + 1

append :: [a] -> a -> [a]
append xs x = xs ++ [x]

8. Testing Hàm thuần túy

Việc test hàm thuần túy trở nên đơn giản hơn nhiều so với hàm không thuần túy.

# Python với pytest
def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

9. Kết luận

Hàm thuần túy là một công cụ mạnh mẽ trong lập trình hàm và phát triển phần mềm nói chung. Mặc dù có một số thách thức, việc sử dụng hàm thuần túy có thể dẫn đến code dễ đọc hơn, dễ bảo trì hơn và ít lỗi hơn. Bằng cách hiểu và áp dụng các nguyên tắc của hàm thuần túy, chúng ta có thể cải thiện đáng kể chất lượng và độ tin cậy của phần mềm mà chúng ta phát triển.