跟着狂神学Vue

前端核心分析

Vue 的核心库只关注视图层，方便与第三方库或既有项目整合。

HTML + CSS + JS : 视图 ： 给用户看，刷新后台给的数据

网络通信 ： axios

页面跳转 ： vue-router

状态管理：vuex

Vue-UI : ICE , Element UI

Vue概述：

Vue (读音/vju/, 类似于view)是一套用于构建用户界面的渐进式框架，发布于2014年2月。与其它大型框架不同的是，Vue被设计为可以自底向上逐层应用。Vue的核心库只关注视图层，不仅易于上手，还便于与第三方库(如: vue-router: 跳转，vue-resource: 通信，vuex:管理)或既有项目整合。

前端知识体系

想要成为真正的“互联网Java全栈工程师”还有很长的一段路要走，其中“我大前端”是绕不开的一门必修课。本阶段课程的主要目的就是带领我Java后台程序员认识前端、了解前端、掌握前端,为实现成为“互联网Java全栈工程师”再向前迈进一步。

前端三要素

●HTML (结构) :超文本标记语言(Hyper Text Markup Language) ，决定网页的结构和内容
●CSS (表现) :层叠样式表(Cascading Style sheets) ，设定网页的表现样式
●JavaScript (行为) :是一种弱类型脚本语言，其源代码不需经过编译，而是由浏览器解释运行,用于控制网页的行为

结构层（HTML）

略

表现层（CSS）

CSS层叠样式表是一门标记语言,并不是编程语言，因此不可以自定义变量，不可以引用等，换句话说就是不具备任何语法支持，它主要缺陷如下:
●语法不够强大，比如无法嵌套书写，导致模块化开发中需要写很多重复的选择器;
●没有变量和合理的样式复用机制，使得逻辑上相关的属性值必须以字面量的形式重复输出，导致难以维护;
这就导致了我们在工作中无端增加了许多工作量。为了解决这个问题，前端开发人员会使用一种称之为[CSS预处理器]的工具，提供CSS缺失的样式层复用机制、减少冗余代码，提高样式代码的可维护性。大大提高了前端在样式上的开发效率。（例如页面在不同的时候有不同的需求，淘宝在双11和618的样式就会不一样）

CSS预处理器

CSS预处理器定义了一种新的语言，其基本思想是，用一种专门的编程语言，为CSS增加了一些编程的特性，将CSS作为目标生成文件,然后开发者就只要使用这种语言进行CSS的编码工作。转化成通俗易懂的话来说就是“用一种专门的编程语言,进行Web页面样式设计，再通过编译器转化为正常的CSS文件，以供项目使用”

常用的CSS预处理器有哪些

●SASS:基于Ruby,通过服务端处理，功能强大。解析效率高。需要学习Ruby语言，上手难度高于LESS。
●LESS:基于NodeJS,通过客户端处理，使用简单。功能比SASS简单，解析效率也低于SASS,但在实际开发中足够了，所以我们后台人员如果需要的话，建议使用LESS。

行为层（JavaScript）

JavaScript一门弱类型脚本语言，其源代码在发往客户端运行之前不需经过编译，而是将文本格式的字符代码发送给浏览器由浏览器解释运行。
 Native原生JS开发
 原生JS开发，也就是让我们按照[ECMAScript] 标准的开发方式，简称是ES,特点是所有浏览器都支持。截止到当前博客发布时间，ES 标准已发布如下版本:
●ES3
●ES4 (内部,未征式发布)
●ES5 (全浏览器支持)
●ES6 (常用，当前主流版本: webpack打包成为ES5支持! )
●ES7
●ES8
●ES9 (草案阶段)
区别就是逐步增加新特性。

TypeScript

