Vue脚手架学习

脚手架文件结构：

    node_moudels
    public
        favicon.ico:页签图标
        index.html:主页面
    src 
        assets:存放静态资源
            logo.png
        component:存放组件
            HelloWord.vue
        App.vue:汇总组件
        main.js:入口文件
    .gitignore:git版本管理忽略的配置
    babel.config.js:babel的配置文件
    package.json:应用包配置文件
    README.md:应用描述文件
    package-lock.json:包版本控制文件

关于不同版本的Vue:

    1.vue.js与vue.runtime.xxx.js区别：
            (1).vue.js是完整版的Vue,包含：核心功能+模板解析器
            (2).vue.runtime.xxx.js是运行版的Vue,只包含：核心功能;没有模板解析器
    2.因为vue.runtime.xxx.js没有模板解析器,所以不能使用template配置项,需要使用render函数接受到的createElement函数去指定具体内容

vue.config.js配置文件

使用vue inspect>output.js可以查看都Vue脚手架的默认配置。
使用vue.config.js可以对脚手架进行个性化定制，详情见：https://cli.vuejs.org/zh/config

ref属性

    1.被用来给元素或子元素注册引用信息（id的替代者）
    2.应用在html标签上获取真实的dom,应用在组件标签上是组件实例对象(vc)
    3.使用方式：
            打标识:<h1 ref="xxx">......</h1>或<School ref="xxx"></School>
            获取：this.refs.xxx 

配置项props

    功能：让组件接受外部传过来的数据
         (1).传递数据：
                <Demo name="xxx"/>
         (2).接收数据：
                第一种方式(只接受)
                    props:['name']
                第二种方式(限制类型):
                    props:{
                        name:Number
                    }
                第三种方式(限制类型、限制必要性、指定默认值);
                    props:{
                        name:{
                            type:String,//类型
                            required:true,//必要性
                            default:'老王'//默认值
                        }
                    }
         (3).备注
                props是只读的,Vue底层会检测你对props的修改，如果进行了修改,就会发出警告，若业务需求确定需要修改,那么请复制props的内容到data中一份，然后去修改data中的数据，所有的 props 都遵循着单向绑定原则，props 因父组件的更新而变化，自然地将新的状态向下流往子组件，而不会逆向传递。这避免了子组件意外修改父组件的状态的情况，不然应用的数据流将很容易变得混乱而难以理解。

mixin(混入)

    功能：可以把多个组件共用的配置提取成一个混入对象
    使用方式：
            第一步定义混合,列如：
                {
                    data(){
                        ....
                    },
                    methods:{...}
                    .....
                }
            第二步使用混入,列如：
                (1).全局混入：Vue.mixin(xxx)
                (2).局部混入:mixins:['xxx']

插件

    功能：用于增强Vue
    本质：包含install方法的一个对象，install的第一个参数是Vue,第二个以后的参数是插件使用者传递的数据
    定义插件：
        对象.install=function(Vue,options){
            //1.添加的全局过滤器
            Vue.filter(...)
            //2.添加全局指令
            Vue.directive(...)
            //3.配置全局混入(合)
            Vue.mixin(...)
            //4.添加实例方法
            Vue.prototype.$myMethod=function(){...}
            Vue.prototype.$myProperty=xxx
        }
    使用插件：Vue.use()

scoped样式

    作用：让样式在局部生效,防止冲突
    写法:<style scoped>

总结TOdoList案例

1.组件化编码流程：

(1)拆分静态组件：组件要按照功能点拆分，命名不要与html元素冲突。
(2)实现动态组件：考虑好数据的存放位置，数据是一个组件在用，还是一些组件再用：
    1).一个组件在用：放在组件自身即可。
    2）.一些组件在用：放在他们共同的父组件上(``状态提升``)
(3).实现交互:从绑定事件开始。

2.props适用于：

(1).父组件===>子组件 通信
(2)。子组件==>父组件 通信（要求父组件先给子组件一个函数）

3.使用v-model时要记住:v-mdeol绑定的值不能是props传过来的值，因为props是不可以修改的！

4.props传过来的若是对象类型的值，修改对象中的属性时Vue不会报错,但不推荐这样做

组件的自定义事件

