适用于您日常工作流程的 ESEST 提示、技巧、最佳实践和代码片段示例
es6 (ecmascript 2015) 对 javascript 进行了重大改革,引入了许多新功能,可以简化您的编码并提高项目的整体质量。
在这篇文章中,我们将介绍一些es2015 提示、技巧、最佳实践,并提供代码片段示例来增强您的日常工作流程。
1. 声明变量:let 和 const 与 var
在 es5 中,变量是使用 var 声明的,它具有函数作用域的行为,导致提升和作用域可见性问题。 es6 引入了具有块作用域的 let 和 const,提供了对变量声明的更好控制。
常量:
定义常量变量:
const variablename = "value"
常量变量不能更改、重新分配或重新定义:
const variablename = "other value" //-->syntaxerror: identifier 'variablename' has already been declaredvariablename = "other value" //-->typeerror: assignment to constant variable.
您可以更改、向常量数组添加值,但不能重新分配或重新定义它:
const arrayname = [1,2,3,4]arrayname.push(5) // output -->[1,2,3,4,5]const arrayname = [9,8,7,6] //-->syntaxerror: identifier 'arrayname' has already been declared
您可以更改常量对象、为其添加值,但不能重新分配或重新定义它:
const person = {name:"developer",email:"developer@developer.com",city:"new delhi"}person.name ="developer 2" //change a property person.location = "gurugram" //add a new propertyperson = {name:"dilip",email:"dilip@abc.com",city:"delhi"} //reassign it //-->syntaxerror: identifier 'arrayname' has already been declared
常量变量存在于块作用域中:
var x = 1{ //this is a block scope const x = 2}console.log(x) //output -->1
让:
定义一个let变量:
let variablename = "value"
让变量存在于块作用域中:
var x = 1{ //this is a block scope let x = 2}console.log(x) //output -->1
let 变量不能重新定义,但可以重新赋值:
let variablename = "other value" //-->syntaxerrorvariablename = "other value"
提升 - var 与 let:
由 var 定义的变量被提升到顶部
console.log(sayhello) //output -->undefined//variable sayhello is hoisted at the top before it was defined by var//this means that variable is there but with value of undefinedvar sayhello = "hello world" console.log(sayhello) //output -->"hello world"
let 定义的变量不会被提升到顶部
console.log(sayhello) //-->referenceerror: cannot access 'sayhello' before initialization/definedlet sayhello = "hello world"console.log(sayhello) //output -->"hello world"
for循环中应该使用let而不是var,因为var定义的变量会泄漏到for循环之外,并且只有在有settimeout函数时才会引用i的最终结果:
与 var
for (var i = 0; i the number is 2 (x3) //settimeout reference i after when the for loop endsconsole.log(i) //--> 2//i is leaked outside the for loop
与let
for (let i = 0; i the number is 0 //-->the number is 1 //-->the number is 2
最佳实践:对于不会改变的变量使用const,对于需要在特定块内改变的变量使用let。避免使用 var 以防止与作用域相关的问题。
2. 箭头功能
箭头函数是一种定义函数的新方法,代码更简洁,常用于回调函数。
箭头函数允许我们编写更短的函数语法。
定义一个带有 return 的箭头函数:
let myfunction = (a, b) => { sum = a * b; return sum;}
定义一个不带返回值的箭头函数:
let myfunction = (a, b) => a * b;
如果没有参数,可以直接使用括号:
let myfunction = () => ("hello world");
es6 之前的方式相同
function functionname(param1,param2){ return param1+param2;}
回调函数中常用箭头函数:
let myarr = [1,2,3]let doublethenfilter = arr => arr.map((value) => (value * 2) ) .filter((value) => (value % 3 === 0));doublethenfilter(myarr)
es6 之前的方式相同
function doublethenfilter(arr){ return arr.map(function(value){ return value *2; }).filter(function(value){ return value % 3 === 0; })};
最佳实践:使用箭头函数作为匿名函数和回调,以使代码更短并避免出现问题。
3. 模板文字与字符串连接
在 es5 中,字符串连接需要使用 +,这使得管理复杂或多行字符串变得困难。 es6 引入了模板文字,允许使用反引号嵌入表达式和多行字符串。
模板文字使用反引号 (` `) 而不是引号 ("") 来定义字符串。
模板字符串是您处理字符串的快速方法。
您可以引用变量:
let first = "dilip";let last = "mishra";console.log(`hello, ${first} ${last}`);//output --> "hello, dilip mishra"
es6 之前的方式相同:
let first = "dilip";let last = "mishra";var greeting = 'hello, ' + name + '!';console.log('hello, ' + first + ' ' +last); //output --> "hello, dilip mishra"
模板文字允许在字符串中使用单引号和双引号:
模板文字允许多行字符串。
你可以只换行,使用 tab 而不使用 n t :
let text ='the quickbrown foxjumps overthe lazy dog'; //output --> "the quickbrown foxjumps overthe lazy dog"
模板文字允许在字符串中表达:
let price = 10;let vat = 0.25;let total = 'total: ${(price * (1 + vat)).tofixed(2)}'; //output --> "total: 12.50"
最佳实践:在处理涉及动态内容或跨多行的字符串时,使用模板文字以获得更好的可读性。
4. 解构赋值与传统访问
解构允许您将数组和对象中的值解压到变量中,从而减少重复代码并增强可读性。
定义与属性同名的变量并赋值:
const person = { name: 'john', age: 30 };const { name, age } = person;console.log(name, age); //output --> john 30
定义属性并为具有不同名称的变量赋值:
const person = { name: 'john', age: 30 };const { name:username, age:userage } = person;console.log(username, userage); //output --> john 30
es6 之前的方式相同
var person = { name: 'john', age: 30 };var name = person.name;var age = person.age;console.log(name, age); //output --> john 30
数组解构将数组中的值分配给不同的变量:
var arr = [1,2,3];var [a,b,c] = arr;console.log(a); //-->1console.log(b); //-->2console.log(c); //-->3
最佳实践:使用解构可以更清晰、更直观地访问数组和对象的属性。
5. 默认参数与回退逻辑
es5 需要手动回退逻辑来处理缺失的函数参数,而 es6 引入了默认参数来直接在函数签名中定义回退值。
es5:
function myfunction(x, y) { var y = y || 10; return x + y;}myfunction(5); // will return 15
es6:
function myfunction(x, y = 10) { // y is 10 if not passed or undefined return x + y;}myfunction(5); //output --> will return 15
最佳实践:使用默认参数干净地处理可选函数参数。
6. spread 运算符与 concat() 或 apply()
扩展运算符 (...) 允许更简单地合并数组和对象,并且比使用 concat() 或 apply() 更加直观。
es5:
var arr1 = [1, 2];var arr2 = [3, 4];var combined = arr1.concat(arr2);console.log(combined); // [1, 2, 3, 4]
es6:
const arr1 = [1, 2];const arr2 = [3, 4];const combined = [...arr1, ...arr2];console.log(combined); // [1, 2, 3, 4]
扩展运算符会将数组分解为值,以便可以轻松使用它们:
let nums = [4,5,6];let nums2 = [1,2,3,...nums,7,8];console.log(nums2); //--> [1,2,3,4,5,6,7,8]
扩展运算符通常在函数不接受数组作为参数时使用:
function sumvalues(a,b,c){ console.log(arguments); //print out an array of the arguments of the functionreturn a+b+c;}let nums = [2,3,4];sumvalues(...nums); //values 2,3,4 of nums array has been passed to a,b,c parameters //-->[2,3,4] //-->9sumvalues(5,5,...nums); //value 2 of nums array has been passed to c parameter //-->[5,5,2,3,4] //-->12
另一个例子
let nums = [1,2,3,4];math.min(nums); //--> nanmath.min(...nums); //-->1
最佳实践:使用展开运算符进行数组串联、克隆对象以及将变量参数传递到函数中。
7. promise 与 callbacks
在 es5 中,异步操作通常通过回调来处理,从而导致复杂的“回调地狱”情况。 es6 引入了 promises,它简化了异步代码。
es5:
function fetchdata(callback) { settimeout(function() { callback('data loaded'); }, 1000);}fetchdata(function(data) { console.log(data); // data loaded});
es6:
function fetchdata() { return new promise((resolve, reject) => { settimeout(() => resolve('data loaded'), 1000); });}fetchdata().then(data => console.log(data)); // data loaded
最佳实践:对异步代码使用 promise(以及现代代码中的 async/await),因为它们提供了更清晰、更易于管理的方法。
8. 类与构造函数
es6 引入了类语法作为面向对象编程的构造函数的语法糖。这提供了一种更清晰、更直观的方式来定义和继承类。
es5:
function person(name, age) { this.name = name; this.age = age;}person.prototype.greet = function() { return 'hello, i am ' + this.name;};var john = new person('john', 30);console.log(john.greet()); // hello, i am john
es6:
class person { constructor(name, age) { this.name = name; this.age = age; } greet() { return `hello, i am ${this.name}`; }}const john = new person('john', 30);console.log(john.greet()); // hello, i am john
最佳实践:在 javascript 中使用 oop 模式时,使用类来处理对象创建和继承。
9. 模块(导入/导出)与 iife 或全局函数
在 es6 之前,javascript 没有原生模块支持。开发人员必须使用立即调用函数表达式 (iife) 或依赖全局变量。 es6 引入了导入和导出,允许模块化代码组织。
es5(iife):
(function() { function add(x, y) { return x + y; } window.add = add;})();console.log(add(2, 3)); // 5
es6(模块):
// math.jsexport function add(x, y) { return x + y;}// main.jsimport { add } from './math.js';console.log(add(2, 3)); // 5
最佳实践:使用 es6 模块来实现更好的代码组织、可重用性和更轻松的依赖管理。
10. 异步/等待
异步
放置在函数之前的 ansync 关键字使该函数的行为类似于 promise:
async function myfunc(){ return "this is a promise";}myfunc().then((val)=>{console.log(val)}); //-->"this is a promise"
在异步函数中,return 关键字将充当 promise 中的resolve 关键字, throw 关键字将充当 promise 中的reject 关键字
async function dohomework(){ let isdone = false; if (isdone){ return("is done"); }else{ throw "is not done"; }}dohomework().then(function(homeworkresult){ console.log("the homework " + homeworkresult);}).catch(function(homeworkresult){ console.log("the homework " + homeworkresult);}) //"the homework is not done"
等待
await 关键字仅在 async 函数中使用。 wait 关键字使您的代码等待,直到函数内的 promise 被履行/拒绝:
async function myFunc(){ let myPromise = new Promise((resolve,reject)=>{ setTimeout(()=>{resolve("done!")},1000) }); let result = await myPromise; //wait for this promise before continuing return result;}myFunc().then((result)=>{console.log(result)})
最后的想法
es6 极大地改进了 javascript 的编写和维护方式。在日常工作流程中采用这些技巧和实践不仅会使您的代码更简洁,而且更易于维护和扩展。无论您是从 es5 切换还是增强 es6 技能,这些技巧都将帮助您保持生产力。
欢迎投稿!如果您根据自己的经验有其他提示、技巧或用例,请随时在评论中分享。
编码愉快!