From c47b44a16eb4662a40e32ce5952997585fcbb42b Mon Sep 17 00:00:00 2001 From: Johnny Charcosset Date: Tue, 8 Nov 2022 11:59:16 +0100 Subject: [PATCH 1/3] Update: watchers.md Add `Eager Watchers` section to composition side --- src/guide/essentials/watchers.md | 19 +++++++++++++++++-- 1 file changed, 17 insertions(+), 2 deletions(-) diff --git a/src/guide/essentials/watchers.md b/src/guide/essentials/watchers.md index 2258a5f459..147e19598e 100644 --- a/src/guide/essentials/watchers.md +++ b/src/guide/essentials/watchers.md @@ -220,9 +220,9 @@ watch( Deep watch requires traversing all nested properties in the watched object, and can be expensive when used on large data structures. Use it only when necessary and beware of the performance implications. ::: -
+## Eager Watchers {#eager-watchers} -## Eager Watchers \* {#eager-watchers} +
`watch` is lazy by default: the callback won't be called until the watched source has changed. But in some cases we may want the same callback logic to be run eagerly - for example, we may want to fetch some initial data, and then re-fetch the data whenever relevant state changes. @@ -245,6 +245,21 @@ export default { ``` The initial execution of the handler function will happen just before the `created` hook. Vue will have already processed the `data`, `computed`, and `methods` options, so those properties will be available on the first invocation. + +
+ +
+ +`watch` is lazy by default: the callback won't be called until the watched source has changed. But in some cases we may want the same callback logic to be run eagerly - for example, we may want to fetch some initial data, and then re-fetch the data whenever relevant state changes. + +We can force a watcher's callback to be executed immediately by declaring it using an object with a `handler` function and the `immediate: true` option: + +```js +watch(obj, (newValue, oldValue) => { + // logic +}, {immediate: true}) +``` +
From 3ad513a2a92c273b524c49d59d41e4c2e707a8b4 Mon Sep 17 00:00:00 2001 From: Johnny Charcosset Date: Tue, 8 Nov 2022 18:26:55 +0100 Subject: [PATCH 2/3] docs: returns consideration --- src/guide/essentials/watchers.md | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/guide/essentials/watchers.md b/src/guide/essentials/watchers.md index 147e19598e..bd81eec105 100644 --- a/src/guide/essentials/watchers.md +++ b/src/guide/essentials/watchers.md @@ -222,10 +222,10 @@ Deep watch requires traversing all nested properties in the watched object, and ## Eager Watchers {#eager-watchers} -
- `watch` is lazy by default: the callback won't be called until the watched source has changed. But in some cases we may want the same callback logic to be run eagerly - for example, we may want to fetch some initial data, and then re-fetch the data whenever relevant state changes. +
+ We can force a watcher's callback to be executed immediately by declaring it using an object with a `handler` function and the `immediate: true` option: ```js @@ -249,15 +249,13 @@ The initial execution of the handler function will happen just before the `creat
- -`watch` is lazy by default: the callback won't be called until the watched source has changed. But in some cases we may want the same callback logic to be run eagerly - for example, we may want to fetch some initial data, and then re-fetch the data whenever relevant state changes. -We can force a watcher's callback to be executed immediately by declaring it using an object with a `handler` function and the `immediate: true` option: +We can force a watcher's callback to be executed immediately by passing the `immediate: true` option: ```js watch(obj, (newValue, oldValue) => { - // logic -}, {immediate: true}) + // ... +}, { immediate: true }) ```
From 2a4e15a6f5f8586a61f0800ac89de25778aa6fe3 Mon Sep 17 00:00:00 2001 From: Johnny Charcosset Date: Thu, 10 Nov 2022 10:01:11 +0100 Subject: [PATCH 3/3] docs: update watchEffects() part --- src/guide/essentials/watchers.md | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/guide/essentials/watchers.md b/src/guide/essentials/watchers.md index bd81eec105..0b1473602d 100644 --- a/src/guide/essentials/watchers.md +++ b/src/guide/essentials/watchers.md @@ -264,7 +264,9 @@ watch(obj, (newValue, oldValue) => { ## `watchEffect()` \*\* {#watcheffect} -`watch()` is lazy: the callback won't be called until the watched source has changed. But in some cases we may want the same callback logic to be run eagerly - for example, we may want to fetch some initial data, and then re-fetch the data whenever relevant state changes. We may find ourselves doing this: +`watch()` is lazy: the callback won't be called until the watched source has changed. But in some cases we may want the same callback logic to be run eagerly, an alternative to [`watch()`](/api/reactivity-core.html#watch) exists. + +We may find ourselves doing this: ```js const url = ref('https://...') @@ -278,7 +280,7 @@ async function fetchData() { // fetch immediately fetchData() // ...then watch for url change -watch(url, fetchData) +watch(url, fetchData, { immediate: true }) ``` This can be simplified with [`watchEffect()`](/api/reactivity-core.html#watcheffect). `watchEffect()` allows us to perform a side effect immediately while automatically tracking the effect's reactive dependencies. The above example can be rewritten as: