理解Vue 2.5的Diff演算法

来源:http://www.cnblogs.com/isLiu/archive/2017/11/28/7909889.html
-Advertisement-
Play Games

DOM“天生就慢”，所以前端各大框架都提供了對DOM操作進行優化的辦法，Angular中的是臟值檢查，React首先提出了Virtual Dom，Vue2.0也加入了Virtual Dom，與React類似。 本文將對於Vue 2.5.3版本中使用的Virtual Dom進行分析。 updataCh ...


DOM“天生就慢”，所以前端各大框架都提供了對DOM操作進行優化的辦法，Angular中的是臟值檢查，React首先提出了Virtual Dom，Vue2.0也加入了Virtual Dom，與React類似。

本文將對於Vue 2.5.3版本中使用的Virtual Dom進行分析。

updataChildren是Diff演算法的核心，所以本文對updataChildren進行了圖文的分析。

1.VNode對象

一個VNode的實例包含了以下屬性，這部分代碼在src/core/vdom/vnode.js里

export default class VNode {
  tag: string | void;
  data: VNodeData | void;
  children: ?Array<VNode>;
  text: string | void;
  elm: Node | void;
  ns: string | void;
  context: Component | void; // rendered in this component's scope
  key: string | number | void;
  componentOptions: VNodeComponentOptions | void;
  componentInstance: Component | void; // component instance
  parent: VNode | void; // component placeholder node

  // strictly internal
  raw: boolean; // contains raw HTML? (server only)
  isStatic: boolean; // hoisted static node
  isRootInsert: boolean; // necessary for enter transition check
  isComment: boolean; // empty comment placeholder?
  isCloned: boolean; // is a cloned node?
  isOnce: boolean; // is a v-once node?
  asyncFactory: Function | void; // async component factory function
  asyncMeta: Object | void;
  isAsyncPlaceholder: boolean;
  ssrContext: Object | void;
  functionalContext: Component | void; // real context vm for functional nodes
  functionalOptions: ?ComponentOptions; // for SSR caching
  functionalScopeId: ?string; // functioanl scope id support
  • tag: 當前節點的標簽名
  • data: 當前節點的數據對象，具體包含哪些欄位可以參考vue源碼types/vnode.d.ts中對VNodeData的定義
  • children: 數組類型，包含了當前節點的子節點
  • text: 當前節點的文本，一般文本節點或註釋節點會有該屬性
  • elm: 當前虛擬節點對應的真實的dom節點
  • ns: 節點的namespace
  • context: 編譯作用域
  • functionalContext: 函數化組件的作用域
  • key: 節點的key屬性，用於作為節點的標識，有利於patch的優化
  • componentOptions: 創建組件實例時會用到的選項信息
  • child: 當前節點對應的組件實例
  • parent: 組件的占位節點
  • raw: raw html
  • isStatic: 靜態節點的標識
  • isRootInsert: 是否作為根節點插入，被
  • isComment: 當前節點是否是註釋節點
  • isCloned: 當前節點是否為克隆節點
  • isOnce: 當前節點是否有v-once指令

2.VNode的分類

VNode可以理解為VueVirtual Dom的一個基類，通過VNode構造函數生成的VNnode實例可為如下幾類：

