原网址 :  https://segmentfault.com/a/1190000013040555

类型

  1. 基本类型:直接存取

    • string
    • number
    • boolean
    • null
    • undefined
    • symbol
    const foo = 1;
    let bar = foo; bar = 9; console.log(foo, bar); // => 1, 9
    • symbol 类型不能完全polyfilled,所以请谨慎使用
  2. 复杂类型: 通过引用的方式存取

    • object
    • array
    • function
    const foo = [1, 2];
    const bar = foo; bar[0] = 9; console.log(foo[0], bar[0]); // => 9, 9

引用

  1. 使用const申明引用类型,避免使用var。eslint 设置:prefer-const,no-const-assign

    为什么?这能确保你无法对引用重新赋值,也不会导致出现 bug 或难以理解。

    // bad
    var a = 1;
    var b = 2; // good
    const a = 1;
    const b = 2;
  2. 如果必须对引用类型重新赋值,使用let而非var。eslint设置:no-var jscs: disallowVar

    为什么?相比于var函数作用域,let块级作用域更容易理解

    // bad
    var count = 1;
    if (true) {
    count += 1;
    } // good, use the let.
    let count = 1;
    if (true) {
    count += 1;
    }
  3. 注意letconst都是块级作用域

    // const and let only exist in the blocks they are defined in.
    {
    let a = 1;
    const b = 1;
    }
    console.log(a); // ReferenceError
    console.log(b); // ReferenceError

