JavaScript异步编程——07-Promise实例的方法【万字长文，感谢支持】

news2024/11/27 21:34:45

Promise 实例的方法简介

Promise 的 API 分为两种：

  • Promise 实例的方法（也称为：Promis的实例方法）

  • Promise 类的方法（也称为：Promise的静态方法）

Promise 实例的方法：我们需要实例化 Promise，也就是先 new 一个 Promise 实例对象，然后通过 Promise 实例去调用 then、catch、finally等方法。这几个方法就是 Promise 的实例方法。

Promise 实例提供了如下方法：

  • promise.then()：异步任务成功的回调函数。

  • promise.catch()：异步任务失败的回调函数。

  • promise.finaly()：异步任务无论成功与否，都会执行的回调函数。

我们在上一篇文章《Promise入门详解》中，用到的都是Promise实例的方法。本篇文章，我们来把这三个实例方法详细学习一下。

Promise 实例的 then()方法

then()方法是 Promise实例上的一个方法。它其实是放在Promise的原型上的 Promise.prototype.then。

then()方法的参数

then()方法可以接收一个参数，也可以接收两个参数。两个参数时，分别代表两个回调函数，这两个函数一直处于监听状态：

  • 参数1：当 Promise 的状态变为 fulfilled（意思是：任务执行成功）时会立即执行的回调函数。

  • 参数2：当 Promise 的状态为 rejected（任务执行失败）时会立即执行的回调函数。

下面这两种写法是等价的。处理 rejected 失败状态的回调函数，既可以放在 then() 方法的第二个参数里，也可以单独放在 catch() 方法的参数里。

写法1：

 
const promise = new Promise((resolve, reject) => {
   reject('qianguyihao');
 });
 ​
 promise.then(
   res => {
     console.log('res:', res);
   },
   err => {
     console.log('err:', err);
   }
 );

写法2：

 const promise = new Promise((resolve, reject) => {
   reject('qianguyihao');
 });
 ​
 promise
   .then(res => {
     console.log('res:', res);
   })
   .catch(err => {
     console.log('err:', err);
   });

then()方法可以被多次调用

一个 Promise 的 then() 方法可以被多次调用。每次调用时我们都可以传入对应fulfilled状态的回调函数。当 Promise 的状态变为 fulfilled 时，这些回调函数都会被执行。

then被调用多次的伪代码：

 const myPromise = new Promise();
 ​
 myPromise.then();
 myPromise.then();
 myPromise.then();

代码举例：

 const myPromise = new Promise((resolve, reject) => {
   resolve('qianguyihao');
 });
 ​
 myPromise.then(res => {
   console.log('成功回调1');
   console.log('res1:', res);
 });
 ​
 myPromise.then(res => {
   console.log('成功回调2');
   console.log('res2:', res);
 });
 ​
 myPromise.then(res => {
   console.log('成功回调3');
   console.log('res3', res);
 });

打印结果：

 成功回调1
 res1: qianguyihao
 ​
 成功回调2
 res2: qianguyihao
 ​
 成功回调3
 res3 qianguyihao

代码解释：

当 myPromise 状态为 fulfilled 时，下面的四个 then() 方法都在监听，所以这四个 then() 方法都会收到状态确定的通知，进而都会执行。

此外，then() 被调用多次还有一种链式调用的写法，它的打印结果与上面的打印结果不同，想要了解 Promise 的链式调用，需要先学习 then() 方法的返回值，我们继续往下看。

then() 方法的返回值（重要）

这一段的知识点略有难度，但是非常重要，是我们学习 Promise 链式调用的理论基础。

then()方法本身是有返回值的，它会返回一个新的Promise对象。因为 then()方法的返回值永远是一个 Promise 对象，所以我们才可以对它进行链式调用。

Promise 链式调用的伪代码：

 // 伪代码
 myPromise.then().then().catch()

上方代码中，因为 myPromise.then() 的返回值本身就是一个 Promise，所以才可以继续调用 then()、继续调用 catch()。

那么，then()方法返回的 Promise 对象处于什么状态呢？then()方法的参数里，是一个回调函数。这取决于回调函数的返回值是什么。情况如下：

1、当then()方法中的回调函数在执行时，那么Promise 处于pending状态。