  • EmptyVNode: 沒有內容的註釋節點
  • TextVNode: 文本節點
  • ElementVNode: 普通元素節點
  • ComponentVNode: 組件節點
  • CloneVNode: 克隆節點，可以是以上任意類型的節點，唯一的區別在於isCloned屬性為true

3.Create-Element源碼解析

這部分代碼在src/core/vdom/create-element.js里，我就直接粘代碼加上我的註釋了

export function createElement (
  context: Component,
  tag: any,
  data: any,
  children: any,
  normalizationType: any,
  alwaysNormalize: boolean
): VNode {
  // 相容不傳data的情況
  if (Array.isArray(data) || isPrimitive(data)) {
    normalizationType = children
    children = data
    data = undefined
  }
  // 如果alwaysNormalize是true
  // 那麼normalizationType應該設置為常量ALWAYS_NORMALIZE的值
  if (isTrue(alwaysNormalize)) {
    normalizationType = ALWAYS_NORMALIZE
  }
  // 調用_createElement創建虛擬節點
  return _createElement(context, tag, data, children, normalizationType)
}

export function _createElement (
  context: Component,
  tag?: string | Class<Component> | Function | Object,
  data?: VNodeData,
  children?: any,
  normalizationType?: number
): VNode {

  /**
   * 如果存在data.__ob__，說明data是被Observer觀察的數據
   * 不能用作虛擬節點的data
   * 需要拋出警告，並返回一個空節點
   *
   * 被監控的data不能被用作vnode渲染的數據的原因是：
   * data在vnode渲染過程中可能會被改變，這樣會觸發監控，導致不符合預期的操作
   */
  if (isDef(data) && isDef((data: any).__ob__)) {
    process.env.NODE_ENV !== 'production' && warn(
      `Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` +
      'Always create fresh vnode data objects in each render!',
      context
    )
    return createEmptyVNode()
  }
  // object syntax in v-bind
  if (isDef(data) && isDef(data.is)) {
    tag = data.is
  }
  if (!tag) {
    // 當組件的is屬性被設置為一個falsy的值
    // Vue將不會知道要把這個組件渲染成什麼
    // 所以渲染一個空節點
    // in case of component :is set to falsy value
    return createEmptyVNode()
  }
  // key為非原始值警告
  // warn against non-primitive key
  if (process.env.NODE_ENV !== 'production' &&
    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
  ) {
    warn(
      'Avoid using non-primitive value as key, ' +
      'use string/number value instead.',
      context
    )
  }
  // 作用域插槽
  // support single function children as default scoped slot
  if (Array.isArray(children) &&
    typeof children[0] === 'function'
  ) {
    data = data || {}
    data.scopedSlots = { default: children[0] }
    children.length = 0
  }
  // 根據normalizationType的值，選擇不同的處理方法
  if (normalizationType === ALWAYS_NORMALIZE) {
    children = normalizeChildren(children)
  } else if (normalizationType === SIMPLE_NORMALIZE) {
    children = simpleNormalizeChildren(children)
  }
  let vnode, ns
  // 如果標簽名是字元串類型
  if (typeof tag === 'string') {
    let Ctor
    // 獲取標簽的命名空間
    ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag)
    // 如果是保留標簽
    if (config.isReservedTag(tag)) {
      // platform built-in elements
      // 就創建這樣一個vnode
      vnode = new VNode(
        config.parsePlatformTagName(tag), data, children,
        undefined, undefined, context
      )
      // 如果不是保留字標簽，嘗試從vm的components上查找是否有這個標簽的定義
    } else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
      // component
      // 如果找到，就創建虛擬組件節點
      vnode = createComponent(Ctor, data, context, children, tag)
    } else {
      // unknown or unlisted namespaced elements
      // check at runtime because it may get assigned a namespace when its
      // parent normalizes children
      // 兜底方案，創建一個正常的vnode
      vnode = new VNode(
        tag, data, children,
        undefined, undefined, context
      )
    }
  } else {
    // 當tag不是字元串的時候，我們認為tag是組件的構造類
    // 所以直接創建
    // direct component options / constructor
    vnode = createComponent(tag, data, context, children)
  }
  if (isDef(vnode)) {
    // 應用命名空間
    if (ns) applyNS(vnode, ns)
    return vnode
  } else {
    // 返回一個空節點
    return createEmptyVNode()
  }
}

function applyNS (vnode, ns, force) {
  vnode.ns = ns
  if (vnode.tag === 'foreignObject') {
    // use default namespace inside foreignObject
    ns = undefined
    force = true
  }
  if (isDef(vnode.children)) {
    for (let i = 0, l = vnode.children.length; i < l; i++) {
      const child = vnode.children[i]
      if (isDef(child.tag) && (isUndef(child.ns) || isTrue(force))) {
        applyNS(child, ns, force)
      }
    }
  }
}

4.Patch原理

patch函數的定義在src/core/vdom/patch.js中，patch邏輯比較簡單，就不粘代碼了

patch函數接收6個參數：

  • oldVnode: 舊的虛擬節點或舊的真實dom節點
  • vnode: 新的虛擬節點
  • hydrating: 是否要跟真是dom混合
  • removeOnly: 特殊flag，用於
  • parentElm: 父節點
  • refElm: 新節點將插入到refElm之前

