怎么快速上手vue3
这篇“怎么快速上手vue3”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“怎么快速上手vue3”文章吧。
创新互联建站服务项目包括叙永网站建设、叙永网站制作、叙永网页制作以及叙永网络营销策划等。多年来，我们专注于互联网行业，利用自身积累的技术优势、行业经验、深度合作伙伴关系等，向广大中小型企业、政府机构等提供互联网行业的解决方案，叙永网站推广取得了明显的社会效益与经济效益。目前，我们服务的客户以成都为中心已经辐射到叙永省份的部分城市，未来相信会继续扩大服务区域并继续获得客户的支持与信任！
全局 API 和应用 API
vue3的一个新概念，返回一个提供应用上下文的应用实例,应用实例挂载的整个组件树共享同一个上下文:
const app = createApp(App);
app.use(store).use(router).mount("#app");vue2：
new Vue({
router,
store,
render: (h) => h(App),
}).$mount("#app");然后以前用Vue.的那些API都变成用这个应用实例app.：
| vue2 | vue3 | | Vue.component | app.component |
| app.config | app.config |
| app.directive | app.directive |
| app.mixin | app.mixin |
| app.use | app.use |
其它API像nextTick、h等都是直接从vue结构出来使用：
import { createApp, h, nextTick } from 'vue'composition API
tips
setup
这个可太重要了，vue3把这个函数当作了入口点。接收两个参数props和context。
函数会在beforeCreate、created之前执行，可以说取代了beforeCreate、created成为新的生命周期。
新增的composition API都写在setup函数中。
props就是vue2的props，context则提供attrs、slots、emit等。
通过return一个对象，把响应式数据暴露给template,相当于vue2的data，不同的是函数也是这样暴露给template：
{{ msg }}
{{ isRef }}
import { defineComponent, ref } from "vue";
export default defineComponent({
name: "HelloWorld",
props: {
msg: String,
},
setup(props) {
console.log(props.msg);
let isRef = ref("is ref");
const test = () => {
console.log(isRef.value);
};
return {
isRef,
test,
};
},
});
单文件组件
vue3还提供了单文件组件（推荐），将setup加到script上，里面的代码就会被编译成setup函数。
比较重要的几个点：
顶层的绑定会被暴露给模板声明的顶层的绑定 (包括变量，函数声明，以及 import 引入的内容) 都能在模板中直接使用
响应式数据、组件等也可以直接使用：
{{ msg }}
{{ isRef }}
import MyComponent from './MyComponent.vue'
import { ref } from "vue";
const msg = "msg";
const isRef = ref("");
function test() {
console.log(isRef.value);
}
使用单文件组件，一些属性的使用也要改变，当然也有其它替代的API：
| 属性 | 对应 | | props和emits | defineProps和defineEmits |
| ref或者$parent | defineExpose |
| slots和attrs | useSlots和useAttrs() |
ref
接受一个内部值并返回一个响应式且可变的 ref 对象，在setup函数内部访问ref函数需要加.value，
如果要加类型，要用泛型，不加则会类型推论，也可以不给初始值，则是any，且是undefined：
const ref1 = ref(1);
const ref2 = ref(2);
const ref3 = ref1.value;//不是响应式，相当于变量
const ref4 = ref();//refs.value是undefined
ref2.value = 5;//赋值 读取都要.value
一般来说，ref只会赋值基础数据类型和数组，也可以泛型联合类型
如果将对象分配为ref值，则它将被reactive函数处理为深层的响应式对象：
//不建议，内部也是reactive处理
const ref1 = ref({
a: 10,
});
//不确定类型
const ref3 = ref();
ref3.value = 1;
ref3.value = "";
//数组对象，ts类型声明，用泛型
type Obj1 = { c: string };
type Obj2 = {
b: string;
c: Obj1[];
};
const ref2 = ref([
{
b: "",
c: [{ c: "" }],
},
]);reactive
用来声明响应式的对象，类型通过泛型添加：
type Obj = {
a: number;
b: string;
};
let obj = reactive({
a: 10,
b: "",
});
let state = reactive({
a: 10,
b: "",
});reactive将会解包所有深层的 refs，同时维持ref的响应性，
将ref分配给reactive的property时，ref也会被自动解包。
简单说就是ref的值和reactive的值响应式了
const count = ref(1)
const obj = reactive({ count })
// ref 会被解包
console.log(obj.count === count.value) // true
// 它会更新 `obj.count`
count.value++
console.log(count.value) // 2
console.log(obj.count) // 2
// 它也会更新 `count` ref
obj.count++
console.log(obj.count) // 3
console.log(count.value) // 3
//跟上面一样效果
const count = ref(1)
const obj = reactive({})
obj.count = count
console.log(obj.count) // 1
console.log(obj.count === count.value) // truetoRef
为源响应式对象上的某个property新创建一个ref，也就是reactive创建的才可以,
会保持对其源 property 的响应式连接：
const state = reactive({
foo: 1,
bar: 2
})
const fooRef = toRef(state, 'foo')
fooRef.value++
console.log(state.foo) // 2
state.foo++
console.log(fooRef.value) // 3toRefs
将响应式对象转换为普通对象，其中结果对象的每个property都是指向原始对象相应property的ref：
const state = reactive({
foo: 1,
bar: 2
})
const stateAsRefs = toRefs(state)
/*
stateAsRefs 的类型:
{
foo: Ref,
bar: Ref
}
*/
// ref 和原始 property 已经“链接”起来了
state.foo++
console.log(stateAsRefs.foo.value) // 2
stateAsRefs.foo.value++
console.log(state.foo) // 3toRef和toRefs在对一些响应式对象结构展开会很有用，可以有用的时候看看。
watch
watch接收两个参数，第一个参数可以是有return的函数，也可以是一个ref,
第二个参数则跟vue2相同的函数，并且watch可以很多个：
//一般ref不用这种方式
let count = ref(0);
watch(
() => count.value,
(val, old) => {
console.log(old, val);
}
);
//单个ref推荐
watch(count, (val, old) => {
console.log(old, val);
});
//监听reactive对象
let state = reactive({ count: 0 });
//函数参数必须具体到某个值，如果是() => state无效，或者加上{ deep: true }
watch(
() => state.count,
(val, old) => {
console.log(old, val);
}
);
//加上{ deep: true }
watch(
() => state,
(val, old) => {
console.log(old, val);
},
{ deep: true }
);
//监听整个对象，新旧的值都相同，或者用lodash.cloneDeep进行深拷贝
//state改成() => _.cloneDeep(state)
watch(state, (val, old) => {
console.log(old.count, val.count);
});也可以同时监听多个，两个参数分别用数组，个人还是建议单个：
const state = reactive({ count: 1 });
const count = ref(0);
// 监听一个数组
watch(
[() => state.count, count],
([newState, newCount], [oldState, oldCount]) => {
console.log("new:", newState, newCount);
console.log("old:", oldState, oldCount);
}
);官网一直提到惰性，其实就是是否加immediate: true，加了初始化就会执行。
watchEffect
它"立即执行"传入的一个函数，同时响应式追踪其依赖，并在其依赖变更时重新运行该函数：
const state = reactive({ count: 1 });
const count = ref(0);
watchEffect(() => {
if (state.count > 3) {
count.value++;
}
});
watchEffect(() => console.log(count.value));至于watch和watchEffect共享停止侦听，清除副作用 (相应地 onInvalidate 会作为回调的第三个参数传入)、
副作用刷新时机和侦听器调试行为后面要仔细研究一下。
computed
从vue2开始，就很多人分不清什么时候用computed什么时候用watch，computed主要是用来声明
有两个及以上的依赖的数据，也就是说一个变量是根据多个数据进行判断的，用computed，单个的用watch。
至于语法的不同就不多说了，vue3的computed常用语法是一个带有return的函数，也可以同时存在多个：
let count = ref(0);
let page = ref(0);
let pg = computed(() => {
return count.value + page.value;
});要注意，computed声明的变量（pg）是不能直接去修改的（只读），跟vue2一样也有get、set函数（可读可写）。
defineProps、defineEmits
在单文件组件中必须使用defineProps和defineEmits API来声明props和emits，可以算是语法糖。
父组件还是跟原来一样传值，子组件接收：
//父组件
