Cách sử dụng TypeScript cho lập trình hàm

TypeScript cung cấp các tính năng mạnh mẽ bổ sung cho lập trình chức năng, chẳng hạn như kiểu mạnh và suy luận kiểu nâng cao. Bài viết này khám phá cách tận dụng TypeScript để triển khai các nguyên tắc lập trình chức năng một cách hiệu quả.

Các nguyên tắc chính của lập trình hàm

Lập trình hàm nhấn mạnh tính bất biến, hàm thuần túy và hàm bậc cao. Các nguyên tắc này có thể được triển khai hiệu quả trong TypeScript để xây dựng mã mạnh mẽ và có thể bảo trì.

Sự bất biến

Tính bất biến đề cập đến khái niệm dữ liệu không bị thay đổi sau khi tạo. TypeScript có thể thực thi tính bất biến thông qua định nghĩa kiểu và kiểu tiện ích.

type ReadonlyUser = {
  readonly id: number;
  readonly name: string;
};

const user: ReadonlyUser = {
  id: 1,
  name: 'Alice',
};

// The following line will result in a TypeScript error
// user.id = 2;

Hàm thuần túy

Hàm thuần túy là hàm luôn tạo ra cùng một đầu ra khi có cùng đầu vào và không có tác dụng phụ. Hệ thống kiểu của TypeScript giúp đảm bảo các hàm tuân thủ tính thuần túy.

const add = (a: number, b: number): number => {
  return a + b;
};

const result = add(2, 3); // 5

Các hàm bậc cao

Các hàm bậc cao là các hàm lấy các hàm khác làm đối số hoặc trả về chúng dưới dạng kết quả. TypeScript có thể nhập các hàm này để đảm bảo chúng được sử dụng đúng cách.

const applyFunction = <T>(fn: (x: T) => T, value: T): T => {
  return fn(value);
};

const increment = (x: number): number => x + 1;

const result = applyFunction(increment, 5); // 6

Thành phần chức năng

Thành phần hàm bao gồm việc kết hợp nhiều hàm để tạo ra một hàm mới. Hệ thống kiểu của TypeScript có thể được sử dụng để đảm bảo rằng các hàm được thành phần có kiểu đúng.

const compose = <T, U, V>(f: (arg: U) => V, g: (arg: T) => U) => (x: T): V => {
  return f(g(x));
};

const double = (x: number): number => x * 2;
const square = (x: number): number => x * x;

const doubleThenSquare = compose(square, double);

const result = doubleThenSquare(3); // 36

Suy luận kiểu và Generic

Suy luận kiểu và kiểu chung của TypeScript cho phép tạo các thành phần chức năng có thể tái sử dụng trong khi vẫn duy trì tính an toàn kiểu mạnh mẽ.

const map = <T, U>(arr: T[], fn: (item: T) => U): U[] => {
  return arr.map(fn);
};

const numbers = [1, 2, 3];
const doubled = map(numbers, (x) => x * 2); // [2, 4, 6]

Phần kết luận

TypeScript tăng cường lập trình chức năng bằng cách cung cấp tính an toàn của kiểu và các kiểu biểu đạt. Bằng cách áp dụng các nguyên tắc như tính bất biến, hàm thuần túy và hàm bậc cao, TypeScript có thể được sử dụng để xây dựng các ứng dụng có thể mở rộng và bảo trì.