promise-3.md

最新推荐文章于 2023-04-21 17:03:49 发布
最新推荐文章于 2023-04-21 17:03:49 发布
阅读量221 收藏
点赞数
分类专栏： js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LLLLLLLLLLe/article/details/107977468
版权

自定义promise

开始之前，先来回顾一下JS中的闭包

JS特殊的作用域

变量的作用域无非就是两种：全局变量和局部变量，Javascript语言的特殊之处，就在于函数内部可以直接读取全局变量，函数外部自然无法读取函数内的局部变量（父对象的所有变量，对子对象都是可见的，反之则不成立）

就像下面的这个例子一样，在f2()中可以访问到f1()的n=999，但在f1()中是获取不到f2()中的m=888的

function f1(){
　　var n=999;
　　function f2(){
　　		var m = 888;
　　　　alert(n); // 999
　　}
}

要解决在f1()中可以获取到f2()中的值或者在f1()的外部获取到f2()中的值，只要把f2()作为返回值，就可以在f1()外部读取它的内部变量了～

function f1(){
　　var n=999;
　　function f2(){
　　　　alert(n);
　　}
　　return f2;
}
var result=f1();
result(); // 999
闭包

所以！！上面说的f2()就是闭包（闭包就是能够读取其他函数内部变量的函数）

由于在Javascript语言中，只有函数内部的子函数才能读取局部变量，因此可以把闭包简单理解成"定义在一个函数内部的函数"

所以，在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁

闭包可以用在许多地方。它的最大用处有两个：

  • 一个是前面提到的可以读取函数内部的变量
  • 另一个就是让这些变量的值始终保持在内存中

看代码理解

function f1(){
　　 var n=999;
　　　nAdd=function(){n+=1}
　　　function f2(){
　　　　alert(n);
　　　}
　　　return f2;
　　}
　var result=f1();
　result(); // 999
　nAdd();
　result(); // 1000

在这段代码中，result实际上就是闭包f2()。它一共运行了两次，第一次的值是999，第二次的值是1000。这证明了，f1()中的局部变量n一直保存在内存中，并没有在f1调用后被自动清除

原因就在于f1是f2的父函数，而f2被赋给了一个全局变量，这导致f2始终在内存中，而f2的存在依赖于f1，因此f1也始终在内存中，不会在调用结束后，被垃圾回收机制（garbage collection）回收

f2被赋给了一个全局变量 ❓❓

"nAdd=function(){n+=1}"这一行，首先在nAdd前面没有使用var关键字，因此nAdd是一个全局变量，而不是局部变量。其次，nAdd的值是一个匿名函数（anonymous function），而这个匿名函数本身也是一个闭包，所以nAdd相当于是一个setter，可以在函数外部对函数内部的局部变量进行操作

自定义promise整体结构

  • 先创建一个lib/promise.js
// 自定义promise函数模块：IIFE

// 最外层的是匿名函数的自调用
// (function (params) {})()

(function (window) {
  /**
   Promise构造函数 
   executor：执行器构造函数（同步执行） 
   */
  function Promise(excutor) {
  	function resolve(){},
  	function reason(){},
  	
	// 立即同步执行excutor（执行器函数）
	excutor(resolve, reject);
  }


  /**
   * Promise原型对象的then()方法
   * 指定成功/失败的回调函数
   * 函数的返回值为一个新的promise对象
   */
  Promise.prototype.then = function (onResolved, onRejected) {
    
  }

  /**
   * Promise原型对象的catch()方法
   * 指定失败的回调函数
   * 函数的返回值为一个新的promise对象
   */
  Promise.prototype.catch = function (onRejected) {

  }

  /**
   * Promise函数对象的resolve方法
   * 返回一个指定结果的成功的promise
   */
  Promise.resolve = function (value) {

  }

  /**
   * Promise函数对象的reject方法
   * 返回一个指定reason的失败的promise
   */
  // 
  Promise.reject = function (reason) {

  }

  /**
   * Promise函数对象的all方法
   * 返回一个promise，只有当所有的promise都成功时才成功，否则失败
   */
  Promise.all = function (promises) {

  }


  /**
   * Promise函数对象的race方法
   * 返回一个promise，其结果由第一个完成的promise来决定
   */
  Promise.race = function (promises) {

  }


  // 向外暴露的Promise函数
  window.Promise = Promise;
})(window)
  • 在html中引入promise.js
