如何写出可读性强实用性强又高质量的JavaScript 代码，需要掌握一些小技巧

虽然现在写代码不像以前，现在都有 eslint、prettier、babel(写新版语法) 这些来保证代码格式，然而，技术手段再高端都不能解决代码可读性（代码能否被未来的自己和同事看懂）的问题，因为这个问题只有人自己才能解决。要想写出不让你同事或者你的交接人吐槽的代码，首先要有良好的代码风格，下列编码陋习你有木有？有的话改进改掉吧！！！
掌握一些JavaScript小技巧有利于你提高代码质量哦！下面我们一起来学习吧！！
1.滥用变量
定义好了之后再也没用过
改进：
数据只使用一次或不使用就无需装到变量中，没用的就删除掉，不然过三个月自己都不敢删，怕是不是那用到了
2.自我感觉良好的缩写

let fName = 'jack'; // 看起来命名挺规范，缩写，驼峰法都用上，ESlint 各种检测规范的工具都通过，
//But，fName 是啥？这时候，你是不是想说 What are you 弄啥呢？
let lName = 'tom'; // 这个问题和上面的一样

改进：

let firstName = 'jack'; // 怎么样，是不是一目了然。少被喷了一次
let lastName = 'tom';//无需对每个变量都写注释，从名字上就看懂

3.无说明的参数

if (value.length < 8) { // 为什么要小于 8，8 表示啥？长度，还是位移，还是高度？Oh,my God!!
    ....
}

改进：

const MAX_INPUT_LENGTH = 8;//添加变量
if (value.length < MAX_INPUT_LENGTH) { // 一目了然，不能超过最大输入长度
    ....
}

4.命名过于啰嗦

let nameString;
let theUsers;

改进：
简洁明了就行

let name;
let users;

5.使用太多的全局变量

name.js
window.name = 'tom';
hello.js
window.name = 'bobu';
time.js
window.name = 'cater';  // 三个文件的先后加载顺序不同，都会使得 window.name 的值不同，
//同时，你对 window.name 的修改了都有可能不生效，因为你不知道你修改过之后别人是不是又在别的说明文件中对其的值重置了。
//所以随着文件的增多，会导致一团乱麻。

改进：
少用或使用替代方案：你可以选择只用局部变量。通过 (){}的方法。
如果你确实用很多的全局变量需要共享，你可以使用 vuex,redux 或者你自己参考 flux 模式写一个也行。

6.从命名无法知道函数返回值类型

function showDatas() {....} // 现在问，你知道这个返回的是一个数组，还是一个对象，还是 true or false

改进：
对于返回 true or false 的函数，最好以 should/is/can/has 开头

function shouldShowData() {...}
function isEmpty() {...}
function canSubmit() {...}
function hasLicense() {...}

7.功能函数的输出变化无常

function plusAbc(a, b, c) {  // 这个函数的输出将变化无常，因为 api 返回的值一旦改变，同样输入函数的 a，b,c 的值，但函数返回的结果却不一定相同。
        var c = fetch('../api');
        return a+b+c;
}

改进：
功能函数使用纯函数，输入一致，输出结果永远唯一

function plusAbc(a, b, c) {  // 同样输入函数的 a，b,c 的值，但函数返回的结果永远相同。
        return a+b+c;
}

8.传参无说明

getLisence(src, true, false); // true 和 false 啥意思，一目不了然

改进：
传参有说明

getLisence({
    image: src,
    includePageBackground: true, // 一目了然，知道这些 true 和 false 是啥意思
    compress: false,
})

9.无法辨别函数意图
改进：
动词开头，函数意图就很明显

function sendEmailr(user) {
    ....
}

10.函数中过多的采用 if else

function getGrades(num){
	let result='';//返回结果
	if(num < 60) {
		result = "不及格";
	}else if(num < 75) {
		result = "一般";
	} else if(num < 90){
		result = "良好";
	}else{
		result = "优秀";
	}
	return result;
}
console.log(getGrades(60))

改进：
1.可以使用 switch 替代或用数组替代

function showGrace(grades,results,curr) {
	for(let i in grades){
		if(curr<grades[i]){
			return results[i]
		}
	}
}
let grades=[60,75,90,101],
results=['不及格','一般','良好','优秀'];
showGrace(grades,results,60)

