如何寫出優雅耐看的JavaScript代碼

時間  2019-11-05
標籤 如何 寫出 優雅 耐看 javascript 代碼 欄目 JavaScript 简体版
原文   原文鏈接

前言

在咱們平時的工做開發中，大多數都是大人協同開發的公共項目；在咱們平時開發中代碼codeing的時候咱們考慮代碼的可讀性、複用性和擴展性。es6

乾淨的代碼，既在質量上較爲可靠，也爲後期維護、升級奠基了良好基礎。數組

咱們從如下幾個方面進行探討：網絡

變量

一、變量命名

通常咱們在定義變量是要使用有意義的詞彙命令，要作到見面知義數據結構

//bad code
const yyyymmdstr = moment().format('YYYY/MM/DD');
//better code
const currentDate = moment().format('YYYY/MM/DD');

二、可描述

經過一個變量生成了一個新變量，也須要爲這個新變量命名，也就是說每一個變量當你看到他第一眼你就知道他是幹什麼的。函數

//bad code
const ADDRESS = 'One Infinite Loop, Cupertino 95014';
const CITY_ZIP_CODE_REGEX = /^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;
saveCityZipCode(ADDRESS.match(CITY_ZIP_CODE_REGEX)[1], ADDRESS.match(CITY_ZIP_CODE_REGEX)[2]);

//better code
const ADDRESS = 'One Infinite Loop, Cupertino 95014';
const CITY_ZIP_CODE_REGEX = /^[^,\\]+[,\\\s]+(.+?)\s*(\d{5})?$/;
const [, city, zipCode] = ADDRESS.match(CITY_ZIP_CODE_REGEX) || [];
saveCityZipCode(city, zipCode);

三、形參命名

在for、forEach、map的循環中咱們在命名時要直接oop

//bad code
const locations = ['Austin', 'New York', 'San Francisco'];
locations.map((l) => {
  doStuff();
  doSomeOtherStuff();
  // ...
  // ...
  // ...
  // 須要看其餘代碼才能肯定 'l' 是幹什麼的。
  dispatch(l);
});

//better code
const locations = ['Austin', 'New York', 'San Francisco'];
locations.forEach((location) => {
  doStuff();
  doSomeOtherStuff();
  // ...
  // ...
  // ...
  dispatch(location);
});

四、避免無心義的前綴

例如咱們只建立一個對象是，沒有必要再把每一個對象的屬性上再加上對象名this

//bad code
const car = {
  carMake: 'Honda',
  carModel: 'Accord',
  carColor: 'Blue'
};

function paintCar(car) {
  car.carColor = 'Red';
}

//better code
const car = {
  make: 'Honda',
  model: 'Accord',
  color: 'Blue'
};

function paintCar(car) {
  car.color = 'Red';
}

五、默認值

//bad code
function createMicrobrewery(name) {
  const breweryName = name || 'Hipster Brew Co.';
  // ...
}

//better code
function createMicrobrewery(name = 'Hipster Brew Co.') {
  // ...
}

函數

一、參數

通常參數多的話要使用ES6的解構傳參的方式spa

//bad code
function createMenu(title, body, buttonText, cancellable) {
  // ...
}

//better code
function createMenu({ title, body, buttonText, cancellable }) {
  // ...
}

//better code
createMenu({
  title: 'Foo',
  body: 'Bar',
  buttonText: 'Baz',
  cancellable: true
});

二、單一化處理

一個方法裏面最好只作一件事，不要過多的處理，這樣代碼的可讀性很是高prototype

//bad code
function emailClients(clients) {
  clients.forEach((client) => {
    const clientRecord = database.lookup(client);
    if (clientRecord.isActive()) {
      email(client);
    }
  });
}

//better code
function emailActiveClients(clients) {
  clients
    .filter(isActiveClient)
    .forEach(email);
}
function isActiveClient(client) {
  const clientRecord = database.lookup(client);    
  return clientRecord.isActive();
}

三、對象設置默認屬性

//bad code
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);


//better code
const menuConfig = {
  title: 'Order',
  // 'body' key 缺失
  buttonText: 'Send',
  cancellable: true
};

