本文共 8165 字,大约阅读时间需要 27 分钟。
英文 | https://javascript.plainenglish.io/34-javascript-optimization-techniques-to-know-in-2021-d561afdf73c3
翻译 | https://www.dsiab.com/post/3922
开发人员的生活总是在学习新事物,并且跟上变化的难度不应该比现在已经难,我的动机是介绍所有JavaScript最佳实践,例如,速记和功能,我们作为前端开发人员必须知道这些使我们的生活在2021年变得更加轻松。
您可能已经进行了很长时间的JavaScript开发,但是有时您可能没有使用不需要解决或编写一些额外代码即可解决问题的最新功能。这些技术可以帮助您编写干净且优化的JavaScript代码。此外,这些主题可以帮助您为2021年的JavaScript采访做好准备。
在这里,我将提供一个新系列,介绍速记技术,这些速记技术可帮助您编写更干净和优化的JavaScript代码。这是您在2021年必须知道的JavaScript编码的备忘单。
我们可以在数组中存储多个值,并且可以使用数组include方法。
//longhandif (x === 'abc' || x === 'def' || x === 'ghi' || x ==='jkl') { //logic}//shorthandif (['abc', 'def', 'ghi', 'jkl'].includes(x)) { //logic}
当我们具有不包含更大逻辑的if-else条件时,这是一个更大的捷径。我们可以简单地使用三元运算符来实现该速记。
// Longhandlet test: boolean;if (x > 100) { test = true;} else { test = false;}// Shorthandlet test = (x > 10) ? true : false;//or we can use directlylet test = x > 10;console.log(test);
当我们有嵌套条件时,我们可以采用这种方式。
let x = 300,test2 = (x > 100) ? 'greater 100' : (x < 50) ? 'less 50' : 'between 50 and 100';console.log(test2); // "greater than 100"
当我们要声明两个具有共同值或共同类型的变量时,可以使用此简写形式。
//Longhand let test1;let test2 = 1;//Shorthand let test1, test2 = 1;
当我们确实创建新变量时,有时我们想检查为其值引用的变量是否为null或未定义。JavaScript确实具有实现这些功能的非常好的捷径。
// Longhandif (test1 !== null || test1 !== undefined || test1 !== '') { let test2 = test1;}// Shorthandlet test2 = test1 || '';
let test1 = null, test2 = test1 || '';console.log("null check", test2); // output will be ""
let test1 = undefined, test2 = test1 || '';console.log("undefined check", test2); // output will be ""
正常值检查
let test1 = 'test', test2 = test1 || '';console.log(test2); // output: 'test'
空合并运算符??如果左侧为null或未定义,则返回右侧的值。默认情况下,它将返回左侧的值。
const test= null ?? 'default';console.log(test);// expected output: "default"const test1 = 0 ?? 2;console.log(test1);// expected output: 0
当我们处理多个变量并希望将不同的值分配给不同的变量时,此速记技术非常有用。
//Longhand let test1, test2, test3;test1 = 1;test2 = 2;test3 = 3;//Shorthand let [test1, test2, test3] = [1, 2, 3];
我们在编程中处理很多算术运算符。这是将运算符分配给JavaScript变量的有用技术之一。
// Longhandtest1 = test1 + 1;test2 = test2 - 1;test3 = test3 * 20;// Shorthandtest1++;test2--;test3 *= 20;
这是我们大家都在使用的常用速记之一,但仍然值得一提。
// Longhandif (test1 === true)// Shorthandif (test1)
注意:如果test1有任何值,它将在if循环后进入逻辑,该运算符通常用于null或未定义的检查。
如果仅在变量为true的情况下才调用函数,则可以使用&&运算符。
//Longhand if (test1) { callMethod(); } //Shorthand test1 && callMethod();
这是迭代的常用速记技术之一。
// Longhandfor (var i = 0; i < testData.length; i++)// Shorthandfor (let i in testData) or for (let i of testData)
每个变量的数组。
function testData(element, index, array) { console.log('test[' + index + '] = ' + element);}[11, 24, 32].forEach(testData);// logs: test[0] = 11, test[1] = 24, test[2] = 32
我们也可以在return语句中使用比较。它将避免我们的5行代码,并将它们减少到1行。
// Longhandlet test;function checkReturn() { if (!(test === undefined)) { return test; } else { return callMe('test'); }}var data = checkReturn();console.log(data); //output testfunction callMe(val) { console.log(val);}// Shorthandfunction checkReturn() { return test || callMe('test');}
//Longhand function add(a, b) { return a + b; } //Shorthand const add = (a, b) => a + b;
更多示例。
function callMe(name) { console.log('Hello', name);}callMe = name => console.log('Hello', name);
我们可以使用三元运算符来实现这些功能。
// Longhandfunction test1() { console.log('test1');};function test2() { console.log('test2');};var test3 = 1;if (test3 == 1) { test1();} else { test2();}// Shorthand(test3 === 1? test1:test2)();
我们可以将条件保存在键值对象中,并可以根据条件使用。
// Longhandswitch (data) { case 1: test1(); break; case 2: test2(); break; case 3: test(); break; // And so on...}// Shorthandvar data = { 1: test1, 2: test2, 3: test};data[something] && data[something]();
使用箭头功能,我们可以直接返回值,而不必编写return语句。
//longhandfunction calculate(diameter) { return Math.PI * diameter}//shorthandcalculate = diameter => ( Math.PI * diameter;)
// Longhandfor (var i = 0; i < 10000; i++) { ... }// Shorthandfor (var i = 0; i < 1e4; i++) {
//Longhandfunction add(test1, test2) { if (test1 === undefined) test1 = 1; if (test2 === undefined) test2 = 2; return test1 + test2;}//shorthandadd = (test1 = 1, test2 = 2) => (test1 + test2);add() //output: 3
//longhand// joining arrays using concatconst data = [1, 2, 3];const test = [4 ,5 , 6].concat(data);//shorthand// joining arraysconst data = [1, 2, 3];const test = [4 ,5 , 6, ...data];console.log(test); // [ 4, 5, 6, 1, 2, 3]
对于克隆,我们也可以使用传播运算符。
//longhand// cloning arraysconst test1 = [1, 2, 3];const test2 = test1.slice()//shorthand// cloning arraysconst test1 = [1, 2, 3];const test2 = [...test1];
如果您厌倦了在单个字符串中使用+来连接多个变量,那么这种速记方式将消除您的头痛。
//longhandconst welcome = 'Hi ' + test1 + ' ' + test2 + '.'//shorthandconst welcome = `Hi ${test1} ${test2}`;
当我们在代码中处理多行字符串时,可以使用以下功能:
//longhandconst data = 'abc abc abc abc abc abc\n\t' + 'test test,test test test test\n\t'//shorthandconst data = `abc abc abc abc abc abc test test,test test test test`
let test1 = 'a'; let test2 = 'b';//Longhand let obj = {test1: test1, test2: test2}; //Shorthand let obj = {test1, test2};
//Longhand let test1 = parseInt('123'); let test2 = parseFloat('12.3'); //Shorthand let test1 = +'123'; let test2 = +'12.3';
//longhandconst test1 = this.data.test1;const test2 = this.data.test2;const test2 = this.data.test3;//shorthandconst { test1, test2, test3 } = this.data;
当我们确实有一个对象数组并且我们想要根据对象属性查找特定对象时,find方法确实很有用。
const data = [{ type: 'test1', name: 'abc' }, { type: 'test2', name: 'cde' }, { type: 'test1', name: 'fgh' },]function findtest1(name) { for (let i = 0; i < data.length; ++i) { if (data[i].type === 'test1' && data[i].name === name) { return data[i]; } }}//ShorthandfilteredData = data.find(data => data.type === 'test1' && data.name === 'fgh');console.log(filteredData); // { type: 'test1', name: 'fgh' }
如果我们有代码来检查类型,并且基于类型需要调用不同的方法,我们可以选择使用多个else if或进行切换,但是如果我们的速记比这更好呢?
// Longhandif (type === 'test1') { test1();}else if (type === 'test2') { test2();}else if (type === 'test3') { test3();}else if (type === 'test4') { test4();} else { throw new Error('Invalid value ' + type);}// Shorthandvar types = { test1: test1, test2: test2, test3: test3, test4: test4};var func = types[type];(!func) && throw new Error('Invalid value ' + type); func();
当我们迭代数组以查找特定值时,我们确实使用indexOf()方法,如果我们找到更好的方法呢?让我们看看这个例子。
//longhandif(arr.indexOf(item) > -1) { // item found }if(arr.indexOf(item) === -1) { // item not found}//shorthandif(~arr.indexOf(item)) { // item found}if(!~arr.indexOf(item)) { // item not found}
按位(〜)运算符将返回非-1的真实值。取反就像做!〜一样简单。另外,我们也可以使用include()函数:
if (arr.includes(item)) { // true if the item found}
此功能有助于将对象转换为对象数组。
const data = { test1: 'abc', test2: 'cde', test3: 'efg' };const arr = Object.entries(data);console.log(arr);/** Output:[ [ 'test1', 'abc' ], [ 'test2', 'cde' ], [ 'test3', 'efg' ]]**/
这也是ES8中引入的一项新功能,它执行与Object.entries()类似的功能,但没有关键部分:
const data = { test1: 'abc', test2: 'cde' };const arr = Object.values(data);console.log(arr);/** Output:[ 'abc', 'cde']**/
(双重NOT按位运算符方法仅适用于32位整数)
// LonghandMath.floor(1.9) === 1 // true// Shorthand~~1.9 === 1 // true
要一次又一次地重复相同的字符,我们可以使用for循环并将它们添加到同一循环中,但是如果我们有一个简写方法呢?
//longhand let test = ''; for(let i = 0; i < 5; i ++) { test += 'test '; } console.log(str); // test test test test test //shorthand 'test '.repeat(5);
const arr = [1, 2, 3]; Math.max(…arr); // 3Math.min(…arr); // 1
let str = 'abc';//Longhand str.charAt(2); // c//Shorthand Note: If we know the index of the array then we can directly use index insted of character.If we are not sure about index it can throw undefinedstr[2]; // c
数学指数幂函数的简写:
//longhandMath.pow(2,3); // 8//shorthand2**3 // 8
学习更多技能
请点击下方web前端开发
转载地址:http://olbpi.baihongyu.com/