Vue 2.5 で Diff アルゴリズムを使用する方法

亚连
リリース: 2018-06-23 17:00:03
オリジナル
1374 人が閲覧しました

この記事では、Vue 2.5.3 バージョンで使用される Virtual Dom を分析します。 updataChildren は Diff アルゴリズムの中核であるため、この記事では updataChildren のグラフィック分析を行います。この記事を通じて、Vue 2.5 の Diff アルゴリズムを共有します。必要な方は参考にしてください。DOM は「本質的に遅い」ため、すべての主要なフロントエンド フレームワークは、DOM 操作を最適化する方法を提供しています。を確認すると、React が最初に Virtual Dom を提案し、Vue2.0 では React に似た Virtual Dom も追加されました。

この記事では、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&#39;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 ソース コードの type/vnode.d.ts の VNodeData の定義を参照してください。
  • children: 子ノードを含む配列タイプ。現在のノードのテキスト
  • text : 現在のノードのテキスト、通常はテキストノードまたはコメントノードがこの属性を持ちます
  • elm: 現在の仮想ノードに対応する実際の dom ノード
  • ns:ノードの名前空間
  • context: コンパイルスコープ
  • functionContext: 機能コンポーネントのスコープ
  • key: ノードのキー属性。ノードの識別子として使用され、パッチの最適化に役立ちます。
  • componentOptions: コンポーネントインスタンス作成時に使用するオプション情報当前Child: 現在のノードに対応するコンポーネントインスタンス
  • parent: コンポーネントの占有ノード
  • Raw: raw html
  • isstatic:静的ノードのロゴ ノード挿入、isComment: 現在のノードがコメントノードかどうか
  • isCloned: 現在のノードがクローンノードかどうか
  • isOnce: 現在のノードがv-onceコマンドを持っているかどうか
  • 2. VNode の分類

  • 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 !== &#39;production&#39; && warn(
      `Avoid using observed data object as vnode data: ${JSON.stringify(data)}\n` +
      &#39;Always create fresh vnode data objects in each render!&#39;,
      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 !== &#39;production&#39; &&
     isDef(data) && isDef(data.key) && !isPrimitive(data.key)
     ) {
     warn(
      &#39;Avoid using non-primitive value as key, &#39; +
      &#39;use string/number value instead.&#39;,
      context
     )
     }
     // 作用域插槽
     // support single function children as default scoped slot
     if (Array.isArray(children) &&
     typeof children[0] === &#39;function&#39;
     ) {
     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 === &#39;string&#39;) {
     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, &#39;components&#39;, 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 === &#39;foreignObject&#39;) {
     // 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. パッチの原理

パッチ関数は src/core/vdom/patch.js で定義されており、コードはスティッキーではありません。 6つのパラメータ:

oldVnode: 古い仮想ノードまたは古いReal domノード

vnode: 新しい仮想ノード 水和: 本物のdomと混合するかどうか

removeOnly: の特別なフラグ

    parentElm: 親ノード
  • refElm : 新しいノードは refElm
  • の前に挿入されます。パッチ ロジックは次のとおりです:

  • vnode は存在しないが、oldVnode が存在する場合、古いノードを破棄することが目的であることを示しますノードを作成し、invokeDestroyHook(oldVnode) を呼び出してそれを破棄します
  • oldVnode が存在しないが vnode が存在する場合は、新しいノードを作成することが目的であることを示し、createElm を呼び出して新しいノードを作成します

  • それ以外の場合は、vnode と oldVnode の両方が存在する場合
  • oldVnode と vnode が同じノードの場合は、patchVnode を呼び出してパッチを適用します

  • vnode と oldVnode が同じノードではない場合、oldVnode が実際の dom ノードであるか、ハイドレーティングが true に設定されている場合は、ハイドレート関数を使用してマッピングする必要があります仮想 dom と実 dom を比較し、oldVnode を対応する仮想 dom に設定して oldVnode を見つけます。vnode に基づいて実 dom ノードを作成し、それを親ノードの oldVnode.elm の位置に挿入します。
  • patchVnode のロジックは次のとおりです。

1. oldVnode が vnode と完全に一致している場合、何もする必要はありません。

2. vnode がクローンの場合、oldVnode と vnode が両方とも同じキーを持つ場合。ノードまたは v-once コマンドによって制御されるノードの場合は、oldVnode.elm と oldVnode.child の両方を vnode にコピーするだけで済み、他の操作は必要ありません

3. vnode がテキスト ノードでない場合、または注釈ノード

oldVnode と vnode の両方に子ノードがあり、両者の子ノードが完全に一致していない場合は、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, &#39;&#39;)
  // 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, &#39;&#39;)
  }
  // 如果新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的逻辑是:

分别获取oldVnode和vnode的firstChild、lastChild,赋值给oldStartVnode、oldEndVnode、newStartVnode、newEndVnode

如果oldStartVnode和newStartVnode是同一节点,调用patchVnode进行patch,然后将oldStartVnode和newStartVnode都设置为下一个子节点,

如果oldEndVnode和newEndVnode是同一节点,调用patchVnode进行patch,然后将oldEndVnode和newEndVnode都设置为上一个子节点,重复上述流程

如果oldStartVnode和newEndVnode是同一节点,调用patchVnode进行patch,如果removeOnly是false,那么可以把oldStartVnode.elm移动到oldEndVnode.elm之后,然后把oldStartVnode设置为下一个节点,newEndVnode设置为上一个节点,重复上述流程

如果newStartVnode和oldEndVnode是同一节点,调用patchVnode进行patch,如果removeOnly是false,那么可以把oldEndVnode.elm移动到oldStartVnode.elm之前,然后把newStartVnode设置为下一个节点,oldEndVnode设置为上一个节点,重复上述流程

如果以上都不匹配,就尝试在oldChildren中寻找跟newStartVnode具有相同key的节点,如果找不到相同key的节点,说明newStartVnode是一个新节点,就创建一个,然后把newStartVnode设置为下一个节点

如果上一步找到了跟newStartVnode相同key的节点,那么通过其他属性的比较来判断这2个节点是否是同一个节点,如果是,就调用patchVnode进行patch,如果removeOnly是false,就把newStartVnode.elm插入到oldStartVnode.elm之前,把newStartVnode设置为下一个节点,重复上述流程

如果在oldChildren中没有寻找到newStartVnode的同一节点,那就创建一个新节点,把newStartVnode设置为下一个节点,重复上述流程

如果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 !== &#39;production&#39; && !vnodeToMove) {
   warn(
    &#39;It seems there are duplicate keys that is causing an update error. &#39; +
    &#39;Make sure each v-for item has a unique key.&#39;
   )
   }
   // 比较两个具有相同的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 は新しい子ノードには存在しません。これらを dom から削除するには、上記の内容をまとめました。将来的には皆さんの役に立つと思います。

関連記事:

Chrome Firefox にはデバッグ ツールが付属しています (詳細なチュートリアル)

Vue.js による無限スクロール読み込みの実装方法について

Angular を使用してテーブル フィルタリングを実装する方法

その実装方法JavaScript 電卓を使用する

以上がVue 2.5 で Diff アルゴリズムを使用する方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

関連ラベル:
ソース:php.cn
このウェブサイトの声明
この記事の内容はネチズンが自主的に寄稿したものであり、著作権は原著者に帰属します。このサイトは、それに相当する法的責任を負いません。盗作または侵害の疑いのあるコンテンツを見つけた場合は、admin@php.cn までご連絡ください。
最新の問題
人気のチュートリアル
詳細>
最新のダウンロード
詳細>
ウェブエフェクト
公式サイト
サイト素材
フロントエンドテンプレート