美文网首页
ECMAScript 6 编码规约

ECMAScript 6 编码规约

作者: 勇往直前888 | 来源:发表于2018-05-10 15:03 被阅读12次

定义

ECMAScript 6（以下简称 ES6）是 JavaScript 语言的下一代标准，ES6 的第一个版本，就这样在 2015 年 6 月发布了，正式名称就是《ECMAScript 2015 标准》（简称 ES2015）。2016 年 6 月，小幅修订的《ECMAScript 2016 标准》（简称 ES2016）如期发布，这个版本可以看作是 ES6.1 版，因为两者的差异非常小（只新增了数组实例的 includes 方法和指数运算符），因此，ES6 是一个泛指， 含义是 5.1 版以后的 JavaScript 的下一代标准，涵盖了 ES2015、ES2016 等，而 ES2015 则是正式名称，特指该年发布的正式版本的语言标准。

规则

变量

  • 【强制】 使用 let 或者 const 代替 var
// Bad
var x = 'y';
var CONFIG = {};

// Good
let x = 'y';
const CONFIG = {};
  • 【强制】 禁止修改被定义为 const 类型的变量
// Bad
const a = 0;
a = 1;

const a = 0;
a += 1;

const a = 0;
++a;

for (const a in [1, 2, 3]) {
  // `a` is re-defined (not modified) on each loop step.
  console.log(a);
}

for (const a of [1, 2, 3]) {
  // `a` is re-defined (not modified) on each loop step.
  console.log(a);
}
  • 【推荐】 定义变量应在你需要它的时候，并放在合理的地方 参考 *解释：let、const是块级作用域而非函数作用域
// bad - unnecessary function call
function checkName(hasName) {
  const name = getName();

  if (hasName === 'test') {
    return false;
  }

  if (name === 'test') {
    this.setName('');
    return false;
  }

  return name;
}

// good
function checkName(hasName) {
  if (hasName === 'test') {
    return false;
  }

  const name = getName();

  if (name === 'test') {
    this.setName('');
    return false;
  }

  return name;
}
  • 【推荐】 如果变量值未被修改，建议使用 const 来定义变量
// Normal
let a = 3;

// Good
const a = 3;
  • 【推荐】 引用类型建议使用 const 定义
// Bad
const a = { b: 1 };
a = {};

// Bad
let c = { d: 1 };
c.d = 2;

// Good
const e = { f: 1 };
e.f = 2;

字符串

  • 【推荐】 建议使用字符串模板替换字符串链接
// Normal
var str = 'Hello, ' + name + '!';
var str = 'Time: ' + 12 * 60 * 60 * 1000;

// Good
var str = 'Hello World!';
var str = `Hello, ${name}!`;
var str = `Time: ${12 * 60 * 60 * 1000}`;

对象

  • 【强制】 禁止对象上的键值进行不必要的计算
// Bad
var foo = { ['a']: 'b' };

// Good
var foo = { a: 'b' };
  • 【推荐】 使用更加简洁的字面量
// Normal
var foo = {
  x: x,
  y: y,
  z: z
};

var foo = {
  a: function() {},
  b: function() {}
};

// Good
var foo = { x, y, z };

var foo = {
  a() {},
  b() {}
};

函数

  • 【强制】 禁止使用箭头函数当它可以与比较混淆时
// Bad
var x = a => (1 ? 2 : 3);
var x = a => (1 ? 2 : 3);
var x = a => (1 ? 2 : 3);
  • 【推荐】 箭头函数的函数主体部分应被大括号包裹
// Normal
let foo = () => 0;

// Good
let foo = () => {
  return 0;
};
let foo = (retv, name) => {
  retv[name] = true;
  return retv;
};
  • 【推荐】 箭头函数的参数应被小括号包裹
// Normal
a => {};

// Good
(a) => {};
  • 【推荐】 建议回调函数使用箭头函数
// Normal
foo(function(a) {
  return a;
});
foo(
  function() {
    return this.a;
  }.bind(this)
);

// Good
foo(a => a);
foo(function*() {
  yield;
});
  • 【强制】 generator 函数中一定要存在 yield
// Bad
function* foo() {
  return 10;
}

// Good
function* foo() {
  yield 5;
  return 10;
}

function foo() {
  return 10;
}
  • 【推荐】 建议使用剩余参数代替 arguments
// Normal
function foo() {
  console.log(arguments);
}

// Good
function foo(...args) {
  console.log(args);
}
function foo(action, ...args) {
  action.apply(null, args);
}
  • 【推荐】 建议使用 Reflect 当适用的时候
// Normal
myFunction.apply(undefined, args);
myFunction.apply(null, args);
obj.myMethod.apply(obj, args);
obj.myMethod.apply(other, args);

myFunction.call(undefined, arg);
myFunction.call(null, arg);
obj.myMethod.call(obj, arg);
obj.myMethod.call(other, arg);

// Good
Reflect.apply(myFunction, undefined, args);
Reflect.apply(myFunction, null, args);
Reflect.apply(obj.myMethod, obj, args);
Reflect.apply(obj.myMethod, other, args);
Reflect.apply(myFunction, undefined, [arg]);
Reflect.apply(myFunction, null, [arg]);
Reflect.apply(obj.myMethod, obj, [arg]);
Reflect.apply(obj.myMethod, other, [arg]);

类

  • 【强制】 不允许修改类声明的变量
// Bad
class A {}
A = 0;

A = 0;
class A {}
  • 【强制】 在类成员中禁止重复名称
// Bad
class Foo {
  bar() {}
  bar() {}
}

class Foo {
  bar() {}
  get bar() {}
}

