# 数据变为视图方法

  • 介绍下面 4 中方法

    • 纯 DOM 法
    • 数组 Join 法
    • ES6 反引导法
    • 模板引擎 Mustache
  • 前三种方法用这个数据进行举栗

  • 此时有个 ul 标签,我们需要在里面添加标签并将 data 中数据以 li 标签渲染到页面上的几种方法

  • HTML

<ul id="list"></ul>
  • data
const data = [
  { tag: 'li', name: 'lain', age: 16 },
  { tag: 'li', name: 'saber', age: 17 },
  { tag: 'li', name: '樱岛麻衣', age: 16 },
  { tag: 'li', name: '稚名真白', age: 17 }
]

# 纯 DOM 法

for (const key of data) {
  // 1. 获取父元素
  const list = document.querySelector("#list")
  
  // 2. 创建标签
  const li = document.createElement(key.tag)
  
  // 3. 添加内容
  li.textContent = key.name + key.age
  
  // 4. 追加子节点
  list.appendChild(li)
}

# 数组 Join 法

  • 这是曾经非常流行的方法,是曾经前端必会的知识
  • join 方法合并数组的元素并返回一个字符串
data.forEach(item => {
  list.innerHTML += [
    '<li>姓名:' + item.name + ' 年龄: ' + item.age + '</li>',
  ].join('')
})

# ES6 反引导法

  • 这是 ES6 的模板字符串,可以直接换行并可以将遍历用 ${} 形式放入
data.forEach(item => {
  list.innerHTML += `
  <li>
    <span>姓名:${item.name}</span>
    <span>年龄:${item.age}</span>
  </li>
  `
})

# 模板引擎 Mustache

  • 先引入 js 文件
<script src="https://cdn.bootcdn.net/ajax/libs/mustache.js/4.1.0/mustache.js"></script>

# 基本用法, 不循环直接进行使用

// 1. 定义补办字符串
const templateStr = `<h1>我喜欢吃{{ peach }}</h1>`
// 2. 定义数据
const fruit = { peach: '桃子' }
// 3. 传入参数 返回新字符串
const domStr = Mustache.render(templateStr, fruit)
console.log(domStr) /* <h1 > 我喜欢吃桃子 < /h1> */
container.innerHTML = domStr