2.短路求值（Short-Circuit Evaluation）：三目运算符是一个很方便快捷的书写一些简单的逻辑语句的方式，
x > 100 ? ‘Above 100’ : ‘Below 100’;
x > 100 ? (x > 200 ? ‘Above 200’ : ‘Between 100-200’) : ‘Below 100’;
11.if判断条件太多

if(fruit==='apple' || fruit==='apple' || fruit==='strawberry' || fruit==='cherry' || fruit==='cranberries'){
	console.log('red');
}else{
	console.log('blue');
}

改进：
利用数组列举条件，
array.indexOf 此方法判断数组中是否存在某个值，如果存在返回数组元素的下标，否则返回-1；
array.find(callback[, thisArg]) 返回数组中满足条件的第一个元素的值，如果没有，返回undefined；
array.findIndex(callback[, thisArg]) 返回数组中满足条件的第一个元素的索引（下标）, 如果没有找到，返回-1
array.includes(searchElement[, fromIndex]) 此方法判断数组中是否存在某个值，如果存在返回 true，否则返回false。

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

12.有效性数据返回判断

if (this.state.data) {
  return this.state.data;
} else {
  return 'Fetching Data';
}
但是我们可以通过上面的方式来简写这个逻辑处理。

return (this.state.data || 'Fetching Data');

13.尽量使用 ES6
1.尽量使用箭头函数
2.不采用传统 + 号，采用模板字符

// var message = 'Hello ' + name + ', it\'s ' + time + ' now'
改进：var message = `Hello ${name}, it's ${time} now`

3.使用解构赋值
传统赋值：

var data = { name: 'dys', age: 1 };
var name = data.name;
var age = data.age;
var fullName = ['jackie', 'willen'];
var firstName = fullName[0];
var lastName = fullName[1];

改进：
解构赋值：

const data = {name:'dys', age:1};
const {name, age} = data;   // 怎么样，是不是简单明了
var fullName = ['jackie', 'willen'];
const [firstName, lastName] = fullName;

4.尽量使用类 class
采用传统的函数原型链实现继承
典型的 ES5 的类 (function) 在继承、构造和方法定义方面可读性较差，当需要继承时，优先选用 class。代码太多，就省略了。
改进：
采用 ES6 类实现继承

class Animal {
  constructor(age) {
    this.age = age
  }
  move() {
    /* ... */
  }
}
class Mammal extends Animal {
  constructor(age, furColor) {
    super(age)
    this.furColor = furColor
  }
  liveBirth() {
    /* ... */
  }
}
class Human extends Mammal {
  constructor(age, furColor, languageSpoken) {
    super(age, furColor)
    this.languageSpoken = languageSpoken
  }
  speak() {
    /* ... */
  }
}

5.过滤唯一值
Set类型是在ES6中新增的，它类似于数组，但是成员的值都是唯一的，没有重复的值。结合扩展运算符（…）我们可以创建一个新的数组，达到过滤原数组重复值的功能。
const array = [1, 2, 3, 3, 5, 5, 1];
const uniqueArray = […new Set(array)];
console.log(uniqueArray); // [1, 2, 3, 5]
在ES6之前，我们如果想要实现这个功能的话，需要的处理代码要多很多。这个技巧的适用范围是数组中的数值的类型为：undefined， null， boolean， string， number。当包涵object， function， array时，则不适用。

附：小技巧
1、转换Boolean型
常规的boolean型值只有 true 和 false，但是在JavaScript中我们可以将其他的值认为是 ‘truthy’ 或者 ‘falsy’的。
除了0， “”， null， undefined， NaN 和 false,其他的我们都可以认为是‘truthy’的。
我们可以通过负运算符！将一系列的变量转换成“boolean”型。

const isTrue  = !0;
const isFalse = !1;
const alsoFalse = !!0;
console.log(isTrue); // Result: true
console.log(typeof true); // Result: "boolean"

2、转换String型
我们可以通过+连接运算符将一个number类型的变量转换成string类型。

const val = 1 + "";
console.log(val); // Result: "1"
console.log(typeof val); // Result: "string"

3、转换Number类型
和上面对应的，我们可以通过加法运算符+将一个string类型的变量转回为number 类型的。

let int = "15";
int = +int;
console.log(int); // Result: 15
console.log(typeof int); Result: "number"

在某些上下文中，+将被解释为连接操作符，而不是加法操作符。当这种情况发生时(您希望返回一个整数，而不是浮点数)，您可以使用两个波浪号: ~~ 。
(需要注意为英文格式)