1.一种组件间通信的方式,适用于：**子组件===》父组件**
2.使用场景：A是父组件,B是子组件，B想给A传数据,那么久要在A中给B绑定自定义事件(事件的回调在A中)
3.绑定自定义事件：
     1.第一种方式,在父组件中：<Demo @hahah="test"/>或<Demo v-on:hahah="test"/>
     2.第二种方式，在父组件中

    <Demo ref="demo"/>
    .....
    mounted(){
        this.#refs.xxx.$on('haha',this.test)
    }

     3.若想让自定义事件只能触发一次，可以使用once修饰符，或$once方法。

4.触发自定义事件：this.$emit('hahha',数据)
5.解绑自定义事件：this.$off('haha')，解绑多个：this.$off(['haha'])，全部解绑：this.$off()
6.组件上可以绑定原生DOM事件,需要使用native修饰符。
7.注意：通过this.$refs.xxx.$on('haha',回调)绑定自定义事件,回调要么配置在methods中,要么用箭头函数``,否则this指向会出问题

全局事件总线(GlobalEvnetBus)

1.一种组件通信的方式,适用于任何组件间通信。

2.安装全局事件总线:

new Vue({
	......
	beforeCreate(){
		Vue.prototype.$bus=this//安装全局事件总线，$bus就是当前应用的vm
	}
})

3.使用事件总线：

​ 1.接受数据：A组件想接受数据,则在A组件中给$bus绑定自定义事件，事件的回调留在A组件自身。

methods(){
	demo(data){
		.....
	}
}
....
mounted(){
	this.$bus.$on('xxx',this.demo)
}
....
beofreDestory(){
	this.$bus.off('xxx')
}

​ 2.提供数据:this.$bus.$emit(‘xxxx’,‘数据’)

