目录
一旦状态改变了就不会在变,也就是说任何时候Promise都只有一种状态。
Promise
1:定义
Promise是异步编程的一种解决方案,可以替代传统的解决方案--回调函数和事件。ES6统一了用法,并原生提供了Promise对象。作为对象,Promise有一下两个特点:
-
对象的状态不受外界影响。
Promise对象代表一个异步操作,有三种状态:pending(进行中)、fulfilled(已成功)和rejected(已失败)。只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。这也是Promise这个名字的由来,它的英语意思就是“承诺”,表示其他手段无法改变。
-
一旦状态改变了就不会在变,也就是说任何时候Promise都只有一种状态。
Promise对象的状态改变,只有两种可能:从pending变为fulfilled和从pending变为rejected。只要这两种情况发生,状态就凝固了,不会再变了,会一直保持这个结果,这时就称为 resolved(已定型)。
2:三种状态
Pending状态(进行中)Fulfilled状态(已成功) Rejected状态(已失败)
一旦发生改变就只有一种状态:Pending -> Fulfilled Pending -> Rejected。
3:基本用法
Resolve,用来接收完成状态,reject用来接收失败的状态。
var promise = new Promise(function(resolve,reject){
let flag = true;
if(flag){
resolve('状态:执行成功!');
}else{
reject("状态:执行失败!");
}
})
promise.then(function(resolve){
console.log(resolve);
},function(reject){
console.log(reject);
})
说明:then方法可以接受两个回调函数作为参数。第一个回调函数是Promise对象的状态变为resolved时调用,第二个回调函数是Promise对象的状态变为rejected时调用。这两个函数都是可选的,不一定要提供。它们都接受Promise对象传出的值作为参数。
4:模拟异步
模拟未来即将发生的代码。
function timeout(ms){
return new Promise(function(relove,reject){
setTimeout(()=>{
console.log('程序'+ms +'毫秒后打印!');
},ms);
})
}
timeout(3000);
5:执行步骤
function timeout(ms){
console.log(2);
return new Promise(function(relove,reject){
setTimeout(()=>{
console.log(3);
relove(4);
},ms);
})
}
console.log(1);
let res = timeout(3000);
res.then(relove=>{
console.log(relove);
})
说明:Promise 新建后立即执行,所以首先输出的是Promise。然后,then方法指定的回调函数,将在当前脚本所有同步任务执行完才会执行,所以4最后输出。
课件代码
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script>
// 1:promise的基本语法
const flag = 1;
const mypromise= new Promise((resolve,reject)=>{
//异步请求
if(flag==2){
resolve("成功的数据");
}else{
reject("失败的数据");
}
});
mypromise.then((resolve)=>{//成功的业务逻辑
console.log(resolve);
},(reject)=>{//失败的业务逻辑
console.log(reject);
})
// 2:模拟异步
console.log("1");
const MyPromise = new Promise((resolve,reject)=>{
console.log("2");
setTimeout(()=>{//模拟异步,不是真的异步
console.log("5");
resolve("成功的数据");
},3000);
})
console.log("3");
MyPromise.then((resolve)=>{ //异步:接收Promise的状态
console.log(resolve);
})
console.log("4");
// 总结:promise 只要new 里面的代码会立即执行
let myPomise=new Promise((resolve,reject)=>{
setTimeout(()=>{
resolve("成功了")
},3000)
})
myPomise.then((resolve)=>{
console.log(resolve);
}
,(reject)=>{
console.log(reject);
})
</script>
</body>
</html>
封装ajax
const sendajax = function(url){
return new Promise(function(reslove,reject){
//创建对象
const o = new XMLHttpRequest();
o.open('GET',url);//初始化
o.send();//发送
//接收状态 绑定事件
o.onreadystatechange = function(){
if(o.readyState === 4){ //标识请求发送结束
if(o.status>=200 && o.status<300){//
reslove(o.response);
}else{
reject(o.status);//失败的状态码
}
}
}
})
}
let test = sendajax('https://api.apiopen.top/getJoke');
test.then(function(value){
console.log(value);
},function(reason){
console.log(reason);
})
7:Proimse.prototype.then
Promise 实例具有then方法,也就是说,then方法是定义在原型对象Promise.prototype上的。它的作用是为 Promise 实例添加状态改变时的回调函数。then方法的第一个参数是resolved状态的回调函数,第二个参数是rejected状态的回调函数,参数可选。
then方法返回的是一个新的Promise实例(注意,不是原来那个Promise实例)。因此可以采用链式写法,即then方法后面再调用另一个then方法。根据这一特性我们可以采用链式方法:
function sayhi(){
let mypromise = new Promise(function(resolve,reject){
let str = "hello world";
resolve(str);
})
return mypromise;
}
sayhi().then(function(value){
console.log(value);
return value;
}).then(function(value){
console.log(value+2);
return value;
})
8:Promise.prototype.catch()
Promise.prototype.catch()方法是.then(null, rejection)或.then(undefined, rejection)的别名,用于指定发生错误时的回调函数。
let myfun = function(){
let mypromise = new Promise(function(resolve,reject){
reject('错误');
})
return mypromise;
}
//发生错误的时捕获
myfun().catch(function(e){
console.error(e);
});
课件代码
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script>
封装
function sendAjax(url){//封装求ajax的地址
return new Promise((resolve,reject)=>{
const ajax = new XMLHttpRequest();
ajax.open("GET",url);//以get方式打开的请求地址
ajax.send();//发送地址
ajax.onreadystatechange = ()=>{
if(ajax.readyState==4){//服务器请求状态
if(ajax.status==200){//http状态码
const data = JSON.parse(ajax.response);
if(data.code==200){//后台接口的状态
resolve(data.lists);
}else{
reject("数据接口请求失败!");
}
}
}
}
})
}
const MyPromise = sendAjax("http://127.0.0.1:8848/web2210/test.json");
MyPromise.then((resolve)=>{
//要么就操作dom
//逻辑处理
//程序的业务逻辑
console.log(resolve);
})
链式写法
function sayHi(){
const MyPormise = new Promise((resolve,reject)=>{
let str = "hello";
resolve(str);
})
return MyPormise;
}
const MyPromise = sayHi();
MyPromise.then((resolve)=>{
console.log(resolve);
return resolve+"2";
}).then((resolve)=>{
console.log(resolve);
})
catch
function sayHi() {
const MyPormise = new Promise((resolve, reject) => {
reject("失败的数据");
})
return MyPormise;
}
sayHi().then((resolve)=>{
},(reject)=>{
console.log(reject);
})
sayHi().catch((e) => {//只抓错误,成功的业务逻辑不需要管理
console.log(e);
})
</script>
</body>
</html>
async 和 await
async和await两种语法结合可以让异步代码像同步代码一样。
4.1.1 async 函数
async 是一个修饰符,async 定义的函数会默认的返回一个Promise对象resolve的值,因此对async函数可以直接进行then操作,返回的值即为then方法的传入函数。
举例:
async function fn(){
//1.如果返回的是一个非Promise的对象,则fn()返回的结果就是成功状态的Promise对象,值为返回值
//2.如果返回的是一个Promise对象,则fn()返回的结果与内部Promise对象的结果一致
//3.如果返回的是抛出错误,则fn()返回的就是失败状态的Promise对象
return new Promise((resolve,reject)=>{
resolve('成功的数据');
});
}
const result = fn();
result.then(
value=>{
console.log(value) //成功的数据
},reason=>{
console.log(reason) //失败的数据
})
4.1.2 await表达式
它也是一个修饰符,await 关键字 只能放在 async 函数内部, await关键字的作用 就是获取 Promise中返回的内容, 获取的是Promise函数中resolve值。
1:await必须放在async函数中
2:await右侧的表达式一般为promise对象
3:await可以返回的是右侧promise成功的值
4:await右侧的promise如果失败了,就会抛出异常,需要通过try…catch捕获处理
举例:
const bbb = function(){ return 'string'}
async function funAsy() {
const a = await 1
const b = await new Promise((resolve, reject)=>{
setTimeout(function(){
console.log(‘b执行了’)
resolve('time')
}, 3000)
})
const c = await bbb()
console.log(a, b, c)
}
funAsy() // 运行结果是 3秒钟之后 ,输出 1, time , string
如果Promise 不加await 会立刻输出 1 string,3秒后输入:”b执行了”。
4.1.3 ajax综合应用
function sendAjax(url) {
return new Promise((resolve, reject) => {
//创建对象
const x = new XMLHttpRequest();
//初始化
x.open('GET', url);
//发送
x.send();
//时间绑定
x.onreadystatechange = () => { //onreadystatechange 回调后的状态
if (x.readyState === 4) {
if (x.status >= 200 && x.status < 300) {
//成功
resolve(x.response)
} else {
//失败
reject(x.status)
}
}
}
// readyState 状态说明:
// 0:代理创建,未调用open()方法;
// 1:open方法已调用
// 2:send()方法一调用
// 3:LOADING 数据下载中 responseText已经有值
// 4:下载操作完成
// status:返回网页状态,200~299都是正常状态,404 not found。
})
}
//async 与 await 测试
async function main() {
let result = await sendAjax("https://api.apiopen.top/getJoke")
mytext = JSON.parse(result);
console.log(mytext.result[0].sid,mytext.result[0].text);
}
main()
课件代码
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<script>
// 1:async的用法
async function myfun(){
// 1:返回非promise对象 那么这个函数返回的就是promise对象成功的状态
// return "succ";
// 2:返回的是promise对象,那么这个函数返回的promise对象与内部一致
return new Promise((resolve,reject)=>{
reject("error");
})
}
const MyPromise = myfun();
MyPromise.then((resolve)=>{
console.log(resolve);
},(reject)=>{
console.log(reject);
})
2:async和await用法
await 修饰的Promise 返回值 是成功的值
await 等待的意思
async function demo(){
try{
const a = 1;
const b = await new Promise((resolve,reject)=>{
setTimeout(()=>{
console.log("promise执行了...");
resolve("error");//成的值
},3000)
})
const c = 3;
console.log(a,b,c);
}catch(e){
console.log(11);
}
}
const MyPromise = demo();
封装
function sendAjax(url){//封装求ajax的地址
return new Promise((resolve,reject)=>{
const ajax = new XMLHttpRequest();
ajax.open("GET",url);//以get方式打开的请求地址
ajax.send();//发送地址
ajax.onreadystatechange = ()=>{
if(ajax.readyState==4){//服务器请求状态
if(ajax.status==200){//http状态码
const data = JSON.parse(ajax.response);
if(data.code==200){//后台接口的状态
resolve(data.lists);
}else{
reject("数据接口请求失败!");
}
}
}
}
})
}
async function getInfo(){
const data = await sendAjax("http://127.0.0.1:8848/web2210/test.json");
//下面的代码依赖data
console.log(data);
}
getInfo();
</script>
</body>
</html>