記錄--通過手寫，分析Promise核心原理

来源:https://www.cnblogs.com/smileZAZ/archive/2022/09/21/16716772.html
-Advertisement-
Play Games

這裡給大家分享我在網上總結出來的一些知識，希望對大家有所幫助 1. 定義整體結構 先寫出構造函數，將Promise向外暴露 /* 自定義Promise函數模塊：IIFE */ (function (window) { /* Promise構造函數 executor:執行器函數 */ function ...


這裡給大家分享我在網上總結出來的一些知識，希望對大家有所幫助

1. 定義整體結構

  1. 先寫出構造函數，將Promise向外暴露
/*
自定義Promise函數模塊：IIFE
 */

(function (window) {
    /*
    Promise構造函數
    executor:執行器函數
     */
    function Promise(executor) {

    }

    // 向外暴露Promise
    window.Promise = Promise
})()
  1. 添加Promise原型對象上的方法
 /*
    Promise原型對象的then
    指定一個成功/失敗的回調函數
    返回一個新的promise對象
     */
    Promise.prototype.then = function(onResolved,onRejected){

    }

    /*
    Promise原型對象的.catch
    指定一個失敗的回調函數
    返回一個新的promise對象
     */
    Promise.prototype.catch = function(onRejected){

    }
  1. 添加Promise函數對象上的方法
/*
    Promise函數對象的resovle方法
    返回一個指定結果的promise對象
     */
    Promise.resolve = function(value){

    }

    /*
    Promise函數對象的reject方法
    返回一個指定reason的失敗狀態的promise對象
    */
    Promise.reject = function(value){

    }

    /*
    Promise函數對象的all方法
    返回一個promise對象，只有當所有promise都成功時返回的promise狀態才成功
    */
    Promise.all = function(0value){

    }

    /*
    Promise函數對象的race方法
    返回一個promise對象，狀態由第一個完成的promise決定
    */
    Promise.race = function(value){

    }

通過上面的註釋可以知道。不管是Promise原型對象上的方法還是Promise函數對象上的方法 ，它們的執行結果都將返回一個Promise對象

2. 實現Promise構造函數

我們看看我們是怎麼使用Promise的

const promiseA = new Promise( (resolve,reject) => {
    resolve(777);
});
  1. 我們傳入了一個函數，而且這個函數被立即執行，不僅如此，這個函數還會立即執行resolve和reject。說明構造函數里有resolve和reject方法。因此我們可以初步實現：
    /*
    Promise構造函數
    executor:執行器函數
     */
    function Promise(executor) {

        function resovle() {

        }
        function reject() {

        }

        // 立即同步執行executor
        executor(resovle,reject)
    }
  1. 每個promise都有一個狀態可能為pending或resolved，rejected。而且初始狀態都為pending。因此需要添加個status來表示當前promise的狀態.。並且每個promise有自己的data。
function Promise(executor) {

        var self = self
        新增代碼
        self.status = 'pending' // 給promise對象指定status屬性，初始值為pending
    
        self.data = undefined // 給promise對象指定一個存儲結果的data

        function resovle() {

        }
        function reject() {

        }

        // 立即同步執行executor
        executor(resovle,reject)
    }

此外，當我們這樣使用Promise的時候，

// 例1
var promise = new Promise((resovle,reject)=>{
    
})

promise.then(resolve=>{},reject=>{})

這時執行到then，因為我們傳入的立即執行函數沒有執行resolve或者reject，所以promise的狀態還是pending，這時要把then裡面的回調函數保存起來，所以需要個callbacks數組

function Promise(executor) {

        var self = self

        self.status = 'pending' // 給promise對象指定status屬性，初始值為pending
        self.data = undefined // 給promise對象指定一個存儲結果的data
        新增代碼
        self.callbacks = []  // 每個元素的結構：{onResolved(){}，onRejected(){}}


        function resovle() {

        }
        function reject() {

        }

        // 立即同步執行executor
        executor(resovle,reject)
    }

那 then函數是怎麼把傳入的回調收集起來的。其實很簡單，就是判斷當前promise是否為pending狀態，是的話，就把回調push到callbacks中。

Promise.prototype.then = function(onResolved,onRejected){

        var self = this
        
        if(self.status === 'pending'){
            // promise當前狀態還是pending狀態，將回調函數保存起來
            self.callbacks.push({
                onResolved(){onResolved(self.data)},
                onRejected(){onRejected(self.data)}
            })
        }else if(self.status === 'resolved'){
        }else{
        }

    }
  1. 在上面的例子1的基礎上，當我們執行resovle（value）時，如例2
// 例2
var promise = new Promise((resolve,reject)=>{
    setTimeout(function () {
        resolve(1)
    })
})

promise.then(
    value=>{console.log(value)},
    err=>{console.log(err)}
    )

此時代碼執行情況是怎麼樣的呢？

  1. 先執行new Promise里的代碼，然後發現個定時器，js線程將定時器交給定時器線程處理，2. 然後繼續執行下麵的代碼，發現是then，而且當前的promise還是pending的狀態。就把then里的回調函數放到callbacks中。
  2. 5秒後定時器線程將定時器里的回調函數（也就是巨集任務）放到消息隊列中，js線程在消息隊列里發現了這個巨集任務，就把它拿來執行。
  3. 執行這個巨集任務，就執行了resolve(1)，此時promise的callbacks里的回調被執行。並將當前promise狀態改為resolved。然後這個1也會被保存到當前promise對象中

那怎麼實現resolve呢？依舊上面的描述，就知道resovle的功能是執行callbacks里的函數，並保存data，並將當前promise狀態改為resolved。所以我們可以這麼實現

function resolve(value) {
    // 將狀態改為resolved
    self.status = 'resolved'
    // 保存value的值
    self.data = value

    // 如果有待執行的callback函數，立即非同步執行回調函數onResolved
    if (self.callbacks.length>0){
        self.callbacks.forEach(callbackObj=>{
            callbackObj.onResolved(value)
        })
    }
}
  1. 我們還知道，promise的狀態只能改變一次，因此當執行resolve的時候要判斷是不是promise是不是pending的狀態，否則是不能執行的
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(callbackObj=>{ A
                callbackObj.onResolved(value)
            })
        })
    }
}
  1. 異曲同工之妙的是reject方法也是這個道理，因此這裡無需贅述