2、当 then()方法中的回调函数中，手动 return 一个返回值时，那么 Promise 的状态取决于返回值的类型。当返回值这行代码执行完毕后， Promise 会立即决议，进入确定状态（成功 or 失败）。具体情况如下：

  • 情况1：如果没有返回值（相当于 return undefined），或者返回值是普通值/普通对象，那么 Promise 的状态为fulfilled。这个值会作为fulfilled 状态的回调函数的参数值。

  • 情况2：如果返回值是另外一个新的 Promise，那么原 Promise 的状态将交给新的 Promise 决定，这两个Promise 的状态一致。

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

还有一种特殊情况：

  • 情况4：当then()方法传入的回调函数遇到异常或者手动抛出异常时，那么， Promise 处于rejected 状态，并将抛出的错误作为 rejected 状态的回调函数的参数值。

小结：then()方法里，我们可以通过 return 传递结果和状态给下一个新的Promise。

默认返回值

如果then()方法的回调函数里没写返回值（相当于 return undefined），那么then()方法的返回值是一个新的Promise。新 Promise 的状态为fulfilled，其then()方法里，res的值为 undefined。

then() 链式调用的代码举例：

 const myPromise = new Promise((resolve, reject) => {
   resolve('qianguyihao');
 });
 ​
 myPromise
   .then(res => {
     console.log('成功回调1');
     console.log('res1:', res);
     /*
     这里虽然什么都没写，底层默认写了如下代码：
     return new Promise((resolve, reject) => {
         resolve(); // resolve() 的参数是空，相当于 resolve(undefined)
     })
     */
   })
   .then(res => {
     console.log('成功回调2');
     console.log('res2:', res);
   })
   .then(res => {
     console.log('成功回调3');
     console.log('res3', res);
   });

打印结果：

 成功回调1
 res1: qianguyihao
 ​
 成功回调2
 res2: undefined
 ​
 成功回调3
 res3：undefined

代码解释：

第一个 then()里的回调，是由 myPromise 进行决议。第二个then()、第三个then() 也在等待决议。

但是，第二个 then() 的回调是由第一个 then()传入的回调函数，返回的 Promise 进行决议；第三个 then() 的回调是由第二个 then()传入的回调函数，返回的 Promise 进行决议，以此类推。所以，这两个then()里面的打印参数的结果是 undefined，并没有打印 myPromise 的决议结果。

换句话说，第一个 then() 在等待 myPromise 的决议结果，有决议结果后执行；第二个 then() 在等待第一个 then()参数里返回的新 Promise的决议结果，有决议结果后执行；第三个 then() 在等待第二个 then()参数里返回的新 Promise的决议结果，有决议结果后执行。

返回普通值：通过 return 传递数据结果

我们也可以在 then()方法的回调函数里，手动 return 自己想要的数据，比如一个普通值 value1。这个普通值就可以传递给下一个新的Promise。新 Promise 的状态为fulfilled，其then()方法里，res的值为 value1。

代码举例：

const myPromise = new Promise((resolve, reject) => {
  resolve('1号');
});

myPromise
  .then(res => {
    console.log('res1:', res);
    // return一个普通值，把这个值传递给下一个Promise
    return '2号';
  	/*
  	上面这行 return，相当于：
  	return new Promise((resolve, reject)=> {
  		resolve('2号');
  	})
  	*/
  })
  .then(res => {
  	// res可以接收到上一个 Promise 传递的值
    console.log('res2:', res);
  })
  .then(res => {
    console.log('res3:', res);
  });

返回结果：

res1: 1号
res2: 2号
res3: undefined

返回新的 Promise

情况1、在 then() 方法的回调函数中 return 一个成功的新 Promise，那么，then()返回的Promise 也是成功状态。相当于把新Promise的成功结果传递出去。代码举例：

const promise1 = new Promise((resolve, reject) => {
  resolve('qianguyihao fulfilled 1');
});

const promise2 = new Promise((resolve, reject) => {
  resolve('qianguyihao fulfilled 2');
});

promise1
  .then(res => {
    console.log('res1:', res);
    return promise2;
  })
  .then(res => {
    // 监听 promise2 的成功状态
    console.log('res2:', res);
  })
  .then(res => {
    console.log('res3', res);
  });

