支付供给精通的简写技艺,有用的简写手艺
分类:前端技术

JavaScript 开发人员需要知道的简写技巧

2017/10/25 · CSS · 1 评论

原文出处: Michael Wanyoike   译文出处:葡萄城控件   

图片 1本文来源于多年的 JavaScript 编码技术经验,适合所有正在使用 JavaScript 编程的开发人员阅读。

本文的目的在于帮助大家更加熟练的运用 JavaScript 语言来进行开发工作。

文章将分成初级篇和高级篇两部分,分别进行介绍。

1.三元操作符

初级篇
1、三目运算符
下面是一个很好的例子,将一个完整的 if 语句,简写为一行代码。

姓名:周小蓬 16019110037

初级篇

当想写if...else语句时,使用三元操作符来代替。

图片 2

转载自:

1、三目运算符

下面是一个很好的例子,将一个完整的 if 语句,简写为一行代码。

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

1
2
3
4
5
6
7
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';

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

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

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

[嵌牛导读]

2、循环语句

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

for (let i = 0; i< allImgs.length; i )

1
for (let i = 0; i< allImgs.length; i )

简写为:

for (let index of allImgs)

1
for (let index of allImgs)

下面是遍历数组 forEach 的简写示例:

function logArrayElements(element, index, array) { console.log("a[" index "] = " element); } [2, 5, 9].forEach(logArrayElements); // logs: // a[0] = 2 // a[1] = 5 // a[2] = 9

