JavaScript异步编程——06-Promise入门详解【万字长文，感谢支持】

前言

Promise 是 JavaScript 中特有的语法。可以毫不夸张得说，Promise 是ES6中最重要的语法，没有之一。初学者可能对 Promise 的概念有些陌生，但是不用担心。大多数情况下，使用 Promise 的语法是比较固定的。我们可以先把这些固定语法和结构记下来，多默写几遍；然后在实战开发中逐渐去学习和领悟 Promise 的原理、底层逻辑以及细节知识点，自然就慢慢掌握了。

在了解 Promise 之前，必须要知道什么是回调函数，这是必不可少的前置知识。关于回调函数的知识，已经在上一篇文章中做了讲解。

Promise 的介绍和优点（为什么需要 Promise？）

Promise 是异步编程的一种新的解决方案和规范。ES6将其写进了语言标准，统一了用法，原生提供了 Promise 对象。

Promise 对象, 可以用同步的表现形式来书写异步代码（也就是说，代码看起来是同步的，但本质上的运行过程是异步的）。使用 Promise 主要有以下优点：

  • 1、可以很好地解决ES5中的回调地狱的问题（避免了层层嵌套的回调函数）。

  • 2、统一规范、语法简洁、可读性和和可维护性强。

  • 3、Promise 对象提供了简洁的 API，使得管理异步任务更方便、更灵活。

从语法上讲，Promise 是一个构造函数。从功能上来说，Promise 对象用于封装一个异步操作，并获取其成功/ 失败的结果值。

从写法规范上讲，Promise 本质上是处理异步任务的一种编写规范，要求每个人都按照这种规范来写。异步任务成功了该怎么写、异步任务失败了该怎么写、成功或者失败之后怎么通知调用者，这些都有规定的写法。Promise 的目的就是要让每个使用ES6的人都遵守这种写法规范。

Promise 的伪代码结构，大概是这样的：

 // 伪代码1
 myPromise()
     .then(
         function () {},
         function () {}
     )
     .then(
         function () {},
         function () {}
     )
     .then(
         function () {},
         function () {}
     );
 ​
 // 伪代码2
 是时候展现真正的厨艺了().然后(买菜).然后(做饭).然后(洗碗);

上面的伪代码可以看出，业务逻辑上层层递进，但是代码写法上却十分优雅，没有过多的嵌套。

Promise 的基本使用

ES5中，使用传统的回调函数处理异步任务时，其基本模型的写法已在上一篇内容“回调函数”里讲过。

ES6中，有了 Promise之后，我们可以对那段代码进行改进（基本模型不变）。你会发现，代码简洁规范了许多。

使用 Promise 处理异步任务的基本代码结构如下，我们先来认识一下：

 
// 使用 Promise 处理异步任务的基本模型
 ​
 // 封装异步任务
 function requestData(url) {
   // resolve 和 reject 这两个单词是形参，可以自由命名。大家的习惯写法是写成 resolve 和 reject
   const promise = new Promise((resolve, reject) => {
     const res = {
       retCode: 0,
       data: 'qiangu yihao`s data',
       errMsg: 'not login',
     };
     setTimeout(() => {
       if (res.retCode == 0) {
         // 网络请求成功
         resolve(res.data);
       } else {
         // 网络请求失败
         reject(res.errMsg);
       }
     }, 1000);
   });
   return promise;
 }
 ​
 ​
 // 调用异步任务
 requestData('www.qianguyihao.com/index1').then(data => {
   console.log('异步任务执行成功:', data);
 }).catch(err=> {
   console.log('异步任务执行失败:', err);
 })
 ​
 // 再次调用异步任务
 requestData('www.qianguyihao.com/index2').then(data => {
   console.log('异步任务再次执行成功:', data);
 }).catch(err=> {
   console.log('异步任务再次执行失败:', err);
 })
 ​
 ​
 // 调用异步任务（写法2）
 /* 这段代码的写法比较啰嗦。一般推荐上面的写法。
 const myPromise = requestData('www.qianguyihao.com/index1');
 myPromise.then(data => {
   console.log('异步任务执行成功:', data);
 });
 myPromise.catch(err => {
   console.log('异步任务执行失败:', err);
 });
 ​
 const myPromise2 = requestData('www.qianguyihao.com/index2');
 myPromise2.then(data => {
   console.log('异步任务执行成功:', data);
 });
 myPromise2.catch(err => {
   console.log('异步任务执行失败:', err);
 });
 */

