Promise笔记-同步回调-异步回调-JS中的异常error处理-Promis的理解和使用-基本使用-链式调用-七个关键问题

JavaScript中Promise的理解与使用
最新推荐文章于 2025-09-03 17:12:21 发布
原创 最新推荐文章于 2025-09-03 17:12:21 发布 · 822 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#笔记 #javascript #okhttp

本文围绕JavaScript展开，先介绍实例对象与函数对象、回调函数类型及JS异常处理等预备知识，重点阐述Promise。包括其概念、状态、值和基本使用，说明使用Promise的原因，介绍多种使用方法，还探讨改变状态、回调顺序、串联任务、异常穿透和中断链等关键问题。

Promise笔记

1. 预备知识

1.1 实例对象与函数对象

  • 实例对象：new 函数产生的对象，称为实例对象，简称为对象

  • 函数对象：将函数作为对象使用时，称为函数对象

function Fn() { // Fn只能称为函数
}
//前面fn称为实例对象，后面fn称为构造函数
const fn = new Fn() // Fn只有new过的才可以称为构造函数

console.log(Fn.prototype)// Fn作为对象使用时，才可以称为函数对象
Fn.bind({}) //Fn作为函数对象使用
$('#test') // $作为函数使用
$.get('/test') // $作为函数对象使用

()左边是函数，点左边是对象(函数对象、实例对象)

1.2 两种类型的回调函数

1. 同步回调

立即执行，完全执行完了才结束，不会放入回调队列中

数组遍历 相关的回调 / Promise的executor函数

const arr = [1, 3, 5];
arr.forEach(item => { // 遍历回调，同步回调，不会放入队列，一上来就要执行
  console.log(item);
})
console.log('forEach()之后')

在这里插入图片描述

2. 异步回调

不会立即执行，会放入回调队列中将来执行

定时器 回调 / ajax回调 / Promise 成功或失败的回调

// 定时器回调
setTimeout(() => { // 异步回调，会放入队列中将来执行
  console.log('timeout callback()')
}, 0)
console.log('setTimeout()之后')

在这里插入图片描述

// Promise 成功或失败的回调
new Promise((resolve, reject) => {
  resolve(1)
}).then(
  value => {console.log('value', value)},
  reason => {console.log('reason', reason)}
)
console.log('----')
// ----
// value 1

js 引擎先把初始化的同步代码都执行完成后，才执行回调队列中的代码

1.3 JS中的异常error处理

1. 错误的类型

Error：所有错误的父类型

ReferenceError：引用的变量不存在

console.log(a) // ReferenceError:a is not defined

RangeError：数据值不在其所允许的范围内

function fn() {
  fn()
}
fn()
// RangeError:Maximum call stack size exceeded

SyntaxError：语法错误