4.最好在beforeDestory钩子中，用$off去解绑`当前组件所用到的事件

消息订阅与发布(pubsub)

​ 1.一种组件间通信的方式，适用于任意组件通信

​ 2.使用步骤:

​ 1.安装pubsub:npm i pubsub-js

​ 2.引入:import pubsub from ‘pubsub-js’

​ 3.接收数据：A组件想接受数据，则在A组件中订阅消息,订阅的回调留在A组件自身

methods(){
	demo(data){......}
}
.....
    mounted() {
        //订阅消息
        this.pid = pubsub.subscribe('show', (subName, name) => {
            this.name = name;
            console.log(name + "，替换成功," + subName);
        })
    },
    beforeDestroy() {
        pubsub.unsubscribe(this.pid)//取消订阅
    }

​ 4.提供数据：pubsub.publish(‘xxx’,数据)

​ 5.最好在beforDestroy钩子中，用 pubsub.unsubscribe(this.pid)去取消订阅

nextTick(钩子函数)

​ 1.语法：this.$nextTick(回调函数)

​ 2.作用：在下一次DOM更新结束后执行其指定代码的回调

​ 3.什么时候用:当改变数据后，要基于更新后的新DOM进行某些操作时，要在nextTick所指定的回调函数中执行

动画

属性	描述
transition	简写属性，用于将四个过渡属性设置为单一属性。
transition-delay	规定过渡效果的延迟（以秒计）。
transition-duration	规定过渡效果要持续多少秒或毫秒。
transition-property	规定过渡效果所针对的 CSS 属性的名称。
transition-timing-function	规定过渡效果的速度曲线。****

Vue封装的过渡与动画

1.作用:在插入、更新或移除DOM元素时,在合适的时候给元素添加样式类名。

3.写法

​ 1.准备好样式：

​ 元素进入的样式:

​ 1.v-enter:进入的起点

​ 2.v-enter-active:进入过程

​ 3.v-enter-to：进入终点

​ 离开样式:

​ 1.v-leave:离开起点

​ 2.v-leave-active:离开过程

​ 3.v-leave-to：离开终点

​ 2.使用<transition>包裹要过渡的元素，并配置name属性：

<transition name="hello" appear>
		<h1 v-show="isShow">你好啊</h1>
</transition>

​ 3.备注：若多个元素需要过渡，则使用：<transition-group>,且每一个元素都要指定key值。appear初次加载触发

4.进入离开触发条件

​ <Transition> 是一个内置组件，这意味着它在任意别的组件中都可以被使用，无需注册。它可以将进入和离开动画应用到通过默认插槽传递给它的元素或组件上。进入或离开可以由以下的条件之一触发：

• 由 v-if 所触发的切换
• 由 v-show 所触发的切换
• 由特殊元素 <component> 切换的动态组件
• 改变特殊的 key 属性

vue脚手架配置代理

方法一

​ 在vue.config.js中添加如下配置：

devServer:{
    proxy:'http://localhsot:5000'
}

说明：

​ 1.优点：配置简单，请求资源时直接发给前端 (8080)即可。

​ 2.缺点：不能配置多个代理，不能灵活的控制请求是否走代理

​ 3.工作方式：若按照上述配置代理，当请求了前端不存在的资源时，那么该请求会转发给服务器(优先匹配前端资源)

方法二

编写vue.config.js配置具体代理规则：

const { defineConfig } = require('@vue/cli-service')
module.exports = defineConfig({
  transpileDependencies: true,
  lintOnSave: false,
  devServer: {
    proxy: {
      '/api': {//匹配所有以，'/api'开头的请求路径
        target: 'http://localhost:9999',//代理目标的基础路径
        changeOrigin: true,
        pathRewrite:{'^/api':''} //把请求的路径中/api替换成''
      }
    }
  }
})
   /**
   	changeOrigin设置为true时候，服务器收到的请求头中的host为：localhsot：9999
   	changeOrigin设置为false时候，服务器收到的请求头中的host为：前端运行项目的端口ip(8080),
   	默认changeOrigin为true

说明：

​ 1.优点：可以配置多个代理，且可以灵活的控制请求是否走代理

​ 2.缺点：配置略微繁琐，请求资源时必须加前缀

插槽

1.作用：让父组件可以向子组件指定位置插入html结构，也是一种组件间通讯的方式，适用于父组件—》子组件。

2.分类：默认插槽，具名插槽，作用域插槽

3.使用方式：

​ 1.默认插槽：

     <!-- 子插槽 -->
<template>
    <div class="container">
        <h4>{{ titel }}</h4>
        <!-- 定义插槽 -->
        <slot>这是一个默认插槽</slot>
    </div>
</template>
     <!-- 父插槽 -->
 <categrop-vue titel="美食分类">
            <img src="favicon.ico" alt="">
  </categrop-vue>

​ 2.具名插槽

     <!-- 子插槽 -->
   <div class="container">
        <h4>{{ titel }}</h4>
        <slot>这是一个默认插槽</slot>
          <!-- 具名插槽-->
        <slot name="footer">这是一个name插槽</slot>

    </div>
     <!-- 父插槽 -->
 <categrop-vue titel="游戏分类">
            <ul style="list-style: none;">
                <li v-for="item in game">{{ item }}</li>
            </ul>
            <div class="conter" slot="footer">
                <a href="">单机游戏</a>
                <a href="">网络游戏</a>

            </div>
</categrop-vue>

​ 3.作用域插槽

​ 1.l理解：数据在组件自身，但根据数据生成的结构需要用组件的使用者来决定。（games数据在Categrop组件中，但使用数据所遍历出来的结构由App自身决定；。

     <!-- 子插槽 -->
    <div class="container">
        <h4>{{ titel }}</h4>
             <!-- 要将指定数据传递给父组件 -->
        <slot :game="game">这是一个默认插槽</slot>
        <slot name="footer">这是一个name插槽</slot>

    </div>
     <!-- 父插槽 -->
 <categrop-vue titel="美食分类">
            <div class="conter" slot="footer">
                <a href="">更多美食</a>
            </div>
             <!-- 获取子组件数据方式1 -->
            <template scope="{game}">
                <img src="favicon.ico" alt="">
                <ul style="list-style: none;">
                    <li v-for="item in game">{{ item }}</li>
                </ul>
                <!-- 父元素数据传入子插槽 多个子组件共用同一个父元素数据-->
                <ul style="list-style: none;">
                    <li v-for="item in movie">{{ item }}</li>
                </ul>
                <button @click="movie.shift()">删除父元素</button>
            </template>
        </categrop-vue>
        <categrop-vue titel="游戏分类">
                         <!-- 获取子组件数据方式2 -->
            <template slot-scope="{game}">
                <!-- 子元素数据在子插槽 作用域为当前-->
                <ul style="list-style: none;">
                    <li v-for="item in game">{{ item }}</li>
                </ul>
                <button @click="game.shift()">删除子元素</button>
                <!-- 父元素数据传入子插槽 多个子组件共用同一个父元素数据-->
                <ul style="list-style: none;">
                    <li v-for="item in movie">{{ item }}</li>
                </ul>
                <button @click="movie.shift()">删除父元素</button>
            </template>

            <div class="conter" slot="footer">
                <a href="">单机游戏</a>
                <a href="">网络游戏</a>

            </div>
 </categrop-vue>
    

Vuex

1.概念

Vuex 是一个专为 Vue.js 应用程序开发的状态管理模式 + 库。它采用集中式存储管理应用的所有组件的状态，并以相应的规则保证状态以一种可预测的方式发生变化。

2.安装搭建

npm install vuex --save

import Vue from "vue"
import vuex from "vuex"
//为啥vuex要注册到vue才可以使用vuex因为vuex的底层用到了vue
Vue.use(vuex)
//保存具体数据
const state = {

}
//支持异步发送 响应组件中用户的动作
const actions = {
   
}
//修改state中的数据
const mutations = {
   
}
//创建并暴露Store
export default new vuex.Store({
    state,
    actions,
    mutations
})

main文件中：

// 该文件是整个项目的入口文件
//引入vue
import Vue from 'vue'
//引入App组件，它是所有组件的父组件
import App from './App.vue'
import store from './store'
//关闭vue的产生提示
Vue.config.productionTip = false
//注册插件
new Vue({
  store,
  render: h => h(App),
  beforeCreate() {
    Vue.prototype.$bus = this;
  }
}).$mount('#app')

3.基本使用

1.初次化数据、配置actions、配置mutations,操作文件store.js

import Vue from "vue"
import vuex from "vuex"
//为啥vuex要注册到vue才可以使用vuex因为vuex的底层用到了vue
Vue.use(vuex)
const state = {
    number: 100
}
//支持异步发送
const actions = {
    incrementOdd(context, value) {
        if (value % 2 === 0) {
            context.commit('increment', value)
        }
    },
    incrementWait(context, value) {
        setTimeout(() => {
            context.commit('incrementWait', value)
        }, 2000);
    }
}
const mutations = {
    increment(state, value) {
        state.number += value;
    },
    decrement(state, value) {
        state.number -= value;
    },
    incrementOdd(state, value) {
        state.number += value;

    },
    incrementWait(state, value) {
        state.number += value;
    }
}

export default new vuex.Store({
    state,
    actions,
    mutations
})

2.组件中读取vuex中的数据：$store.state.sum

3.组件中修改vuex的数据：$store.dispatch(‘action中的方法名’数据)或$store.comit(‘mutations中的方法名’,数据)

备注：若没有网络请求或其他业务逻辑，组件中也可以越过actions,既不写dispatch,直接编译commit

4.getters的使用

1.概念：当store中的数据需要经过加工后在使用时，可以使用getters加工。

2.在store.js中追加getters配置

//对state中数据进行加工，像极了computed监听data
const getters = {
    number(state) {
        return state.number * 10;
    }
}
export default new vuex.Store({
    state,
    actions,
    mutations,
    getters
})

3.组件中读取数据：$store.getters.number

5.四个map方法使用

1.mapState方法：用于帮助我们映射State中的数据为计算属性，既简化了:$store.state

   computed: {
        //借助mapState生成计算属性：number（对象写法）
        // ...mapState({ number: 'number' }),
        //借助mapState生成计算属性：number（数组写法）
        ...mapState(['number'])
    },

2.mapGetters方法：用于帮助我们映射getters中的计算属性，帮我们省略了:$store.getters

 computed: {
         //借助mapGetters生成计算属性：getNumber（对象写法）
        // ...mapGetters({ getNumber: 'getNumber' })
       //借助mapGetters生成计算属性：getNumber（数组写法）
        ...mapGetters(['getNumber'])
    }

3.mapActions方法：用于帮助我们生成与actions对话的方法：既：包含$store.dispatch(xxx)的函数

  methods: {
        //靠mapActions生成：incrementWait,incrementOdd(对象形式)
        // ...mapActions({ incrementWait: 'incrementWait', incrementOdd: 'incrementOdd' }),
        //靠mapActions生成：incrementWait,incrementOdd(数组形式)
        ...mapActions(['incrementWait', 'incrementOdd']),
    }

4.mapMutations方法：用于帮我们生成mutations对话的方式，即：包含$store.commit(xxx)函数

methods:{
	    //靠mapMutations生成：increment,decrement(对象形式)
        // ...mapMutations({ increment: 'increment', decrement: 'decrement' }),
        //靠mapMutations生成：increment,increment(数组形式)
        ...mapMutations(['increment', 'decrement'])
}

备注：mapMutations、mapActions使用时，若需要传递参数需要：在模板中绑定事件时传递好参数,否则参数是事件对象``

6.模块化+命名空间

1.目的：让代码更好维护，让多种数据分享更加明确

2.修改store.js

import Vue from "vue"
import vuex from "vuex"
import axios from 'axios'
//为啥vuex要注册到vue才可以使用vuex因为vuex的底层用到了vue
Vue.use(vuex)
const ShopList = {
	//开启命名空间
    namespaced: true,
    actions: {
        items(context, value) {
            axios.get('https://api.uixsj.cn/hitokoto/get?type=social').then(
                rep => {
                    value.name = rep.data;
                    context.commit('items', value)

                },
                err => {
                    console.log(err)
                }
            )
        }
    },
    mutations: {
        items(state, value) {
            state.items.push(value)
        }
    },
    state: {
        items: [
            { id: '001', name: '张三1' },
            { id: '002', name: '张三2' },
            { id: '003', name: '张三3' },
            { id: '004', name: '张三4' }
        ]
    },
    getters: {

    }
}
const Count = {
	//开启命名空间
	namespaced: true,
    actions: {
        incrementOdd(context, value) {
            if (context.state.number % 2 === 0) {
                context.commit('increment', value)
            }
        },
        incrementWait(context, value) {
            setTimeout(() => {
                context.commit('incrementWait', value)
            }, 2000);
        }
    },
    mutations: {
        increment(state, value) {
            state.number += value;
        },
        decrement(state, value) {
            state.number -= value;
        },
        incrementOdd(state, value) {
            state.number += value;

        },
        incrementWait(state, value) {
            state.number += value;
        }
    },
    state: {
        number: 100

    },
    getters: {
        getNumber(state) {
            return state.number * 10;
        }
    }
}

export default new vuex.Store({
    modules: {
        ShopList,
        Count
    }
})

3.开启命名空间后，组件中读取state数据：

//方式一：直接读取
this.$store.state.ShopList.items
//方式二：借助mapState读取：
...mapState('ShopList'，['items'])

4.开启命名空间后，组件中读取getters数据：

//方式一：直接读取
this.$store.getters.Count.getNumber
//方式二：借助mapGetters读取：
...mapGetters('Count'，['getNumber'])

5.开启命名空间后，组件中调用dispatch

//方式一：直接读取
this.$store.dispatch('Count/incrementOdd',value)
//方式二：借助mapGetters读取：
...mapActions('Count'，['incrementOdd','incrementWait'])

6.开启命名空间后，组件中调用commit

//方式一：直接读取
this.$store.commit('Count/increment',value)
//方式二：借助mapGetters读取：
...mapMutations('Count'，['increment','decrement'])

路由

1.基本使用

1.安装vue-router,命令npm i vue-router

2.应用插件Vue.use(VueRouter)

3.编写router配置项

//改文件专门用于创建整个程序的路由器
import VueRouter from "vue-router";
//引入组件
import About from '../components/About.vue'
import Home from '../components/Home.vue'
//创建router实例对象，去管理一组一组的路由规则
export default new VueRouter({
    routes: [
        {
            path: '/about',
            component: About
        },
        {
            path: '/home',
            component: Home
        }
    ]
})
//暴露router

4.实现切换（active-class可配置高亮切换样式)

 <router-link to="/about" active-class="active">关于</router-link>

5.指定展示位置

<RouterView></RouterView>

2.几个注意点

1.路由组件通常存放在pages文件夹，一般组件通常存放在components文件夹

2.通过切换,”隐藏“了的路由组件，默认是被销毁的，需要的时候在去挂载。

3.每个组件都有自己的route属性，里面存储着自己的路由信息

4.整个应用只有一个roter，可以通过组件的$router属性获取。

3.多级路由

1.配置路由规则，使用children配置项：

//创建一个路由器
export default new VueRouter({
    routes: [
        {
            path: '/about',
            component: About,
            children: [//通过children配置子级路由
                {
                    path: 'demo1',//此处一定不要写：/demo1
                    component: Demo1
                },
                {
                    path: 'demo2',//此处一定不要写：/demo2
                    component: Demo2
                }
            ]
        },
        {
            path: '/home',
            component: Home
        }
    ]
})

2.跳转（要写完整路径）：

 <router-link to="/about/demo1">demo1</router-link>

4.路由的query参数

1.传递参数

 <o1>
            <!-- 跳转并携带参数query参数，to的字符串写法 -->
            <li v-for="item in list" :key="item.id">
                <router-link :to="`/home/Detail?id=${item.id}&name=${item.name}`">{{ item.name }}</router-link>
            </li>
            <!-- 传递并携带参数对象写法 -->
            <li v-for="item in list" :key="item.id">
                <router-link :to="{
                    path: '/home/Detail',
                    query: {
                        id: item.id,
                        name: item.name
                    }
                }">{{ item.name }}</router-link>
            </li>
   </o1>
   <router-view></router-view>

2.接受参数：

$route.query.id
$route.query.title

5.命名路由

1.作用：可以简化路由的跳转（name)

//创建一个路由器
export default new VueRouter({
    routes: [
        {
		//起一个路由名字
            name: 'about',
            path: '/about',
            component: About,
            children: [//通过children配置子级路由
                {
                    name: 'demo1',
                    path: 'demo1',//此处一定不要写：/demo1
                    component: Demo1
                },
                {
	//起一个路由名字
                    name: 'demo2',
                    path: 'demo2',//此处一定不要写：/demo2
                    component: Demo2
                }
            ]
        },

2.简化跳转：

   <!-- 简化前 -->
        <router-link to="/about/demo1">demo1</router-link>
        <!-- 简化后，直接通过name跳转 -->
        <router-link :to="{ name: 'demo1' }">demo1</router-link>
        <!-- 简化版，配合传参 -->
        <router-link :to="{
            name: 'hello', query: {
                id: '666',
                titel: '张三'
            }
        }">demo1</router-link>

6.路由的params参数

1.配置路由，声明接收params参数

export default new VueRouter({
    routes: [
        {
            name: 'about',
            path: '/about',
            component: About,
            children: [//通过children配置子级路由
                {
                    name: 'demo1',
                    path: 'demo1',//此处一定不要写：/demo1
                    component: Demo1
                },
                {
                    name: 'demo2',
                    path: 'demo2',//此处一定不要写：/demo2
                    component: Demo2
                }
            ]
        },
        {
            name: 'home',
            path: '/home',
            component: Home,
            children: [//通过children配置子级路由
                {
                    name: 'Detail',
                    path: 'Detail/:id/:titel',//使用占位符声明接受params参数
                    component: Detail
                }
            ]
        }
    ]
})

2.传递参数

  <o1>
            <!-- 跳转并携带参数query参数，to的字符串写法 -->
            <li v-for="item in list" :key="item.id">
                <router-link :to="`/home/Detail/${item.id}/${item.name}`">{{ item.name }}</router-link>
            </li>
            <!-- 传递并携带参数对象写法
			路由携带params参数时，若使用to的对象写法,则不能使用path配置项，必须使用name配置!-->
      
            <li v-for="item in list" :key="item.id">
                <router-link :to="{
                    name: 'Detail',
                    params: {
                        id: item.id,
                        name: item.name
                    }
                }">{{ item.name }}</router-link>
            </li>
        </o1>
   <router-view></router-view>

特别注意：路由携带params参数时，若使用to的对象写法,则不能使用path配置项，必须使用name配置!

3.接收参数

$route.params.id
$route.params.name

7.路由的props配置

作用：让路由组件更方便收到参数

 {
            name: 'home',
            path: '/home',
            component: Home,
            children: [
                //通过children配置子级路由
                {
                    name: 'detail',
                    path: 'detail',//使用占位符声明接受params参数
                    component: Detail,
                    //第一种写法，props值为对象，该对象中所有的key-value的组合最终都会通过props传递给Detail组件
                    // props: { a: '张三', b: '李四' }
                    // 第二种写法，值为布尔，若为真，就会把该路由组件收到的所有params参数，以props的形式给Detail组件
                    // props: true
                    // 第三种写法，值为函数
                    props($route) {
                        return { id: $route.query.id, titel: $route.query.titel }
                    }
				//es6
				// props({ query: { id, titel } }) {
                    //    return { id, titel }
                   // }
                }
            ]
    }

8.的replace属性

1.作用：控制路由跳转时操作浏览器历史记录的模式，底层是通过队列实现

2.浏览器的历史记录有两种写入方式：分别为push和replace，push是追加历史记录，replace是替换当前记录，路由跳转时候默认为push

3.如何开启replace模式:<router-link replace……>News</router-link>

9.编程式路由导航

1.作用：不借助<router-link>实现路由跳转，让路由跳转更加灵活

2.具体编码：

//跳转路由两个api 底层是promis实现的
  toRouter(m) {
            this.$router.push({
                name: 'detail',
                params: {
                    id: m.id,
                    name: m.name
                }
            }).catch(err => { err })
  },
   toReplace(m) {
            this.$router.replace({
                name: 'detail',
                params: {
                    id: m.id,
                    name: m.name
                }
            }).catch(err => { err })
   }
     this.$router.forward();//前进
     this.$router.back();//后退
  	this.$router.go(1);//可前进也可后退
          

10.缓存路由组件

1.作用：让不展示的路由组件保持挂载，不被销毁。include=“组件名”

2.具体编码：

<keep-alive include="News">
	<router-view></router-view>
</keep-alive>
//缓存多个
<keep-alive :include="['News','New2">
	<router-view></router-view>
</keep-alive>

11.路由里面的两个钩子函数

1.作用：路由组件所独有的两个钩子，用于捕获路由组件的激活状态。

2.具体名字：

​ 1.activated 路由组件被激活时触发

​ 2.deactivated路由组件失活时触发

12.路由守卫

1.作用：对路由进行权限控制

2.分类：全局守卫、独享守卫、组件守卫

3.全局守卫

//全局前置路由；初始化执行、每次路由切换前执行
router.beforeEach((to, form, next) => {
 console.log(to, from,"@before");
    if (to.meta.isAuth === true) {
        if (localStorage.getItem('user') === 'admin') {
            next()
        } else {
            alert("权限不够")
        }
    } else {
        next()
    }
})
//全局后置守卫，初始化时执行，每次路由切换后执行
router.afterEach((to, from) => {
    console.log(to, from,"@after");
    document.title = to.meta.titel || '优品汇'//修改网页titel
})

4.独享路由守卫(可以配合全局后置路由守卫用)

  children: [
                //通过children配置子级路由
                {
                    name: 'detail',
                    path: 'detail',//使用占位符声明接受params参数
                    component: Detail,
                    meta: {
                        isAuth: true,
                        titel: '契合'
                    },
                    //独享路由守卫
                    beforeEnter(to, form, next) {
                        console.log(to)
                        console.log(form);
                        if (to.meta.isAuth === true) {//判断当前路由是否需要权限控制
                            if (localStorage.getItem('user') === 'admin') {
                                next()
                            } else {
                                alert("权限不够")
                            }
                        } else {
                            next()
                        }

                        console.log("===============================")
                    }
                }
            ]

5.组件内守卫

 //进入守卫，通过路由规则，进入该组件时被调用
    beforeRouteEnter(to, from, next) {
        console.log("进入守卫路由beforeRouteEnter");
        next();
    },
    //离开守卫，通过路由规则，离开该组件时被调用
    beforeRouteLeave(to, from, next) {
        console.log("进入守卫路由beforeRouteEnter");
        next();
    }

13.路由器的两种工作模式

1.对一个url来说，什么是hash值？——#及其后面的内容就是hash值

2.hash值不会包含在http请求中，既：hash值不会带给服务器

3.hash模式

​ 1.地址中永远带着#号，不美观

​ 2.若以后将地址通过第三方手机app分享，若app校验严格，则地址会被标记为不合格。

​ 3.兼容性较好

4.history模式：

​ 1.地址干净，美观

​ 2.兼容性和hash模式的相比略差

​ 3.应用部署上线时需要后端人员支持，解决刷新页面服务器404的问题

5.abstract模式：

​ 隐藏路径

欢迎使用Markdown编辑器

你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。

新的改变

我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客：

1. 全新的界面设计 ，将会带来全新的写作体验；
2. 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示；
3. 增加了 图片拖拽 功能，你可以将本地的图片直接拖拽到编辑区域直接展示；
4. 全新的 KaTeX数学公式 语法；
5. 增加了支持甘特图的mermaid语法¹ 功能；
6. 增加了 多屏幕编辑 Markdown文章功能；
7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能，功能按钮位于编辑区域与预览区域中间；
8. 增加了 检查列表 功能。

功能快捷键

撤销：Ctrl/Command + Z
重做：Ctrl/Command + Y
加粗：Ctrl/Command + B
斜体：Ctrl/Command + I
标题：Ctrl/Command + Shift + H
无序列表：Ctrl/Command + Shift + U
有序列表：Ctrl/Command + Shift + O
检查列表：Ctrl/Command + Shift + C
插入代码：Ctrl/Command + Shift + K
插入链接：Ctrl/Command + Shift + L
插入图片：Ctrl/Command + Shift + G
查找：Ctrl/Command + F
替换：Ctrl/Command + G

合理的创建标题，有助于目录的生成

直接输入1次#，并按下space后，将生成1级标题。
输入2次#，并按下space后，将生成2级标题。
以此类推，我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

如何改变文本的样式

强调文本 强调文本

加粗文本 加粗文本

标记文本

删除文本

引用文本

H₂O is是液体。

2¹⁰ 运算结果是 1024.

插入链接与图片

链接: link.

图片:

带尺寸的图片:

居中的图片:

居中并且带尺寸的图片:

当然，我们为了让用户更加便捷，我们增加了图片拖拽功能。

如何插入一段漂亮的代码片

去博客设置页面，选择一款你喜欢的代码片高亮样式，下面展示同样高亮的 代码片.

// An highlighted block
var foo = 'bar';

生成一个适合你的列表

• 项目
  • 项目
    • 项目

1. 项目1
2. 项目2
3. 项目3

• 计划任务
• 完成任务

创建一个表格

一个简单的表格是这么创建的：

项目	Value
电脑	$1600
手机	$12
导管	$1

设定内容居中、居左、居右

使用:---------:居中
使用:----------居左
使用----------:居右

第一列	第二列	第三列
第一列文本居中	第二列文本居右	第三列文本居左

SmartyPants

SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如：

TYPE	ASCII	HTML
Single backticks	'Isn't this fun?'	‘Isn’t this fun?’
Quotes	"Isn't this fun?"	“Isn’t this fun?”
Dashes	-- is en-dash, --- is em-dash	– is en-dash, — is em-dash

创建一个自定义列表

Markdown

Text-to- HTML conversion tool

Authors

John

Luke

如何创建一个注脚

一个具有注脚的文本。²

注释也是必不可少的

Markdown将文本转换为 HTML。

KaTeX数学公式

您可以使用渲染LaTeX数学表达式 KaTeX:

Gamma公式展示 $\Gamma (n)=(n-1)!\forall n\in \mathbb{N}$ 是通过欧拉积分

$$\Gamma (z)={\int }_0^{\infty }{t}^{z-1}{e}^{-t}dt.$$

你可以找到更多关于的信息 LaTeX 数学表达式here.

新的甘特图功能，丰富你的文章

• 关于 甘特图 语法，参考 这儿,

UML 图表

可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图：

这将产生一个流程图。:

• 关于 Mermaid 语法，参考 这儿,

FLowchart流程图

我们依旧会支持flowchart的流程图：

• 关于 Flowchart流程图 语法，参考 这儿.

导出与导入

导出

如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ，生成一个.md文件或者.html文件进行本地保存。

导入

如果你想加载一篇你写过的.md文件，在上方工具栏可以选择导入功能进行对应扩展名的文件导入，
继续你的创作。

---

1. mermaid语法说明 ↩︎

2. 注脚的解释 ↩︎