day03

组件

  • 组件 (Component) 是 Vue.js 最强大的功能之一
  • 组件可以扩展 HTML 元素，封装可重用的代

组件注册

全局注册

  • Vue.component(‘组件名称’, { }) 第1个参数是标签名称，第2个参数是一个选项对象
  • 全局组件注册后，任何vue实例都可以用

组件基础用
  1. <div id="example">
  2.   <!-- 2、 组件使用 组件名称 是以HTML标签的形式使用  -->  
  3.   <my-component></my-component>
  4. </div>
  5. <script>
  6.     //   注册组件 
  7.     // 1、 my-component 就是组件中自定义的标签名
  8.     Vue.component('my-component', {
  9.       template: '<div>A custom component!</div>'
  10.     })
  12.     // 创建根实例
  13.     new Vue({
  14.       el: '#example'
  15.     })
  17. </script>

组件注意事项
  • 组件参数的data值必须是函数同时这个函数要求返回一个对象
  • 组件模板必须是单个根元素
  • 组件模板的内容可以是模板字符串
  1.   <div id="app">
  2.      <!-- 
  3.         4、  组件可以重复使用多次 
  4.           因为data中返回的是一个对象所以每个组件中的数据是私有的
  5.           即每个实例可以维护一份被返回对象的独立的拷贝   
  6.     --> 
  7.     <button-counter></button-counter>
  8.     <button-counter></button-counter>
  9.     <button-counter></button-counter>
  10.       <!-- 8、必须使用短横线的方式使用组件 -->
  11.      <hello-world></hello-world>
  12.   </div>
  14. <script type="text/javascript">
  15.     //5  如果使用驼峰式命名组件，那么在使用组件的时候，只能在字符串模板中用驼峰的方式使用组件，
  16.     // 7、但是在普通的标签模板中，必须使用短横线的方式使用组件
  17.      Vue.component('HelloWorld', {
  18.       data: function(){
  19.         return {
  20.           msg: 'HelloWorld'
  21.         }
  22.       },
  23.       template: '<div>{{msg}}</div>'
  24.     });
  28.     Vue.component('button-counter', {
  29.       // 1、组件参数的data值必须是函数 
  30.       // 同时这个函数要求返回一个对象  
  31.       data: function(){
  32.         return {
  33.           count: 0
  34.         }
  35.       },
  36.       //  2、组件模板必须是单个根元素
  37.       //  3、组件模板的内容可以是模板字符串  
  38.       template: `
  39.         <div>
  40.           <button @click="handle">点击了{{count}}次</button>
  41.           <button>测试123</button>
  42.             #  6 在字符串模板中可以使用驼峰的方式使用组件    
  43.            <HelloWorld></HelloWorld>
  44.         </div>
  45.       `,
  46.       methods: {
  47.         handle: function(){
  48.           this.count += 2;
  49.         }
  50.       }
  51.     })
  52.     var vm = new Vue({
  53.       el: '#app',
  54.       data: {
  56.       }
  57.     });
  58.   </script>

局部注册

  • 只能在当前注册它的vue实例中使用
  1.   <div id="app">
  2.       <my-component></my-component>
  3.   </div>
  6. <script>
  7.     // 定义组件的模板
  8.     var Child = {
  9.       template: '<div>A custom component!</div>'
  10.     }
  11.     new Vue({
  12.       //局部注册组件  
  13.       components: {
  14.         // <my-component> 将只在父模板可用  一定要在实例上注册了才能在html文件中使用
  15.         'my-component': Child
  16.       }
  17.     })
  18.  </script>

Vue 调试工具

Vue组件之间传值

父组件向子组件传值

  • 父组件发送的形式是以属性的形式绑定值到子组件身上。
  • 然后子组件用属性props接收
  • 在props中使用驼峰形式，模板中需要使用短横线的形式字符串形式的模板中没有这个限制
  1.   <div id="app">
  2.     <div>{{pmsg}}</div>
  3.      <!--1、menu-item  在 APP中嵌套着 故 menu-item   为  子组件      -->
  4.      <!-- 给子组件传入一个静态的值 -->
  5.     <menu-item title='来自父组件的值'></menu-item>
  6.     <!-- 2、 需要动态的数据的时候 需要属性绑定的形式设置 此时 ptitle  来自父组件data 中的数据 . 
  7.           传的值可以是数字、对象、数组等等
  8.     -->
  9.     <menu-item :title='ptitle' content='hello'></menu-item>
  10.   </div>
  12.   <script type="text/javascript">
  13.     Vue.component('menu-item', {
  14.       // 3、 子组件用属性props接收父组件传递过来的数据  
  15.       props: ['title', 'content'],
  16.       data: function() {
  17.         return {
  18.           msg: '子组件本身的数据'
  19.         }
  20.       },
  21.       template: '<div>{{msg + "----" + title + "-----" + content}}</div>'
  22.     });
  23.     var vm = new Vue({
  24.       el: '#app',
  25.       data: {
  26.         pmsg: '父组件中内容',
  27.         ptitle: '动态绑定属性'
  28.       }
  29.     });
  30.   </script>

