C# Tutorial For Beginners - 14. Pass By Value VS. Pass By Reference

0:00 what's up guys this is teddy welcome to

0:02 my youtube channel this video we're

0:04 going to be talking about pass by value

0:06 versus pass by reference and

0:09 the concept of a value type and a

0:11 reference type is uh i've covered it in

0:14 one of my previous videos but i'll just

0:16 go ahead and give you a very

0:18 simple 10 000 foot introduction to what

0:22 a value type is a value type is usually

0:24 integers and it looks like this

0:27 what you need to know about a value type

0:29 is that it's stored on the stack and

0:32 the values are typically

0:34 simpler they're not as long lasting and

0:37 when you store a value type

0:40 it is the number that you actually

0:43 declare

0:44 so value type

0:46 and this is important for

0:49 uh

0:50 just understanding like i'm just going

0:51 to tell you what you need to understand

0:53 the how to pat you know what's happening

0:55 when you're passing by value versus

0:57 passing by reference so with the value

0:59 type the

1:02 the value

1:05 is actually there like just remember

1:08 that like the value

1:10 when you store a value type and you

1:12 store it into this eye

1:14 like that ah that two is actually

1:17 um

1:19 there like so you know quote unquote

1:21 like that two is there it's not stored

1:24 in the heap somewhere else and it's not

1:26 stored by reference when you source

1:29 something by reference

1:31 and a reference type is usually more

1:34 complicated

1:35 and the

1:39 value type is always the most simple and

1:40 i'll explain after i get done with this

1:42 i'll show you exactly you know passing

1:44 by value because it's super simple and

1:46 people make this way more complicated

1:48 than it really needs to be

1:50 so a reference type is uh

1:53 the value is like the way it sounds it's

1:55 stored by reference there's a pointer

1:58 that says

2:00 this value is not really here but if you

2:02 want to go get it because it's such a

2:05 large long lasting object

2:07 i'm going to put this on the heap and

2:09 whenever you need this you can go get it

2:11 so

2:12 we'll say class and references are

2:14 always classes

2:16 and there's a there's

2:18 strings or reference reference types

2:20 arrays or reference types but

2:22 for purposes of this video and just kind

2:24 of

2:25 not to confuse you just think of a class

2:28 as like what a reference type is

2:31 so

2:33 when we

2:34 make this

2:36 this doesn't actually exist like this is

2:38 just like a uh an abstraction for

2:42 you to understand this this whole class

2:44 is for you this isn't really for the

2:45 computer

2:47 this

2:48 actually creates

2:51 this class right here so once you

2:53 actually declare this class

2:55 like it's actually in your program when

2:57 you make a class

2:58 the class doesn't really exist so once

3:01 you use this new word right here it's

3:04 going to go put this on the heap it's

3:06 going to actually create it and you can

3:08 actually see this happening if you want

3:09 to see this like an actual action

3:13 as a cool actual action

3:16 it's a cool little uh work play on words

3:19 i just did there didn't even mean to

3:22 so

3:23 i ain't i it's just gonna like

3:26 just watch this

3:27 so i like the two's there like it's

3:30 actually there when you go down to here

3:33 uh gotta

3:36 go here you gotta put that console right

3:37 line there so

3:39 when you go here

3:42 and you get these little curly brackets

3:44 that means that this is not actually

3:46 like this is like you just hover over

3:49 this the two is there

3:51 when you hover over this

3:53 this isn't actually there and

3:57 what's happening is it's stored by

3:59 reference there's

4:01 what's

4:01 this actually is and if you can actually

4:04 i think you can actually see this here

4:06 let me see

4:07 there's a way to

4:09 uh turn this into a hexadecimal so what

4:12 really is really happening is that this

4:14 is a hexadecimal that points to an

4:17 address in memory where this part is

4:19 stored right here so i hopefully that

4:22 you know didn't confuse you too much and

4:24 you got the picture betw uh

4:27 what the difference between a value type

4:29 and a reference type is so

4:31 in the context we'll just go ahead and

4:33 we'll do value first because value is a

4:35 lot more simple to understand when

4:37 talking about pass by value passed by

4:39 reference

4:41 so let's just go ahead in here

4:44 and

4:44 we're going to initialize two

4:47 variables let's say this one's five

4:50 and num two and this one is ten

4:55 then we can go ahead let's console

5:00 right

5:04 console right line this one then we'll