TypeScript是一种由微软开发的自由和开源的编程语言。它是JavaScript的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程。由安德斯海尔斯伯格(C#、Delphi、TypeScript 之父; .NET 创立者)主导。
 该语言的特点就是除了具备ES的特性之外还纳入了许多不在标准范围内的新特性，所以会导致很多浏览器不能直接支持TypeScript语法，需要编译后(编译成JS)才能被浏览器正确执行。

JavaScript框架

●jQuery: 大家熟知的JavaScript框架，优点是简化了DOM操作，缺点是DOM操作太频繁,影响前端性能;在前端眼里使用它仅仅是为了兼容IE6、7、8;
●Angular: Google收购的前端框架，由一群Java程序员开发，其特点是将后台的MVC模式搬到了前端并增加了模块化开发的理念，与微软合作，采用TypeScript语法开发;对后台程序员友好，对前端程序员不太友好;最大的缺点是版本迭代不合理(如: 1代-> 2代，除了名字，基本就是两个东西;截止发表博客时已推出了Angular6)
●React: Facebook出品，一款高性能的JS前端框架;特点是提出了新概念[虚拟DOM（利用内存缓存）]用于减少真实DOM操作，在内存中模拟DOM操作，有效的提升了前端渲染效率;缺点是使用复杂，因为需要额外学习一门[JSX] 语言;
●Vue:一款渐进式JavaScript框架，所谓渐进式就是逐步实现新特性的意思，如实现模块化开发、路由、状态管理等新特性。其特点是综合了Angular (模块化)和React (虚拟DOM)的优点;
●Axios :前端通信框架;因为Vue 的边界很明确，就是为了处理DOM,所以并不具备通信能力，此时就需要额外使用一个通信框架与服务器交互;当然也可以直接选择使用jQuery提供的AJAX通信功能;
前端三大框架：Angular、React、Vue

UI框架

●Ant-Design:阿里巴巴出品，基于React的UI框架
●ElementUI、 iview、 ice: 饿了么出品，基于Vue的UI框架
●Bootstrap: Twitter推出的一个用于前端开发的开源工具包
●AmazeUI:又叫"妹子UI"，一款HTML5跨屏前端框架.
JavaScript 构建工具
●Babel: JS编译工具，主要用于浏览器不支持的ES新特性，比如用于编译TypeScript
●WebPack: 模块打包器，主要作用是打包、压缩、合并及按序加载
注：以上知识点将WebApp开发所需技能全部梳理完毕

三端合一

混合开发（Hybid App）

主要目的是实现一套代码三端统一(PC、Android:.apk、iOS:.ipa )并能备够调用到底层件(如:传感器、GPS、 摄像头等)，打包方式主要有以下两种:
●云打包: HBuild -> HBuildX， DCloud出品; API Cloud
●本地打包: Cordova (前身是PhoneGap)
后端技术
 前端人员为了方便开发也需要掌握一定的后端技术， 但我们Java后台人员知道后台知识体系极其庞大复杂，所以为了方便前端人员开发后台应用，就出现了NodeJS这样的技术。
 NodeJS的作者已经声称放弃NodeJS (说是架构做的不好再加上笨重的node_ modules，可能让作者不爽了吧)，开始开发全新架构的Deno
 既然是后台技术，那肯定也需要框架和项目管理工具，NodeJS 框架及项目管理工具如下:
●Express: NodeJS框架
●Koa: Express简化版
●NPM:项目综合管理工具，类似于Maven
●YARN: NPM的替代方案，类似于Maven和Gradle的关系

后端技术

前端人员为了方便开发也需要掌握一定的后端技术, 但我们Java后台人员知道后台知识体系极其庞大复杂,所以为了方便前端人员开发后台应用，就出现了NodeJS这样的技术。
NodeJS的作者已经声称放弃NodeJS (说是架构做的不好再加上笨重的node_ modules, 可能让作者不爽了吧)，开始开发全新架构的Deno
既然是后台技术，那肯定也需要框架和项目管理工具，NodeJS框架及项目管理工具如下:
●Express: NodeJS框架
●Koa: Express简化版
●NPM:项目综合管理工具，类似于Maven
●YARN: NPM的替代方案，类似于Maven和Gradle的关系

主流前端框架

Vue.js

iView

iview是一个强大的基于Vue的UI库，有很多实用的基础组件比elementui的组件更丰富，主要服务于PC界面的中后台产品。使用单文件的Vue组件化开发模式基于npm + webpack +babel开发，支持ES2015高质量、功能丰富友好的API，自由灵活地使用空间。
●官网地址
●Github
●iview- admin
备注:属于前端主流框架，选型时可考虑使用，主要特点是移动端支持较多

ElementUI

Element是饿了么前端开源维护的Vue UI组件库,组件齐全，基本涵盖后台所需的所有组件,
文档讲解详细，例子也很丰富。主要用于开发PC端的页面，是-个质量比较高的Vue UI组件库。
●官网地址
●Github
●vue-element-admin
备注:属于前端主流框架，选型时可考虑使用，主要特点是桌面端支持较多

ICE

飞冰是阿里巴巴团队基于React/Angular/Vue的中后台应用解决方案，在阿里巴巴内部，已经有270多个来自几乎所有BU的项目在使用。飞冰包含 了一条从设计端到开发端的完整链路，帮助用户快速搭建属于自己的中后台应用。
●官网地址
●Github
备注:主要组件还是以React为主，截止2019年02月17日更新博客前对Vue的支持还不太完善，目前尚处于观望阶段

VantUl

Vant UI是有赞前端团队基于有赞统-的规范实现的Vue组件库,提供了一整套UI基础组件和
业务组件。通过Vant,可以快速搭建出风格统-的页面，提升开发效率。
●官网地址
●Github

AtUI

at-ui是一款基于Vue 2.x的前端UI组件库，主要用于快速开发PC网站产品。它提供了- -套
npm + webpack + babel前端开发工作流程，CSS 样式独立，即使采用不同的框架实现都能保持统一的UI风格。
●官网地址
●Github

CubeUI

cube-ui是滴滴团队开发的基于Vue.js实现的精致移动端组件库。支持按需引入和后编译.轻量
灵活;扩展性强，可以方便地基于现有组件实现二次开发。
●官网地址
●Github

混合开发

Flutter

Flutter是谷歌的移动端UI框架，可在极短的时间内构建Android和ios上高质量的原生级应
用。Flutter 可与现有代码一起工作,它被世界各地的开发者和组织使用,并且Flutter是免费和开源
的。
●官网地址
●Github
备注: Google 出品，主要特点是快速构建原生APP应用程序，如做混合应用该框架为必选框架

lonic

lonic既是一个CSS框架也是- -个Javascript UI库, lonic 是目前最有潜力的一款HTML5手
机应用开发框架。通过SASS构建应用程序，它提供了很多UI组件来帮助开发者开发强大的应用。它
使用JavaScript MVVM框架和AngularJS/Vue来增强应用。提供故据的双向绑定，使用它成为
Web和移动开发者的共同选择。
●官网地址
●官网文档
●Github

微信小程序

mpvue

mpvue是美团开发的一-个使用Vue.js 开发小程序的前端框架，目前支持微信小程序、百度智能
小程序，头条小程序和支付宝小程序。框架基于Vue.js. 修改了的运行时框架runtime 和代码编
译器compiler 实现，使其可运行在小程序环境中,从而为小程序开发引入了Vue.js 开发体验。
●官网地址
●Github
备注:完备的Vue开发体验，井且支持多平台的小程序开发，推荐使用

WeUI

WeUl是-套同微信原生视觉体验一致的基础样式库， 由微信官方设计团队为微信内网页和微信小
程序量身设计，令用户的使用感知更加统- -。包含button. cell. dialog. toast, article. icon 等
各式元素。
●官网地址
●Github

MVC

后端为主的MVC时代

为了降低开发的复杂度，以后端为出发点，比如: Struts、 SpringMVC 等框架的使用，就是后端
的MVC时代;
以SpringMVC 流程为例:

●发起请求到前端控制器( DispatcherServlet )
●前端控制器请求HandlerMapping 查找Handler，可以根据xml配置、注解进行查找
●处理器映射器HandlerMapping 向前端控制器返回Handler
●前端控制器调用处理器适配器去执行Handler
●处理器适配器去执行Handler
●Handler 执行完成给适配器返回ModelAndView
●处理器适配器向前端控制器返回ModelAndView. Mode lAndView是SpringMVC 框架的-一个底层
对象，包括Model 和View
●前端控制器请求视图解析器去进行视图解析，根据逻辑视图名解析成真正的视图( ISP )
●视图解析器向前端控制器返回View
●前端控制器进行视图渲染，视图渲染将模型数据(在Mode lAndView对象中)填充到request 域
●前端控制器向用户响应结果

优点

MVC是一个非常好的协作模式，能够有效降低代码的耦合度，从架构，上能够让开发者明白代码应该写在哪里。为了让View更纯粹，还可以使用Thymeleaf. Freemarker 等模板引擎,使模板里无法写入Java代码,让前后端分工更加清晰。

缺点

●前端开发重度依赖开发环境，开发效率低，这种架构下，前后端协作有两种模式:

• 第一种是前端写DEMO,写好后，让后端去套模板。好处是DEMO可以本地开发，很高效。不足是还需要后端套模板,有可能套错，套完后还需要前端确定,来回沟通调整的成本比较
  大;
• 另一种协作模式是前端负责浏览器端的所有开发和服务器端的View层模板开发。好处是UI相关的代码都是前端去写就好，后端不用太关注,不足就是前端开发重度绑定后端环境，环境成为影响前端开发效率的重要因素。

●前后端职责纠缠不清:模板引擎功能强大,依旧可以通过拿到的上下文变量来实现各种业务逻辑。这样，只要前端弱势-点,往往就会被后端要求在模板层写出不少业务代码。还有一个很大的灰色地带是Controller ，页面路由等功能本应该是前端最关注的，但却是由后端来实现。Controller本身与Model 往往也会纠缠不清，看了让人咬牙的业务代码经常会出现在Controller层。这些问题不能全归结于程序员的素养，否则JSP就够了。

●对前端发挥的局限性:性能优化如果只在前端做空间非常有限，于是我们经常需要后端合作，但由于后端框架限制，我们很难使用[Comet] 、[BigPipe] 等技术方案来优化性能。

注:在这期间(2005 年以前)，包括早期的JSP. PHP可以称之为Web 1.0时代。在这里想说一句，如果你是-名Java初学者，请你不要再把一-些陈旧的技术当回事了，比如JSP,因为时代在变.技术在变、什么都在变(引用扎克伯格的一句话:唯-不变的是变化本身) ;当我们去给大学做实训时，有些同学会认为我们没有讲什么干货.其实不然，只能说是你认知里的干货对于市场来说早就过时了而已。

基于AJAX带来的SPA时代

时间回到2005年AJAX (Asynchronous JavaScript And XML,异步JavaScript和XML,老技术新用法)被正式提出并开始使用CDN 作为静态资源存储，于是出现了JavaScript王者归来(在这之前JS都是用来在网页上贴狗皮膏药广告的)的SPA (Single Page Application)单页面应用时代。

优点

这种模式下，前后端的分工非常清晰，前后端的关键协作点是AJAX接口.看起来是如此美妙，但回过头来看看的话，这与JSP时代区别不大。复杂度从服务端的JSP里移到了浏览器的JavaScript,浏览器端变得很复杂。类似Spring MVC,这个时代开始出现浏览器端的分层架构:

缺点

● 前后端接口的约定: 如果后端的接口一塌糊涂，如果后端的业务模型不够稳定，那么前端开发会很痛苦;不少团队也有类似尝试，通过接口规则、接口平台等方式来做。有了和后端一起沉淀的接口规则，还可以用来模拟数据，使得前后端可以在约定接口后实现高效井行开发。
●前端开发的复杂度控制: SPA 应用大多以功能交互型为主，JavaScript 代码过十万行很正常。大量JS代码的组织，与View层的绑定等，都不是容易的事情。

前端为主的MV*时代

此处的MV*模式如下:

●MVC (同步通信为主) : Model. View. Controller
●MVP (异步通信为主) : Model. View. Presenter
●MVVM (异步通信为主) : Model. View. ViewModel
为了降低前端开发复杂度，涌现了大量的前端框架，比如: AngularJS、 React、 Vue.js .EmberJs等，这些框架总的原则是先按类型分层，比如Templates. Controllers. Models. 然后再在层内做切分，如下图:

优点

●前后端职责很清晰:前端工作在浏览器端，后端工作在服务端。清晰的分工，可以让开发并行，测试数据的模拟不难，前端可以本地开发。后端则可以专注于业务逻辑的处理，输出RESTful等接口.
●前端开发的复杂度可控:前端代码很重， 但合理的分层，让前端代码能各司其职。这一块蛮有意思的，简单如模板特性的选择,就有很多很多讲究。并非越强大越好，限制什么留下哪些自由，代码应该如何组织，所有这一切设计， 得花一本书的厚度去说明。
●部署相对独立: 可以快速改进产品体验

缺点

●代码不能复用。比如后端依旧需要对数据做各种校验，校验逻辑无法复用浏览器端的代码。如果可以复用，那么后端的数据校验可以相对简单化。
●全异步，对SEO不利。往往还需要服务端做同步渲染的降级方案。
●性能并非最佳,特别是移动互联网环境下。
●SPA不能满足所有需求，依旧存在大量多页面应用。URL Design需要后端配合，前端无法完全掌控。

NodeJS带来的全栈时代

前端为主的MV*模式解决了很多很多问题，但如上所述，依旧存在不少不足之处。随着NodeJS的兴起，JavaScript 开始有能力运行在服务端。这意味着可以有一种新的研发模式:

在这种研发模式下，前后端的职责很清晰。对前端来说，两个UI层各司其职:
●Front-end UI layer处理浏览器层的展现逻辑。通过CSS渲染样式，通过JavaScript添加交互功能，HTML的生成也可以放在这层，具体看应用场景。
●Back-end UI layer处理路由、模板、数据获取、Cookie等。通过路由，前端终于可以自主把控URL Design,这样无论是单页面应用还是多页面应用，前端都可以自由调控。后端也终于可以摆脱对展现的强关注，转而可以专心于业务逻辑层的开发。

通过Node, Web Server层也是JavaScript代码，这意味着部分代码可前后复用，需要SEO的场景可以在服务端同步渲染，由于异步请求太多导致的性能问题也可以通过服务端来缓解。前一种模式的不足，通过这种模式几乎都能完美解决掉。

与JSP模式相比，全栈模式看起来是一种回归，也的确是一种向原始开发模式的回归， 不过是一种螺旋上升式的回归。

基于NodeJS的全栈模式，依旧面临很多挑战:

●需要前端对服务端编程有更进一步的认识。 比如TCP/IP等网络知识的掌握。
●NodeJS层与Java层的高效通信。NodeJS模式下，都在服务器端，RESTful HTTP通信未必高效，通过SOAP等方式通信更高效。一切需要在验证中前行。
●对部署、运维层面的熟练了解，需要更多知识点和实操经验。
●大量历史遗留问题如何过渡。这可能是最大最大的阻力。

注:看到这里，相信很多同学就可以理解，为什么我总在课堂上说:“前端想学后台很难， 而我们后端程序员学任何东西都很简单”;就是因为我们后端程序员具备相对完善的知识体系.
全栈! So Easy!

总结

综上所述，模式也好，技术也罢，没有好坏优劣之分，只有适合不适合;前后分离的开发思想主要
是基于soC (关注度分离原则) ，上面种种模式，都是让前后端的职责更清晰，分工更合理高效。

第一个Vue程序

Vue

Vue (读音/vju/, 类似于view)是一套用于构建用户界面的渐进式框架，发布于2014年2月。与其它大型框架不同的是，Vue被设计为可以自底向上逐层应用。Vue的核心库只关注视图层，不仅易于上手，还便于与第三方库(如: vue-router, vue-resource, vuex)或既有项目整合。

MVVM模式的实现者

●Model:模型层，在这里表示JavaScript对象
●View:视图层,在这里表示DOM (HTML操作的元素)
●ViewModel:连接视图和数据的中间件，Vue.js就是MVVM中的ViewModel层的实现者

在MVVM架构中，是不允许数据和视图直接通信的，只能通过ViewModel来通信，而ViewModel就是定义了一个Observer观察者

●ViewModel能够观察到数据的变化，并对视图对应的内容进行更新
●ViewModel能够监听到视图的变化，并能够通知数据发生改变

至此，我们就明白了，Vue.js 就是一个MVVM的实现者，他的核心就是实现了DOM监听与数据绑定

为什么要使用Vue.js

●轻量级，体积小是一个重要指标。Vue.js 压缩后有只有20多kb (Angular 压缩后56kb+ ,React压缩后44kb+ )
●移动优先。更适合移动端，比如移动端的Touch事件
●易上手，学习曲线平稳,文档齐全
●吸取了Angular (模块化)和React (虚拟DOM)的长处，并拥有自己独特的功能，如:计算属性
●开源，社区活跃度高

第一个Vue程序

[说明] IDEA 可以安装Vue的插件!

注意: Vue不支持IE8及以下版本，因为Vue使用了1IE8 无法模拟的ECMAScript5特性。但它支持所有兼容ECMAScript 5的浏览器。

下载地址

●开发版本

• 包含完整的警告和调试模式: https://vuejs.org/js/vue.js
• 删除了警告，30.96KB min + gzip: htps://uejs.org/is/vue.min.js
  ●CDN
• <script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.js"></script>
• <script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>

第一个Vue

<!DOCTYPE html>
<html lang="en" xmlns:v-bind="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>狂神说Java</p>

<!--view层 模板-->
<div id="app">
    <span v-bind:title="message">鼠标悬停几秒钟查看此处动态绑定的提示信息！</span>
    <p>{{message}}</p>
</div>
</body>

<!--导入js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: "#app",
        data: {
            message: "hello,vue"
        }
    })
