规范内容

声明

• 1.1 变量

  对于只在当前作用域下有效的变量，应使用let来代替var 对于全局变量声明，采用var，但应避免声明过多全局变量污染环境

  // 不好
  const variables; 
  const globalObj = null; // 不是定义一个常量
  let globalObj = null; 
  
  for (var i=0; i<5; i++) {
    console.log(i);
  }
  console.log(i);
  
  // 好
  let variables;
  var globalObj = null; 
  
  for (let i=0; i<5; i++) {
    console.log(i);
  }
  console.log(i);
  

• 1.2 常量

  对于常量应使用const进行声明，命名应遵循字母全大写的通俗约定 对于使用 immutable 数据应用const进行声明 注意: const与let只在声明所在的块级作用域内有效

  // 不好
  const someNum = 123;
  const AnotherStr = '不变的字符串';
  let SOME_ARR = ['不','变','数','组'];
  var ANOTHER_OBJ = {
    '不变对象': true
  };
  
  // 好
  const SOME_NUM = 123;
  const ANOTHER_STR = '不变的字符串';
  const SOME_ARR = ['不','变','数','组'];
  const ANOTHER_OBJ = {
    '不变对象': true
  };
  

字符串

• 2.1 模板字符串

  为多行作品，以作品的情况，以作品的情况为代表的标签（`）署名 字符密码，代码更易编写

  // 不好
    const  multiStr  =  '多行字符串换行表示，\\n这是换行了。' ; 
    function  sayHi ( name )  { 
      return  '你好吗，'  +  name  +  '？' ; 
    } 
  
    // 好
    const  multiStr  =  `多行字符串换行表示，
                    这是换行了。` ; 
    function  sayHi ( name )  { 
      return  `你好吗，${ name }？` ; 
    }
  

解构

• 3.1 不能类结构的3类对象层数超过层数

  // 不好
  let obj = {
    'one': [
      { 'newTwo': [
          { 'three': [
              'four': '太多层了，头晕晕'
            ]
          }
        ]
    ]
  };
  
  // 好
  let obj = {
    'one': [
      'two',
      {'twoObj': '结构清晰' }
    ]
  };
  

• 3.2 解构语句中统一不使用圆括号

  // 不好
  [(a)] = [11]; // a未定义
  let { a: (b) } = {}; // 解析出错
  
  // 好
  let [a, b] = [11, 22];
  

• 3.3 对象解构

  对象解构 元素与顺序无关 对象指定默认值时仅对恒等于undefined ( !== null ) 的情况生效

  • 3.3.1 若函数形参为对象时，使用对象解构赋值

    // 不好
    function someFun(opt) {
      let opt1 = opt.opt1;
      let opt2 = opt.opt2;
      console.log(op1);
    }
    
    // 好
    function someFun(opt){
      let {opt1, opt2} = opt;
      console.log( `$(opt1) 加上 $(opt2)` );
    }
    
    function someFun( {opt1, opt2} ){
      console.log(opt1);
    }
    

  • 3.3.2 若函数有多个返回值时，使用对象解构，不使用数组解构，避免添加顺序的问题

    // 不好
    function anotherFun(){
      const one = 1, two = 2, three = 3;
      return [one, two, three];
    }
    
    const [one, three, two] = anotherFun(); // 顺序乱了
    
    // 好
    function anotherFun(){
      const one = 1, two = 2, three = 3;
      return { one, two, three };
    }
    
    const { one, three, two } = anotherFun(); // 不用管顺序
    

  • 3.3.3 已声明的变量不能用于解构赋值（语法错误）

    // 语法错误
    let a;
    {a} = {a: 123};
    

• 3.4 数组解构

  数组元素与顺序相关

  • 3.4.1 交换变量的值

    let x = 1;
    let y = 2;
    
    // 不好
    let temp;
    temp = x;
    x = y;
    y = temp;
    
    // 好
    [x, y] = [y, x]; // 交换变量
    

  • 3.4.2 将数组成员赋值给变量时，使用数组解构

    const arr = [1,2,3,4,5];
    
    // 不好
    const one = arr[0];
    const two = arr[1];
    
    // 好
    const [one, two] = arr;
    

数组

• 4.1 将类数组(array-like)对象与可遍历对象(如Set, Map)转为真正数组

  采用Array.from进行转换

  // 不好
  function foo(){
    let args = Array.prototype.slice.call(arguments);
  }
  
  // 好
  function foo(){
    let args = Array.from(arguments);
  }
  

• 4.2 数组去重

  结合Set结构与Array.from

  // 不好
  // 使用indexOf，HashTable等形式，不够简洁清晰
  
  // 好
  function deduplication(arr){
    return Array.from(new Set(arr));
  }
  

• 4.3 数组拷贝

  采用数组扩展...形式

  const items = [1,2,3];
  
  // 不好
  const len = items.length;
  let copyTemp = [];
  for (let i=0; i<len; i++) {
    copyTemp[i] = items[i];
  }
  
  // 好
  let copyTemp = [...items];
  

• 4.4 将一组数值转为数组

  采用Array.of进行转换

  // 不好
  let arr1 = new Array(2); // [undefined x 2]
  let arr2 = new Array(1,2,3); // [1, 2, 3]
  
  // 好
  let arr1 = Array.of(2);  // [2]
  let arr2 = Array.of(1,2,3); // [1, 2, 3]