ES6 语法简写常用的 Javascript 语法

/** * 当想写 if ... else 语句时，使用三元运算符来代替 */

const x = 20;let answer;if (x > 10) {    answer = 'is greater';} else {    answer = 'is lesser';}

// 简写const answer = x > 10 ? 'is greater' : 'is lesser';// 也可以嵌套 if 语句const big = x > 10 ? 'grester 10' : x;

/** * 当给一个变量分配另一个值时，想确定原始值不是 null , undefined 或空值。可以撰写一个多重条件的 if 语句。 */

if (variable1 !== null || variable1 !== undefined || variable1 !== '') {    let variable2 = variable1;}// 或者可以使用短路求值的方法const variable2 = variable1 || 'new';

let x;let y;let z = 3;// 简写方法let x, y, z = 3;

// 只有 likeJavascript 是真值时，二者语句才相等
if (likeJavascript === true) {    // do something ...}// 简写if (likeJavascript) {    // do something ...}// 如果判断值不是真值时，则可以这样：let a;if (a !== true) {    // do something ...}// 简写if (!a) {    // do something ...}

for (let i = 0; i < allImgs.length; i++) {    // do something ...}// 简写： 
for(let index in allImgs) {    // do something ...}allImgs.forEach((element, index, array) => {
    // do something ...
});

let dbHost;if (process.env.DB_HOST) {    dbHost = process.env.DB_HOST;} else {    dbHost = 'localhost';}// 简写const dbHost = process.env.DB_HOST || 'localhost';

/** * 7、十进制指数 * 当需要写数字带有很多零时 (如 10000000 )，可以采用指数 ( 1e7 ) 来代替这个数字： */

for(let i = 0; i < 1e7; i++) {
    // do something ...
}1e0 = 1 // true1e1 = 10 // true1e2 = 100 // true1e3 = 1000 // true1e4 = 10000 // true1e5 = 100000 // true

/** * 如果属性名与 key 值相同，则可以采用 ES6 的方法 */
const obj = { x: x, y: y }// 简写const obj = { x, y }

function sayHello(name) {    console.log("Hello", name);}setTimeout(function() {    console.log("Loaded");}, 2000);list.forEach(function(item) {    console.log(item);})// 简写const sayHello = name => console.log('Hello', name);setTimeout(() => console.log('Loaded'), 2000);list.forEach(item => console.log(item))

/** * 经常使用 return 语句来返回函数最终结果，一个单独语句的箭头函数能隐式返回其值（函数必须省略{}，为了省略 return 关键字） */// 为返回多行语句（例如对象字面表达式），则需要使用（）包围函数体function calcCircumference(diameter) {    return Math.PI * diameter;}var func = function func() {    return { foo: 1 };}// 简写const calcCircumference = diameter => Math.PI * diameter;var func = () => ({ foo: 1 });

/** * 为了给函数中传递默认值，通常使用 if 语句来编写，但是使用 ES6 定义默认值，则会很简单 */function volume(l, w, h) {
    if (l === undefined) {        l = 2;    }    if (w === undefined) {        w = 3;    }    if (h === undefined) {        h = 4;    }    return l * w * h;}// 简写volume = (l = 2, w = 3, h = 4) => (l * w * h)

/** * 传统的 Javascript 语言，输出模版通常为 */const welcome = 'You have logged in as ' + first + ' ' + last + '.';const db = 'http://' + host + ':' + post + '/' + database;// ES6 可以使用反引号和 ${} 简写const welcome = `You have logged in as ${first} ${last}.`const db = `http://${host}:${port}/${database}`;

/** * 在 web 框架中，经常需要从组件和 API 之间来回传递数组或对象字面形式的数据，然后需要解构它 */const observable = require('mobx/observable');const action = require('mobx/action');const runInAction = require('mobx/runInAction');const store = this.props.store;const form = this.props.form;const loading = this.props.loading;const errors = this.props.errors;const entity = this.props.entity;// 简写import { observable, action, runInAction } from 'mobx';const { store, form, loading, errors, entity } = this.props;// 也可以分配变量名const { store, form, loading, errors, entity: contact } = this.props;

/** * 需要输出多行字符串，需要使用 + 来拼接 */const lorem = 'Lorem ipsum dolor sit amet, consectetur' +    'adipisicing elit, sed do eiusmod tempor incididunt' +    'ut labore et dolore magna aliqua. Ut enim ad minim' +    'veniam, quis nostrud exercitation ullamco laboris' +    'nisi ut aliquip ex ea commodo consequat. Duis aute' +    'irure dolor in reprehenderit in voluptate velit esse.'// 使用反引号，则可以达到简写，即字符串的拼接优化  const lorem = `Lorem ipsum dolor sit amet, consectetur                adipisicing elit, sed do eiusmod tempor incididunt                ut labore et dolore magna aliqua. Ut enim ad minim                veniam, quis nostrud exercitation ullamco laboris                nisi ut aliquip ex ea commodo consequat. Duis aute                irure dolor in reprehenderit in voluptate velit esse.`

/** * 拓展运算符有几种用例让 Javascript 代码更加有效使用，可以用来代替某个数组函数 */// joining arraysconst odd = [1, 3, 5];const nums = [2, 4, 6].concat(odd);// cloning arraysconst arr = [1, 2, 3, 4];const arr2 = arr.slice();// 简写//joining arraysconst odd = [1, 3, 5];const nums = [2, 4, 6, ...odd];// cloning arraysconst arr = [1, 2, 3, 4];const arr2 = [...arr];// 不像 concat() 函数，可以使用拓展运算符来在一个数组中任意处插入另一个数组const odd = [1, 3, 5];const nums = [2, ...odd, 4, 6];// 也可以使用拓展运算符来解构const { a, b, ...z } = { a: 1, b: 2, c: 3, d: 4 };

/** * Javascript 中如果没有向函数参数传递值，则参数为 undefined 。为了增强参数赋值，可以使用 if 语句来抛出一场，或使用强制参数简写方法 */function foo(bar) {    if (bar === undefined) {        throw new Error('Missing parameter!');    }    return bar;}// 简写mandatory = () => {    throw new Error('Missing parameter!');}foo = (bar = mandatory()) => {    return bar;}

/** * 想从数组中查找某个值，则需要循环。在 ES6 中，find() 函数能实现同样的效果 */const pets = [{        type: 'Dog',        name: 'Max'    },    {        type: 'Cat',        name: 'Karl'    },    {        type: 'Dog',        name: 'Tommy'    }]function findDog(name) {    for (let i = 0; i < pets.length; ++i) {        if (pets[i].type === 'Dog' && pets[i].name === name) {            return pets[i];        }    }}// 简写pet = pets.find(pet => pet.type === 'Dog' && pet.name === 'Tommy')

/** * 18、Object[key] 简写 * 考虑一个验证函数 */function validate(values) {    if (!values.first) {        return false;    }    if (!values.last) {        return false;    }    return true;}console.log(validate({ first: 'Bruce', last: 'Wayne' })); // true// 假设当需要不同域和规则来验证，能否编写一个通用函数在运行时确认// 对象验证const schema = {    first: {        required: true    },    last: {        requred: true    }}// 通用验证函数const validate = (schema, values) => {    for (field in schema) {        if (schema[field].required) {            if (!values[field]) {                return false;            }        }    }    return true;}console.log(validate(schema, { first: 'Bruce' })); // falseconsole.log(validate(schema, { first: 'Bruce', last: 'Wayne' })); // true

/** * 有一个有效用例用于双重非运算操作符。可以用来代替 Math.floor(), 其优势在于运行快 */Math.floor(4.9) === 4 // true// 简写~~4.9 === 4 // true