跟讀練習: Learn useMemo In 10 Minutes - 通過影片學習英語口語

選擇練習模式

每種模式都會開啟全屏練習室。

139 句

如果句子過短或過長，請點選 Edit 進行調整。

Hello everyone, welcome back to my React Hooks series, where in this video we're going to take a look at use memo,

how it works, and when you should actually use it.

And if you're interested in diving into React even deeper, make sure to check out my full

React course, which I'm going to link down in the description below.

Have you wanted free web hosting that doesn't suck?

Well you're in luck because today's video sponsor, Atlantic .net, is giving you an entire year -long free trial of their hosting.

And if you use the code

Kyle when you check out, you're going to get an additional $50 of credit that you can use towards whatever you want on the hosting platform.

On top of that, this hosting platform has powerful servers with great data reliability

and redundancy so you know that your site is going to be there and running with the data you want it to.

So make sure you use the code

Kyle in the link down in the description below to get your free hosting.

Welcome back to Web Dev Simplified.

My name's Kyle and my job is to simplify the web for you so you can start building your dream project sooner.

So if that sounds interesting, make sure you subscribe to the channel for more videos just like this.

Now to get started, I just have some really basic boilerplate code set up for us to test our application.

I'm going to walk through it real quick so you know exactly what we're doing.

I just have a simple single component called app, which has two pieces of state.

One is a number, which we can control by this input over here on the right.

And the second one is a Boolean for dark or light, which is toggled by this change theme button on the right side of our screen.

Then what we do is we have a function which doubles our number, so just multiplies by two, but this function is very slow.

If I scroll down here, you can see I just have a really long for loop

that just loops doing nothing for a really long time to emulate what would happen in a really slow, long -running, complex function.

Obviously, since this function just multiplies by two, all this code is doing is making the function really slow.

And if I change this number, for example, by clicking this up arrow, you're going to see it takes about a second,

half a second for it to actually double the number.

So you can see this function is quite slow to execute.

Now continuing onward, we just have a variable here,

which is taking this dark boolean and changing if we have a dark or light theme down here.

And then lastly, over here, we just have the output code which changes our number

when we update here and also toggles our theme when we click this button.

So that's just the basics of our code

and you may think okay this is fine code it's working great

and the slowness is you know not that bad

but it only is going to be slow when we update our number but actually that's incorrect thinking.

If we click our change theme button you're going to notice we have the same delay.

I'm going to click

it now you can see it takes about half a second

to a second for it to actually change the actual theme

and the reason for that is because when you update state in React, it's going to re -render your entire component.

So it's going to run this entire function from top to bottom,

which means that this slow function gets called every single time that we render our app component.

So whether we're changing the theme, whether we're actually updating the number here, or whether some other component is causing this component to re -render,

you're going to be forcing it to go through that slow function over and over and over again.

And this is a really big performance problem when you have these slow functions that don't really change that often.

So React has a built -in way to solve this with a hook which is called use memo.

So we can import this use memo hook just like this.

And memo here stands for memoization, which essentially is the idea of caching a value so you don't have to re -compute it every single time.

So in our example, this slow function here takes an input of number,

and it's always going to give us the same output every time we give it the same input.

So we can cache that input value number and the output it gives us.

That way if the number doesn't change we don't have to recalculate our slow function over and over and over again.

And the easy way to use this is we just call use memo and we're going to pass it in a function.

And this function is going to be the thing that we actually mem -wise.

So this is the thing that we're caching which in our case is going to be this slow function.

We just want to make sure we return this slow function here, get the result from it.

And then just like all of the other hooks that we talked about like useEffect for example, we're going to have a list of dependencies here.

And in our case the only dependency of this is going to be our number here.

Our number is the only thing that changes.

And when our number changes we need to rerun the code inside this useMemo hook

but if our number doesn't change we don't need to rerun this slow function code.

So with that one simple change let's save and see what happened to our app.

It's loading over here we can change this to for example one

and you can see it has a kind of delay change it up again it's going to have a delay.

When we click change theme you're going to notice this is instantaneous I can click it as much as I want to.

And that's because when we go through our code, we click change theme, it causes our component to re -render.

So it calls this function, does all this stuff, and it gets down to use memo.

And it says, well, our number is exactly the same as what it was last time.

So we're not going to recall this slow function here because we already know what the result is.

It's the exact same thing as it was last time.

So we're saving ourselves from having to recalculate this number with the slow function,

and we only are forcing ourselves to do this when we actually update this number inside of our input here.

So we're essentially only running this slow code when we have to, and not running it when we don't actually need to.

Now this seems really nice, and you may think, let me just use memo everywhere, why not just memwise everything?

Like this theme styles here, why don't I memwise that based on this dark boolean variable?

And the reason you don't want to memwise everything is because it does give you some performance overheads and some memory overhead.

