【VueJs入门】

一、上手步骤

vue.js和jquery一样，只要引入vue.js就可以了。

1、创建一个Vue实例： 先引入Vue.js文件，然后new一个Vue的实例即可。如下面的代码，通过<script src="./vue.js"></script>引入，然后在<script>标签中创建实例

2、挂载 在Vue的实例里，通过传递的el属性

3、单向/双向绑定 data属性里的变量 = html标签里的{{}} = input标签里的v-model

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.     <script src="./vue.js"></script>
  4. <body>
  5. <div id="app">
  6.     <input v-model="test"/>
  7.     {{test}}
  8. </div>
  9. <script>
  10.     new Vue({   //创建一个Vue的实例
  11.         el: "#app", //挂载点是id="app"的地方
  12.         data: {     //数据
  13.             test: "abc"     //变量test
  14.         }
  15.     })
  16. </script>
  17. </body>
  18. </html>

二、案例(DEMO控制)

  1. 案例说明：
    1. 单个dom的添加/删除/显示/隐藏——变量控
  2. 2. 多个在显示上互斥的dom（如登录时的提示）—— 用１个变量去控制
  3. 3. 多个同类型dom（用v-for来动态生成）

示例页面

代码：

  1.  1 <html lang="en">
  2.  2     <script src="./vue.js"></script>
  3.  3 <body>
  4.  4 <div id="app">
  5.  5     <p>
  6.  6         点击按钮切换显示的图标
  7.  7     </p>
  8.  8     <input type="button" v-on:click="set1" v-if="data1" value="【一个图标】"/>
  9.  9     <input type="button" v-on:click="set1" v-if="!data1" value="另外一个图标"/>
  10. 10     <p>————————————————————————————</p>
  11. 11     <p>点击不同按钮决定显示什么</p>
  12. 12     <input type="button" @click="set2('baidu')" value="百度">
  13. 13     <input type="button" @click="set2('qq')" value="腾讯">
  14. 14     <input type="button" @click="set2('taobao')" value="淘宝">
  15. 15     <button @click="set2">什么都不显示</button>
  16. 16     <p>
  17. 17         <a href="http://www.baidu.com" target="_blank" v-if="data2=='baidu'">百度</a>
  18. 18         <a href="http://www.qq.com" target="_blank" v-if="data2=='qq'">腾讯</a>
  19. 19         <a href="http://www.taobao.com" target="_blank" v-if="data2=='taobao'">淘宝</a>
  20. 20     </p>
  21. 21     <p>————————————————————————————</p>
  22. 22     <p>
  23. 23         同类型dom，典型的是表格，类似的有li。<br>
  24. 24         <button @click="set3">点击添加内容</button>
  25. 25     </p>
  26. 26     <ul>
  27. 27         <li v-for="i in data3">{{i}}</li>
  28. 28     </ul>
  29. 29 </div>
  30. 30 <script>
  31. 31     new Vue({   //创建一个Vue的实例
  32. 32         el: "#app", //挂载点是id="app"的地方
  33. 33         data: {
  34. 34             data1: true,
  35. 35             data2: "",
  36. 36             data3: [1]
  37. 37         },
  38. 38         methods: {
  39. 39             set1: function () {
  40. 40                 this.data1 = !this.data1;
  41. 41             },
  42. 42             set2: function (arg) {
  43. 43                 this.data2 = arg;
  44. 44             },
  45. 45             set3: function (arg) {
  46. 46                 this.data3.push(this.data3.length + 1);
  47. 47             }
  48. 48         }
  49. 49     })
  50. 50 </script>
  51. 51 </body>

三、案例（input相关）

微博的注册页面如下图

案例页面

 代码：

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.     <script src="./vue.js"></script>
  4. <body>
  5. <div id="app">
  6.     <p>
  7.         邮箱：<input v-model="mail"/>
  8.     </p>
  9.     <p>
  10.         设置密码：<input type="password" v-model="pw"/>
  11.     </p>
  12.     <p>
  13.         官方注册微博名：<input v-model="name" placeholder="请参考组织/企业/品牌名称"/>
  14.     </p>
  15.     <p>
  16.         所在地：
  17.         <select v-model="province">
  18.             <option value="zhejiang">浙江</option>
  19.             <option value="shanghai">上海</option>
  20.         </select>
  21.         <select v-model="city">
  22.             <option v-for="(val,key) in citys" v-bind:value="key">{{val}}</option>
  23.         </select>
  24.     </p>
  25.     <p>
  26.         验证码：
  27.         <input v-model="verificationCode">
  28.         请输入：1234
  29.     </p>
  30.     <p>
  31.         <input type="button" v-on:click="check" value="提交"/>
  32.         <input type="button" v-on:click="inputDefault" value="默认值"/>
  33.     </p>
  34.     <p style="color:green" v-if="error=='success'">提交成功</p>
  35.     <p style="color:red" v-if="error=='less'">缺少内容</p>
  36.     <p style="color:red" v-if="error=='VerificationCode'">验证码错误</p>
  37. </div>
  38. <script>
  39.     new Vue({   //创建一个Vue的实例
  40.         el: "#app", //挂载点是id="app"的地方
  41.         created: function () {
  42.             this.changeProvince();
  43.         },
  44.         data: {     //数据
  45.             province: "zhejiang",
  46.             mail: "",
  47.             pw: "",
  48.             name: "",
  49.             city: "",
  50.             citys: {},
  51.             provinceWithCity: {
  52.                 zhejiang: {
  53.                     hangzhou: "杭州",
  54.                     shaoxing: "绍兴"
  55.                 },
  56.                 shanghai: {
  57.                     pudong: "浦东区",
  58.                     jingan: "静安区"
  59.                 }
  60.             },
  61.             verificationCode: "",
  62.             error: ""
  63.         },
  64.         methods: {
  65.             changeProvince: function () {
  66.                 this.citys = this.provinceWithCity['zhejiang'];
  67.                 this.$watch('province', function (newVal, oldVal) {
  68.                     this.citys = this.provinceWithCity[newVal];
  69.                 })
  70.             },
  71.             check: function () {    //提交内容检查
  72.                 if (this.mail && this.pw && this.name && this.province && this.city) {
  73.                     if (this.verificationCode === '1234') {
  74.                         this.error = 'success';
  75.                         console.log([this.mail, this.pw, this.name, this.province, this.city]);
  76.                     } else {
  77.                         this.error = 'VerificationCode'
  78.                     }
  79.                 } else {
  80.                     this.error = 'less';
  81.                 }
  82.             },
  83.             inputDefault: function () {
  84.                 this.mail = '123@qq.com';
  85.                 this.pw = '123';
  86.                 this.name = 'abc';
  87.                 this.province = 'zhejiang';
  88.                 this.city = 'hangzhou';
  89.                 this.verificationCode = '1234';
  90.             }
  91.         }
  92.     })
  93. </script>
  94. </body>
  95. </html>

四、案例(表格相关)

  1. 1.表格的核心特点是：类型重复的大量内容。
  2. 2.Vue非常擅长对表格的处理，只需要已知数据，预先设置好格式，即可自动生成数据。
  3. 3.常见表格需求是选择性显示（比如只显示符合条件的项），这点Vue也十分擅长，你只需要设置好条件，Vue在渲染的时候会自动帮你完成

案例页面

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.     <script src="./vue.js"></script>
  4.     <style>
  5.         table {
  6.             border-collapse: collapse;
  7.         }
  8.         th, td {
  9.             border: 1px solid #000;
  10.         }
  11.     </style>
  12. <body>
  13. <div id="app">
  14.     <input type="button" v-on:click="randomData" value="随机生成数据"/>
  15.     <input type="button" v-on:click="yearAbove20" v-if="yearLimit!==20" value="只显示年龄大于20的人"/>
  16.     <input type="button" v-on:click="all" v-if="yearLimit>0" value="显示全部"/>
  17.     <p></p>
  18.     <table>
  19.         <tr>
  20.             <td>序号</td>
  21.             <td>姓名</td>
  22.             <td>年龄</td>
  23.         </tr>
  24.         <tr v-for="(val,key) in datas" v-if="val.year > yearLimit">
  25.             <td>{{val.index}}</td>
  26.             <td>{{val.name}}</td>
  27.             <td v-if="val.year<30">{{val.year}}</td>
  28.             <td v-else>年龄太大了，不告诉你喔</td>
  29.         </tr>
  30.     </table>
  31. </div>
  32. <script>
  33.     new Vue({   //创建一个Vue的实例
  34.         el: "#app", //挂载点是id="app"的地方
  35.         data: {
  36.             datas: [],
  37.             yearLimit: 0
  38.         },
  39.         methods: {
  40.             getName: function () {
  41.                 var familyNames = new Array(
  42.                     "赵", "钱", "孙", "李", "周", "吴", "郑", "王", "冯", "陈",
  43.                     "褚", "卫", "蒋", "沈", "韩", "杨", "朱", "秦", "尤", "许",
  44.                     "何", "吕", "施", "张", "孔", "曹", "严", "华", "金", "魏",
  45.                     "陶", "姜", "戚", "谢", "邹", "喻", "柏", "水", "窦", "章",
  46.                     "云", "苏", "潘", "葛", "奚", "范", "彭", "郎", "鲁", "韦",
  47.                     "昌", "马", "苗", "凤", "花", "方", "俞", "任", "袁", "柳",
  48.                     "酆", "鲍", "史", "唐", "费", "廉", "岑", "薛", "雷", "贺",
  49.                     "倪", "汤", "滕", "殷", "罗", "毕", "郝", "邬", "安", "常",
  50.                     "乐", "于", "时", "傅", "皮", "卞", "齐", "康", "伍", "余",
  51.                     "元", "卜", "顾", "孟", "平", "黄", "和", "穆", "萧", "尹"
  52.                 );
  53.                 var givenNames = new Array(
  54.                     "子璇", "淼", "国栋", "夫子", "瑞堂", "甜", "敏", "尚", "国贤", "贺祥", "晨涛",
  55.                     "昊轩", "易轩", "益辰", "益帆", "益冉", "瑾春", "瑾昆", "春齐", "杨", "文昊",
  56.                     "东东", "雄霖", "浩晨", "熙涵", "溶溶", "冰枫", "欣欣", "宜豪", "欣慧", "建政",
  57.                     "美欣", "淑慧", "文轩", "文杰", "欣源", "忠林", "榕润", "欣汝", "慧嘉", "新建",
  58.                     "建林", "亦菲", "林", "冰洁", "佳欣", "涵涵", "禹辰", "淳美", "泽惠", "伟洋",
  59.                     "涵越", "润丽", "翔", "淑华", "晶莹", "凌晶", "苒溪", "雨涵", "嘉怡", "佳毅",
  60.                     "子辰", "佳琪", "紫轩", "瑞辰", "昕蕊", "萌", "明远", "欣宜", "泽远", "欣怡",
  61.                     "佳怡", "佳惠", "晨茜", "晨璐", "运昊", "汝鑫", "淑君", "晶滢", "润莎", "榕汕",
  62.                     "佳钰", "佳玉", "晓庆", "一鸣", "语晨", "添池", "添昊", "雨泽", "雅晗", "雅涵",
  63.                     "清妍", "诗悦", "嘉乐", "晨涵", "天赫", "玥傲", "佳昊", "天昊", "萌萌", "若萌"
  64.                 );
  65.                 var ran1 = parseInt(100 * Math.random());
  66.                 var ran2 = parseInt(100 * Math.random());
  67.                 return familyNames[ran1] + givenNames[ran2];
  68.             },
  69.             randomData: function () {
  70.                 var data = [];
  71.                 for (var i = 1; i < (5 + 10 * Math.random()); i++) {
  72.                     var obj = {
  73.                         index: i,
  74.                         name: this.getName(),
  75.                         year: parseInt(1 + Math.random() * 50)
  76.                     }
  77.                     data.push(obj)
  78.                 }
  79.                 this.datas = data;
  80.                 console.log(this.datas);
  81.             },
  82.             yearAbove20: function () {
  83.                 this.yearLimit = 20;
  84.             },
  85.             all: function () {
  86.                 this.yearLimit = -1;
  87.             }
  88.         }
  89.     })
  90. </script>
  91. </body>
  92. </html>