function reject(value) {
    // 如果當前狀態不是pending，則不執行
    if(self.status !== 'pending'){
        return
    }
    // 將狀態改為rejected
    self.status = 'rejected'
    // 保存value的值
    self.data = value

    // 如果有待執行的callback函數，立即非同步執行回調函數onResolved
    if (self.callbacks.length>0){
      self.callbacks.forEach(callbackObj=>{
          callbackObj.onRejected(value)
      })
    }
}
  1. 我們又知道，當在執行executor的時候，如果執行異常的話，這個promise的狀態會直接執行reject方法。例如
// 例 3
var promise = new Promise((resolve,reject)=>{

    error；執行到這裡出錯了

    setTimeout(function () {
        resolve(1)
    })
})

要實現這個功能，我們可以在executor外讓try catch來捕獲

try{
    // 立即同步執行executor
    executor(resolve,reject)
}catch (e) { // 如果執行器拋出異常，promise對象變為rejected狀態
    reject(e)
}

好了，現在測試下

 // 例4
 let promise = new Promise((resolve,reject)=>{
        
        setTimeout(function () {
            resolve(1)
            //reject(1)
        },100)
    })

    promise.then(
        value=>{
            console.log("onResolved:",value);
        },
        reason=>{
            console.log("onRejected:",reason);
        }
    )

發現成功。 成功輸出onResolved:1

3. 實現then方法

我們在上面簡單的實現了當前promise為pending狀態的情況，如：