5:06 we'll do this one

5:08 and the key point here is to

5:11 watch what happens

5:13 before

5:14 this function executes that i'm about to

5:16 write and after this function executes

5:18 that i'm about to write and

5:20 because we're in.net 6 we have to uh

5:24 declare to

5:25 um top line statements

5:28 and top line statements means that

5:30 you're going to have to put your um

5:34 functions down here you can't put them

5:36 above your where you're doing your

5:38 declarations and your function execution

5:40 so we'll just call this one we're going

5:42 to square these

5:45 i'm assuming that you know what what to

5:47 square something means means you're just

5:49 going to multiply it by itself

5:52 i can

5:54 type this

5:58 hold on one second

6:00 gotta

6:01 move my microphone here

6:03 there we go it's a lot better

6:06 so ant i

6:10 into a

6:11 hint b

6:14 then go down here

6:16 and

6:17 we're going to say a is equal to a

6:20 times a

6:23 then b is equal to b

6:25 times b

6:27 yep and like i said

6:30 very simple

6:32 so we're going to

6:35 we have to go up here we're going to

6:37 create our function

6:39 and then we're going to pass in our two

6:42 variables very simple

6:46 num2

6:49 and then we are going to go down here

6:52 and we're going to console right line

6:55 what

6:56 we are passing in

6:57 and hopefully i can

7:01 have a good visual representation of

7:03 what's going on so let's just go ahead

7:06 here

7:07 go into our debugger

7:12 we're going to go down

7:13 we're going to declare our variables

7:16 then we are going to

7:20 do our console.writeline let's see what

7:21 happens beforehand so console.writeline

7:24 is executed let's see what happens

7:30 so fi all right

7:32 and i need to put this because

7:35 it does not look correct

7:39 so we go down once again we declare our

7:41 variables let's see our console right

7:43 line is executed before our square part

7:46 right here

7:48 and our

7:49 variables are exactly the same it's

7:51 going to be a 5 and a 10.

7:53 now let's watch what happens when we

7:55 actually step inside our square

7:59 so we step inside our square

8:01 it's going to pass the actual value so

8:04 here's a really key point

8:07 when i was talking about value types and

8:09 i mentioned that with value types like

8:11 the the number is like the actual number

8:14 there's no reference being passed there

8:16 and

8:17 that's really the whole entire key point

8:20 of it like the actual value is going to

8:22 be passed in and it's not tied or

8:26 referenced so

8:28 what's going to happen and if you don't

8:30 even want to really understand like

8:32 what's really going on

8:33 just realize that when you pass

8:35 something in as a value type into a

8:37 function

8:39 once the function executes

8:41 these numbers aren't actually going to

8:44 be

8:45 these numbers aren't actually going to

8:46 change because they're not connected to

8:49 each other like if i just had to give

8:52 you just like a really simple way to

8:53 describe it because it's a value type

8:56 and the actual value is stored like in

8:58 the actual place in memory

9:00 it's they're not going to be connected

9:02 to each other so when this thing steps

9:05 out if you watch it

9:07 so our it steps out it does the

9:09 calculation

9:10 what's going to happen is

9:13 that console the variables on the

9:15 outside aren't even going to change so

9:18 if you look at it

9:20 like i said

9:21 it does the calculation it goes into the

9:24 function and the variables on the

9:26 outside aren't going to change because

9:28 they're not actually referencing each

9:30 other

9:31 so

9:32 key point

9:33 value type when some when something is

9:36 passed into a function on the outside

9:38 the actual

9:40 variable is not going to change like if

9:43 let me just

9:46 outside function

9:48 variable is not going to change

9:55 not going to change

9:58 so let's go ahead and

10:00 let's do a reference type

10:05 so reference types are going to be

10:08 in theory a little bit more complicated

10:10 but they're really not the only reason

10:11 they're more complicated is because

10:13 usually you're dealing with more

10:15 complicated data so

10:16 with this one

10:18 we will go ahead we'll go down here and

10:20 let's just go ahead and make our class

10:22 and we're just going to make a very

10:24 simple person class and this person

10:26 class is going to have an int they're

10:29 going to have an age

10:34 very simple like the most simple class

10:36 that you could possibly have

10:38 then we're gonna go up here we're gonna

10:40 instantiate them

10:45 and we're just gonna give them super

10:51 simple

10:52 just

10:52 instantiation like look we won't make it