五、其它Vue常见功能

1、过滤器功能：

  1. 1. 主要用于文本转换；
  2. 2. 例如获得一个日期对象后，通过过滤器命令自动转为我们要求的日期格式。
  3. 3. {{ message | capitalize }}  message变量被过滤器函数capitalize所处理

2、计算属性：

  1. 1. 更加高级的功能，可以视为过滤器功能的进阶版，适用的方向更多（不仅仅是文本）
  2. 2. 获取一个变量（输入内容）→通过计算函数转换→显示转换结果（输出内容）
  3. 3. 当输入内容变更时，输出内容也会自动随之变更
  4. 4. 利用ES5的getter和setter特性来实现，有缓存特点

3、$watch方法：

  1. 1. 监控变量，当变量改变时触发回调函数；
  2. 2. 例如之前的微博注册demo中，通过检测表示省份的变量的变化，来动态设置表示市的dom

4、class/style绑定：

  1. 1. 通过改变变量，来设置dom的样式的类，或者直接设置样式的属性
  2. 2. <div v-bind:class="{ active: isActive }"></div>
  3. 3. isActive值为true时，dom获得active这个类

5、事件监听：

  1. 1. 通过$emit触发事件和$on响应事件，只在当前Vue实例内有效，因此不会带来干扰；
  2. 2. 用起来非常舒服，适用于一对多和多对一的场景；
  3. 3. 跨组件响应（父子组件通信）时，可以使用global event bus来实现，或者使用插件实现

6、路由功能：

  1. 1. 简单来说，按需加载，而不是一次性全部加载；
  2. 2. 有官方推荐支持使用的的vue-router库；

VueJs开发环境的搭建和讲解初始框架

有关如何搭建vue.js框架我这看了一篇文章，自己也根据它进行搭建环境。

文章地址：vue.js2.0实战(1):搭建开发环境及构建项目

接下来对初始的框架进行讲解，只讲index.html是如何被渲染出来的。

一、启动项目

第一步：cmd进入项目文件里，运行npm run dev  启动项目    这里说明启动端口号是8080

第二步：往页面输入：localhost:8080

二、解析渲染步骤

先看整体框架样式和index.html：

从上面我们可以看出，index的body中只有一个id为app的div，那是如何被渲染的呢。一步一步寻找

 第一步：main.js

main.js是我们的入口文件，主要作用是初始化vue实例并使用需要的插件。

这里new Vue代表新建vue对象

  el官方解释：为实例提供挂载元素。值可以是 CSS 选择符，或实际 HTML 元素，或返回 HTML 元素的函数。

这里就通过index.html中的<div id="app"><div>中的id=“app”和这里的“#app”进行挂载。

  components:代表组件。这里是'App',这说明。首先页面肯定有<app></app>这样的标签，同时有个组建为‘App.Vue‘文件

这个地方我思考好久，才明白，首先App.vue是有的，因为上面已经import导入了，但index.html中并没有<app></App>标签

  template：代表模板。官方解释：模板将会替换挂载的元素。挂载元素的内容都将被忽略。

也就是说:template: '<App/>' 表示用<app></app>替换index.html里面的<div id="app"></div>

那到底是不是这样，我们先把main中components这行注释掉：

再看页面：发现里面就有一个<app></app>标签。这样那么逻辑就通了。

这样mian.js就通了，那通过components: { App },我们来看App.vue

  第二步：App.vue

首先一个正常的vue结尾的文件里，一般包含三部分:<template>,<script>,<style>

这里面的<img>标签，就代表页面的vue的logo,它下面又有一个组件<HellWord>

我们只要在进入到HellWord.vue中明白了。

第三步：HellWord.vue

这样一来，页面所渲染的东西都找到了，其实并不复杂，只是在main.js稍微绕了个弯。

自己也是一边学一边写，有错的地方或者有更好的解释也希望大家予以指点。

VueJs(3)---V-指令(1)

一、语法

v- 指令是带有v-的特殊属性

  1. v-if 条件渲染
  2. v-show
  3. v-else (必须在v-if/v-else-if/v-show指令后)
  4. v-else-if (v-if/v-else-if后)
  5. v-for (遍历)
  6. v-html (绑定HTML属性中的值)   (本篇先讲这6个)
  7. v-bind (响应更新HTML特性，绑定自定义属性，如绑定某个class元素或style)
  8. v-on (监听指定元素的dom事件)
  9. v-model (内置的双向数据绑定，用在表单控件，绑定的value通常是静态字符串)
  10. v-cloak 关于vuejs页面闪烁{{message}}
  11. v-once 只渲染元素和组件一次，随后的重新渲染,元素/组件及其所有的子节点将被视为静态内容并跳过

v-text和v-html

v-test

  1. <span v-text="msg"></span>
  2. <!-- 和下面的一样 -->
  3. <span>{{msg}}</span>

v-html :如果你的数据是“<h1>标题文字<h1>"那么它会解析成下面的，v-test永远是按文本输出。

v-show、v-if、v-else、v-else-if

v-show

根据表达式之真假值，切换元素的 display CSS 属性。

  1. <h1 v-show="ok">Hello!</h1>

不同的是带有 v-show 的元素始终会被渲染并保留在 DOM 中。v-show 只是简单地切换元素的 CSS 属性 display

   注意，v-show 不支持 <template> 元素，也不支持 v-else

v-if

根据表达式的值的真假条件渲染元素。在切换时元素及它的数据绑定 / 组件被销毁并重建。如果元素是 <template> ，将提出它的内容作为条件块。

  1. <h1 v-if="ok">Yes</h1>
  2. <!--也可以和v-else一起用-->
  3. <h1 v-if="ok">Yes</h1>
  4. <h1 v-else>No</h1>

在 <template> 元素上使用 v-if 条件渲染分组

因为 v-if 是一个指令，所以必须将它添加到一个元素上。但是如果想切换多个元素呢？此时可以把一个 <template> 元素当做不可见的包裹元素，并在上面使用 v-if。最终的渲染结果将不包含 <template> 元素。

  1. <template v-if="ok">
  2.   <h1>Title</h1>
  3.   <p>Paragraph 1</p>
  4.   <p>Paragraph 2</p>
  5. </template>

v-else

你可以使用 v-else 指令来表示 v-if 的“else 块

  1. <div v-if="Math.random() > 0.5">
  2.   Now you see me
  3. </div>
  4. <div v-else>
  5.   Now you don't
  6. </div>

注意：v-else 元素必须紧跟在带 v-if 或者 v-else-if 的元素的后面，否则它将不会被识别。

v-else-if

v-else-if，顾名思义，充当 v-if 的“else-if 块”，可以连续使用

  1. <div v-if="type === 'A'">
  2.   A
  3. </div>
  4. <div v-else-if="type === 'B'">
  5.   B
  6. </div>
  7. <div v-else>
  8.   Not A/B/C
  9. </div>

v-if vs v-show

   v-if 是“真正”的条件渲染，因为它会确保在切换过程中条件块内的事件监听器和子组件适当地被销毁和重建。

   v-if 也是惰性的：如果在初始渲染时条件为假，则什么也不做——直到条件第一次变为真时，才会开始渲染条件块。

相比之下，v-show 就简单得多——不管初始条件是什么，元素总是会被渲染，并且只是简单地基于 CSS 进行切换。

