小编给大家分享一下vue3中文档梳理的示例分析,相信大部分人都还不怎么了解,因此分享这篇文章给大家参考一下,希望大家阅读完这篇文章后大有收获,下面让我们一起去了解一下吧!
组合式 API:
setup
选项应该为一个函数
setup
选项函数接受两个参数: props
和 context
setup
选项函数需要返回要暴露给组件的内容
setup
需要使用 return
返回,才能给组件使用,包含数据和方法
setup
函数中的 props
是响应式的,当传入新的 prop 时,它将被更新
export default { props: { title: String }, setup(props) { console.log(props.title) } }
但是,因为 props
是响应式的,你不能使用 ES6 解构,因为它会消除 prop 的响应性。
如果需要解构 prop,可以通过使用 setup 函数中的 toRefs
来安全地完成此操作。
import { toRefs } from 'vue' setup(props) { const { title } = toRefs(props) console.log(title.value) }
setup
函数中的第二个参数 ——contextcontext
上下文是一个普通的 JavaScript 对象,它暴露三个组件的 property
xport default { setup(props, context) { // Attribute (非响应式对象) console.log(context.attrs) // 插槽 (非响应式对象) console.log(context.slots) // 触发事件 (方法) console.log(context.emit) } }
context
是一个普通的 JavaScript
对象,也就是说,它不是响应式的,这意味着你可以安全地对 context 使用 ES6 解构
export default { setup(props, { attrs, slots, emit }) { ... } }
如果 setup
返回一个对象,则可以在组件的模板中像传递给 setup
的 props property
一样访问该对象的 property:
<template> <!-- 模板中使用会被自动解开,所以不需要 .value --> <div>{{ readersNumber }} {{ book.title }}</div> </template> <script> import { ref, reactive } from 'vue' export default { setup() { const readersNumber = ref(0) const book = reactive({ title: 'Vue 3 Guide' }) // expose to template return { readersNumber, book } } } </script>
注意:从 setup 返回的 refs 在模板中访问时是被自动解开的,因此不应在模板中使用 .value
reactive()
接收一个普通对象然后返回该普通对象的响应式代理。等同于 2.x 的 Vue.observable()
const obj = reactive({ count: 0 })
响应式转换是“深层的”:会影响对象内部所有嵌套的属性。基于 ES2015 的 Proxy 实现,返回的代理对象不等于原始对象。建议仅使用代理对象而避免依赖原始对象。
<template> <div id="app">{ state.count }</div> </template> <script> import { reactive } from 'vue' export default { setup() { // state 现在是一个响应式的状态 const state = reactive({ count: 0, }) } } </script>
接受一个参数值并返回一个响应式且可改变的 ref
对象。ref
对象拥有一个指向内部值的单一属性 .value
。
const count = ref(0) console.log(count.value) // 0 count.value++ console.log(count.value) // 1
如果传入 ref
的是一个对象,将调用 reactive 方法进行深层响应转换。
模板中访问:
当 ref
作为渲染上下文的属性返回(即在setup()
返回的对象中)并在模板中使用时,它会自动解套,无需在模板内额外书写 .value:
<template> <div>{{ count }}</div> </template> <script> export default { setup() { return { count: ref(0), } }, } </script>
作为响应式对象的属性访问:
当 ref 作为 reactive
对象的 property
被访问或修改时,也将自动解套 value
值,其行为类似普通属性:
const count = ref(0) const state = reactive({ count, }) console.log(state.count) // 0 state.count = 1 console.log(count.value) // 1
注意:如果将一个新的 ref
分配给现有的 ref
, 将替换旧的 ref
:
const otherCount = ref(2) state.count = otherCount console.log(state.count) // 2 console.log(count.value) // 1
注意:当嵌套在 reactive Object
中时,ref
才会解套。从 Array
或者 Map
等原生集合类中访问 ref
时,不会自动解套:
const arr = reactive([ref(0)]) // 这里需要 .value console.log(arr[0].value) const map = reactive(new Map([['foo', ref(0)]])) // 这里需要 .value console.log(map.get('foo').value)
类型定义:
interface Ref<T> { value: T } function ref<T>(value: T): Ref<T>
有时我们可能需要为 ref
做一个较为复杂的类型标注。我们可以通过在调用 ref
时传递泛型参数来覆盖默认推导:
const foo = ref<string | number>('foo') // foo 的类型: Ref<string | number> foo.value = 123 // 能够通过!
使用响应式 computed API
有两种方式:
(1)传入一个 getter
函数,返回一个默认不可手动修改的 ref
对象。
const count = ref(1) const plusOne = computed(() => count.value + 1) console.log(plusOne.value) // 2 plusOne.value++ // 错误!
(2)传入一个拥有 get
和 set
函数的对象,创建一个可手动修改的计算状态。
const count = ref(1) const plusOne = computed({ get: () => count.value + 1, set: (val) => { count.value = val - 1 }, }) plusOne.value = 1 console.log(count.value) // 0
类型定义:
// 只读的 function computed<T>(getter: () => T): Readonly<Ref<Readonly<T>>> // 可更改的 function computed<T>(options: { get: () => T set: (value: T) => void }): Ref<T>
传入一个对象(响应式或普通)或 ref
,返回一个原始对象的只读代理。一个只读的代理是“深层的”,对象内部任何嵌套的属性也都是只读的。
const original = reactive({ count: 0 }) const copy = readonly(original) watchEffect(() => { // 依赖追踪 console.log(copy.count) }) // original 上的修改会触发 copy 上的侦听 original.count++ // 无法修改 copy 并会被警告 copy.count++ // warning!
立即执行传入的一个函数,并响应式追踪其依赖,并在其依赖变更时重新运行该函数。
const count = ref(0) watchEffect(() => console.log(count.value)) // -> 打印出 0 setTimeout(() => { count.value++ // -> 打印出 1 }, 100)
当 watchEffect
在组件的 setup()
函数或生命周期钩子被调用时, 侦听器会被链接到该组件的生命周期,并在组件卸载时自动停止。
在一些情况下,也可以显式调用返回值以停止侦听:
const stop = watchEffect(() => { /* ... */ }) // 之后 stop()
有时副作用函数会执行一些异步的副作用, 这些响应需要在其失效时清除(即完成之前状态已改变了)。所以侦听副作用传入的函数可以接收一个 onInvalidate
函数作入参, 用来注册清理失效时的回调。当以下情况发生时,这个失效回调会被触发:
副作用即将重新执行时
侦听器被停止 (如果在 setup() 或 生命周期钩子函数中使用了 watchEffect, 则在卸载组件时)
watchEffect((onInvalidate) => { const token = performAsyncOperation(id.value) onInvalidate(() => { // id 改变时 或 停止侦听时 // 取消之前的异步操作 token.cancel() }) })
我们之所以是通过传入一个函数去注册失效回调,而不是从回调返回它(如 React useEffect
中的方式),是因为返回值对于异步错误处理很重要。
在执行数据请求时,副作用函数往往是一个异步函数:
const data = ref(null) watchEffect(async () => { data.value = await fetchData(props.id) })
我们知道异步函数都会隐式地返回一个 Promise
,但是清理函数必须要在 Promise
被 resolve
之前被注册。另外,Vue
依赖这个返回的 Promise
来自动处理 Promise
链上的潜在错误。
Vue
的响应式系统会缓存副作用函数,并异步地刷新它们,这样可以避免同一个 tick 中多个状态改变导致的不必要的重复调用。在核心的具体实现中, 组件的更新函数也是一个被侦听的副作用。当一个用户定义的副作用函数进入队列时, 会在所有的组件更新后执行:
<template> <div>{{ count }}</div> </template> <script> export default { setup() { const count = ref(0) watchEffect(() => { console.log(count.value) }) return { count, } }, } </script>
在这个例子中:
count
会在初始运行时同步打印出来
更改 count
时,将在组件更新后执行副作用。
请注意:初始化运行是在组件 mounted
之前执行的。因此,如果你希望在编写副作用函数时访问 DOM
(或模板 ref),请在 onMounted
钩子中进行:
onMounted(() => { watchEffect(() => { // 在这里可以访问到 DOM 或者 template refs }) })
如果副作用需要同步或在组件更新之前重新运行,我们可以传递一个拥有 flush 属性的对象作为选项(默认为 'post
'):
// 同步运行 watchEffect( () => { /* ... */ }, { flush: 'sync', } ) // 组件更新前执行 watchEffect( () => { /* ... */ }, { flush: 'pre', } )
onTrack
和 onTrigger
选项可用于调试一个侦听器的行为。
当一个 reactive
对象属性或一个 ref
作为依赖被追踪时,将调用 onTrack
依赖项变更导致副作用被触发时,将调用 onTrigger
这两个回调都将接收到一个包含有关所依赖项信息的调试器事件。建议在以下回调中编写 debugger 语句来检查依赖关系:
watchEffect( () => { /* 副作用的内容 */ }, { onTrigger(e) { debugger }, } )
onTrack
和 onTrigger
仅在开发模式下生效。
类型定义:
function watchEffect( effect: (onInvalidate: InvalidateCbRegistrator) => void, options?: WatchEffectOptions ): StopHandle interface WatchEffectOptions { flush?: 'pre' | 'post' | 'sync' onTrack?: (event: DebuggerEvent) => void onTrigger?: (event: DebuggerEvent) => void } interface DebuggerEvent { effect: ReactiveEffect target: any type: OperationTypes key: string | symbol | undefined } type InvalidateCbRegistrator = (invalidate: () => void) => void type StopHandle = () => void
watch API
完全等效于 2.x this.$watch
(以及 watch
中相应的选项)。watch
需要侦听特定的数据源,并在回调函数中执行副作用。默认情况是懒执行的,也就是说仅在侦听的源变更时才执行回调。
对比
watchEffect,watch
允许我们:
懒执行副作用;
更明确哪些状态的改变会触发侦听器重新运行副作用;
访问侦听状态变化前后的值。
侦听单个数据源
侦听器的数据源可以是一个拥有返回值的 getter 函数,也可以是 ref:
// 侦听一个 getter const state = reactive({ count: 0 }) watch( () => state.count, (count, prevCount) => { /* ... */ } ) // 直接侦听一个 ref const count = ref(0) watch(count, (count, prevCount) => { /* ... */ })
watcher
也可以使用数组来同时侦听多个源:
watch([fooRef, barRef], ([foo, bar], [prevFoo, prevBar]) => { /* ... */ })
watch
和 watchEffect
在停止侦听, 清除副作用 (相应地 onInvalidate
会作为回调的第三个参数传入),副作用刷新时机 和 侦听器调试 等方面行为一致.
类型定义:
// 侦听单数据源 function watch<T>( source: WatcherSource<T>, callback: ( value: T, oldValue: T, onInvalidate: InvalidateCbRegistrator ) => void, options?: WatchOptions ): StopHandle // 侦听多数据源 function watch<T extends WatcherSource<unknown>[]>( sources: T callback: ( values: MapSources<T>, oldValues: MapSources<T>, onInvalidate: InvalidateCbRegistrator ) => void, options? : WatchOptions ): StopHandle type WatcherSource<T> = Ref<T> | (() => T) type MapSources<T> = { [K in keyof T]: T[K] extends WatcherSource<infer V> ? V : never } // 共有的属性 请查看 `watchEffect` 的类型定义 interface WatchOptions extends WatchEffectOptions { immediate?: boolean // default: false deep?: boolean }
以上是“vue3中文档梳理的示例分析”这篇文章的所有内容,感谢各位的阅读!相信大家都有了一定的了解,希望分享的内容对大家有所帮助,如果还想学习更多知识,欢迎关注亿速云行业资讯频道!
免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。