子组件向父组件传值

  • 子组件用$emit()触发事件
  • $emit() 第一个参数为 自定义的事件名称 第二个参数为需要传递的数据
  • 父组件用v-on 监听子组件的事件
  2.  <div id="app">
  3.     <div :style='{fontSize: fontSize + "px"}'>{{pmsg}}</div>
  4.      <!-- 2 父组件用v-on 监听子组件的事件
  5.         这里 enlarge-text  是从 $emit 中的第一个参数对应   handle 为对应的事件处理函数    
  6.     -->    
  7.     <menu-item :parr='parr' @enlarge-text='handle($event)'></menu-item>
  8.   </div>
  9.   <script type="text/javascript" src="js/vue.js"></script>
  10.   <script type="text/javascript">
  11.     /*
  12.       子组件向父组件传值-携带参数
  13.     */
  15.     Vue.component('menu-item', {
  16.       props: ['parr'],
  17.       template: `
  18.         <div>
  19.           <ul>
  20.             <li :key='index' v-for='(item,index) in parr'>{{item}}</li>
  21.           </ul>
  22.             ###  1、子组件用$emit()触发事件
  23.             ### 第一个参数为 自定义的事件名称   第二个参数为需要传递的数据  
  24.           <button @click='$emit("enlarge-text", 5)'>扩大父组件中字体大小</button>
  25.           <button @click='$emit("enlarge-text", 10)'>扩大父组件中字体大小</button>
  26.         </div>
  27.       `
  28.     });
  29.     var vm = new Vue({
  30.       el: '#app',
  31.       data: {
  32.         pmsg: '父组件中内容',
  33.         parr: ['apple','orange','banana'],
  34.         fontSize: 10
  35.       },
  36.       methods: {
  37.         handle: function(val){
  38.           // 扩大字体大小
  39.           this.fontSize += val;
  40.         }
  41.       }
  42.     });
  43.   </script>

兄弟之间的传递

  • 兄弟之间传递数据需要借助于事件中心，通过事件中心传递数据

    • 提供事件中心 var hub = new Vue()
  • 传递数据方，通过一个事件触发hub.$emit(方法名，传递的数据)
  • 接收数据方，通过mounted(){} 钩子中 触发hub.$on()方法名
  • 销毁事件 通过hub.$off()方法名销毁之后无法进行传递数据
  1.  <div id="app">
  2.     <div>父组件</div>
  3.     <div>
  4.       <button @click='handle'>销毁事件</button>
  5.     </div>
  6.     <test-tom></test-tom>
  7.     <test-jerry></test-jerry>
  8.   </div>
  9.   <script type="text/javascript" src="js/vue.js"></script>
  10.   <script type="text/javascript">
  11.     /*
  12.       兄弟组件之间数据传递
  13.     */
  14.     //1、 提供事件中心
  15.     var hub = new Vue();
  17.     Vue.component('test-tom', {
  18.       data: function(){
  19.         return {
  20.           num: 0
  21.         }
  22.       },
  23.       template: `
  24.         <div>
  25.           <div>TOM:{{num}}</div>
  26.           <div>
  27.             <button @click='handle'>点击</button>
  28.           </div>
  29.         </div>
  30.       `,
  31.       methods: {
  32.         handle: function(){
  33.           //2、传递数据方，通过一个事件触发hub.$emit(方法名，传递的数据)   触发兄弟组件的事件
  34.           hub.$emit('jerry-event', 2);
  35.         }
  36.       },
  37.       mounted: function() {
  38.        // 3、接收数据方，通过mounted(){} 钩子中  触发hub.$on(方法名
  39.         hub.$on('tom-event', (val) => {
  40.           this.num += val;
  41.         });
  42.       }
  43.     });
  44.     Vue.component('test-jerry', {
  45.       data: function(){
  46.         return {
  47.           num: 0
  48.         }
  49.       },
  50.       template: `
  51.         <div>
  52.           <div>JERRY:{{num}}</div>
  53.           <div>
  54.             <button @click='handle'>点击</button>
  55.           </div>
  56.         </div>
  57.       `,
  58.       methods: {
  59.         handle: function(){
  60.           //2、传递数据方，通过一个事件触发hub.$emit(方法名，传递的数据)   触发兄弟组件的事件
  61.           hub.$emit('tom-event', 1);
  62.         }
  63.       },
  64.       mounted: function() {
  65.         // 3、接收数据方，通过mounted(){} 钩子中  触发hub.$on()方法名
  66.         hub.$on('jerry-event', (val) => {
  67.           this.num += val;
  68.         });
  69.       }
  70.     });
  71.     var vm = new Vue({
  72.       el: '#app',
  73.       data: {
  75.       },
  76.       methods: {
  77.         handle: function(){
  78.           //4、销毁事件 通过hub.$off()方法名销毁之后无法进行传递数据  
  79.           hub.$off('tom-event');
  80.           hub.$off('jerry-event');
  81.         }
  82.       }
  83.     });
  84.   </script>