</script>
</html>

什么是MVVM

MVVM (Model-View-ViewModel) 是一种软件架构设计模式，由微软WPF (用于替代WinForm，以前就是用这个技术开发桌面应用程序的)和Silverlight (类似于Java Applet,简单点说就是在浏览器上运行的WPF)的架构师Ken Cooper和Ted Peters 开发，是一种简化用户界面的事件驱动编程方式。由John Gossman (同样也是WPF和Silverlight的架构师)于2005年在他的博客上发表。

MVVM 源自于经典的MVC (ModI-View-Controller) 模式。MVVM的核心是ViewModel层，负责转换Model中的数据对象来让数据变得更容易管理和使用，其作用如下:

• 该层向上与视图层进行双向数据绑定
• 向下与Model层通过接口请求进行数据交互

MVVM已经相当成熟了，主要运用但不仅仅在网络应用程序开发中。当下流行的MVVM框架有Vue.js，AngularJs 等。

为什么要使用MVVM

MVVM模式和MVC模式一样，主要目的是分离视图(View)和模型(Model),有几大好处：

• 低耦合:视图(View)可以独立于Model变化和修改,一个ViewModel可以绑定到不同的View上，当View变化的时候Model可以不变，当Model变化的时候View也可以不变。
• 可复用:你可以把一些视图逻辑放在一个ViewModel里面，让很多View重用这段视图逻辑。
• 独立开发:开发人员可以专注于业务逻辑和数据的开发(ViewModel),设计人员可以专注于页面设计。
• 可测试:界面素来是比较难于测试的，而现在测试可以针对ViewModel来写。