patch的邏輯是：

  1. if vnode不存在但是oldVnode存在，說明意圖是要銷毀老節點，那麼就調用invokeDestroyHook(oldVnode)來進行銷
  2. if oldVnode不存在但是vnode存在，說明意圖是要創建新節點，那麼就調用createElm來創建新節點

  3. else 當vnode和oldVnode都存在時

    • if oldVnode和vnode是同一個節點，就調用patchVnode來進行patch
    • 當vnode和oldVnode不是同一個節點時，如果oldVnode是真實dom節點或hydrating設置為true，需要用hydrate函數將虛擬dom和真是dom進行映射，然後將oldVnode設置為對應的虛擬dom，找到oldVnode.elm的父節點，根據vnode創建一個真實dom節點並插入到該父節點中oldVnode.elm的位置

patchVnode的邏輯是：

  1. 如果oldVnode跟vnode完全一致，那麼不需要做任何事情
  2. 如果oldVnode跟vnode都是靜態節點，且具有相同的key，當vnode是克隆節點或是v-once指令控制的節點時，只需要把oldVnode.elm和oldVnode.child都複製到vnode上，也不用再有其他操作

  3. 否則，如果vnode不是文本節點或註釋節點

    • 如果oldVnode和vnode都有子節點，且2方的子節點不完全一致，就執行updateChildren
    • 如果只有oldVnode有子節點，那就把這些節點都刪除
    • 如果只有vnode有子節點，那就創建這些子節點
    • 如果oldVnode和vnode都沒有子節點，但是oldVnode是文本節點或註釋節點，就把vnode.elm的文本設置為空字元串

  4. 如果vnode是文本節點或註釋節點，但是vnode.text != oldVnode.text時，只需要更新vnode.elm的文本內容就可以

代碼如下：

  function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
    // 如果新舊節點一致，什麼都不做
    if (oldVnode === vnode) {
      return
    }

    // 讓vnode.el引用到現在的真實dom，當el修改時，vnode.el會同步變化
    const elm = vnode.elm = oldVnode.elm

    // 非同步占位符
    if (isTrue(oldVnode.isAsyncPlaceholder)) {
      if (isDef(vnode.asyncFactory.resolved)) {
        hydrate(oldVnode.elm, vnode, insertedVnodeQueue)
      } else {
        vnode.isAsyncPlaceholder = true
      }
      return
    }

    // reuse element for static trees.
    // note we only do this if the vnode is cloned -
    // if the new node is not cloned it means the render functions have been
    // reset by the hot-reload-api and we need to do a proper re-render.
    // 如果新舊都是靜態節點，並且具有相同的key
    // 當vnode是克隆節點或是v-once指令控制的節點時，只需要把oldVnode.elm和oldVnode.child都複製到vnode上
    // 也不用再有其他操作
    if (isTrue(vnode.isStatic) &&
      isTrue(oldVnode.isStatic) &&
      vnode.key === oldVnode.key &&
      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
    ) {
      vnode.componentInstance = oldVnode.componentInstance
      return
    }

    let i
    const data = vnode.data
    if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
      i(oldVnode, vnode)
    }

    const oldCh = oldVnode.children
    const ch = vnode.children
    if (isDef(data) && isPatchable(vnode)) {
      for (i = 0; i < cbs.update.length; ++i) cbs.update[i](oldVnode, vnode)
      if (isDef(i = data.hook) && isDef(i = i.update)) i(oldVnode, vnode)
    }
    // 如果vnode不是文本節點或者註釋節點
    if (isUndef(vnode.text)) {
      // 並且都有子節點
      if (isDef(oldCh) && isDef(ch)) {
        // 並且子節點不完全一致，則調用updateChildren
        if (oldCh !== ch) updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly)

        // 如果只有新的vnode有子節點
      } else if (isDef(ch)) {
        if (isDef(oldVnode.text)) nodeOps.setTextContent(elm, '')
        // elm已經引用了老的dom節點，在老的dom節點上添加子節點
        addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue)

        // 如果新vnode沒有子節點，而vnode有子節點，直接刪除老的oldCh
      } else if (isDef(oldCh)) {
        removeVnodes(elm, oldCh, 0, oldCh.length - 1)

        // 如果老節點是文本節點
      } else if (isDef(oldVnode.text)) {
        nodeOps.setTextContent(elm, '')
      }

      // 如果新vnode和老vnode是文本節點或註釋節點
      // 但是vnode.text != oldVnode.text時，只需要更新vnode.elm的文本內容就可以
    } else if (oldVnode.text !== vnode.text) {
      nodeOps.setTextContent(elm, vnode.text)
    }
    if (isDef(data)) {
      if (isDef(i = data.hook) && isDef(i = i.postpatch)) i(oldVnode, vnode)
    }
  }