打印结果：

res1: qianguyihao fulfilled 1
res2: qianguyihao fulfilled 2
res3 undefined

情况2、在 then() 方法的回调函数中 return 一个失败的新 Promise，那么，then()返回的Promise 也是失败状态。再继续往下走，会怎么样？相当于把新Promise 的失败原因传递出去。代码举例：

const promise1 = new Promise((resolve, reject) => {
  resolve('qianguyihao fulfilled 1');
});

const promise2 = new Promise((resolve, reject) => {
  reject('qianguyihao rejected 2');
});

promise1
  .then(res => {
    console.log('res1:', res);
    // return 一个 失败的 Promise
    return promise2;
  })
  .then(res => {
    console.log('res2:', res);
  }, err => {
    // 如果 promise2 为失败状态，可以通过 then() 的第二个参数（即失败的回调函数）捕获异常，然后就可以继续往下执行其他的代码
    console.log('err2:', err);
   // 这里相当于 return undefined
  })
  .then(res => {
    console.log('res3', res);
  }, err => {
    console.log('err3:', err);
  });

打印结果：

res1: qianguyihao fulfilled 1
err2: qianguyihao rejected 2
res3: undefined

上方代码可以看到，第二个Promise走的是失败回调，这很容易理解。重点是，最后一个 Promise 走的是成功回调，这很出人意料。我们稍后学习 catch()方法的返回值后，就能看懂。这例子很经典，一定要记住。

情况3：在 then() 方法的回调函数中 return 一个 pending 状态的新 Promise，那么 then() 返回的Promise状态也是 pending。

返回 thenable 对象

代码举例：

const myPromise = new Promise((resolve, reject) => {
  resolve('qianguyihao fulfilled 1');
});

myPromise
  .then(res => {
    console.log('res1:', res);
    return {
      then: (resolve, reject) => {
        resolve('thenable fulfilled');
      },
    };
  })
  .then(res => {
    console.log('res2:', res);
  })
  .then(res => {
    console.log('res3', res);
  });

打印结果：

res1: qianguyihao fulfilled 1
res2: thenable fulfilled
res3 undefined

then() 中抛出异常

当then()方法传入的回调函数遇到异常或者手动抛出异常时，那么，then()所返回的新的 Promise 会进入rejected 状态，进而触发新Promise 的 catch() 方法的执行，做异常捕获。

这方面的内容，我们在后续的文章《异常处理方案》中会详细讲解。

特殊情况：then() 中传入非函数时，会发生值穿透

在Promise的then()方法中，如果传入一个非函数作为参数，JS 会将其忽略，并且将前一个 Promise 的结果值传递给下一个then()方法。这意味着如果你在then()中传入非函数参数，它将被视为一个空操作，而不会对Promise链产生任何影响。

“值穿透”的意思是，传入的非函数值会被忽略。

代码举例：

const myPromise = new Promise((resolve, reject) => {
  resolve('Hello');
});

myPromise
  .then('Invalid Argument')
  .then(res1 => {
    console.log('res1:', res1);
    return 'World';
  })
  .then(res2 => {
    console.log('res2:', res2);
  });

打印结果：

res1: Hello
res2: World

Promise 实例的 catch() 方法

catch()方法是 Promise实例上的一个方法。它其实是放在Promise的原型上的 Promise.prototype.catch。

catch() 方法的参数

catch()方法可以接收一个参数。这个参数是一直处于监听状态的回调函数。当 Promise 的状态为 rejected（任务执行失败）时会立即执行这个回调函数。

代码举例：

const promise = new Promise((resolve, reject) => {
  reject('qianguyihao reject');
});

promise
  .then(res => {
    console.log('res:', res);
  })
  .catch(err => {
    console.log('err:', err);
  });

打印结果：

err: qianguyihao reject

catch() 方法可以被多次调用

一个 Promise 的 catch() 方法可以被多次调用。每次调用时我们都可以传入对应 rejected 状态的回调函数。当 Promise 的状态变为 rejected 时，这些回调函数都会被执行。

catch() 被调用多次的伪代码：

const myPromise = new Promise();

myPromise.catch();
myPromise.catch();
myPromise.catch();

代码举例：