<body>
  <script src="./lib/promise.js"></script>
  <script>
    const p = new Promise((resolve, reject) => {
       resolve(1); // 1 代表的是 value
      // reject(2); // 2 代表的是 reason
    )
  </script>
</body>

因为在html的promise中有resolve(value) 和 reject(reason)，所以在promise中的executor：执行器构造函数中也就应该有对应的参数

/**
Promise构造函数 
 executor：执行器构造函数（同步执行） 
 */
function Promise(excutor) {
	function resolve(value){},
	function reason(reason){}
}

接下来稍微完善一下excutor构造函数和html文件

/**
Promise构造函数 
 executor：执行器构造函数（同步执行） 
 */
function Promise(excutor) {
	this.status = 'pending'; //给promise对象指定status属性，初始值为pending
  	this.data = undefined; //给promise对象指定一个用于存储结果数据的属性
    this.callbacks = []; //每个元素的结构：{onResolved: {}, onRejected: {}}
    
	function resolve(value){},
	function reason(reason){}
}

<body>
  <script src="./lib/promise.js"></script>
  <script>
    const p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(1); // 1 代表的是 value
      // reject(2); // 2 代表的是 reason
      });
    })

    p.then(
      value => {},
      reason => {}
    )

    p.then(
      value => {},
      reason => {}
    )
  </script>
</body>

and then

如果执行html中的resolve的时候，js中的excutor构造函数得干嘛呢？？

/**
   Promise构造函数 
   executor：执行器构造函数（同步执行） 
   */
  function Promise(excutor) {
    // 重定向this为_this, _this指的是Promise对象，不重定向的话this指的是window
    const _this = this;
    _this.status = 'pending'; //给promise对象指定status属性，初始值为pending
    _this.data = undefined; //给promise对象指定一个用于存储结果数据的属性
    _this.callbacks = []; //每个元素的结构：{onResolved: {}, onRejected: {}}

    function resolve(value) {
    // 这里判断如果当前状态不是pending，直接结束
      if(_this.status !== 'pending'){
        return;
      }

      // 将状态改为resolved
      _this.status = 'resolved'
      // 保存value数据
      _this.data = value;
      // 如果由待执行的callback函数，立即执行回调函数onResolved()
      if (_this.callbacks.length > 0) {
        setTimeout(() => { // 放入队列中所有成功的回调
          _this.callbacks.forEach(callbacksObj => {
            callbacksObj.onResolved(value);
          })
        }, 0);
      }
    }

    function reject(reason) {
    // 这里判断如果当前状态不是pending，直接结束
      if(_this.status !== 'pending'){
        return;
      }
      
      // 将状态改为rejected
      _this.status = 'rejected'
      // 保存value数据
      _this.data = reason;
      // 如果由待执行的callback函数，立即执行回调函数onResolved()
      if (_this.callbacks.length > 0) {
        setTimeout(() => { // 放入队列中所有失败的回调
          _this.callbacks.forEach(callbacksObj => {
            callbacksObj.onRejected(reason);
          })
        }, 0);
      }
    }


	// html如果在执行器中抛出异常的话，promise会变成失败状态，也就是即没调用resolve又没调用reject。执行器抛出异常想让Promise变成失败状态，就需要在js中 catch error 了
	
    // 立即同步执行excutor（执行器函数）
    try {
      excutor(resolve, reject);
    } catch (error) {   //如果执行器抛出异常，promise对象变为rejected状态
      return error;
    }
  }

然后在.then()函数中进行操作

Promise.prototype.then = function (onResolved, onRejected) {
    // 重定向this为_this, _this指的是Promise对象，不重定向的话this指的是window
    const _this = this;
    
    // 假设当前状态还是pending，将回调函数保存起来
    _this.callbacks.push({
      onResolved,
      onRejected
    })
  }

⚠️ 现在写的流程是先改状态，再指定回调函数。但是正常的流程是先执行回调函数再改状态。所以这里应该修改一下。给setTimeOut 加个延迟时间。然后可以在p.then()中打印一下