For example, this use memo function must be called every single render of your component.

So you're calling an additional function.

And also it's saving the value, this previous value in some memory variable.

So you're forcing your memory to get larger every time you use memo

because you have to store an additional variable in memory to store that previous value.

Now this isn't a huge deal.

But especially where you don't need it,

it's going to cause additional memory usage and additional performance problems when just not using it would have been better.

So I highly recommend you only use memo in this case when you actually need the performance benefits, when the function you're calling is incredibly slow.

Then use memo is great.

But there's also a second use case for use memo, and that is something called referential equality.

And if you aren't really familiar with value versus reference in JavaScript.

I have a video on that topic I'll link in the cards in description.

But essentially what that is saying is when you try to compare two different variables in JavaScript,

it's going to compare their reference in the case of objects and arrays.

So for example, this theme styles here is a specific object.

And if I were to duplicate this theme styles, for example, theme styles two right here,

you would think that theme styles and theme style 2 are equal to each other, but in JavaScript they reference different objects.

They have the same values in the object, but the actual reference to the object itself is different.

So these two values are actually not equal to each other, which is something really important.

And as you know, inside of hooks in React, we have this array here of all of our dependencies, and when our dependencies change,

it's going to rerun our hook.

So let's take a quick example where we have a use effect

100

and we want to run this use effect every single time that our theme styles here changes.

101

So we're just going to have a really simple console .log

102

theme changed and down here inside of our dependencies I'm going to have our theme styles.

103

Let's just get rid of this console down here and of course we need to make sure we import use effect

104

just like that.

105

And now if I just really quickly inspect this page here, pull this over, go to the console,

106

you can see we get our theme changed being printed out.

107

And when we change our theme, you can see it's continually printing out theme changed.

108

But a problem you'll notice if I clear this out is when we change our number, it's also causing this theme change to be run.

109

And the reason for that is that referential equality.

110

What's happening is every time we run our function, we get a new theme styles object being created.

111

And this new theme style object is not the same as the old theme styles, even though they have the exact same values in the object,

112

they reference different places in memory.

113

And that's really important to know.

114

So in order to make sure that we only ever run useEffect when our theme style object actually gets re -updated, we can use memo again.

115

So what we can do is wrap this in a use memo, make sure you pass it a function,

116

and in here we're just going to return that object.

117

We just indent all this properly, and in here for our dependencies we're just going to put

118

that dark variable because that's the only thing that this object depends on.

119

Now if we were to rerun this you can see a change in our theme causes this to update our theme, logs it out, but

120

when we change our number you're going to notice we don't actually get anything printed in our console

121

and only when we click change theme.

122

And the reason for this is that now we are wrapping this object inside of memorization.

123

Essentially, if our dark variable doesn't change, we don't re -update our theme styles.

124

So we get the exact same reference as we had the previous time we rendered our app.

125

So now our use effect is comparing our old theme styles with our new theme styles, but they both reference the exact same object.

126

So these are the two big use cases for use memo.

127

The first and most obvious is when you want to make a slow function,

128

wrap it in this use memo so that it doesn't recompute every single time you render your component,

129

and it only computes when you actually need the value from that function since the input's actually changed.

130

The second use case, which is a little bit trickier, is this idea of referential equality.

131

Whenever you want to make sure the reference of an object

132

or an array is exactly the same as it was the last time you rendered if none of the internal workings changed,

133

you're going to want to use memo here to make sure

134

that you only update the reference of

135

that object whenever the actual contents of the object change instead of updating every single time you render.

136

And that's all there is to the use memo hook.

137

If you enjoyed this video, make sure to check out my full react course linked in the description to get a full overview of everything

138

you need to know about react.

139

Thank you very much for watching and have a good day.

下載應用

流利口語所需的一切

AI 發音評分逐句打分

音標練習掌握每個音

詞彙學習建立你的詞庫

詞彙遊戲邊玩邊學

掃碼

Download on theApp Store Get it onGoogle Play

同頻道

Learn Next.js Parallel Routes In 16 Minutes

Business EnglishUniversity StudentsWorking Adults

FOR YOU

本課的詞彙與口語要點

這節口語課以影片“Learn useMemo In 10 Minutes”為素材。影片中反覆出現的詞有：theme, function, memo, slow, object。這段影片共有 139 個句子、2166 個單詞可供跟讀。講話部分時長為 10:41。說話人語速較快，每分鐘約 203 個詞，會出現較多連讀和弱讀。 87% 的單詞屬於英語最常用的 3,000 詞，詞彙容易理解。

影片中的重點詞彙

影片中 15 個值得學習的單詞，附發音和釋義：