const myPromise = new Promise((resolve, reject) => {
  reject('qianguyihao rejected');
});

myPromise.catch(err => {
  console.log('失败回调1');
  console.log('err1:', err);
});

myPromise.catch(err => {
  console.log('失败回调2');
  console.log('err2:', err);
});

myPromise.catch(err => {
  console.log('失败回调3');
  console.log('err3:', err);
});

打印结果：

失败回调1
err1: qianguyihao rejected

失败回调2
err2: qianguyihao rejected

失败回调3
err3: qianguyihao rejected

代码解释：

当 myPromise 状态为 rejected 时，下面的四个 catch() 方法都在监听，所以这四个 catch() 方法都会收到状态确定的通知，进而都会执行。

catch() 方法的返回值（重要）

与 then() 方法类似，catch()方法默认也是有返回值的，它会返回一个新的Promise对象。因为 catch()方法的返回值永远是一个 Promise 对象，所以我们才可以对它进行链式调用。

Promise 链式调用的伪代码：

// 伪代码
myPromise.then().then().catch().then()

上方代码中，因为 myPromise.catch() 的返回值本身就是一个 Promise，所以才可以继续调用 then()、继续调用 catch()。

与 then() 方法类似，catch()方法返回的 Promise 对象处于什么状态呢？catch()方法的参数里，是一个回调函数。这取决于回调函数的返回值是什么。情况如下：

1、当catch()方法中的回调函数在执行时，那么Promise 处于 pending 状态。

2、当 catch方法中的回调函数中，手动 return 一个返回值时，那么 Promise 的状态取决于返回值的类型。当返回值这行代码执行完毕后， Promise 会立即决议，进入确定状态（成功 or 失败），进而触发下一个then/catch 函数的执行。同时可以给下一个 then/catch 传递参数。具体情况如下：

  • 情况1：如果没有返回值（相当于 return undefined），或者返回值是普通值/普通对象，那么 Promise 的状态为fulfilled。这个值会作为then()回调的参数。

  • 情况2：如果返回值是另外一个新的 Promise，那么原 Promise 的状态将交给新的 Promise 决定。这两个Promise 的状态一致。

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

还有一种特殊情况：

  • 情况4：当catch()方法传入的回调函数遇到异常或者手动抛出异常时，那么， Promise 处于rejected 状态。

小结：catch()方法里，我们可以通过 return 传递结果给下一个新的Promise。

默认返回值

如果catch()方法的回调函数里没写返回值（相当于 return undefined），那么catch()方法的返回值是一个新的Promise。新 Promise 的状态为fulfilled，其then()方法里，res的值为 undefined。

代码举例：

const myPromise = new Promise((resolve, reject) => {
  reject('qianguyihao rejected');
});

myPromise
  .catch(err => {
    console.log('err:', err);
    /*
    这里虽然什么都没写，底层默认写了如下代码：
    return new Promise((resolve, reject) => {
      resolve(undefined); // resolve() 的参数是空
    })
    */
  })
  .then(res => {
    console.log('res:', res);
  });

打印结果：

err: qianguyihao rejected
res: undefined

返回普通值

我们也可以在 catch()方法的回调函数里，手动 return 自己想要的数据，比如一个普通值 value1。这个普通值就可以传递给下一个新的Promise。新 Promise 的状态为fulfilled，其then()方法里，res的值为 value1。

代码举例：

const myPromise = new Promise((resolve, reject) => {
  reject('1号');
});

myPromise
  .catch(err => {
    console.log('err1:', err);
    return '2号';
    /*
    上面这行 return，相当于：
    return new Promise((resolve, reject)=> {
      resolve('2号');
    })
    */
  })
  .then(res => {
    console.log('res2:', res);
  })
  .then(res => {
    console.log('res3:', res);
  });

返回结果：

err1: 1号
res2: 2号
res3: undefined

catch() 方法的执行时机

Promise 抛出 rejected 异常时，一定要捕获并处理

当 Promise 状态为 rejected 时，表示抛出异常，如果不处理失败的回调，行不行呢？不行，会报错。代码举例：

      const promise = new Promise((resolve, reject) => {
        // 在这里抛出异常
        reject('qianguyihao reject');
      });

      promise.then(res => {
        console.log('res:', res);
      });