Promise.prototype.then = function(onResolved,onRejected){

    var self = this

    if(self.status === 'pending'){
        // promise當前狀態還是pending狀態，將回調函數保存起來
        self.callbacks.push({
            onResolved(){onResolved(self.data)},
            onRejected(){onRejected(self.data)}
        })
    }else if(self.status === 'resolved'){
    }else{
    }

}

那其他情況呢？

執行到then時，promise可能會是pending狀態，此時就要把then里的回調函數保存起來，也可能會是resolved或者rejected狀態，此時就不用把回調保存起來，直接執行onResolved或onRejected方法。註意是非同步執行。而且是做為微任務的，這裡我們簡單的用setTimeout來實現就好了。

Promise.prototype.then = function(onResolved,onRejected){

  var self = this

  if(self.status === 'pending'){
      // promise當前狀態還是pending狀態，將回調函數保存起來
      self.callbacks.push({
          onResolved(){onResolved(self.data)},
          onRejected(){onRejected(self.data)}
      })
  }else if(self.status === 'resolved'){
      setTimeout(()=>{
          onResolved(self.data)
      })
  }else{
      setTimeout(()=>{
          onResolved(self.data)
      })
  }

}

而且我們知道，執行完then是要返回一個新的promise的，而新的promise的狀態則由當前then的執行結果來確定。

 Promise.prototype.then = function(onResolved,onRejected){

    var self = this

    return new Promise((resolve,reject)=>{
        if(self.status === 'pending'){
            // promise當前狀態還是pending狀態，將回調函數保存起來
            self.callbacks.push({
                onResolved(){onResolved(self.data)},
                onRejected(){onRejected(self.data)}
            })
        }else if(self.status === 'resolved'){
            setTimeout(()=>{
                onResolved(self.data)
            })
        }else{
            setTimeout(()=>{
                onResolved(self.data)
            })
        }
    })

}

當 當前的promise狀態為resolved的時候，則執行then的時候，會執行第二個判斷語句

則當前執行第二個判斷語句的時候會出現三種情況

  1. 如果then里的回調函數返回的不是promise，return的新promise的狀態是則是resolved，value就是返回的值。例如：
// 例5
let promise = new Promise((resolve,reject)=>{
    resolve(1)
})

promise.then(
    value=>{
        return value //返回的不是promise，是value
    }
)

因此，我們可以這樣實現

Promise.prototype.then = function(onResolved,onRejected){

    var self = this

    return new Promise((resolve,reject)=>{
        if(self.status === 'pending'){
            // promise當前狀態還是pending狀態，將回調函數保存起來
            self.callbacks.push({
                onResolved(){onResolved(self.data)},
                onRejected(){onRejected(self.data)}
            })
        }else if(self.status === 'resolved'){
            修改代碼
            setTimeout(()=>{
                const result = onResolved(self.data)
                if (result instanceof Promise){

                } else {
                // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
                    resolve(result)
                }
            })
        }else{
            setTimeout(()=>{
                onResolved(self.data)
            })
        }
    })

}

簡單解釋下：

執行onResolved(self.data)，其實就是執行例子中的下麵這個回調函數

value=>{
        return value //返回的不是promise，是value
    }

那麼這個回調函數返回了value。就把value傳入resolve函數，resolve函數將當前新的promise的狀態改為resolved，同時將value保存到當前新的promise的data中。

  1. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果，如代碼所示，我們返回一個新的promise。如果這個promise執行了resolve，返回的新的promise的狀態則是resolved的。否則為rejected
// 例6
let promise = new Promise((resolve,reject)=>{
    resolve(1)
})

promise.then(
    value=>{
        return new Promise((resolve,reject)=>{
            resolve(2)
            //或者
            //reject(error)
        })
    }
)

因此我們可以這樣實現