# 循环对象

  • 先定义变量接收对象类型数据 对象中定义一个数组类型,它的名字决定了 {{#arr}} 这里面要写的名字
  • 定义变量接收模板字符串 里面与 反引导法 写法一样,写标签
  • 调用 Mustache.render 方法,参数一:模板字符串变量,参数二:数据类型变量,渲染返回一组新的字符串
  • 最后进行挂载,下面来进行演示
// 1. 定义数据 对象类型 对象里面定义要循环的数组
const data = {
  arr: [
    { tag: 'li', name: 'lain', age: 16 },
    { tag: 'li', name: 'saber', age: 17 },
    { tag: 'li', name: '樱岛麻衣', age: 16 },
    { tag: 'li', name: '稚名真白', age: 17 }
  ]
}
// 2. 定义模板字符串 {{#arr}} 代表循环的数组 接着写法如下
const templateStr = `
  <ul>
    {{#arr}}
      <li>
        <span>姓名:{{ name }}</span>
        <span>年龄:{{ age }}</span>
      </li>
    {{/arr}} 
  </ul>
`
// 3. 返回遍历渲染完的新字符串
const domStr = Mustache.render(templateStr, data)
// 4. 进行挂载 id 属性可以不用进行获取
container.innerHTML = domStr
  • 我们这里打印下 domStr , 输出下面字符串
/*
<ul>
    <li>
      <span > 姓名:lain</span>
      <span > 年龄:16</span>
    </li>
    <li>
      <span > 姓名:saber</span>
      <span > 年龄:17</span>
    </li>
    <li>
      <span > 姓名:樱岛麻衣 & lt;/span>
      <span > 年龄:16</span>
    </li>
    <li>
      <span > 姓名:稚名真白 & lt;/span>
      <span > 年龄:17</span>
    </li>
</ul>
*/

# 循环简单数组

  • 循环简单数组可直接用 . 表示即可
// 1. 定义数据
const fruits = {
  fruits: ['peach', 'watermelon', 'cherry']
// 2. 定义模板字符串
const templateStr = `
  <ul>
    {{ #fruits }}
      <li>{{ . }}</li> // 因为这里是简单的数组 直接用 . 即可
    {{ /fruits }}
  </ul>
`
// 3. 返回遍历渲染完的新字符串
const domStr = Mustache.render(templateStr, fruits)
console.log(domStr)
/*
  <ul>
      <li>peach</li>
      <li>watermelon</li>
      <li>cherry</li>
  </ul>
*/
// 4. 挂载
container.innerHTML = domStr

# 循环数组嵌套

  • 复杂的数组写法
// 1. 定义数据 对象类型 对象里面定义要循环的数组
const data = {
  arr: [
    { tag: 'li', name: 'lain', age: 16, freiends: ['saber', '樱岛麻衣'] },
    { tag: 'li', name: 'saber', age: 17, freiends: ['樱岛麻衣', '稚名真白'] },
    { tag: 'li', name: '樱岛麻衣', age: 16, freiends: ['稚名真白', 'lain'] },
    { tag: 'li', name: '稚名真白', age: 17, freiends: ['lain', 'saber'] }
  ]
}
// 2. 定义模板字符串 写法如下
const templateStr = `
  <ul>
    {{ #arr }}
      <li>
        <span>姓名:{{ name }}</span>
        <span>年龄:{{ age }}</span>
        <ol>
          {{ #freiends }}
            <li>freiends: {{ . }}</li>
          {{ /freiends }}
        </ol>
      </li>
    {{ /arr }}
  </ul>
`
// 3. 返回遍历渲染完的新字符串
const domStr = Mustache.render(templateStr, data)
// 4. 进行挂载 id 属性可以不用进行获取
container.innerHTML = domStr
  • 进行打印 domStr
/*
<ul>
    <li>
      <span > 姓名:lain</span>
      <span > 年龄:16</span>
      <ol>
          <li>freiends: saber</li>
          <li>freiends: 樱岛麻衣 & lt;/li>
      </ol>
    </li>
    <li>
      <span > 姓名:saber</span>
      <span > 年龄:17</span>
      <ol>
          <li>freiends: 樱岛麻衣 & lt;/li>
          <li>freiends: 稚名真白 & lt;/li>
      </ol>
    </li>
    <li>
      <span > 姓名:樱岛麻衣 & lt;/span>
      <span > 年龄:16</span>
      <ol>
          <li>freiends: 稚名真白 & lt;/li>
          <li>freiends: lain</li>
      </ol>
    </li>
    <li>
      <span > 姓名:稚名真白 & lt;/span>
      <span > 年龄:17</span>
      <ol>
          <li>freiends: lain</li>
          <li>freiends: saber</li>
      </ol>
    </li>
</ul>
*/

# 布尔值 显示隐藏

  • 其实与 v-if 一样,会删除元素
// 1. 定义模板
const templateStr = `
  {{ #m }}
    <h2>Hello World~</h2>
  {{ /m }}
`
// 2. 定义数据
const flag = {
  m: true, // 显示
  //m: false // 隐藏
}
    
// 3. 返回遍历渲染完的新字符串
const domStr = Mustache.render(templateStr, flag)
// 4. 进行挂载 id 属性可以不用进行获取
container.innerHTML = domStr

# template

<!-- 1.0 直接使用 script test/template 属性定义模板 -->
<script type="test/template" id="template">
  <ul>
    {{ #arr }}
      <li>
        <span>姓名:{{ name }}</span>
        <span>年龄:{{ age }}</span>
        <ol>
          {{ #freiends }}
            <li>freiends: {{ . }}</li>
          {{ /freiends }}
        </ol>
      </li>
    {{ /arr }}
  <ul>
</script>
<script>
  // 1.1 获取模板
  const templateStr = document.querySelector('#template').textContent
  console.log(templateStr);
  // 2. 定义数据 对象类型 对象里面定义要循环的数组
  const data = {
    arr: [
      { tag: 'li', name: 'lain', age: 16, freiends: ['saber', '樱岛麻衣'] },
      { tag: 'li', name: 'saber', age: 17, freiends: ['樱岛麻衣', '稚名真白'] },
      { tag: 'li', name: '樱岛麻衣', age: 16, freiends: ['稚名真白', 'lain'] },
      { tag: 'li', name: '稚名真白', age: 17, freiends: ['lain', 'saber'] }
    ]
  }
  // 3. 返回遍历渲染完的新字符串
  const domStr = Mustache.render(templateStr, data)
  
  // 4. 进行挂载 id 属性可以不用进行获取
  container.innerHTML = domStr
</script>