国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

細(xì)談 vue - slot 篇

kaka / 2789人閱讀

摘要：結(jié)合我們的例子，子組件則會生成以下代碼到目前為止，對于普通插槽和作用域插槽已經(jīng)談的差不多了。下面我們將仔細(xì)談?wù)勥@塊的內(nèi)容。在看具體實(shí)現(xiàn)邏輯前，我們先通過一個例子來先了解下其基本用法然后進(jìn)行使用頁面展示效果如下看著好。

本篇文章是細(xì)談 vue 系列第二篇了，上篇我們已經(jīng)細(xì)談了 vue 的核心之一 vdom，傳送門

今天我們將分析我們經(jīng)常使用的 vue 功能 slot 是如何設(shè)計(jì)和實(shí)現(xiàn)的，本文將圍繞 普通插槽 和 作用域插槽 以及 vue 2.6.x 版本的 v-slot 展開對該話題的討論。當(dāng)然還不懂用法的同學(xué)建議官網(wǎng)先看看相關(guān) API 先。接下來，我們直接進(jìn)入正文吧

一、普通插槽

首先我們看一個我們對于 slot 最常用的例子

<template>
  <div class="slot-demo">
    <slot>this is slot default content text.slot>
  div>
template>

然后我們直接使用，頁面則正常顯示一下內(nèi)容

然后，這個時(shí)候我們使用的時(shí)候，對 slot 內(nèi)容進(jìn)行覆蓋

<slot-demo>this is slot custom content.slot-demo>

內(nèi)容則變成下圖所示

對于此，大家可能都能清楚的知道會是這種情況。今天我就將帶領(lǐng)大家直接看看 vue 底層對 slot 插槽的具體實(shí)現(xiàn)。

1、vm.$slots

我們開始前，先看看 vue 的 Component 接口上對 $slots 屬性的定義

$slots: { [key: string]: Array };

多的咱不說，咱直接 console 一下上面例子中的 $slots

剩下的篇幅將講解 slot 內(nèi)容如何進(jìn)行渲染以及如何轉(zhuǎn)換成上圖內(nèi)容

2、renderSlot

看完了具體實(shí)例中 slot 渲染后的 vm.$slots 對象，這一小篇我們直接看看 renderSlot 這塊的邏輯，首先我們先看看 renderSlot 函數(shù)的幾個參數(shù)都有哪些

renderSlot()

export function renderSlot (
  name: string, // 插槽名 slotName
  fallback: ");// 插槽默認(rèn)內(nèi)容生成的 vnode 數(shù)組
  props: ");// props 對象
  bindObject: ");// v-bind 綁定對象
): ");Array<VNode> {}

這里我們先不看 scoped-slot 的邏輯，我們只看普通 slot 的邏輯。

const slotNodes = this.$slots[name]
nodes = slotNodes || fallback
return nodes

這里直接先取值 this.$slots[name] ，若存在則直接返回其對其的 vnode 數(shù)組，否則返回 fallback。看到這，很多人可能不知道 this.$slots 在哪定義的。解釋這個之前我們直接往后看另外一個方法

renderslots()

export function resolveSlots (
  children: ");// 父節(jié)點(diǎn)的 children
  context: ");// 父節(jié)點(diǎn)的上下文，即父組件的 vm 實(shí)例
): { [key: string]: Array } {}

看完 resolveSlots 的參數(shù)后我們接著往后過其中具體的邏輯。如果 children 參數(shù)不存在，直接返回一個空對象

const slots = {}
if (!children) {
  return slots
}

如果存在，則直接對 children 進(jìn)行遍歷操作

for (let i = 0, l = children.length; i < l; i++) {
  const child = children[i]
  const data = child.data
  // 如果 data.slot 存在，將插槽名稱當(dāng)做 key，child 當(dāng)做值直接添加到 slots 中去
  if ((child.context === context || child.fnContext === context) &&
    data && data.slot != null
  ) {
    const name = data.slot
    const slot = (slots[name] || (slots[name] = []))
    // child 的 tag 為 template 標(biāo)簽的情況
    if (child.tag === "template") {
      slot.push.apply(slot, child.children || [])
    } else {
      slot.push(child)
    }
  // 如果 data.slot 不存在，則直接將 child 丟到 slots.default 中去
  } else {
    (slots.default || (slots.default = [])).push(child)
  }
}