Promise.prototype.then = function(onResolved,onRejected){

    var self = this

    return new Promise((resolve,reject)=>{
        if(self.status === 'pending'){
            // promise當前狀態還是pending狀態，將回調函數保存起來
            self.callbacks.push({
                onResolved(){onResolved(self.data)},
                onRejected(){onRejected(self.data)}
            })
        }else if(self.status === 'resolved'){
            setTimeout(()=>{
                const result = onResolved(self.data)
                if (result instanceof Promise){
                    // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
                    result.then(
                        value => {resolve(value)},
                        reason => {reject(reason)}
                    )
                } else {
                    // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
                    resolve(result)
                }
            })
        }else{
            setTimeout(()=>{
                onResolved(self.data)
            })
        }
    })

}

在這裡說明一下：

result.then(
    value => {resolve(value)},
    reason => {reject(reason)}
)

由於我們在例6中執行了then里的

value=>{
        return new Promise((resolve,reject)=>{
            resolve(2)
            //或者
            //reject(error)
        })
    }

則返回一個promise對象，這個promise對象可能為resolved狀態（執行 resolve(2)）也可能為rejected狀態（執行reject(error)）。

將會導致value => {resolve(value)},這個回調函數的執行或者 reason => {reject(reason)}的執行。

因此會把即將返回的新的promise的data設置為value或者，reason。會把狀態設置為resolved或者rejected。

  1. 如果執行這段代碼的時候拋出錯誤，則返回的promise的狀態為rejected，我們可以用try catch來實現
setTimeout(()=>{
    try{
        const result = onResolved(self.data)
        if (result instanceof Promise){
            // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
            result.then(
                value => {resolve(value)},
                reason => {reject(reason)}
            )
        } else {
            // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
            resolve(result)
        }
    }catch (e) {
      //  3.如果執行onResolved的時候拋出錯誤，則返回的promise的狀態為rejected
        reject(e)
    }
})

異曲同工之妙的是當status === 'rejected'，道理一樣

 setTimeout(()=>{
      try{
          const result = onRejected(self.data)
          if (result instanceof Promise){
              // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
              result.then(
                  value => {resolve(value)},
                  reason => {reject(reason)}
              )
          } else {
              // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
              resolve(result)
          }
      }catch (e) {
          //  3.如果執行onResolved的時候拋出錯誤，則返回的promise的狀態為rejected
          reject(e)
      }
  })

到這裡，我們發現當執行resolve的時候，onResolved(self.data)和onRejected(self.data)執行時也會跟上面一樣的結果，可以說執行回調函數都要做以上判斷，因此我們要將

 self.callbacks.push({
    onResolved(){onResolved(self.data)},
    onRejected(){onRejected(self.data)}
})

改成