在日常开发中使用Promise时，80%以上的场景都符合上面的代码结构。你说它重不重要？我们暂且先记下，默写十遍，形成肌肉记忆，然后继续往下边学习边理解。

Promise 的状态和回调函数

Promise的三种状态是我们需要学习的第一个概念，也是最重要的概念，理解它才能理解 Promise的用法。

Promise 对象的 3 种状态

在使用 Promise 时，我们可以将它划分为三种状态：

  • pending：等待中。属于初始状态，既没有被兑现，也没有被拒绝。

  • fulfilled：已兑现/已解决/成功。执行了resolve() 时，立即处于该状态，表示 Promise已经被解决，任务执行成功。

  • rejected：已拒绝/失败。执行了 reject()时，立即处于该状态，表示 Promise已经被拒绝，任务执行失败。

具体解释：

1、Promise 的中文名翻译为“承诺”（一般不称呼中文名）。resolve 的中文翻译为“解决”，reject 的中文翻译为“拒绝”。

2、当 new Promise()执行之后，promise 对象的状态会被初始化为pending，这个是初始状态。new Promise()这行代码，括号里的内容是同步执行的。括号里可以再定义一 异步任务的 function，function 有两个参数：resolve 和 reject。如下：

  • 如果异步任务成功了，请执行 resolve()，此时，promise 的状态会自动变为 fulfilled。

  • 如果异步任务失败了，请执行 reject()，此时，promise 的状态会自动变为 rejected。

3、什么时候算成功，什么时候算失败呢？这是你自己定的，需要结合具体需求和业务逻辑灵活决定。

关于 promise 的状态改变，以及如何处理状态改变，伪代码及详细注释如下：

 // 创建 promise 实例
 const promise = new Promise((resolve, reject) => {
   //进来之后，promise 的状态为 pending
   console.log('同步代码'); //这行代码是同步的
   //开始执行异步操作（这里开始，根据具体需求写异步的代码，比如ajax请求 or 开启定时器）
   if (异步的ajax请求成功) {
     console.log('233');
     // 如果请求成功了，请写resolve()，此时，promise的状态会自动变为fulfilled（成功状态）
     resolve('请求成功，并传参');
   } else {
     // 如果请求失败了，请写reject()，此时，promise的状态会被自动变为rejected（失败状态）
     reject('请求失败，并传参');
   }
 });
 console.log('qianguyihao');
 ​
 //调用promise的then()：开始处理成功和失败
 promise.then(
   successValue => {
     // 处理 promise 的成功状态：如果promise的状态为fulfilled，则执行这里的代码
     console.log(successValue, '回调成功了'); // 这里的 successMsg 是前面的 resolve('请求成功，并传参')  传过来的参数
   },
   errorMsg => {
     //处理 promise 的失败状态：如果promise的状态为rejected，则执行这里的代码
     console.log(errorMsg, '回调失败了'); // 这里的 errorMsg 是前面的 reject('请求失败，并传参') 传过来的参数
   }
 );

上面的注释要多看几遍。

Promise 的回调函数

Promise的回调函数，伪代码如下：

 const promise = new Promise(executor);
 ​
 // 【划重点】下面这两行代码是等价的，选其中一种写法即可。这两种写法没有区别，只是写法形式上的区别
 promise.then(onFulfilled, onRejected);
 ​
 promise.then(onFulfilled).catch(onRejected);

Promise是一个类，通过 new Promise() 进行实例化，构造出一个 Promise 实例对象。

1、Promise 的构造函数中需要传入一个参数，这个参数是一个回调函数，常用于处理异步任务。这个回调函数有一个专有名词叫 executor（执行器），因为在 new Promise() 时，这个函数会立即执行。

可以在该回调函数中传入两个参数：resolve 和 reject。我们可以在适当的时机执行 resolve()、reject()，用于改变当前 Promise 实例的状态到成功或失败。