class Foo {
  static bar() {}
  static bar() {}
}

// Good
class Foo {
  bar() {}
  qux() {}
}

class Foo {
  get bar() {}
  set bar(value) {}
}

class Foo {
  static bar() {}
  bar() {}
}
  • 【强制】 继承类的构造函数一定调用 super(), 非继承类的构造函数一定不调用 super()
// Bad
class A {
  constructor() {
    super(); // This is a SyntaxError.
  }
}

class A extends B {
  constructor() {} // Would throw a ReferenceError.
}

// Classes which inherits from a non constructor are always problems.
class A extends null {
  constructor() {
    super(); // Would throw a TypeError.
  }
}

class A extends null {
  constructor() {} // Would throw a ReferenceError.
}

// Good
class A {
  constructor() {}
}

class A extends B {
  constructor() {
    super();
  }
}
  • 【强制】 禁止在构造函数的 super() 执行之前使用 this
// Bad
class A extends B {
  constructor() {
    this.a = 0;
    super();
  }
}

class A extends B {
  constructor() {
    this.foo();
    super();
  }
}

class A extends B {
  constructor() {
    super.foo();
    super();
  }
}

class A extends B {
  constructor() {
    super(this.foo());
  }
}

// Good
class A {
  constructor() {
    this.a = 0; // OK, this class doesn't have an `extends` clause.
  }
}

class A extends B {
  constructor() {
    super();
    this.a = 0; // OK, this is after `super()`.
  }
}

class A extends B {
  foo() {
    this.a = 0; // OK. this is not in a constructor.
  }
}
  • 【强制】 禁止使用无用的构造函数
// Bad
class A {
  constructor() {}
}

class A extends B {
  constructor(...args) {
    super(...args);
  }
}

// Good
class A {}

class A {
  constructor() {
    doSomething();
  }
}

class A extends B {
  constructor() {
    super('foo');
  }
}

class A extends B {
  constructor() {
    super();
    doSomething();
  }
}

模块系统

  • 【强制】 禁止重复引用
// Bad
import { merge } from 'module';
import something from 'another-module';
import { find } from 'module';

// Good
import { merge, find } from 'module';
import something from 'another-module';
  • 【强制】 禁止使用导入、导出、解构的重命名功能时重命名为何之前一样的名字
// Bad
import { foo as foo } from "bar";
export { foo as foo };
export { foo as foo } from "bar";
let { foo: foo } = bar;
let { 'foo': foo } = bar;
function foo({ bar: bar }) {}
({ foo: foo }) => {}

// Good
import * as foo from "foo";
import { foo } from "bar";
import { foo as bar } from "baz";

export { foo };
export { foo as bar };
export { foo as bar } from "foo";

let { foo } = bar;
let { foo: bar } = baz;
let { [foo]: foo } = bar;

function foo({ bar }) {}
function foo({ bar: baz }) {}

({ foo }) => {}
({ foo: bar }) => {}
  • 【推荐】 建议使用 import export 来取代非标准的 CMD AMD 等
// Normal
const _ = require('lodash');

// Good
import * as _ from 'lodash';

其他

  • 【强制】 Symbol 函数前不能使用 new 命令
// Bad
var foo = new Symbol('foo');

// Good
var foo = Symbol('foo');
  • 推荐】 使用 Symbol 函数最好传入描述
// Normal
var foo = Symbol();

// Good
var foo = Symbol('some description');
  • 【强制】 禁止使用 parseInt() 当用到二进制，八进制，十六进制的时候
// Bad
parseInt('111110111', 2) === 503;
parseInt('767', 8) === 503;
parseInt('1F7', 16) === 255;

// Good
parseInt(1);
parseInt(1, 3);

0b111110111 === 503;
0o767 === 503;
0x1f7 === 503;

a[parseInt](1, 2);

parseInt(foo);
parseInt(foo, 2);

相关文章

  • ECMAScript 6 编码规约

    定义 ECMAScript 6（以下简称 ES6）是 JavaScript 语言的下一代标准，ES6 的第一个版本...

  • 研发二部JAVA后台开发规约（参考阿里JAVA代码规范）

    主要内容 工程规约 编码规约 异常处理日志规约 MySQL规约 安全规约 工程规约 应用分层： 工程分层如上图所示...

  • Java编码规约插件使用

    Java编码规约插件使用

  • 编码规范

    程序编码规范： 命名规约：

  • android:阿里编码规约初体验

    一、阿里编码规约简介 阿里编码规约是由阿里巴巴 P3C 项目组开发的针对 Java 语言的代码检测插件。 能够在编...

  • CSS 编码规约

    基本规约 【推荐】缩进使用两个空格 在每个声明块的左花括号前添加一个空格 【推荐】声明块的右花括号应当单独成行 每...

  • HTML 编码规约

    基本规约 在每个 HTML 页面开头使用这个简单地 doctype 来启用标准模式，使其每个浏览器中尽可能一致的展...

  • React 编码规约

    基本 每个文件只写一个组件，但是多个无状态组件可以放在单个文件中。 组件 【强制】有内部状态，方法或者是要对外暴露...

  • Less 编码规约

    @import @import 语句必须声明于文件的头部位置。 变量定义 文件全局的变量在全局头部次于 @impo...

  • 编码规约 + Maven

    1. 如何使用阿里巴巴的规约？ 答：使用plugin搜索alibaba即可 2. 什么是maven？ 3.如何通过...

网友评论

      本文标题：ECMAScript 6 编码规约

      本文链接：https://www.haomeiwen.com/subject/rkvzrftx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|ECMAScript 6 编码规约|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！