组件插槽

  • 组件的最大特性就是复用性，而用好插槽能大大提高组件的可复用能力

匿名插槽

  2.   <div id="app">
  3.     <!-- 这里的所有组件标签中嵌套的内容会替换掉slot  如果不传值 则使用 slot 中的默认值  -->  
  4.     <alert-box>有bug发生</alert-box>
  5.     <alert-box>有一个警告</alert-box>
  6.     <alert-box></alert-box>
  7.   </div>
  9.   <script type="text/javascript">
  10.     /*
  11.       组件插槽：父组件向子组件传递内容
  12.     */
  13.     Vue.component('alert-box', {
  14.       template: `
  15.         <div>
  16.           <strong>ERROR:</strong>
  17.         # 当组件渲染的时候，这个 <slot> 元素将会被替换为“组件标签中嵌套的内容”。
  18.         # 插槽内可以包含任何模板代码，包括 HTML
  19.           <slot>默认内容</slot>
  20.         </div>
  21.       `
  22.     });
  23.     var vm = new Vue({
  24.       el: '#app',
  25.       data: {
  27.       }
  28.     });
  29.   </script>
  30. </body>
  31. </html>

具名插槽

  • 具有名字的插槽
  • 使用 中的 “name” 属性绑定元素
  2.   <div id="app">
  3.     <base-layout>
  4.        <!-- 2、 通过slot属性来指定, 这个slot的值必须和下面slot组件得name值对应上
  5.                 如果没有匹配到 则放到匿名的插槽中   --> 
  6.       <p slot='header'>标题信息</p>
  7.       <p>主要内容1</p>
  8.       <p>主要内容2</p>
  9.       <p slot='footer'>底部信息信息</p>
  10.     </base-layout>
  12.     <base-layout>
  13.       <!-- 注意点：template临时的包裹标签最终不会渲染到页面上     -->  
  14.       <template slot='header'>
  15.         <p>标题信息1</p>
  16.         <p>标题信息2</p>
  17.       </template>
  18.       <p>主要内容1</p>
  19.       <p>主要内容2</p>
  20.       <template slot='footer'>
  21.         <p>底部信息信息1</p>
  22.         <p>底部信息信息2</p>
  23.       </template>
  24.     </base-layout>
  25.   </div>
  26.   <script type="text/javascript" src="js/vue.js"></script>
  27.   <script type="text/javascript">
  28.     /*
  29.       具名插槽
  30.     */
  31.     Vue.component('base-layout', {
  32.       template: `
  33.         <div>
  34.           <header>
  35.             ###    1、 使用 <slot> 中的 "name" 属性绑定元素 指定当前插槽的名字
  36.             <slot name='header'></slot>
  37.           </header>
  38.           <main>
  39.             <slot></slot>
  40.           </main>
  41.           <footer>
  42.             ###  注意点： 
  43.             ###  具名插槽的渲染顺序，完全取决于模板，而不是取决于父组件中元素的顺序
  44.             <slot name='footer'></slot>
  45.           </footer>
  46.         </div>
  47.       `
  48.     });
  49.     var vm = new Vue({
  50.       el: '#app',
  51.       data: {
  53.       }
  54.     });
  55.   </script>
  56. </body>
  57. </html>

作用域插槽

  • 父组件对子组件加工处理
  • 既可以复用子组件的slot，又可以使slot内容不一致
  1.   <div id="app">
  2.     <!-- 
  3.         1、当我们希望li 的样式由外部使用组件的地方定义，因为可能有多种地方要使用该组件，
  4.         但样式希望不一样 这个时候我们需要使用作用域插槽 
  6.     -->  
  7.     <fruit-list :list='list'>
  8.        <!-- 2、 父组件中使用了<template>元素,而且包含scope="slotProps",
  9.             slotProps在这里只是临时变量   
  10.         --->     
  11.       <template slot-scope='slotProps'>
  12.         <strong v-if='slotProps.info.id==3' class="current">
  13.             {{slotProps.info.name}}                 
  14.          </strong>
  15.         <span v-else>{{slotProps.info.name}}</span>
  16.       </template>
  17.     </fruit-list>
  18.   </div>
  19.   <script type="text/javascript" src="js/vue.js"></script>
  20.   <script type="text/javascript">
  21.     /*
  22.       作用域插槽
  23.     */
  24.     Vue.component('fruit-list', {
  25.       props: ['list'],
  26.       template: `
  27.         <div>
  28.           <li :key='item.id' v-for='item in list'>
  29.             ###  3、 在子组件模板中,<slot>元素上有一个类似props传递数据给组件的写法msg="xxx",
  30.             ###   插槽可以提供一个默认内容，如果如果父组件没有为这个插槽提供了内容，会显示默认的内容。
  31.                     如果父组件为这个插槽提供了内容，则默认的内容会被替换掉
  32.             <slot :info='item'>{{item.name}}</slot>
  33.           </li>
  34.         </div>
  35.       `
  36.     });
  37.     var vm = new Vue({
  38.       el: '#app',
  39.       data: {
  40.         list: [{
  41.           id: 1,
  42.           name: 'apple'
  43.         },{
  44.           id: 2,
  45.           name: 'orange'
  46.         },{
  47.           id: 3,
  48.           name: 'banana'
  49.         }]
  50.       }
  51.     });
  52.   </script>
  53. </body>
  54. </html>