const c = """"
// SyntaxError:Unexpected string
2. 错误处理（捕获与抛出）

抛出错误：throw error

function something() {
  if (Date.now()%2===1) {
    console.log('当前时间为奇数，可以执行任务')
  } else { //如果时间为偶数抛出异常，由调用来处理
    throw new Error('当前时间为偶数，无法执行任务')
  }
}

捕获错误：try ... catch

// 捕获处理异常
try {
  something()
} catch (error) {
  alert(error.message)
}
3. 错误对象

  • massage 属性：错误相关信息

  • stack 属性：函数调用栈记录信息

try {
  let d
  console.log(d.xxx)
} catch (error) {
  console.log(error.message)
  console.log(error.stack)
}
console.log('出错之后')
// Cannot read property 'xxx' of undefined
// TypeError:Cannot read property 'xxx' of undefined
// 出错之后

因为错误被捕获处理了，后面的代码才能运行下去，打印出‘出错之后’

2.Promise的理解和使用

2.1 Promise是什么

1.理解Promise

抽象表达：Promise是JS中进行异步编程的新的解决方案(旧方案是单纯使用回调函数)
【推荐阅读 【JavaScript】同步与异步-异步与并行-异步运行机制-为什么要异步编程-异步与回调-回调地狱-JavaScript中的异步操作】
---- 异步编程 ①fs 文件操作 ②数据库操作 ③Ajax ④定时器

具体表达：
①从语法上看：Promise是一个构造函数 (自己身上有all、reject、resolve这几个方法，原型上有then、catch等方法)
②从功能上看：promise对象用来封装一个异步操作并可以获取其成功/失败的结果值

阮一峰的解释：
所谓Promise，简单说就是一个容器，里面保存着某个未来才会结束的事件（通常是一个异步操作）的结果
从语法上说，Promise 是一个对象，从它可以获取异步操作的消息
Promise 提供统一的 API，各种异步操作都可以用同样的方法进行处理

2.Promise 的状态

实例对象promise中的一个属性 PromiseState

pending 变为 resolved/fullfilled
pending 变为 rejected
注意

  • 对象的状态不受外界影响

  • 只有这两种，且一个 promise 对象只能改变一次

  • 一旦状态改变，就不会再变，任何时候都可以得到这个结果

  • 无论成功还是失败，都会有一个结果数据。成功的结果数据一般称为 value，而失败的一般称为 reason。

3. Promise对象的值

实例对象promise的另一个值 PromiseResult
保存着对象 成功/失败 的值（value/reason）

resolve/reject可以修改值

4. Promise 的基本使用
const promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(reason);
  }
});

Promise构造函数接受一个函数（执行器函数）作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由 JavaScript 引擎提供，不用自己部署。

resolve函数的作用是，将Promise对象的状态从“未完成”变为“成功”（即从 pending 变为 resolved），在异步操作成功时调用，并将异步操作的结果，作为参数value传递出去；
reject函数的作用是，将Promise对象的状态从“未完成”变为“失败”（即从 pending 变为 rejected），在异步操作失败时调用，并将异步操作报出的错误，作为参数error/reason传递出去。

Promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数。

promise.then(function(value) {
  // success
}, function(reason) {
  // failure
});

then方法可以接受两个回调函数作为参数。
第一个回调函数onResolved()是Promise对象的状态变为resolved时调用
第二个回调函数onRejected()是Promise对象的状态变为rejected时调用
这两个函数都是可选的，不一定要提供。它们都接受Promise对象传出的值作为参数

  • 一个例子
// 创建一个新的p对象promise
const p = new Promise((resolve, reject) => { // 执行器函数
  // 执行异步操作任务
  setTimeout(() => {
    const time = Date.now() 
    // 如果当前时间是偶数代表成功，否则失败
    if (time % 2 == 0) {
      // 如果成功，调用resolve(value)
      resolve('成功的数据，time=' + time)
    } else {
      // 如果失败，调用reject(reason)
      reject('失败的数据，time=' + time)
    }
  }, 1000);
})

p.then(
  value => { // 接收得到成功的value数据 onResolved
    console.log('成功的回调', value)  // 成功的回调 成功的数据，time=1615015043258
  },
  reason => { // 接收得到失败的reason数据 onRejected
    console.log('失败的回调', reason)    // 失败的回调 失败的数据，time=1615014995315
  }
)

.then() 和执行器(executor)同步执行，.then() 中的回调函数异步执行

2.2 为什么要用 Promise

1.指定回调函数的方式更加灵活

旧的：必须在启动异步任务前指定

// 1. 纯回调的形式
// 成功的回调函数
function successCallback(result) {
  console.log("声音文件创建成功：" + result);
}
// 失败的回调函数
function failureCallback(error) {
  console.log("声音文件创建失败：" + error);
}
// 必须先指定回调函数，再执行异步任务
createAudioFileAsync(audioSettings, successCallback, failureCallback) // 回调函数在执行异步任务（函数）前就要指定

promise：启动异步任务 => 返回promise对象 => 给promise对象绑定回调函数(甚至可以在异步任务结束后指定)

// 2. 使用Promise
const promise = createAudioFileAsync(audioSettings);  // 执行2秒
setTimeout(() => {
  promise.then(successCallback, failureCallback) // 也可以获取
}, 3000);

具体参考
03promise基本使用.html
04为什么使用Promise.html

2.支持链式调用，可以解决回调地狱问题

什么是回调地狱？

回调函数嵌套调用，外部回调函数异步执行的结果是其内部嵌套的回调函数执行的条件

doSomething(function(result) {
  doSomethingElse(result, function(newResult) {
    doThirdThing(newResult, function(finalResult) {
      console.log('Got the final result:' + finalResult)
    }, failureCallback)
  }, failureCallback)
}, failureCallback)
回调地狱的缺点？

  1. 不便于阅读

  2. 不便于异常处理

解决方案？
  • promise 链式调用

使用 promise 的链式调用解决回调地狱

doSomething()
  .then(result => doSomethingElse(result))
  .then(newResult => doThirdThing(newResult))
  .then(finalResult => {console.log('Got the final result:' + finalResult)})
  .catch(failureCallback)
终极解决方案？
  • async/await

回调地狱的终极解决方案 async/await

async function request() {
  try{
    const result = await doSomething()
    const newResult = await doSomethingElse(result)
    const finalResult = await doThirdThing(newResult)
    console.log('Got the final result:' + finalResult)
  } catch (error) {
    failureCallback(error)
  }
}

2.3 如何使用 Promise

  1. Promise 构造函数：Promise(executor) {}
    executor 函数：同步执行 (resolve, reject) => {}

resolve 函数：内部定义成功时调用的函数 resove(value)

reject 函数：内部定义失败时调用的函数 reject(reason)

说明：executor 是执行器，会在 Promise 内部立即同步回调，异步操作 resolve/reject 就在 executor 中执行

  1. Promise.prototype.then 方法：p.then(onResolved, onRejected)
    指定两个回调（成功+失败）

onResolved 函数：成功的回调函数 (value) => {}

onRejected 函数：失败的回调函数 (reason) => {}

说明：指定用于得到成功 value 的成功回调和用于得到失败 reason 的失败回调，返回一个新的 promise 对象

  1. Promise.prototype.catch 方法：p.catch(onRejected)
    指定失败的回调

1）onRejected 函数：失败的回调函数 (reason) => {}

说明：这是then() 的语法糖，相当于 then(undefined, onRejected)

new Promise((resolve, reject) => { // excutor执行器函数
 setTimeout(() => {
   if(...) {
     resolve('成功的数据') // resolve()函数
   } else { 
     reject('失败的数据') //reject()函数
    }
 }, 1000)
}).then(
 value => { // onResolved()函数
  console.log(value) // 成功的数据
}
).catch(
 reason => { // onRejected()函数
  console.log(reason) // 失败的数据
}
)

Promise.resolve 方法：Promise.resolve(value)
value：将被 Promise 对象解析的参数，也可以是一个成功或失败的 Promise 对象

返回：返回一个带着给定值解析过的 Promise 对象，如果参数本身就是一个 Promise 对象，则直接返回这个 Promise 对象。

如果传入的参数为 非Promise类型的对象, 则返回的结果为成功promise对象

Promise.resolve 是 JavaScript 中的一个方法，它是 Promise 对象的一部分，用于将一个给定的值解析为一个 Promise。下面详细介绍 Promise.resolve 方法的特点：

  1. 值解析：

  • 当传递一个非 Promise 类型的值给 Promise.resolve 方法时，它会返回一个新的 Promise 对象，该对象会立即解析为传递的值。

  • 例如: Promise.resolve(42) 将返回一个解析为 42 的 Promise 对象。

  1. Promise 对象：

  • 如果传递一个已经是 Promise 对象的值给 Promise.resolve 方法，它将直接返回这个 Promise 对象，而不会创建一个新的 Promise 对象。

  • 例如: 如果 p 是一个 Promise 对象，Promise.resolve(p) 将直接返回 p。

  1. 对象解析：

  • 如果传递的值是一个包含 then 方法的对象，Promise.resolve 将尝试返回一个新的 Promise 对象，并尝试执行该对象的 then 方法。

  • 例如: 如果有一个对象 o 有一个 then 方法，Promise.resolve(o) 将尝试执行 o.then。

这个方法通常用于确保一个值是 Promise 对象，如果不是的话，就将它转换为一个 Promise 对象。这对于处理异步操作非常有用，特别是当你不确定一个值是否是 Promise 对象时，Promise.resolve 可以确保你始终都有一个 Promise 对象来工作。

举个例子，你可能有一个函数，它可能返回一个值或一个 Promise。使用 Promise.resolve 可以确保你总是得到一个 Promise，从而可以在该 Promise 上使用 .then() 或 .catch() 方法。

产生一个成功值为521的promise对象

let p1 = Promise.resolve(521);
console.log(p1); // Promise {<fulfilled>: 521}

在这里插入图片描述

1. Promise.reject 方法：Promise.resolve(reason)

reason：失败的原因

说明：返回一个失败的 promise 对象

let p = Promise.reject(521);
let p2 = Promise.reject('iloveyou');
let p3 = Promise.reject(new Promise((resolve, reject) => {
    resolve('OK');
}));

console.log(p);
console.log(p2);
console.log(p3);

在这里插入图片描述

2.Promise.all 方法：Promise.all(iterable)

iterable：包含 n 个 promise 的可迭代对象，如 Array 或 String

说明：返回一个新的 promise，只有所有的 promise 都成功才成功，只要有一个失败了就直接失败

let p1 = new Promise((resolve, reject) => {
  resolve('OK');
})
let p2 = Promise.resolve('Success');
let p3 = Promise.resolve('Oh Yeah');

const result = Promise.all([p1, p2, p3]);
console.log(result);

在这里插入图片描述

let p1 = new Promise((resolve, reject) => {
  resolve('OK');
})
let p2 = Promise.reject('Error');
let p3 = Promise.resolve('Oh Yeah');

const result = Promise.all([p1, p2, p3]);
console.log(result);

在这里插入图片描述

const p1 = Promise.resolve(1)
const p2 = Promise.resolve(2)
const p3 = Promise.reject(3)

const pAll = Promise.all([p1, p2, p3])
const pAll2 = Promise.all([p1, p2])
//因为其中p3是失败所以pAll失败
pAll.then(
value => {
   console.log('all onResolved()', value)
 },
reason => {
   console.log('all onRejected()', reason) 
 }
)
// all onRejected() 3
pAll2.then(
values => {
   console.log('all onResolved()', values)
 },
reason => {
   console.log('all onRejected()', reason) 
 }
)
// all onResolved() [1, 2]
3.Promise.race方法：Promise.race(iterable)

iterable：包含 n 个 promise 的可迭代对象，如 Array 或 String

说明：返回一个新的 promise，第一个完成的 promise 的结果状态就是最终的结果状态
谁先完成就输出谁(不管是成功还是失败)

const pRace = Promise.race([p1, p2, p3])
// 谁先完成就输出谁(不管是成功还是失败)
const p1 = new Promise((resolve, reject) => {
 setTimeout(() => {
   resolve(1)
 }, 1000)
})
const p2 = Promise.resolve(2)
const p3 = Promise.reject(3)

pRace.then(
value => {
   console.log('race onResolved()', value)
 },
reason => {
   console.log('race onRejected()', reason) 
 }
)
//race onResolved() 2

3.Promise 的几个关键问题

1.如何改变 promise 的状态？

(1)resolve(value)：如果当前是 pending 就会变为 resolved

(2)reject(reason)：如果当前是 pending 就会变为 rejected

(3)抛出异常：如果当前是 pending 就会变为 rejected

const p = new Promise((resolve, reject) => {
  //resolve(1) // promise变为resolved成功状态
  //reject(2) // promise变为rejected失败状态
  throw new Error('出错了') // 抛出异常，promise变为rejected失败状态，reason为抛出的error
})
p.then(
  value => {},
  reason => {console.log('reason',reason)}
)
// reason Error:出错了

2. 一个 promise 指定多个成功/失败回调函数，都会调用吗？

当 promise 改变为对应状态时都会调用

const p = new Promise((resolve, reject) => {
  //resolve(1)
  reject(2)
})
p.then(
  value => {},
  reason => {console.log('reason',reason)}
)
p.then(
  value => {},
  reason => {console.log('reason2',reason)}
)
// reason 2
// reason2 2

3. 改变 promise 状态和指定回调函数谁先谁后？

都有可能，常规是先指定回调再改变状态，但也可以先改状态再指定回调

  • 如何先改状态再指定回调？

(1)在执行器中直接调用 resolve()/reject()

(2)延迟更长时间才调用 then()

  1. 直接在执行器中调用 resolve()/reject(): Promise会立即解决，然后你可以在后面指定then()的回调。
let p = new Promise((resolve, reject) => {
    resolve('OK');
});

// 在这里，我们可能有其他的同步或异步代码

p.then(value => {
    console.log(value);
});
  1. 通过setTimeout延迟指定回调：即使Promise很快解决，仍然可以使用setTimeout来延迟指定回调。
let p = new Promise((resolve, reject) => {
    resolve('OK');
});

setTimeout(() => {
    p.then(value => {
        console.log(value);
    });
}, 1000);
  1. 在其他Promise的回调中指定：如果我们有另一个Promise，并在其回调中指定新的回调，那么根据这两个Promises的解决速度，任何情况都有可能发生。
let p1 = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve('First');
    }, 500);
});

let p2 = new Promise((resolve, reject) => {
    resolve('OK');
});

p1.then(value => {
    p2.then(value2 => {
        console.log(value2);
    });
});

在上面的例子中，即使p2立即解决，p2的回调函数也不会立即执行，因为它被指定在p1的回调中，而p1是在500ms后解决的。

这些例子确实表明Promise的状态变化和回调函数的执行顺序是灵活的，并取决于如何编写和组合代码。

什么时候才能得到数据？

(1)如果先指定的回调，那当状态发生改变时，回调函数就会调用得到数据

(2)如果先改变的状态，那当指定回调时，回调函数就会调用得到数据

new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve(1) // 改变状态
  }, 1000)
}).then( // 指定回调函数 （先指定）
  value => {},
  reason =>{}
)

此时，先指定回调函数，保存当前指定的回调函数；后改变状态(同时指定数据)，然后异步执行之前保存的回调函数。

new Promise((resolve, reject) => {
  resolve(1) // 改变状态
}).then( // 指定回调函数
  value => {},
  reason =>{}
)

这种写法，先改变的状态(同时指定数据)，后指定回调函数(不需要再保存)，直接异步执行回调函数

4. promise.then() 返回的新 promise 的结果状态由什么决定？

(1)简单表达：由 then() 指定的回调函数执行的结果决定

let p = new Promise((resolve, reject) => {
  resolve('ok');
});
//执行 then 方法
let result = p.then(value => {
  console.log(value);
}, reason => {
  console.warn(reason);
});

console.log(result);

在这里插入图片描述

(2)详细表达：

​ ① 如果抛出异常，新 promise 变为 rejected，reason 为抛出的异常

let p = new Promise((resolve, reject) => {
  resolve('ok');
});
//执行 then 方法
let result = p.then(value => {
  //1. 抛出错误
  throw '出了问题';
}, reason => {
  console.warn(reason);
});

console.log(result);

在这里插入图片描述

② 如果返回的是非 promise 的任意值，新 promise 变为 resolved，value 为返回的值

let p = new Promise((resolve, reject) => {
  resolve('ok');
});
//执行 then 方法
let result = p.then(value => {
	//2. 返回结果是非 Promise 类型的对象
	return 521;
}, reason => {
  console.warn(reason);
});

console.log(result);

在这里插入图片描述

③ 如果返回的是另一个新 promise，此 promise 的结果就会成为新 promise 的结果

let p = new Promise((resolve, reject) => {
  resolve('ok');
});
//执行 then 方法
let result = p.then(value => {
	//3. 返回结果是 Promise 对象
	return new Promise((resolve, reject) => {
		// resolve('success');
		reject('error');
	});
}, reason => {
  console.warn(reason);
});

console.log(result);

在这里插入图片描述

没有继续传递return 就是undefined

new Promise((resolve, reject) => {
  resolve(1)
}).then(
  value => {
    console.log('onResolved1()', value)
  },
  reason => {
    console.log('onRejected1()', reason)
  }
).then(
  value => {
    console.log('onResolved2()', value)
  },
  reason => {
    console.log('onRejected2()', reason)
  }
)
// onResolved1() 1
// onResolved2() undefined


new Promise((resolve, reject) => {
  resolve(1)
}).then(
  value => {
    console.log('onResolved1()', value)
    //return 2                   // onResolved2() 2
    //return Promise.resolve(3)  // onResolved2() 3
    //return Promise.reject(4)   // onRejected2() 4
    //throw 5                    // onRejected2() 5
  },
  reason => {
    console.log('onRejected1()', reason)
  }
).then(
  value => {
    console.log('onResolved2()', value)
  },
  reason => {
    console.log('onRejected2()', reason)
  }
)
// onResolved1() 1
// onResolved2() undefined
// Promise {<fulfilled>: undefined}
// 对应输出如上所示

5.promise 如何串联多个操作任务？

(1)promise 的 then() 返回一个新的 promise，可以并成 then() 的链式调用

(2)通过 then 的链式调用串联多个同步/异步任务

let p = new Promise((resolve, reject) => {
  setTimeout(() => {
      resolve('OK');
  }, 1000);
});

p.then(value => {
  return new Promise((resolve, reject) => {
      resolve("success");
  });
}).then(value => {
  console.log(value); // success
}).then(value => {
  console.log(value); // undefined
})

在这里插入图片描述

new Promise((resolve, reject) => {
  setTimeout(() => {
    console.log('执行任务1(异步)')
    resolve(1)
  }, 1000)
}).then(
  value => {
    console.log('任务1的结果', value)
    console.log('执行任务2(同步)')
    return 2 // 同步任务直接return返回结果
  }
).then(
  value => {
    console.log('任务2的结果', value)
    return new Promise((resolve, reject) => { // 异步任务需要包裹在Promise对象中
      setTimeout(() => {
        console.log('执行任务3(异步)')
        resolve(3)
      }, 1000)
    })
  }
).then(
  value => {
    console.log('任务3的结果', value)
  }
)
// 执行任务1(异步)
// 任务1的结果 1
// 执行任务2(同步)
// 任务2的结果 2
// 执行任务3(异步)
// 任务3的结果 3

6.Promise 异常穿透(传透)？

(1)当使用 promise 的 then 链式调用时，可以在最后指定失败的回调

(2)前面任何操作出了异常，都会传到最后失败的回调中处理

new Promise((resolve, reject) => {
   //resolve(1)
   reject(1)
}).then(
  value => {
    console.log('onResolved1()', value)
    return 2
  }
).then(
  value => {
    console.log('onResolved2()', value)
    return 3
  }
).then(
  value => {
    console.log('onResolved3()', value)
  }
).catch(
  reason => {
    console.log('onRejected1()', reason)
  }
)
// onRejected1() 1

相当于这种写法：多写了很多reason => {throw reason}

new Promise((resolve, reject) => {
   //resolve(1)
   reject(1)
}).then(
  value => {
    console.log('onResolved1()', value)
    return 2
  },
  reason => {throw reason} // 抛出失败的结果reason
).then(
  value => {
    console.log('onResolved2()', value)
    return 3
  },
  reason => {throw reason} // 抛出失败的结果reason
).then(
  value => {
    console.log('onResolved3()', value)
  },
  reason => {throw reason} // 抛出失败的结果reason
).catch(
  reason => {
    console.log('onRejected1()', reason)
  }
)
// onRejected1() 1

所以失败的结果是一层一层处理下来的，最后传递到 catch 中。

或者，将 reason => {throw reason} 替换为 reason => Promise.reject(reason) 也是一样的

7.中断 promise 链？

当使用 promise 的 then 链式调用时，在中间中断，不再调用后面的回调函数

办法：在回调函数中返回一个 pending 状态的 promise 对象

new Promise((resolve, reject) => {
   //resolve(1)
   reject(1)
}).then(
  value => {
    console.log('onResolved1()', value)
    return 2
  }
).then(
  value => {
    console.log('onResolved2()', value)
    return 3
  }
).then(
  value => {
    console.log('onResolved3()', value)
  }
).catch(
  reason => {
    console.log('onRejected1()', reason)
  }
).then(
  value => {
    console.log('onResolved4()', value)
  },
  reason => {
    console.log('onRejected2()', reason)
  }
)
// onRejected1() 1
// onResolved4() undefined

为了在 catch 中就中断执行，可以这样写：

new Promise((resolve, reject) => {
   //resolve(1)
   reject(1)
}).then(
  value => {
    console.log('onResolved1()', value)
    return 2
  }
).then(
  value => {
    console.log('onResolved2()', value)
    return 3
  }
).then(
  value => {
    console.log('onResolved3()', value)
  }
).catch(
  reason => {
    console.log('onRejected1()', reason)
    return new Promise(() => {}) // 返回一个pending的promise
  }
).then(
  value => {
    console.log('onResolved4()', value)
  },
  reason => {
    console.log('onRejected2()', reason)
  }
)
// onRejected1() 1

在 catch 中返回一个新的 promise，且这个 promise 没有结果。

由于，返回的新的 promise 结果决定了后面 then 中的结果，所以后面的 then 中也没有结果。

这就实现了中断 promise链的效果。

JavaScript Promise的错误处理（五）
小帅的编程笔记
10-06 1022
今天我们来学习在Promise中如何处理异常错误。 假设有一个getUserById函数用来获取用户，它返回一个promise。 function getUserById(id) { return new Promise((resolve, reject) => { resolve({ id: id, username: 'admin' }); }); } throw new Error 在返回promise之前，如果id参数不合法throw一个异常
深入理解 Promise：使用指南与手动实现
vvilkin的学习备忘
03-04 1428
Promise是一个表示异步操作最终完成（或失败）及其结果值的对象。Pending（等待中）：初始状态，既不是成功，也不是失败。Fulfilled（已成功）：操作成功完成。Rejected（已失败）：操作失败。Promise的核心功能是通过thencatch和finally方法处理异步操作的结果。通过本文，我们学习了Promise的基本用法，包括创建、使用、链式调用以及静态方法。同时，我们还手动实现了一个简化版的Promise，深入理解了Promise。
Promise中有resolve和无resolve的代码执行顺序
秦时明月的专栏
03-12 1795
请写出下面代码的输出顺序： 示例1： console.log('script start') new Promise(function(resolve) { console.log('promise') resolve() console.log('promise after resolve') }).then(function() { console.log('promise then') }) console.log('script end') 示例2： console.log('
使用 Promise 时的5个常见错误
粉丝们务必加入微信粉丝群
11-26 3110
作者：Ravidu Perera 译者：前端小智 来源：medium 有梦想，有干货，微信搜索 【大迁世界】 关注这个在凌晨还在刷碗的刷碗智。 本文 GitHub https://github.com/qq449245884/xiaozhi 已收录，有一线大厂面试完整考点、资料以及我的系列文章。 Promise 提供了一种优雅的方法来处理 JS 中的异步操作。这也是避免“回调地狱”的解决方案。然而，并没有多少开发人员了解其中的内容。因此，许多人在实践中往往会犯错误。 在本文中，介绍一下使用 pro.
JavaScript错误处理：分析 Uncaught(in promise) error
2301_81431930的博客
10-22 6676
当我们使用Promise进行异步编程时，Uncaught(in promise) error 是一个常见的错误类型。在上述示例中，将Promise的代码放在一个async函数中，并使用await关键字等待Promise对象。如果Promise的状态变成rejected，那么catch方法会被调用，我们就可以在里面处理这个错误。如果代码上不方便使用catch方法或者不能使用catch方法处理Promise的错误，我们可以使用async/await语法糖来捕获Promise的错误。3.3 全局异常处理。
JavaScript异步回调的Promise模式封装实例
01-19
异步请求完成的操作必须预先定义在回调函数中，等到请求完成就必须调用这个函数。这种非线性的异步编程方式会让开发者很不适应，同时也带来了诸多的不便，增加了代码的耦合度和复杂性，代码的组织上也会很不优雅，...
Promise回调处理和简洁的处理方案
m_suki的博客
09-03 825
Promise 提供了强大的异步编程能力，通过合理的链式调用、async/await 语法糖和各种静态方法，可以编写出既简洁又易于维护的异步代码。结合高级模式如错误处理中间件、超时控制和重试机制，可以构建更健壮的异步应用。选择哪种方式取决于具体场景和个人偏好，但 async/await 通常是使代码最接近同步风格的选择，特别适合复杂的异步逻辑。而 Promise 的静态方法则非常适合处理多个并行的异步操作。
WeChat Mini-Program High-frequency API toolkit - 一款使用 promis
最新发布
09-16
Promise是JavaScript异步编程的一种解决方案，它的出现使得异步编程更加清晰，易于理解。通过promise模式，开发者可以将异步操作以同步的流程进行书写，大大增强了代码的可读性和可维护性。而且，Promise对象代表了...
vue-resource调用promise取数据方式详解
08-29
Promise对象可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。 在Vue-Resource中，可以使用Promise API来处理响应结果。使用then方法可以处理响应结果，then方法有两个参数，第一个参数是响应...
前端知识点---promise链(javascript)
2302_80171619的博客
03-31 968
Promise 链（Promise chain）是指通过 Promise 对象的 then() 方法将多个异步操作按顺序串联起来，实现异步操作的顺序执行。每个 then() 方法都会返回一个新的 Promise，从而可以继续调用后续的 then() 方法。通过链式调用，可以避免回调地狱（callback hell），使代码更加简洁和可读。
js 将Promise改为同步操作
Misnice的博客
05-16 1890
js 将Promise改为同步操作。async/await实现。
Promise篇
weixin_34406086的博客
06-12 162
Promise 原理解析与实现(遵循Promise/A+规范) 1什么是Promise？ Promise是JS异步编程中的重要概念，异步抽象处理对象，是目前比较流行Javascript异步编程解决方案之一 2 对于几种常见异步编程方案 回调函数 事件监听 发布/订阅 Promise对象 这里就拿回调函数...
在JavaScript中使用Promises时最常见的3个错误
i_am_someone的博客
08-18 508
在JavaScript中使用Promises时最常见的3个错误 Promise 在 JavaScript 中有着举足轻重的地位。即使如今引入了 async/await ，Promise 对 JS 开发人员来说仍旧是不可或缺的。
用vue中的Promise封装axios并实现同步返回值
HelloMyCode的博客
07-18 7886
Promise封装axios(封装的方法网上很多，不详细写了) 可参考： https://www.kancloud.cn/cooldrw2015/vue_2/1163405 https://www.jianshu.com/p/0229211ea679 /** * post方法，对应post请求 * @param {String} url [请求的url地址] * @param {Obj...
Promise 的错误处理方式
qq_46177396的博客
12-16 4346
Promise 的错误处理方式
Promise中的同步与异步
grx1125的博客
11-10 2124
关于Promise中，Promise对象本身、resolve、then、catch的同步异步，异步中的宏队列和微队列的讨论内容。
Promise常见错误
weixin_44766633的博客
06-18 294
源代码如下： function runap() { let p1 = new Promise(function (resolve, reject) { setTimeout(function () { console.log('1'); resolve('222'); }, 1000) }) .
Uncaught (in promise) Error
热门推荐
以沫wh的博客
06-17 3万+
报Uncaught (in promise) Error错误解决办法 基本上是因为使用promise出现的，下面记录一下我的解决办法，有两种情况 使用axios请求接口时，在then()后加上catch() export function stopMCUMixTranscode(params) { return new Promise((resolve, reject) => { axios .post(`********`, params) .then((re
Promise从入门到手写
good god~的博客
04-09 491
Promise深入 + 自定义Promise 1. 准备 1.1. 函数对象与实例对象 1. 函数对象: 将函数作为对象使用时, 简称为函数对象 2. 实例对象: new 函数产生的对象, 简称为对象 1.2. 回调函数的分类 1. 同步回调: 理解: 立即执行, 完全执行完了才结束, 不会放入回调队列中 例子: 数组遍历相关的回调函数 / Promise的excutor函数 2. 异步回调: 理解: 不会立即执行, 会放入回调队列中将来执行 例子: 定时器回调 / a
smartconfig: promis scan ret -1
08-21
<think>我们正在处理的是ESP-IDF中SmartConfig配网时出现的错误：`promis scan ret -1`。根据错误信息，这通常表示在启动混杂模式扫描时出现了问题。错误码-1通常对应`ESP_FAIL`，表示一般性错误，但我们需要结合上下文具体分析。 参考用户提供的引用[1]，我们知道SmartConfig例程位于`smartconfig_main.c`中。同时引用[2]提到可以通过`menuconfig`进行配置，引用[3]则提醒我们注意目标芯片平台（如ESP32-S3）的编译设置。 ### 问题分析：`promis scan ret -1`错误 该错误发生在SmartConfig尝试启动混杂模式（promiscuous mode）扫描时。可能的原因包括： 1. **WiFi驱动状态冲突**：WiFi接口可能处于无法启动混杂模式的状态（如正在连接、断开或扫描中）[^1]。 2. **资源不足**：内存不足或WiFi任务队列满。 3. **配置问题**：`menuconfig`中WiFi相关配置不正确。 4. **硬件限制**：某些ESP32系列芯片的混杂模式有特殊要求。 --- ### 一、核心解决方案 #### 1. 检查并重置WiFi状态 在启动SmartConfig前，确保WiFi处于正确的状态： ```c // 停止SmartConfig（如果之前运行过） esp_smartconfig_stop(); // 断开WiFi连接 esp_wifi_disconnect(); // 停止WiFi esp_wifi_stop(); // 重新初始化WiFi esp_wifi_init(); // 设置模式为STA（工作站模式） esp_wifi_set_mode(WIFI_MODE_STA); // 启动WiFi esp_wifi_start(); ``` #### 2. 添加状态检查 在调用`esp_smartconfig_start()`之前，检查WiFi状态： ```c wifi_mode_t mode; ESP_ERROR_CHECK(esp_wifi_get_mode(&mode)); if (mode != WIFI_MODE_STA) { ESP_LOGE(TAG, "WiFi is not in STA mode!"); return; } ``` #### 3. 增加延迟 在关键操作之间添加短暂延迟，确保状态稳定： ```c esp_wifi_stop(); vTaskDelay(100 / portTICK_PERIOD_MS); // 等待100ms esp_wifi_start(); ``` #### 4. 检查menuconfig配置 通过`idf.py menuconfig`检查以下配置： - **Component config → Wi-Fi → WiFi softAP support**：启用（即使使用STA模式，某些底层功能依赖此选项）[^2]。 - **Component config → ESP32-specific → WiFi task core affinity**：建议设置为Core 0（避免多核冲突）。 - **Component config → Wi-Fi → WiFi IRAM speed optimization**：启用（提升性能）。 --- ### 二、错误处理增强 在SmartConfig事件处理函数中捕获错误事件： ```c static void smartconfig_event_handler(void* arg, esp_event_base_t base, int32_t id, void* data) { if (base == SC_EVENT && id == SC_EVENT_SCAN_DONE) { esp_smartconfig_stop(); // 扫描完成后停止SmartConfig // 处理扫描结果 } else if (base == SC_EVENT && id == SC_EVENT_SEND_ACK_DONE) { // SmartConfig完成 } else if (base == WIFI_EVENT && id == WIFI_EVENT_STA_DISCONNECTED) { // 处理断开连接 } else if (base == SC_EVENT && id == SC_EVENT_ERROR) { // 处理错误 smartconfig_event_got_error_t *error_data = (smartconfig_event_got_error_t *)data; ESP_LOGE(TAG, "SmartConfig error: %d", error_data->error); if (error_data->error == SC_ERROR_PROMIS_SCAN) { // 针对混杂模式扫描错误的处理 ESP_LOGE(TAG, "Promiscuous scan failed, retrying..."); vTaskDelay(1000 / portTICK_PERIOD_MS); esp_smartconfig_stop(); start_smartconfig(); // 重新启动SmartConfig } } } ``` --- ### 三、深入排查 #### 1. 检查内存泄漏 在`menuconfig`中启用内存调试： ``` Component config → ESP System Settings → Memory debugging → Enable heap memory debugging → Enable heap tracing ``` 运行后检查是否有内存泄漏导致资源不足。 #### 2. 更新ESP-IDF版本 使用最新稳定版ESP-IDF（如v5.1+），修复可能存在的驱动问题： ```bash cd ~/esp/esp-idf git checkout release/v5.1 git pull git submodule update ``` #### 3. 芯片特定配置 对于ESP32-S3，需确认以下配置： - **SPIRAM支持**：如果使用外部RAM，在`menuconfig`中启用`Component config → ESP32S3-specific → Support for external, SPI-connected RAM`。 - **WiFi协议模式**：确保设置为802.11b/g/n（兼容SmartConfig）： ```c wifi_config_t wifi_config = { .sta = { .threshold.authmode = WIFI_AUTH_WPA2_PSK, .sae_pwe_h2e = WPA3_SAE_PWE_BOTH, }, }; esp_wifi_set_config(WIFI_IF_STA, &wifi_config); ``` --- ### 四、替代方案 若问题持续，考虑以下替代方案： 1. **使用BLE配网**：通过蓝牙传输WiFi凭证（更稳定）[^3]。 2. **Web配网**：启动AP模式，用户连接热点后通过网页配置。 > **关键点**：根据引用[1]的实践，**状态重置是解决扫描错误的最有效方法**（90%案例有效），务必在SmartConfig启动前执行完整的状态清理。 §§相关问题§§ 1. ESP32-S3 如何优化 WiFi 性能以减少配网失败？ 2. SmartConfig 和 BLE 配网有何性能差异？ 3. 如何实现配网模式的自动故障切换？</think>### ESP-IDF SmartConfig 混杂模式扫描错误 `promis scan ret -1` 排查指南 #### 一、错误原因分析 `promis scan ret -1` 表示 ESP32 在启动混杂模式（Promiscuous Mode）扫描时失败。错误码 `-1` 对应 `ESP_FAIL`（通用错误），常见原因包括： 1. **WiFi 状态冲突** - 当 WiFi 处于连接中（`WIFI_EVENT_STA_CONNECTING`）或扫描中时，无法启动混杂模式[^1] - 典型场景：SmartConfig 启动时 WiFi 尚未完成初始化 2. **资源冲突** - 内存不足（需至少 4KB 空闲堆内存） - 同时运行其他 WiFi 任务（如 STA+AP 模式） 3. **配置错误** - `menuconfig` 中 WiFi 参数未正确配置（如未启用混杂模式支持） - 射频参数不兼容（如信道设置超出范围） 4. **时序问题** - 未等待 WiFi 初始化完成就启动 SmartConfig - 未正确处理状态机转换 --- #### 二、解决方案 ##### 1. 强制 WiFi 状态重置（关键步骤） ```c // 在启动 SmartConfig 前执行 esp_wifi_disconnect(); // 断开连接 esp_wifi_stop(); // 停止 WiFi vTaskDelay(200 / portTICK_PERIOD_MS); // 等待 200ms ESP_ERROR_CHECK(esp_wifi_start()); // 重启 WiFi ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA)); // 确认 STA 模式 ``` ##### 2. 检查 menuconfig 配置 通过 `idf.py menuconfig` 验证： ```bash Component config → Wi-Fi → [*] Enable WiFi RX IRAM speed optimization [*] WiFi softAP support # 必须启用 [*] WiFi promiscuous support # 关键配置！ (11) WiFi channel # 推荐固定信道 ``` > **注意**：ESP32-S3 需额外启用 `SPIRAM` 支持[^3] ##### 3. 优化启动时序 ```c void start_smartconfig() { // 等待 WiFi 初始化完成 while(esp_wifi_init() != ESP_OK) { vTaskDelay(100 / portTICK_PERIOD_MS); } // 添加安全延迟 vTaskDelay(500 / portTICK_PERIOD_MS); // 启动 SmartConfig smartconfig_start_config_t cfg = SMARTCONFIG_START_CONFIG_DEFAULT(); ESP_ERROR_CHECK(esp_smartconfig_start(&cfg)); } ``` ##### 4. 内存优化 添加内存检查防止资源不足： ```c size_t free_heap = esp_get_free_heap_size(); if (free_heap < 4096) { // 确保最小 4KB 空闲内存 ESP_LOGE("SMARTCONFIG", "内存不足! 空闲: %d bytes", free_heap); esp_restart(); // 或执行内存回收 } ``` ##### 5. 错误处理增强 在事件处理函数中捕获错误： ```c static void smartconfig_event_handler(void* arg, esp_event_base_t base, int32_t id, void* data) { if (id == SC_EVENT_ERROR) { smartconfig_event_got_error_t *error = (smartconfig_event_got_error_t*)data; if (error->error == SC_ERROR_PROMIS_SCAN) { ESP_LOGE("SC", "混杂扫描失败! 错误码: %d", error->error); // 执行状态重置 esp_wifi_stop(); vTaskDelay(100); esp_wifi_start(); } } } ``` --- #### 三、高级调试技巧 1. **启用详细日志** 在 `menuconfig` 中： ``` Component config → Log output → Default log verbosity → Debug Component config → Wi-Fi → [*] Enable WiFi debug log (Verbose) ``` 2. **WiFi 状态机监控** 添加状态跟踪： ```c wifi_mode_t mode; esp_wifi_get_mode(&mode); ESP_LOGI("WIFI", "当前模式: %s", (mode == WIFI_MODE_STA) ? "STA" : (mode == WIFI_MODE_AP) ? "AP" : "STA+AP"); ``` 3. **信道扫描测试** 验证基础扫描功能： ```c wifi_scan_config_t scan_conf = { .scan_type = WIFI_SCAN_TYPE_ACTIVE, .scan_time = { .active = { .min = 100, .max = 300 } } }; ESP_ERROR_CHECK(esp_wifi_scan_start(&scan_conf, false)); ``` --- #### 四、替代方案 若问题持续，考虑： 1. **BLE 配网** 使用 `esp_ble_prov` 通过蓝牙传输 WiFi 凭证 2. **Web 配网** 启动 AP 模式提供配置页面： ```c esp_wifi_set_mode(WIFI_MODE_APSTA); wifi_config_t ap_config = { .ap = { .ssid = "ESP32-Config", .password = "12345678", .max_connection = 3 } }; esp_wifi_set_config(WIFI_IF_AP, &ap_config); ``` > **关键点**：根据引用[1]的实践，**90% 的混杂扫描失败源于状态冲突**，通过预重置可解决大部分问题[^1]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值