slots 獲取到值后，則進(jìn)行一些過濾操作，然后直接返回有用的 slots

// ignore slots that contains only whitespace
for (const name in slots) {
  if (slots[name].every(isWhitespace)) {
    delete slots[name]
  }
}
return slots

// isWhitespace 相關(guān)邏輯
function isWhitespace (node: VNode): boolean {
  return (node.isComment && !node.asyncFactory) || node.text === " "
}

數(shù)組 every() 方法傳送門 - Array.prototype.every()

initRender()

我們從上面已經(jīng)知道了 vue 對 slots 是如何進(jìn)行賦值保存數(shù)據(jù)的。而在 src/core/instance/render.js 的 initRender 方法中則是對 vm.$slots 進(jìn)行了初始化的賦值。

const options = vm.$options
const parentVnode = vm.$vnode = options._parentVnode // the placeholder node in parent tree
const renderContext = parentVnode && parentVnode.context
vm.$slots = resolveSlots(options._renderChildren, renderContext)

genSlot()

了解了是 vm.$slots 這塊邏輯后，肯定有人會問：你這不就只是拿到了一個對象么，怎么把其中的內(nèi)容給搞出來呢？別急，我們接著就來講一下對于 slot 這塊 vue 是如何進(jìn)行編譯的。這里咱就把 slot generate 相關(guān)邏輯過上一過，話不多說，咱直接上代碼

function genSlot (el: ASTElement, state: CodegenState): string {
  const slotName = el.slotName || ""default"" // 取 slotName，若無，則直接命名為 "default"
  const children = genChildren(el, state) // 對 children 進(jìn)行 generate 操作
  let res = `_t(${slotName}${children ");`,${children}` : ""}`
  const attrs = el.attrs && `{${el.attrs.map(a => `${camelize(a.name)}:${a.value}`).join(",")}}` // 將 attrs 轉(zhuǎn)換成對象形式
  const bind = el.attrsMap["v-bind"] // 獲取 slot 上的 v-bind 屬性
  // 若 attrs 或者 bind 屬性存在但是 children 卻木得，直接賦值第二參數(shù)為 null
  if ((attrs || bind) && !children) {
    res += `,null`
  }
  // 若 attrs 存在，則將 attrs 作為 `_t()` 的第三個參數(shù)(普通插槽的邏輯處理)
  if (attrs) {
    res += `,${attrs}`
  }
  // 若 bind 存在，這時(shí)如果 attrs 存在，則 bind 作為第三個參數(shù)，否則 bind 作為第四個參數(shù)(scoped-slot 的邏輯處理)
  if (bind) {
    res += `${attrs ");"" : ",null"},${bind}`
  }
  return res + ")"
}

注：上面的 slotName 在 src/compiler/parser/index.js 的 processSlot() 函數(shù)中進(jìn)行了賦值，并且 父組件編譯階段用到的 slotTarget 也在這里進(jìn)行了處理