單詞	發音	釋義
memo 名詞	/ˈmɛməʊ̯/	備忘錄 /備忘錄, 便箋 /便箋
hook 名詞	/hʊk/	鉤 /鉤, 鉤子 /鉤子
component 名詞	/kəmˈpoʊ.nənt/	元件, 部件
input 名詞	/ˈɪnpʊt/	輸入 /輸入
essentially 副詞	/ɪˈsɛnʃəli/	本質上 /本質上, 基本上
compare 動詞	/kəmˈpɛɚ/	比, 比較 /比較
output 名詞	/ˈaʊtpʊt/	輸出 /輸出
delay 名詞	/dɪˈleɪ̯/	遲延 /遲延, 延遲 /延遲
equality 名詞	/ɪˈkwɑ.lɪ.ti/	平等, 均等
wrap 動詞	/ɹæp/	包裝 /包裝, 包
cache 名詞	/kæʃ/	快取 /快取, 快取
loop 名詞	/luːp/	圈, 環 /環
import 名詞	/ˈɪm.pɔɹt/	進口貨 /進口貨, 舶來品 /舶來品
overhead 名詞	/ˈəʊvəˌhɛd/	間接費用 /間接費用
topic 名詞	/ˈtɑpɪk/	主題 /主題, 話題 /話題

影片中出現的短語動詞

單詞	釋義
check out 動詞	退房
go through 動詞	通過 /通過

影片中的語法

說話人最常用的結構，並附上影片中的原話：

結構	影片中的用法
被動語態 be + 過去分詞 — 強調發生了什麼，而不是誰做的	is toggled · is called · must be called
定語從句 who / which + 從句 — 補充說明人或事物	app, which has · light, which is · hook which is

需要注意的發音

說話人用了 48 次縮略和弱讀形式，例如 we're, you're, don't。請按聽到的簡短形式來說。

“sh” 和 “zh” 音: essentially /ɪˈsɛnʃəli/, cache /kæʃ/, referential /ɹɛfəˈɹɛnʃəl/, memoization /ˌmɛmoʊaɪˈzeɪʃən/, memorization /ˈmem(ə)ɹaɪˌzeɪʃn̩/
長單詞——注意重音位置: dependency /dɪˈpɛndənsi/, essentially /ɪˈsɛnʃəli/, equality /ɪˈkwɑ.lɪ.ti/, incredibly /ɪŋˈkɹɛdɪbli/, continually /kənˈtɪnjuəli/

中文母語者容易讀錯的音：

/v/ — 不要讀成 /w/，上齒輕觸下唇: variable [ˈvæɹ.i.ə.bl̩], overhead /ˈəʊvəˌhɛd/, server /ˈsɝvɚ/, solve /sɒlv/, versus /ˈvɝsəs/
詞尾子音 — 要讀清楚，後面不要加母音: hook /hʊk/, component /kəmˈpoʊ.nənt/, react /ɹiːˈækt/, input /ˈɪnpʊt/, output /ˈaʊtpʊt/
/r/ 和 /l/ 的區別: variable [ˈvæɹ.i.ə.bl̩], recall /ɹɪˈkɔl/, incredibly /ɪŋˈkɹɛdɪbli/, scroll /skɹoʊl/, referential /ɹɛfəˈɹɛnʃəl/

如何用這段影片練習

先完整聽一遍影片，不要開口，記下不認識的單詞。
先用 0.75 倍速逐句跟讀，熟練之後再回到正常速度。
錄下自己的聲音並與原聲對比，特別注意 memo, hook, component 這類單詞。

什麼是跟讀法？

跟讀法 (Shadowing) 是一種有科學依據的語言學習技巧，最初開發用於專業口譯員的培訓，並由多語言者Alexander Arguelles博士普及。這個方法簡單而強大：您在聽英語母語原聲的同時立即大聲重複——就像是一個延遲1-2秒緊跟說話者的影子。與被動聽力或語法練習不同，跟讀法強迫您的大腦和口腔肌肉同時處理並模模擬實的講話模式。研究表明它能顯著提高發音準確性，語調，節奏，連讀，聽力理解和口語流利度——使其成為雅思口語備考和真實英語交流最有效的方法之一。

影子跟讀法: 閱讀完整分步指南 →

跟讀練習: Learn useMemo In 10 Minutes - 通過影片學習英語口語

選擇練習模式

下載應用

同頻道

Learn Next.js Parallel Routes In 16 Minutes

推薦影片

10 Essential React Native Tips Every Developer Must Know

JUST $1 For Billions of Tokens?! (DeepSeek v4 Pro)

The easy way to keep your repos tidy.

My 4.9-Star iOS App Is Actually a Website: Here’s How I Built It

Use these CSS features instead of JavaScript

Video

Go’s Big Mistake

Getting ADDICTED to STUDYING is Easy, Actually

Give me 31 minutes, I will make PyTorch click forever

The future unfolds! How to optimize Android apps for adaptive layouts

How I Learned Procedural Generation

Learn Java in 14 Minutes (seriously)