JavaScript 的简写技巧

àì夳堔傛蜴生んèń 2023-10-08 12:07 4阅读 0赞

#### JavaScript 的简写技巧 ####

*   *  写在前面
     *   *  1、三目运算
         *  2、循环语句
         *  3、十进制数
         *  4、变量赋值
         *  5、对象属性
         *  6、箭头函数
         *  7、隐式返回值
         *  8、默认参数值
         *  9、模板字符串
         *  10、解构赋值
         *  11、展开运算符
         *  12、强制参数
         *  13、Array.find
         *  14、Object \[key\]
         *  15、双位操作符

### 写在前面 ###

本文转载自：葡萄城官网

> https://www.cnblogs.com/powertoolsteam/p/shorthand-javascript.html

标题5及以后为ES6 版本以上的新语法

#### 1、三目运算 ####

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

简写：

const answer = x > 10 ? 'greater than 10' : 'less than 10';

> let 变量只在 let 命令所在的代码块 \{\} 内有效，在 \{\} 之外不能访问。  
> const 声明常量时必须进行初始化，且初始化后值不可再修改

#### 2、循环语句 ####

当使用纯 JavaScript（不依赖外部库，如 jQuery 或 lodash）时，下面的简写会非常有用。

for (let i = 0; i < j.length; i++)

简写：

for (let i of j)

#### 3、十进制数 ####

可以使用科学计数法来代替较大的数据，如可以将 10000000 简写为 1e7。

#### 4、变量赋值 ####

当将一个变量的值赋给另一个变量时，首先需要确保原值不是 null、未定义的或空值。

可以通过编写一个包含多个条件的判断语句来实现：

if (a !== null || a !== undefined || a !== '') {
         let b = a; }

或则简写：

const b = a  || 'new';

#### 5、对象属性 ####

ES6 提供了一个很简单的办法，来分配属性的对象。如果属性名与 key 名相同，则可以使用简写。

const obj = {
         x:x, y:y };

简写为：

const obj = {
         x, y };

#### 6、箭头函数 ####

经典函数很容易读写，但是如果把它们嵌套在其它函数中进行调用时，整个函数就会变得有些冗长和混乱。这时候可以使用箭头函数来简写：

简写为：

sayHello = name => console.log('Hello', name);
    setTimeout(() => console.log('Loaded'), 2000);
    list.forEach(item => console.log(item));

#### 7、隐式返回值 ####

返回值是我们通常用来返回函数最终结果的关键字。只有一个语句的箭头函数，可以隐式返回结果（函数必须省略括号（\{ \}），以便省略返回关键字）。

要返回多行语句（例如对象文本），需要使用（）而不是\{ \}来包裹函数体。这样可以确保代码以单个语句的形式进行求值。

function f(a) {
         return Math.PI * a }

简写为：

f = a => (Math.PI * a;)

#### 8、默认参数值 ####

可以使用 if 语句来定义函数参数的默认值。ES6 中规定了可以在函数声明中定义默认值。

function volume(l, w, h) {
        
      if (w === undefined)
        w = 3;
      if (h === undefined)
        h = 4;
      return l * w * h;
    }

简写为：

volume = (l, w = 3, h = 4 ) => (l * w * h);
    volume(2) //output: 24

#### 9、模板字符串 ####

过去我们习惯了使用“+”将多个变量转换为字符串，但是有没有更简单的方法呢？

ES6 提供了相应的方法，我们可以使用反引号和 $ \{ \} 将变量合成一个字符串。

const welcome = 'You have logged in as ' + first + ' ' + last + '.'
    const db = 'http://' + host + ':' + port + '/' + database;

简写为：

const welcome = `You have logged in as ${
          first} ${
          last}`;
    const db = `http://${
          host}:${
          port}/${
          database}`;

#### 10、解构赋值 ####

解构赋值是一种表达式，用于从数组或对象中快速提取属性值，并赋给定义的变量。

在代码简写方面，解构赋值能达到很好的效果。

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;

#### 11、展开运算符 ####

展开运算符是在 ES6 中引入的，使用展开运算符能够让 JavaScript 代码更加有效和有趣。

使用展开运算符可以替换某些数组函数。

// joining arrays
    const odd = [1, 3, 5];
    const nums = [2 ,4 , 6].concat(odd);
     
    // cloning arrays
    const arr = [1, 2, 3, 4];
    const arr2 = arr.slice( )

简写为：

// joining arrays
    const odd = [1, 3, 5 ];
    const nums = [2 ,4 , 6, ...odd];
    console.log(nums); // [ 2, 4, 6, 1, 3, 5 ]
     
    // cloning arrays
    const arr = [1, 2, 3, 4];
    const arr2 = [...arr];

和 concat( ) 功能不同的是，用户可以使用扩展运算符在任何一个数组中插入另一个数组。

const odd = [1, 3, 5 ];
    const nums = [2, ...odd, 4 , 6];

也可以将展开运算符和 ES6 解构符号结合使用：

const {
         a, b, ...z } = {
         a: 1, b: 2, c: 3, d: 4 };
    console.log(a) // 1
    console.log(b) // 2
    console.log(z) // { c: 3, d: 4 }

#### 12、强制参数 ####

默认情况下，如果不向函数参数传值，那么 JavaScript 会将函数参数设置为未定义。其它一些语言则会发出警告或错误。要执行参数分配，可以使用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;
    }

#### 13、Array.find ####

如果你曾经编写过普通 JavaScript 中的 find 函数，那么你可能使用了 for 循环。在 ES6 中，介绍了一种名为 find（）的新数组函数，可以实现 for 循环的简写。

简写为：

pet = pets.find(pet => pet.type ==='Dog' && pet.name === 'Tommy');
    console.log(pet); // { type: 'Dog', name: 'Tommy' }

#### 14、Object \[key\] ####

虽然将 foo.bar 写成 foo \[‘bar’\] 是一种常见的做法，但是这种做法构成了编写可重用代码的基础。

请考虑下面这个验证函数的简化示例：

function validate(values) {
        
      if(!values.first)
        return false;
      if(!values.last)
        return false;
      return true;
    }
    console.log(validate({
        first:'Bruce',last:'Wayne'})); // true

上面的函数完美的完成验证工作。但是当有很多表单，则需要应用验证，此时会有不同的字段和规则。如果可以构建一个在运行时配置的通用验证函数，会是一个好选择。

// object validation rules
    const schema = {
        
      first: {
        
        required:true
      },
      last: {
        
        required:true
      }
    }
     
    // universal validation function
    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'})); // false
    console.log(validate(schema, {
        first:'Bruce',last:'Wayne'})); // true

现在有了这个验证函数，我们就可以在所有窗体中重用，而无需为每个窗体编写自定义验证函数。

#### 15、双位操作符 ####

位操作符是 JavaScript 初级教程的基本知识点，但是我们却不常使用位操作符。因为在不处理二进制的情况下，没有人愿意使用 1 和 0。

但是双位操作符却有一个很实用的案例。你可以使用双位操作符来替代 Math.floor( )。双否定位操作符的优势在于它执行相同的操作运行速度更快。

Math.floor(4.9) === 4  //true

简写为：

~~4.9 === 4  //true