（2）当Promise状态变为成功时，会触发 then() 方法里的回调函数的执行，对成功的返回结果进行处理。

（3）当Promise状态变为失败时，会触发 catch() 方法里的回调函数的执行，，对失败的返回结果进行处理。

2、then()方法的括号里面有两个参数，分别代表两个回调函数 onFulfilled 和 onRejected，这两个函数一直处于监听状态：

  • 参数1：成功的回调函数。如果 Promise 的状态为 fulfilled（意思是：任务执行成功），则触发 onFulfilled 函数的执行。

  • 参数2：失败的回调函数。如果 Promise 的状态为 rejected（意思是，任务执行失败），则触发 onRejected 函数的执行。

3、只有 Promise 的状态被改变之后，才会走到 then() 或者 catch()。也就是说，在 new Promise() 时，如果没有写 resolve()，则 promise.then() 不执行；如果没有写 reject()，则 promise.catch() 不执行。

4、resolve()和 reject()这两个方法，可以给 promise.then()、promise.catch()传递参数。

5、then() 可以被多次调用，会按照顺序执行。比如：

 const promise = new Promise(executor);
 ​
 // then() 可以被多次调用
 promise.then(onFulfilled, onRejected);
 promise.then(onFulfilled, onRejected);

Promise的状态图

image-20230624100254023

上面的Promise状态图很经典，需要反复研读，了然于胸。

Promise 的状态一旦改变，就不能再变

Promise 的状态一旦改变，就确定下来了，不能再变。也不能再次执行 resolve()或者 reject()来改变状态。Promise 的状态改变，是不可逆的。

代码举例：

 const p = new Promise((resolve, reject) => {
     resolve(1); // 代码执行到这里时， promise状态是 fulfilled
     resolve(111); // 这行重复代码写了没用，等于没写
     reject(2); // 尝试修改状态为 rejected，是不行的。因为状态执行到上面的 resolve(1)时，已经被改变了。
 });
 ​
 p.then((res) => {
     console.log(res);
 }).catch((err) => {
     console.log(err);
 });

上方代码的打印结果是 1，而不是 2，详见注释。

new Promise() 是同步代码

new Promise()这行代码本身是同步的。promise 如果没有使用 resolve 或 reject 更改状态时，状态为 pending，里面的代码是同步代码。

举例 1：（重要）

 // 会立即创建 Promise 实例
 const promise1 = new Promise((resolve, reject) => {
   // 这行代码会立即执行
   console.log('qianguyihao1');
 })
 ​
 console.log(promise1); // 此时 promise1 的状态为 pending（准备阶段）
 ​
 // 需要调用 promise2函数，才会创建 Promise 实例
 function promise2() {
   return new Promise((resolve, reject) => {
     // 这行代码不会立即执行
     console.log('qianguyihao2');
   })
 }

上面的代码中，我既没有写 reslove()，也没有写 reject()。那么，Promise 一直处于准备阶段。

此外，需要特别注意的是，promise1 中的 console.log() 会立即执行，因为Promise的执行器函数在创建 Promise 实例时就会被调用，并立即开始执行其中的代码逻辑。

举例 2：

 new Promise((resolve, reject) => {
     console.log('promise1'); // 这行代码是同步代码，会立即执行
 }).then((res) => {
     console.log('promise then:' + res); // 这行代码不会执行，因为前面没有写 resolve()，所以走不到 .then
 });

打印结果：

promise1

上方代码，仔细看注释：如果前面没有写 resolve()，那么后面的 .then是不会执行的。

举例 3：

new Promise((resolve, reject) => {
    resolve();
    console.log('promise1'); // 代码1：同步任务，会立即执行
}).then(res => {
    console.log('promise  then'); // 代码2：异步任务中的微任务
});

console.log('千古壹号'); // 代码3：同步任务

打印结果：

promise1
千古壹号
promise  then

代码解释：

当完成异步任务之后，状态分为成功或失败，此时我们就可以用 reslove() 和 reject() 来修改 promise 的状态。

代码 1 是同步代码，所以最先执行。代码 2 是微任务里面的代码，所以要先等同步任务（代码 3）先执行完。当写完resolve();之后，就会立刻把 .then()里面的代码加入到微任务队列当中。