10:54 complicated at all

10:57 then we're going to create two of the

10:58 objects

11:01 and go ahead and console rightline them

11:07 or let's actually before we do that it

11:10 might be a better idea

11:12 to actually assign some values to them

11:14 so that we can see something actually

11:16 change

11:18 okay then we have our age here

11:22 and we'll do a console.writeline

11:28 caught some right line

11:30 then let's make a square for our actual

11:34 we're gonna go down here we're gonna

11:35 make an actual square

11:37 function because we have to pass in you

11:39 know this function to something and

11:42 once again make it very simple so square

11:48 we're going to pass in our

11:51 objects

11:56 and let's name this one actually a

11:59 just like i said make things simple and

12:02 not

12:03 make things more confusing than they

12:05 need to be

12:07 and what

12:09 gonna go in here we're going to

12:10 manipulate our age make sure that you

12:12 just don't put an a right there because

12:14 it's not going to actually manipulate

12:16 any of the variables and it will give

12:19 you an error

12:26 sql a dot age

12:29 plus

12:30 not plus we're going to square

12:33 a dot

12:34 a dot age

12:38 then we're going to go b

12:40 h is equal to b h wow look at that

12:43 intellisense intellisense is amazing i

12:46 love intellisense

12:50 okay then we're going to have our age

12:55 going to have

12:57 that little space there we're going to

12:59 go down b dot age

13:02 so that we can see what is going on

13:04 inside of the function

13:06 and then for

13:07 this one we have to do our function

13:12 all right p

13:14 dot one

13:15 we're just gonna pass in our

13:18 p.2

13:20 and then we're gonna do one more

13:22 console.writeline like i said so that we

13:24 can see what's happening after the

13:26 function is actually executed

13:30 p

13:32 p

13:33 one

13:36 age plus

13:40 put that space there for

13:43 visual purposes just to kind of make it

13:44 look better

13:47 then we go up here

13:50 okay great and that doesn't look right

13:53 so i am going to just copy that

13:56 into there

14:01 okay

14:03 all right let's step through that that

14:04 was actually that was actually

14:05 relatively complicated

14:08 it's a lot of a lot of just with

14:11 reference reference types uh are just

14:13 typically going to be more complicated

14:15 because they're actually

14:16 classes and there's just more stuff

14:18 going on so we go up here we declare we

14:21 create our references we go down we

14:23 assign um

14:26 values within our class so or not within

14:30 our class within our object that was

14:31 created by the class so go down here p

14:34 dot age

14:36 okay so this is probably the most

14:38 important part we go through here

14:41 obviously our values are just going to

14:43 be 5 and 10 just like before but we

14:45 haven't gone inside of our function yet

14:47 so

14:48 let's step into our function

14:50 we go in here it's going to go a.h

14:53 remember that this is um

14:55 by reference so when this is actually

14:59 when you actually go inside here

15:02 it's actually going to manipulate the

15:04 values on the outside of the function

15:08 just if you

15:09 those are probably the only thing so

15:12 when

15:13 we pass by value type the

15:16 variables on the outside are not

15:19 um altered in any way but when we pass

15:22 by reference type they are

15:24 about variables outside

15:28 are

15:30 changed

15:32 change manipulated whatever you want to

15:33 call variables are changed on the

15:36 outside

15:37 if that's the only thing you you

15:39 remember and you don't even want to

15:41 watch the rest the rest of the video you

15:43 could probably just get away with

15:45 knowing that and they are going to ask

15:46 you this kind of stuff on an interview

15:49 so make sure that you remember pass by

15:51 you know pass by value pass by reference

15:53 so we go in here

15:56 and

15:57 the values are going to change they are

15:59 going to be squared

16:01 but key point and just like i said after

16:04 we get out of this function it's going

16:06 to go through here it's going to print

16:08 these values and you can actually see

16:10 the values

16:12 and

16:13 those values are going to be

16:16 changed on the outside of the function

16:19 and that's pretty much all you're going

16:21 to really need to know for pass by value

16:23 and pass by reference it's going to get

16:25 a little bit more complicated and we're

16:26 going to have to talk about reference or

16:28 ref

16:30 ref

16:31 out and in but i'm going to do those in

16:33 a separate video because i'm kind of the

16:36 time on this video's getting up there a

16:38 little bit and i'm gonna save it for a

16:40 separate video so that i can also target