image-20230521135912267

这个报错的意思是：未捕获 rejected 失败状态的 Promise 异常。必须要加一个 catch() 进行捕获。

书写 Promise 时，比较好的习惯是，无论如何都要在末尾写一个 catch() 方法。

可在 then() 中通过 throw 抛出异常

先来看一段代码：

const myPromise = new Promise((resolve, reject) => {
  resolve('aaa');
});

myPromise
  .then(res => {
    console.log('res1:', res);
   // 如果我想在这里 return 一个失败状态的promise，该怎么做？
  })
  .then(res => {
    console.log('res2:', res);
  })
  .catch(err => {
    console.log('err:', err);
  });

注意看注释，如果在那个位置return 一个失败状态的Promise，该怎么做？

做法1：

return new Promise((resolve, reject)=> {
  reject('第二个 promise 执行失败');
})

做法2：

throw new Error('第二个 Promise 执行失败');

做法2比做法1更为常用，完整代码如下：

const myPromise = new Promise((resolve, reject) => {
  resolve('aaa');
});

myPromise
  .then(res => {
    console.log('res1:', res);
    // 抛出异常：相当于 return 一个失败状态的 Promise
    throw new Error('第二个 Promise 执行失败');
  })
  .then(res => {
    console.log('res2:', res);
  })
  .catch(err => {
    console.log('err:', err);
  });

打印结果：

res1: aaa
err: Error: 第二个 Promise 执行失败

当通过 throw 抛出异常后，当前 then() 里的后续代码会暂停执行，后续的 then() 也会暂停执行，直接往后走到最近的 catch()。

throw 这种写法在实战开发中很常用，需要理解并记住。

找到最近的 catch() 去执行

我们先来看一段代码：

const myPromise = new Promise((resolve, reject) => {
  reject('qianguyihao rejected');
});

myPromise
  .then(res => {
    console.log('res1:', res);
  })
  .then(res => {
    console.log('res2:', res);
  })
  .catch(err => {
    console.log('err:', err);
  });

打印结果：

err: qianguyihao rejected

上方代码中的 catch() 是属于哪个 Promise 实例的方法呢？其实没有严格的界限。它既可以捕获 myPromise的异常，也可以捕获那两个 then()的异常，就是这么灵活。

再来看一段代码：

const myPromise = new Promise((resolve, reject) => {
  resolve('qianguyihao fulfilled');
});

myPromise
  .then(res => {
    console.log('res1:', res);
    // 遇到异常（或者任务失败）后，会找到最近的 catch() 去执行
    throw new Error('not login')
  })
  .then(res => {
    console.log('res2:', res);
  }, err => {
    console.log('err2:', err);
  })
  .catch(err => {
    console.log('err3:', err);
  });

打印结果：

res1: qianguyihao fulfilled
err2: Error: not login

请记住，myPromise 的状态变为失败时，它会找到最近的那个失败回调函数并执行。这是 Promise的内部机制。

处理失败状态的两种写法

我们有两种写法可以捕获 Promise的失败/异常状态：

  • 写法 1：单独写 catch() 方法作为失败的回调函数。

  • 写法 2：then()方法里可以传两个参数，第⼀个参数是成功时的回调函数，第⼆个参数是失败时的回调函数。

代码格式

这两种写法的代码格式如下：

// 第一步：model层的接口封装
const myPromise = new Promise((resolve, reject) => {
  // 这里做异步任务（比如 ajax 请求接口，或者定时器），然后执行 resolve 或者 reject。
	...
  ...
});

const onFulfilled = (res) => {
  console.log(res);
};

const onRejected = function (err) {
  console.log(err);
};

// 写法1：通过 catch 方法捕获失败状态的Promise
myPromise.then(onFulfilled).catch(onRejected);

// 写法2：then()方法里可以传两个参数，第⼀个参数是成功时的回调函数，第⼆个参数是失败时的回调函数。
myPromise.then(onFulfilled, onRejected);

注意事项：

1、上面这两种写法是等价的，选其中一种写法即可。这两种写法几乎没有区别。