MVVM的组成部分

View

View是视图层，也就是用户界面。前端主要由HTML 和Css来构建，为了更方便地展现ViewModel或者Model 层的数据，已经产生了各种各样的前后端模板语言，比如FreeMarker、Thymeleaf等等,各大MVVM框架如Vue.js, AngularJS, EJS 等也都有自己用来构建用户界面的内置模板语言。

Model

Model是指数据模型，泛指后端进行的各种业务逻辑处理和数据操控，主要围绕数据库系统展开。这里的难点主要在于需要和前端约定统-的接口规则

ViewModel

ViewModel是由前端开发人员组织生成和维护的视图数据层。在这一层，前端开发者对从后端获取的Model数据进行转换处理，做二次封装，以生成符合View层使用预期的视图数据模型。

需要注意的是ViewModel所封装出来的数据模型包括视图的状态和行为两部分，而Model层的
数据模型是只包含状态的

●比如页面的这-块展示什么，那一块展示什么这些都属于视图状态(展示)
●页面加载进来时发生什么，点击这一块发生什么，这一块滚动时发生什么这些都属于视图行为(交互)

视图状态和行为都封装在了ViewModel里。这样的封装使得ViewModel可以完整地去描述View层。由于实现了双向绑定，ViewModel 的内容会实时展现在View层，这是激动人心的，因为前端开发者再也不必低效又麻烦地通过操纵DOM去更新视图。

MVVM框架已经把最脏最累的一块做好了,我们开发者只需要处理和维护ViewModel,更新数据视图就会自动得到相应更新，真正实现事件驱动编程。

View层展现的不是Model 层的数据，而是ViewModel 的数据，由ViewModel 负责与Model层交互，这就完全解耦了View层和Model层，这个解耦是至关重要的，它是前后端分离方案实施的重要一环。

MVVM模式的实现者

• Model : 模型层，在这里表示JavaScript对象

• View : 视图层,在这里表示DOM (HTML操作的元素)

• ViewModel : 连接视图和数据的中间件，Vue.js就是MVVM中的ViewModel层的实现者

在MVVM架构中，是不允许数据和视图直接通信的，只能通过ViewModel来通信，而ViewModel就是定义了一个Observer观察者

• ViewModel 能够观察到数据的变化，并对视图对应的内容进行更新

• ViewModel 能够监听到视图的变化，并能够通知数据发生改变