16:42 those keywords anyway that i hopefully

16:44 that uh didn't confuse you too much it

16:47 is kind of like a little bit of a

16:48 confusing subject if you guys like this

16:51 video make sure to hit that like button

16:53 make sure to hit that subscribe button

16:54 and as always thank you for watching

0:00 Xin chào mọi người! Mình là Teddy. Chào mừng đến với kênh YouTube của mình. Trong video này, chúng ta sẽ cùng tìm hiểu về truyền tham trị và truyền tham chiếu.

0:09 Về khái niệm kiểu giá trị và kiểu tham chiếu, mình đã đề cập đến nó trong một video trước đây rồi, nhưng mình sẽ giới thiệu một cách đơn giản nhất về kiểu giá trị.

0:22 Kiểu giá trị thường là số nguyên và nó trông như thế này. Điều quan trọng bạn cần biết về kiểu giá trị là nó được lưu trữ trên stack và các giá trị thường đơn giản hơn, không tồn tại lâu dài.

0:37 Khi bạn lưu trữ một kiểu giá trị, đó chính là con số mà bạn khai báo.

0:44 Vì vậy, kiểu giá trị, và điều này rất quan trọng để hiểu, mình sẽ chỉ cho bạn những gì bạn cần hiểu, cách thức, bạn biết đấy, điều gì đang xảy ra khi bạn truyền tham trị so với truyền tham chiếu.

0:57 Với kiểu giá trị, giá trị thực sự nằm ở đó. Hãy nhớ rằng, khi bạn lưu trữ một kiểu giá trị và bạn lưu nó vào biến "I" này, thì số hai đó thực sự, ừm, ở đó, giống như, bạn biết đấy, số hai đó ở đó.

1:24 Nó không được lưu trữ trong heap ở một nơi nào khác và nó không được lưu trữ bằng tham chiếu khi bạn lấy một cái gì đó bằng tham chiếu.

1:31 Kiểu tham chiếu thường phức tạp hơn, còn kiểu giá trị luôn đơn giản nhất.

1:40 Mình sẽ giải thích sau khi hoàn thành việc này. Mình sẽ chỉ cho bạn chính xác cách truyền tham trị, vì nó siêu đơn giản và mọi người làm cho nó phức tạp hơn nhiều so với thực tế.

1:50 Kiểu tham chiếu là, giá trị được lưu trữ bằng tham chiếu, đúng như tên gọi của nó.

1:55 Có một con trỏ cho biết giá trị này không thực sự ở đây, nhưng nếu bạn muốn lấy nó vì nó là một đối tượng lớn, tồn tại lâu dài, mình sẽ đặt nó trên heap và bất cứ khi nào bạn cần, bạn có thể lấy nó.

2:12 Chúng ta sẽ nói về class, và tham chiếu luôn là các class. Có các chuỗi hoặc các kiểu tham chiếu, mảng hoặc các kiểu tham chiếu, nhưng cho mục đích của video này và để tránh làm bạn bối rối, hãy cứ nghĩ về class như là kiểu tham chiếu.

2:31 Vì vậy, khi chúng ta tạo ra điều này, điều này thực sự không tồn tại. Đây chỉ là một sự trừu tượng để bạn hiểu.

2:42 Toàn bộ class này là dành cho bạn, không thực sự dành cho máy tính.

2:47 Điều này thực sự tạo ra class này ngay tại đây. Vì vậy, khi bạn thực sự khai báo class này, giống như nó thực sự có trong chương trình của bạn, khi bạn tạo một class, class đó thực sự không tồn tại.

3:01 Khi bạn sử dụng từ "new" này ngay tại đây, nó sẽ đặt nó trên heap. Nó sẽ thực sự tạo ra nó và bạn thực sự có thể thấy điều này xảy ra nếu bạn muốn thấy điều này như một hành động thực tế.

3:13 Là một hành động thực tế thú vị, đó là một cách chơi chữ nhỏ thú vị mà mình vừa thực hiện ở đó. Thậm chí không có ý định.

3:23 Mình không... cứ xem cái này đi.

3:27 Mình thích số hai ở đó, giống như nó thực sự ở đó. Khi bạn đi xuống đây, bạn phải đặt dòng console right đó ở đó.

3:39 Khi bạn đến đây và bạn nhận được những dấu ngoặc nhọn nhỏ này, điều đó có nghĩa là điều này không thực sự, giống như điều này là, bạn chỉ cần di chuột qua điều này, số hai ở đó.