2、有一点点区别：

  • myPromise.then(onFulfilled).catch(onRejected)：既可以捕获到 myPromise 的异常，也可以捕获到 then() 里面的异常（划重点）。

  • myPromise.then(onFulfilled, onRejected)：只能捕获到 promise的异常，无法捕获then()里面的异常。

知识拓展：myPromise.catch().then()这种写法，只能捕获到 myPromise 里面的异常。

代码举例

这两种写法在实战开发中的代码举例如下：

function myPromise() {
    return new Promise((resolve, reject) => {
        // 这里做异步任务（比如 ajax 请求接口，或者定时器）
            ...
            ...
    });
}

// 写法1
myPromise()
    .then((res) => {
        // 从 resolve 获取正常结果
        console.log('接口请求成功时，走这里');
        console.log(res);
    })
    .catch((err) => {
        // 从 reject 获取异常结果
        console.log('接口请求失败时，走这里');
        console.log(err);
    })
    .finally(() => {
        console.log('无论接口请求成功与否，都会走这里');
    });


// 写法 2：（和写法 1 等价）
myPromise()
    .then(
        (res) => {
            // 从 resolve 获取正常结果
            console.log('接口请求成功时，走这里');
            console.log(res);
        },
        (err) => {
            // 从 reject 获取异常结果
            console.log('接口请求失败时，走这里');
            console.log(err);
        }
    )
    .finally(() => {
        console.log('无论接口请求成功与否，都会走这里');
    });

代码解释：写法 1 和写法 2 的作用是等价的。只不过，写法 2 是把 catch 里面的代码作为 then 里面的第二个参数而已。

Promise 实例的 finally() 方法

finally() 方法是在ES9（ES 2018）中新增的一个特性，表示 Promise 对象无论变成 fulfilled 状态 还是 rejected 状态，finally() 里传入的回调函数都会被执行。

finally() 里可传入一个参数，这个参数是一个回调函数。回调函数不传参数，因为前面无论是 fulfilled 状态，还是 rejected状态，这个回调函数都会执行。

finally() 方法很实用，可以避免我们写很多重复代码，它的执行时机也有很重要的应用场景。

代码举例：

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

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

promise1
  .then(res => {
    console.log('res1:', res);
  })
  .catch(err => {
    console.log('err1:', err);
  })
  .finally(() => {
    console.log('promise1 决议后都会执行的代码');
  });

promise2
  .then(res => {
    console.log('res2:', res);
  })
  .catch(err => {
    console.log('err2:', err);
  })
  .finally(() => {
    console.log('promise2 决议后都会执行的代码');
  });

打印结果：

res1: promise1 fulfilled
err2: promise2 rejected
promise1 决议后都会执行的代码
promise2 决议后都会执行的代码

Promise的其他写法

写法1

Promise 规范

Promise 是⼀个拥有 then ⽅法的对象或函数。任何符合 promise 规范的对象或函数都可以成为 Promise。

关于 promise 规范的详细解读，可以看下面这个链接：

  • Promises/A+ 规范：Promises/A+

  • 【翻译】Promises/A+规范：图灵社区

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

F1C200S 添加韦根驱动笔记（设备树修改）

F1C200S 添加韦根驱动笔记（设备树修改）

参考资料：linux开发笔记（buildroot 增加自己的开发板支持文件）-CSDN博客 首先需要有F1C200S开发板的原理图和buildroot 如果没有可以在我的资源里面下载。 参考上面的文章修改这个目录下的设备树即可。 /home/test/lc/buildroot/board/wi…
阅读更多...
【神经网络】矩阵乘法的应用详解

【神经网络】矩阵乘法的应用详解

文章目录 一、多维数组使用NumPy创建和操作多维数组 二、矩阵乘法矩阵乘法的基本定义计算 2x2 矩阵的乘积矩阵形状的要求特殊情况：矩阵与向量的乘积 三、神经网络中的矩阵乘法神经网络的结构简介矩阵乘法在神经网络中的应用计算细节和NumPy的实现 一、多维数组 多维…
阅读更多...
【机器学习300问】80、指数加权平均数是什么？

【机器学习300问】80、指数加权平均数是什么？