<body>
  <script src="./lib/promise.js"></script>
  <script>
    const p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(1); // 1 代表的是 value
      // reject(2); // 2 代表的是 reason

	 // 这里
      }, 100);
    })

    p.then(
      value => {
        console.log("onResolved1():", value);
      },
      reason => {
        console.log("onRejected1():", reason);
      }
    )

    p.then(
      value => {
        console.log("onResolved2():", value);
      },
      reason => {
        console.log("onRejected2():", reason);
      }
    )
  </script>
</body>

上面是resolve成功时的执行结果

还有一个就是来测试一下到底是同步调用还是异步调用

如果console.log("reject()改变状态之后");这句先执行，p.then()后执行，则可以说明回调函数是异步执行的

<body>
  <script src="./lib/promise.js"></script>
  <script>
    const p = new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(1); // 1 代表的是 value
      // reject(2); // 2 代表的是 reason

      // 用这个console.log来验证到底是同步还是异步
      console.log("reject()改变状态之后");
      }, 100);
    })

    p.then(
      value => {
        console.log("onResolved1():", value);
      },
      reason => {
        console.log("onRejected1():", reason);
      }
    )

    p.then(
      value => {
        console.log("onResolved2():", value);
      },
      reason => {
        console.log("onRejected2():", reason);
      }
    )
  </script>
</body>

怎么改状态，怎么存数据由内部定义者决定，什么时候调用由外部使用者决定

上面在.then()中直接是假设当前状态为pending的，但实际不一定是这样的，所以就需要在其中做状态的判断

