This article is suitable for any developer based on JavaScript. I wrote this article mainly about some abbreviated codes in JavaScript to help everyone better understand some of the basics of JavaScript. I hope these codes can help you better understand JavaScript from different perspectives.
If you use the if...else statement, then this is a good way to save code.
Longhand:
const x = 20;
let answer;
if (x > 10) {
answer = 'is greater';
} else {
answer = 'is lesser';
}Shorthand:
const answer = x > 10 ? 'is greater' : 'is lesser';
You can also nest like belowifStatement:
const big = x > 10 ? " greater 10" : x
When assigning the value of one variable to another variable, you may want to ensure that the variable is not null, undefined or empty. You can write a conditional statement or Short-circuit Evaluation with multiple if.
Longhand:
if (variable1 !== null || variable1 !== undefined || variable1 !== '') {
let variable2 = variable1;
}Shorthand:
const variable2 = variable1 || 'new';
Don’t believe me, please believe in your own test first (you can put the following The code is pasted in es6console)
let variable1; let variable2 = variable1 || ''; console.log(variable2 === ''); // prints true variable1 = 'foo'; variable2 = variable1 || ''; console.log(variable2); // prints foo
When declaring variables in a function, declaring multiple variables at the same time like the following can save you a lot of time and space:
Longhand:
let x; let y; let x = 3;
Shorthand:
let x, y, z=3;
This is probably trivial, but worth mentioning. When doing "if checks", the assignment operator can sometimes be omitted.
Longhand:
if (likeJavaScript === true)
Shorthand:
if (likeJavaScript)
Note: These two methods are not the same Exactly the same, the abbreviation check will pass as long as likeJavaScript is true.
Here's another example. If a is not true, then what to do.
Longhand:
let a;
if ( a !== true ) {
// do something...
}Shorthand:
let a;
if ( !a ) {
// do something...
}If you just want This little trick is very useful if you want native JavaScript without relying on external libraries like jQuery or Lodash.
Longhand:
for (let i = 0; i < allImgs.length; i++)
Shorthand:
for (let index in allImgs)
Array.forEachAbbreviation:
function logArrayElements(element, index, array) {
console.log("a[" + index + "] = " + element);
}
[2, 5, 9].forEach(logArrayElements);
// logs:
// a[0] = 2
// a[1] = 5
// a[2] = 9If the parameter is null or undefined, we can simply use a Short-circuit logical operation to achieve one line of code replacement How to write six lines of code.
Longhand:
let dbHost;
if (process.env.DB_HOST) {
dbHost = process.env.DB_HOST;
} else {
dbHost = 'localhost';
}Shorthand:
const dbHost = process.env.DB_HOST || 'localhost';
You may have seen this. It is essentially a strange way of writing numbers, that is, there are many 0 after a number. For example, 1e7 is essentially equivalent to 10000000 (1 is followed by 7 0). It represents the decimal notation equal to 10000000.
Longhand:
for (let i = 0; i < 10000; i++) {}Shorthand:
for (let i = 0; i < 1e7; i++) {}
// All the below will evaluate to true
1e0 === 1;
1e1 === 10;
1e2 === 100;
1e3 === 1000;
1e4 === 10000;
1e5 === 100000;Definition of object literals ) makes JavaScript more interesting. ES6 provides a simpler way to assign object properties. If the property name and value are the same, you can use the following abbreviation.
Longhand:
const obj = { x:x, y:y };Shorthand:
const obj = { x, y };Classic functions are easy to read and can be written, but they do get a bit verbose and can confuse you especially when nested functions call other functions.
Longhand:
function sayHello(name) {
console.log('Hello', name);
}
setTimeout(function() {
console.log('Loaded')
}, 2000);
list.forEach(function(item) {
console.log(item);
});Shorthand:
sayHello = name => console.log('Hello', name); setTimeout(() => console.log('Loaded'), 2000); list.forEach(item => console.log(item));
returnA keyword often used in functions will return the final result of the function. Arrow functions use a statement to implicitly return the result (the function must omit the {}, in order to omit the return keyword).
If a multi-line statement (such as an object) is returned, it is necessary to use () instead of {} in the function body. This ensures that the code is returned as a separate statement.
Longhand:
function calcCircumference(diameter) {
return Math.PI * diameter
}Shorthand:
calcCircumference = diameter => ( Math.PI * diameter; )
You can useif statement to define the default values of function parameters. In ES6, default values can be defined in function declarations.
Longhand:
function volume(l, w, h) {
if (w === undefined)
w = 3;
if (h === undefined)
h = 4;
return l * w * h;
}Shorthand:
volume = (l, w = 3, h = 4 ) => (l * w * h); volume(2) //output: 24
Are you tired of using it+To concatenate multiple variables into a string? Isn't there an easier way? If you can use ES6, you're lucky. In ES6, what you have to do is use apostrophes and ${}, and put your variables inside curly braces.
Longhand:
const welcome = 'You have logged in as ' + first + ' ' + last + '.' const db = 'http://' + host + ':' + port + '/' + database;
Shorthand:
const welcome = `You have logged in as ${first} ${last}`;
const db = `http://${host}:${port}/${database}`;If you are using either With popular web frameworks, there are many opportunities to use arrays or data objects to pass information between APIs. Once the data object reaches a component, you need to expand it.
Longhand:
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;
Shorthand:
import { observable, action, runInAction } from 'mobx';
const { store, form, loading, errors, entity } = this.props;You can even specify the variable name yourself:
const { store, form, loading, errors, entity:contact } = this.props;You will find that the code you used to write multi-line strings will look like the following:
Longhand:
const lorem = 'Lorem ipsum dolor sit amet, consectetur\n\t'
+ 'adipisicing elit, sed do eiusmod tempor incididunt\n\t'
+ 'ut labore et dolore magna aliqua. Ut enim ad minim\n\t'
+ 'veniam, quis nostrud exercitation ullamco laboris\n\t'
+ 'nisi ut aliquip ex ea commodo consequat. Duis aute\n\t'
+ 'irure dolor in reprehenderit in voluptate velit esse.\n\t'但还有一个更简单的方法。使用撇号。
Shorthand:
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.`Spread Operator是ES6中引入的，使JavaScript代码更高效和有趣。它可以用来代替某些数组的功能。Spread Operator只是一个系列的三个点(...)。
Longhand:
// 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()
Shorthand:
// 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()函数，使用Spread Operator你可以将一个数组插入到另一个数组的任何地方。
const odd = [1, 3, 5 ]; const nums = [2, ...odd, 4 , 6];
另外还可以当作解构符：
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 }默认情况下，JavaScript如果不给函数参数传一个值的话，将会是一个undefined。有些语言也将抛出一个警告或错误。在执行参数赋值时，你可以使用if语句，如果未定义将会抛出一个错误，或者你可以使用强制参数（Mandatory parameter）。
Longhand:
function foo(bar) {
if(bar === undefined) {
throw new Error('Missing parameter!');
}
return bar;
}Shorthand:
mandatory = () => {
throw new Error('Missing parameter!');
}
foo = (bar = mandatory()) => {
return bar;
}如果你以前写过一个查找函数，你可能会使用一个for循环。在ES6中，你可以使用数组的一个新功能find()。
Longhand:
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];
}
}
}Shorthand:
pet = pets.find(pet => pet.type ==='Dog' && pet.name === 'Tommy');
console.log(pet); // { type: 'Dog', name: 'Tommy' }你知道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这个函数可以正常工作。然而，需要考虑一个这样的场景：有很多种形式需要应用验证，而且不同领域有不同规则。在运行时很难创建一个通用的验证功能。
Shorthand:
// 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现在我们有一个验证函数，可以各种形式的重用，而不需要为每个不同的功能定制一个验证函数。
如果你是一位JavaScript新手的话，对于逐位运算符（Bitwise Operator）你应该永远不会在任何地方使用。此外，如果你不处理二进制0和1，那就更不会想使用。
然而，一个非常实用的用例，那就是双位操作符。你可以用它替代Math.floor()。Double Bitwise NOT运算符有很大的优势，它执行相同的操作要快得多。你可以在这里阅读更多关于位运算符相关的知识。
Longhand:
Math.floor(4.9) === 4 //true
Shorthand:
~~4.9 === 4 //true
The above is the detailed content of 19 Tips for JavaScript Coding. For more information, please follow other related articles on the PHP Chinese website!
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