严格讲指数加权平均数并不是机器学习中的专有知识，但他是诸多梯度下降优化算法的基础，所有我打算专门写一篇文章来介绍这种计算平均数的方法。还是老规矩，首先给大家来两个例子感受一下什么是指数加权平均数。 一、两个例子感性理解什么是指…
阅读更多...
【数据结构（邓俊辉）学习笔记】栈与队列01——栈应用（栈混洗、前缀后缀表达式、括号匹配）

【数据结构（邓俊辉）学习笔记】栈与队列01——栈应用（栈混洗、前缀后缀表达式、括号匹配）

文章目录 0. 概述1. 操作与接口2. 操作实例3. 实现4. 栈与递归5. 应用5.1 逆序输出5.1.1 进制转换5.1.1.1 思路5.1.1.2 算法实现 5.2 递归嵌套5.2.1 栈混洗5.2.1.1 混洗5.2.1.2 计数5.2.1.3 甄别 5.2.2 括号匹配5.2.2.1 构思5.2.2.2 实现5.2.2.3 实例 5.3 延迟缓冲5.3.1 中缀表…
阅读更多...
https介绍,加密解密(举例+必要性,对称/非对称加密介绍),数字摘要/指纹(介绍,应用(session id,网盘的秒传功能))

https介绍,加密解密(举例+必要性,对称/非对称加密介绍),数字摘要/指纹(介绍,应用(session id,网盘的秒传功能))

目录 https 引入 介绍 加密解密层 介绍 没有绝对的安全 使用ssl的弊端 加密解密 概念 加密 解密 秘钥 举例 现实中 网络中 加密的必要性 常见加密方式 对称加密 特点 非对称加密 特点 数字摘要/指纹 介绍 应用 session id 百度网盘的秒传功能 https …
阅读更多...
设备能耗数据在线监测

设备能耗数据在线监测

在追求可持续发展和绿色经济的当下，企业对于设备能耗的管理愈发重视。设备能耗数据在线监测，不仅能帮助企业实时掌握设备的运行状况，还能为企业节能减排、降低运营成本提供有力支持。HiWoo Cloud平台凭借其先进的技术和丰富的经验&#xff0c…
阅读更多...
qt操作硬件（以imx6ull为例）

qt操作硬件（以imx6ull为例）

下面用imx6ull的qt点灯说明，这里要使用c，c混合编程 一、完成ui界面位置 构造一个这样的简单界面即可，主要是实现open和close的槽函数即可。我这里分别把两个按钮改名为为openbt closebt了 二、实现逻辑功能 2.1完成led类创建 在主文件夹le…
阅读更多...
网络演进技术演进：裸纤专线、SDH、MSTP+、OTN、PTN、IP-RAN

网络演进技术演进：裸纤专线、SDH、MSTP+、OTN、PTN、IP-RAN

前言 文章主要介绍常见名词以及其在各自领域实现的功能价值。 01 裸纤 裸光纤（裸光纤）由运营商提供，是无中继的光纤线路，仅通过配线架连接。相比传统光纤，裸光纤提供纯粹的物理传输路径，无需额外网…
阅读更多...
【C++】类与对象（类章节）

【C++】类与对象（类章节）

面向过程和面向对象 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完 成。 一、类 1.类…
阅读更多...
OpenBayes 一周速览｜Apple 开源大模型 OpenELM 上线；字节发布 COCONut 首个全景图像分割数据集，入选 CVPR2024

OpenBayes 一周速览｜Apple 开源大模型 OpenELM 上线；字节发布 COCONut 首个全景图像分割数据集，入选 CVPR2024

公共资源速递 This Weekly Snapshots ！ 5 个数据集： * COCONut 大规模图像分割数据集 * THUCNews 新闻数据集 * DuConv 对话数据集 * 安徽电信知道问答数据集 * Sentiment Analysis 中文情感分析数据集 2 个模型： * OpenELM-3B-Inst…
阅读更多...
面试笔记——类加载器

面试笔记——类加载器

基础 类加载器：用于装载字节码文件(.class文件)运行时数据区：用于分配存储空间执行引擎：执行字节码文件或本地方法垃圾回收器：用于对JVM中的垃圾内容进行回收 类加载器 ：JVM只会运行二进制文件，类加载器的…
阅读更多...
Python入门系列-02 pip的安装

Python入门系列-02 pip的安装