至此，我们就明白了，Vue.js 就是一个MVVM的实现者，他的核心就是实现了DOM监听与数据绑定

VUE基本语法

V-BIND

​ 现在数据和DOM已经被建立了关联，所有的东西都是响应式的。我们在控制台操作对象的属性，界面可以实时更新。

​ 我们可以使用v-bind来绑定元素属性！

<!DOCTYPE html>
<html lang="en" xmlns:v-bind="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>狂神说Java</p>

<!--view层 模板-->
<div id="app">
    <span v-bind:title="message">鼠标悬停几秒钟查看此处动态绑定的提示信息！</span>
</div>
</body>

<!--导入js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    var app = new Vue({
        el: "#app",
        data: {
            message: "hello,vue"
        }
    })
</script>
</html>

你看到的v-bind等被称为指令。指令带有前缀v-，以表示它们是Vue提供的特殊特性。可能你已经猜到了，它们会在渲染的DOM.上应用特殊的响应式行为。在这里，该指令的意思是:“将这个元素节点的title 特性和Vue实例的message属性保持一致”。

如果你再次打开浏览器的JavaScript控制台，输入app.message = '新消息’，就会再一-次看到这个绑定了title 特性的HTML已经进行了更新。

v-if,v-else

仕么是条件判断语句，就不需要我说明了吧以下两个属性!

• v-if
• v-else
  上代码:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>狂神说Java</p>

<!--view层 模板-->
<div id="app">
    <h1 v-if="type==='A'">A</h1>
    <h1 v-else-if="type==='B'">B</h1>
    <h1 v-else>C</h1>
</div>
</body>

<!--导入js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: "#app",
        data: {
            type: "A"
        }
    })
</script>
</html>

v-for

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>狂神说Java</p>

<!--view层 模板-->
<div id="app">
    <li v-for="item in items">
        姓名：{{item.name}}，年龄：{{item.age}}
    </li>
</div>
</body>

<!--导入js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: "#app",
        data: {
            items: [
                {name: "zhangsan", age: 12},
                {name: "lisi", age: 10},
                {name: "wangwu", age: 16}
            ]
        }
    })
</script>
</html>

v-on

<!DOCTYPE html>
<html lang="en" xmlns:v-on="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div id="app">
    <button v-on:click="sayHi">click</button>
</div>


<!--1.导入Vue。js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: "#app",
        data: {
            message: 'huang'
        },
        methods: {
            sayHi: function (event) {
                alert(this.message)
            }
        }
    });

</script>
</body>
</html>

Vue:表单双绑、组件

什么是双向数据绑定

Vuejs是-个MVVM框架，即数据双向绑定，即当数据发生变化的时候，视图也就发生变化，当视图发生变化的时候，数据也会跟着同步变化。这也算是Vue.js的精髓之处了。

值得注意的是，我们所说的数据双向绑定，-定是对于UI控件来说的，非UI控件不会涉及到数据双向绑定。单向数据绑定是使用状态管理工具的前提。如果我们使用vuex ，那么数据流也是单项的，这时就会和双向数据绑定有冲突。

为什么要实现数据的双向绑定

在Vue.js 中，如果使用vuex ，实际上数据还是单向的，之所以说是数据双向绑定，这是用的UI控件来说，对于我们处理表单，Vue.js 的双向数据绑定用起来就特别舒服了。即两者并不互斥，在全局性数据流使用单项，方便跟踪;局部性数据流使用双向,简单易操作。

在表单中使用双向数据绑定

你可以用v-model 指令在表单<input> 、<textarea> 及<select> 元素上创建双向数据绑定。它会根据控件类型自动选取正确的方法来更新元素。尽管有些神奇，但v-model本质上不过是语法糖。它负责监听用户的输入事件以更新数据，并对-些极端场景进行一些特 殊处理。

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

v-model

用v-model 指令在表单<input> 、<textarea> 及<select> 元素上创建双向数据绑定

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>


<div id="app">
输入文本：<input type="text" v-model="message"> {{message}}
</div>

<div id="app2">
    下拉框：
    <select v-model="selected">
        <option disabled value="">--请选择--</option>
        <option>A</option>
        <option>B</option>
        <option>C</option>
    </select>
    {{selected}}
</div>

<div id="app3">
    性别：
    <input type="radio" name="sex" value="男" v-model="huang">男
    <input type="radio" name="sex" value="女" v-model="huang">女
    <p>选中了:{{huang}}</p>
</div>


<!--1.导入Vue。js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    var vm = new Vue({
        el: "#app",
        data: {
            message: ''
        }
    });

    var vm2 = new Vue({
        el: "#app2",
        data: {
            selected: ''
        }
    });

    var vm3 = new Vue({
        el: "#app3",
        data: {
            huang: ''
        }
    });

</script>
</body>
</html>

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

什么是组件

组件是可复用的Vue实例，说白了就是一组可以重复使 用的模板，跟JSTL 的自定义标签、Thymeleaf的th:fragment 等框架有着异曲同工之妙。通常一个应 用会以一棵 嵌套的组件树的形式来组织:

例如，你可能会有页头、侧边栏、内容区等组件，每个组件又包含了其它的像导航链接、博文之类的组件.

第一个Vue组件

注意:在实际开发中，我们并不会用以下方式开发组件，而是采用vue-cli创建.vue模板文件的方式开发，以下方法只是为了让大家理解什么是组件。
使用Vue.component()方法注册组件,格式如下:

Vue.component()

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div id="app">
    <huang v-for="item in items" v-bind:jia="item"></huang>
</div>


<!--1.导入Vue。js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>

    //定义一个Vue组件component
    Vue.component("huang",{
        props:['jia'],
        template:'<li>{{jia}}</li>'
        });
    var vm = new Vue({
        el: "#app",
        data: {
            items:["JAVA","Linux","前端"]
        }
    });

</script>
</body>
</html>

说明:

●v-for="item in items" :遍历Vue 实例中定义的名为items 的数组,并创建同等数
量的组件
●v-bind:item="item" :将遍历的item 项绑定到组件中props 定义的名为item属性上; =号左边的item为props定义的属性名，右边的为item in items中遍历的item项的值

Vue: Axios异步通信

什么是Axios

Axios是一个开源的可以用在浏览器端和NodeJS 的异步通信框架，她的主要作用就是实现AJAX
异步通信，其功能特点如下:

