js条件语句的优化

你的名字 2022-04-10 12:43 201阅读 0赞

### 1、多重判断，使用Array.includes ###

function test(fruit) {
      if (fruit == 'apple' || fruit == 'strawberry') {
        console.log('red');
      }
    }

当条件过多时，进行优化

function test(fruit) {
      const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries'];
      if (redFruits.includes(fruit)) {
        console.log('red');
      }
    }

### 2.更少的嵌套，尽早 Return ###

function test(fruit, quantity) {
      const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries'];
    
      // 条件 1: fruit 必须有值
      if (fruit) {
        // 条件 2: 必须是red的
        if (redFruits.includes(fruit)) {
          console.log('red');
    
          // 条件 3: quantity大于10
          if (quantity > 10) {
            console.log('big quantity');
          }
        }
      } else {
        throw new Error('No fruit!');
      }
    }

// 测试结果
    test(null); // error: No fruits
    test('apple'); // print: red
    test('apple', 20); // print: red, big quantity

代码弊端

*  1个 if/else 语句筛选出无效的语句
 *  3层if嵌套语句 (条件 1, 2 & 3)

优化：少了一层嵌套语句

function test(fruit, quantity) {
      const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries'];
    
      // 条件 1: 尽早抛出错误
      if (!fruit) throw new Error('No fruit!');
    
      // 条件 2: 必须是红色的
      if (redFruits.includes(fruit)) {
        console.log('red');
    
        // 条件 3: 必须是大质量的
        if (quantity > 10) {
          console.log('big quantity');
        }
      }
    }

优化：通过倒置判断条件2，我们的代码避免了嵌套语句

function test(fruit, quantity) {
      const redFruits = ['apple', 'strawberry', 'cherry', 'cranberries'];
    
      // 条件 1: 尽早抛出错误
      if (!fruit) throw new Error('No fruit!');
      // 条件 2: 当水果不是红色时停止继续执行
      if (!redFruits.includes(fruit)) return; 
    
      console.log('red');
    
      // 条件 3: 必须是大质量的
      if (quantity > 10) {
        console.log('big quantity');
      }
    }

*  代码比较短且直接，包含if嵌套的更清晰
 *  倒置判断条件可能加重思考的负担(增加认知载荷)

### 3.使用默认参数和解构 ###

function test(fruit, quantity) {
      if (!fruit) return;
      // 如果 quantity 参数没有传入，设置默认值为 1
      const q = quantity || 1; 
    
      console.log(`We have ${q} ${fruit}!`);
    }
    
    //test results
    test('banana'); // We have 1 banana!
    test('apple', 2); // We have 2 apple!

优化：通过声明 默认函数参数 来消除变量 q。

function test(fruit, quantity = 1) {
      // 如果 quantity 参数没有传入，设置默认值为 1
      if (!fruit) return;
      console.log(`We have ${quantity} ${fruit}!`);
    }
    
    //test results
    test('banana'); // We have 1 banana!
    test('apple', 2); // We have 2 apple!

function test(fruit = 'unknown', quantity = 1)

例子：fruit是一个object会怎么样？

function test(fruit) { 
      // 当值存在时打印 fruit 的值
      if (fruit && fruit.name)  {
        console.log (fruit.name);
      } else {
        console.log('unknown');
      }
    }
    
    //test results
    test(undefined); // unknown
    test({ }); // unknown
    test({ name: 'apple', color: 'red' }); // apple

优化：

// 为其赋默认值为空对象

function test({name} = {}) {
      console.log (name || 'unknown');
    }
    
    // test results
    test(undefined); // unknown
    test({ }); // unknown
    test({ name: 'apple', color: 'red' }); // apple

优化：

*  使用 Lodash get函数
 *  使用Facebook开源的idx库(with Babeljs)

使用Lodash的例子:

function test(fruit) {
      // 获取属性名，如果属性名不可用，赋默认值为 unknown
      console.log(__.get(fruit, 'name', 'unknown'); 
    }
    
    // test results
    test(undefined); // unknown
    test({ }); // unknown
    test({ name: 'apple', color: 'red' }); // apple

### 4.倾向于对象遍历而不是Switch语句 ###

function test(color) {
      // 使用条件语句来寻找对应颜色的水果
      switch (color) {
        case 'red':
          return ['apple', 'strawberry'];
        case 'yellow':
          return ['banana', 'pineapple'];
        case 'purple':
          return ['grape', 'plum'];
        default:
          return [];
      }
    }
    
    // test results
    test(null); // []
    test('yellow'); // ['banana', 'pineapple']

优化：对象遍历实现相同的结果，语法看起来更简洁:

const fruitColor = {
      red: ['apple', 'strawberry'],
      yellow: ['banana', 'pineapple'],
      purple: ['grape', 'plum']
    };
    
    function test(color) {
      return fruitColor[color] || [];
    }

优化2：使用 Map实现相同的结果:

const fruitColor = new Map()
        .set('red', ['apple', 'strawberry'])
        .set('yellow', ['banana', 'pineapple'])
        .set('purple', ['grape', 'plum']);
    
    function test(color) {
      return fruitColor.get(color) || [];
    }

优化3：TL;DR; 重构语法--》Array.filter 重构我们的代码

const fruits = [
        { name: 'apple', color: 'red' }, 
        { name: 'strawberry', color: 'red' }, 
        { name: 'banana', color: 'yellow' }, 
        { name: 'pineapple', color: 'yellow' }, 
        { name: 'grape', color: 'purple' }, 
        { name: 'plum', color: 'purple' }
    ];
    
    function test(color) {
      return fruits.filter(f => f.color == color);
    }

### 5.对 所有/部分 判断使用Array.every & Array.some ###

const fruits = [
        { name: 'apple', color: 'red' },
        { name: 'banana', color: 'yellow' },
        { name: 'grape', color: 'purple' }
      ];
    
    function test() {
      let isAllRed = true;
    
      // 条件：所有水果都是红色
      for (let f of fruits) {
        if (!isAllRed) break;
        isAllRed = (f.color == 'red');
      }
    
      console.log(isAllRed); // false
    }

const fruits = [
        { name: 'apple', color: 'red' },
        { name: 'banana', color: 'yellow' },
        { name: 'grape', color: 'purple' }
      ];
    
    function test() {
      const isAllRed = fruits.every(f => f.color == 'red');
    
      console.log(isAllRed); // false
    }

const fruits = [
        { name: 'apple', color: 'red' },
        { name: 'banana', color: 'yellow' },
        { name: 'grape', color: 'purple' }
    ];
    
    function test() {
      // 条件：任何一个水果是红色
      const isAnyRed = fruits.some(f => f.color == 'red');
    
      console.log(isAnyRed); // true
    }