一般来说，v-if 有更高的切换开销，而 v-show 有更高的初始渲染开销。因此，如果需要非常频繁地切换，则使用 v-show 较好；如果在运行时条件很少改变，则使用 v-if 较好。

v-for

v-for需要用特定语法：alias in expression 为当前遍历的元素提供别名

  1. <!--常见的四种用法-->
  2. <div v-for="item in items">  {{ item.text }}</div>
  3. <div v-for="(item, index) in items"></div>
  4. <div v-for="(val, key) in object"></div>
  5. <div v-for="(val, key, index) in object"></div>

   v-for 默认行为试着不改变整体，而是替换元素。迫使其重新排序的元素，你需要提供一个 key 的特殊属性

  1. <div v-for="item in items" :key="item.id">
  2.   {{ item.text }}
  3. </div>

案例官网：v-for列表渲染

key

当 Vue.js 用 v-for 正在更新已渲染过的元素列表时，它默认用“就地复用”策略。如果数据项的顺序被改变，Vue 将不会移动 DOM 元素来匹配数据项的顺序， 而是简单复用此处每个元素，并且确保它在特定索引下显示已被渲染过的每个元素。这个类似 Vue 1.x 的 track-by="$index"

为了给 Vue 一个提示，以便它能跟踪每个节点的身份，从而重用和重新排序现有元素，你需要为每项提供一个唯一 key 属性。理想的 key 值是每项都有的且唯一的 id。这个特殊的属性相当于 Vue 1.x 的 track-by ，但它的工作方式类似于一个属性，所以你需要用 v-bind 来绑定动态值 (在这里使用简写)

  1. <div v-for="item in items" :key="item.id">
  2.   <!-- 内容 -->
  3. </div>

注意事项

由于 JavaScript 的限制，Vue 不能检测以下变动的数组：

  1. 当你利用索引直接设置一个项时，例如：vm.items[indexOfItem] = newValue
  2. 当你修改数组的长度时，例如：vm.items.length = newLength

举个例子：

  1. var vm = new Vue({
  2.   data: {
  3.     items: ['a', 'b', 'c']
  4.   }
  5. })
  6. vm.items[1] = 'x'  <!--不是响应性的-->
  7. vm.items.length = 2 <!-- 不是响应性的-->

为了解决第一类问题，以下两种方式都可以实现和 vm.items[indexOfItem] = newValue 相同的效果，同时也将触发状态更新：

  1. <!-- Vue.set-->
  2. Vue.set(vm.items, indexOfItem, newValue)
  3. <!-- Array.prototype.splice-->
  4. vm.items.splice(indexOfItem, 1, newValue)

你也可以使用 vm.$set 实例方法，该方法是全局方法 Vue.set 的一个别名

  1. vm.$set(vm.items, indexOfItem, newValue)

为了解决第二类问题，你可以使用 splice：

  1. vm.items.splice(newLength)

   对象更改检测注意事项