一个波浪号~，被称为“按位不运算符”，等价于 - n - 1。所以~15 = -16.
使用两个~~可以有效的否定运算。这是因为 - (- n - 1) - 1 = n + 1 - 1 = n。也就是说 ~-16 = 15

const int = ~~"15"
console.log(int); // Result: 15
console.log(typeof int); Result: "number"

4、快速求幂
从ES7开始，我们可以使用幂运算符 ** 作为求幂的简写，相对之前的Math.pow(2, 3) 更加快捷。这是一个很简单实用的点，但是大部分的教程并不会专门介绍它。

console.log(2 ** 3); // Result: 8
这不应该与 ^ 符号混淆，^ 符号通常用于表示指数，但在JavaScript中是位XOR操作符。
在ES7之前，幂的简写主要依靠的是位左移位操作符 <<，几种写法的区别。

// 下面几种写法是等价的
Math.pow(2, n);
2 << (n - 1);
2**n;
其中需要注意的是 2 << 3 = 16 等价于 2 ** 4 = 16

5、快速Float转Integer
我们平时可以使用Math.floor(), Math.ceil()和Math.round()将float类型转换成integer类型。
但是还有一种更快的方法可以使用|(位或运算符)将浮点数截断为整数。

console.log(23.9 | 0);  // Result: 23
console.log(-23.9 | 0); // Result: -23

| 的行为取决于处理的是正数还是负数，所以最好只在确定的情况下使用这个快捷方式。
如果n是正数的，则 n | 0 有效地向下舍入。如果n是负数的，它则有效地向上取整。更准确地说，该操作结果是直接删除小数点后的内容，将浮点数截断为整数，和上面提到的其他几个方法是有所区别的。
您还可以使用 ~~ 来获得相同的舍入效果，如上所述，实际上任何位操作符都会强制浮点数为整数。这些特殊操作之所以有效，是因为一旦强制为整数，值就保持不变。
使用场景：
位或运算符可以用于从整数的末尾删除任意数量的数字。这意味着我们不必使用这样的代码在类型之间进行转换。

let str = "1553"; 
Number(str.substring(0, str.length - 1));
而是可以使用下面的方式来实现我们的功能
console.log(1553 / 10   | 0)  // Result: 155
console.log(1553 / 100  | 0)  // Result: 15
console.log(1553 / 1000 | 0)  // Result: 1

6、类中自动绑定

我们可以在类中通过使用ES6增加的箭头函数的方式来实现隐形绑定作用域。而按照之前的处理，我们需要显式的去为我们写的方法进行绑定，类似于 this.myMethod = this.myMethod.bind(this)这样。当我们的类中有很多方法时，会增加大量的绑定的代码的书写。现在我们就可以通过箭头函数的方式来简化这个过程。

import React, { Component } from React;
export default class App extends Compononent {
  constructor(props) {
    super(props);
    this.state = {};
  }
  myMethod = () => {
    // 隐式绑定
  }
  render() {
    return (
      <>
        <div>
          {this.myMethod()}
        </div>
      </>
    )
  }
};

7、截取数组
如果您想从数组的末尾删除值，有比使用splice()更快的替代方法。
例如，如果你知道原始数组的长度，就可以通过重新定义它的length属性来实现截取。

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array.length = 4;
console.log(array); // Result: [0, 1, 2, 3]

这是一个特别简洁的解决方案。但是，slice()方法的运行时更快。如果速度是你的主要目标，考虑使用下面的方式。

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
array = array.slice(0, 4);
console.log(array); // Result: [0, 1, 2, 3]

8、获取数组中的最后的元素
数组方法slice()可以接受负整数，如果提供它，它将从数组的末尾开始截取数值，而不是开头。

let array = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(array.slice(-1)); // Result: [9]
console.log(array.slice(-2)); // Result: [8, 9]
console.log(array.slice(-3)); // Result: [7, 8, 9]

9、格式化JSON代码
我们可能在处理一些JSON相关的处理时很多时候都会使用到JSON.stringify，但是你是否意识到它可以帮助缩进JSON呢？
stringify()方法接受两个可选参数:一个replacer函数和一个space值，replacer函数可以用来过滤显示的JSON。
space值接受一个整数，表示需要的空格数或一个字符串(如’\t’来插入制表符)，它可以使读取获取的JSON数据变得容易得多。

console.log(JSON.stringify({ alpha: 'A', beta: 'B' }, null, '\t'));
// Result:
// '{
//     "alpha": A,
//     "beta": B
// }'