function createMenu(config) {
  config = Object.assign({
    title: 'Foo',
    body: 'Bar',
    buttonText: 'Baz',
    cancellable: true
  }, config);

  // config 就變成了: {title: "Order", body: "Bar", buttonText: "Send", cancellable: true}
  // ...
}

createMenu(menuConfig);

四、避免反作用

函數接收一個值返回一個新值，除此以外的行爲咱們都稱之爲反作用，好比修改全局變量、對文件進行 IO 操做等。設計

當函數確實須要反作用時，好比對文件進行 IO 操做時，請不要用多個函數/類進行文件操做，有且僅用一個函數/類來處理。也就是說反作用須要在惟一的地方處理。

反作用的三大天坑：隨意修改可變數據類型、隨意分享沒有數據結構的狀態、沒有在統一地方處理反作用。

//bad code
// 全局變量被一個函數引用
// 如今這個變量從字符串變成了數組，若是有其餘的函數引用，會發生沒法預見的錯誤。
var name = 'Ryan McDermott';
function splitIntoFirstAndLastName() {
  name = name.split(' ');
}
splitIntoFirstAndLastName();
console.log(name); // ['Ryan', 'McDermott'];


//better code
var name = 'Ryan McDermott';
var newName = splitIntoFirstAndLastName(name)

function splitIntoFirstAndLastName(name) {
  return name.split(' ');
}

console.log(name); // 'Ryan McDermott';
console.log(newName); // ['Ryan', 'McDermott'];

在 JavaScript 中，基本類型經過賦值傳遞，對象和數組經過引用傳遞。以引用傳遞爲例：

假如咱們寫一個購物車，經過 addItemToCart()方法添加商品到購物車，修改 購物車數組。此時調用 purchase()方法購買，因爲引用傳遞，獲取的 購物車數組正好是最新的數據。

看起來沒問題對不對？

若是當用戶點擊購買時，網絡出現故障， purchase()方法一直在重複調用，與此同時用戶又添加了新的商品，這時網絡又恢復了。那麼 purchase()方法獲取到 購物車數組就是錯誤的。

爲了不這種問題，咱們須要在每次新增商品時，克隆 購物車數組並返回新的數組。

//bad code
const addItemToCart = (cart, item) => {
  cart.push({ item, date: Date.now() });
};

//better code
const addItemToCart = (cart, item) => {
  return [...cart, {item, date: Date.now()}]
};

五、全局方法

在 JavaScript 中，永遠不要污染全局，會在生產環境中產生難以預料的 bug。舉個例子，好比你在 Array.prototype上新增一個 diff方法來判斷兩個數組的不一樣。而你同事也打算作相似的事情，不過他的 diff方法是用來判斷兩個數組首位元素的不一樣。很明顯大家方法會產生衝突，遇到這類問題咱們能夠用 ES2015/ES6 的語法來對 Array進行擴展。

//bad code
Array.prototype.diff = function diff(comparisonArray) {
  const hash = new Set(comparisonArray);
  return this.filter(elem => !hash.has(elem));
};

//better code
class SuperArray extends Array {
  diff(comparisonArray) {
    const hash = new Set(comparisonArray);
    return this.filter(elem => !hash.has(elem));        
  }
}

六、避免類型檢查

JavaScript 是無類型的，意味着你能夠傳任意類型參數，這種自由度很容易讓人困擾，不自覺的就會去檢查類型。仔細想一想是你真的須要檢查類型仍是你的 API 設計有問題？

//bad code
function travelToTexas(vehicle) {
  if (vehicle instanceof Bicycle) {
    vehicle.pedal(this.currentLocation, new Location('texas'));
  } else if (vehicle instanceof Car) {
    vehicle.drive(this.currentLocation, new Location('texas'));
  }
}

//better code
function travelToTexas(vehicle) {
  vehicle.move(this.currentLocation, new Location('texas'));
}

若是你須要作靜態類型檢查，好比字符串、整數等，推薦使用 TypeScript，否則你的代碼會變得又臭又長。

//bad code
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');
}

//better code
function combine(val1, val2) {
  return val1 + val2;
}

複雜條件判斷