function processSlot (el) {
  if (el.tag === "slot") {
    // 直接獲取 attr 里面 name 的值
    el.slotName = getBindingAttr(el, "name")
    // ...
  }
  // ...
  const slotTarget = getBindingAttr(el, "slot")
  if (slotTarget) {
    // 如果 slotTarget 存在則直接取命名插槽的 slot 值，否則直接為 "default"
    el.slotTarget = slotTarget === """" ");""default"" : slotTarget
    if (el.tag !== "template" && !el.slotScope) {
      addAttr(el, "slot", slotTarget)
    }
  }
}

隨即在 genData() 中使用 slotTarget 進(jìn)行 data 的數(shù)據(jù)拼接

if (el.slotTarget && !el.slotScope) {
  data += `slot:${el.slotTarget},`
}

此時(shí)父組件將生成以下代碼

with(this) {
  return _c("div", [
    _c("slot-demo"),
    {
      attrs: { slot: "default" },
      slot: "default"
    },
    [ _v("this is slot custom content.") ]
  ])
}

然后當(dāng) el.tag 為 slot 的情況，則直接執(zhí)行 genSlot()

else if (el.tag === "slot") {
  return genSlot(el, state)
}

按照我們舉出的例子，則子組件最終會生成以下代碼

with(this) {
  // _c => createElement ; _t => renderSlot ; _v => createTextVNode
  return _c(
    "div",
    {
      staticClass: "slot-demo"
    },
    [ _t("default", [ _v("this is slot default content text.") ]) ]
  )
}
二、作用域插槽

上面我們已經(jīng)了解到 vue 對于普通的 slot 標(biāo)簽是如何進(jìn)行處理和轉(zhuǎn)換的。接下來我們來分析下作用域插槽的實(shí)現(xiàn)邏輯。

1、vm.$scopedSlots

了解之前還是老規(guī)矩，先看看 vue 的 Component 接口上對 $scopedSlots 屬性的定義

$scopedSlots: { [key: string]: () => VNodeChildren };

其中的 VNodeChildren 定義如下：

declare type VNodeChildren = Array<");

先來個相關(guān)的例子

<template>
  <div class="slot-demo">
    <slot text="this is a slot demo , " :msg="msg">slot>
  div>
template>

<script>
export default {
  name: "SlotDemo",
  data () {
    return {
      msg: "this is scoped slot content."
    }
  }
}
script>

然后進(jìn)行使用

<template>
  <div class="parent-slot">
    <slot-demo>
      <template slot-scope="scope">
        <p>{{ scope.text }}p>
        <p>{{ scope.msg }}p>
      template>
    slot-demo>
  div>
template>

效果如下

從使用層面我們能看出來，子組件的 slot 標(biāo)簽上綁定了一個 text 以及 :msg 屬性。然后父組件在使用插槽使用了 slot-scope 屬性去讀取插槽帶的屬性對應(yīng)的值

注：提及一下 processSlot() 對于 slot-scope 的處理邏輯

let slotScope
if (el.tag === "template") {
  slotScope = getAndRemoveAttr(el, "scope")
  // 兼容 2.5 以前版本 slot scope 的用法(這塊有個警告，我直接忽略掉了)
  el.slotScope = slotScope || getAndRemoveAttr(el, "slot-scope")
} else if ((slotScope = getAndRemoveAttr(el, "slot-scope"))) {
  el.slotScope = slotScope
}

從上面的代碼我們能看出，vue 對于這塊直接讀取 slot-scope 屬性并賦值給 AST 抽象語法樹的 slotScope 屬性上。而擁有 slotScope 屬性的節(jié)點(diǎn)，會直接以 **插槽名稱 name 為 key、本身為 value **的對象形式掛載在父節(jié)點(diǎn)的 scopedSlots 屬性上

else if (element.slotScope) { 
  currentParent.plain = false
  const name = element.slotTarget || ""default""
  ;(currentParent.scopedSlots || (currentParent.scopedSlots = {}))[name] = element
}

然后在 src/core/instance/render.js 的 renderMixin 方法中對 vm.$scopedSlots 則是進(jìn)行了如下賦值：

if (_parentVnode) {
  vm.$scopedSlots = _parentVnode.data.scopedSlots || emptyObject
}

然后 genData() 里會進(jìn)行以下邏輯處理

if (el.scopedSlots) {
  data += `${genScopedSlots(el, el.scopedSlots, state)},`
}

緊接著我們來看看 genScopedSlots 中的邏輯

function genScopedSlots (
  slots: { [key: string]: ASTElement },
  state: CodegenState
): string {
  // 對 el.scopedSlots 對象進(jìn)行遍歷，執(zhí)行 genScopedSlot，且將結(jié)果用逗號進(jìn)行拼接
  // _u => resolveScopedSlots (具體邏輯下面一個小節(jié)進(jìn)行分析)
  return `scopedSlots:_u([${
    Object.keys(slots).map(key => {
      return genScopedSlot(key, slots[key], state)
    }).join(",")
  }])`
}

然后我們再來看看 genScopedSlot 是如何生成 render function 字符串的

function genScopedSlot (
  key: string,
  el: ASTElement,
  state: CodegenState
): string {
  if (el.for && !el.forProcessed) {
    return genForScopedSlot(key, el, state)
  }
  // 函數(shù)參數(shù)為標(biāo)簽上 slot-scope 屬性對應(yīng)的值 (getAndRemoveAttr(el, "slot-scope"))
  const fn = `function(${String(el.slotScope)}){` +
    `return ${el.tag === "template"
      ");if
        ");`${el.if}");${genChildren(el, state) || "undefined"}:undefined`
        : genChildren(el, state) || "undefined"
      : genElement(el, state)
    }}`
  // key 為插槽名稱，fn 為生成的函數(shù)代碼
  return `{key:${key},fn:${fn}}`
}

我們把上面例子的 $scopedSlots 打印一下，結(jié)果如下

然后上面例子中父組件最終會生成如下代碼

with(this){
  // _c => createElement ; _u => resolveScopedSlots
  // _v => createTextVNode ; _s => toString
  return _c("div",
    { staticClass: "parent-slot" },
    [_c("slot-demo",
      { scopedSlots: _u([
        {
          key: "default",
          fn: function(scope) {
            return [
              _c("p", [ _v(_s(scope.text)) ]),
              _c("p", [ _v(_s(scope.msg)) ])
            ]
          }
        }])
      }
    )]
  )
}
2、renderSlot(slot-scope)

renderSlot()

上面我們提及對于插槽 render 邏輯的時(shí)候忽略了 slot-scope 的相關(guān)邏輯，這里我們來看看這部分內(nèi)容

export function renderSlot (
  name: string,
  fallback: ");): ");Array<VNode> {
  const scopedSlotFn = this.$scopedSlots[name]
  let nodes
  if (scopedSlotFn) { // scoped slot
    props = props || {}
    // ...
    nodes = scopedSlotFn(props) || fallback
  }
	// ...
	return nodes
}

resolveScopedSlots()

這里我們看看 renderHelps 里面的 _u ，即 resolveScopedSlots，其邏輯如下

export function resolveScopedSlots (
  fns: ScopedSlotsData, // Array<{ key: string, fn: Function } | ScopedSlotsData>
  res");): { [key: string]: Function } {
  res = res || {}
  // 遍歷 fns 數(shù)組，生成一個 `key 為插槽名稱，value 為函數(shù)` 的對象
  for (let i = 0; i < fns.length; i++) {
    if (Array.isArray(fns[i])) {
      resolveScopedSlots(fns[i], res)
    } else {
      res[fns[i].key] = fns[i].fn
    }
  }
  return res
}

genSlot

這塊會對 attrs 和 v-bind 進(jìn)行，對于這塊內(nèi)容上面我已經(jīng)提過了，要看請往上翻閱。結(jié)合我們的例子，子組件則會生成以下代碼

with(this) {
  return _c(
    "div",
    {
      staticClass: "slot-demo"
    },
    [
      _t("default", null, { text: "this is a slot demo , ", msg: msg })
    ]
  )
}

到目前為止，對于普通插槽和作用域插槽已經(jīng)談的差不多了。接下來，我們將一起看看 vue 2.6.x 版本的 v-slot

三、v-slot 1、基本用法

vue 2.6.x 已經(jīng)出來有一段時(shí)間了，其中對于插槽這塊則是放棄了 slot-scope 作用域插槽推薦寫法，直接改成了 v-slot 指令形式的推薦寫法(當(dāng)然這只是個語法糖而已)。下面我們將仔細(xì)談?wù)?v-slot 這塊的內(nèi)容。

在看具體實(shí)現(xiàn)邏輯前，我們先通過一個例子來先了解下其基本用法

<template>
  <div class="slot-demo">
    <slot name="demo">this is demo slot.slot>
    <slot text="this is a slot demo , " :msg="msg">slot>
  div>
template>

<script>
export default {
  name: "SlotDemo",
  data () {
    return {
      msg: "this is scoped slot content."
    }
  }
}
script>

然后進(jìn)行使用

<template>
  <slot-demo>
    <template v-slot:demo>this is custom slot.template>
    <template v-slot="scope">
      <p>{{ scope.text }}{{ scope.msg }}p>
    template>
  slot-demo>
template>

頁面展示效果如下

看著好 easy 。

2、相同與區(qū)別

接下來，咱來會會這個新特性

round 1. $slots & $scopedSlots

$slots 這塊邏輯沒變，還是沿用的以前的代碼

// $slots
const options = vm.$options
const parentVnode = vm.$vnode = options._parentVnode
const renderContext = parentVnode && parentVnode.context
vm.$slots = resolveSlots(options._renderChildren, renderContext)

$scopedSlots 這塊則進(jìn)行了改造，執(zhí)行了 normalizeScopedSlots() 并接收其返回值為 $scopedSlots 的值

if (_parentVnode) {
  vm.$scopedSlots = normalizeScopedSlots(
    _parentVnode.data.scopedSlots,
    vm.$slots,
    vm.$scopedSlots
  )
}

接著，我們來會一會 normalizeScopedSlots ，首先我們先看看它的幾個參數(shù)

export function normalizeScopedSlots (
  slots: { [key: string]: Function } | void,  // 某節(jié)點(diǎn) data 屬性上 scopedSlots
  normalSlots: { [key: string]: Array }, // 當(dāng)前節(jié)點(diǎn)下的普通插槽
  prevSlots");// 當(dāng)前節(jié)點(diǎn)下的特殊插槽
): any {}

首先，如果 slots 參數(shù)不存在，則直接返回一個空對象 {}

if (!slots) {
  res = {}
}

若 prevSlots 存在，且滿足系列條件的情況，則直接返回 prevSlots

const hasNormalSlots = Object.keys(normalSlots).length > 0 // 是否擁有普通插槽
const isStable = slots ");// slots 上的 $stable 值
const key = slots && slots.$key // slots 上的 $key 值
else if (
  isStable &&
  prevSlots &&
  prevSlots !== emptyObject &&
  key === prevSlots.$key && // slots $key 值與 prevSlots $key 相等
  !hasNormalSlots && // slots 中沒有普通插槽
  !prevSlots.$hasNormal // prevSlots 中沒有普通插槽
) {
  return prevSlots
}

注：這里的 $key , $hasNormal , $stable 是直接使用 vue 內(nèi)部對 Object.defineProperty 封裝好的 def() 方法進(jìn)行賦值的

def(res, "$stable", isStable)
def(res, "$key", key)
def(res, "$hasNormal", hasNormalSlots)

否則，則對 slots 對象進(jìn)行遍歷，操作 normalSlots ，賦值給 key 為 key，value 為 normalizeScopedSlot 返回的函數(shù) 的對象 res

let res
else {
  res = {}
  for (const key in slots) {
    if (slots[key] && key[0] !== "$") {
      res[key] = normalizeScopedSlot(normalSlots, key, slots[key])
    }
  }
}

隨后再次對 normalSlots 進(jìn)行遍歷，若 normalSlots 中的 key 在 res 找不到對應(yīng)的 key，則直接進(jìn)行 proxyNormalSlot 代理操作，將 normalSlots 中的 slot 掛載到 res 對象上

for (const key in normalSlots) {
  if (!(key in res)) {
    res[key] = proxyNormalSlot(normalSlots, key)
  }
}

function proxyNormalSlot(slots, key) {
  return () => slots[key]
}

接著，我們看看 normalizeScopedSlot() 都做了些什么事情。該方法接收三個參數(shù)，第一個參數(shù)為 normalSlots，第二個參數(shù)為 key，第三個參數(shù)為 fn

function normalizeScopedSlot(normalSlots, key, fn) {
  const normalized = function () {
    // 若參數(shù)為多個，則直接使用 arguments 作為 fn 的參數(shù)，否則直接傳空對象作為 fn 的參數(shù)
    let res = arguments.length ");null, arguments) : fn({})
    // fn 執(zhí)行返回的 res 不是數(shù)組，則是單 vnode 的情況，賦值為 [res] 即可
    // 否則執(zhí)行 normalizeChildren 操作，這塊主要對針對 slot 中存在 v-for 操作
    res = res && typeof res === "object" && !Array.isArray(res)
      ");// single vnode
      : normalizeChildren(res)
    return res && (
      res.length === 0 ||
      (res.length === 1 && res[0].isComment) // slot 上 v-if 相關(guān)處理
    ) ");undefined
      : res
  }
  // v-slot 語法糖處理
  if (fn.proxy) {
    Object.defineProperty(normalSlots, key, {
      get: normalized,
      enumerable: true,
      configurable: true
    })
  }
  return normalized
}

round 2. renderSlot

這塊邏輯處理其實(shí)和之前是一樣的，只是刪除了一些警告的代碼而已。這點(diǎn)這里就不展開敘述了

round 3. processSlot

首先，這里解析 slot 的方法名從 processSlot 變成了 processSlotContent，但其實(shí)前面的邏輯和以前是一樣的。只是新增了一些對于 v-slot 的邏輯處理，下面我們就來捋捋這塊。過具體邏輯前，我們先看一些相關(guān)的正則和方法

1、相關(guān)正則 & functions

dynamicArgRE 動態(tài)參數(shù)匹配

const dynamicArgRE = /^[.*]$/ // 匹配到 "[]" 則為 true，如 "[ item ]"

slotRE 匹配 v-slot 語法相關(guān)正則

const slotRE = /^v-slot(:|$)|^#/ // 匹配到 "v-slot" 或 "v-slot:" 則為 true

getAndRemoveAttrByRegex 通過正則匹配綁定的 attr 值

export function getAndRemoveAttrByRegex (
  el: ASTElement,
  name: RegExp // 
) {
  const list = el.attrsList // attrsList 類型為 Array
  // 對 attrsList 進(jìn)行遍歷，若有滿足 RegExp 的則直接返回當(dāng)前對應(yīng)的 attr
  // 若參數(shù) name 傳進(jìn)來的是 slotRE = /^v-slot(:|$)|^#/
  // 那么匹配到 "v-slot" 或者 "v-slot:xxx" 則會返回其對應(yīng)的 attr
  for (let i = 0, l = list.length; i < l; i++) {
    const attr = list[i]
    if (name.test(attr.name)) {
      list.splice(i, 1)
      return attr
    }
  }
}

ASTAttr 接口定義

declare type ASTAttr = {
  name: string;
  value: any;
  dynamic");

createASTElement 創(chuàng)建 ASTElement

export function createASTElement (
  tag: string, // 標(biāo)簽名
  attrs: Array, // attrs 數(shù)組
  parent: ASTElement | void // 父節(jié)點(diǎn)
): ASTElement {
  return {
    type: 1,
    tag,
    attrsList: attrs,
    attrsMap: makeAttrsMap(attrs),
    rawAttrsMap: {},
    parent,
    children: []
  }
}

getSlotName 獲取 slotName

function getSlotName (binding) {
  // "v-slot:item" 匹配獲取到 "item"
  let name = binding.name.replace(slotRE, "")
  if (!name) {
    if (binding.name[0] !== "#") {
      name = "default"
    } else if (process.env.NODE_ENV !== "production") {
      warn(
        `v-slot shorthand syntax requires a slot name.`,
        binding
      )
    }
  }
  // 返回一個 key 包含 name，dynamic 的對象
  // "v-slot:[item]" 匹配然后 replace 后獲取到 name = "[item]"
  // 進(jìn)而進(jìn)行動態(tài)參數(shù)進(jìn)行匹配 dynamicArgRE.test(name) 結(jié)果為 true
  return dynamicArgRE.test(name)
    ");name: name.slice(1, -1), dynamic: true } // 截取變量，如 "[item]" 截取后變成 "item"
    : { name: `"${name}"`, dynamic: false }
}
2、processSlotContent

這里我們先看看 slot 對于 template 是如何處理的

if (el.tag === "template") {
  // 匹配綁定在 template 上的 v-slot 指令，這里會匹配到對應(yīng) v-slot 的 attr(類型為 ASTAttr)
  const slotBinding = getAndRemoveAttrByRegex(el, slotRE)
  // 若 slotBinding 存在，則繼續(xù)進(jìn)行 slotName 的正則匹配
  // 隨即將匹配出來的 name 賦值給 slotTarget，dynamic 賦值給 slotTargetDynamic
  // slotScope 賦值為 slotBinding.value 或者 "_empty_"
  if (slotBinding) {
    const { name, dynamic } = getSlotName(slotBinding)
    el.slotTarget = name
    el.slotTargetDynamic = dynamic
    el.slotScope = slotBinding.value || emptySlotScopeToken
  }
}

如果不是 template，而是綁定在 component 上的話，對于 v-slot 指令和 slotName 的匹配操作是一樣的，不同點(diǎn)在于由于這里需要將組件的 children 添加到其默認(rèn)插槽中去

else {
  // v-slot on component 表示默認(rèn)插槽
  const slotBinding = getAndRemoveAttrByRegex(el, slotRE)
  // 將組件的 children 添加到其默認(rèn)插槽中去
  if (slotBinding) {
    // 獲取當(dāng)前組件的 scopedSlots
    const slots = el.scopedSlots || (el.scopedSlots = {})
    // 匹配拿到 slotBinding 中 name，dynamic 的值
    const { name, dynamic } = getSlotName(slotBinding)
    // 獲取 slots 中 key 對應(yīng)匹配出來 name 的 slot
    // 然后再其下面創(chuàng)建一個標(biāo)簽名為 template 的 ASTElement，attrs 為空數(shù)組，parent 為當(dāng)前節(jié)點(diǎn)
    const slotContainer = slots[name] = createASTElement("template", [], el)
    // 這里 name、dynamic 統(tǒng)一賦值給 slotContainer 的 slotTarget、slotTargetDynamic，而不是 el
    slotContainer.slotTarget = name
    slotContainer.slotTargetDynamic = dynamic
    // 將當(dāng)前節(jié)點(diǎn)的 children 添加到 slotContainer 的 children 屬性中
    slotContainer.children = el.children.filter((c: any) => {
      if (!c.slotScope) {
        c.parent = slotContainer
        return true
      }
    })
    slotContainer.slotScope = slotBinding.value || emptySlotScopeToken
    // 清空當(dāng)前節(jié)點(diǎn)的 children
    el.children = []
    el.plain = false
  }
}

這樣處理后我們就可以直接在父組件上面直接使用 v-slot 指令去獲取 slot 綁定的值。舉個官方例子來表現(xiàn)一下

Default slot with text


<foo>
  <template slot-scope="{ msg }">
    {{ msg }}
  template>
foo>


<foo v-slot="{ msg }">
  {{ msg }}
foo>

Default slot with element


<foo>
  <div slot-scope="{ msg }">
    {{ msg }}
  div>
foo>


<foo v-slot="{ msg }">
  <div>
    {{ msg }}
  div>
foo>

更多例子請點(diǎn)擊 new-slot-syntax 自行查閱

round 4. generate

genSlot() 在這塊邏輯也沒發(fā)生本質(zhì)性的改變，唯一一個改變就是為了支持 v-slot 動態(tài)參數(shù)做了些改變，具體如下

// old
const attrs = el.attrs && `{${el.attrs.map(a => `${camelize(a.name)}:${a.value}`).join(",")}}`

// new
// attrs、dynamicAttrs 進(jìn)行 concat 操作，并執(zhí)行 genProps 將其轉(zhuǎn)換成對應(yīng)的 generate 字符串
const attrs = el.attrs || el.dynamicAttrs
    ");attr => ({
          // slot props are camelized
          name: camelize(attr.name),
          value: attr.value,
          dynamic: attr.dynamic
        }))
    	)
    : null
最后

文章到這，對于 普通插槽、作用域插槽、v-slot 基本用法以及其背后實(shí)現(xiàn)原理的相關(guān)內(nèi)容已經(jīng)是結(jié)束了，還想要深入了解的同學(xué)，可自行查閱 vue 源碼進(jìn)行研究。

老規(guī)矩，文章末尾打上波廣告

前端交流群：731175396

群里不定期進(jìn)行視頻或語音的技術(shù)類分享，歡迎小伙伴吧上車，帥哥美女等著你們呢。

然后，emmm，我要去打籃球了 ~

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://m.specialneedsforspecialkids.com/yun/7236.html

相關(guān)文章

  • 【Vue原理】Compile - 源碼版 之 generate 節(jié)點(diǎn)數(shù)據(jù)拼接

    摘要：寫文章不容易，點(diǎn)個贊唄兄弟專注源碼分享，文章分為白話版和源碼版，白話版助于理解工作原理，源碼版助于了解內(nèi)部詳情，讓我們一起學(xué)習(xí)吧研究基于版本如果你覺得排版難看，請點(diǎn)擊下面鏈接或者拉到下面關(guān)注公眾號也可以吧原理源碼版之節(jié)點(diǎn)數(shù)據(jù)拼接上一篇我們 寫文章不容易，點(diǎn)個贊唄兄弟 專注 Vue 源碼分享，文章分為白話版和 源碼版，白話版助于理解工作原理，源碼版助于了解內(nèi)部詳情，讓我們一起學(xué)習(xí)吧研究...

    fizz 評論0 收藏0

  • Vue 的組件

    摘要：組件上一篇的表單輸入綁定使用組件注冊組件首先我們要創(chuàng)建一個實(shí)例要注冊一個全局組件，你可以使用。使用傳遞數(shù)據(jù)組件實(shí)例的作用域是孤立的。這意味著不能也不應(yīng)該在子組件的模板內(nèi)直接引用父組件的數(shù)據(jù)。 組件 上一篇：Vue的表單輸入綁定：https://segmentfault.com/a/11... 使用組件 注冊組件 首先我們要創(chuàng)建一個實(shí)例： new Vue({ el:.exp, ...

    kk_miles 評論0 收藏0

  • vue 2.6 中 slot 的新用法

    摘要：最近發(fā)布不久的，使用插槽的語法變得更加簡潔。插槽可用包裹外部的標(biāo)簽或者組件，并允許其他或組件放在具名插槽對應(yīng)名稱的插槽上。在部分中，監(jiān)聽的變化，當(dāng)發(fā)生變化時(shí)，清除狀態(tài)，然后調(diào)用并，當(dāng)成功完成或失敗時(shí)更新狀態(tài)。 為了保證的可讀性，本文采用意譯而非直譯。 最近發(fā)布不久的Vue 2.6，使用插槽的語法變得更加簡潔。 對插槽的這種改變讓我對發(fā)現(xiàn)插槽的潛在功能感興趣，以便為我們基于Vue的項(xiàng)目提...

    genedna 評論0 收藏0

  • 7個有用的Vue開發(fā)技巧

    摘要：另外需要說明的是，這里只是凍結(jié)了的值，引用不會被凍結(jié)，當(dāng)我們需要數(shù)據(jù)的時(shí)候，我們可以重新給賦值。1 狀態(tài)共享 隨著組件的細(xì)化，就會遇到多組件狀態(tài)共享的情況，Vuex當(dāng)然可以解決這類問題，不過就像Vuex官方文檔所說的，如果應(yīng)用不夠大，為避免代碼繁瑣冗余，最好不要使用它，今天我們介紹的是vue.js 2.6新增加的Observable API ，通過使用這個api我們可以應(yīng)對一些簡單的跨組件數(shù)...

    Godtoy 評論0 收藏0

  • 預(yù)計(jì)今年發(fā)布的Vue3.0到底有什么不一樣的地方？

    摘要：模板語法的將保持不變。基于的觀察者機(jī)制目前，的反應(yīng)系統(tǒng)是使用的和。為了繼續(xù)支持，將發(fā)布一個支持舊觀察者機(jī)制和新版本的構(gòu)建。 showImg(https://segmentfault.com/img/remote/1460000017862774?w=1898&h=796); 還有幾個月距離vue2的首次發(fā)布就滿3年了，而vue的作者尤雨溪也在去年年末發(fā)布了關(guān)于vue3.0的計(jì)劃，如果不...

    fnngj 評論0 收藏0

發(fā)表評論

0條評論

最新活動
閱讀需要支付1元查看
<