Blog of CodeJELLOW’S ENGINEERING NOTES
← 返回文章

VUE3之Composition API(一)

VUE3之Composition API(一) mixin和extends setup reactive API ref API readOnly

mixin和extends

mixin的基本使用

mixin本质上是一个对象,其中可以包含一个组件的option属性:

TEXT
export const demoMixin = {
    data() {
        return {
            message:"hello demoMixin"
        }
    },
    methods: {
        foo(){
            console.log("demo mixin foo");
        }
    },
    created() {
        console.log("执行了demo mixin");
    },
}

在使用时,写在组件的options的mixins属性里面:

TEXT
<script>
import {demoMixin} from './mixins/demoMixin.js'
    export default {
        mixins:[demoMixin],
        data() {
            return {
                title: "hello world"
            }
        },
        methods: {
            
        },
    }
</script>

如果mixin与组件中不存在命名冲突,就直接合并,如果存在冲突,分成不同情况处理:

返回值对象默认情况下会合并,如果data返回值对象的属性发生了冲突,那么会保留组件自身的数据。

生命周期钩子函数会被合并到数组中,都会被调用。

对于methods、computed这种对象,会直接合并,如果对象的key相同,则采用组件的value。

全局mixin

全局mixin是直接调用app实例的mixin方法,并传入mixin对象完成的,所有app的组件都会享有全局mixin的内容:

TEXT
const app=createApp(App);
app.mixin({
    created() {
        console.log("全局的生命周期")
    },
})
app.mount('#app');

extends

extends类似于OOP的继承,可以让一个页面继承于另一个页面:

TEXT
// BasePage.vue
<script>
    export default {
        data() {
            return {
                title:"hello page"
            }
        },
        methods: {
            bar(){
                console.log("base page bar");
            }
        },
    }
</script>
TEXT
// Home.vue
<template>
    <div>
        home page
        <h2>{{title}}</h2>
        <button @click="bar">按钮</button>
    </div>
</template>

<script>
import BasePage from './BasePage.vue';
    export default {
        extends:BasePage
    }
</script>

extends的规则和用法与mixin相同,并且只能继承父组件的script标签的内容。

setup

setup的两个参数:props和context

组件定义props的方式与之前相同。setup中要是想使用props,直接使用第一个传入的参数,而不能使用this来获取。

context包含三个属性:attrs、slots、emit

TEXT
<script>
    export default {
        props:{
            message:{
                type:String,
                require:true
            }
        },
        /**
         * 参数一:props,父组件传递过来属性
         * 参数二:context,包含三个属性:attrs slots emit
         */
        // setup(props, context) {
        //     console.log(props.message);
        //     console.log(context.attrs.id,context.attrs.class);
        //     console.log(context.slots);
        //     console.log(context.emit);
        // }
        // 解构
        setup(props, {attrs,slots,emit}) {
            console.log(props.message);
            console.log(attrs.id,attrs.class);
            console.log(slots);
            console.log(emit);
        }
    }
</script>

setup方法可以有返回值,返回值是一个对象,类似于原先options中的data:

TEXT
<template>
    <div>
        home page
        <h2>{{message}}</h2>

        <h2>{{title}}</h2>
        <h2>当前计数: {{counter}}</h2>
        <button @click="increment">+1</button>
    </div>
</template>

<script>
    export default {
        props:{
            message:{
                type:String,
                require:true
            }
        },
        setup() {
            let counter=100;
            // 局部函数
            const increment=()=>{
                counter++;
                console.log("button click");
            }
            return {
                title:"hello home",
                counter,
                increment
            }
        }
    }
</script>

但是这里定义的counter不具有响应式,setup中的局部函数不能改变界面。

reactive API

使用reactive包裹数据使之成为响应式的:

TEXT
<template>
    <div>
        <h2>当前计数: {{state.counter}}</h2>
        <button @click="increment">+1</button>
    </div>
</template>

<script>
import {reactive} from 'vue';
    export default {
        setup() {
            const state = reactive({
                counter:100
            });
            // 局部函数
            const increment=()=>{
                state.counter++;
                console.log("button click",state.counter);
            }
            return {
                state,
                increment
            }
        }
    }
</script>

ref API

reactive API的弊端是,必须传入一个对象或者数组,对于number类型的例如100等不能进行响应式。ref API可以做到这一点,在使用上稍有不同:

TEXT
<template>
    <div>
        home page
        <!-- 当在template中使用ref对象时,会自动解包counter->value -->
        <h2>当前计数: {{counter}}</h2>
        <button @click="increment">+1</button>
    </div>
</template>

<script>
import { ref } from 'vue';
    export default {
        setup() {
            // counter变成了ref可响应式的引用
            let counter = ref(100);
            
            const increment=()=>{
                // 但是在这里不会自动解包
                counter.value++;
                console.log("button click",counter.value);
            }
            return {
                counter,
                increment
            }
        }
    }
</script>

此处counter变成了一个ref对象,在代码中需要使用counter.value来获取值,但是在template中,vue3已经自动完成了解包的功能。这种解包是浅层的解包:

TEXT
<template>
    <div>
        home page
        <!-- 当在template中使用ref对象时,会自动解包counter->value -->
        <h2>当前计数: {{counter}}</h2>
        <!-- ref解包是浅层解包 -->
        <h2>当前计数{{info.counter.value}}</h2>
        <!-- 用reactive包裹就可以解包 -->
        <h2>当前计数{{reactiveInfo.counter}}</h2>
        <button @click="increment">+1</button>
    </div>
</template>

<script>
import { reactive, ref } from 'vue';
    export default {
        setup() {
            // counter变成了ref可响应式的引用
            let counter = ref(100);
            const info ={counter};
            const reactiveInfo = reactive({
                counter
            })
            
            const increment=()=>{
                // 但是在这里不会自动解包
                counter.value++;
                console.log("button click",counter.value);
            }
            return {
                counter,
                info,
                reactiveInfo,
                increment
            }
        }
    }
</script>

readOnly

将任意一个对象设置为不可修改的:

TEXT
<template>
    <div>
        home page
        <button @click="updateState">修改状态</button>
    </div>
</template>

<script>
import { reactive,ref,readonly } from 'vue';
    export default {
        setup() {
            // 普通对象
            const info1 ={name:"sk"};
            const readOnlyInfo1 = readonly(info1);
            // 响应式对象reactive
            const info2 = reactive({
                name:"sk"
            });
            const readOnlyInfo2 = readonly(info2);
            // 响应式对象ref
            const info3=ref("sk");
            const readOnlyInfo3 = readonly(info3);
            const updateState=()=>{
                // readOnlyInfo1.name="123";
                // readOnlyInfo2.name="123";
                readOnlyInfo3.value="123";
            }
            return {
                updateState
            }
        }
    }
</script>

通过 RSS 订阅更新 →