DEV.コミュニティへこんにちは!
この記事には、主に使用されている、またはある種のダークサイドにあり、本来注目されていない Vue 3 の複数の側面が含まれます。
Vue 3 について説明するので、昔ながらのオプション API ではなく、コンポジション API を使用します。どちらのメソッドの概念も同じなので、コンポジション API にすぐに適応できます。私には何かを指示する立場はなく、すべてのプログラマーがプログラムの書き方を自由に選択できますが、個人的な意見として、私は簡潔な構文と優れたコード管理の点でコンポジション API を好みます。したがって、コンポジション API に変更するのがまだ怖い場合は、価値があるので試してみることをお勧めします。
反応性について話すときに思い浮かぶのは React だけではありません。反応性とは、エンティティ (Web ページが指定された場合) がデータの変更に基づいて反応する能力を指します。この概念は MVVM として知られているかもしれません。 MVVM は、Model-View-View-Model の省略形です。名前が示すように、データが変更されるとビューも変更され、その逆も同様です。
Vue の反応能力を利用するために、いくつかのオプションを取り上げます。
ref は、Vue アプリケーション内で使用できる特別な種類の変数と考えることができます。この説明は、Vue を初めて使用する場合にのみ当てはまります。その後は少し複雑になります。
ref の定義は次のように簡単です。
const message = ref("Hello World")
補間構文を使用してテンプレート内で使用します。
<span>{{ message }}</span>
変数と呼んでいるのに、const キーワードを使用してメッセージを宣言した理由を自問している場合は、それを行う権利があります。
ご存知のとおり、const キーワードの目的であるため、constant の値を変更することはできません。しかし、知っておくべき微妙な点があります。キーワード const では変数のデータを変更できませんが、ネストされたデータは気にされません。 refの場合も同様です。この状況を理解するには、以下のコードを試してみるとよいでしょう:
const o = {
a: 1,
b: 2,
c: 3
}
console.log(o.a) // 1
o.a = 4
console.log(o.a) // 4
ご覧のとおり、オブジェクトは単なる参照であり、それ自体が全体の値ではないため、o.a の値を変更できます。したがって、オブジェクト内の a の値を変更すると、const 制限は適用されません。もちろん、 o 自体に値を代入したい場合は、エラーがスローされ、それを行うことはできません。たとえば、以下のコードは間違っています:
const o = {
a: 1,
b: 2,
c: 3
}
o = "hello"
これは、ref (および後でここで説明する他のもの) を使用する場合と同じです。 ref 関数を呼び出すと、受け取ったすべてがオブジェクトに変換されます。これをラッピングといいます。このコードを試してください:
const message = ref("Hello World")
console.log(message)
以下の画像のようなものが表示されるはずです:
メッセージ変数をログに記録するとわかるように、Hello World を直接受信しているのではなく、オブジェクト内にあり、前述のオブジェクトの値キーを使用して実際の値にアクセスできます。これにより、Vue が変更を監視し、MVVM の処理を実行できるようになります。 :)
Vue テンプレート内の ref にアクセスする場合、message.value のようにアクセスする必要はありません。 Vue は、オブジェクトではなくテンプレート内の実際の値をレンダリングするのに十分な機能を備えています。ただし、スクリプト内の ref の値にアクセスまたは変更したい場合は、 .value:
を使用して行う必要があります。
message.value = "Adnan!" console.log(message.value) // Adnan!
ref を使用するときに見たように、Vue はデータをオブジェクト内にラップし、.value 経由でデータにアクセスできるようにします。通常、これが最もよく使用されるケースです。 ref を使用してほとんどすべてをラップし、リアクティブにすることができます。
Vue がどのように値の変更を監視し、ビューを何度もレンダリングするのか疑問に思った場合は、JavaScript プロキシを確認してください。
値がオブジェクト自体の場合は、ref の代わりに reactive を使用できます。リアクティブ関数は値をラップせず、代わりにオブジェクト自体をリアクティブにして監視可能にします。
const o = reactive({count: 0})
o 定数を出力しようとすると、大きな変更を加えることなく実際にオブジェクトであることがわかります。
Now you may manipulate the key count as you would normally do in JavaScript and Vue will render the changes as soon as possible.
Here is an example:
const increase = () => {
o.count++
}
If you had ref instead of reactive it would have looked like this:
const o = ref({count: 0})
const increase = () => {
o.value.count++
}
If you are still unsure which one to use, keep in mind that ref is a safe option to use.
Give that you have a ref like below:
const state = ref({
names: {
adnan: 'babakan',
arian: 'amini',
ata: 'parvin',
mahdi: 'salehi'
}
})
And printed my last name in your template as below:
<span>{{ state.names.adnan }}</span>
If you every changed my last name like this:
state.value.names.adnan = 'masruri'
Your template will be updated to show masruri instead of babakan. This is due to the fact that ref makes a deeply watched object and the changes to the view (template) are triggered for nested data as well.
There is an option to prevent such behaviour if that's what you want. To do so you may use shallowRef. A shallowRef acts exactly like ref does, with an exception of not watching for deep changes.
const state = shallowRef({
names: {
adnan: 'babakan',
arian: 'amini',
ata: 'parvin',
mahdi: 'salehi'
}
})
onMounted(() => {
state.value.names.adnan = 'masruri'
})
The code above will result in your template showing babakan as it is not watched. But changing the .value entirely will trigger changes. So the code below will result in your template getting updated as well:
const state = shallowRef({
names: {
adnan: 'babakan',
arian: 'amini',
ata: 'parvin',
mahdi: 'salehi'
}
})
onMounted(() => {
state.value = {
names: {
adnan: 'masruri',
arian: 'amini',
ata: 'parvin',
mahdi: 'salehi'
}
}
})
This is a great option for performance-related concerns.
So far we've known that ref wraps the data and watches it deeply and shallowRef wraps the data and watches it shallowly. Now tell me this, if reactive makes an object reactive, what does shallowReactive do?
const state = shallowReactive({
names: {
adnan: 'babakan',
arian: 'amini',
ata: 'parvin',
mahdi: 'salehi',
},
})
onMounted(() => {
state.names.adnan = 'masruri'
})
As you might have guessed the template won't be updated.
Given that you are using a shallowRef and changed a value and now want your template to be updated according to the new data as well, you may use the triggerRef function:
const state = shallowRef({
names: {
adnan: 'babakan',
arian: 'amini',
ata: 'parvin',
mahdi: 'salehi'
}
})
onMounted(() => {
state.value.names.adnan = 'masruri'
triggerRef(state)
})
Now the template will also show masruri. This is more like changing from an automatic gear to a manual gear if you will.
This is usable for both shallowRef and shallowReactive.
The readonly function receives a ref or a reactive as an argument and returns an exact copy that is only possible to be read from. This is used when you want to make sure your data is safe and is not possible to change when watching for it.
Example:
<template>
<div>
{{ infoReadOnly }}
</div>
</template>
<script setup>
const info = ref({
first: 'Adnan',
last: 'Babakan'
})
const infoReadOnly = readonly(info)
onMounted(() => {
info.value.first = 'Arian'
})
</script>
Though I've changed the value of info, since infoReadOnly is actually a live copy of info my changes are reflected in infoReadOnly as well. Yet you may not change the values using infoReadOnly directly:
const info = ref({
first: 'Adnan',
last: 'Babakan'
})
const infoReadOnly = readonly(info)
onMounted(() => {
infoReadOnly.value.first = 'Arian'
})
This won't change the data and will warn you in the console as below:
If we have ref and shallowRef, reactive and shallowReactive, why not have a shallowReadonly?
A shallowReadonly only makes the root level elements readonly whilst you can change the nested data:
const stateShallowReadonly = shallowReadonly({
name: 'Adnan',
friends: [
{ name: 'Arian' },
{ name: 'Ata' },
{ name: 'Mahdi' }
]
})
onMounted(() => {
stateShallowReadonly.name = 'Brad'
})
The code above will warn you and won't change the value of name since it is a direct property.
But you can freely change anything inside friends since it is nested:
const stateShallowReadonly = shallowReadonly({
name: 'Adnan',
friends: [
{ name: 'Arian' },
{ name: 'Ata' },
{ name: 'Mahdi' }
]
})
onMounted(() => {
stateShallowReadonly.friends[0].name = 'Brad'
})
Man, I love computed in Vue! You can imagine it as a glass in which you can mix your potions and still have your potions standing there intact!
A computed is like a ref or reactive that can be accessed and watched but not changed. Then what's the difference between a computed and a readonly you might ask. A computed can be a mixture of stuff. For example:
const state = ref({
first: 'Adnan',
last: 'Babakan'
})
const fullName = computed(() => state.value.first + ' ' + state.value.last)
Now you have a fullName which you may access its value inside a template with {{ fullName }} or inside your script using fullName.value.
The value of fullName will always depend on the state.value.first and state.value.last and will change if those guys change.
A computed receives a function that returns a value and can depend on multiple reactive data.
Though a computed is mostly used to read a combination of data, the possibility to make a computed writable is also there.
Instead of passing a function to computed you may pass an object including two properties called get and set that both are functions.
For instance:
const state = ref({
first: 'Adnan',
last: 'Babakan'
})
const fullName = computed({
get: () => state.value.first + ' ' + state.value.last,
set: (value) => {
const [first, last] = value.split(' ')
state.value.first = first
state.value.last = last
}
})
Now if you try to write the value of fullName like below:
fullName.value = 'Ata Parvin'
It will split your string into 2 parts using a space and assign the first part to state.value.first and the second to state.value.last.
This is not a good way to determine which part of a name is a first name and which is a last name, but for the sake of demonstration, this is the only thing that came to my mind. :D
Watching is something that you will probably need a lot. Watching is referred to the act in which you want to run something in case a reactive data changes. In different systems there are various naming for this act, sometimes they are called hooks as well. But in Vue, we will call them watches.
The first thing you will encounter. A watch function receives two arguments. The reactive data to watch and the function to be invoked when the data changes respectively.
Here is a simple watch:
const count = ref(0)
const increase = () => {
count.value++
}
watch(count, () => {
console.log('Count changed to ' + count.value)
})
Now whenever the value of count is changed, you will see the log Count changed to ((count)) in your console.
The callback function also receives two arguments which are passed to it when the watch is triggered. The first argument holds the new value and the second one holds the old value. Here is an example:
const count = ref(0)
const increase = () => {
count.value++
}
watch(count, (newValue, oldValue) => {
console.log('Counter changed from ' + oldValue + ' to ' + newValue)
})
Note: Be careful when using the newValue and oldValue with objects as objects are passed by reference.
To be more accurate, a watch function receives a third argument as well. This third argument is an object that holds some options which can change the behaviour of the watching action.
An immediate watch function is triggered at the instance it's created as well as when a change happens. You can think of it as the difference between a while loop and a do...while loop if you know what I mean. In other words, even if there is never a change, your callback function will run at least once:
watch(count, () => {
console.log('Count changed to ' + count.value)
}, {
immediate: true,
})
The value for immediate can be true or false. And the default value is false.
If you want your watcher to run only once, you may define the once option and set its value to true. The default value is false.
watch(count, () => {
console.log('Count changed to ' + count.value)
}, {
once: true,
})
This will only trigger once when the value of count changes.
Previously we've mentioned that watchers accept a reactive data as the first argument. While this is true, this is not the whole case.
A watch function can receive a getter function or an array of reactive objects and getter functions. This is used for when we need to watch for multiple data changes, and/or when we need to watch the result of two or more things when affecting each other. Let's have some examples.
Take the code below as an example:
<template>
<div>
<div>
<div>Timer one: {{ timerOne }}</div>
<div>Timer two: {{ timerTwo }}</div>
</div>
<button @click="timerOne++">Accelerate timer one</button>
<button @click="timerTwo++">Accelerate timer two</button>
</div>
</template>
<script setup>
const timerOne = ref(0)
const timerTwo = ref(0)
onMounted(() => {
setInterval(() => {
timerOne.value++
timerTwo.value++
}, 1000)
})
watch(() => timerOne.value - timerTwo.value, () => {
console.log('There was a change in the gap between timerOne and timerTwo. Gap is ' + (Math.abs(timerOne.value - timerTwo.value)) + ' seconds.')
})
</script>
It's a simple code that makes 2 refs holding a number and increasing both of them 1 by 1 each second. Logically the difference of these two refs are always equal to zero unless one gets changes out of its turn. As both increase the difference stays 0 so the watched won't get triggered as it only watches for the changes to the result of timerOne.value - timerTwo.value.
Yet there are two buttons that each adds 1 to timerOne and timerTwo respectively. When you click on any of those buttons the difference will be more or less than 0 thus the watch being triggered and logging the gap between these two timers.
Here is an example of an array of reactive data being passed to the first argument of the watch function:
<template>
<div>
<div>
<div>Counter one: {{ counterOne }}</div>
<div>Counter two: {{ counterTwo }}</div>
</div>
<button @click="counterOne++">Increase counter one</button>
<button @click="counterTwo++">Increase counter two</button>
</div>
</template>
<script setup>
const counterOne = ref(0)
const counterTwo = ref(0)
watch([
counterOne,
counterTwo,
], () => {
console.log('One of the counters changes')
})
</script>
No matter which ref changes, the watcher will be triggered.
A watchEffect function acts almost exactly like a watch function with a main difference. In a watchEffect you don't need to define what to watch and any reactive data that is used inside the callback you provide your watchEffect is watched automatically. For example:
const count = ref(0)
watchEffect(() => {
console.log(count.value)
})
In case our count is changed the watchEffect will trigger its callback function since count.value is used inside it. This is good if you have complex logic to watch for.
Hope this was useful and you've enjoyed it. In case you spot any mistakes or feel like there should be an improvement, kindly let me know.
BTW! Check out my free Node.js Essentials E-book here:
Feel free to contact me if you have any questions or suggestions.
以上がダークサイドの Vue チートシート |部品の反応性の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。
![[Web フロントエンド] Node.js クイック スタート](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