5.updataChildren原理

updateChildren的邏輯是：

  1. 分別獲取oldVnode和vnode的firstChild、lastChild，賦值給oldStartVnode、oldEndVnode、newStartVnode、newEndVnode
  2. 如果oldStartVnode和newStartVnode是同一節點，調用patchVnode進行patch，然後將oldStartVnode和newStartVnode都設置為下一個子節點，重覆上述流程
  3. 如果oldEndVnode和newEndVnode是同一節點，調用patchVnode進行patch，然後將oldEndVnode和newEndVnode都設置為上一個子節點，重覆上述流程
  4. 如果oldStartVnode和newEndVnode是同一節點，調用patchVnode進行patch，如果removeOnly是false，那麼可以把oldStartVnode.elm移動到oldEndVnode.elm之後，然後把oldStartVnode設置為下一個節點，newEndVnode設置為上一個節點，重覆上述流程
  5. 如果newStartVnode和oldEndVnode是同一節點，調用patchVnode進行patch，如果removeOnly是false，那麼可以把oldEndVnode.elm移動到oldStartVnode.elm之前，然後把newStartVnode設置為下一個節點，oldEndVnode設置為上一個節點，重覆上述流程
  6. 如果以上都不匹配，就嘗試在oldChildren中尋找跟newStartVnode具有相同key的節點，如果找不到相同key的節點，說明newStartVnode是一個新節點，就創建一個，然後把newStartVnode設置為下一個節點
  7. 如果上一步找到了跟newStartVnode相同key的節點，那麼通過其他屬性的比較來判斷這2個節點是否是同一個節點，如果是，就調用patchVnode進行patch，如果removeOnly是false，就把newStartVnode.elm插入到oldStartVnode.elm之前，把newStartVnode設置為下一個節點，重覆上述流程
  8. 如果在oldChildren中沒有尋找到newStartVnode的同一節點，那就創建一個新節點，把newStartVnode設置為下一個節點，重覆上述流程
  9. 如果oldStartVnode跟oldEndVnode重合了，並且newStartVnode跟newEndVnode也重合了，這個迴圈就結束了