这里先将状态定义成常量，是在(function (window) {下面直接定义的，然后将之前在各函数中的定义的状态都改成现在这样的大写形式

(function (window) {

  const PENDING = 'pending'
  const RESOLVED = 'resolved'
  const REJECTED = 'rejected'

  /**
   Promise构造函数 
   executor：执行器构造函数（同步执行） 
   */
  function Promise(excutor) {
  ...

修改完后在之前的.then方法中进行状态判断

 /**
   * Promise原型对象的then()方法
   * 指定成功/失败的回调函数
   * 函数的返回值为一个新的promise对象
   */
  Promise.prototype.then = function (onResolved, onRejected) {
    const _this = this;
    // 假设当前状态还是PENDiNG，将回调函数保存起来
    // 这里的this指的是promise对象

    if(_this.status === 'PENDING'){
      _this.callbacks.push({
        onResolved,
        onRejected
      })
    }else if (_this.status === 'RESOLVED'){
      setTimeout(() => {
        onResolved(_this.data);
      });
    }else {   // rejected
      setTimeout(() => {
        onRejected(_this.data);
      });
    }
  }

就像.then()函数上面的注释里面说的一样，最后结果是返回一个新的promise对象，所以这里应该return new Promise👇

 // 返回一个新的promise对象
 return new Promise ((resolve, reject) => {

 })

又因为这个Promise的参数中有 resolve 和 reject，如果你想在执行完函数之后根据结果去判断到底是调用resolve还是reject，这个时候就需要用上面的这个return语句将上面的状态判断包起来，然后在里面进行判断

/**
 * Promise原型对象的then()方法
  * 指定成功/失败的回调函数
  * 函数的返回值为一个新的promise对象
  */
 Promise.prototype.then = function (onResolved, onRejected) {
   const _this = this;
   // 假设当前状态还是PENDiNG，将回调函数保存起来
   // 这里的this指的是promise对象

   // 返回一个新的promise对象
   return new Promise((resolve, reject) => {
     if (_this.status === 'PENDING') {
       _this.callbacks.push({
         onResolved,
         onRejected
       })
     } else if (_this.status === 'RESOLVED') {
       setTimeout(() => {

         /**
          * 1. 如果抛出异常，return的Promise就会失败，reason就是error
          * 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
          * 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
          * 
          */

         try {
           const result = onResolved(_this.data);

           if (result instanceof Promise) {
             // 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
             result.then(
               value => resolve(value), // 当result成功时，让return 的 Promise 也成功
               reason => reject(reason) // 当result失败时，让return 的 Promise 也失败

               // 与下面写法一致
               // value => {
               //   resolve(value);
               // },
               // reason => {
               //   reject(reason);
               // }
             )
           } else {
             // 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
             resolve(result);
           }
           
         } catch (error) {
           // 1. 如果抛出异常，return的Promise就会失败，reason就是error
           reject(error);
         }

       });
     } else { // rejected
       setTimeout(() => {
         onRejected(_this.data);
       });
     }


   })

 }

接下来将上面else if 中的的写法更改成更简洁版

setTimeout(() => {

   /**
      * 1. 如果抛出异常，return的Promise就会失败，reason就是error
      * 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
      * 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
      * 
      */

     try {
       const result = onResolved(_this.data);

       if (result instanceof Promise) {
         // 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
         // result.then(
         //   value => resolve(value), // 当result成功时，让return 的 Promise 也成功
         //   reason => reject(reason) // 当result失败时，让return 的 Promise 也失败
         // )

         //  上面的写法和下面的是一样的
         
         // 说明
         // 假设result成功了，那它会调 resolve，并且给resolve传入成功的value
         // 那return 的 Promise 就会变成成功的状态
         result.then(resolve, reject);
       } else {
         // 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
         resolve(result);
       }
       
     } catch (error) {
       // 1. 如果抛出异常，return的Promise就会失败，reason就是error
       reject(error);
     }

   });

else if 中可以这样写的话，那么else 中也就可以这样写了，只是把之前的 onResolved() 改为 onRejected()

else { // rejected
setTimeout(() => {

  /**
   * 1. 如果抛出异常，return的Promise就会失败，reason就是error
   * 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
   * 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
   * 
   */

  try {
    const result = onRejected(_this.data);

    if (result instanceof Promise) {
      // 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
      // result.then(
      //   value => resolve(value), // 当result成功时，让return 的 Promise 也成功
      //   reason => reject(reason) // 当result失败时，让return 的 Promise 也失败
      // )

      //  上面的写法和下面的是一样的
      
      // 说明
      // 假设result成功了，那它会调 resolve，并且给resolve传入成功的value
      // 那return 的 Promise 就会变成成功的状态
      result.then(resolve, reject);
    } else {
      // 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
      resolve(result);
    }
    
  } catch (error) {
    // 1. 如果抛出异常，return的Promise就会失败，reason就是error
    reject(error);
  }

});
}

接下来

看一下.then函数里面的代码

如果当前是pending状态的时候，就直接_this.callbacks.push 存起来，而且如果成功了的话就会执行onResolved函数，如果失败了就执行onRejected。但问题是执行完它们之后，怎么影响这个Promise的状态呢？？（可以看出直接将onResolved，onRejected存进callbacks中是不行的

 Promise.prototype.then = function (onResolved, onRejected) {
  const _this = this;
  // 假设当前状态还是PENDiNG，将回调函数保存起来
  // 这里的this指的是promise对象

  // 返回一个新的promise对象
  return new Promise((resolve, reject) => {
    if (_this.status === 'PENDING') {
      _this.callbacks.push({
        onResolved,
        onRejected
      })
    } else if (_this.status === 'RESOLVED') {
      setTimeout(() => {

        /**
         * 1. 如果抛出异常，return的Promise就会失败，reason就是error
         * 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
         * 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
         * 
         */

        try {
          const result = onResolved(_this.data);

          if (result instanceof Promise) {
            // 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
            // result.then(
            //   value => resolve(value), // 当result成功时，让return 的 Promise 也成功
            //   reason => reject(reason) // 当result失败时，让return 的 Promise 也失败
            // )

            //  上面的写法和下面的是一样的

            // 说明
            // 假设result成功了，那它会调 resolve，并且给resolve传入成功的value
            // 那return 的 Promise 就会变成成功的状态
            result.then(resolve, reject);
          } else {
            // 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
            resolve(result);
          }
          
        } catch (error) {
          // 1. 如果抛出异常，return的Promise就会失败，reason就是error
          reject(error);
        }

      });
    } else { // rejected
      setTimeout(() => {

        /**
         * 1. 如果抛出异常，return的Promise就会失败，reason就是error
         * 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
         * 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
         * 
         */

        try {
          const result = onRejected(_this.data);

          if (result instanceof Promise) {
            // 3. 如果回调函数返回的是Promise，return的promise的结果就是这个promise的结果
            // result.then(
            //   value => resolve(value), // 当result成功时，让return 的 Promise 也成功
            //   reason => reject(reason) // 当result失败时，让return 的 Promise 也失败
            // )

            //  上面的写法和下面的是一样的
            
            // 说明
            // 假设result成功了，那它会调 resolve，并且给resolve传入成功的value
            // 那return 的 Promise 就会变成成功的状态
            result.then(resolve, reject);
          } else {
            // 2. 如果回调函数返回的不是Promise，return的promise就会成功，value就是返回的值
            resolve(result);
          }
          
        } catch (error) {
          // 1. 如果抛出异常，return的Promise就会失败，reason就是error
          reject(error);
        }

      });
    }
  })
}

这块还没有完善好…

自定义resolve/reject
OOOOOOh~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python编程基础：第二十五节 args参数*args
wzy628810的博客
07-15 7187
*args = parameter that will pack all arguments into a tuple. useful so that a function can accept a varying amount of arguments
python中*args的使用
weixin_45336222的博客
06-05 7668
python中的一些语法使用
Python *args 用法笔记
TEDxPY
07-25 1万+
整理自《Effective Python 编写高质量 Python 代码的 59 个有效方法》第 18 条。 1. 定义、用法 在 def 语句中使用 *args，即可令函数接受数量可变的位置参数。 比如确定一个函数接收 message 信息参数和 values 值参数，但不确定 values 有几个值，解决方法可以把 values 定义成列表，有数据就塞入列表，无数据就空列表，得到如下函数代码： def log(message,values): if not values: pri
python args用法_【python】args kwargs 用法
weixin_29421565的博客
03-01 300
def foo(*args, **kwargs):print 'args = ', argsprint 'kwargs = ', kwargsprint '---------------------------------------'if __name__ == '__main__':foo(1,2,3,4)foo(a=1,b=2,c=3)foo(1,2,3,4, a=1,b=2,c=3)foo...
Python args 参数用法
u011699626的博客
04-21 1225
以前写代码的时候也用到过args参数，但是时间久了就有些忘了，今天用的时候遇到了一个错误，这里特来记录一下。
05-promise调用顺序.md
03-31
大厂前端面试题目|# 开始 遇到一个需求、问题或者一段代码，如何能高效的分析、解决它，这是前端程序员的必备技能。否则你将无法独立工作，这不是企业需要的人才。本章将通过多个面试题，教你如何分析问题、解决...
pdfjs-2.2.228-dist.rar
12-30
3. **自定义界面**：PDF.js 提供了一个基本的 UI，但允许开发者根据自己的需求定制界面，例如添加工具栏、设置全屏模式等。 4. **分块加载**：为了提高性能，PDF.js 会按需加载 PDF 文件的各个部分，而不是一次性...
axios-0.19.2.tar.gz
最新发布
06-10
3. **拦截器**：Axios提供了请求和响应拦截器，允许在请求发送前或响应接收后添加额外的操作，如统一处理错误或者添加全局的请求头。 4. **支持多种请求方法**：包括GET、POST、PUT、DELETE等HTTP方法，并且可以...
axios-0.13.1.tar.gz
06-10
3. **跨域请求** 在浏览器环境中，Axios可以轻松处理跨域请求，这对于现代Web应用来说至关重要。它能够自动添加合适的CORS头，使得前端应用可以与不同源的API进行通信。 4. **转换请求和响应数据** Axios允许...
promise.md
06-03
promise.md记载了promise的规范 它是一套异步操作处理机制， [Promise A+](https://promisesaplus.com/) 是规范，jQuery、ES2015、q的promise都是对该规范的一种实现.
promise:Python 中的超高性能 Promise 实现
05-30
承诺 这是 Python 中 Promise 的一个实现。 它是 Promises/A+ 的超级集，旨在拥有可读、高性能的代码，并仅提供在 Python 中使用 Promise 绝对必要的扩展。 它与完全兼容 安装 $ pip install promise 用法 下面的示例显示了如何加载 Promise 库。 然后它演示了从头开始创建一个 promise。 您只需调用Promise(fn) 。 在有一个关于这个方法返回什么的完整规范。 from promise import Promise promise = Promise ( lambda resolve , reject : resolve ( 'RESOLVED!' ) ) 应用程序接口 在所有示例之前，您将需要： from promise import Promise 承诺（解析器） 这将创建并返回一个新的
python中args是什么意思_Python中*args、**args到底是什么、有啥区别、怎么用
weixin_39525355的博客
12-05 2530
调用函数时使用*和 **假设有函数def test(a, b, c)test(*args)：* 的作用其实就是把序列 args 中的每个元素，当作位置参数传进去。比如上面这个代码，如果 args 等于 (1,2,3) ，那么这个代码就等价于 test(1, 2, 3) 。test(**kwargs)：** 的作用则是把字典 kwargs 变成关键字参数传递。比如上面这个代码，如果 kwargs 等...
Python 学习入门（17）—— args, kwargs
810364804
12-05 112
The special syntax,*argsand**kwargsin function definitions is used to pass a variable number of arguments to a function. The single asterisk form (*args) is used to pass anon-keyworded, variable-lengt...
Python *args 和 *kwargs 的用法
一分耕耘一分收获
02-17 1858
1.*args的使用方法 *args 用来将参数打包成 tuple 给函数体调用，args 是 tuple 或者 list 都可以。 此处的 * 可以理解为解析 args 这个 tuple。 2.**kwargs的使用方法 ** kwargs 打包关键字参数成 dict 给函数体调用。kwargs 是一个字典。 此处的 * 可以理解为解析 kwargs 这个 dict。 注意：参数arg、*args、**kwargs三个参数的位置必须是一定的，
python 不指定参数个数---args基础用法
爱在深秋
04-17 2395
在有些时候，设计函数的时候，可能不知道要传入的参数类型或者参数个数，此时args可以很好地解决。
Python函数*args与**kwargs的用法
热门推荐
木子木泗的博客
05-12 2万+
这两个是python中的可变参数。 *args表示任何多个无名参数，它是一个tuple； **kwargs表示关键字参数，它是一个dict。 并且同时使用*args和**kwargs时，必须*args参数列要在**kwargs前，def fun(*args,**kwargs): print('args=', args) print('kwargs=',kwargs) fun(1
pyhton的*args,**kwargs使用
sinat_31608641的博客
08-09 1235
python 可变参数
pythonawait概念图解_轻松理解 Python 中的 async await 概念
weixin_42429109的博客
01-29 543
from time import sleep, timedef demo1():"""假设我们有三台洗衣机, 现在有三批衣服需要分别放到这三台洗衣机里面洗."""def washing1():sleep(3) # 第一台洗衣机, 需要洗3秒才能洗完 (只是打个比方)print('washer1 finished') # 洗完的时候, 洗衣机会响一下, 告诉我们洗完了def washing2():s...
Python中*args用法
a578656995的博客
02-05 1万+
Python中可用def function(): 创建一个自定义函数。 下面我将用代码解释def function(*args): 的用法 --- *args输入参数如何工作的： #!/usr/bin/python # -*- coding: UTF-8 -*- def biggest_number(*args): print max(args) return max(args
我只有这个spark-md5.min,如果说改成SHA-256算法,那我需要下载哪些,怎么下载
06-10
如果您想在前端使用SHA-256算法来计算哈希值，可以使用`crypto.subtle.digest()`方法。这是一个Web Crypto API提供的方法，可以在浏览器中进行安全的哈希计算。 以下是一个示例代码，使用SHA-256算法计算字节数组的哈希值： ```javascript async function sha256(bytes) { const hashBuffer = await crypto.subtle.digest('SHA-256', bytes); const hashArray = Array.from(new Uint8Array(hashBuffer)); const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join(''); return hashHex; } ``` 这个函数会将字节数组作为参数，返回一个Promise对象，计算完成后返回哈希值，以16进制字符串的形式表示。 需要注意的是，使用`crypto.subtle.digest()`方法计算哈希值需要浏览器支持Web Crypto API。如果您需要支持较老的浏览器，可以考虑使用第三方库，例如CryptoJS。您可以在官方网站上下载最新版本的CryptoJS库，以下是一个使用SHA-256算法计算哈希值的示例代码： ```javascript const hash = CryptoJS.SHA256(bytes).toString(); ``` 这个代码会将字节数组作为参数，使用CryptoJS库中的SHA-256算法计算哈希值，返回一个哈希字符串。 需要注意的是，使用第三方库可能会增加页面加载时间和运行时开销。因此，如果您只需要在较新的浏览器中使用SHA-256算法计算哈希值，建议使用Web Crypto API提供的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值