补充知识：异步任务分为“宏任务”、“微任务”两种。我们到后续的章节中再详细讲。

Promise 封装定时器

传统写法

写法 1：

// 定义一个异步的延迟函数：异步函数结束1秒之后，再执行cb回调函数
function fun1(cb) {
    setTimeout(function () {
        console.log('即将执行cb回调函数');
        cb();
    }, 1000);
}

// 先执行异步函数 fun1，再执行回调函数 myCallback
fun1(myCallback);

// 定义回调函数
function myCallback() {
    console.log('我是延迟执行的cb回调函数');
}

写法 2：（精简版，更常见）

// 定义一个异步的延迟函数：异步函数结束1秒之后，再执行cb回调函数
function fun1(cb) {
    setTimeout(cb, 1000);
}

// 先执行异步函数fun1，再执行回调函数
fun1(function () {
    console.log('我是延迟执行的cb回调函数');
});

上⾯的例⼦就是最传统的写法，在异步结束后通过传入回调函数的方式执⾏函数。

学习 Promise 之后，我们可以将这个异步函数封装为 Promise，如下。

Promise 写法

function myPromise() {
    return new Promise((resolve) => {
        setTimeout(resolve, 1000);
    });
}

/* 【重要】上面的 myPromise 也可以写成：
function myPromise() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve();
        }, 1000);
    });
}
*/

// 先执行异步函数 myPromise，再执行回调函数
myPromise().then(() => {
    console.log('我是延迟执行的回调函数');
});

Promise 封装 Ajax 请求

传统写法

// 封装 ajax 请求：传入回调函数 success 和 fail
function ajax(url, success, fail) {
    var xmlhttp = new XMLHttpRequest();
    xmlhttp.open('GET', url);
    xmlhttp.send();
    xmlhttp.onreadystatechange = function () {
        if (xmlhttp.readyState === 4 && xmlhttp.status === 200) {
            success && success(xmlhttp.responseText);
        } else {
            // 这里的 && 符号，意思是：如果传了 fail 参数，就调用后面的 fail()；如果没传 fail 参数，就不调用后面的内容。因为 fail 参数不一定会传。
            fail && fail(new Error('接口请求失败'));
        }
    };
}

// 执行 ajax 请求
ajax(
    '/a.json',
    (res) => {
        console.log('qianguyihao 第一个接口请求成功:' + JSON.stringify(res));
    },
    (err) => {
        console.log('qianguyihao 请求失败:' + JSON.stringify(err));
    }
);

上面的传统写法里，定义和执行 ajax 时需要传⼊ success 和 fail 这两个回调函数，进而执行回调函数。

注意看注释，callback && callback()这种格式的写法，很常见。

Promise 写法

有了 Promise 之后，我们不需要传入回调函数，而是：

  • 先将 promise 实例化；

  • 然后在原来执行回调函数的地方，改为执行对应的改变 promise 状态的函数；

  • 并通过 then ... catch 或者 then ...then 等写法，实现链式调用，提高代码可读性。

和传统写法相比，promise 在写法上的大致区别是：定义异步函数的时候，将 callback 改为 resolve 和 reject，待状态改变之后，我们在外面控制具体执行哪些函数。

写法 1：

// 封装 ajax 请求：传入回调函数 success 和 fail
function ajax(url, success, fail) {
    var xmlhttp = new XMLHttpRequest();
    xmlhttp.open('GET', url);
    xmlhttp.send();
    xmlhttp.onreadystatechange = function () {
        if (xmlhttp.readyState === 4 && xmlhttp.status === 200) {
            success && success(xmlhttp.responseText);
        } else {
            // 这里的 && 符号，意思是：如果传了 fail 参数，就调用后面的 fail()；如果没传 fail 参数，就不调用后面的内容。因为 fail 参数不一定会传。
            fail && fail(new Error('接口请求失败'));
        }
    };
}