具體代碼如下：

  function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
    let oldStartIdx = 0 // 舊頭索引
    let newStartIdx = 0 // 新頭索引
    let oldEndIdx = oldCh.length - 1 // 舊尾索引
    let newEndIdx = newCh.length - 1 // 新尾索引
    let oldStartVnode = oldCh[0] // oldVnode的第一個child
    let oldEndVnode = oldCh[oldEndIdx] // oldVnode的最後一個child
    let newStartVnode = newCh[0] // newVnode的第一個child
    let newEndVnode = newCh[newEndIdx] // newVnode的最後一個child
    let oldKeyToIdx, idxInOld, vnodeToMove, refElm

    // removeOnly is a special flag used only by <transition-group>
    // to ensure removed elements stay in correct relative positions
    // during leaving transitions
    const canMove = !removeOnly

    // 如果oldStartVnode和oldEndVnode重合，並且新的也都重合了，證明diff完了，迴圈結束
    while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
      // 如果oldVnode的第一個child不存在
      if (isUndef(oldStartVnode)) {
        // oldStart索引右移
        oldStartVnode = oldCh[++oldStartIdx] // Vnode has been moved left

      // 如果oldVnode的最後一個child不存在
      } else if (isUndef(oldEndVnode)) {
        // oldEnd索引左移
        oldEndVnode = oldCh[--oldEndIdx]

      // oldStartVnode和newStartVnode是同一個節點
      } else if (sameVnode(oldStartVnode, newStartVnode)) {
        // patch oldStartVnode和newStartVnode， 索引左移，繼續迴圈
        patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue)
        oldStartVnode = oldCh[++oldStartIdx]
        newStartVnode = newCh[++newStartIdx]

      // oldEndVnode和newEndVnode是同一個節點
      } else if (sameVnode(oldEndVnode, newEndVnode)) {
        // patch oldEndVnode和newEndVnode，索引右移，繼續迴圈
        patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue)
        oldEndVnode = oldCh[--oldEndIdx]
        newEndVnode = newCh[--newEndIdx]

      // oldStartVnode和newEndVnode是同一個節點
      } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
        // patch oldStartVnode和newEndVnode
        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue)
        // 如果removeOnly是false，則將oldStartVnode.eml移動到oldEndVnode.elm之後
        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm))
        // oldStart索引右移，newEnd索引左移
        oldStartVnode = oldCh[++oldStartIdx]
        newEndVnode = newCh[--newEndIdx]

      // 如果oldEndVnode和newStartVnode是同一個節點
      } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
        // patch oldEndVnode和newStartVnode
        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue)
        // 如果removeOnly是false，則將oldEndVnode.elm移動到oldStartVnode.elm之前
        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm)
        // oldEnd索引左移，newStart索引右移
        oldEndVnode = oldCh[--oldEndIdx]
        newStartVnode = newCh[++newStartIdx]

      // 如果都不匹配
      } else {
        if (isUndef(oldKeyToIdx)) oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)

        // 嘗試在oldChildren中尋找和newStartVnode的具有相同的key的Vnode
        idxInOld = isDef(newStartVnode.key)
          ? oldKeyToIdx[newStartVnode.key]
          : findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx)

        // 如果未找到，說明newStartVnode是一個新的節點
        if (isUndef(idxInOld)) { // New element
          // 創建一個新Vnode
          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)

        // 如果找到了和newStartVnodej具有相同的key的Vnode，叫vnodeToMove
        } else {
          vnodeToMove = oldCh[idxInOld]
          /* istanbul ignore if */
          if (process.env.NODE_ENV !== 'production' && !vnodeToMove) {
            warn(
              'It seems there are duplicate keys that is causing an update error. ' +
              'Make sure each v-for item has a unique key.'
            )
          }

          // 比較兩個具有相同的key的新節點是否是同一個節點
          //不設key，newCh和oldCh只會進行頭尾兩端的相互比較，設key後，除了頭尾兩端的比較外，還會從用key生成的對象oldKeyToIdx中查找匹配的節點，所以為節點設置key可以更高效的利用dom。
          if (sameVnode(vnodeToMove, newStartVnode)) {
            // patch vnodeToMove和newStartVnode
            patchVnode(vnodeToMove, newStartVnode, insertedVnodeQueue)
            // 清除
            oldCh[idxInOld] = undefined
            // 如果removeOnly是false，則將找到的和newStartVnodej具有相同的key的Vnode，叫vnodeToMove.elm
            // 移動到oldStartVnode.elm之前
            canMove && nodeOps.insertBefore(parentElm, vnodeToMove.elm, oldStartVnode.elm)

          // 如果key相同，但是節點不相同，則創建一個新的節點
          } else {
            // same key but different element. treat as new element
            createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm)
          }
        }

        // 右移
        newStartVnode = newCh[++newStartIdx]
      }
    }

6.具體的Diff分析

不設key，newCh和oldCh只會進行頭尾兩端的相互比較，設key後，除了頭尾兩端的比較外，還會從用key生成的對象oldKeyToIdx中查找匹配的節點，所以為節點設置key可以更高效的利用dom。

diff的遍歷過程中，只要是對dom進行的操作都調用api.insertBefore，api.insertBefore只是原生insertBefore的簡單封裝。
比較分為兩種，一種是有vnode.key的，一種是沒有的。但這兩種比較對真實dom的操作是一致的。

對於與sameVnode(oldStartVnode, newStartVnode)和sameVnode(oldEndVnode,newEndVnode)為true的情況，不需要對dom進行移動。

