async属不属于es6属性

//定义一个普通函数，返回一个字符串
functiontest(){
return"helloasync";
}
constresult1=test();
console.log(result1);//输出一个字符串helloasync

//定义一个使用了async修饰的函数，同样返回一个字符串
asyncfunctiontestAsync(){
return"helloasync";
}
constresult2=testAsync();
console.log(result2);//输出一个Promise对象Promise{:'helloasync'}

//async较好的用法
asyncfunctiontestAsync(){
//返回一个Promise对象
returnnewPromise((resolve,reject)=>{
//处理异步任务
setTimeout(function(){
resolve("testAsync")
},1000);
})
}
//async通常用于声明一个处理异步任务且返回了Promise对象的函数

//定义一个使用async修饰的函数，处理异步任务
asyncfunctiontestAsync(){
returnnewPromise((resolve,reject)=>{
setTimeout(function(){
resolve("testAsync")
},1000);
})
}

//定义一个函数，直接调用testAsync函数
functiontestAwait(){
console.log('testAsync调用前')
testAsync().then(res=>{
console.log(res)//输出"testAsync"
})
console.log('testAsync调用后')
}

/*****输出如下*****/
testAsync调用前
testAsync调用后
testAsync
//尽管代码按顺序写，但不按顺序执行，因为testAsync()是异步函数

//定义一个函数（不使用async声明该函数）用await修饰调用testAsync函数
functiontestAwait(){
console.log('testAsync调用前')
awaittestAsync().then(res=>{//使用await关键字修饰
console.log(res)
})
console.log('testAsync调用后')
}

//调用testAwait()函数
testAwait()
//报错：UncaughtSyntaxError:awaitisonlyvalidinasyncfunctionsandthetoplevelbodiesofmodules，因为await只能使用在被async修饰的函数内。

//定义一个函数（使用async声明该函数）用await修饰调用testAsync函数
asyncfunctiontestAwait(){
console.log('testAsync调用前')
awaittest免费云主机域名Async().then(res=>{
console.log(res)
})
console.log('testAsync调用后')
}

/*****输出如下*****/
testAsync调用前
testAsync
testAsync调用后

//使用了await关键字修饰，使得代码按照顺序执行，即同步执行

//定义一个函数，处理异步任务（使用定时器模拟），返回一个Promise对象
asyncfunctiontestAsync(){
returnnewPromise((resolve,reject)=>{
setTimeout(function(){
resolve("成功调用testAsync")
},1000);
});
}

//定义一个函数，使用await关键字修饰调用testAsync()函数
asyncfunctiontestAwait(){
//使用了await关键字修饰调用testAsyn()函数
awaitthis.testAsync().then(res=>{
console.log(res)//输出的是testAsync()函数resolve的值
});
console.log("helloAsync");
}

//主线程
console.log('testAwait调用前')
testAwait();
console.log('testAwait调用后')

/*****输出结果如下*****/
testAwait调用前
testAwait调用后//因为testAwait()函数使用了async关键字修饰，所以不会阻塞主线程的执行，所以这两句话会先直接输出，然后再执行testAwait()函数
成功调用testAsync//因为testAwait()函数在内部调用testAsync()函数时使用了await关键字修饰，所以在对应的协程上会阻塞，等待testAsync()函数执行完，再输出下面那句'helloAsync'
helloAsync

//例如：
consta=await'HelloAwait'
//相当于
consta=awaitPromise.resolve('HelloAwait');

console.log(a)//输出'HelloAwait'

（3）await的本质是等待它所修饰的Promise对象的fulfilled状态，并把resolve(data)的数据data返回。

asyncfunctiontestAsync(){
returnnewPromise((resolve,reject)=>{
setTimeout(function(){
resolve("成功调用testAsync")
},1000);
});
}

consta=awaittestAsync()//这里的a就会拿到testAsync函数resolve的数据
console.log(a)//在一秒后输出'成功调用testAsync'

asynctestAwait(){
//变量a用于接收testAsync()函数resolve的数据
leta=awaittestAsync().catch(err=>{
//处理异常和reject的数据
})
}

//定义一个函数，该函数接收一个参数，1s后再返回参数的两倍
asyncfunctiondouble(num){
returnnewPromise((resolve,reject)=>{
setTimeout(()=>{//使用定时器模拟异步任务
resolve(2*num)//将运算结果交给resolve
},1000);
})
}

asyncfunctiongetResult(){
console.log('double调用前')//顺序：2
letresult=awaitdouble(10);//将10作为参数传递给double函数
//result变量用于接收double()函数resolve的值
console.log(result);//顺序：4
console.log('double调用后')//顺序：4
}

console.log('getResult调用前')//顺序：1
getResult();
console.log('getResult调用后')//顺序：3

/*****依次输出如下*****/
getResult调用前
double调用前
getResult调用后
20//1s后输出
double调用后

①首先打印输出getResult调用前，同步代码，顺序执行；

//方法一：通过promise对象的catch进行捕获
functiona(){
returnnewPromise((resolve,reject)=>{
setTimeout(()=>{
reject("something")
},1000)
})
}

asyncfunctionb(){
letr=awaita().catch((err)=>{
console.log(err)
})
}

//方法二：通过try/catch语句处理
functiona(){
returnnewPromise((resolve,reject)=>{
setTimeout(()=>{
reject("something")
},1000)
})
}

asyncfunctionb(){
letr=null
try{
r=awaita()
}catch(err){
console.log(err)
}
}

//原本的解决方案
//第二个请求依赖于第一个请求的返回值，第三个请求依赖于第二个请求的返回值
request1().then(function(data){
returnrequest2(data)
}).then(function(data){
returnrequest3(data)
})
//这里只发送了三次请求，代码看起来还不错，虽然它已经比普通的回调函数形式好了很多。
//那如果需要发送五次或十次请求呢？代码也许会没那么美观，接下来我们使用学习到的await去解决这个问题。

//使用await的解决方案
varres1=awaitrequest1()//将request1的返回值赋值给res1
varres2=awaitrequest2(res1)//将res1作为参数传给request2，并将request2的返回值赋值给res2
varres3=awaitrequest3(res2)//同理

//这样子写的代码更加的美观，并且更符合我们平时编写代码的习惯