3:51 Khi bạn di chuột qua điều này, điều này không thực sự ở đó và điều gì đang xảy ra là nó được lưu trữ bằng tham chiếu.

4:01 Cái này thực sự là gì, và nếu bạn thực sự có thể, mình nghĩ bạn thực sự có thể thấy điều này ở đây, để mình xem.

4:07 Có một cách để biến điều này thành một số thập lục phân.

4:12 Điều thực sự đang xảy ra là đây là một số thập lục phân trỏ đến một địa chỉ trong bộ nhớ nơi phần này được lưu trữ ngay tại đây.

4:19 Mình hy vọng điều đó không làm bạn quá bối rối và bạn đã hiểu được sự khác biệt giữa kiểu giá trị và kiểu tham chiếu.

4:31 Trong bối cảnh này, chúng ta sẽ tiếp tục và làm giá trị trước vì giá trị dễ hiểu hơn nhiều khi nói về truyền tham trị, truyền tham chiếu.

4:41 Hãy tiếp tục và khởi tạo hai biến. Giả sử cái này là năm và num hai là mười.

4:55 Sau đó, chúng ta có thể tiếp tục, console right, console right line cái này, sau đó chúng ta sẽ làm cái này.

5:08 Điểm mấu chốt ở đây là xem điều gì xảy ra trước khi hàm này thực thi mà mình sắp viết và sau khi hàm này thực thi mà mình sắp viết.

5:20 Vì chúng ta đang ở trong .NET 6, chúng ta phải khai báo cho các câu lệnh hàng đầu, và các câu lệnh hàng đầu có nghĩa là bạn sẽ phải đặt

5:34 các hàm của bạn ở đây. Bạn không thể đặt chúng phía trên nơi bạn đang thực hiện các khai báo và thực thi hàm của mình.

5:40 Chúng ta sẽ chỉ gọi cái này. Chúng ta sẽ bình phương những cái này.

5:45 Mình cho rằng bạn biết bình phương một cái gì đó có nghĩa là gì. Có nghĩa là bạn sẽ chỉ nhân nó với chính nó.

5:52 Mình có thể gõ cái này.

5:58 Chờ một giây.

6:00 Phải di chuyển micrô của mình ở đây.

6:03 Thế là tốt hơn nhiều.

6:06 Vì vậy, int I, vào a, gợi ý b.

6:14 Sau đó, đi xuống đây và chúng ta sẽ nói a bằng a nhân a, sau đó b bằng b nhân b.

6:27 Ừ, và như mình đã nói, rất đơn giản.

6:32 Chúng ta sẽ phải đi lên đây. Chúng ta sẽ tạo hàm của mình và sau đó chúng ta sẽ truyền vào hai biến của mình. Rất đơn giản.

6:46 num2 và sau đó chúng ta sẽ đi xuống đây và chúng ta sẽ console right line những gì chúng ta đang truyền vào.

6:57 Hy vọng rằng mình có thể có một biểu diễn trực quan tốt về những gì đang xảy ra. Vì vậy, hãy cứ tiếp tục ở đây, đi vào trình gỡ lỗi của chúng ta.

7:12 Chúng ta sẽ đi xuống. Chúng ta sẽ khai báo các biến của mình.

7:16 Sau đó, chúng ta sẽ thực hiện console.writeline của mình. Hãy xem điều gì xảy ra trước. Vì vậy, console.writeline được thực thi. Hãy xem điều gì xảy ra.

7:30 Vậy là xong, được rồi, và mình cần sửa lại cái này vì nó trông không đúng.

7:39 Chúng ta đi xuống một lần nữa. Chúng ta khai báo các biến của mình. Hãy xem dòng console right của chúng ta được thực thi trước phần bình phương của chúng ta ngay tại đây và các biến của chúng ta hoàn toàn giống nhau. Nó sẽ là 5 và 10.

7:53 Bây giờ, hãy xem điều gì xảy ra khi chúng ta thực sự bước vào hàm bình phương của mình.

7:59 Chúng ta bước vào hàm bình phương của mình. Nó sẽ truyền giá trị thực tế.

8:04 Đây là một điểm thực sự quan trọng. Khi mình nói về các kiểu giá trị và mình đã đề cập rằng với các kiểu giá trị, số là số thực tế, không có tham chiếu nào được truyền ở đó, và đó thực sự là toàn bộ điểm mấu chốt của nó.