还是由于 JavaScript 的限制，Vue 不能检测对象属性的添加或删除

  1. var vm = new Vue({
  2.   data: {
  3.     a: 1
  4.   }
  5. })
  6. <!-- `vm.a` 现在是响应式的-->
  7. vm.b = 2
  8. <!--vm.b` 不是响应式的-->

对于已经创建的实例，Vue 不能动态添加根级别的响应式属性。但是，可以使用 Vue.set(object, key, value) 方法向嵌套对象添加响应式属性。例如，对于：

  1. var vm = new Vue({
  2.   data: {
  3.     userProfile: {
  4.       name: 'Anika'
  5.     }}})
  6. <!--你可以添加一个新的 age 属性到嵌套的 userProfile 对象-->
  7. Vue.set(vm.userProfile, 'age', 27)

你还可以使用 vm.$set 实例方法，它只是全局 Vue.set 的别名

  1. vm.$set(vm.userProfile, 'age', 27)

显示过滤/排序结果

v-for with v-if

当它们处于同一节点，v-for 的优先级比 v-if 更高，这意味着 v-if 将分别重复运行于每个 v-for 循环中。当你想为仅有的_一些_项渲染节点时，这种优先级的机制会十分有用，如下

  1. <li v-for="todo in todos" v-if="!todo.isComplete">
  2.   {{ todo }}
  3. </li>
  4. <!--上面的代码只传递了未完成的 todos。-->

而如果你的目的是有条件地跳过循环的执行，那么可以将 v-if 置于外层元素 (或 <template>)上。如

  1. <ul v-if="todos.length">
  2.   <li v-for="todo in todos">
  3.     {{ todo }}
  4.   </li>
  5. </ul>
  6. <p v-else>No todos left!</p>

一个组件的 v-for

在自定义组件里，你可以像任何普通元素一样用 v-for

  1. <my-component v-for="item in items" :key="item.id"></my-component>

2.2.0+ 的版本里，当在组件中使用 v-for 时，key 现在是必须的。

然而，任何数据都不会被自动传递到组件里，因为组件有自己独立的作用域。为了把迭代数据传递到组件里，我们要用 props

完整例子

  1. <div id="todo-list-example">
  2.   <input
  3.     v-model="newTodoText"
  4.     v-on:keyup.enter="addNewTodo"
  5.     placeholder="Add a todo"
  6.   >
  7.   <ul>
  8.     <li
  9.       is="todo-item"
  10.       v-for="(todo, index) in todos"
  11.       v-bind:key="todo.id"
  12.       v-bind:title="todo.title"
  13.       v-on:remove="todos.splice(index, 1)"  <!--删除一个元素-->
  14.     ></li>
  15.   </ul>
  16. </div>

组件

  1. Vue.component('todo-item', {
  2.   template: '\
  3.     <li>\
  4.       {{ title }}\                     <!--z这里有两个地方不太明白1："/"是什么意思。 2：这里的remove是什么意思，是调用上面的remove吗？求解。-->
  5.       <button v-on:click="$emit(\'remove\')">X</button>\
  6.     </li>\
  7.   ',
  8.   props: ['title']
  9. })
  10.  
  11. new Vue({
  12.   el: '#todo-list-example',
  13.   data: {
  14.     newTodoText: '',
  15.     todos: [
  16.       {
  17.         id: 1,
  18.         title: 'Do the dishes',
  19.       },
  20.       {
  21.         id: 2,
  22.         title: 'Take out the trash',
  23.       },
  24.       {
  25.         id: 3,
  26.         title: 'Mow the lawn'
  27.       }
  28.     ],
  29.     nextTodoId: 4
  30.   },
  31.   methods: {
  32.     addNewTodo: function () {
  33.       this.todos.push({      <!--push代表末尾添加-->
  34.         id: this.nextTodoId++,
  35.         title: this.newTodoText
  36.       })
  37.       this.newTodoText = ''
  38.     }
  39.   }
  40. })

注意这里的 is="todo-item" 属性。这种做法在使用 DOM 模板时是十分必要的，因为在 <ul> 元素内只有 <li> 元素会被看作有效内容。

动态效果看官网：一个组件的v-for

V-model指令

摘要

  限制：

v-model只能用在：<input>    <select>    <textarea>  <components>

修饰符

  • .lazy - 取代 input 监听 change 事件
  • .number - 输入字符串转为数字
  • .trim - 输入首尾空格过滤

基础用法

v-model 会忽略所有表单元素的 value、checked、selected 特性的初始值而总是将 Vue 实例的数据作为数据来源。你应该通过 JavaScript 在组件的 data 选项中声明初始值。

文本

  1. <input v-model="message" placeholder="edit me">
  2. <p>Message is: {{ message }}</p>

多行文本

  1. <span>Multiline message is:</span>
  2. <p style="white-space: pre-line;">{{ message }}</p>
  3. <br>
  4. <textarea v-model="message" placeholder="add multiple lines"></textarea>

复选框

 单个复选框，绑定到布尔值

  1. <input type="checkbox" id="checkbox" v-model="checked">
  2. <label for="checkbox">{{ checked }}</label>

多个复选框，绑定到同一个数组

  1. <div id='example-3'>
  2.   <input type="checkbox" id="jack" value="Jack" v-model="checkedNames">
  3.   <label for="jack">Jack</label>
  4.   <input type="checkbox" id="john" value="John" v-model="checkedNames">
  5.   <label for="john">John</label>
  6.   <input type="checkbox" id="mike" value="Mike" v-model="checkedNames">
  7.   <label for="mike">Mike</label>
  8.   <br>
  9.   <span>Checked names: {{ checkedNames }}</span>
  10. </div>
  11. new Vue({
  12.   el: '#example-3',
  13.   data: {
  14.     checkedNames: []
  15.   }
  16. })

单选按钮

  1. <div id="example-4">
  2.   <input type="radio" id="one" value="One" v-model="picked">
  3.   <label for="one">One</label>
  4.   <br>
  5.   <input type="radio" id="two" value="Two" v-model="picked">
  6.   <label for="two">Two</label>
  7.   <br>
  8.   <span>Picked: {{ picked }}</span>
  9. </div>

选择框

单选时

  1. <div id="example-5">
  2.   <select v-model="selected">
  3.     <option disabled value="">请选择</option>
  4.     <option>A</option>
  5.     <option>B</option>
  6.     <option>C</option>
  7.   </select>
  8.   <span>Selected: {{ selected }}</span>
  9. </div>
  10. new Vue({
  11.   el: '#example-5',
  12.   data: {
  13.     selected: ''
  14.   }
  15. })

       注意：如果 v-model 表达式的初始值未能匹配任何选项，<select> 元素将被渲染为“未选中”状态。在 iOS 中，这会使用户无法选择第一个选项。因为这样的情况下，iOS 不会触发 change 事件。因此，更推荐像上面这样提供一个值为空的禁用选项。

    多选时 (绑定到一个数组)

  1. <div id="example-6">
  2.   <select v-model="selected" multiple style="width: 50px;">
  3.     <option>A</option>
  4.     <option>B</option>
  5.     <option>C</option>
  6.   </select>
  7.   <br>
  8.   <span>Selected: {{ selected }}</span>
  9. </div>
  10. new Vue({
  11.   el: '#example-6',
  12.   data: {
  13.     selected: []
  14.   }
  15. })

    用 v-for 渲染的动态选项

  1. <select v-model="selected">
  2.   <option v-for="option in options" v-bind:value="option.value">
  3.     {{ option.text }}
  4.   </option>
  5. </select>
  6. <span>Selected: {{ selected }}</span>
  7. new Vue({
  8.   el: '...',
  9.   data: {
  10.     selected: 'A',
  11.     options: [
  12.       { text: 'One', value: 'A' },
  13.       { text: 'Two', value: 'B' },
  14.       { text: 'Three', value: 'C' }
  15.     ]
  16.   }
  17. })

值绑定

对于单选按钮，复选框及选择框的选项，v-model 绑定的值通常是静态字符串 (对于复选框也可以是布尔值)：

  1. <!--看到这里上面的你都应该明白了-->
    <!-- 当选中时，`picked` 为字符串 "a" -->
  2. <input type="radio" v-model="picked" value="a">
  3.  
  4. <!-- `toggle` 为 true 或 false -->
  5. <input type="checkbox" v-model="toggle">
  6.  
  7. <!-- 当选中第一个选项时，`selected` 为字符串 "abc" -->
  8. <select v-model="selected">
  9.   <option value="abc">ABC</option>
  10. </select>

 思考：有时我们可能想把值绑定到 Vue 实例的一个动态属性上，这时可以用 v-bind 实现，并且这个属性的值可以不是字符串。

修饰符

.lazy

在默认情况下，v-model 在每次 input 事件触发后将输入框的值与数据进行同步 (除了上述输入法组合文字时)。你可以添加 lazy 修饰符，从而转变为使用 change 事件进行同步

  1. <!-- 在“change”时而非“input”时更新 -->
  2. <input v-model.lazy="msg" >

  .number

如果想自动将用户的输入值转为数值类型，可以给 v-model 添加 number 修饰符

  1. <input v-model.number="age" type="number">
  2. <!--这通常很有用，因为即使在 type="number" 时，HTML 输入元素的值也总会返回字符串-->
  3. <!--我想它主要是用来限制用户输入的时候只能是数字-->

 .trim

  1. <!--如果要自动过滤用户输入的首尾空白字符，可以给 v-model 添加 trim 修饰符->
  2. <input v-model.trim="msg">

在组件上使用 v-model

用自定义事件的表单输入组件

讲这个前，首先我们要明白的是：

  1. <input v-model="something">
  2. <!--它其实是个语法糖，而真正的其实如下：-->
  3.  
  4. <input
  5.   v-bind:value="something"
  6.   v-on:input="something = $event.target.value">
  7.  
  8. <!--所以在组件中使用时，它相当于下面的简写-->
  9. <custom-input
  10.   v-bind:value="something"
  11.   v-on:input="something = arguments[0]">
  12. </custom-input>

看了上面我们就明白，父主键是无法直接向子主键传值的，它其实绑定了父主键的click事件。

所以要让组件的 v-model 生效，它应该 (从 2.2.0 起是可配置的)：

  • 接受一个 value prop
  • 在有新的值时触发 input 事件并将新值作为参数

案例：

货币输入的自定义控件，限制最多小数点保留两位

  1. <currency-input v-model="price"></currency-input>

  2. Vue.component('currency-input', {
  3.   template: '\
  4.     <span>\
  5.       $\
  6.       <input\
  7.         ref="input"\
  8.         v-bind:value="value"\
  9.         v-on:input="updateValue($event.target.value)"\
  10.       >\
  11.     </span>\
  12.   ',
  13.   props: ['value'],
  14.   methods: {
  15.     // 不是直接更新值，而是使用此方法来对输入值进行格式化和位数限制
  16.     updateValue: function (value) {
  17.       var formattedValue = value
  18.         // 删除两侧的空格符
  19.         .trim()
  20.         // 保留 2 位小数
  21.         .slice(
  22.           0,
  23.           value.indexOf('.') === -1
  24.             ? value.length
  25.             : value.indexOf('.') + 3
  26.         )
  27.       // 如果值尚不合规，则手动覆盖为合规的值
  28.       if (formattedValue !== value) {
  29.         this.$refs.input.value = formattedValue
  30.       }
  31.       // 通过 input 事件带出数值
  32.       this.$emit('input', Number(formattedValue))
  33.     }
  34.   }
  35. })

最后结果，就你可以没有小数，但如果有小数后面最后只能有两位小数

上面案例我理解的：

  slice方法

  

ref ($refs)用法

ref 有三种用法

1.ref 加在普通的元素上，用this.ref.name 获取到的是dom元素

2.ref 加在子组件上，用this.ref.name 获取到的是组件实例，可以使用组件的所有方法。

3.如何利用v-for 和ref 获取一组数组或者dom 节点

一、ref使用在外面的组件上

HTML 部分

  1. <div id="ref-outside-component" v-on:click="consoleRef">
  2.     <component-father ref="outsideComponentRef">
  3.     </component-father>
  4.     <p>ref在外面的组件上</p>
  5. </div>

js部分

  1. var refoutsidecomponentTem={
  2.         template:"<div class='childComp'><h5>我是子组件</h5></div>"
  3.     };
  4.     var  refoutsidecomponent=new Vue({
  5.         el:"#ref-outside-component",
  6.         components:{
  7.             "component-father":refoutsidecomponentTem
  8.         },
  9.         methods:{
  10.             consoleRef:function () {
  11.                 console.log(this); // #ref-outside-component     vue实例
  12.                 console.log(this.$refs.outsideComponentRef);  // div.childComp vue实例
  13.             }
  14.         }
  15.     });

二、ref使用在外面的元素上

HTML部分

  1. <!--ref在外面的元素上-->
  2. <div id="ref-outside-dom" v-on:click="consoleRef" >
  3.    <component-father>
  4.    </component-father>
  5.    <p  ref="outsideDomRef">ref在外面的元素上</p>
  6. </div>

JS部分

  1. var refoutsidedomTem={
  2.         template:"<div class='childComp'><h5>我是子组件</h5></div>"
  3.     };
  4.     var  refoutsidedom=new Vue({
  5.         el:"#ref-outside-dom",
  6.         components:{
  7.             "component-father":refoutsidedomTem
  8.         },
  9.         methods:{
  10.             consoleRef:function () {
  11.                 console.log(this); // #ref-outside-dom    vue实例
  12.                 console.log(this.$refs.outsideDomRef);  //   <p> ref在外面的元素上</p>
  13.             }
  14.         }
  15.     });

三、ref使用在里面的元素上---局部注册组件

HTML

  1. <!--ref在里面的元素上-->
  2. <div id="ref-inside-dom">
  3.     <component-father>
  4.     </component-father>
  5.     <p>ref在里面的元素上</p>
  6. </div>

JS部分

  1. var refinsidedomTem={
  2.         template:"<div class='childComp' v-on:click='consoleRef'>" +
  3.                        "<h5 ref='insideDomRef'>我是子组件</h5>" +
  4.                   "</div>",
  5.         methods:{
  6.             consoleRef:function () {
  7.                 console.log(this);  // div.childComp   vue实例
  8.                 console.log(this.$refs.insideDomRef);  // <h5 >我是子组件</h5>
  9.             }
  10.         }
  11.     };
  12.     var  refinsidedom=new Vue({
  13.         el:"#ref-inside-dom",
  14.         components:{
  15.             "component-father":refinsidedomTem
  16.         }
  17.     });

四、ref使用在里面的元素上---全局注册组件

HTML

  1. <!--ref在里面的元素上--全局注册-->
  2. <div id="ref-inside-dom-all">
  3.     <ref-inside-dom-quanjv></ref-inside-dom-quanjv>
  4. </div>

JS部分

  1. Vue.component("ref-inside-dom-quanjv",{
  2.         template:"<div class='insideFather'> " +
  3.                     "<input type='text' ref='insideDomRefAll' v-on:input='showinsideDomRef'>" +
  4.                     "  <p>ref在里面的元素上--全局注册 </p> " +
  5.                   "</div>",
  6.         methods:{
  7.             showinsideDomRef:function () {
  8.                 console.log(this); //这里的this其实还是div.insideFather
  9.                 console.log(this.$refs.insideDomRefAll); // <input  type="text">
  10.             }
  11.         }
  12.     });
  13.  
  14.     var refinsidedomall=new Vue({
  15.         el:"#ref-inside-dom-all"
  16.     });

  $emit理解

关于$emit的用法

1、父组件可以使用 props 把数据传给子组件。
   2、子组件可以使用 $emit 触发父组件的自定义事件。

子组件：

  1. <template>
  2.   <div class="train-city">
  3.     <span @click='select(`大连`)'>大连</span>
  4.   </div>
  5. </template>
  6. <script>
  7. export default {
  8.   name:'trainCity',
  9.   methods:{
  10.     select(val) {
  11.       let data = {
  12.         cityname: val
  13.       };
  14.       this.$emit('showCityName',data);//select事件触发后，自动触发showCityName事件
  15.     }
  16.   }
  17. }
  18. </script>

父组件

  1. <template>
  2.     <trainCity @showCityName="updateCity" :index="goOrtoCity"></trainCity> //监听子组件的showCityName事件。
  3. <template>
  4. <script>
  5. export default {
  6.   name:'index',
  7.   data () {
  8.    return {
  9.       toCity:"北京"
  10.     }
  11.   }
  12.   methods:{
  13.     updateCity(data){//触发子组件城市选择-选择城市的事件
  14.       this.toCity = data.cityname;//改变了父组件的值
  15.       console.log('toCity:'+this.toCity)
  16.     }
  17.   }
  18. }
  19. </script>

结果为：toCity: 大连

在找个例子：

  1. <!DOCTYPE html>
  2. <html>
  3.     <head>
  4.         <meta charset="UTF-8">
  5.         <title></title>
  6.     </head>
  7.     <body>
  8.         <div id="counter-event-example">
  9.             <p>{{ total }}</p>
  10.             <button-counter v-on:increment1="incrementTotal"></button-counter>
  11.             <button-counter v-on:increment2="incrementTotal"></button-counter>
  12.         </div>
  13.     </body>
  14.     <script src="vue/vue.min.js"></script>
  15.     <script>
  16.         Vue.component('button-counter',{
  17.             template:'<button v-on:click="increment">{{ counter }}</button>',
  18.             data:function(){
  19.                 return {counter: 0}<!--组件数据就是这样的，函数式的，请注意-->
  20.             },
  21.             methods:{
  22.                 increment:function(){
  23.                     this.counter += 1;
  24.                     this.$emit('increment1',[12,'kkk']);<!--$emit-->
  25.                 }
  26.             }
  27.         });
  28.         new Vue({
  29.             el:'#counter-event-example',
  30.             data:{
  31.                 total:0
  32.             },
  33.             methods:{
  34.                 incrementTotal:function(e){
  35.                     this.total += 1;
  36.                     console.log(e);
  37.                 }
  38.             }
  39.         });
  40.     </script>
  41. </html>

先看组件 button-counter

绑定了事件click————>increment

然后 this.counter += 1; this.$emit('increment1',[12,'kkk']);

这边就是触发事件 increment1，参考文献里面有点乱，这边是不是清晰多了

然后 <button-counter v-on:increment1="incrementTotal"></button-counter>

v-on相当于监听吧，就触发 incrementTotal

输出// [12, "kkk"]

VueJs(5)---V-bind指令

V-bind指令

一、概述

v-bind  主要用于属性绑定，比方你的class属性，style属性，value属性，href属性等等，只要是属性，就可以用v-bind指令进行绑定。

示例：

  1. <!-- 绑定一个属性 -->
  2. <img v-bind:src="data:imageSrc">
  3.  
  4. <!-- 缩写 -->
  5. <img :src="data:imageSrc">
  6.  
  7. <!-- 内联字符串拼接 -->
  8. <img :src="'/path/to/images/' + fileName">
  9.  
  10. <!-- class 绑定 -->
  11. <div :class="{ red: isRed }"></div>
  12. <div :class="[classA, classB]"></div>
  13. <div :class="[classA, { classB: isB, classC: isC }]">
  14.  
  15. <!-- style 绑定 -->
  16. <div :style="{ fontSize: size + 'px' }"></div>
  17. <div :style="[styleObjectA, styleObjectB]"></div>
  18.  
  19. <!-- 绑定一个有属性的对象 -->
  20. <div v-bind="{ id: someProp, 'other-attr': otherProp }"></div>
  21.  
  22. <!-- 通过 prop 修饰符绑定 DOM 属性 -->
  23. <div v-bind:text-content.prop="text"></div>
  24.  
  25. <!-- prop 绑定。“prop”必须在 my-component 中声明。-->
  26. <my-component :prop="someThing"></my-component>
  27.  
  28. <!-- 通过 $props 将父组件的 props 一起传给子组件 -->
  29. <child-component v-bind="$props"></child-component>
  30.  
  31. <!-- XLink -->
  32. <svg><a :xlink:special="foo"></a></svg>

二、绑定 HTML Class

对象语法

我们可以传给 v-bind:class 一个对象，以动态地切换 class

  1. <div v-bind:class="{ active: isActive }"></div>

上面的语法表示 active 这个 class 存在与否将取决于数据属性 isActive 的 truthiness

你可以在对象中传入更多属性来动态切换多个 class。此外，v-bind:class 指令也可以与普通的 class 属性共存。当有如下模板:

  1. <div class="static"
  2.      v-bind:class="{ active: isActive, 'text-danger': hasError }">
  3. </div>

和如下 data

  1. data: {
  2.   isActive: true,
  3.   hasError: false
  4. }

结果渲染为：

  1. <div class="static active"></div>

当 isActive 或者 hasError 变化时，class 列表将相应地更新。例如，如果 hasError 的值为 true，class 列表将变为 "static active text-danger"

 绑定的数据对象不必内联定义在模板里

  1. <div v-bind:class="classObject"></div>
  1. data: {
  2.   classObject: {
  3.     active: true,
  4.     'text-danger': false
  5.   }
  6. }

渲染的结果和上面一样。我们也可以在这里绑定一个返回对象的计算属性。这是一个常用且强大的模式：

  1. <div v-bind:class="classObject"></div>
  1. data: {
  2.   isActive: true,
  3.   error: null
  4. },
  5. computed: {
  6.   classObject: function () {
  7.     return {
  8.       active: this.isActive && !this.error,
  9.       'text-danger': this.error && this.error.type === 'fatal'
  10.     }
  11.   }
  12. }

数组语法

我们可以把一个数组传给 v-bind:class，以应用一个 class 列表

  1. <div v-bind:class="[activeClass, errorClass]"></div>
  1. data: {
  2.   activeClass: 'active',
  3.   errorClass: 'text-danger'
  4. }

渲染为：

  1. <div class="active text-danger"></div>

如果你也想根据条件切换列表中的 class，可以用三元表达式

  1. <div v-bind:class="[isActive ? activeClass : '', errorClass]"></div>

这样写将始终添加 errorClass，但是只有在 isActive 是 truthy 时才添加 activeClass。

不过，当有多个条件 class 时这样写有些繁琐。所以在数组语法中也可以使用对象语法

  1. <div v-bind:class="[{ active: isActive }, errorClass]"></div>

三、用在组件上

当在一个自定义组件上使用 class 属性时，这些类将被添加到该组件的根元素上面。这个元素上已经存在的类不会被覆盖。

例如，如果你声明了这个组件：

  1. Vue.component('my-component', {
  2.   template: '<p class="foo bar">Hi</p>'
  3. })

然后在使用它的时候添加一些 class

  1. <my-component class="baz boo"></my-component>

HTML 将被渲染为:

  1. <p class="foo bar baz boo">Hi</p>

对于带数据绑定 class 也同样适用

  1. <my-component v-bind:class="{ active: isActive }"></my-component>

当 isActive 为 truthy时，HTML 将被渲染成为

  1. <p class="foo bar active">Hi</p>

四、绑定内联样式

对象语法

  v-bind:style 的对象语法十分直观——看着非常像 CSS，但其实是一个 JavaScript 对象。CSS 属性名可以用驼峰式 (camelCase) 或短横线分隔 (kebab-case，记得用单引号括起来) 来命名：

  1. <div v-bind:style="{ color: activeColor, fontSize: fontSize + 'px' }"></div>
  1. data: {
  2.   activeColor: 'red',
  3.   fontSize: 30
  4. }

直接绑定到一个样式对象通常更好，这会让模板更清晰

  1. <div v-bind:style="styleObject"></div>
  1. data: {
  2.   styleObject: {
  3.     color: 'red',
  4.     fontSize: '13px'
  5.   }
  6. }

同样的，对象语法常常结合返回对象的计算属性使用

数组语法

   v-bind:style 的数组语法可以将多个样式对象应用到同一个元素上

  1. <div v-bind:style="[baseStyles, overridingStyles]"></div>

VueJs(6)---V-on指令

V-on指令

一、概述

v-on是用来绑定事件监听器，用在普通元素上时，只能监听原生 DOM 事件。用在自定义元素组件上时，也可以监听子组件触发的自定义事件。

在监听原生 DOM 事件时，方法以事件为唯一的参数。如果使用内联语句，语句可以访问一个 $event 属性：v-on:click="handle('ok', $event)"。

示例

  1. <!-- 方法处理器 -->
  2. <button v-on:click="doThis"></button>
  3.  
  4. <!-- 内联语句 -->
  5. <button v-on:click="doThat('hello', $event)"></button>
  6.  
  7. <!-- 缩写 -->
  8. <button @click="doThis"></button>
  9.  
  10. <!-- 停止冒泡 -->
  11. <button @click.stop="doThis"></button>
  12.  
  13. <!-- 阻止默认行为 -->
  14. <button @click.prevent="doThis"></button>
  15.  
  16. <!-- 阻止默认行为，没有表达式 -->
  17. <form @submit.prevent></form>
  18.  
  19. <!--  串联修饰符 -->
  20. <button @click.stop.prevent="doThis"></button>
  21.  
  22. <!-- 键修饰符，键别名 -->
  23. <input @keyup.enter="onEnter">
  24.  
  25. <!-- 键修饰符，键代码 -->
  26. <input @keyup.13="onEnter">
  27.  
  28. <!-- 点击回调只会触发一次 -->
  29. <button v-on:click.once="doThis"></button>
  30.  
  31. <!-- 对象语法 (2.4.0+) -->
  32. <button v-on="{ mousedown: doThis, mouseup: doThat }"></button>

在子组件上监听自定义事件 (当子组件触发“my-event”时将调用事件处理器)

  1. <my-component @my-event="handleThis"></my-component>
  2.  
  3. <!-- 内联语句 -->
  4. <my-component @my-event="handleThis(123, $event)"></my-component>
  5.  
  6. <!-- 组件中的原生事件 -->
  7. <my-component @click.native="onClick"></my-component>

二、时间处理

1、 监听事件

可以用 v-on 指令监听 DOM 事件，并在触发时运行一些 JavaScript 代码

示例

  1. <div id="example-1">
  2.   <button v-on:click="counter += 1">Add 1</button>
  3.   <p>The button above has been clicked {{ counter }} times.</p>
  4. </div>
  1. var example1 = new Vue({
  2.   el: '#example-1',
  3.   data: {
  4.     counter: 0
  5.   }
  6. })

 结果：每点击一次按钮，p标签的counter就加1

2、事件处理方法

然而许多事件处理逻辑会更为复杂，所以直接把 JavaScript 代码写在 v-on 指令中是不可行的。因此 v-on 还可以接收一个需要调用的方法名称。

 示例

  1. <div id="example-2">
  2.   <!-- `greet` 是在下面定义的方法名 -->
  3.   <button v-on:click="greet">Greet</button>
  4. </div>
  1. var example2 = new Vue({
  2.   el: '#example-2',
  3.   data: {
  4.     name: 'Vue.js'
  5.   },
  6.   // 在 `methods` 对象中定义方法
  7.   methods: {
  8.     greet: function (event) {
  9.       // `this` 在方法里指向当前 Vue 实例
  10.       alert('Hello ' + this.name + '!')
  11.       // `event` 是原生 DOM 事件
  12.       if (event) {
  13.         alert(event.target.tagName)
  14.       }
  15.     }
  16.   }
  17. })
  18.  
  19. // 也可以用 JavaScript 直接调用方法
  20. example2.greet() // => 'Hello Vue.js!'

 结果：当点击Green按钮，会先后弹出两个提示框

3、内联处理器中的方法

除了直接绑定到一个方法，也可以在内联 JavaScript 语句中调用方法

  1. <div id="example-3">
  2.   <button v-on:click="say('hi')">Say hi</button>
  3.   <button v-on:click="say('what')">Say what</button>
  4. </div>
  1. new Vue({
  2.   el: '#example-3',
  3.   methods: {
  4.     say: function (message) {
  5.       alert(message)
  6.     }
  7.   }
  8. })

结果：当我点击Say hi 按钮会弹如下提示框。

有时也需要在内联语句处理器中访问原始的 DOM 事件。可以用特殊变量 $event 把它传入方法

  1. <button v-on:click="warn('Form cannot be submitted yet.', $event)">
  2.   Submit
  3. </button>
  1. // ...
  2. methods: {
  3.   warn: function (message, event) {
  4.     // 现在我们可以访问原生事件对象
  5.     if (event) event.preventDefault()
  6.     alert(message)
  7.   }
  8. }

4、事件修饰符

在事件处理程序中调用 event.preventDefault() 或 event.stopPropagation() 是非常常见的需求。尽管我们可以在方法中轻松实现这点，但更好的方式是：方法只有纯粹的数据逻辑，而不是去处理 DOM 事件细节。

为了解决这个问题，Vue.js 为 v-on 提供了事件修饰符。之前提过，修饰符是由点开头的指令后缀来表示的。

  1. <!-- 阻止单击事件继续传播 -->
  2. <a v-on:click.stop="doThis"></a>
  3.  
  4. <!-- 提交事件不再重载页面 -->
  5. <form v-on:submit.prevent="onSubmit"></form>
  6.  
  7. <!-- 修饰符可以串联 -->
  8. <a v-on:click.stop.prevent="doThat"></a>
  9.  
  10. <!-- 只有修饰符 -->
  11. <form v-on:submit.prevent></form>
  12.  
  13. <!-- 添加事件监听器时使用事件捕获模式 -->
  14. <!-- 即元素自身触发的事件先在此处处理，然后才交由内部元素进行处理 -->
  15. <div v-on:click.capture="doThis">...</div>
  16.  
  17. <!-- 只当在 event.target 是当前元素自身时触发处理函数 -->
  18. <!-- 即事件不是从内部元素触发的 -->
  19. <div v-on:click.self="doThat">...</div>

 注意：使用修饰符时，顺序很重要；相应的代码会以同样的顺序产生。因此，用 v-on:click.prevent.self 会阻止所有的点击，而 v-on:click.self.prevent 只会阻止对元素自身的点击。

5、按键修饰符

在监听键盘事件时，我们经常需要检查常见的键值。Vue 允许为 v-on 在监听键盘事件时添加按键修饰符：

  1. <!-- 只有在 `keyCode` 是 13 时调用 `vm.submit()` -->
  2. <input v-on:keyup.13="submit">

记住所有的 keyCode 比较困难，所以 Vue 为最常用的按键提供了别名

  1. <!-- 同上 -->
  2. <input v-on:keyup.enter="submit">
  3.  
  4. <!-- 缩写语法 -->
  5. <input @keyup.enter="submit">

全部的按键别名：

  • .enter
  • .tab
  • .delete (捕获“删除”和“退格”键)
  • .esc
  • .space
  • .up
  • .down
  • .left
  • .right

计算属性和侦听器

一、 概述

计算属性

模板内的表达式非常便利，但是设计它们的初衷是用于简单运算的。在模板中放入太多的逻辑会让模板过重且难以维护。例如：

  1. <div id="example">
  2.   {{ message.split('').reverse().join('') }}
  3. </div>

在这个地方，模板不再是简单的声明式逻辑。你必须看一段时间才能意识到，这里是想要显示变量 message 的翻转字符串。当你想要在模板中多次引用此处的翻转字符串时，就会更加难以处理。

所以，对于任何复杂逻辑，你都应当使用计算属性。

基础例子

  1. <div id="example">
  2.   <p>Original message: "{{ message }}"</p>
  3.   <p>Computed reversed message: "{{ reversedMessage }}"</p>
  4. </div>
  1. var vm = new Vue({
  2.   el: '#example',
  3.   data: {
  4.     message: 'Hello'
  5.   },
  6.   computed: {
  7.     // 计算属性的 getter
  8.     reversedMessage: function () {
  9.       // `this` 指向 vm 实例
  10.       return this.message.split('').reverse().join('')
  11.     }
  12.   }
  13. })

    结果：

这里我们声明了一个计算属性 reversedMessage。我们提供的函数将用作属性 vm.reversedMessage 的 getter 函数

  1. console.log(vm.reversedMessage) // => 'olleH'
  2. vm.message = 'Goodbye'
  3. console.log(vm.reversedMessage) // => 'eybdooG'

你可以像绑定普通属性一样在模板中绑定计算属性。Vue 知道 vm.reversedMessage 依赖于 vm.message，因此当 vm.message 发生改变时，所有依赖 vm.reversedMessage 的绑定也会更新。而且最妙的是我们已经以声明的方式创建了这种依赖关系：计算属性的 getter 函数是没有副作用 (side effect) 的，这使它更易于测试和理解。

二、计算属性缓存 vs 方法

你可能已经注意到我们可以通过在表达式中调用方法来达到同样的效果

  1. <p>Reversed message: "{{ reversedMessage() }}"</p>
  1. // 在组件中
  2. methods: {
  3.   reversedMessage: function () {
  4.     return this.message.split('').reverse().join('')
  5.   }
  6. }

我们可以将同一函数定义为一个方法而不是一个计算属性。两种方式的最终结果确实是完全相同的。然而，不同的是计算属性是基于它们的依赖进行缓存的。计算属性只有在它的相关依赖发生改变时才会重新求值。这就意味着只要 message 还没有发生改变，多次访问 reversedMessage 计算属性会立即返回之前的计算结果，而不必再次执行函数。

这也同样意味着下面的计算属性将不再更新，因为 Date.now() 不是响应式依赖

  1. computed: {
  2.   now: function () {
  3.     return Date.now()
  4.   }
  5. }

相比之下，每当触发重新渲染时，调用方法将总会再次执行函数。

我们为什么需要缓存？

假设我们有一个性能开销比较大的的计算属性 A，它需要遍历一个巨大的数组并做大量的计算。然后我们可能有其他的计算属性依赖于 A 。如果没有缓存，我们将不可避免的多次执行 A 的 getter！如果你不希望有缓存，请用方法来替代。

三、计算属性 vs 侦听属性

Vue 提供了一种更通用的方式来观察和响应 Vue 实例上的数据变动：侦听属性。当你有一些数据需要随着其它数据变动而变动时，你很容易滥用 watch——特别是如果你之前使用过 AngularJS。然而，通常更好的做法是使用计算属性而不是命令式的 watch 回调。

细想一下这个例子

  1. <div id="demo">{{ fullName }}</div>
  1. var vm = new Vue({
  2.   el: '#demo',
  3.   data: {
  4.     firstName: 'Foo',
  5.     lastName: 'Bar',
  6.     fullName: 'Foo Bar'
  7.   },
  8.   watch: {
  9.     firstName: function (val) {
  10.       this.fullName = val + ' ' + this.lastName
  11.     },
  12.     lastName: function (val) {
  13.       this.fullName = this.firstName + ' ' + val
  14.     }
  15.   }
  16. })

上面代码是命令式且重复的。将它与计算属性的版本进行比较：

  1. var vm = new Vue({
  2.   el: '#demo',
  3.   data: {
  4.     firstName: 'Foo',
  5.     lastName: 'Bar'
  6.   },
  7.   computed: {
  8.     fullName: function () {
  9.       return this.firstName + ' ' + this.lastName
  10.     }
  11.   }
  12. })

是不是好多了。我的理解监听一般用于单个对象比较合适，如果同时要监听多个数据的变化这个时候用监听显得非常麻烦，而用计算方式显的轻松很多。

四、计算属性的 setter

计算属性默认只有 getter ，不过在需要时你也可以提供一个 setter

  1. // ...
  2. computed: {
  3.   fullName: {
  4.     // getter
  5.     get: function () {
  6.       return this.firstName + ' ' + this.lastName
  7.     },
  8.     // setter
  9.     set: function (newValue) {
  10.       var names = newValue.split(' ')
  11.       this.firstName = names[0]
  12.       this.lastName = names[names.length - 1]
  13.     }
  14.   }
  15. }
  16. // ...

现在再运行 vm.fullName = 'John Doe' 时，setter 会被调用，vm.firstName 和 vm.lastName 也会相应地被更新。

五、侦听器

虽然计算属性在大多数情况下更合适，但有时也需要一个自定义的侦听器。这就是为什么 Vue 通过 watch 选项提供了一个更通用的方法，来响应数据的变化。当需要在数据变化时执行异步或开销较大的操作时，这个方式是最有用的。

 例如：

  1. <div id="watch-example">
  2.   <p>
  3.     Ask a yes/no question:
  4.     <input v-model="question">
  5.   </p>
  6.   <p>{{ answer }}</p>
  7. </div>
  1. <!-- 因为 AJAX 库和通用工具的生态已经相当丰富，Vue 核心代码没有重复 -->
  2. <!-- 提供这些功能以保持精简。这也可以让你自由选择自己更熟悉的工具。 -->
  3. <script src="https://cdn.jsdelivr.net/npm/axios@0.12.0/dist/axios.min.js"></script>
  4. <script src="https://cdn.jsdelivr.net/npm/lodash@4.13.1/lodash.min.js"></script>
  5. <script>
  6. var watchExampleVM = new Vue({
  7.   el: '#watch-example',
  8.   data: {
  9.     question: '',
  10.     answer: 'I cannot give you an answer until you ask a question!'
  11.   },
  12.   watch: {
  13.     // 如果 `question` 发生改变，这个函数就会运行
  14.     question: function (newQuestion, oldQuestion) {
  15.       this.answer = 'Waiting for you to stop typing...'
  16.       this.getAnswer()
  17.     }
  18.   },
  19.   methods: {
  20.     // `_.debounce` 是一个通过 Lodash 限制操作频率的函数。
  21.     // 在这个例子中，我们希望限制访问 yesno.wtf/api 的频率
  22.     // AJAX 请求直到用户输入完毕才会发出。想要了解更多关于
  23.     // `_.debounce` 函数 (及其近亲 `_.throttle`) 的知识，
  24.     // 请参考：https://lodash.com/docs#debounce
  25.     getAnswer: _.debounce(
  26.       function () {
  27.         if (this.question.indexOf('?') === -1) {
  28.           this.answer = 'Questions usually contain a question mark. ;-)'
  29.           return
  30.         }
  31.         this.answer = 'Thinking...'
  32.         var vm = this
  33.         axios.get('https://yesno.wtf/api')
  34.           .then(function (response) {
  35.             vm.answer = _.capitalize(response.data.answer)
  36.           })
  37.           .catch(function (error) {
  38.             vm.answer = 'Error! Could not reach the API. ' + error
  39.           })
  40.       },
  41.       // 这是我们为判定用户停止输入等待的毫秒数
  42.       500
  43.     )
  44.   }
  45. })
  46. </script>

结果：当没有输入？号，那么显示如下：

当有?时候会输出“yes”或者“no”

具体案例效果地址：侦听器

在这个示例中，使用 watch 选项允许我们执行异步操作 (访问一个 API)，限制我们执行该操作的频率，并在我们得到最终结果前，设置中间状态。这些都是计算属性无法做到的。

VueJs(8)---组件（注册组件）

组件（注册组件）

一、介绍

组件系统是Vue.js其中一个重要的概念，它提供了一种抽象，让我们可以使用独立可复用的小组件来构建大型应用，任意类型的应用界面都可以抽象为一个组件树

那么什么是组件呢？

组件可以扩展HTML元素，封装可重用的HTML代码，我们可以将组件看作自定义的HTML元素。

二、如何注册组件

Vue.js的组件的使用有3个步骤：创建组件构造器、注册组件和使用组件。

下面用代码演示这三步

  1. <!DOCTYPE html>
  2. <html>
  3.     <body>
  4.         <div id="app">
  5.             <!-- 注意： #app是Vue实例挂载的元素，应该在挂载元素范围内使用组件-->
  6.             <my-component></my-component>
  7.         </div>
  8.     </body>
  9.    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
  10.     <script>
  11.         <!-- 1.创建一个组件构造器 -->
  12.         var myComponent = Vue.extend({
  13.             template: '<div>This is my first component!</div>'
  14.         })
  15.  
  16.         <!-- 2.注册组件，并指定组件的标签，组件的HTML标签为<my-component> -->
  17.         Vue.component('my-component', myComponent)
  18.  
  19.        <!-- 3.通过id=app进行挂载 -->
  20.         new Vue({
  21.             el: '#app'
  22.         });
  23.  
  24.     </script>
  25. </html>

运行结果如下：

一、 全局注册和局部注册

调用Vue.component()注册组件时，组件的注册是全局的，这意味着该组件可以在任意Vue示例下使用。
如果不需要全局注册，或者是让组件使用在其它组件内，可以用选项对象的components属性实现局部注册。

 我自己的理解只要是component就代表全局组件，components代表局部组件

上面的示例可以改为局部注册的方式：

  1. <!DOCTYPE html>
  2. <html>
  3.     <body>
  4.         <div id="app">
  5.             <!-- 3. my-component只能在#app下使用-->
  6.             <my-component></my-component>
  7.         </div>
  8.     </body>
  9.     <script src="js/vue.js"></script>
  10.     <script>
  11.         // 1.创建一个组件构造器
  12.         var myComponent = Vue.extend({
  13.             template: '<div>This is my first component!</div>'
  14.         })
  15.  
  16.         new Vue({
  17.             el: '#app',
  18.             components: {
  19.            // 2. 将myComponent组件注册到Vue实例下
  20.                 'my-component' : myComponent
  21.             }
  22.         });
  23.     </script>
  24. </html>

由于my-component组件是注册在#app元素对应的Vue实例下的，所以它不能在其它Vue实例下使用。

  1. <div id="app2">
  2.     <!-- 不能使用my-component组件，因为my-component是一个局部组件，它属于#app-->
  3.     <my-component></my-component>
  4. </div>
  5.  
  6. <script>
  7.     new Vue({
  8.         el: '#app2'
  9.     });
  10. </script>

二、组件注册语法糖

以上组件注册的方式有些繁琐，Vue.js为了简化这个过程，提供了注册语法糖

  1. // 全局注册，my-component1是标签名称
  2. Vue.component('my-component1',{
  3.     template: '<div>This is the first component!</div>'
  4. })
  5.  
  6. var vm1 = new Vue({
  7.     el: '#app1'
  8. })

Vue.component()的第1个参数是标签名称，第2个参数是一个选项对象，使用选项对象的template属性定义组件模板。
使用这种方式，Vue在背后会自动地调用Vue.extend()。

components实现局部注册

  1. var vm2 = new Vue({
  2.     el: '#app2',
  3.     components: {
  4.         // 局部注册，my-component2是标签名称
  5.         'my-component2': {
  6.             template: '<div>This is the second component!</div>'
  7.         },
  8.         // 局部注册，my-component3是标签名称
  9.         'my-component3': {
  10.             template: '<div>This is the third component!</div>'
  11.         }
  12.     }
  13. })

三、父组件和子组件

我们可以在组件中定义并使用其他组件，这就构成了父子组件的关系。

  1. <!DOCTYPE html>
  2. <html>
  3.     <body>
  4.         <div id="app">
  5.             <parent-component>
  6.             </parent-component>
  7.         </div>
  8.     </body>
  9.   <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
  10.   <script>
  11.  
  12.         var Child = Vue.extend({
  13.             template: '<p>This is a child component!</p>'
  14.         })
  15.  
  16.         var Parent = Vue.extend({
  17.             // 在Parent组件内使用<child-component>标签
  18.             template :'<p>This is a Parent component</p><child-component></child-component>',
  19.             components: {
  20.              // 局部注册Child组件，该组件只能在Parent组件内使用
  21.                 'child-component': Child
  22.             }
  23.         })
  24.  
  25.         // 全局注册Parent组件
  26.         Vue.component('parent-component', Parent)
  27.  
  28.         new Vue({
  29.             el: '#app'
  30.         })
  31.  
  32.     </script>
  33. </html>

这段代码的运行结果如下

四、使用script或template标签

尽管语法糖简化了组件注册，但在template选项中拼接HTML元素比较麻烦，这也导致了HTML和JavaScript的高耦合性。
庆幸的是，Vue.js提供了两种方式将定义在JavaScript中的HTML模板分离出来。

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <title>vue组件</title>
  7.     <script src="js/vue.js"></script>
  8. </head>
  9.  
  10. <body>
  11.     <div id="app1">
  12.         <my-com></my-com>
  13.         <my-com1></my-com1>
  14.     </div>
  15.  
  16.     <template id="myCom">
  17.         <div>这是template标签构建的组件</div>
  18.     </template>
  19.  
  20.     <script type="text/x-template" id="myCom1">
  21.         <div>这是script标签构建的组件</div>
  22.     </script>
  23.     <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
  24.     <script>
  25.         Vue.component('my-com1', {
  26.             template: '#myCom1'
  27.         });
  28.  
  29.         var app1 = new Vue({
  30.             el: '#app1',
  31.             components: {
  32.                 'my-com': {
  33.                     template: '#myCom'
  34.                 }
  35.             }
  36.         });
  37.     </script>
  38. </body>
  39.  
  40. </html>

 运行结果：

注意：使用<script>标签时，type指定为text/x-template，意在告诉浏览器这不是一段js脚本，浏览器在解析HTML文档时会忽略<script>标签内定义的内容。

在理解了组件的创建和注册过程后，我建议使用<script>或<template>标签来定义组件的HTML模板。
这使得HTML代码和JavaScript代码是分离的，便于阅读和维护。

五、模板的注意事项

1. 以子标签的形式在父组件中使用

  1. <div id="app">
  2.     <parent-component>
  3.         <child-component></child-component>
  4.     </parent-component>
  5. </div>

上面是错误的。为什么这种方式无效呢？因为当子组件注册到父组件时，Vue.js会编译好父组件的模板，模板的内容已经决定了父组件将要渲染的HTML。
<parent-component>…</parent-component>相当于运行时，它的一些子标签只会被当作普通的HTML来执行，<child-component></child-component>不是标准的HTML标签，会被浏览器直接忽视掉

     2.组件的模板只能有一个根元素。下面的情况是不允许的。

  1. template: `<div>这是一个局部的自定义组件，只能在当前Vue实例中使用</div>
  2.             <button>hello</button>`

     3.组件中的data必须是函数

注册组件时传入的配置和创建Vue实例差不多，但也有不同，其中一个就是data属性必须是一个函数。

这是因为如果像Vue实例那样，传入一个对象，由于JS中对象类型的变量实际上保存的是对象的引用，所以当存在多个这样的组件时，会共享数据，导致一个组件中数据的改变会引起其他组件数据的改变。

而使用一个返回对象的函数，每次使用组件都会创建一个新的对象，这样就不会出现共享数据的问题来了。

     4.关于DOM模板的解析

当使用 DOM 作为模版时 (例如，将 el 选项挂载到一个已存在的元素上), 你会受到 HTML 的一些限制，因为 Vue 只有在浏览器解析和标准化 HTML 后才能获取模板内容。尤其像这些元素 <ul>，<ol>，<table>，<select> 限制了能被它包裹的元素，而一些像 <option> 这样的元素只能出现在某些其它元素内部

在自定义组件中使用这些受限制的元素时会导致一些问题，例如

  1. <table>
  2.   <my-row>...</my-row>
  3. </table>

自定义组件 <my-row> 被认为是无效的内容，因此在渲染的时候会导致错误。这时应使用特殊的 is 属性：

  1. <table>
  2.   <tr is="my-row"></tr>
  3. </table>

也就是说，标准HTML中，一些元素中只能放置特定的子元素，另一些元素只能存在于特定的父元素中。比如table中不能放置div，tr的父元素不能div等。所以，当使用自定义标签时，标签名还是那些标签的名字，但是可以在标签的is属性中填写自定义组件的名字。

三、动态组件

有的时候，在不同组件之间进行动态切换是非常有用的，比如在一个多标签的界面里

简单点说：就是几个组件放在一个挂载点下，然后根据父组件的某个变量来决定显示哪个，或者都不显示。

要点：在挂载点使用component标签，然后使用v-bind:is=”组件名”，会自动去找匹配的组件名，如果没有，则不显示

动态组件，先看案例效果：

代码演示：css代码就不复制了，上面案例效果里有。

  1. <script src="https://unpkg.com/vue"></script>
  2.  
  3. <div id="dynamic-component-demo" class="demo">
  4.     <button v-for="tab in tabs" 
                v-bind:key="tab" 
                v-bind:class="['tab-button', { active: currentTab === tab }]" 
                v-on:click="currentTab = tab">{{ tab }}</button>
  5.  
  6.     <component v-bind:is="currentTabComponent" class="tab"></component>
  7. </div>

这里v-bind:key其实可有可无，具体key介绍可以看官网。

这里v-bind:class和v-on:click都是用来为了改变样式用的。

关键是component组件标签。

  1. <script>
  2.     //显示定义了三个组件
  3.     Vue.component('tab-科长', {
  4.         template: '<div>一共有100个科长</div>'
  5.     })
  6.     Vue.component('tab-处长', {
  7.         template: '<div>一种有50个处长</div>'
  8.     })
  9.     Vue.component('tab-局长', {
  10.         template: '<div>一共有10个局长</div>'
  11.     })
  12.  
  13.     new Vue({
  14.         el: '#dynamic-component-demo',
  15.         data: {
  16.             currentTab: '局长',
  17.             tabs: ['科长', '处长', '局长']
  18.         },
  19.     //计算属性，根据currentTab的改变来判断选择哪个组件
  20.         computed: {
  21.             currentTabComponent: function() {
  22.                 return 'tab-' + this.currentTab
  23.             }
  24.         }
  25.     })
  26. </script>

VueJs(1)---操作指南的更多相关文章

  1. TODO：搭建Laravel VueJS SemanticUI

    TODO:搭建Laravel VueJS SemanticUI Laravel是一套简洁.优雅的PHP开发框架(PHP Web Framework).可以让你从面条一样杂乱的代码中解脱出来:它可以帮你 ...

  2. 【项目管理】GitHub使用操作指南

    GitHub使用操作指南 作者:白宁超 2016年10月5日18:51:03> 摘要:GitHub的是版本控制和协作代码托管平台,它可以让你和其他人的项目从任何地方合作.相对于CVS和SVN的联 ...

  3. 一次页面从Jq到Vuejs+PartialView的迁徙

    题外话 本篇分享不能帮助你入门vue,入门的文章也是无意义的,官方文档http://cn.vuejs.org/v2/guide/ 已经写的不能再清晰了.希望我们勇敢的主动地给自己创造实践的机会. 手里 ...

  4. 使用vuejs框架进行列表渲染

    爱编程爱分享,原创文章,转载请注明出处,谢谢!http://www.cnblogs.com/fozero/p/6170706.html 1.通过Script引入Vuejs框架 <script t ...

  5. Vuejs学习笔记1

    首次写vue可能会出现:[Vue warn]: Cannot find element: #app 这是因为你的js在html页面头部引入的原因,自定义js文件要最后引入,因为要先有元素id,vue才 ...

  6. 【vuejs小项目——vuejs2.0版本】单页面搭建

    http://router.vuejs.org/zh-cn/essentials/nested-routes.html 使用嵌套路由开发,这里会出错主要把Vue.use(VueRouter);要进行引 ...

  7. 【vuejs小项目】一、脚手架搭建工作

    一.关于vuejs 这是一个MVVM的前端开发框架,model(数据).viewmode(通讯).view(视图),它吸取了reactjs和angularjs的长处,核心重点在于组件化的设计原则. 我 ...

  8. vuejs的动态过滤

    想要通过vuejs动态过滤(这里动态指得是过滤的条件是动态变化的), 一直没找到好办法, 最蠢的办法当然是两个两个数组,一个作为原始副本数组 一个作为视图数组,这样当过滤条件变化的时候 动态拷贝原始数 ...

  9. 使用 v-cloak 防止页面加载时出现 vuejs 的变量名

    使用 vuejs 做了一个简单的功能页面,逻辑是,页面加载后获取当前的经纬度,然后通过 ajax 从后台拉取附近的小区列表.但是 bug 出现了,在显示小区列表之前,会闪现小区名对应的 vuejs 变 ...

  10. vuejs里封装的和IOS,Android通信模块

    项目需要,在vuejs开发的web项目中与APP进行通信,实现原理和cordova一致.使用WebViewJavascriptBridge. 其实也是通过拦截url scheme,支持ios6往前的系 ...

随机推荐

  1. 大厂SSP的Java学习路线

    现在互联网环境这么差,Java还能学吗? 学Java还能找到工作吗? 大家好呀, 我是程序员回家养猪, 一个专升本, 三段实习经历拿下大厂SSP offer的程序员博主. 关于我的个人经历, 之前文章 ...

  2. 两个新出的 JavaScript 运算符

    在 ECMAScript 2021(ES12)中,JavaScript 引入了新的逻辑赋值操作符 &&= 和 ??=.这些操作符将逻辑运算符与赋值运算符相结合,提供了更加简洁.直观的赋 ...

  3. VMware安装教程---------------------以及Windows,Linux,Apple MAC OS系统安装

    1.什么是VMware虚拟机 VMware虚拟机是一个虚拟机软件,它可以在一台机器上同时运行多个系统,这些系统包括Windows,Linux,Apple os等. 2.虚拟机有什么用 虚拟机的用处很多 ...

  4. php 超过64位进制和10进制的转换

    有时候想把一个很大的数尽量用更少的空间存储起来,那么就可以采用很大的进制来存储它,比如说,一个大于等于10小于等于16数字使用10进制就需要两位,使用16进制就只需要1位,那就等于帮程序省了一位的空间 ...

  5. 网站统计代码v1.0

    var m = {}; var p ={}; var gifUrl = 'http://hm.iwgame.test/v.gif'; (function() { //参数组合类 m = { ck : ...

  6. 数字IC知识点：处理多个时钟

    1. 多时钟域 图1.多时钟域 对于工程师来说,开发含多个时钟(见图1)的设计是一种挑战. 这样的设计中可能有以下任何一个,或者全部类型的时钟关系: 时钟的频率不同 时钟频率相同,但相位不同 以上两种 ...

  7. 用于自然语言处理的循环神经网络RNN

    前一篇:<人工智能模型学习到的知识是怎样的一种存在?> 序言:在人工智能领域,卷积神经网络(CNN)备受瞩目,但神经网络的种类远不止于此.实际上,不同类型的神经网络各有其独特的应用场景.在 ...

  8. JAVA8的computeIfAbsent使用方法

    基础说明 computeIfAbsent 是 Java 8 引入的 Map 接口中的一个默认方法.它允许你以原子操作的方式在给定键不存在时计算其值,并将其添加到映射中.如果该键已经存在,则返回已存在的 ...

  9. Vue脚手架(vue-cli)搭建和目录结构

    环境搭建 1.安装node.npm.webpack 2.安装vue-cli脚手架构建工具,打开命令行工具输入:npm install vue-cli -g,安装完成之后输入 vue -V(注意这里是大 ...

  10. vue3 学习笔记（不断更新中...）(2024.11.13)

    组合式API setup() 11 响应式API ref ref 用于创建响应式数据(通常用来定义 基本类型数据) 在JavaScript代码中,需要使用 .value 来操作数据 let count ...