// 第一步：model层的接口封装
function promiseA() {
    return new Promise((resolve, reject) => {
        ajax('xxx_a.json', (res) => {
            // 这里的 res 是接口的返回结果。返回码 retCode 是动态数据。
            if (res.retCode == 0) {
                // 接口请求成功时调用
                resolve('request success' + res);
            } else {
                // 接口请求失败时调用
                reject({ retCode: -1, msg: 'network error' });
            }
        });
    });
}

// 第二步：业务层的接口调用。这里的 data 就是 从 resolve 和 reject 传过来的，也就是从接口拿到的数据
promiseA()
    .then((res) => {
        // 从 resolve 获取正常结果：接口请求成功后，打印接口的返回结果
        console.log(res);
    })
    .catch((err) => {
        // 从 reject 获取异常结果
        console.log(err);
    });

上方代码中，当从接口返回的数据data.retCode的值（接口返回码）不同时，可能会走 resolve，也可能会走 reject，这个由你自己的业务决定。

接口返回的数据，一般是{ retCode: 0, msg: 'qianguyihao' } 这种 json 格式， retCode 为 0 代表请求接口成功，所以前端对应会写if (res.retCode == 0)这样的逻辑。

另外，上面的写法中，是将 promise 实例定义成了一个函数 promiseA。我们也可以将 promise 实例定义成一个变量 promiseB，达到的效果和上面的代码是一模一样的。写法如下：（写法上略有区别）

写法 2：

// 第一步：model层的接口封装
const promiseB = new Promise((resolve, reject) => {
    ajax('xxx_a.json', (res) => {
        // 这里的 res 是接口的返回结果。返回码 retCode 是动态数据。
        if (res.retCode == 0) {
            // 接口请求成功时调用
            resolve('request success' + res);
        } else {
            // 接口请求失败时调用
            reject({ retCode: -1, msg: 'network error' });
        }
    });
});

// 第二步：业务层的接口调用。这里的 data 就是 从 resolve 和 reject 传过来的，也就是从接口拿到的数据
promiseB
    .then((res) => {
        // 从 resolve 获取正常结果
        console.log(res);
    })
    .catch((err) => {
        // 从 reject 获取异常结果
        console.log(err);
    });

注意，如果你用的是写法 1（将 promise 实例定义为函数），则调用 promise 的时候是promiseA().then()，如果你用的是写法 2（将 promise 实例定位为函数），则调用的时候用的是promiseB.then()。写法 1 多了个括号，不要搞混了。

resolve() 传入的参数（重要）

执行 resolve()之后，Promise 的状态一定会变成 fulfilled 吗？这是不一定的。

严格来说，在我们调用 resolve 时，如果 resolve()的参数中传入的值本身不是一个Promise，那么会将该 promise 的状态变成 fulfilled。

resolve()的参数中，可以传入哪些值，Promise会进入哪种状态呢？具体情况如下：

  • 情况1：如果resolve()中传入普通的值或者普通对象（包括 undefined），那么Promise 的状态为fulfilled。这个值会作为then()回调的参数。这是最常见的情况。

  • 情况2：如果resolve()中传入的是另外一个新的 Promise，那么原 Promise 的状态将交给新的 Promise 决定。

  • 情况3：如果resolve()中传入的是一个对象，并且这个对象里有实现then()方法（这种对象称为 thenable 对象），那就会执行该then()方法，并且根据then()方法的结果来决定Promise的状态。

情况3中，我们通常称这个对象为 thenable 对象。thenable 的意思是，在某个对象或者函数中定义了一个 then() 方法，我们就称其为 thenable 对象/thenable函数。注意，thenable对象里面的那个单词只能写 then，不能写其他的单词；如果写其他的单词，就不是 thenable 对象了，就不符合情况3，而是符合情况1。

扩展一下：reject()的参数中可以传入什么值呢？无论传入什么值，Promise 都会直接进入 rejected 状态，并触发 catch() 方法的执行。

情况1的代码已经在前面反复出现过了，接下来重点讲一下情况2 和情况3。

resolve() 中传入新的 Promise

代码举例：

const promise1 = new Promise((resolve, reject) => {
  resolve(promise2);
});

const promise2 = new Promise((resolve, reject) => {
  reject('promise2 的 reject');
});

promise1
  .then(res => {
    console.log('qianguyihao then');
    console.log(res);
  })
  .catch(err => {
    console.log('qianguyihao catch');
    console.log(err);
  });