1
2
3
4
5
6
7
8
function logArrayElements(element, index, array) {
  console.log("a[" index "] = " element);
}
[2, 5, 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[2] = 9

也可以嵌套if语句:
const big = x > 10 ? " greater 10" : x

图片 3

本文来源于多年的 JavaScript 编码技术经验,适合所有正在使用 JavaScript 编程的开发人员阅读。

3、声明变量

在函数开始之前,对变量进行赋值是一种很好的习惯。在申明多个变量时:

let x; let y; let z = 3;

1
2
3
let x;
let y;
let z = 3;

可以简写为:

let x, y, z=3;

1
let x, y, z=3;

2.短路求值简写方式

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

本文的目的在于帮助大家更加熟练的运用 JavaScript 语言来进行开发工作。

4、if 语句

在使用 if 进行基本判断时,可以省略赋值运算符。

if (likeJavaScript === true)

1
if (likeJavaScript === true)

简写为:

if (likeJavaScript)

1
if (likeJavaScript)

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

2、循环语句
当使用纯 JavaScript(不依赖外部库,如 jQuery 或 lodash)时,下面的简写会非常有用。
for (let i = 0; i < allImgs.length; i )
简写为:
for (let index of allImgs)
下面是遍历数组 forEach 的简写示例:

文章将分成初级篇和高级篇两部分,分别进行介绍。

5、十进制数

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

for (let i = 0; i<10000;i ){}

1
for (let i = 0; i<10000;i ){}

简写为:

for (let i = 0; i<1e7; i ) { }

1
for (let i = 0; i<1e7; i ) { }

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

图片 4

[嵌牛鼻子]

6、多行字符串

如果需要在代码中编写多行字符串,就像下面这样:

const lorem = 'Lorem ipsum dolor sit amet, consecteturnt' 'adipisicing elit, sed do eiusmod tempor incididuntnt' 'ut labore et dolore magna aliqua. Ut enim ad minimnt' 'veniam, quis nostrud exercitation ullamco laborisnt' 'nisi ut aliquip ex ea commodo consequat. Duis autent' 'irure dolor in reprehenderit in voluptate velit esse.nt'

1
2
3
4
5
6
const lorem = 'Lorem ipsum dolor sit amet, consecteturnt'
     'adipisicing elit, sed do eiusmod tempor incididuntnt'
     'ut labore et dolore magna aliqua. Ut enim ad minimnt'
     'veniam, quis nostrud exercitation ullamco laborisnt'
     'nisi ut aliquip ex ea commodo consequat. Duis autent'
     'irure dolor in reprehenderit in voluptate velit esse.nt'

但是还有一个更简单的方法,只使用引号:

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.`

1
2
3
4
5
6
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.`

3.声明变量简写方法

function logArrayElements(element, index, array) { console.log("a[" index "] = " element);}[2, 5, 9].forEach(logArrayElements);// logs:// a[0] = 2// a[1] = 5// a[2] = 9

java语言

高级篇

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

图片 5

[嵌牛提问]

1、变量赋值

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

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

if (variable1 !== null || variable1 !== undefined || variable1 !== '') { let variable2 = variable1; }

1
2
3
if (variable1 !== null || variable1 !== undefined || variable1 !== '') {
     let variable2 = variable1;
}

或者简写为以下的形式:

const variable2 = variable1 || 'new';

1
const variable2 = variable1  || 'new';

可以将下面的代码粘贴到 es6console 中,自己测试:

let variable1; let variable2 = variable1 || ''; console.log(variable2 === ''); // prints true variable1 = 'foo'; variable2 = variable1 || ''; console.log(variable2); // prints foo

1
2
3
4
5
6
let variable1;
let variable2 = variable1  || '';
console.log(variable2 === ''); // prints true
variable1 = 'foo';
variable2 = variable1  || '';
console.log(variable2); // prints foo

4.if存在条件简写方法

3、声明变量
在函数开始之前,对变量进行赋值是一种很好的习惯。在申明多个变量时:
let x;let y;let z = 3;
可以简写为:
let x, y, z=3;

Java语音的编写基础

2、默认值赋值

如果预期参数是 null 或未定义,则不需要写六行代码来分配默认值。我们可以只使用一个简短的逻辑运算符,只用一行代码就能完成相同的操作。

let dbHost; if (process.env.DB_HOST) { dbHost = process.env.DB_HOST; } else { dbHost = 'localhost'; }

1
2
3
4
5
6
let dbHost;
if (process.env.DB_HOST) {
  dbHost = process.env.DB_HOST;
} else {
  dbHost = 'localhost';
}

简写为:

const dbHost = process.env.DB_HOST || 'localhost';

1
const dbHost = process.env.DB_HOST || 'localhost';

if (likeJavaScript === true)

4、if 语句
在使用 if 进行基本判断时,可以省略赋值运算符。
if (likeJavaScript === true)
简写为:
if (likeJavaScript)

[嵌牛正文]

3、对象属性

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

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

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

简写为:

const obj = { x, y };

1
const obj = { x, y };

简写:
if (likeJavaScript)

5、十进制数
可以使用科学计数法来代替较大的数据,如可以将 10000000 简写为 1e7。
for (let i = 0; i < 10000; i ) { }
简写为:
for (let i = 0; i < 1e7; i ) { }

初级篇

4、箭头函数

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

function sayHello(name) { console.log('Hello', name); } setTimeout(function() { console.log('Loaded') }, 2000); list.forEach(function(item) { console.log(item); });

1
2
3
4
5
6
7
8
9
10
11
function sayHello(name) {
  console.log('Hello', name);
}
setTimeout(function() {
  console.log('Loaded')
}, 2000);
list.forEach(function(item) {
  console.log(item);
});

简写为:

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

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

只有likeJavaScript是真值时,二者语句才相等

6、多行字符串
如果需要在代码中编写多行字符串,就像下面这样:

1、三目运算符

5、隐式返回值

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

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

function calcCircumference(diameter) { return Math.PI * diameter }

1
2
3
function calcCircumference(diameter) {
  return Math.PI * diameter
}

简写为:

calcCircumference = diameter => ( Math.PI * diameter; )

1
2
3
calcCircumference = diameter => (
  Math.PI * diameter;
)

如果判断值不是真值,则可以这样:

图片 6

下面是一个很好的例子,将一个完整的 if 语句,简写为一行代码。

6、默认参数值

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

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

1
2
3
4
5
6
7
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

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

let a;
if ( a !== true ) {
// do something...
}
简写:

const lorem = 'Lorem ipsum dolor sit amet, consecteturnt' 'adipisicing elit, sed do eiusmod tempor incididuntnt' 'ut labore et dolore magna aliqua. Ut enim ad minimnt' 'veniam, quis nostrud exercitation ullamco laborisnt' 'nisi ut aliquip ex ea commodo consequat. Duis autent' 'irure dolor in reprehenderit in voluptate velit esse.nt'

const x = 20;

7、模板字符串

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

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

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

1
2
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 = `;

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

let a;
if ( !a ) {
// do something...
}
5.JavaScript循环简写方法

图片 7

let answer;if(x > 10) {

8、解构赋值

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

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

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;

1
2
3
4
5
6
7
8
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;

1
2
import { observable, action, runInAction } from 'mobx';
const { store, form, loading, errors, entity } = this.props;

甚至可以指定自己的变量名:

const { store, form, loading, errors, entity:contact } = this.props;

1
const { store, form, loading, errors, entity:contact } = this.props;

for (let i = 0; i < allImgs.length; i )

但是还有一个更简单的方法,只使用引号:

answer= 'greater than 10';

9、展开运算符

展开运算符是在 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( )

1
2
3
4
5
6
7
// 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];

1
2
3
4
5
6
7
8
// 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];

1
2
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 }

1
2
3
4
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 }

简写:
for (let index in allImgs)
也可以使用Array.forEach:

图片 8

}else{

10、强制参数

默认情况下,如果不向函数参数传值,那么 JavaScript 会将函数参数设置为未定义。其它一些语言则会发出警告或错误。要执行参数分配,可以使用if语句抛出未定义的错误,或者可以利用“强制参数”。

function foo(bar) { if(bar === undefined) { throw new Error('Missing parameter!'); } return bar; }

1
2
3
4
5
6
function foo(bar) {
  if(bar === undefined) {
    throw new Error('Missing parameter!');
  }
  return bar;
}

简写为:

mandatory = ( ) => { throw new Error('Missing parameter!'); } foo = (bar = mandatory( )) => { return bar; }

1
2
3
4
5
6
mandatory = ( ) => {
  throw new Error('Missing parameter!');
}
foo = (bar = mandatory( )) => {
  return bar;
}

function logArrayElements(element, index, array) {
console.log("a[" index "] = " element);
}
[2, 5, 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[2] = 9
6.短路评价

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.

answer= 'less than 10';

11、Array.find

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

const pets = [ { type: 'Dog', name: 'Max'}, { type: 'Cat', name: 'Karl'}, { type: 'Dog', name: 'Tommy'}, ] function findDog(name) { for(let i = 0; ii) { if(pets[i].type === 'Dog' && pets[i].name === name) { return pets[i]; } } }

1
2
3
4
5
6
7
8
9
10
11
12
const pets = [
  { type: 'Dog', name: 'Max'},
  { type: 'Cat', name: 'Karl'},
  { type: 'Dog', name: 'Tommy'},
]
function findDog(name) {
  for(let i = 0; ii) {
    if(pets[i].type === 'Dog' && pets[i].name === name) {
      return pets[i];
    }
  }
}

简写为:

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

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

给一个变量分配的值是通过判断其值是否为null或undefined,则可以:

图片 9

}

12、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

1
2
3
4
5
6
7
8
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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 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

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

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

高级篇
1、变量赋值
当将一个变量的值赋给另一个变量时,首先需要确保原值不是 null、未定义的或空值。
可以通过编写一个包含多个条件的判断语句来实现:
if (variable1 !== null || variable1 !== undefined || variable1 !== '') { let variable2 = variable1;}
或者简写为以下的形式:
const variable2 = variable1 || 'new';
可以将下面的代码粘贴到 es6console 中,自己测试:

简写为:

13、双位操作符

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

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

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

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

简写为:

~~4.9 === 4 //true

1
~~4.9 === 4  //true

7.十进制指数

图片 10

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

总结

上述是一些常用的 JavaScript 简写技巧,如果有其它未提及的简写技巧,也欢迎大家补充。

 

1 赞 4 收藏 1 评论

图片 11

当需要写数字带有很多零时(如10000000),可以采用指数(1e7)来代替这个数字:
for (let i = 0; i < 10000; i ) {}
简写:

let variable1;let variable2 = variable1 || '';console.log(variable2 === ''); // prints truevariable1 = 'foo';variable2 = variable1 || '';console.log(variable2); // prints foo

2、循环语句

for (let i = 0; i < 1e7; i ) {}

图片 12

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

// 下面都是返回true
1e0 === 1;
1e1 === 10;
1e2 === 100;
1e3 === 1000;
1e4 === 10000;
1e5 === 100000;
8.对象属性简写

2、默认值赋值
如果预期参数是 null 或未定义,则不需要写六行代码来分配默认值。我们可以只使用一个简短的逻辑运算符,只用一行代码就能完成相同的操作。

for(let i = 0; i < allImgs.length; i )

如果属性名与key名相同,则可以采用ES6的方法:
const obj = { x:x, y:y };

图片 13

简写为:

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

let dbHost;if (process.env.DB_HOST) { dbHost = process.env.DB_HOST;} else { dbHost = 'localhost';}

for(letindexofallImgs)

9.箭头函数简写

图片 14

下面是遍历数组 forEach 的简写示例:

传统函数编写方法很容易让人理解和编写,但是当嵌套在另一个函数中,则这些优势就荡然无存。

简写为:
const dbHost = process.env.DB_HOST || 'localhost';

functionlogArrayElements(element, index, array) {

function sayHello(name) {
console.log('Hello', name);
}

3、对象属性
ES6 提供了一个很简单的办法,来分配属性的对象。如果属性名与 key 名相同,则可以使用简写。
const obj = { x:x, y:y };
简写为:
const obj = { x, y };

console.log("a[" index "] = " element);

setTimeout(function() {
console.log('Loaded')
}, 2000);

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

}

list.forEach(function(item) {
console.log(item);
});
简写:

图片 15

[2, 5, 9].forEach(logArrayElements);//logs://a[0] = 2//a[1] = 5//a[2] = 9

sayHello = name => console.log('Hello', name);

function sayHello(name) { console.log('Hello', name);} setTimeout(function() { console.log('Loaded')}, 2000); list.forEach(function(item) { console.log(item);});

3、声明变量

setTimeout(() => console.log('Loaded'), 2000);

图片 16

在函数开始之前,对变量进行赋值是一种很好的习惯。在申明多个变量时:

list.forEach(item => console.log(item));
10.隐式返回值简写

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

let x;

经常使用return语句来返回函数最终结果,一个单独语句的箭头函数能隐式返回其值(函数必须省略{}为了省略return关键字)

5、隐式返回值
返回值是我们通常用来返回函数最终结果的关键字。只有一个语句的箭头函数,可以隐式返回结果(函数必须省略括号({ }),以便省略返回关键字)。
要返回多行语句(例如对象文本),需要使用()而不是{ }来包裹函数体。这样可以确保代码以单个语句的形式进行求值。
function calcCircumference(diameter) { return Math.PI * diameter}
简写为:
calcCircumference = diameter => ( Math.PI * diameter;)

let y;

为返回多行语句(例如对象字面表达式),则需要使用()包围函数体。

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

let z= 3;

function calcCircumference(diameter) {
return Math.PI * diameter
}

图片 17

可以简写为:

var func = function func() {
return { foo: 1 };
};
简写:

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

let x, y, z=3;

calcCircumference = diameter => (
Math.PI * diameter;
)

图片 18

4、if 语句

var func = () => ({ foo: 1 });
11.默认参数值

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

在使用 if 进行基本判断时,可以省略赋值运算符。

为了给函数中参数传递默认值,通常使用if语句来编写,但是使用ES6定义默认值,则会很简洁:

7、模板字符串
过去我们习惯了使用“ ”将多个变量转换为字符串,但是有没有更简单的方法呢?
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};

if(likeJavaScript ===true)

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

8、解构赋值
解构赋值是一种表达式,用于从数组或对象中快速提取属性值,并赋给定义的变量。
在代码简写方面,解构赋值能达到很好的效果。

简写为:

volume = (l, w = 3, h = 4 ) => (l * w * h);

图片 19

if(likeJavaScript)

volume(2) //output: 24
12.模板字符串

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;

5、十进制数

传统的JavaScript语言,输出模板通常是这样写的。

图片 20

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

const welcome = 'You have logged in as ' first ' ' last '.'

简写为:
import { observable, action, runInAction } from 'mobx';const { store, form, loading, errors, entity } = this.props;
甚至可以指定自己的变量名:
const { store, form, loading, errors, entity:contact } = this.props;

for(let i = 0; i < 10000; i ) { }

const db = 'http://' host ':' port '/' database;
ES6可以使用反引号和${}简写:

9、展开运算符
展开运算符是在 ES6 中引入的,使用展开运算符能够让 JavaScript 代码更加有效和有趣。
使用展开运算符可以替换某些数组函数。

简写为:

const welcome = You have logged in as ${first} ${last};

图片 21

for(let i = 0; i <1e7; i ) { }

const db = http://${host}:${port}/${database};
13.解构赋值简写方法

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

6、多行字符串

在web框架中,经常需要从组件和API之间来回传递数组或对象字面形式的数据,然后需要解构它

图片 22

如果需要在代码中编写多行字符串,就像下面这样:

const observable = require('mobx/observable');
const action = require('mobx/action');
const runInAction = require('mobx/runInAction');

简写为:

const lorem = 'Lorem ipsum dolor sit amet, consecteturnt'

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;
简写:

图片 23

'adipisicing elit, sed do eiusmod tempor incididuntnt'

import { observable, action, runInAction } from 'mobx';

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

'ut labore et dolore magna aliqua. Ut enim ad minimnt'

const { store, form, loading, errors, entity } = this.props;
也可以分配变量名:

图片 24

'veniam, quis nostrud exercitation ullamco laborisnt'

const { store, form, loading, errors, entity:contact } = this.props;
//最后一个变量名为contact
14.多行字符串简写

和 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) // 1console.log(b) // 2console.log(z) // { c: 3, d: 4 }

'nisi ut aliquip ex ea commodo consequat. Duis autent'

需要输出多行字符串,需要使用 来拼接:

10、强制参数
默认情况下,如果不向函数参数传值,那么 JavaScript 会将函数参数设置为未定义。其它一些语言则会发出警告或错误。要执行参数分配,可以使用if语句抛出未定义的错误,或者可以利用“强制参数”。

'irure dolor in reprehenderit in voluptate velit esse.nt'

const lorem = 'Lorem ipsum dolor sit amet, consecteturnt'

图片 25

但是还有一个更简单的方法,只使用引号:

  • 'adipisicing elit, sed do eiusmod tempor incididuntnt'
  • 'ut labore et dolore magna aliqua. Ut enim ad minimnt'
  • 'veniam, quis nostrud exercitation ullamco laborisnt'
  • 'nisi ut aliquip ex ea commodo consequat. Duis autent'
  • 'irure dolor in reprehenderit in voluptate velit esse.nt'
    使用反引号,则可以达到简写作用:

function foo(bar) { if(bar === undefined) { throw new Error('Missing parameter!'); } return bar;}

const lorem =`Lorem ipsum dolor sit amet, consectetur

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.
15.扩展运算符简写

图片 26

adipisicing elit, seddoeiusmod tempor incididunt

扩展运算符有几种用例让JavaScript代码更加有效使用,可以用来代替某个数组函数。

简写为:

ut labore et dolore magna aliqua. Ut enim ad minim

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

图片 27

veniam, quis nostrud exercitation ullamco laboris

// cloning arrays
const arr = [1, 2, 3, 4];
const arr2 = arr.slice()
简写:

mandatory = ( ) => { throw new Error('Missing parameter!');}foo = (bar = mandatory( )) => { return bar;}

nisi ut aliquip ex ea commodo consequat. Duis aute

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

图片 28

irure dolorinreprehenderitinvoluptate velit esse.`

// cloning arrays
const arr = [1, 2, 3, 4];
const arr2 = [...arr];
不像concat()函数,可以使用扩展运算符来在一个数组中任意处插入另一个数组。

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

高级篇

const odd = [1, 3, 5 ];
const nums = [2, ...odd, 4 , 6];
也可以使用扩展运算符解构:

图片 29

1、变量赋值

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 }
16.强制参数简写

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]; } }}

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

JavaScript中如果没有向函数参数传递值,则参数为undefined。为了增强参数赋值,可以使用if语句来抛出异常,或使用强制参数简写方法。

图片 30

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

function foo(bar) {
if(bar === undefined) {
throw new Error('Missing parameter!');
}
return bar;
}
简写:

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

if(variable1 !==null|| variable1 !== undefined || variable1 !== '') {

mandatory = () => {
throw new Error('Missing parameter!');
}

12、Object [key]
虽然将 foo.bar 写成 foo ['bar'] 是一种常见的做法,但是这种做法构成了编写可重用代码的基础。
请考虑下面这个验证函数的简化示例:

let variable2=variable1;

foo = (bar = mandatory()) => {
return bar;
}
17.Array.find简写

图片 31

}

想从数组中查找某个值,则需要循环。在ES6中,find()函数能实现同样效果。

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

或者简写为以下的形式:

const pets = [
{ type: 'Dog', name: 'Max'},
{ type: 'Cat', name: 'Karl'},
{ type: 'Dog', name: 'Tommy'},
]

图片 32

const variable2 = variable1  ||'new';

function findDog(name) {
for(let i = 0; i<pets.length; i) {
if(pets[i].type === 'Dog' && pets[i].name === name) {
return pets[i];
}
}
}
简写:

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

可以将下面的代码粘贴到es6console中,自己测试:

pet = pets.find(pet => pet.type ==='Dog' && pet.name === 'Tommy');
console.log(pet); // { type: 'Dog', name: 'Tommy' }
18.Object[key]简写

图片 33

let variable1;

考虑一个验证函数

// object validation rulesconst schema = { first: { required:true }, last: { required:true }} // universal validation functionconst 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

let variable2= variable1  || '';

function validate(values) {
if(!values.first)
return false;
if(!values.last)
return false;
return true;
}

图片 34

console.log(variable2=== '');//prints truevariable1 = 'foo';

console.log(validate({first:'Bruce',last:'Wayne'})); // true
假设当需要不同域和规则来验证,能否编写一个通用函数在运行时确认?

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

variable2= variable1  || '';

// 对象验证规则
const schema = {
first: {
required:true
},
last: {
required:true
}
}

13、双位操作符
位操作符是 JavaScript 初级教程的基本知识点,但是我们却不常使用位操作符。因为在不处理二进制的情况下,没有人愿意使用 1 和 0。
但是双位操作符却有一个很实用的案例。你可以使用双位操作符来替代 Math.floor( )。双否定位操作符的优势在于它执行相同的操作运行速度更快。
Math.floor(4.9) === 4 //true
简写为:
~~4.9 === 4 //true

console.log(variable2);//prints foo

// 通用验证函数
const validate = (schema, values) => {
for(field in schema) {
if(schema[field].required) {
if(!values[field]) {
return false;
}
}
}
return true;
}

2、默认值赋值

console.log(validate(schema, {first:'Bruce'})); // false
console.log(validate(schema, {first:'Bruce',last:'Wayne'})); // true
现在可以有适用于各种情况的验证函数,不需要为了每个而编写自定义验证函数了

如果预期参数是 null 或未定义,则不需要写六行代码来分配默认值。我们可以只使用一个简短的逻辑运算符,只用一行代码就能完成相同的操作。

19.双重非位运算简写

let dbHost;if(process.env.DB_HOST) {

有一个有效用例用于双重非运算操作符。可以用来代替Math.floor(),其优势在于运行更快,可以阅读此文章了解更多位运算。
Math.floor(4.9) === 4 //true

dbHost=process.env.DB_HOST;

简写:
~~4.9 === 4 //true

}else{

本文转载于掘金--19 个 JavaScript 有用的简写技术

dbHost= 'localhost';

}

简写为:

const dbHost =process.env.DB_HOST || 'localhost';

3、对象属性

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

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

简写为:

const obj = { x, y };

4、箭头函数

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

functionsayHello(name) {

console.log('Hello', name);

}

setTimeout(function() {

console.log('Loaded')

},2000);

list.forEach(function(item) {

console.log(item);

});

简写为:

sayHello = name => console.log('Hello', name);

setTimeout(()=> console.log('Loaded'), 2000);

list.forEach(item=> console.log(item));

5、隐式返回值

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

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

functioncalcCircumference(diameter) {returnMath.PI *diameter

}

简写为:

calcCircumference = diameter =>(

Math.PI*diameter;

)

6、默认参数值

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

functionvolume(l, w, h) {if(w ===undefined)

w= 3;if(h ===undefined)

h= 4;returnl * w *h;

}

简写为:

volume = (l, w = 3, h = 4 ) => (l * w *h);

volume(2)//output: 24

7、模板字符串

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

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

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

简写为:

const welcome = `You have loggedinas ${first} ${last}`;

const db= `;

8、解构赋值

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

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

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;

9、展开运算符

展开运算符是在 ES6 中引入的,使用展开运算符能够让 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 arraysconstodd= [1, 3, 5];

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

const arr2= [...arr];

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

constodd= [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)//1console.log(b)//2console.log(z)//{ c: 3, d: 4 }

10、强制参数

默认情况下,如果不向函数参数传值,那么 JavaScript 会将函数参数设置为未定义。其它一些语言则会发出警告或错误。要执行参数分配,可以使用if语句抛出未定义的错误,或者可以利用“强制参数”。

functionfoo(bar) {if(bar ===undefined) {thrownewError('Missing parameter!');

}returnbar;

}

简写为:

mandatory = ( ) =>{thrownewError('Missing parameter!');

}

foo= (bar = mandatory( )) =>{returnbar;

}

11、Array.find

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

const pets =[

{ type:'Dog', name: 'Max'},

{ type:'Cat', name: 'Karl'},

{ type:'Dog', name: 'Tommy'},

]functionfindDog(name) {for(let i = 0; i

}

}

}

