Mình là TUẤN hiện đang là một Full-stack Developer tại Tokyo 😊. Nếu bạn thấy Blog này hay xin hãy cho mình một like và đăng ký để ủng hộ mình nhé 😉.
Chào buổi sáng mọi người, hãy cũng nhau cưỡi ngựa xem hoa, cưỡi tên lửa ngắm đài điểu những Ví dụ về clean code. Cứ xem bài viết này như là một Checklist cho chúng ta tự Review Code của mình trước khi commit.
OK cùng ngồi xuống uống miếng bánh ăn miếng nước và GÉT GÔ nào....
Variables
Sử dụng tên biến có nghĩa
Not Good
const yyyymmdstr = moment().format('YYYY/MM/DD');
Good
const currentDate = moment().format('YYYY/MM/DD');
Sử dụng cùng từ vựng cho cùng loại biến
Not Good
getUserInfo();
getClientData();
getCustomerRecord();
Good
getUser();
Sử dụng các tên có thể tìm kiếm được
Not Good
// 86400000 là cái gì?
setTimeout(blastOff, 86400000);
Good
// Khai báo chúng như một biến global.
const MILLISECONDS_IN_A_DAY = 86400000;
setTimeout(blastOff, MILLISECONDS_IN_A_DAY);
Sử dụng những biến có thể giải thích được
Not Good
const address = 'One Infinite Loop, Cupertino 95014';
const cityZipCodeRegex = /^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;
saveCityZipCode(address.match(cityZipCodeRegex)[1], address.match(cityZipCodeRegex)[2]);
Good
const address = 'One Infinite Loop, Cupertino 95014';
const cityZipCodeRegex = /^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;
const [, city, zipCode] = address.match(cityZipCodeRegex) || [];
saveCityZipCode(city, zipCode);
Tường minh mọi thứ
Not Good
const locations = ['Austin', 'New York', 'San Francisco'];
locations.forEach((l) => { doStuff(); doSomeOtherStuff(); // ... // ... // ... // `l` làm cái gì vậy? dispatch(l);
});
Good
const locations = ['Austin', 'New York', 'San Francisco'];
locations.forEach((location) => { doStuff(); doSomeOtherStuff(); // ... // ... // ... dispatch(location);
});
Đừng thêm những thứ không cần thiết
Not Good
const Car = { carMake: 'Honda', carModel: 'Accord', carColor: 'Blue'
}; function paintCar(car, color) { car.carColor = color;
}
Good
const Car = { make: 'Honda', model: 'Accord', color: 'Blue'
}; function paintCar(car, color) { car.color = color;
}
Sử dụng những tham số mặc định thay vì kiểm tra các điều kiện lòng vòng
Not Good
function createMicrobrewery(name) { const breweryName = name || 'Hipster Brew Co.'; // ...
} Good
function createMicrobrewery(breweryName = 'Hipster Brew Co.') { // ...
} Functions
Đối số của hàm
Lý tưởng là ít hơn hoặc bằng 2. Not Good
function createMenu(title, body, buttonText, cancellable) { // ...
}
Good
function createMenu({ title, body, buttonText, cancellable }) { // ...
} createMenu({ title: 'Foo', body: 'Bar', buttonText: 'Baz', cancellable: true
});
Một Function chỉ nên giải quyết một vấn đề
Not Good
function emailClients(clients) { clients.forEach((client) => { const clientRecord = database.lookup(client); if (clientRecord.isActive()) { email(client); } });
}
Good
function emailClients(clients) { clients .filter(isClientActive) .forEach(email);
} function isClientActive(client) { const clientRecord = database.lookup(client); return clientRecord.isActive();
}
Tên hàm phải nói ra được những gì chúng làm
Not Good
function addToDate(date, month) { // ...
} const date = new Date(); // Khó để biết được hàm này thêm gì thông qua tên hàm.
addToDate(date, 1);
Good
function addMonthToDate(month, date) { // ...
} const date = new Date();
addMonthToDate(1, date);
Hàm chỉ nên có một lớp trừu tượng
Not Good
function parseBetterJSAlternative(code) { const REGEXES = [ // ... ]; const statements = code.split(' '); const tokens = []; REGEXES.forEach((REGEX) => { statements.forEach((statement) => { // ... }); }); const ast = []; tokens.forEach((token) => { // lex... }); ast.forEach((node) => { // parse... });
}
Good
function tokenize(code) { const REGEXES = [ // ... ]; const statements = code.split(' '); const tokens = []; REGEXES.forEach((REGEX) => { statements.forEach((statement) => { tokens.push( /* ... */ ); }); }); return tokens;
} function lexer(tokens) { const ast = []; tokens.forEach((token) => { ast.push( /* ... */ ); }); return ast;
} function parseBetterJSAlternative(code) { const tokens = tokenize(code); const ast = lexer(tokens); ast.forEach((node) => { // parse... });
}
Xóa code trùng lặp
Not Good
function showDeveloperList(developers) { developers.forEach((developer) => { const expectedSalary = developer.calculateExpectedSalary(); const experience = developer.getExperience(); const githubLink = developer.getGithubLink(); const data = { expectedSalary, experience, githubLink }; render(data); });
} function showManagerList(managers) { managers.forEach((manager) => { const expectedSalary = manager.calculateExpectedSalary(); const experience = manager.getExperience(); const portfolio = manager.getMBAProjects(); const data = { expectedSalary, experience, portfolio }; render(data); });
}
Good
function showEmployeeList(employees) { employees.forEach((employee) => { const expectedSalary = employee.calculateExpectedSalary(); const experience = employee.getExperience(); let portfolio = employee.getGithubLink(); if (employee.type === 'manager') { portfolio = employee.getMBAProjects(); } const data = { expectedSalary, experience, portfolio }; render(data); });
}
Thiết lập những đối tượng mặc định với Object.assign
Not Good
const menuConfig = { title: null, body: 'Bar', buttonText: null, cancellable: true
}; function createMenu(config) { config.title = config.title || 'Foo'; config.body = config.body || 'Bar'; config.buttonText = config.buttonText || 'Baz'; config.cancellable = config.cancellable === undefined ? config.cancellable : true;
} createMenu(menuConfig);
Good
const menuConfig = { title: 'Order', // User did not include 'body' key buttonText: 'Send', cancellable: true
}; function createMenu(config) { config = Object.assign({ title: 'Foo', body: 'Bar', buttonText: 'Baz', cancellable: true }, config); // config now equals: {title: "Order", body: "Bar", buttonText: "Send", cancellable: true} // ...
} createMenu(menuConfig);
Đừng sử dụng các flag như đối số của hàm
Not Good
function createFile(name, temp) { if (temp) { fs.create(`./temp/${name}`); } else { fs.create(name); }
}
Good
function createFile(name) { fs.create(name);
} function createTempFile(name) { createFile(`./temp/${name}`);
}
Tránh những ảnh hưởng không cần thiết
VD1: Not Good
// Biến toàn cục được tham chiếu bởi hàm dưới đây.
// Nếu chúng ta có một hàm khác sử dụng name, nó sẽ trở thành một array
let name = 'Ryan McDermott'; function splitIntoFirstAndLastName() { name = name.split(' ');
} splitIntoFirstAndLastName(); console.log(name); // ['Ryan', 'McDermott'];
Good
function splitIntoFirstAndLastName(name) { return name.split(' ');
} const name = 'Ryan McDermott';
const newName = splitIntoFirstAndLastName(name); console.log(name); // 'Ryan McDermott';
console.log(newName); // ['Ryan', 'McDermott'];
Đừng Override những function hoặc biến toàn cục
Not Good
Array.prototype.diff = function diff(comparisonArray) { const hash = new Set(comparisonArray); return this.filter(elem => !hash.has(elem));
};
Good
class SuperArray extends Array { diff(comparisonArray) { const hash = new Set(comparisonArray); return this.filter(elem => !hash.has(elem)); }
}
Ưu tiên functional programming hơn là imperative programming
Ưu tiên lập trình theo hướng function hơn lập trình theo từng lệnh. Not Good
const programmerOutput = [ { name: 'Uncle Bobby', linesOfCode: 500 }, { name: 'Suzie Q', linesOfCode: 1500 }, { name: 'Jimmy Gosling', linesOfCode: 150 }, { name: 'Gracie Hopper', linesOfCode: 1000 }
]; let totalOutput = 0; for (let i = 0; i < programmerOutput.length; i++) { totalOutput += programmerOutput[i].linesOfCode;
}
Good
const programmerOutput = [ { name: 'Uncle Bobby', linesOfCode: 500 }, { name: 'Suzie Q', linesOfCode: 1500 }, { name: 'Jimmy Gosling', linesOfCode: 150 }, { name: 'Gracie Hopper', linesOfCode: 1000 }
]; const INITIAL_VALUE = 0; const totalOutput = programmerOutput .map((programmer) => programmer.linesOfCode) .reduce((acc, linesOfCode) => acc + linesOfCode, INITIAL_VALUE);
Đóng gói các điều kiện
Not Good
if (fsm.state === 'fetching' && isEmpty(listNode)) { // ...
}
Good
function shouldShowSpinner(fsm, listNode) { return fsm.state === 'fetching' && isEmpty(listNode);
} if (shouldShowSpinner(fsmInstance, listNodeInstance)) { // ...
}
Tránh điều kiện tiêu cực
Not Good
function isDOMNodeNotPresent(node) { // ...
} if (!isDOMNodeNotPresent(node)) { // ...
}
Good
function isDOMNodePresent(node) { // ...
} if (isDOMNodePresent(node)) { // ...
}
Tránh điều kiện
Not Good
class Airplane { // ... getCruisingAltitude() { switch (this.type) { case '777': return this.getMaxAltitude() - this.getPassengerCount(); case 'Air Force One': return this.getMaxAltitude(); case 'Cessna': return this.getMaxAltitude() - this.getFuelExpenditure(); } }
}
Good
class Airplane { // ...
} class Boeing777 extends Airplane { // ... getCruisingAltitude() { return this.getMaxAltitude() - this.getPassengerCount(); }
} class AirForceOne extends Airplane { // ... getCruisingAltitude() { return this.getMaxAltitude(); }
} class Cessna extends Airplane { // ... getCruisingAltitude() { return this.getMaxAltitude() - this.getFuelExpenditure(); }
}
Tránh kiểm tra kiểu
VD1: Not Good
function travelToTexas(vehicle) { if (vehicle instanceof Bicycle) { vehicle.peddle(this.currentLocation, new Location('texas')); } else if (vehicle instanceof Car) { vehicle.drive(this.currentLocation, new Location('texas')); }
}
Good
function travelToTexas(vehicle) { vehicle.move(this.currentLocation, new Location('texas'));
}
VD2: Not Good
function combine(val1, val2) { if (typeof val1 === 'number' && typeof val2 === 'number' || typeof val1 === 'string' && typeof val2 === 'string') { return val1 + val2; } throw new Error('Must be of type String or Number');
}
Good
function combine(val1, val2) { return val1 + val2;
}
Xóa dead code
Not Good
function oldRequestModule(url) { // ...
} function newRequestModule(url) { // ...
} const req = newRequestModule;
inventoryTracker('apples', req, 'www.inventory-awesome.io'); Good
function newRequestModule(url) { // ...
} const req = newRequestModule;
inventoryTracker('apples', req, 'www.inventory-awesome.io');
Objects and Data Structures
Sử dụng getter và setter
Not Good
function makeBankAccount() { // ... return { balance: 0, // ... };
} const account = makeBankAccount();
account.balance = 100;
Good
function makeBankAccount() { // this one is private let balance = 0; // Một "getter", thiết lập public thông qua đối tượng được trả về dưới đây function getBalance() { return balance; } // Một "setter", thiết lập public thông qua đối tượng được trả về dưới đây function setBalance(amount) { // ... validate before updating the balance balance = amount; } return { // ... getBalance, setBalance, };
} const account = makeBankAccount();
account.setBalance(100); Sử dụng tính bao đóng trong JS
Điều này có thể được thực hiện thông qua closures (cho ES5 và cũ hơn). Not Good
const Employee = function(name) { this.name = name;
}; Employee.prototype.getName = function getName() { return this.name;
}; const employee = new Employee('John Doe');
console.log(`Employee name: ${employee.getName()}`); // Employee name: John Doe
delete employee.name;
console.log(`Employee name: ${employee.getName()}`); // Employee name: undefined
Good
const Employee = function (name) { this.getName = function getName() { return name; };
}; const employee = new Employee('John Doe');
console.log(`Employee name: ${employee.getName()}`); // Employee name: John Doe
delete employee.name;
console.log(`Employee name: ${employee.getName()}`); // Employee name: John Doe
Classes
Ưu tiên class ES2015/ES6 hơn các function thuần ES5
Not Good
const Animal = function(age) { if (!(this instanceof Animal)) { throw new Error('Instantiate Animal with `new`'); } this.age = age;
}; Animal.prototype.move = function move() {}; const Mammal = function(age, furColor) { if (!(this instanceof Mammal)) { throw new Error('Instantiate Mammal with `new`'); } Animal.call(this, age); this.furColor = furColor;
}; Mammal.prototype = Object.create(Animal.prototype);
Mammal.prototype.constructor = Mammal;
Mammal.prototype.liveBirth = function liveBirth() {}; const Human = function(age, furColor, languageSpoken) { if (!(this instanceof Human)) { throw new Error('Instantiate Human with `new`'); } Mammal.call(this, age, furColor); this.languageSpoken = languageSpoken;
}; Human.prototype = Object.create(Mammal.prototype);
Human.prototype.constructor = Human;
Human.prototype.speak = function speak() {};
Good
class Animal { constructor(age) { this.age = age; } move() { /* ... */ }
} class Mammal extends Animal { constructor(age, furColor) { super(age); this.furColor = furColor; } liveBirth() { /* ... */ }
} class Human extends Mammal { constructor(age, furColor, languageSpoken) { super(age, furColor); this.languageSpoken = languageSpoken; } speak() { /* ... */ }
}
Xâu chuỗi các hàm
Not Good
class Car { constructor() { this.make = 'Honda'; this.model = 'Accord'; this.color = 'white'; } setMake(make) { this.make = make; } setModel(model) { this.model = model; } setColor(color) { this.color = color; } save() { console.log(this.make, this.model, this.color); }
} const car = new Car();
car.setColor('pink');
car.setMake('Ford');
car.setModel('F-150');
car.save();
Good
class Car { constructor() { this.make = 'Honda'; this.model = 'Accord'; this.color = 'white'; } setMake(make) { this.make = make; // Ghi chú: Trả về this để xâu chuỗi các hàm return this; } setModel(model) { this.model = model; // Ghi chú: Trả về this để xâu chuỗi các hàm return this; } setColor(color) { this.color = color; // Ghi chú: Trả về this để xâu chuỗi các hàm return this; } save() { console.log(this.make, this.model, this.color); // Ghi chú: Trả về this để xâu chuỗi các hàm return this; }
} const car = new Car() .setColor('pink') .setMake('Ford') .setModel('F-150') .save();
Ưu tiên component hơn là kế thừa
Not Good
class Employee { constructor(name, email) { this.name = name; this.email = email; } // ...
} // Không tốt bởi vì Employees "có" dữ liệu thuế.
// EmployeeTaxData không phải là một loại của Employee
class EmployeeTaxData extends Employee { constructor(ssn, salary) { super(); this.ssn = ssn; this.salary = salary; } // ...
}
Good
class EmployeeTaxData { constructor(ssn, salary) { this.ssn = ssn; this.salary = salary; } // ...
} class Employee { constructor(name, email) { this.name = name; this.email = email; } setTaxData(ssn, salary) { this.taxData = new EmployeeTaxData(ssn, salary); } // ...
}
SOLID
Nguyên lí mỗi người một việc (Single Responsibility Principle)
Not Good
class UserSettings { constructor(user) { this.user = user; } changeSettings(settings) { if (this.verifyCredentials()) { // ... } } verifyCredentials() { // ... }
}
Good
class UserAuth { constructor(user) { this.user = user; } verifyCredentials() { // ... }
} class UserSettings { constructor(user) { this.user = user; this.auth = new UserAuth(user); } changeSettings(settings) { if (this.auth.verifyCredentials()) { // ... } }
}
Nguyên lí đóng mở (Open/Closed Principle)
Trong ví dụ bạn sẽ thấy ko nên cho các HttpRequester tương tác hoặc biết về sự tồn tại của AjaxAdapter, NodeAdapter mà tất cả chỉ biết và tương tác với nhau thông qua Adapter
Not Good
class AjaxAdapter extends Adapter { constructor() { super(); this.name = 'ajaxAdapter'; }
} class NodeAdapter extends Adapter { constructor() { super(); this.name = 'nodeAdapter'; }
} class HttpRequester { constructor(adapter) { this.adapter = adapter; } fetch(url) { if (this.adapter.name === 'ajaxAdapter') { return makeAjaxCall(url).then((response) => { // transform response and return }); } else if (this.adapter.name === 'httpNodeAdapter') { return makeHttpCall(url).then((response) => { // transform response and return }); } }
} function makeAjaxCall(url) { // request and return promise
} function makeHttpCall(url) { // request and return promise
}
Good
class AjaxAdapter extends Adapter { constructor() { super(); this.name = 'ajaxAdapter'; } request(url) { // request and return promise }
} class NodeAdapter extends Adapter { constructor() { super(); this.name = 'nodeAdapter'; } request(url) { // request and return promise }
} class HttpRequester { constructor(adapter) { this.adapter = adapter; } fetch(url) { return this.adapter.request(url).then((response) => { // transform response and return }); }
}
Nguyên lí thay thế Liskov (Liskov Substitution Principle)
Not Good
class Rectangle { constructor() { this.width = 0; this.height = 0; } setColor(color) { // ... } render(area) { // ... } setWidth(width) { this.width = width; } setHeight(height) { this.height = height; } getArea() { return this.width * this.height; }
} class Square extends Rectangle { setWidth(width) { this.width = width; this.height = width; } setHeight(height) { this.width = height; this.height = height; }
} function renderLargeRectangles(rectangles) { rectangles.forEach((rectangle) => { rectangle.setWidth(4); rectangle.setHeight(5); const area = rectangle.getArea(); // BAD: Will return 25 for Square. Should be 20. rectangle.render(area); });
} const rectangles = [new Rectangle(), new Rectangle(), new Square()];
renderLargeRectangles(rectangles);
Good
class Shape { setColor(color) { // ... } render(area) { // ... }
} class Rectangle extends Shape { constructor(width, height) { super(); this.width = width; this.height = height; } getArea() { return this.width * this.height; }
} class Square extends Shape { constructor(length) { super(); this.length = length; } getArea() { return this.length * this.length; }
} function renderLargeShapes(shapes) { shapes.forEach((shape) => { const area = shape.getArea(); shape.render(area); }); } const shapes = [new Rectangle(4, 5), new Rectangle(4, 5), new Square(5)];
renderLargeShapes(shapes);
Nguyên lí phân tách interface (Interface Segregation Principle)
Not Good
class DOMTraverser { constructor(settings) { this.settings = settings; this.setup(); } setup() { this.rootNode = this.settings.rootNode; this.animationModule.setup(); } traverse() { // ... }
} const $ = new DOMTraverser({ rootNode: document.getElementsByTagName('body'), animationModule() {} // Most of the time, we won't need to animate when traversing. // ...
}); Good
class DOMTraverser { constructor(settings) { this.settings = settings; this.options = settings.options; this.setup(); } setup() { this.rootNode = this.settings.rootNode; this.setupOptions(); } setupOptions() { if (this.options.animationModule) { // ... } } traverse() { // ... }
} const $ = new DOMTraverser({ rootNode: document.getElementsByTagName('body'), options: { animationModule() {} }
});
Nguyên lí đảo ngược dependency (Dependency Inversion Principle)
Not Good
class InventoryRequester { constructor() { this.REQ_METHODS = ['HTTP']; } requestItem(item) { // ... }
} class InventoryTracker { constructor(items) { this.items = items; // Not Good chúng ta đã tạo một phụ thuộc vào một hiện thực của một request cụ thể // Chúng ta nên có những requestItems phụ thuộc vào một hàm request `request` this.requester = new InventoryRequester(); } requestItems() { this.items.forEach((item) => { this.requester.requestItem(item); }); }
} const inventoryTracker = new InventoryTracker(['apples', 'bananas']);
inventoryTracker.requestItems();
Good
class InventoryTracker { constructor(items, requester) { this.items = items; this.requester = requester; } requestItems() { this.items.forEach((item) => { this.requester.requestItem(item); }); }
} class InventoryRequesterV1 { constructor() { this.REQ_METHODS = ['HTTP']; } requestItem(item) { // ... }
} class InventoryRequesterV2 { constructor() { this.REQ_METHODS = ['WS']; } requestItem(item) { // ... }
} // Bằng cách xây dựng các phụ thuộc ở ngoài và thêm chúng vào, chúng ta có thể
// dễ dàng thay thế module request bằng một module mới lạ sử dụng WebSockets.
const inventoryTracker = new InventoryTracker(['apples', 'bananas'], new InventoryRequesterV2());
inventoryTracker.requestItems();
Testing
Một khái niệm duy nhất cho mỗi unit test
Not Good
const assert = require('assert'); describe('MakeMomentJSGreatAgain', () => { it('handles date boundaries', () => { let date; date = new MakeMomentJSGreatAgain('1/1/2015'); date.addDays(30); date.shouldEqual('1/31/2015'); date = new MakeMomentJSGreatAgain('2/1/2016'); date.addDays(28); assert.equal('02/29/2016', date); date = new MakeMomentJSGreatAgain('2/1/2015'); date.addDays(28); assert.equal('03/01/2015', date); });
});
Good
const assert = require('assert'); describe('MakeMomentJSGreatAgain', () => { it('handles 30-day months', () => { const date = new MakeMomentJSGreatAgain('1/1/2015'); date.addDays(30); date.shouldEqual('1/31/2015'); }); it('handles leap year', () => { const date = new MakeMomentJSGreatAgain('2/1/2016'); date.addDays(28); assert.equal('02/29/2016', date); }); it('handles non-leap year', () => { const date = new MakeMomentJSGreatAgain('2/1/2015'); date.addDays(28); assert.equal('03/01/2015', date); });
});
Concurrency - Xử lí đồng thời
Hãy dùng Promise, đừng dùng callback
Not Good
require('request').get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin', (requestErr, response) => { if (requestErr) { console.error(requestErr); } else { require('fs').writeFile('article.html', response.body, (writeErr) => { if (writeErr) { console.error(writeErr); } else { console.log('File written'); } }); }
}); Good
require('request-promise').get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin') .then((response) => { return require('fs-promise').writeFile('article.html', response); }) .then(() => { console.log('File written'); }) .catch((err) => { console.error(err); }); Async/Await thì 'clean' hơn Promise
Not Good
require('request-promise').get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin') .then((response) => { return require('fs-promise').writeFile('article.html', response); }) .then(() => { console.log('File written'); }) .catch((err) => { console.error(err); }); Good
async function getCleanCodeArticle() { try { const response = await require('request-promise').get('https://en.wikipedia.org/wiki/Robert_Cecil_Martin'); await require('fs-promise').writeFile('article.html', response); console.log('File written'); } catch(err) { console.error(err); }
}
Error Handling
Đừng bỏ qua những lỗi đã bắt được
Not Good
try { functionThatMightThrow();
} catch (error) { console.log(error);
}
Good
try { functionThatMightThrow();
} catch (error) { // One option (more noisy than console.log): console.error(error); // Another option: notifyUserOfError(error); // Another option: reportErrorToService(error); // OR do all three!
}
Đừng bỏ qua những promise bị lỗi (rejected)
Cùng nguyên nhân với phần trên. Not Good
getdata()
.then((data) => { functionThatMightThrow(data);
})
.catch((error) => { console.log(error);
});
Good
getdata()
.then((data) => { functionThatMightThrow(data);
})
.catch((error) => { // One option (more noisy than console.log): console.error(error); // Another option: notifyUserOfError(error); // Another option: reportErrorToService(error); // OR do all three!
});
Formatting
Not Good
const DAYS_IN_WEEK = 7;
const daysInMonth = 30; const songs = ['Back In Black', 'Stairway to Heaven', 'Hey Jude'];
const Artists = ['ACDC', 'Led Zeppelin', 'The Beatles']; function eraseDatabase() {}
function restore_database() {} class animal {}
class Alpaca {}
Good
const DAYS_IN_WEEK = 7;
const DAYS_IN_MONTH = 30; const songs = ['Back In Black', 'Stairway to Heaven', 'Hey Jude'];
const artists = ['ACDC', 'Led Zeppelin', 'The Beatles']; function eraseDatabase() {}
function restoreDatabase() {} class Animal {}
class Alpaca {}
Các hàm gọi và hàm được gọi nên nằm gần nhau
Not Good
class PerformanceReview { constructor(employee) { this.employee = employee; } lookupPeers() { return db.lookup(this.employee, 'peers'); } lookupManager() { return db.lookup(this.employee, 'manager'); } getPeerReviews() { const peers = this.lookupPeers(); // ... } perfReview() { this.getPeerReviews(); this.getManagerReview(); this.getSelfReview(); } getManagerReview() { const manager = this.lookupManager(); } getSelfReview() { // ... }
} const review = new PerformanceReview(user);
review.perfReview();
Good
class PerformanceReview { constructor(employee) { this.employee = employee; } perfReview() { this.getPeerReviews(); this.getManagerReview(); this.getSelfReview(); } getPeerReviews() { const peers = this.lookupPeers(); // ... } lookupPeers() { return db.lookup(this.employee, 'peers'); } getManagerReview() { const manager = this.lookupManager(); } lookupManager() { return db.lookup(this.employee, 'manager'); } getSelfReview() { // ... }
} const review = new PerformanceReview(employee);
review.perfReview();
Comments
Chỉ nên viết comment cho những thứ có logic phức tạp.
Not Good
function hashIt(data) { // Khai báo hash let hash = 0; // Lấy chiều dài của chuỗi const length = data.length; // Lặp qua mỗi kí tự for (let i = 0; i < length; i++) { // Lấy code của kí tự const char = data.charCodeAt(i); // Gán value cho hash hash = ((hash << 5) - hash) + char; // Chuyển thành định dạng số nguyên 32 bit hash &= hash; }
}
Good
function hashIt(data) { let hash = 0; const length = data.length; for (let i = 0; i < length; i++) { const char = data.charCodeAt(i); hash = ((hash << 5) - hash) + char; // Chuyển thành định dạng số nguyên 32 bit hash &= hash; }
} Đừng giữ lại những đoạn code bị comment trong codebase của bạn.
Not Good
doStuff();
// doOtherStuff();
// doSomeMoreStuff();
// doSoMuchStuff();
Good
doStuff();
Đừng viết các comment log
Sử dụng git log để xem lịch sử được mà!
Not Good
/** * 2016-12-20: Removed monads, didn't understand them (RM) * 2016-10-01: Improved using special monads (JP) * 2016-02-03: Removed type-checking (LI) * 2015-03-14: Added combine with type-checking (JR) */
function combine(a, b) { return a + b;
}
Good
function combine(a, b) { return a + b;
}
Tránh những đánh dấu vị trí
Not Good
////////////////////////////////////////////////////////////////////////////////
// Scope Model Instantiation
////////////////////////////////////////////////////////////////////////////////
$scope.model = { menu: 'foo', nav: 'bar'
}; ////////////////////////////////////////////////////////////////////////////////
// Action setup
////////////////////////////////////////////////////////////////////////////////
const actions = function() { // ...
};
Good
$scope.model = { menu: 'foo', nav: 'bar'
}; const actions = function() { // ...
};
Roundup
Như mọi khi, mình hy vọng bạn thích bài viết này và học thêm được điều gì đó mới.
Cảm ơn và hẹn gặp lại các bạn trong những bài viết tiếp theo! 😍
Nếu bạn thấy Blog này hay xin hãy cho mình một like và đăng ký để ủng hộ mình nhé. Thank you.😉