购物车案例

1. 实现组件化布局

  • 把静态页面转换成组件化模式
  • 把组件渲染到页面上
  1.  <div id="app">
  2.     <div class="container">
  3.       <!-- 2、把组件渲染到页面上 --> 
  4.       <my-cart></my-cart>
  5.     </div>
  6.   </div>
  7.   <script type="text/javascript" src="js/vue.js"></script>
  8.   <script type="text/javascript">
  9.     # 1、 把静态页面转换成组件化模式
  10.     # 1.1  标题组件 
  11.     var CartTitle = {
  12.       template: `
  13.         <div class="title">我的商品</div>
  14.       `
  15.     }
  16.     # 1.2  商品列表组件 
  17.     var CartList = {
  18.       #  注意点 ：  组件模板必须是单个根元素  
  19.       template: `
  20.         <div>
  21.           <div class="item">
  22.             <img src="img/a.jpg"/>
  23.             <div class="name"></div>
  24.             <div class="change">
  25.               <a href="">－</a>
  26.               <input type="text" class="num" />
  27.               <a href="">＋</a>
  28.             </div>
  29.             <div class="del">×</div>
  30.           </div>
  31.           <div class="item">
  32.             <img src="img/b.jpg"/>
  33.             <div class="name"></div>
  34.             <div class="change">
  35.               <a href="">－</a>
  36.               <input type="text" class="num" />
  37.               <a href="">＋</a>
  38.             </div>
  39.             <div class="del">×</div>
  40.           </div>
  41.           <div class="item">
  42.             <img src="img/c.jpg"/>
  43.             <div class="name"></div>
  44.             <div class="change">
  45.               <a href="">－</a>
  46.               <input type="text" class="num" />
  47.               <a href="">＋</a>
  48.             </div>
  49.             <div class="del">×</div>
  50.           </div>
  51.           <div class="item">
  52.             <img src="img/d.jpg"/>
  53.             <div class="name"></div>
  54.             <div class="change">
  55.               <a href="">－</a>
  56.               <input type="text" class="num" />
  57.               <a href="">＋</a>
  58.             </div>
  59.             <div class="del">×</div>
  60.           </div>
  61.           <div class="item">
  62.             <img src="img/e.jpg"/>
  63.             <div class="name"></div>
  64.             <div class="change">
  65.               <a href="">－</a>
  66.               <input type="text" class="num" />
  67.               <a href="">＋</a>
  68.             </div>
  69.             <div class="del">×</div>
  70.           </div>
  71.         </div>
  72.       `
  73.     }
  74.     # 1.3  商品结算组件 
  75.     var CartTotal = {
  76.       template: `
  77.         <div class="total">
  78.           <span>总价：123</span>
  79.           <button>结算</button>
  80.         </div>
  81.       `
  82.     }
  83.     ## 1.4  定义一个全局组件 my-cart
  84.     Vue.component('my-cart',{
  85.       ##  1.6 引入子组件  
  86.       template: `
  87.         <div class='cart'>
  88.           <cart-title></cart-title>
  89.           <cart-list></cart-list>
  90.           <cart-total></cart-total>
  91.         </div>
  92.       `,
  93.       # 1.5  注册子组件   
  94.       components: {
  95.         'cart-title': CartTitle,
  96.         'cart-list': CartList,
  97.         'cart-total': CartTotal
  98.       }
  99.     });
  100.     var vm = new Vue({
  101.       el: '#app',
  102.       data: {
  104.       }
  105.     });
  107.   </script>