• 从浏览器中创建XMLHttpRequests
• 从node.js创建http请求
• 支持Promise API [JS中链式编程]
• 拦截请求和响应
• 转换请求数据和响应数据
• 取消请求
• 自动转换JSON数据
• 客户端支持防御XSRF (跨站请求伪造)

GitHub: https://github.com/axios/axios
中文文档: http://www.axios-js.com/

为什么要使用Axios

由于Vue.js 是一个视图层框架并且作者(尤雨溪)严格准守SoC (关注度分离原则) ，所以Vue.js并不包含AJAX的通信功能，为了解决通信问题，作者单独开发了一个名为vue- resource的插件，不过在进入2.0版本以后停止了对该插件的维护并推荐了Axios 框架。少用jQuery,因为它操作Dom太频繁!

第一个Axios应用程序

咱们开发的接口大部分都是采用JSON格式，可以先在项目里模拟一段JSON数据，数据内容如下:创建一个名为data.json的文件并填入上面的内容，放在项目的根目录下

data.json

{
  "name": "狂神说Java",
  "url": "https://blog.kuangstudy.com",
  "page": 1,
  "isNonProfit": true,
  "address": {
    "street": "含光门",
    "city": "陕西西安",
    "country": "中国"
  },
  "links": [
    {
      "name": "bilibili",
      "url": "https://space.bilibili.com/95256449"
    },
    {
      "name": "狂伸说java",
      "url": "https://blog.kuangstudy.com"
    },
    {
      "name": "百度",
      "url": "https://www.baidu.com/"
    }
  ]
}

<!DOCTYPE html>
<html lang="en" xmlns:v-bind="http://www.w3.org/1999/xhtml" xmlns:v-for="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>狂神说Java</title>
    <!--v-cloak 解决闪烁问题-->
    <style>
        [v-cloak] {
            display: none;
        }
    </style>
</head>
<body>

<div id="vue" v-cloak>
    <div>名称：{{info.name}}</div>
    <div>地址：{{info.address.country}}-{{info.address.city}}-{{info.address.street}}</div>
    <div>链接：<a v-bind:href="info.url" target="_blank">{{info.url}}</a></div>
<hr>
    <li v-for="link in info.links">
        {{link.name}}--><a v-bind:href="link.url" target="_blank">{{link.url}}</a>
    </li>
</div>

<!--引入 JS 文件-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script type="text/javascript">
    var vm = new Vue({
        el: '#vue',
        data() {
            return {
                info: {
                    name: null,
                    address: {
                        country: null,
                        city: null,
                        street: null
                    },
                    url: null,

                    links: [
                        {
                            name: null,
                            url: null
                        }
                    ]

                }
            }
        },
        mounted() { //钩子函数
            axios
                .get('../data.json')
                .then(response => (this.info = response.data));
        }
    });
</script>

</body>
</html>

运行结果

Vue:计算属性、内容分发、自定义事件

什么是计算属性

计算属性的重点突出在属性两个字上(属性是名词)，首先它是个属性其次这个属性有计算的能力(计算是动词) .这里的计算就是个函数:简单点说，它就是一-个能够将计算结果缓存起来的属性(将行为转化成了静态的属性)，仅此而已;可以想象为缓存!

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>狂神说Java</title>
    <script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.js"></script>
</head>
<body>

<div id="vue">
    <!--注意，一个是方法，一个是属性-->
    <h3>{{message}}</h3>
    <p>调用当前时间的方法：{{currentTime1()}}</p>
    <p>当前时间的计算属性：{{currentTime2}}</p>
</div>

<script type="text/javascript">
    var vm = new Vue({
        el: '#vue',
        data: {
            message: 'Hello Vue'
        },
        methods: {
            currentTime1: function () {
                return Date.now();
            }
        },
        computed: {
            //currentTime2 ，这是一个属性！不是方法
            currentTime2: function () {
                this.message;
                return Date.now();
            }
        }
    });
</script>
</body>
</html>

注意: methods和computed里的东西不能重名

说明:

●methods: 定义方法，调用方法使用currentTime1()， 需要带括号

●computed:定义计算属性，调用属性使用currentTime2,不需要带括号; this.message 是为了能够让currentTime2观察到数据变化而变化

●如何在方法中的值发生了变化,则缓存就会刷新!可以在控制台使用vm. message-“qinjiang” ,改变下数据的值，再次测试观察效果!

结论:

调用方法时，每次都需要进行计算，既然有计算过程则必定产生系统开销,那如果这个结果是不经常变化的呢?此时就可以考虑将这个结果缓存起来，采用计算属性可以很方便的做到这-点计算属性的主要特性就是为了将不经常变化的计算结果进行缓存，以节约我们的系统开销;

内容分发<slot>

在Vue.js中我们使用<slot> 元素作为承载分发内容的出口，作者称其为插槽，可以应用在组合组件的场景中;

测试

比如准备制作一个待办事项组件(todo) ，该组件由待办标题(todo-title) 和待办内容(todo-items)组成，但这三个组件又是相互独立的，该如何操作呢? ’
第-步:定义一个待办事项的组件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.js"></script>
<body>
<div id="vue">
    <!--:是v-bind的缩写-->
    <todo>
        <todo-title slot="todo-title" :vtitle="title"></todo-title>
        <todo-items slot="todo-items" v-for="(item, index) in todoItems" v-bind:vitem="item" v-bind:vindex="index"
                    :key="index"></todo-items>
    </todo>
</div>
<script type="text/javascript">

    Vue.component('todo', {
        template: '<div>\
                    <slot name="todo-title"></slot>\
                    <ul>\
                        <slot name="todo-items"></slot>\
                    </ul>\
               </div>'
    });
    Vue.component('todo-title', {
        props: ['vtitle'],
        template: '<div>{{vtitle}}</div>'
    });
    Vue.component('todo-items', {
        props: ['vitem', 'vindex'],
        template: '<li>{{vindex + 1}}. {{vitem}}</li>'
    });
    var vm = new Vue({
        el: '#vue',
        data: {
            title: '秦老师系列课程',
            todoItems: ['狂神说Java', '狂神说运维', '狂神说前端']
        }
    });
</script>
</body>
</html>

运行结果

自定义事件内容分发

​ 通过以上代码不难发现，数据项在Vue的实例中，但删除操作要在组件中完成，那么组件如何才能删除Vue实例中的数据呢?此时就涉及到参数传递与事件分发了，Vue为我们提供了自定义事件的功能很好的帮助我们解决了这个问题;

