目录
一旦状态改变了就不会在变，也就是说任何时候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>