if(self.status === 'pending'){
// promise當前狀態還是pending狀態，將回調函數保存起來
self.callbacks.push({
    onResolved(){
        try{
            const result = onResolved(self.data)
            if (result instanceof Promise){
                // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
                result.then(
                    value => {resolve(value)},
                    reason => {reject(reason)}
                )
            } else {
                // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
                resolve(result)
            }
        }catch (e) {
            //  3.如果執行onResolved的時候拋出錯誤，則返回的promise的狀態為rejected
            reject(e)
        }
    },

到此，我們發現，相同的代碼太多了，因此有必要封裝一下

 function handle(callback) {
    try{
        const result = callback(self.data)
        if (result instanceof Promise){
            // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
            result.then(
                value => {resolve(value)},
                reason => {reject(reason)}
            )
        } else {
            // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
            resolve(result)
        }
    }catch (e) {
        //  3.如果執行onResolved的時候拋出錯誤，則返回的promise的狀態為rejected
        reject(e)
    }
}

這樣以來就清爽了很多

   Promise.prototype.then = function(onResolved,onRejected){

        var self = this

        return new Promise((resolve,reject)=>{
           /*
            調用指定回調函數的處理，根據執行結果。改變return的promise狀態
             */
            function handle(callback) {
                try{
                    const result = callback(self.data)
                    if (result instanceof Promise){
                        // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
                        result.then(
                            value => {resolve(value)},
                            reason => {reject(reason)}
                        )
                    } else {
                        // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
                        resolve(result)
                    }
                }catch (e) {
                    //  3.如果執行onResolved的時候拋出錯誤，則返回的promise的狀態為rejected
                    reject(e)
                }
            }
            if(self.status === 'pending'){
                // promise當前狀態還是pending狀態，將回調函數保存起來
                self.callbacks.push({
                    onResolved(){
                        handle(onResolved)
                    },
                    onRejected(){
                        handle(onRejected)
                    }
                })
            }else if(self.status === 'resolved'){
                setTimeout(()=>{
                    handle(onResolved)
                })
            }else{ // 當status === 'rejected'
                setTimeout(()=>{
                    handle(onRejected)
                })
            }
        })

    }

另外，我們還知道，promise會發生值傳透，例如

let promsie = new Promise((resolve,reject)=>{
    resolve(1)
})
promsie
  .then(2)
  .then(3)
  .then(value =>console.log(value))

運行結果： 1

解釋：.then 或者 .catch 的參數期望是函數，傳入非函數則會發生值穿透。值傳透可以理解為，當傳入then的不是函數的時候，這個then是無效的。而實際原理上其實是當then中傳入的不算函數，則這個then返回的promise的data，將會保存上一個的promise.data。這就是發生值穿透的原因。而且每一個無效的then所返回的promise的狀態都為resolved。

因此，要實現直傳透這個特性，我們可以這樣實現

添加這兩句來判斷要不要發生值傳透

onResolved = typeof onResolved === 'function'? onResolved: value => value
onRejected = typeof onRejected === 'function'? onRejected: reason => {throw reason}

實際上就是改寫，如果傳入的不是函數，那就忽略那個傳入值，自己再寫一個函數。這個函數的執行結果將返回上一個promise的data

Promise.prototype.then = function(onResolved,onRejected){
    onResolved = typeof onResolved === 'function'? onResolved: value => value
    onRejected = typeof onRejected === 'function'? onRejected: reason => {throw reason}
    var self = this

    return new Promise((resolve,reject)=>{

        /*
        調用指定回調函數的處理，根據執行結果。改變return的promise狀態
         */
        function handle(callback) {
            try{
                const result = callback(self.data)
                if (result instanceof Promise){
                    // 2. 如果回調函數返回的是promise，return的promise的結果就是這個promise的結果
                    result.then(
                        value => {resolve(value)},
                        reason => {reject(reason)}
                    )
                } else {
                    // 1. 如果回調函數返回的不是promise，return的promise的狀態是resolved，value就是返回的值。
                    resolve(result)
                }
            }catch (e) {
                //  3.如果執行onResolved的時候拋出錯誤，則返回的promise的狀態為rejected
                reject(e)
            }
        }
        if(self.status === 'pending'){
            // promise當前狀態還是pending狀態，將回調函數保存起來
            self.callbacks.push({
                onResolved(){
                    handle(onResolved)
                },
                onRejected(){
                    handle(onRejected)
                }
            })
        }else if(self.status === 'resolved'){
            setTimeout(()=>{
                handle(onResolved)
            })
        }else{ // 當status === 'rejected'
            setTimeout(()=>{
                handle(onRejected)
            })
        }
    })

}

3.實現catch方法

catch方法的作用跟then里的第二歌回調函數一樣，因此我們可以這樣來實現

Promise.prototype.catch = function(onRejected){
    return this.then(undefined,onRejected)
}

我的天啊，居然這麼簡單

4. 實現Promise.resolve

我們都知道，Promise.resolve方法可以傳三種值

  1. 不是promise
  2. 成功狀態的promise
  3. 失敗狀態的promise
    Promise.resolve(1)
    Promise.resolve(Promise.resolve(1))
    Promise.resolve(Promise.reject(1))

實際上跟實現上面的then時有點像

Promise.resolve = function(value){
  return new Promise((resolve,reject)=>{
      if (value instanceof Promise){
          // 如果value 是promise
          value.then(
              value => {resolve(value)},
              reason => {reject(reason)}
          )
      } else{
          // 如果value不是promise
          resolve(value)
      }

  }

}

5.實現Promise.reject

實現這個比較簡單，返回一個狀態為rejected的promise就好了

/*
Promise函數對象的reject方法
返回一個指定reason的失敗狀態的promise對象
*/
Promise.reject = function(reason){
    return new Promise((resolve,reject)=>{
        reject(reason)
    })
}

6.實現Promise.all

我們知道，這個方法會返回一個promise

    /*
    Promise函數對象的all方法
    返回一個promise對象，只有當所有promise都成功時返回的promise狀態才成功
    */
    Promise.all = function(promises){
        return new Promise((resolve,reject)=>{
           
        })
    }

而這個promise的狀態由遍歷每個promise產生的結果決定

    /*
    Promise函數對象的all方法
    返回一個promise對象，只有當所有promise都成功時返回的promise狀態才成功
    */
    Promise.all = function(promises){
        return new Promise((resolve,reject)=>{
            // 遍歷promises，獲取每個promise的結果
            promises.forEach((p,index)=>{
                
            })
        })
    }

有兩種結果：

  1. 遍歷到有一個promise是reject狀態，則直接返回的promise狀態為rejected
 Promise.all = function(promises){
        return new Promise((resolve,reject)=>{
            // 遍歷promises，獲取每個promise的結果
            promises.forEach((p,index)=>{
                p.then(
                    value => {
    
                    },
                    reason => { //只要有一個失敗，return的promise狀態就為reject
                        reject(reason)
                    }
                )
            })
        })
    }
  1. 遍歷所有的promise的狀態都為resolved,則返回的promise狀態為resolved，並且還要每個promise產生的值傳遞下去
   Promise.all = function(promises){
      const values = new Array(promises.length)
      var resolvedCount = 0 //計狀態為resolved的promise的數量
      return new Promise((resolve,reject)=>{
          // 遍歷promises，獲取每個promise的結果
          promises.forEach((p,index)=>{
              p.then(
                  value => {
                      // p狀態為resolved，將值保存起來
                      values[index] = value
                      resolvedCount++;
                      // 如果全部p都為resolved狀態，return的promise狀態為resolved
                      if(resolvedCount === promises.length){
                          resolve(values)
                      }
                  },
                  reason => { //只要有一個失敗，return的promise狀態就為reject
                      reject(reason)
                  }
              )
          })
      })
  }

好像可以了，當其實這裡還有一個問題，就是all傳進去的數組不一定都是promise對象，可能是這樣的

all([p,2,3,p])

因此需要把不是promise的數字包裝成promise

    Promise.all = function(promises){
        const values = new Array(promises.length)
        var resolvedCount = 0 //計狀態為resolved的promise的數量
        return new Promise((resolve,reject)=>{
            // 遍歷promises，獲取每個promise的結果
            promises.forEach((p,index)=>{
                Promise.resolve(p).then(
                    value => {
                        // p狀態為resolved，將值保存起來
                        values[index] = value
                        resolvedCount++;
                        // 如果全部p都為resolved狀態，return的promise狀態為resolved
                        if(resolvedCount === promises.length){
                            resolve(values)
                        }
                    },
                    reason => { //只要有一個失敗，return的promise狀態就為reject
                        reject(reason)
                    }
                )
            })
        })
    }

7.實現Promise.race

這個方法的實現要比all簡單很多

  /*
    Promise函數對象的race方法
    返回一個promise對象，狀態由第一個完成的promise決定
    */
    Promise.race = function(promises){
        return new Promise((resolve,reject)=>{
            // 遍歷promises，獲取每個promise的結果
            promises.forEach((p,index)=>{
                Promise.resolve(p).then(
                    value => {
                        // 只要有一個成功，返回的promise的狀態九尾resolved
                        resolve(value)

                    },
                    reason => { //只要有一個失敗，return的promise狀態就為reject
                        reject(reason)
                    }
                )
            })
        })
    }

本文轉載於:

https://juejin.cn/post/6856213486633304078

如果對您有所幫助，歡迎您點個關註，我會定時更新技術文檔，大家一起討論學習，一起進步。

 


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • Linux系統Oracle常見操作
    一、 登錄 1.1 登錄預設資料庫 首先切換到oracle用戶，用資料庫預設管理員登錄。 [root@tsm-zh01 ~]# su – oracle [oracle@redhat ~]$ lsnrctl start #開啟監聽 [oracle@tsm-zh01 ~]$ sqlplus / as s ...
  • 一條sql瞭解MYSQL的架構設計
    對於一個服務端開發來說 MYSQL 可能是他使用最熟悉的資料庫工具，然而，大部分的Java工程師對MySQL的瞭解和掌握程度，大致就停留在這麼一個階段:它可以建庫、建表、建索引，然後就是對裡面的數據進行增刪改查，語句性能有點差？沒關係，在表裡建幾個索引或者調整一下查詢邏輯就可以了，一條sql，MYS... ...
  • PostgreSQL邏輯複製解密
    在數字化時代的今天，我們都認同數據會創造價值。為了最大化數據的價值，我們不停的建立著數據遷移的管道，從同構到異構，從關係型到非關係型，從雲下到雲上，從數倉到數據湖，試圖在各種場景挖掘數據的價值。而在這縱橫交錯的數據網路中，邏輯複製扮演著及其重要的角色。 讓我們將視角從複雜的網路拉回其中的一個端點，... ...
  • 日本開放Wi-Fi 6E認證
    2022年9月2日，日本MIC（総務省）發佈了“電波法施行規則等の一部を改正する省令（令和4年総務省令第59號）”省令，更新了Wi-Fi 6E Band 5頻帶5925 ~ 6425 MHz的技術要求。隔天（9月3日），日本DSP機構發佈了“「6GHz帯小電力データ通信システム」の特性試験方法”，為 ...
  • Android12申請藍牙許可權說明
    AU上傳ipa出現下圖紅框提示說明成功上傳，如果App Store後臺沒有出現構建版本， 請登錄 apple賬號對應的郵箱查看反饋，特別留意垃圾郵箱，無論成功還是失敗，apple都會發郵件 一、首先登錄iTunes Connect 後臺、查看ipa構建情況 https://appstoreconne ...
  • 如何用AR Engine開發一個虛擬形象表情包？
    現如今，人們在網上聊天、發帖時越來越愛用表情包，表情包一方面是一種個性化的表達方式，另一方面更能傳達出當下的心理活動，可以說在網路社交中表情包是一個不可或缺的存在。加上近年來元宇宙的興起，3D虛擬形象廣泛應用，用戶可以通過自己的表情來控制虛擬形象的表情，做一系列專屬的表情包，更加生動形象。 那麼，如 ...
  • vue+element-ui後臺管理系統模板
    ##vue+element-ui後臺管理系統模板 前端：基於vue2.0+或3.0+加上element-ui組件框架 後端：springboot+mybatis-plus寫介面 通過Axios調用介面完成數據傳遞 通過router路由完成各頁面的跳轉 ###全局配置 App.vue <templat ...
  • Html飛機大戰(十七): 優化移動端
    好家伙，繼續優化， 好家伙，我把我的飛機大戰發給我的小伙伴們玩 期待著略微的贊賞之詞，然後他們用手機打開我的給他們的網址 然後點一下飛機就炸了。 游戲體驗零分 （滑鼠點擊在移動端依舊可以生效） 好了所以我們來優化一下這個觸屏移動事件 由於沒有參考，就去翻文檔了 觸摸事件分三個：touchstart、 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類