​ 使用this.$emit (‘自定义事件名’,参数)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
</head>
<body>
<div id="app">
    <todo>
        <todo-title slot="todo-title" v-bind:name="title"></todo-title>
        <todo-items slot="todo-items" v-for="(item,index) in todoItems" v-bind:item="item"
                    v-bind:index="index" v-on:vremove="removeItems(index)"></todo-items>//v-on自定义绑定事件
    </todo>
</div>

<!--1.导入vue.js-->
<script src="https://cdn.jsdelivr.net/npm/vue@2.5.21/dist/vue.min.js"></script>
<script>
    //slot 插槽 这个组件要定义在前面不然出不来数据
    Vue.component("todo", {
        template: '<div>\
                <slot name="todo-title"></slot>\
                <ul>\
                <slot name="todo-items"></slot>\
                </ul>\
                <div>'
    });
    Vue.component("todo-title", {
        //属性
        props: ['name'],
        template: '<div>{{name}}</div>'
    });
    Vue.component("todo-items", {
        props: ['item','index'],
        //只允许绑定当前组件
        template: '<li>{{index}}---{{item}} <button @click="remove">删除</button></li>',
        methods: {
            remove: function (index) {
                // this.$emit 自定义事件分发
                this.$emit('vremove',index)
            }
        }
    });
    let vm = new Vue({
        el: "#app",
        data: {
            //标题
            title: "图书馆系列图书",
            //列表
            todoItems: ['三国演义', '红楼梦', '西游记', '水浒传']
        },
        methods: {
            removeItems: function (index) {
                console.log("删除了"+this.todoItems[index]+"OK");
                this.todoItems.splice(index,1);
            }
        }
    });
</script>
</body>
</html>

Vue小结

Vue入门小结

核心:数据驱动,组件化
优点:借鉴了AngulaJS的模块化开发和React的虚拟Dom,虚拟Dom就是把Dom操作放到内存中执行;
常用的属性:
●v-if
●v-else-if
●v-else
●v-for
●v-on绑定事件,简写@
●v-model数据双向绑定
●v-bind给组件绑定参数,简写 :
组件化:
●组合组件slot插槽
●组件内部绑定事件需要使用到this . $emit("事件名",参数);
●计算属性的特色,缓存计算数据

遵循SoC关注度分离原则,Vue是纯粹的视图框架，并不包含,比如Ajax之类的通信功能，为了解决通
信问题,我们需要使用Axios框架做异步通信;

说明

Vue的开发都是要基于NodeJS,实际开发采用vue-cli脚手架开发,vue-router路由,vuex做状态管理; Vue UI,界面我们一般使用ElementUl(饿了么出品),.或者ICE(阿里巴巴出品!)来快速搭建前端项目~
官网:
●https://element.eleme.cn/#/zh-CN
●https://ice.work/

Vue:第-个vue-cli项目

什么是vue-cli

vue-cli官方提供的一个脚手架,用于快速生成-个vue的项目模板;

预先定义好的目录结构及基础代码，就好比咱们在创建Maven项目时可以选择创建一个骨架项目，这个骨架项目就是脚手架,我们的开发更加的快速;

主要的功能:
●统一的目录结构
●本地调试
●热部署
●单元测试
●集成打包.上线

需要的环境

●Node.js : http://nodejs.cn/ download/
安装就无脑下一步就好,安装在自己的环境目录下
●Git : https://git-scm.com/ downloads
镜像:https://npm.taobao.org/mirrors/git-for-windows/
确认nodejs安装成功:
●cmd下输入node -v，查看是否能够正确打印出版本号即可!
●cmd下输入npm-v ,查看是否能够正确打印出版本号即可!
这个npm,就是-一个软件包管理工具就和linux下的apt软件安装差不多!

安装Node.js淘宝镜像加速器(cnpm)
这样子的话,下载会快很多~

# -g就是全局安装，一次安装一劳永逸
npm insta11 cnpm -g
#或使用如下语句解决npm速度慢的问题，每次安装都需运行一次
npm install --registry=https://registry.npm. taobao.org

安装过程可能有点慢~ ,耐心等待!虽然安装了cnpm,但是尽量少用!
安装的位置: C: \Users \Administrator\AppData \Roaming\npm

安装vue-cli

cnpm install vue-cli -g
#测试是否安装成功
#查看可以基于哪些模板创建vue 应用程序，通常我们选择webpack
vue list

第一个vue-cli应用程序

1.创建一个Vue项目,我们随便建立- -个空的文件夹在电脑上,我这里在D盘下新建一个目录D: \Project\vue-study ;
2.创建一个基于webpack模板的vue应用程序

#这里的myvue是项目名称，可以根据自己的需求起名
vue init webpack myvue

一路都选择no即可;

说明:

●Project name:项目名称，默认回车即可
●Project description:项目描述，默认回车即可

初始化并运行

cd myvue
npm insta11
npm run dev

执行完成后，目录多了很多依赖

Vue: Webpack学习

什么是Webpack

本质上，webpack是一个现代JavaScript应用程序的静态模块打包器(module bundler)。当webpack处理应用程序时，它会递归地构建一个依赖关 系图(dependency graph),其中包含应用程序需要的每个模块，然后将所有这些模块打包成一个或多个bundle.

Webpack是当下最热门的前端资源模块化管理和打包工具，它可以将许多松散耦合的模块按照依赖和规则打包成符合生产环境部署的前端资源。还可以将按需加载的模块进行代码分离，等到实际需要时再异步加载。通过loader转换，任何形式的资源都可以当做模块，比如CommonsJS、AMD、ES6、 CSS、JSON、CoffeeScript. LESS等;
伴随着移动互联网的大潮，当今越来越多的网站已经从网页模式进化到了WebApp模式。它们运行在现代浏览器里，使用HTML5. CSS3、ES6等新的技术来开发丰富的功能，网页已经不仅仅是完成浏览器的基本需求; WebApp通常是一个SPA (单页面应用) ，每一个视图通过异步的方式加载，这导致页面初始化和使用过程中会加载越来越多的JS代码，这给前端的开发流程和资源组织带来了巨大挑战。

前端开发和其他开发工作的主要区别，首先是前端基于多语言、多层次的编码和组织工作，其次前端产品的交付是基于浏览器的，这些资源是通过增量加载的方式运行到浏览器端，如何在开发环境组织好这些碎片化的代码和资源，并且保证他们在浏览器端快速、优雅的加载和更新，就需要-一个模块化系统，这个理想中的模块化系统是前端工程师多年来一直探索的难题。

模块化的演进

Script标签