2、实现 标题和结算功能组件

  • 标题组件实现动态渲染

    • 从父组件把标题数据传递过来 即 父向子组件传值
    • 把传递过来的数据渲染到页面上

  • 结算功能组件

    • 从父组件把商品列表list 数据传递过来 即 父向子组件传值
    • 把传递过来的数据计算最终价格渲染到页面上
  1.  <div id="app">
  2.     <div class="container">
  3.       <my-cart></my-cart>
  4.     </div>
  5.   </div>
  6.   <script type="text/javascript" src="js/vue.js"></script>
  7.   <script type="text/javascript">
  8.      # 2.2  标题组件     子组件通过props形式接收父组件传递过来的uname数据
  9.     var CartTitle = {
  10.       props: ['uname'],
  11.       template: `
  12.         <div class="title">{{uname}}的商品</div>
  13.       `
  14.     }
  15.     # 2.3  商品结算组件  子组件通过props形式接收父组件传递过来的list数据   
  16.     var CartTotal = {
  17.       props: ['list'],
  18.       template: `
  19.         <div class="total">
  20.           <span>总价：{{total}}</span>
  21.           <button>结算</button>
  22.         </div>
  23.       `,
  24.       computed: {
  25.         # 2.4    计算商品的总价  并渲染到页面上 
  26.         total: function() {
  27.           var t = 0;
  28.           this.list.forEach(item => {
  29.             t += item.price * item.num;
  30.           });
  31.           return t;
  32.         }
  33.       }
  34.     }
  35.     Vue.component('my-cart',{
  36.       data: function() {
  37.         return {
  38.           uname: '张三',
  39.           list: [{
  40.             id: 1,
  41.             name: 'TCL彩电',
  42.             price: 1000,
  43.             num: 1,
  44.             img: 'img/a.jpg'
  45.           },{
  46.             id: 2,
  47.             name: '机顶盒',
  48.             price: 1000,
  49.             num: 1,
  50.             img: 'img/b.jpg'
  51.           },{
  52.             id: 3,
  53.             name: '海尔冰箱',
  54.             price: 1000,
  55.             num: 1,
  56.             img: 'img/c.jpg'
  57.           },{
  58.             id: 4,
  59.             name: '小米手机',
  60.             price: 1000,
  61.             num: 1,
  62.             img: 'img/d.jpg'
  63.           },{
  64.             id: 5,
  65.             name: 'PPTV电视',
  66.             price: 1000,
  67.             num: 2,
  68.             img: 'img/e.jpg'
  69.           }]
  70.         }
  71.       },
  72.       #  2.1  父组件向子组件以属性传递的形式 传递数据
  73.       #   向 标题组件传递 uname 属性   向 商品结算组件传递 list  属性  
  74.       template: `
  75.         <div class='cart'>
  76.           <cart-title :uname='uname'></cart-title>
  77.           <cart-list></cart-list>
  78.           <cart-total :list='list'></cart-total>
  79.         </div>
  80.       `,
  81.       components: {
  82.         'cart-title': CartTitle,
  83.         'cart-list': CartList,
  84.         'cart-total': CartTotal
  85.       }
  86.     });
  87.     var vm = new Vue({
  88.       el: '#app',
  89.       data: {
  91.       }
  92.     });
  94.   </script>