对象

  1. 使用字面值创建对象。eslint: no-new-object

    // bad
    const item = new Object(); // good
    const item = {};
  2. 创建对象的动态属性时,使用计算属性

    为什么?这样可以在一个地方定义对象所有的属性

    function getKey(k) {
    return `a key named ${k}`;
    } // bad
    const obj = {
    id: 5,
    name: 'San Francisco',
    };
    obj[getKey('enabled')] = true; // good
    const obj = {
    id: 5,
  [getKey('enabled')]: true,
};
```
  1. 使用对象方法的简写形式。 eslint: object-shorthand jscs: requireEnhancedObjectLiterals

    为什么?方法定义简洁清晰

    // bad
    const atom = {
    value: 1, addValue: function (value) {
    return atom.value + value;
    },
    }; // good
    const atom = {
    value: 1, addValue(value) {
    return atom.value + value;
    },
    };
  2. 使用属性值简写形式。eslint: object-shorthand jscs: [requireEnhancedObjectLiterals]

    为什么?书写更加简洁,更有描述性。

    const lukeSkywalker = 'Luke Skywalker';
    
    // bad
    const obj = {
    lukeSkywalker: lukeSkywalker,
    }; // good
    const obj = {
    lukeSkywalker,
    };
  3. 对象声明时分类简写和非简写的属性名。

    为什么?更清晰的了解哪些属性是简写的。

    const anakinSkywalker = 'Anakin Skywalker';
    const lukeSkywalker = 'Luke Skywalker'; // bad
    const obj = {
    episodeOne: 1,
    twoJediWalkIntoACantina: 2,
    lukeSkywalker,
    episodeThree: 3,
    mayTheFourth: 4,
    anakinSkywalker,
    }; // good
    const obj = {
    lukeSkywalker,
    anakinSkywalker,
    episodeOne: 1,
    twoJediWalkIntoACantina: 2,
    episodeThree: 3,
    mayTheFourth: 4,
    };
  4. 只有对那些不合法的属性名标识符添加引号。eslint: quote-props jscs: disallowQuotedKeysInObjects

    为什么?对象属性更直观,可读性强。能够代码高亮显示,同时对于大多数的js引擎更容易优化代码。

    // bad
    const bad = {
    'foo': 3,
    'bar': 4,
    'data-blah': 5,
    }; // good
    const good = {
    foo: 3,
    bar: 4,
    'data-blah': 5,
    };
  5. 不要直接使用Object.prototype上的方法,例如hasOwnPropertypropertyIsEnumerable, 和 isPrototypeOf

    为什么?这些方法可能受对象的其他属性影响。例如{ hasOwnProperty: false } 或者 对象可能是null(Object.create(null))

    // bad
    console.log(object.hasOwnProperty(key)); const object = Object.create(null);
    obj.hasOwnProperty(key) // Uncaught TypeError: obj.hasOwnProperty is not a function // good
    console.log(Object.prototype.hasOwnProperty.call(object, key)); // best
    const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
    /* or */
    import has from 'has'; // https://www.npmjs.com/package/has
    // ...
    console.log(has.call(object, key));
  6. 浅拷贝对象时推荐使用对象展开操作(object spread operator)而不是Object.assign。使用对象剩余操作符(object rest operator)获取对象中剩余的属性。

    为什么?Object.assign使用不当会修改原对象

    // very bad
    const original = { a: 1, b: 2 };
    const copy = Object.assign(original, { c: 3 }); // this mutates `original` ಠ_ಠ
    delete copy.a; // so does this // bad
    const original = { a: 1, b: 2 };
    const copy = Object.assign({}, original, { c: 3 }); // copy => { a: 1, b: 2, c: 3 } // good
    const original = { a: 1, b: 2 };
    const copy = { ...original, c: 3 }; // copy => { a: 1, b: 2, c: 3 } const { a, ...noA } = copy; // noA => { b: 2, c: 3 }

数组

  1. 使用字面量声明数组。eslint: no-array-constructor

    // bad
    const items = new Array(); // good
    const items = [];
  2. 向数组添加元素时,使用Arrary#push替代直接赋值。

    const someStack = [];
    
    // bad
    someStack[someStack.length] = 'abracadabra'; // good
    someStack.push('abracadabra');
  3. 使用数组展开操作符...拷贝数组

    // bad
    const len = items.length;
    const itemsCopy = [];
    let i; for (i = 0; i < len; i += 1) {
    itemsCopy[i] = items[i];
    } // good
    const itemsCopy = [...items];
  4. 将类数组对象(array-like)转换成数组时,使用...而不是Array.from

    const foo = document.querySelectorAll('.foo');
    
    // good
    const nodes = Array.from(foo); // best
    const nodes = [...foo];
  5. 当需要对可遍历对象进行map操作时,使用Array.from而不是展开操作符...,避免新建一个临时数组。

    // bad
    const baz = [...foo].map(bar); // good
    const baz = Array.from(foo, bar);
  6. 数组方法回调需要有返回值。如果函数体比较简单,可以直接用表达式,省略return语句。 eslint: array-callback-return

    // good
    [1, 2, 3].map((x) => {
    const y = x + 1;
    return x * y;
    }); // good
    [1, 2, 3].map(x => x + 1); // bad - no returned value means `memo` becomes undefined after the first iteration
    [[0, 1], [2, 3], [4, 5]].reduce((memo, item, index) => {
    const flatten = memo.concat(item);
    memo[index] = flatten;
    }); // good
    [[0, 1], [2, 3], [4, 5]].reduce((memo, item, index) => {
    const flatten = memo.concat(item);
    memo[index] = flatten;
    return flatten;
    }); // bad
    inbox.filter((msg) => {
    const { subject, author } = msg;
    if (subject === 'Mockingbird') {
    return author === 'Harper Lee';
    } else {
    return false;
    }
    }); // good
    inbox.filter((msg) => {
    const { subject, author } = msg;
    if (subject === 'Mockingbird') {
    return author === 'Harper Lee';
    } return false;
    });
  7. 如果数组有多行,请在打开和关闭数组括号之前使用换行符

    为什么? 更具有可读性

    // bad
    const arr = [
    [0, 1], [2, 3], [4, 5],
    ]; const objectInArray = [{
    id: 1,
    }, {
    id: 2,
    }]; const numberInArray = [
    1, 2,
    ]; // good
    const arr = [[0, 1], [2, 3], [4, 5]]; const objectInArray = [
    {
    id: 1,
    },
    {
    id: 2,
    },
    ]; const numberInArray = [
    1,
    2,
    ];

解构

  1. 访问和使用对象的多个属性时用对象解构操作。eslint: prefer-destructuring jscs: requireObjectDestructuring

    为什么?解构可以避免为这些属性创建临时引用。

    // bad
    function getFullName(user) {
    const firstName = user.firstName;
    const lastName = user.lastName; return `${firstName} ${lastName}`;
    } // good
    function getFullName(user) {
    const { firstName, lastName } = user;
    return `${firstName} ${lastName}`;
    } // best
    function getFullName({ firstName, lastName }) {
    return `${firstName} ${lastName}`;
    }
  2. 使用数组解构。eslint: prefer-destructuring jscs: requireArrayDestructuring

    const arr = [1, 2, 3, 4];
    
    // bad
    const first = arr[0];
    const second = arr[1]; // good
    const [first, second] = arr;
  3. 使用对象解构来实现多个返回值,而不是数组解构。jscs: disallowArrayDestructuringReturn

    为什么?你可以随时为返回值新增属性而不用关心属性的顺序。

    // bad
    function processInput(input) {
    // then a miracle occurs
    return [left, right, top, bottom];
    } // 调用者需要注意返回值中对象的顺序
    const [left, __, top] = processInput(input); // good
    function processInput(input) {
    // then a miracle occurs
    return { left, right, top, bottom };
    } // 调用者只需要使用它需要的对象
    const { left, top } = processInput(input);

字符串

  1. 字符串使用单引号。eslint: quotes jscs: validateQuoteMarks

    // bad
    const name = "Capt. Janeway"; // bad - 当需要插值或者换行时才使用模板文字
    const name = `Capt. Janeway`; // good
    const name = 'Capt. Janeway';
  2. 不超过100个字符的字符串不应该使用连接符或者换行书写。

    为什么?换行的字符串不好阅读,并且不方便搜索代码。

    // bad
    const errorMessage = 'This is a super long error that was thrown because \
    of Batman. When you stop to think about how Batman had anything to do \
    with this, you would get nowhere \
    fast.'; // bad
    const errorMessage = 'This is a super long error that was thrown because ' +
    'of Batman. When you stop to think about how Batman had anything to do ' +
    'with this, you would get nowhere fast.'; // good
    const errorMessage = 'This is a super long error that was thrown because of Batman. When you stop to think about how Batman had anything to do with this, you would get nowhere fast.';
  3. 以编程方式构建字符串时,使用模板字符串而不是连接符。eslint: prefer-template template-curly-spacing jscs: requireTemplateStrings

    为什么?模板字符串更为简洁,更具可读性。

    // bad
    function sayHi(name) {
    return 'How are you, ' + name + '?';
    } // bad
    function sayHi(name) {
    return ['How are you, ', name, '?'].join();
    } // bad
    function sayHi(name) {
    return `How are you, ${ name }?`;
    } // good
    function sayHi(name) {
    return `How are you, ${name}?`;
    }
  4. 永远不要在字符串上使用eval()方法,它有太多的问题。eslint: no-eval
  5. 不要过多的转义字符串。eslint: no-useless-escape

    为什么?反斜杠影响代码可读性,只有在必要的时候才使用。

    // bad
    const foo = '\'this\' \i\s \"quoted\"'; // good
    const foo = '\'this\' is "quoted"';
    const foo = `my name is '${name}'`;

函数

  1. 使用命名函数表达式而不是函数声明。eslint: func-style jscs: disallowFunctionDeclarations

    为什么?函数声明会被提前。这意味着很可能在函数定义前引用该函数,但是不会报错。这不利于代码的可读性和可维护性。如果你发现一个函数定义的很大很复杂,以至于妨碍了了解文件中的其他内容,那么是时候把这个函数提取到自己的模块中去了!不要忘记显示指定表达式的名称,尽管它能从变量名中被推断出来(现代浏览器或者编译器(如Babel)支持)。这能让错误的调用栈更清晰。(讨论)

    // bad
    function foo() {
    // ...
    } // bad
    const foo = function () {
    // ...
    }; // good
    // 函数名和变量引用名不同
    const short = function longUniqueMoreDescriptiveLexicalFoo() {
    // ...
    };
    // Is it worse
    const sum = function(a, b) {
    return a + b;
    }; // than this?
    const my_sum = function sum(a, b) {
    return a + b;
    };

    第一个函数没有.name属性,在debugging过程中,它会是一个匿名函数。第二个函数有名字为sum,你可以检索到它,调试过程中能够快速定位。

    使用banel 和babel-preset-env配置,const foo = () => {}会转换成var foo = function foo () {},并且从Node v6开始,const foo = () => {}中的foo 也有.name。所以它不再是匿名函数。(函数名字推断)

  2. 用圆括号包裹立即执行函数表达式(IIFE)。eslint: wrap-iife jscs: requireParenthesesAroundIIFE

    为什么? 立即执行函数表达式是单一执行单元-使用圆括号包裹调用,简洁明了的表示了这一点。请注意,在通用的模块中,你几乎用不到IIFE。

    // immediately-invoked function expression (IIFE)
    (function () {
    console.log('Welcome to the Internet. Please follow me.');
    }());
  3. 永远不要在一个非函数代码块(if、while 等)中声明一个函数,把那个函数赋给一个变量。浏览器允许你这么做,但它们的解析表现不一致。eslint: no-loop-func
  4. 注意:ECMA-262把block定义为一组语句。但是函数声明不是语句。

    // bad
    if (currentUser) {
    function test() {
    console.log('Nope.');
    }
    } // good
    let test;
    if (currentUser) {
    test = () => {
    console.log('Yup.');
    };
    }
  5. 永远不要把参数命名为arguments。这将取代原来函数作用域内的 arguments对象。

    // bad
    function foo(name, options, arguments) {
    // ...
    } // good
    function foo(name, options, args) {
    // ...
    }
  6. 不要使用arguments。可以选择 rest 语法 ... 替代。

    为什么?使用 ... 能明确你要传入的参数。另外 rest 参数是一个真正的数组,而 arguments 是一个类数组。

    // bad
    function concatenateAll() {
    const args = Array.prototype.slice.call(arguments);
    return args.join('');
    } // good
    function concatenateAll(...args) {
    return args.join('');
    }
  7. 使用函数默认参数指定默认值,而不是用一个可变的函数参数

    // really bad
    function handleThings(opts) {
    // 不!我们不应该改变函数参数
    // 更糟糕的是: 如果 opts 是 falsy (为''或者是false), 它仍然会被赋值为对象,但是这可能会引发bug
    opts = opts || {};
    // ...
    } // still bad
    function handleThings(opts) {
    if (opts === void 0) {
    opts = {};
    }
    // ...
    } // good
    function handleThings(opts = {}) {
    // ...
    }

8.使用函数参数默认值的时避免副作用。

> 为什么?这样的写法会让人困惑。

```javascript
var b = 1;
// bad
function count(a = b++) {
console.log(a);
}
count(); // 1
count(); // 2
count(3); // 3
count(); // 3
```
  1. 参数默认值放在函数参数列表的最后。

    // bad
    function handleThings(opts = {}, name) {
    // ...
    } // good
    function handleThings(name, opts = {}) {
    // ...
    }
  2. 不要使用Function构造器创建函数。 eslint: no-new-func

    为什么?通过这种方式创建的函数和使用eval()类似,会带来不确定的问题

    // bad
    var add = new Function('a', 'b', 'return a + b'); // still bad
    var subtract = Function('a', 'b', 'return a - b');
  3. 函数名两边留白。eslint: space-before-function-paren [space-before-blocks]

    为什么?保持代码一致性,当你添加或者删除名字时不需要额外增减空格。

    // bad
    const f = function(){};
    const g = function (){};
    const h = function() {}; // good
    const x = function () {};
    const y = function a() {};
  4. 不要修改参数。 eslint: no-param-reassign

    为什么?操作参数对象会在原始调用方中导致不可预知的变量副作用。

    // bad
    function f1(obj) {
    obj.key = 1;
    } // good
    function f2(obj) {
    const key = Object.prototype.hasOwnProperty.call(obj, 'key') ? obj.key : 1;
    }
  5. 不要给参数赋值。eslint: no-param-reassign

    为什么?重新分配参数可能会导致意外的行为,特别是在访问参数对象时。 它也可能导致优化问题,特别是在V8中。

    // bad
    function f1(a) {
    a = 1;
    // ...
    } function f2(a) {
    if (!a) { a = 1; }
    // ...
    } // good
    function f3(a) {
    const b = a || 1;
    // ...
    } function f4(a = 1) {
    // ...
    }
  6. 使用展开操作符...调用可变参数函数。eslint: prefer-spread

    为什么?它更简洁,你不需要提供上下文,并且组合使用newapply不容易。

    // bad
    const x = [1, 2, 3, 4, 5];
    console.log.apply(console, x); // good
    const x = [1, 2, 3, 4, 5];
    console.log(...x); // bad
    new (Function.prototype.bind.apply(Date, [null, 2016, 8, 5])); // good
    new Date(...[2016, 8, 5]);
  7. 带有多行函数签名或调用的函数应该像本指南中的其他多行列表一样缩进:每行中包含一项,最后一个项目带有逗号。

    // bad
    function foo(bar,
    baz,
    quux) {
    // ...
    } // good
    function foo(
    bar,
    baz,
    quux,
    ) {
    // ...
    } // bad
    console.log(foo,
    bar,
    baz); // good
    console.log(
    foo,
    bar,
    baz,
    );

箭头函数

  1. 当你必须要使用匿名函数(如在传递内联回调时),请使用箭头函数。eslint: prefer-arrow-callbackarrow-spacingjscs: requireArrowFunctions

    为什么?因为箭头函数创造了新的一个 this 执行环境,通常情况下都能满足你的需求,而且这样的写法更为简洁。(参考 Arrow functions - JavaScript | MDN )

    为什么不?如果你有一个相当复杂的函数,你或许可以把逻辑部分转移到一个函数声明上。

    // bad
    [1, 2, 3].map(function (x) {
    const y = x + 1;
    return x * y;
    }); // good
    [1, 2, 3].map((x) => {
    const y = x + 1;
    return x * y;
    });
  2. 如果一个函数适合用一行写出并且只有一个参数,那就把花括号、圆括号和 return 都省略掉。如果不是,那就不要省略。eslint: arrow-parensarrow-body-style jscs: disallowParenthesesAroundArrowParamrequireShorthandArrowFunctions

    为什么?这是一个很好用的语法糖。在链式调用中可读性很高。

    // bad
    [1, 2, 3].map(number => {
    const nextNumber = number + 1;
    `A string containing the ${nextNumber}.`;
    }); // good
    [1, 2, 3].map(number => `A string containing the ${number}.`); // good
    [1, 2, 3].map((number) => {
    const nextNumber = number + 1;
    return `A string containing the ${nextNumber}.`;
    }); // good
  [index]: number,
})); // No implicit return with side effects
function foo(callback) {
const val = callback();
if (val === true) {
// Do something if callback returns true
}
} let bool = false; // bad
foo(() => bool = true); // good
foo(() => {
bool = true;
});
```
  1. 如果表达式过长需要多行表示,请将其包含在括号中,增加可读性。

    为什么?它能清除的标识函数的开始和结束位置。

    // bad
    ['get', 'post', 'put'].map(httpMethod => Object.prototype.hasOwnProperty.call(
    httpMagicObjectWithAVeryLongName,
    httpMethod,
    )
    ); // good
    ['get', 'post', 'put'].map(httpMethod => (
    Object.prototype.hasOwnProperty.call(
    httpMagicObjectWithAVeryLongName,
    httpMethod,
    )
    ));
  2. 如果函数只有一个参数并且函数体没有使用花括号,那就省略括号。否则,为了保持清晰一致性,总在参数周围加上括号。总是使用括号也是可以接受的,在这种情况下使用eslint的 “always” option 或者不要在jscs中引入 disallowParenthesesAroundArrowParam。eslint: arrow-parens jscs: disallowParenthesesAroundArrowParam

    为什么? 不那么混乱,可读性强。

    // bad
    [1, 2, 3].map((x) => x * x); // good
    [1, 2, 3].map(x => x * x); // good
    [1, 2, 3].map(number => (
    `A long string with the ${number}. It’s so long that we don’t want it to take up space on the .map line!`
    )); // bad
    [1, 2, 3].map(x => {
    const y = x + 1;
    return x * y;
    }); // good
    [1, 2, 3].map((x) => {
    const y = x + 1;
    return x * y;
    });
  3. 避免箭头函数语法(=>)和比较运算符(<=,=>)一起使用时带来的困惑。

    // bad
    const itemHeight = item => item.height > 256 ? item.largeSize : item.smallSize; // bad
    const itemHeight = (item) => item.height > 256 ? item.largeSize : item.smallSize; // good
    const itemHeight = item => (item.height > 256 ? item.largeSize : item.smallSize); // good
    const itemHeight = (item) => {
    const { height, largeSize, smallSize } = item;
    return height > 256 ? largeSize : smallSize;
    };