<script src="module1.js"></scirpt>
<script src="module2.js"></scirpt>
<script src="module3.js"></scirpt>
<script src="module4.js"></scirpt>

这是最原始的JavaScript文件加载方式，如果把每一个文件看做是一个模块，那么他们的接口
通常是暴露在全局作用域下，也就是定义在window对象中,不同模块的调用都是.一个作用域。
这种原始的加载方式暴露了一些显而易见的弊端:

●全局作用域下容易造成变量冲突
●文件只能按照<script>的书写顺序进行加载
●开发人员必须主观解决模块和代码库的依赖关系
●在大型项目中各种资源难以管理，长期积累的问题导致代码库混乱不堪

CommonsJS

服务器端的NodeJS遵循CommonsJS规范，该规范核心思想是允许模块通过require方法来同步加载所需依赖的其它模块，然后通过exports或module.exports来导出需要暴露的接口。

require("module");
require(". ./module.js");
export.doStuff = function() {};
module.exports = someValue;

优点:

●服务器端模块便于重用
●NPM中已经有超过45万个可以使用的模块包
●简单易用

缺点:

●同步的模块加载方式不适合在浏览器环境中，同步意味着阻塞加载，浏览器资源是异步加载的
●不能非阻塞的并行加载多个模块

实现:

●服务端的NodeJS
●Browserify, 浏览器端的CommonsJS实现，可以使用NPM的模块，但是编译打包后的文件体积较大
●modules-webmake,类似Browserify,但不如Browserify 灵活
●wreq, Browserify 的前身

AMD

Asynchronous Module Definition规范其实主要一个主要接口define(id?,dependencies?, factory);它要在声明模块的时候指定所有的依赖dependencies,并且还要当做形参传到factory中,对于依赖的模块提前执行。

define( "module", ["dep1", "dep2"], function(d1, d2) {
return someExportedvalue;
});
require(["module", "../file.js"], function(module, file) {});

优点

●适合在浏览器环境中异步加载模块
●可以并行加载多个模块

缺点

●提高了开发成本，代码的阅读和书写比较困难，模块定义方式的语义不畅
●不符合通用的模块化思维方式，是-种妥协的实现

实现

●RequireJS
●curl

CMD

Commons Module Definition规范和AMD很相似，尽量保持简单，并与CommonsJS和NodeJS的Modules规范保持了很大的兼容性。

define(function(require, exports, module) {
var $ = require("jquery");
var Spinning = require("./spinning");
exports .doSomething = ...;
module. exports = ...;
});

优点:

●依赖就近，延迟执行
●可以很容易在NodeJS中运行

缺点

●依赖SPM打包，模块的加载逻辑偏重

实现

●Sea.js
●coolie

ES6模块

EcmaScript6标准增加了JavaScript语言层面的模块体系定义。ES6 模块的设计思想，尽量静态化，使编译时就能确定模块的依赖关系，以及输入和输出的变量。CommonsJS和AMD模块，都只能在运行时确定这些东西。民

import "jquery";
export function doStuff() {}
module "localModule" {}

优点

●容易进行静态分析
●面向未来的EcmaScript标准

缺点

●原生浏览器端还没有实现该标准
●全新的命令，新版的NodeJS才支持
实现
●Babel

大家期望的模块系统
可以兼容多种模块风格,尽量可以利用已有的代码,不仅仅只是JavaScript模块化，还有CSS、图片、字体等资源也需要模块化。

安装Webpack

WebPack是一款模块加载器兼打包工具，它能把各种资源，如JS. JSX. ES6、SASS. LESS.图片等都作为模块来处理和使用。

安装:

npm install webpack -g
npm install webpack-cli g

测试安装成功:
●webpack -V
●webpack-cli -V

配置

创建webpack.config.js 配置文件
●entry: 入口文件，指定WebPack用哪个文件作为项目的入口
●output: 输出，指定WebPack把处理完成的文件放置到指定路径
●module: 模块，用于处理各种类型的文件
●plugins: 插件,如:热更新、代码重用等
●resolve:设置路径指向
●watch:监听，用于设置文件改动后直接打包

module.exports = {
entry :
output: {
path:”",
filename:
},
module: {
loaders: [
{test: /\.js$/ ,loader: “"}
]
},
p1ugins: {},
resolve :{},
watch: true
}

直接运行webpack命令打包

使用webpack

1.创建项目
2.创建一个名为mgdules的目录，用于放置JS模块等资源文件
3.在modules下创建模块文件，如hello.js.用于编写JS模块相关代码

//暴露一个方法:sayHi
exports.sayHi = function () {
	document.write("<div>He11o WebPack</div>");
};

4.在modules下创建- -个名为main.js的入口文件，用于打包时设置entry属性

//require导入一个模块,就可以调用这个模块中的方法了
let hello=require("./hello");
hello.sayHi()

5.在主目录创建webpack-config.js
webpack-config.js 这个相当于webpack的配置文件 enrty请求main.js的文件 output是输出的位置和名字

module.exports = {
    entry: './modules/main.js',
    output: {
        filename: "./js/bundle.js"
    }
};

6.在idea命令台输入webpack命令（idea要设置管理员启动）

7.完成上述操作之后会在主目录生成一个dist文件 生成的js文件夹路径为/dist/js/bundle.js
8.在主目录创建index.html 导入bundle.js
index.html

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="dist/js/bundle.js"></script>
</head>
<body>
</body>
</html>

运行截图

说明:

#参数--watch用于监听变化
webpack -watch

VUE-ROUTER路由

​ Vue Router是Vue.js官方的路由管理器（路径跳转）。它和Vue.js的核心深度集成，让构建单页面应用变得易如反掌。包含的功能有:

• 嵌套的路由/视图表

• 模块化的、基于组件的路由配置

• 路由参数、查询、通配符

• 基于Vue.js过渡系统的视图过渡效果

• 细粒度的导航控制

• 带有自动激活的CSS class的链接

• HTML5历史模式或hash模式，在IE9中自动降级

• 自定义的滚动条行为

安装

​ 基于第一个vue-cli进行测试学习;先查看node_modules中是否存在 vue-router
 vue-router 是一个插件包，所以我们还是需要用 npm/cnpm 来进行安装的。打开命令行工具，进入你的项目目录，输入下面命令。

npm install vue-router --save-dev

如果在一个模块化工程中使用它，必须要通过Vue.use()明确地安装路由功能:

import Vue from 'vue '
import VueRouter from ' vue-router "
Vue .use(VueRouter);