简写为:

pet = pets.find(pet => pet.type ==='Dog' && pet.name === 'Tommy');

console.log(pet);//{ type: 'Dog', name: 'Tommy' }

12、Object [key]

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

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

functionvalidate(values) {if(!values.first)returnfalse;if(!values.last)returnfalse;returntrue;

}

console.log(validate({first:'Bruce',last:'Wayne'}));//true

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

//object validation rulesconst schema ={

first: {

required:true},

last: {

required:true}

}//universal validation functionconst validate = (schema, values) =>{for(fieldinschema) {if(schema[field].required) {if(!values[field]) {returnfalse;

}

}

}returntrue;

}

console.log(validate(schema, {first:'Bruce'}));//falseconsole.log(validate(schema, {first:'Bruce',last:'Wayne'}));//true

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

13、双位操作符

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

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

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

简写为:

~~4.9 === 4//true

JavaScript 开发工具推荐

SpreadJS纯前端表格控件是基于 HTML5 的 JavaScript 电子表格和网格功能控件,提供了完备的公式引擎、排序、过滤、输入控件、数据可视化、Excel 导入/导出等功能,适用于 .NET、Java 和移动端等各平台在线编辑类 Excel 功能的表格程序开发。

总结

上述是一些常用的 JavaScript 简写技巧,如果有其它未提及的简写技巧,也欢迎大家补充。

原文链接:

转载请注明出自:葡萄城控件

关于葡萄城

葡萄城成立于1980年,是全球最大的控件提供商,世界领先的企业应用定制工具、企业报表和商业智能解决方案提供商,为超过75%的全球财富500强企业提供服务。葡萄城于1988年在中国设立研发中心,在全球化产品的研发过程中,不断适应中国市场的本地需求,并为软件企业和各行业的信息化提供优秀的软件工具和咨询服务。

本文由pc28.am发布于前端技术,转载请注明出处:支付供给精通的简写技艺,有用的简写手艺

上一篇:让页脚永远停靠在页面底部,页面不够长怎么确 下一篇:没有了
猜你喜欢
热门排行
精彩图文