类 & 构造函数

  1. 总是使用class。避免直接操作prototype

    为什么?class语法更简洁更易于理解。

    // bad
    function Queue(contents = []) {
    this.queue = [...contents];
    }
    Queue.prototype.pop = function () {
    const value = this.queue[0];
    this.queue.splice(0, 1);
    return value;
    }; // good
    class Queue {
    constructor(contents = []) {
    this.queue = [...contents];
    }
    pop() {
    const value = this.queue[0];
    this.queue.splice(0, 1);
    return value;
    }
    }
  2. 使用extends继承。

    为什么? 因为 extends 是一个内建的原型继承方法并且不会破坏 instanceof。

    // bad
    const inherits = require('inherits');
    function PeekableQueue(contents) {
    Queue.apply(this, contents);
    }
    inherits(PeekableQueue, Queue);
    PeekableQueue.prototype.peek = function () {
    return this.queue[0];
    }; // good
    class PeekableQueue extends Queue {
    peek() {
    return this.queue[0];
    }
    }
  3. 方法可以返回 this 来帮助链式调用。

    // bad
    Jedi.prototype.jump = function () {
    this.jumping = true;
    return true;
    }; Jedi.prototype.setHeight = function (height) {
    this.height = height;
    }; const luke = new Jedi();
    luke.jump(); // => true
    luke.setHeight(20); // => undefined // good
    class Jedi {
    jump() {
    this.jumping = true;
    return this;
    } setHeight(height) {
    this.height = height;
    return this;
    }
    } const luke = new Jedi(); luke.jump()
    .setHeight(20);
  4. 可以写一个自定义的 toString() 方法,但要确保它能正常运行并且不会引起副作用。

    class Jedi {
    constructor(options = {}) {
    this.name = options.name || 'no name';
    } getName() {
    return this.name;
    } toString() {
    return `Jedi - ${this.getName()}`;
    }
    }
  5. 类有默认构造器。一个空的构造函数或者只是重载父类构造函数是不必要的。eslint: no-useless-constructor

    // bad
    class Jedi {
    constructor() {} getName() {
    return this.name;
    }
    } // bad
    class Rey extends Jedi {
    constructor(...args) {
    super(...args);
    }
    } // good
    class Rey extends Jedi {
    constructor(...args) {
    super(...args);
    this.name = 'Rey';
    }
    }
  6. 避免重复的类成员。eslint: no-dupe-class-members

    为什么?重复的类成员声明中只有最后一个生效-重复的声明肯定是一个错误。

    // bad
    class Foo {
    bar() { return 1; }
    bar() { return 2; }
    } // good
    class Foo {
    bar() { return 1; }
    } // good
    class Foo {
    bar() { return 2; }
    }