目录 一、pip介绍二、pip安装检查三、pip安装 一、pip介绍 pip 是 Python 包管理工具，该工具提供了对Python 包的查找、下载、安装、卸载的功能。 二、pip安装检查 你可以通过以下命令来判断是否已安装。 pip --version # Python2.x 版本命令 pip3 --versio…
阅读更多...
uniapp——弹出键盘遮挡住输入框 textarea，处理方法

uniapp——弹出键盘遮挡住输入框 textarea，处理方法

案例 在写输入框的时候会遇见 键盘遮挡住部分textarea框的一部分&#xff0c;使用cursor-spacing处理即可 修改后&#xff1a; 其他问题&#xff1a; 调起键盘输入时&#xff0c;不希望上方的内容被顶上去 代码 <view class"commentBox" :style"botto…
阅读更多...
蓝桥杯EDA常见电路原理图设计和分析

蓝桥杯EDA常见电路原理图设计和分析

目录 前言 一、常见器件及其作用 二、原理图设计题目 1.蜂鸣器原理图 2.LCD背光控制电路 3.参考电压源 4.低通滤波器电路设计 5.5-3.3电源转换电路 6.3.3V-VDD_EXT电平转换电路 7.DS18B20原理图 8.供电输出控制接口电路 9.电源检测接口电路 10.USB转串口电路 三、…
阅读更多...
微信小程序原生组件使用

微信小程序原生组件使用

1、video组件使用 <view class"live-video"><video id"myVideo" src"{{videoSrc}}" bindplay"onPlay" bindfullscreenchange"fullScreenChange" controls object- fit"contain"> </video&g…
阅读更多...
每日两题 / 104. 二叉树的最大深度 102. 二叉树的层序遍历（LeetCode热题100）

每日两题 / 104. 二叉树的最大深度 102. 二叉树的层序遍历（LeetCode热题100）

104. 二叉树的最大深度 - 力扣&#xff08;LeetCode&#xff09; 递归判断&#xff0c;当前节点的最大深度为1 max(左节点的最大深度&#xff0c;右节点的最大深度) /*** Definition for a binary tree node.* struct TreeNode {* int val;* TreeNode *left;* …
阅读更多...
PowerPhotos for Mac：您的照片管理助手

PowerPhotos for Mac：您的照片管理助手

PowerPhotos for Mac&#xff0c;作为一款专业的照片管理软件&#xff0c;为用户提供了全方位的照片管理解决方案。从照片的导入、整理到查找、编辑&#xff0c;PowerPhotos都能为您提供便捷的操作体验。 首先&#xff0c;PowerPhotos支持多库管理&#xff0c;用户可以根据需要…
阅读更多...
Spark云计算平台Databricks使用，第一个scala程序

Spark云计算平台Databricks使用，第一个scala程序

1) 创建Spark计算集群 Spark云计算平台Databricks使用&#xff0c;创建workspace和cluster-CSDN博客 2) 创建notebook Workspace -> Users&#xff0c;选择用户&#xff0c;点击Create -> Notebook 选择集群&#xff0c;可以修改notebook名字 修改了notebook名字 选择S…
阅读更多...
triton之语法学习

triton之语法学习

一 基本语法 1 torch中tensor的声明 x = torch.tensor([[1,2, 1, 1, 1, 1, 1, 1],[2,2,2,2,2,2,2,2]],device=cuda) 声明的时候有的时候需要指出数据的类型，不然在kernel中数据类型无法匹配 x = torch.tensor([1,2,1,1,1,1,1,1],dtype = torch.int32,device=cuda) 2 idx id…
阅读更多...
关于冯诺依曼体系结构 和 操作系统（Operator System）的概念讲解（冯诺依曼体系结构，操作系统的作用等）

关于冯诺依曼体系结构 和 操作系统（Operator System）的概念讲解（冯诺依曼体系结构，操作系统的作用等）

目录 一、冯诺依曼体系结构 二、操作系统 1. 概念 2. 设计操作系统的目的 3.系统调用和库函数概念 4.总结 三、完结撒❀ 一、冯诺依曼体系结构 我们常见的计算机&#xff0c;如笔记本。我们不常见的计算机&#xff0c;如服务器&#xff0c;大部分都遵守冯诺依曼体系。 截…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023