Hàm nhỏ, làm một việc

Hàm dài làm nhiều việc vs các hàm nhỏ rõ vai trò

// Truoc: mot ham lam het - validate, tinh, luu, gui email
async function processOrder(order: Order): Promise<void> {
  if (!order.items || order.items.length === 0) {
    throw new Error('Don hang trong');
  }
  if (!order.customerId) {
    throw new Error('Thieu khach hang');
  }
  let total = 0;
  for (const item of order.items) {
    total += item.price * item.quantity;
  }
  if (order.coupon) {
    total = total * (1 - order.coupon.discount);
  }
  await db.orders.save({ ...order, total });
  await emailService.sendConfirmation(order.customerId, total);
}

// Sau: moi ham mot viec; doc processOrder la hieu toan bo luong
async function processOrder(order: Order): Promise<void> {
  validateOrder(order);
  const total = calculateTotal(order);
  await saveOrder(order, total);
  await notifyCustomer(order.customerId, total);
}

function validateOrder(order: Order): void { /* ... */ }
function calculateTotal(order: Order): number { /* ... */ }
async function saveOrder(order: Order, total: number): Promise<void> { /* ... */ }
async function notifyCustomer(customerId: string, total: number): Promise<void> { /* ... */ }

Lẫn lộn mức trừu tượng vs nhất quán một mức

// Xau: tron cai cao (logic don hang) voi cai thap (xu ly string)
function generateInvoice(order: Order): string {
  const lines: string[] = [];
  // cap cao: logic don hang
  if (order.isPremium) applyPremiumDiscount(order);
  // cap thap: xu ly string, padding, format
  lines.push('INVOICE'.padStart(20, ' '));
  lines.push('-'.repeat(40));
  for (const item of order.items) {
    const price = item.price.toFixed(2).padStart(10);
    lines.push(`${item.name.padEnd(28)}${price}`);
  }
  return lines.join('\n');
}

// Tot: ham cap cao goi ham cap thap; moi ham nhat quan mot muc
function generateInvoice(order: Order): string {
  if (order.isPremium) applyPremiumDiscount(order);
  return formatInvoice(order);
}

function formatInvoice(order: Order): string {
  return [
    formatHeader(),
    ...order.items.map(formatLineItem),
  ].join('\n');
}

function formatLineItem(item: OrderItem): string {
  return `${item.name.padEnd(28)}${item.price.toFixed(2).padStart(10)}`;
}

Hàm 3+ tham số vs gom thành object param

// Kho: 3 tham so - thu tu nao? don vi nao? moi khi goi lai phai xem
function createUser(name: string, age: number, role: string): User { /* ... */ }
createUser('Meo Con', 5, 'student'); // age va role co the bi doi cho?

// Tot: object param voi type ro rang - khong can nho thu tu
type CreateUserParams = {
  name: string;
  age: number;
  role: 'student' | 'teacher' | 'admin';
};
function createUser(params: CreateUserParams): User { /* ... */ }
createUser({ name: 'Meo Con', age: 5, role: 'student' }); // ro rang

Flag argument vs hai hàm rõ ý định

// Xau: true/false dieu huong hanh vi - ham lam 2 viec
function render(data: ReportData, printMode: boolean): string { /* ... */ }
render(data, true);   // che do in? hay gì? phai vao xem
render(data, false);

// Tot: hai ham rieng biet, ten noi ro hanh vi
function renderForScreen(data: ReportData): string { /* ... */ }
function renderForPrint(data: ReportData): string { /* ... */ }

Side effect ẩn: hàm làm nhiều hơn tên hứa

// Nguy hiem: checkPassword nghe nhu chi kiem tra, nhung xoa session
function checkPassword(userId: string, password: string): boolean {
  const user = userRepo.getById(userId);
  if (!user) return false;
  if (!bcrypt.compare(password, user.passwordHash)) {
    sessionManager.clearSession(userId); // side effect an!
    return false;
  }
  return true;
}

// Tot: ten phan anh day du hanh vi; hoac tach ra ham rieng
function checkPasswordAndClearSessionOnFailure(userId: string, password: string): boolean { /* ... */ }
// Hoac tot hon: tach ra
function verifyPassword(userId: string, password: string): boolean { /* ... */ }
function handleFailedLogin(userId: string): void { /* ... */ }

Command-query separation

// Xau: set va kiem tra trong cung mot ham - CQS bi vi pham
function setAttribute(name: string, value: string): boolean {
  if (attribute.exists(name)) {
    attribute.set(name, value); // LAM (command)
    return true;                // KIEM TRA (query) - tron lan!
  }
  return false;
}
if (setAttribute('username', 'meocon')) { /* ... */ } // set hay kiem tra?

// Tot: tach command va query ro rang
function hasAttribute(name: string): boolean {
  return attribute.exists(name);       // query: chi tra loi, khong side effect
}
function setAttribute(name: string, value: string): void {
  attribute.set(name, value);          // command: chi lam, khong tra data
}

if (hasAttribute('username')) {
  setAttribute('username', 'meocon'); // ro rang: kiem tra truoc, set sau
}

If/switch lặp vs đa hình (polymorphism)

// Xau: if/switch theo type lap o nhieu ham - them loai la sua nhieu cho
function calculatePay(employee: Employee): number {
  if (employee.type === 'fulltime') return employee.salary / 12;
  if (employee.type === 'parttime') return employee.hoursWorked * employee.hourlyRate;
  if (employee.type === 'contractor') return employee.invoiceAmount;
  throw new Error('Unknown type');
}
function getDescription(employee: Employee): string {
  if (employee.type === 'fulltime') return 'Nhan vien chinh thuc';
  if (employee.type === 'parttime') return 'Nhan vien ban thoi gian';
  if (employee.type === 'contractor') return 'Nha thau';
  throw new Error('Unknown type');
}

// Tot: da hinh - them loai chi can them lop; diem goi khong doi
interface Employee {
  calculatePay(): number;
  getDescription(): string;
}
class FullTimeEmployee implements Employee {
  calculatePay() { return this.salary / 12; }
  getDescription() { return 'Nhan vien chinh thuc'; }
}
class PartTimeEmployee implements Employee {
  calculatePay() { return this.hoursWorked * this.hourlyRate; }
  getDescription() { return 'Nhan vien ban thoi gian'; }
}
class Contractor implements Employee {
  calculatePay() { return this.invoiceAmount; }
  getDescription() { return 'Nha thau'; }
}