模块

  1. 总是使用模组 (import/export) 而不是其他非标准模块系统。你可以编译为你喜欢的模块系统。

    为什么?模块是未来,让我们开始迈向未来吧。

    // bad
    const AirbnbStyleGuide = require('./AirbnbStyleGuide');
    module.exports = AirbnbStyleGuide.es6; // ok
    import AirbnbStyleGuide from './AirbnbStyleGuide';
    export default AirbnbStyleGuide.es6; // best
    import { es6 } from './AirbnbStyleGuide';
    export default es6;
  2. 不要使用通配符 import

    为什么?这样确保只有一个默认的export

    // bad
    import * as AirbnbStyleGuide from './AirbnbStyleGuide'; // good
    import AirbnbStyleGuide from './AirbnbStyleGuide';
  3. 不要直接从importexport

    为什么?虽然一行代码简洁明了,但让 import 和 export 各司其职让事情能保持一致。

    // bad
    // filename es6.js
    export { es6 as default } from './AirbnbStyleGuide'; // good
    // filename es6.js
    import { es6 } from './AirbnbStyleGuide';
    export default es6;
  4. 同一个路径只使用一次import。eslint: no-duplicate-imports

    为什么?相同路径有多个import会导致代码难以维护。

    // bad
    import foo from 'foo';
    // … some other imports … //
    import { named1, named2 } from 'foo'; // good
    import foo, { named1, named2 } from 'foo'; // good
    import foo, {
    named1,
    named2,
    } from 'foo';
  5. 不要export可变的绑定。 eslint: import/no-mutable-exports

    为什么?避免不确定的可变量,特别是export可变的绑定。如果某些特殊情况需要使用这种场景,通常应该export常量引用。

    // bad
    let foo = 3;
    export { foo }; // good
    const foo = 3;
    export { foo };
  6. 模块中只有单个export,最好使用default export 。 eslint: import/prefer-default-export

    为什么?一个文件最好只做一件事,这样更具备可读性和可维护性。

    // bad
    export function foo() {} // good
    export default function foo() {}
  7. 将所有的import语句放在文件的顶部。eslint: import/first

    为什么?由于imports会被提升,最好保持它们在顶部以防出现不可预期的行为。

    // bad
    import foo from 'foo';
    foo.init(); import bar from 'bar'; // good
    import foo from 'foo';
    import bar from 'bar'; foo.init();
  8. 多行import应该和多行数组和对象一样有缩进。

    为什么?花括号需要遵循与指南中的每个其他花括号相同的缩进规则,末尾的逗号也一样。

    // bad
    import {longNameA, longNameB, longNameC, longNameD, longNameE} from 'path'; // good
    import {
    longNameA,
    longNameB,
    longNameC,
    longNameD,
    longNameE,
    } from 'path';
  9. 禁止在模块导入语句中使用Webpack加载器语法。eslint: import/no-webpack-loader-syntax

    为什么?在import中使用webpack 语法会将代码耦合进bundler中。推荐在webpack.config.js中配置loader 规则。

    // bad
    import fooSass from 'css!sass!foo.scss';
    import barCss from 'style!css!bar.css'; // good
    import fooSass from 'foo.scss';
    import barCss from 'bar.css';