3. 实现列表组件删除功能

  • 从父组件把商品列表list 数据传递过来 即 父向子组件传值
  • 把传递过来的数据渲染到页面上

  • 点击删除按钮的时候删除对应的数据

    • 给按钮添加点击事件把需要删除的id传递过来

      • 子组件中不推荐操作父组件的数据有可能多个子组件使用父组件的数据 我们需要把数据传递给父组件让父组件操作数据
      • 父组件删除对应的数据
  1.  <div id="app">
  2.     <div class="container">
  3.       <my-cart></my-cart>
  4.     </div>
  5.   </div>
  6.   <script type="text/javascript" src="js/vue.js"></script>
  7.   <script type="text/javascript">
  9.     var CartTitle = {
  10.       props: ['uname'],
  11.       template: `
  12.         <div class="title">{{uname}}的商品</div>
  13.       `
  14.     }
  15.     #  3.2 把列表数据动态渲染到页面上  
  16.     var CartList = {
  17.       props: ['list'],
  18.       template: `
  19.         <div>
  20.           <div :key='item.id' v-for='item in list' class="item">
  21.             <img :src="item.img"/>
  22.             <div class="name">{{item.name}}</div>
  23.             <div class="change">
  24.               <a href="">－</a>
  25.               <input type="text" class="num" />
  26.               <a href="">＋</a>
  27.             </div>
  28.             # 3.3  给按钮添加点击事件把需要删除的id传递过来
  29.             <div class="del" @click='del(item.id)'>×</div>
  30.           </div>
  31.         </div>
  32.       `,
  33.       methods: {
  34.         del: function(id){
  35.            # 3.4 子组件中不推荐操作父组件的数据有可能多个子组件使用父组件的数据 
  36.           #       我们需要把数据传递给父组件 让父组件操作数据 
  37.           this.$emit('cart-del', id);
  38.         }
  39.       }
  40.     }
  41.     var CartTotal = {
  42.       props: ['list'],
  43.       template: `
  44.         <div class="total">
  45.           <span>总价：{{total}}</span>
  46.           <button>结算</button>
  47.         </div>
  48.       `,
  49.       computed: {
  50.         total: function() {
  51.           // 计算商品的总价
  52.           var t = 0;
  53.           this.list.forEach(item => {
  54.             t += item.price * item.num;
  55.           });
  56.           return t;
  57.         }
  58.       }
  59.     }
  60.     Vue.component('my-cart',{
  61.       data: function() {
  62.         return {
  63.           uname: '张三',
  64.           list: [{
  65.             id: 1,
  66.             name: 'TCL彩电',
  67.             price: 1000,
  68.             num: 1,
  69.             img: 'img/a.jpg'
  70.           },{
  71.             id: 2,
  72.             name: '机顶盒',
  73.             price: 1000,
  74.             num: 1,
  75.             img: 'img/b.jpg'
  76.           },{
  77.             id: 3,
  78.             name: '海尔冰箱',
  79.             price: 1000,
  80.             num: 1,
  81.             img: 'img/c.jpg'
  82.           },{
  83.             id: 4,
  84.             name: '小米手机',
  85.             price: 1000,
  86.             num: 1,
  87.             img: 'img/d.jpg'
  88.           },{
  89.             id: 5,
  90.             name: 'PPTV电视',
  91.             price: 1000,
  92.             num: 2,
  93.             img: 'img/e.jpg'
  94.           }]
  95.         }
  96.       },
  97.       # 3.1 从父组件把商品列表list 数据传递过来 即 父向子组件传值  
  98.       template: `
  99.         <div class='cart'>
  100.           <cart-title :uname='uname'></cart-title>
  101.           #  3.5  父组件通过事件绑定 接收子组件传递过来的数据 
  102.           <cart-list :list='list' @cart-del='delCart($event)'></cart-list>
  103.           <cart-total :list='list'></cart-total>
  104.         </div>
  105.       `,
  106.       components: {
  107.         'cart-title': CartTitle,
  108.         'cart-list': CartList,
  109.         'cart-total': CartTotal
  110.       },
  111.       methods: {
  112.         # 3.6    根据id删除list中对应的数据        
  113.         delCart: function(id) {
  114.           // 1、找到id所对应数据的索引
  115.           var index = this.list.findIndex(item=>{
  116.             return item.id == id;
  117.           });
  118.           // 2、根据索引删除对应数据
  119.           this.list.splice(index, 1);
  120.         }
  121.       }
  122.     });
  123.     var vm = new Vue({
  124.       el: '#app',
  125.       data: {
  127.       }
  128.     });
  130.   </script>
  131. </body>
  132. </html>