打印结果：

qianguyihao catch
promise2 的 reject

代码解释：

promise1 在执行resolve时，传入的是 promise2。那么，promise1接下来的状态将交给 promise2 处理。因为 promise2 执行的是 reject()，所以 promise1 的状态进入 rejected，执行 catch() 方法。

上方代码中，如果把 promise1 和 promise2 的顺序换一下的话， 代码会报错：

const promise1 = new Promise((resolve, reject) => {
  resolve(promise2);
});

const promise2 = new Promise((resolve, reject) => {
  reject('promise2 的 reject');
});

promise1
  .then(res => {
    console.log('qianguyihao then');
  })
  .catch(err => {
    console.log('qianguyihao catch');
    console.log(err);
  });

报错如下：

image-20230520224902096

resolve()中传入 thenable 对象

代码举例：

const promise1 = new Promise((resolve, reject) => {
  // resolve 里传入了一个 thenable 对象，里面有一个 then()方法，then()方法里执行的是 reject()
  resolve({
    name: 'qianguyihao',
    then: (resolve, reject) => {
      // 可以执行 resolve，也可以执行 reject，这里以 reject 为例
      reject('thenable reject');
    },
  });
});

promise1
  .then(res => {
    console.log('qianguyihao then');
    console.log(res);
  })
  .catch(err => {
    console.log('qianguyihao catch');
    console.log(err);
  });

打印结果：

qianguyihao catch
thenable reject

代码解释：

promise1 在执行resolve时，传入的是一个 thenable 对象。thenable 对象里有一个 then()方法。那么，promise1接下来的状态将由 thenable 对象 里的 then() 方法决定。当前的代码中， then() 里执行的是 reject()，所以 promise1 的状态进入 rejected，执行 catch() 方法。

上方代码中，如果把 thenable 对象里的单词then改成then1会怎么样呢？那它就不是 thenable 对象，只是一个普通的对象，代码如下：

const promise1 = new Promise((resolve, reject) => {
  // resolve 里传入了一个 thenable 对象，里面有一个 then()方法，then()方法里执行的是 reject()
  resolve({
    name: 'qianguyihao',
    // 把 单词 then 改成 then1，就不符合 thenable 对象 的特征了
    then1: (resolve, reject) => {
      reject('thenable resolve');
    },
  });
});

promise1
  .then(res => {
    console.log('qianguyihao then');
    console.log(JSON.stringify(res));
  })
  .catch(err => {
    console.log('qianguyihao catch');
    console.log(err);
  });

打印结果：

qianguyihao then
{"name":"qianguyihao"}

小结

学习这些内容之后， 相信你已经对 Promise 有了基本了解。下一篇文章，我们来讲一讲 Promise 在实战开发的常见用法。

参考链接

  • Promise 注册微任务和执行过程

  • 深入分析 Promise 实现细节

  • 当面试官问你 Promise 的时候，他究竟想听到什么？

  • 手写一个 Promise/A+,完美通过官方 872 个测试用例

  • 从 Promises/A+ 看异步流控制 - Liu Bowen

希望各位可以点个赞点个关注，这对up真的很重要，谢谢大家啦！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/609512.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

三月份饮料行业线上市场销售数据分析

三月份饮料行业线上市场销售数据分析

2024年3月，中国饮料市场呈现出多样化和健康趋势的明显特征。从消费场景、消费端需求以及销售渠道来看，饮料市场正在经历多元化的发展，这不仅体现在产品种类上，也体现在消费者的购买行为和偏好上。 据鲸参谋数据统计，线…
阅读更多...
LLM大语言模型（十五）：LangChain的Agent中使用自定义的ChatGLM，且底层调用的是remote的ChatGLM3-6B的HTTP服务

LLM大语言模型（十五）：LangChain的Agent中使用自定义的ChatGLM，且底层调用的是remote的ChatGLM3-6B的HTTP服务