Airbnb JavaScript 编码风格指南(2018年最新版)的更多相关文章

  1. JavaScript编码风格指南(中文版)

    前言: 程序语言的编码风格对于一个长期维护的软件非常重要,特别是在团队协作中.如果一个团队使用统一规范的编码分风格,可以提高团队的协作水平和工作效率.编程风格指南的核心是基本的格式化规则,这些规则决定 ...

  2. 《编写可维护的 Javascript》读书笔记(附录 A 部分):Javascript 编码风格指南(1)原始值

    记录一下比较有用的编码规范(该指南是基于 Java 语言编码规范和 Javascript 编程规范,同时结合作者 Nicholos Zakas 的个人经验和喜好). 一些关于格式(包括缩进.行的长度. ...

  3. JavaScript 编码风格指南

    A.1  缩进 // 4个空格的层级缩进 if (true) { doSomething(); } A.2  行的长度 // 每行限于80个字符,超出则在运算符后换行,缩进2个层级(8个空格) doS ...

  4. JavaScript编码规范指南

    前言 本文摘自Google JavaScript编码规范指南,截取了其中比较容易理解与遵循的点作为团队的JavaScript编码规范. JavaScript 语言规范 变量 声明变量必须加上 var  ...

  5. 一些达成共识的JavaScript编码风格约定

    如果你的代码易于阅读,那么代码中bug也将会很少,因为一些bug可以很容被调试,并且,其他开发者参与你项目时的门槛也会比较低.因此,如果项目中有多人参与,采取一个有共识的编码风格约定非常有必要.与其他 ...

  6. 一些达成共识的JavaScript编码风格约定【转】

    如果你的代码易于阅读,那么代码中bug也将会很少,因为一些bug可以很容被调试,并且,其他开发者参与你项目时的门槛也会比较低.因此,如果项目中有多人参与,采取一个有共识的编码风格约定非常有必要.与其他 ...

  7. R 语言编码风格指南

    R 语言是一门主要用于统计计算和绘图的高级编程语言.这份 R 语言编码风格指南旨在让我们的 R代码更容易阅读.分享和检查.以下规则系与 Google 的 R 用户群体协同设计而成. 概要: R编码风格 ...

  8. 来自 Google 的 R 语言编码风格指南

    来自 Google 的 R 语言编码风格指南R 语言是一门主要用于统计计算和绘图的高级编程语言. 这份 R 语言编码风格指南旨在让我们的 R 代码更容易阅读.分享和检查. 以下规则系与 Google ...

  9. Objective-C 编码风格指南

    本文转自:[Objective-C 编码风格指南 | www.samirchen.com][2] ## 背景 保证自己的代码遵循团队统一的编码规范是一个码农的基本节操,能够进入一个有统一编码规范的团队 ...

随机推荐

  1. 【学习心得】Link-cut Tree

    Link-cut Tree是一种支持改变树(森林)的形态(link和cut),同时维护树的路径上节点信息的数据结构.lct通过splay来维护每次的perferred path,说白了就是一个动态的树 ...

  2. Nginx与Lua开发

    1.Lua及基础语法 Nginx与Lua环境 场景:用Nginx结合Lua实现代码的灰度发布 1.Lua 是一个简洁.轻量.可扩展的脚本语言 2.Nginx+Lua优势 充分的结合Nginx的并发处理 ...

  3. Java数据结构之排序---冒泡排序

    冒泡排序的基本思想: 通过对待排序序列从前到后(从下标小的元素开始),依次比较相邻位置的元素的值,若发现与给定的次序冲突,则交换位置(假设数值大的数放在序列的后面),使数值较大的元素逐渐从前移动到后部 ...

  4. git本地文件提交

    一.github在线上传文件夹 1.点击上传文件 2 .直接拖拽 直接拖拽即可上传文件夹及文件夹里面的文件.如果点击 choose your files 就只能上传单个文件. 二.通过git工具上传本 ...

  5. 关闭Linux无用端口

    关闭系统不必要的端口,增强系统安全,此处以关闭111端口为例进行说明. 1).查看本机正在监听的端口: [root@b ~]# netstat -tlnup Active Internet conne ...

  6. ORACLE动态监听

    动态监听的原理 pmon在数据库启动到mount或open时,动态从参数文件中读取service_names值.service_names可以为多值(可以有64个,其中包括两个系统的).  servi ...

  7. P1058立体图

    一道大模拟 思路: 首先是打表找规律时间 仔细思考(暴力手算)后推出这么一个数组: //宽的增加量 ]={,,,};//1竖着摞,2横着摞,3前后摞 //长的增加量 ]={,,,};//1竖着摞,2横 ...

  8. 算法所产生的性能改进已经超过了硬件所带来的性能提升 The future is algorithms, not code

    w 大数据的发展,伴随的将是软件工程师的渐退,算法工程师的崛起  http://mp.weixin.qq.com/s/XTz2HnzwlgTD3g5zU2u5Tg

  9. http://bbs.csdn.net/topics/340046630 dbgrid怎么获取当前记录值

    这根grid无关,当你选中一条记录时,数据集就定位到这条数据上了,你只需要读取数据集中的数据就行了   对我有用[0] 丢个板砖[0] 引用 | 举报| 管理 hongss hongss 本版等级: ...

  10. WordPress致命错误 紧急处理代码

    将下面代码添加到当前主题函数模板 functions.php 中: dadd_filter( 'wp_fatal_error_handler_enabled', '__return_false' );