8:20 Giá trị thực tế sẽ được truyền vào và nó không bị ràng buộc hoặc tham chiếu.

8:28 Nếu bạn không thực sự muốn hiểu điều gì đang xảy ra, chỉ cần nhận ra rằng khi bạn truyền một thứ gì đó dưới dạng kiểu giá trị vào một hàm, sau khi hàm thực thi, những số này sẽ không thực sự thay đổi vì chúng không được kết nối với nhau.

8:49 Nếu mình phải cung cấp cho bạn một cách thực sự đơn giản để mô tả nó, vì nó là một kiểu giá trị và giá trị thực tế được lưu trữ như ở vị trí thực tế trong bộ nhớ, chúng sẽ không được kết nối với nhau.

9:02 Khi thứ này bước ra, nếu bạn xem nó, nó thực hiện phép tính.

9:10 Điều gì sẽ xảy ra là console, các biến ở bên ngoài thậm chí sẽ không thay đổi.

9:18 Nếu bạn nhìn vào nó, như mình đã nói, nó thực hiện phép tính, nó đi vào hàm và các biến ở bên ngoài sẽ không thay đổi vì chúng không thực sự tham chiếu lẫn nhau.

9:31 Điểm mấu chốt, kiểu giá trị, khi một số, khi một thứ gì đó được truyền vào một hàm ở bên ngoài, biến thực tế sẽ không thay đổi.

9:40 Biến hàm bên ngoài sẽ không thay đổi.

9:58 Hãy tiếp tục và thực hiện một kiểu tham chiếu.

10:05 Các kiểu tham chiếu, về lý thuyết, phức tạp hơn một chút, nhưng chúng thực sự không phải vậy.

10:11 Lý do duy nhất chúng phức tạp hơn là vì thông thường bạn đang xử lý dữ liệu phức tạp hơn.

10:16 Với cái này, chúng ta sẽ tiếp tục. Chúng ta sẽ đi xuống đây và tạo class của chúng ta. Chúng ta sẽ chỉ tạo một class người rất đơn giản và class người này sẽ có một int, tuổi.

10:34 Rất đơn giản, class đơn giản nhất mà bạn có thể có.

10:38 Sau đó, chúng ta sẽ đi lên đây. Chúng ta sẽ khởi tạo chúng và chúng ta sẽ chỉ cung cấp cho chúng siêu đơn giản, chỉ khởi tạo, chúng ta sẽ không làm cho nó phức tạp chút nào.

10:57 Sau đó, chúng ta sẽ tạo hai đối tượng và tiếp tục console rightline chúng.

11:07 Hoặc thực tế, trước khi chúng ta làm điều đó, có thể là một ý tưởng tốt hơn để thực sự gán một số giá trị cho chúng để chúng ta có thể thấy một cái gì đó thực sự thay đổi.

11:18 Được rồi, sau đó chúng ta có tuổi của chúng ta ở đây và chúng ta sẽ thực hiện console.writeline, bắt một số dòng right.

11:30 Sau đó, hãy tạo một hàm bình phương cho thực tế của chúng ta. Chúng ta sẽ đi xuống đây. Chúng ta sẽ tạo một hàm bình phương thực tế vì chúng ta phải truyền vào hàm này cho một cái gì đó.

11:42 Một lần nữa, làm cho nó rất đơn giản. Vì vậy, bình phương, chúng ta sẽ truyền vào các đối tượng của chúng ta.

11:56 Hãy đặt tên cho cái này là "a". Như mình đã nói, làm cho mọi thứ đơn giản và không làm cho mọi thứ trở nên khó hiểu hơn mức cần thiết.

12:07 Và những gì sẽ đi vào đây? Chúng ta sẽ thao tác với tuổi của chúng ta. Đảm bảo rằng bạn không chỉ đặt một "a" ngay ở đó vì nó sẽ không thực sự thao tác với bất kỳ biến nào và nó sẽ cung cấp cho bạn một lỗi.

12:26 a.age, cộng, không cộng, chúng ta sẽ bình phương a.age.

12:38 Sau đó, chúng tôi sẽ đi b.age bằng b.age. Ồ, hãy nhìn vào điều đó. Intellisense. Intellisense thật tuyệt vời. Mình yêu Intellisense.