背景 本文搭建了一个完整的LangChain的Agent，调用本地启动的ChatGLM3-6B的HTTP server。 为后续的RAG做好了准备。 增加服务端role：observation ChatGLM3的官方demo：openai_api_demo目录 api_server.py文件 class ChatMessage(BaseModel…
阅读更多...
LeetCode HOT 100刷题总结

LeetCode HOT 100刷题总结

文章目录 1 哈希1.1 1-1.两数之和🟢1.2 2-49.字母异位词分组🟡1.3 3-128.最长连续序列🟡 2 双指针2.1 4-283.移动零🟢2.2 6-15.三数之和🟡2.3 7-11.盛最多水的容器🟡2.4 8-42.接雨水🔴 3 滑动窗…
阅读更多...
传输层协议——UDP协议

传输层协议——UDP协议

目录 一、传输层 二、再谈端口号 端口号的划分 知名端口号 pidof netstat命令 三、UDP协议 1、UDP协议格式 2、UDP协议特点 3、UDP协议的缓冲区 四、基于UDP的应用层协议 一、传输层 上一篇文章我们所讲到的HTTP协议和HTTPS协议，是属于应用层协议。我们…
阅读更多...
【小笔记】问答系统可视化实现的三种方式

【小笔记】问答系统可视化实现的三种方式

下面三种方式都是基于Python的哈，从简单到复杂。 方式一：命令行交互问答 优点：原始简单直接 方式二：使用Python可视化框架 优点：无需学习前端技术栈即可搭建一个web。 streamlit：⭐️⭐️⭐️⭐️gra…
阅读更多...
【服务器优化】LVS负载均衡

【服务器优化】LVS负载均衡

LVS负载均衡 LVS简介 ​ LVS（Linux Virtual Server）即Linux虚拟服务器，是由章文嵩博士主导的开源负载均衡项目，目前LVS已经被集成到Linux内核模块中。该项目在Linux内核中实现了基于IP的数据请求负载均衡调度方案，终…
阅读更多...
nginx的应用部署nginx

nginx的应用部署nginx

这里写目录标题 nginxnginx的优点什么是集群常见的集群什么是正向代理、反向代理、透明代理常见的代理技术正向代理反向代理透明代理 nginx部署 nginx nginx（发音同enginex）是一款轻量级的Web服务器/反向代理服务器及电子邮件（IMAP/POP3&…
阅读更多...
Java设计模式 _结构型模式_外观模式

Java设计模式 _结构型模式_外观模式

一、外观模式 1、外观模式 外观模式（Facade Pattern）是一种结构型模式。主要特点为隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这有助于降低系统的复杂性，提高可维护性。当客户端与多个子系统之间存在大量…
阅读更多...
FPGA+海思ARM方案，可同时接收HDMI/VGA 两种信号，远程控制

FPGA+海思ARM方案，可同时接收HDMI/VGA 两种信号，远程控制

FPGA海思ARM方案，可同时接收HDMI/VGA 两种信号，通过配置输出任一图像或者拼接后的图像 客户应用：无线远程控制 主要特性： 1.支持2K以下任意分辨率格式 2.支持H264压缩图像 3.支持WIFI/4G无线传输 4.支持自适应输入图像分辨率 …
阅读更多...
如何编辑百度百科里面的资料

如何编辑百度百科里面的资料

编辑百度百科资料是一个相对简单的过程，但同时也需要遵循一定的规则和流程。以下是百科优化网yajje整理的编辑百度百科资料的步骤和注意事项。 登录账户 首先，编辑百度百科需要一个百度账号。如果没有，你需要先注册一个。登录后，…
阅读更多...
西奥机电CLRT-01：重塑碳酸饮料质检新纪元

西奥机电CLRT-01：重塑碳酸饮料质检新纪元

西奥机电CLRT-01：重塑碳酸饮料质检新纪元 在追求品质生活的今天，碳酸饮料的品质检测成为了行业内外关注的焦点。西奥机电，作为行业创新的领跑者，携其最新研发的CLRT-01二氧化碳气容量测试仪，为碳酸饮料行业带来了革命性…
阅读更多...
一文详解｜影响成长的关键思考（二）

一文详解｜影响成长的关键思考（二）

之前写过一篇《一文详解｜影响成长的关键思考》，里面对自己工作前几年的心法进行了总结，并分享了出来。现在又工作了一段时间后，有了一些新的体会，想进一步分析一下，于是便有了此文。的确，思考也…
阅读更多...
LeetCode63：不同路径Ⅱ

LeetCode63：不同路径Ⅱ

题目描述 一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish”）。 现在考虑网格中有障碍物。那么从左上角…
阅读更多...
【NPS】微软NPS配置802.1x，验证域账号，动态分配VLAN（NPS篇）

【NPS】微软NPS配置802.1x，验证域账号，动态分配VLAN（NPS篇）

NPS简介 Network Policy Server（NPS）是微软Windows Server中的一个网络服务，它作为RADIUS服务器实现，用于集中管理网络接入请求。NPS处理对网络资源的认证、授权和审计请求，通常用于控制远程访问VPN和无线网络的接入。…
阅读更多...
Python 数据库操作- sqlite3 模块

Python 数据库操作- sqlite3 模块

Python sqlite3 模块 1. 安装 SQLite3 可使用 sqlite3 模块与 Python 进行集成。sqlite3 模块是由 Gerhard Haring 编写的。它提供了一个与 PEP 249 描述的 DB-API 2.0 规范兼容的 SQL 接口。用户不需要单独安装该模块，因为 Python 2.5.x 以上版本默认自带了该模块…
阅读更多...
(动画详解)LeetCode225.用队列实现栈

(动画详解)LeetCode225.用队列实现栈

. - 力扣&#xff08;LeetCode&#xff09; 题目描述 解题思路 这道题的思路就是使用两个队列来实现 入栈就是入队列 出栈就是将非空队列的前n-1个元素移动到新的队列中去 再将最后一个元素弹出 动画详解 代码实现 #define _CRT_SECURE_NO_WARNINGS 1#include <stdio.…
阅读更多...
打车遇到臭车的底层逻辑！修炼的法门居然又捡起来了！——早读（逆天打工人爬取热门微信文章解读）

打车遇到臭车的底层逻辑！修炼的法门居然又捡起来了！——早读（逆天打工人爬取热门微信文章解读）

冥冥之中自有天意 引言Python 代码第一篇 洞见 热搜上“打车遇到臭车”话题&#xff0c;戳到了650万成年人的尴尬第二篇 冯站长之家 三分钟新闻早餐结尾 生命不息 探索不止 在生命的旅程中 我不断探索不断发现 永不停歇 引言 记 ​一大突破 炁​机启动 ​没想到 ​去年9月份…
阅读更多...
【NodeMCU实时天气时钟温湿度项目 3】连接SHT30传感器，获取并显示当前环境温湿度数据（I2C）

【NodeMCU实时天气时钟温湿度项目 3】连接SHT30传感器，获取并显示当前环境温湿度数据（I2C）

今天&#xff0c;我们开始第三个专题&#xff1a;连接SHT30温湿度传感器模块&#xff0c;获取当前环境实时温湿度数据&#xff0c;并显示在1.3寸TFT液晶显示屏上。 第一专题内容&#xff0c;请参考 【NodeMCU实时天气时钟温湿度项目 1】连接点亮SPI-TFT屏幕和UI布局设计…
阅读更多...
【0day漏洞复现】中移铁通禹路由器信息泄露漏洞

【0day漏洞复现】中移铁通禹路由器信息泄露漏洞

0x01 阅读须知 “如棠安全的技术文章仅供参考&#xff0c;此文所提供的信息只为网络安全人员对自己所负责的网站、服务器等&#xff08;包括但不限于&#xff09;进行检测或维护参考&#xff0c;未经授权请勿利用文章中的技术资料对任何计算机系统进行入侵操作。利用此文所提供…
阅读更多...
AJAX家政系统源码部署/售后更新/搭建/上线维护

AJAX家政系统源码部署/售后更新/搭建/上线维护

基于FastAdmin和原生微信小程序开发的一款同城预约、上门服务、到店核销家政系统&#xff0c;用户端、服务端(高级授权)、门店端(高级授权)各端相互依赖又相互独立&#xff0c;支持选择项目、选择服务人员、选择门店多种下单方式&#xff0c;支持上门服务和到店核销两种服务方式…
阅读更多...
最新文章

Copyright @ 2022~2023