總結遍歷過程，有3種dom操作：上述圖中都有

  1. 當oldStartVnode，newEndVnode值得比較，說明oldStartVnode.el跑到oldEndVnode.el的後邊了。
  2. 當oldEndVnode，newStartVnode值得比較，oldEndVnode.el跑到了oldStartVnode.el的前邊，準確的說應該是oldEndVnode.el需要移動到oldStartVnode.el的前邊”。
  3. newCh中的節點oldCh里沒有， 將新節點插入到oldStartVnode.el的前邊

在結束時，分為兩種情況：

  1. oldStartIdx > oldEndIdx，可以認為oldCh先遍歷完。當然也有可能newCh此時也正好完成了遍歷，統一都歸為此類。此時newStartIdx和newEndIdx之間的vnode是新增的，調用addVnodes，把他們全部插進before的後邊，before很多時候是為null的。addVnodes調用的是insertBefore操作dom節點，我們看看insertBefore的文檔：parentElement.insertBefore(newElement, referenceElement)
    如果referenceElement為null則newElement將被插入到子節點的末尾。如果newElement已經在DOM樹中，newElement首先會從DOM樹中移除。所以before為null，newElement將被插入到子節點的末尾。
  2. newStartIdx > newEndIdx，可以認為newCh先遍歷完。此時oldStartIdx和oldEndIdx之間的vnode在新的子節點里已經不存在了，調用removeVnodes將它們從dom里刪除

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

-Advertisement-
Play Games
更多相關文章
  • vue初步學習，零散記錄
    針對vue中控制項的用法 首先 初步用法 }) 子組件調用父組件的方法 和父組件傳值入子組件 子組件： 父組件 ： 動態切換不同的組件 在掛載點使用component標簽，然後使用v-bind:is=”組件名”，會自動去找匹配的組件名，如果沒有，則不顯示； 改變掛載的組件，只需要修改is指令的值即可 ...
  • 輕鬆學習 JavaScript——第 6 部分：JavaScript 箭頭函數
    JavaScript箭頭函數是ECMAScript 6中引入的編寫函數表達式的一種簡便方法。通常，在JavaScript中，可以通過兩種方式創建函數： 函數語句。 函數表達式。 可以如下所示創建函數語句： 也可以創建相同功能的函數表達式，如下所示： ECMA 2015（或ECMA Script 6） ...
  • ajax的使用
    jquery中的ajax方法參數總是記不住，這裡記錄一下。 1.url: 要求為String類型的參數，（預設為當前頁地址）發送請求的地址。 2.type: 要求為String類型的參數，請求方式（post或get）預設為get。註意其他http請求方法，例如put和delete也可以使用，但僅部分 ...
  • JavaScript的setter與getter方法
    作者： 以前在寫項目過程一直都沒有使用過Javascript的setter與getter方法，所以對其是一種要懂不懂的概念；今天看書看到這個知識點，還是模模糊糊的，於是就打算研究研究； Javascript對象的屬性是由名字，值和一組特性構成的。那麼首先，來瞭解一下對象的兩種屬性： + 數據屬性，我 ...
  • vue自定義全局組件並通過全局方法 Vue.use() 使用該組件
    簡介 Vue.use( plugin )：安裝 Vue.js 插件。如果插件是一個對象，必須提供 install 方法。如果插件是一個函數，它會被作為 install 方法。install 方法將被作為 Vue 的參數調用。 當 install 方法被同一個插件多次調用，插件將只會被安裝一次。 Vu ...
  • 基於vue-cli的改造的多頁面開發腳手架
    項目的GitHub地址：https://github.com/hellobajie/vue-cli-multipage 該腳手架同時支持vux，scss，less 目錄結構 修改配置文件 構建多頁面應用的關鍵在於向配置對象的plugins子項添加多個HtmlWebpackPlugin。 怎樣根據頁面 ...
  • jquery animate動畫持續運動
    如上，想要實現左右持續運動，則把該動畫封裝為一個函數，再反覆調用就好。 ...
  • 基於socket.io打造hybrid調試頁面
    前言 參考的 "釘釘調試頁面" 實現，僅供學習！ 功能為： __PC端編寫代碼，手機端執行__ 解決的痛點是： __避免了調試 應用時重覆寫各種測試頁面__ 源碼與示例 __源碼__ "https://github.com/dailc/node server examples/tree/master ...
一周排行
    -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.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類