咱們編寫js代碼時常常遇到複雜邏輯判斷的狀況，一般你們能夠用if/else或者switch來實現多個條件判斷，但這樣會有個問題，隨着邏輯複雜度的增長，代碼中的if/else/switch會變得愈來愈臃腫，愈來愈看不懂，那麼如何更優雅的寫判斷邏輯

一、if/else

點擊列表按鈕事件

/**
 * 按鈕點擊事件
 * @param {number} status 活動狀態：1 開團進行中 2 開團失敗 3 商品售罄 4 開團成功 5 系統取消
 */
const onButtonClick = (status)=>{
  if(status == 1){
    sendLog('processing')
    jumpTo('IndexPage')
  }else if(status == 2){
    sendLog('fail')
    jumpTo('FailPage')
  }else if(status == 3){
    sendLog('fail')
    jumpTo('FailPage')
  }else if(status == 4){
    sendLog('success')
    jumpTo('SuccessPage')
  }else if(status == 5){
    sendLog('cancel')
    jumpTo('CancelPage')
  }else {
    sendLog('other')
    jumpTo('Index')
  }
}

從上面咱們能夠看到的是經過不一樣的狀態來作不一樣的事情，代碼看起來很是很差看，你們能夠很輕易的提出這段代碼的改寫方案，switch出場：

二、switch/case

/**
 * 按鈕點擊事件
 * @param {number} status 活動狀態：1 開團進行中 2 開團失敗 3 商品售罄 4 開團成功 5 系統取消
 */
const onButtonClick = (status)=>{
  switch (status){
    case 1:
      sendLog('processing')
      jumpTo('IndexPage')
      break
    case 2:
    case 3:
      sendLog('fail')
      jumpTo('FailPage')
      break  
    case 4:
      sendLog('success')
      jumpTo('SuccessPage')
      break
    case 5:
      sendLog('cancel')
      jumpTo('CancelPage')
      break
    default:
      sendLog('other')
      jumpTo('Index')
      break
  }
}

這樣看起來比if/else清晰多了，細心的同窗也發現了小技巧，case 2和case 3邏輯同樣的時候，能夠省去執行語句和break，則case 2的狀況自動執行case 3的邏輯。

三、存放到Object

將判斷條件做爲對象的屬性名，將處理邏輯做爲對象的屬性值，在按鈕點擊的時候，經過對象屬性查找的方式來進行邏輯判斷，這種寫法特別適合一元條件判斷的狀況。

const actions = {
  '1': ['processing','IndexPage'],
  '2': ['fail','FailPage'],
  '3': ['fail','FailPage'],
  '4': ['success','SuccessPage'],
  '5': ['cancel','CancelPage'],
  'default': ['other','Index'],
}
/**
 * 按鈕點擊事件
 * @param {number} status 活動狀態：1開團進行中 2開團失敗 3 商品售罄 4 開團成功 5 系統取消
 */
const onButtonClick = (status)=>{
  let action = actions[status] || actions['default'],
      logName = action[0],
      pageName = action[1]
  sendLog(logName)
  jumpTo(pageName)
}

四、存放到Map

const actions = new Map([
  [1, ['processing','IndexPage']],
  [2, ['fail','FailPage']],
  [3, ['fail','FailPage']],
  [4, ['success','SuccessPage']],
  [5, ['cancel','CancelPage']],
  ['default', ['other','Index']]
])
/**
 * 按鈕點擊事件
 * @param {number} status 活動狀態：1 開團進行中 2 開團失敗 3 商品售罄 4 開團成功 5 系統取消
 */
const onButtonClick = (status)=>{
  let action = actions.get(status) || actions.get('default')
  sendLog(action[0])
  jumpTo(action[1])
}

這樣寫用到了es6裏的Map對象，是否是更爽了？Map對象和Object對象有什麼區別呢？

  1. 一個對象一般都有本身的原型，因此一個對象總有一個"prototype"鍵。
  2. 一個對象的鍵只能是字符串或者Symbols，但一個Map的鍵能夠是任意值。
  3. 你能夠經過size屬性很容易地獲得一個Map的鍵值對個數，而對象的鍵值對個數只能手動確認。

代碼風格

常量大寫

//bad code
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 {}

//better code
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 {}

先聲明後調用

//bad code
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(employee);
review.perfReview();

//better code
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();
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程