12:50 Được rồi, sau đó chúng ta sẽ có tuổi của chúng ta, sẽ có một khoảng trống nhỏ ở đó. Chúng ta sẽ đi xuống b.age để chúng ta có thể thấy điều gì đang xảy ra bên trong hàm.

13:06 Và sau đó cho cái này, chúng ta phải thực hiện hàm của chúng ta.

13:12 p.one. Chúng ta sẽ chỉ truyền vào p.2 của chúng ta và sau đó chúng ta sẽ thực hiện thêm một console.writeline, như mình đã nói, để chúng ta có thể thấy điều gì đang xảy ra sau khi hàm thực sự được thực thi.

13:30 p.age cộng, đặt khoảng trống đó ở đó cho mục đích trực quan, chỉ để làm cho nó trông đẹp hơn.

13:47 Sau đó, chúng ta đi lên đây. Được rồi, tuyệt vời và điều đó trông không đúng. Vì vậy, mình sẽ chỉ sao chép nó vào đó.

14:01 Được rồi, hãy bước qua điều đó. Điều đó thực sự tương đối phức tạp.

14:08 Có rất nhiều, rất nhiều chỉ với các kiểu tham chiếu, thường sẽ phức tạp hơn vì chúng thực sự là các class và có nhiều thứ đang diễn ra hơn.

14:18 Chúng ta đi lên đây. Chúng ta khai báo, chúng ta tạo các tham chiếu của chúng ta. Chúng ta đi xuống. Chúng ta gán các giá trị trong class của chúng ta.

14:26 Hoặc không phải trong class của chúng ta, trong đối tượng của chúng ta được tạo bởi class. Vì vậy, đi xuống đây, p.age.

14:36 Đây có lẽ là phần quan trọng nhất. Chúng ta đi qua đây.

14:41 Rõ ràng, các giá trị của chúng ta sẽ chỉ là 5 và 10 giống như trước đây, nhưng chúng ta vẫn chưa đi vào bên trong hàm của chúng ta.

14:48 Hãy bước vào hàm của chúng ta.

14:50 Chúng ta đi vào đây. Nó sẽ đi a.age. Hãy nhớ rằng đây là bằng tham chiếu.

14:55 Khi điều này thực sự, khi bạn thực sự đi vào bên trong đây, nó sẽ thực sự thao tác các giá trị ở bên ngoài hàm.

15:08 Đó có lẽ là điều duy nhất.

15:12 Vì vậy, khi chúng ta truyền bằng kiểu giá trị, các biến ở bên ngoài không bị thay đổi, nhưng khi chúng ta truyền bằng kiểu tham chiếu, chúng sẽ bị thay đổi.

15:24 Các biến bên ngoài được thay đổi, thao tác, bất cứ điều gì bạn muốn gọi, các biến được thay đổi ở bên ngoài.

15:37 Nếu đó là điều duy nhất bạn nhớ và bạn thậm chí không muốn xem phần còn lại của video, bạn có thể chỉ cần nhớ điều đó thôi. Họ sẽ hỏi bạn những điều này trong một cuộc phỏng vấn đấy.

15:49 Hãy đảm bảo rằng bạn nhớ truyền bằng giá trị, truyền bằng tham chiếu.

15:53 Chúng ta đi vào đây và các giá trị sẽ thay đổi. Chúng sẽ được bình phương.

16:01 Sau khi chúng ta ra khỏi hàm này, nó sẽ đi qua đây. Nó sẽ in các giá trị này và bạn thực sự có thể thấy các giá trị đó sẽ được thay đổi ở bên ngoài hàm.

16:19 Đó là hầu hết tất cả những gì bạn sẽ thực sự cần biết về truyền bằng giá trị và truyền bằng tham chiếu.

16:23 Nó sẽ trở nên phức tạp hơn một chút và chúng ta sẽ phải nói về "ref", "ref out" và "in", nhưng mình sẽ thực hiện những điều đó trong một video riêng vì thời lượng video này đang tăng lên một chút và mình sẽ lưu nó cho một video riêng để mình cũng có thể nhắm mục tiêu những từ khóa đó.

16:42 Mình hy vọng rằng không làm bạn quá bối rối. Nó là một chủ đề hơi khó hiểu.

16:51 Nếu các bạn thích video này, hãy nhớ nhấn nút thích và đăng ký kênh của mình nhé. Cảm ơn bạn đã xem!