4. 实现组件更新数据功能 上

  • 将输入框中的默认数据动态渲染出来
  • 输入框失去焦点的时候 更改商品的数量
  • 子组件中不推荐操作数据 把这些数据传递给父组件 让父组件处理这些数据
    1. 父组件中接收子组件传递过来的数据并处理
  1.  <div id="app">
  2.     <div class="container">
  3.       <my-cart></my-cart>
  4.     </div>
  5.   </div>
  6.   <script type="text/javascript" src="js/vue.js"></script>
  7.   <script type="text/javascript">
  9.     var CartTitle = {
  10.       props: ['uname'],
  11.       template: `
  12.         <div class="title">{{uname}}的商品</div>
  13.       `
  14.     }
  15.     var CartList = {
  16.       props: ['list'],
  17.       template: `
  18.         <div>
  19.           <div :key='item.id' v-for='item in list' class="item">
  20.             <img :src="item.img"/>
  21.             <div class="name">{{item.name}}</div>
  22.             <div class="change">
  23.               <a href="">－</a>
  24.                 # 1. 将输入框中的默认数据动态渲染出来
  25.                 # 2. 输入框失去焦点的时候 更改商品的数量  需要将当前商品的id 传递过来
  26.               <input type="text" class="num" :value='item.num' @blur='changeNum(item.id, $event)'/>
  27.               <a href="">＋</a>
  28.             </div>
  29.             <div class="del" @click='del(item.id)'>×</div>
  30.           </div>
  31.         </div>
  32.       `,
  33.       methods: {
  34.         changeNum: function(id, event){
  35.           # 3 子组件中不推荐操作数据  因为别的组件可能也引用了这些数据
  36.           #  把这些数据传递给父组件 让父组件处理这些数据
  37.           this.$emit('change-num', {
  38.             id: id,
  39.             num: event.target.value
  40.           });
  41.         },
  42.         del: function(id){
  43.           // 把id传递给父组件
  44.           this.$emit('cart-del', id);
  45.         }
  46.       }
  47.     }
  48.     var CartTotal = {
  49.       props: ['list'],
  50.       template: `
  51.         <div class="total">
  52.           <span>总价：{{total}}</span>
  53.           <button>结算</button>
  54.         </div>
  55.       `,
  56.       computed: {
  57.         total: function() {
  58.           // 计算商品的总价
  59.           var t = 0;
  60.           this.list.forEach(item => {
  61.             t += item.price * item.num;
  62.           });
  63.           return t;
  64.         }
  65.       }
  66.     }
  67.     Vue.component('my-cart',{
  68.       data: function() {
  69.         return {
  70.           uname: '张三',
  71.           list: [{
  72.             id: 1,
  73.             name: 'TCL彩电',
  74.             price: 1000,
  75.             num: 1,
  76.             img: 'img/a.jpg'
  77.           }]
  78.       },
  79.       template: `
  80.         <div class='cart'>
  81.           <cart-title :uname='uname'></cart-title>
  82.             # 4  父组件中接收子组件传递过来的数据 
  83.           <cart-list :list='list' @change-num='changeNum($event)' @cart-del='delCart($event)'></cart-list>
  84.           <cart-total :list='list'></cart-total>
  85.         </div>
  86.       `,
  87.       components: {
  88.         'cart-title': CartTitle,
  89.         'cart-list': CartList,
  90.         'cart-total': CartTotal
  91.       },
  92.       methods: {
  93.         changeNum: function(val) {
  94.           //4.1 根据子组件传递过来的数据，跟新list中对应的数据
  95.           this.list.some(item=>{
  96.             if(item.id == val.id) {
  97.               item.num = val.num;
  98.               // 终止遍历
  99.               return true;
  100.             }
  101.           });
  102.         },
  103.         delCart: function(id) {
  104.           // 根据id删除list中对应的数据
  105.           // 1、找到id所对应数据的索引
  106.           var index = this.list.findIndex(item=>{
  107.             return item.id == id;
  108.           });
  109.           // 2、根据索引删除对应数据
  110.           this.list.splice(index, 1);
  111.         }
  112.       }
  113.     });
  114.     var vm = new Vue({
  115.       el: '#app',
  116.       data: {
  118.       }
  119.     });
  121.   </script>

5. 实现组件更新数据功能 下

  • 子组件通过一个标识符来标记对用的用户点击 + - 或者输入框输入的内容
  • 父组件拿到标识符更新对应的组件
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <title>Document</title>
  6.   <style type="text/css">
  7.     .container {
  8.     }
  9.     .container .cart {
  10.       width: 300px;
  11.       margin: auto;
  12.     }
  13.     .container .title {
  14.       background-color: lightblue;
  15.       height: 40px;
  16.       line-height: 40px;
  17.       text-align: center;
  18.       /*color: #fff;*/  
  19.     }
  20.     .container .total {
  21.       background-color: #FFCE46;
  22.       height: 50px;
  23.       line-height: 50px;
  24.       text-align: right;
  25.     }
  26.     .container .total button {
  27.       margin: 0 10px;
  28.       background-color: #DC4C40;
  29.       height: 35px;
  30.       width: 80px;
  31.       border: 0;
  32.     }
  33.     .container .total span {
  34.       color: red;
  35.       font-weight: bold;
  36.     }
  37.     .container .item {
  38.       height: 55px;
  39.       line-height: 55px;
  40.       position: relative;
  41.       border-top: 1px solid #ADD8E6;
  42.     }
  43.     .container .item img {
  44.       width: 45px;
  45.       height: 45px;
  46.       margin: 5px;
  47.     }
  48.     .container .item .name {
  49.       position: absolute;
  50.       width: 90px;
  51.       top: 0;left: 55px;
  52.       font-size: 16px;
  53.     }
  55.     .container .item .change {
  56.       width: 100px;
  57.       position: absolute;
  58.       top: 0;
  59.       right: 50px;
  60.     }
  61.     .container .item .change a {
  62.       font-size: 20px;
  63.       width: 30px;
  64.       text-decoration:none;
  65.       background-color: lightgray;
  66.       vertical-align: middle;
  67.     }
  68.     .container .item .change .num {
  69.       width: 40px;
  70.       height: 25px;
  71.     }
  72.     .container .item .del {
  73.       position: absolute;
  74.       top: 0;
  75.       right: 0px;
  76.       width: 40px;
  77.       text-align: center;
  78.       font-size: 40px;
  79.       cursor: pointer;
  80.       color: red;
  81.     }
  82.     .container .item .del:hover {
  83.       background-color: orange;
  84.     }
  85.   </style>
  86. </head>
  87. <body>
  88.   <div id="app">
  89.     <div class="container">
  90.       <my-cart></my-cart>
  91.     </div>
  92.   </div>
  93.   <script type="text/javascript" src="js/vue.js"></script>
  94.   <script type="text/javascript">
  96.     var CartTitle = {
  97.       props: ['uname'],
  98.       template: `
  99.         <div class="title">{{uname}}的商品</div>
  100.       `
  101.     }
  102.     var CartList = {
  103.       props: ['list'],
  104.       template: `
  105.         <div>
  106.           <div :key='item.id' v-for='item in list' class="item">
  107.             <img :src="item.img"/>
  108.             <div class="name">{{item.name}}</div>
  109.             <div class="change">
  110.               # 1.  + - 按钮绑定事件 
  111.               <a href="" @click.prevent='sub(item.id)'>－</a>
  112.               <input type="text" class="num" :value='item.num' @blur='changeNum(item.id, $event)'/>
  113.               <a href="" @click.prevent='add(item.id)'>＋</a>
  114.             </div>
  115.             <div class="del" @click='del(item.id)'>×</div>
  116.           </div>
  117.         </div>
  118.       `,
  119.       methods: {
  120.         changeNum: function(id, event){
  121.           this.$emit('change-num', {
  122.             id: id,
  123.             type: 'change',
  124.             num: event.target.value
  125.           });
  126.         },
  127.         sub: function(id){
  128.           # 2 数量的增加和减少通过父组件来计算   每次都是加1 和 减1 不需要传递数量   父组件需要一个类型来判断 是 加一 还是减1  以及是输入框输入的数据  我们通过type 标识符来标记 不同的操作   
  129.           this.$emit('change-num', {
  130.             id: id,
  131.             type: 'sub'
  132.           });
  133.         },
  134.         add: function(id){
  135.          # 2 数量的增加和减少通过父组件来计算   每次都是加1 和 减1 不需要传递数量   父组件需要一个类型来判断 是 加一 还是减1  以及是输入框输入的数据  我们通过type 标识符来标记 不同的操作
  136.           this.$emit('change-num', {
  137.             id: id,
  138.             type: 'add'
  139.           });
  140.         },
  141.         del: function(id){
  142.           // 把id传递给父组件
  143.           this.$emit('cart-del', id);
  144.         }
  145.       }
  146.     }
  147.     var CartTotal = {
  148.       props: ['list'],
  149.       template: `
  150.         <div class="total">
  151.           <span>总价：{{total}}</span>
  152.           <button>结算</button>
  153.         </div>
  154.       `,
  155.       computed: {
  156.         total: function() {
  157.           // 计算商品的总价
  158.           var t = 0;
  159.           this.list.forEach(item => {
  160.             t += item.price * item.num;
  161.           });
  162.           return t;
  163.         }
  164.       }
  165.     }
  166.     Vue.component('my-cart',{
  167.       data: function() {
  168.         return {
  169.           uname: '张三',
  170.           list: [{
  171.             id: 1,
  172.             name: 'TCL彩电',
  173.             price: 1000,
  174.             num: 1,
  175.             img: 'img/a.jpg'
  176.           },{
  177.             id: 2,
  178.             name: '机顶盒',
  179.             price: 1000,
  180.             num: 1,
  181.             img: 'img/b.jpg'
  182.           },{
  183.             id: 3,
  184.             name: '海尔冰箱',
  185.             price: 1000,
  186.             num: 1,
  187.             img: 'img/c.jpg'
  188.           },{
  189.             id: 4,
  190.             name: '小米手机',
  191.             price: 1000,
  192.             num: 1,
  193.             img: 'img/d.jpg'
  194.           },{
  195.             id: 5,
  196.             name: 'PPTV电视',
  197.             price: 1000,
  198.             num: 2,
  199.             img: 'img/e.jpg'
  200.           }]
  201.         }
  202.       },
  203.       template: `
  204.         <div class='cart'>
  205.           <cart-title :uname='uname'></cart-title>    
  206.         # 3 父组件通过事件监听   接收子组件的数据  
  207.           <cart-list :list='list' @change-num='changeNum($event)' @cart-del='delCart($event)'></cart-list>
  208.           <cart-total :list='list'></cart-total>
  209.         </div>
  210.       `,
  211.       components: {
  212.         'cart-title': CartTitle,
  213.         'cart-list': CartList,
  214.         'cart-total': CartTotal
  215.       },
  216.       methods: {
  217.         changeNum: function(val) {
  218.           #4 分为三种情况：输入框变更、加号变更、减号变更
  219.           if(val.type=='change') {
  220.             // 根据子组件传递过来的数据，跟新list中对应的数据
  221.             this.list.some(item=>{
  222.               if(item.id == val.id) {
  223.                 item.num = val.num;
  224.                 // 终止遍历
  225.                 return true;
  226.               }
  227.             });
  228.           }else if(val.type=='sub'){
  229.             // 减一操作
  230.             this.list.some(item=>{
  231.               if(item.id == val.id) {
  232.                 item.num -= 1;
  233.                 // 终止遍历
  234.                 return true;
  235.               }
  236.             });
  237.           }else if(val.type=='add'){
  238.             // 加一操作
  239.             this.list.some(item=>{
  240.               if(item.id == val.id) {
  241.                 item.num += 1;
  242.                 // 终止遍历
  243.                 return true;
  244.               }
  245.             });
  246.           }
  247.         }
  248.       }
  249.     });
  250.     var vm = new Vue({
  251.       el: '#app',
  252.       data: {
  254.       }
  255.     });
  257.   </script>
  258. </body>
  259. </html>