Các lớp có được chuyển qua tham chiếu trong javascript không?

Bài viết này đã được lấy từ Step Up Your JS. Hướng dẫn toàn diện về JavaScript trung cấp, khóa học trực tuyến của tôi. Vui lòng xem nó ở đó để biết sân chơi mã tương tác và bài kiểm tra trực tuyến

Nội dung chính Show

Chỉ định theo tham chiếu
Chỉ định lại một tham chiếu
Hàm thuần túy
Tự kiểm tra
Đó là nó. Đi viết một số mã
Khóa học trực tuyến
Các lớp có được chuyển qua tham chiếu không?
JavaScript có được chuyển theo giá trị hoặc tham chiếu không?
Loại JavaScript nào được chuyển qua tham chiếu?
Các chuỗi JavaScript có được chuyển qua tham chiếu không?

Javascript có 5 kiểu dữ liệu được truyền theo giá trị.

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

0, và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

1. Chúng ta sẽ gọi những kiểu nguyên thủy này

Javascript có 3 kiểu dữ liệu được truyền theo tham chiếu.

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

3 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

4. Đây đều là những Đối tượng về mặt kỹ thuật, vì vậy chúng tôi sẽ gọi chung chúng là Đối tượng

nguyên thủy

Nếu một kiểu nguyên thủy được gán cho một biến, chúng ta có thể coi biến đó chứa giá trị nguyên thủy

________số 8

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

5 chứa

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

7 chứa

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

8. Để củng cố ý tưởng này, chúng tôi sẽ duy trì một hình ảnh về những biến này và giá trị tương ứng của chúng trông như thế nào trong bộ nhớ

Khi chúng tôi gán các biến này cho các biến khác bằng cách sử dụng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

9, chúng tôi sao chép giá trị cho biến mới. Chúng được sao chép theo giá trị

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Cả

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

50 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

5 hiện có chứa

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

6. Cả

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

53 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

7 hiện có chứa

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

8. Chúng tách biệt vì bản thân các giá trị đã được sao chép

Thay đổi cái này không thay đổi cái khác. Hãy nghĩ về các biến không có mối quan hệ với nhau

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Đối tượng

Điều này sẽ cảm thấy khó hiểu, nhưng hãy chịu đựng tôi và đọc qua nó. Một khi bạn vượt qua nó, nó sẽ có vẻ dễ dàng

Các biến được gán một giá trị không nguyên thủy được cung cấp một tham chiếu đến giá trị đó. Tham chiếu đó trỏ đến vị trí của đối tượng trong bộ nhớ. Các biến không thực sự chứa giá trị

Các đối tượng được tạo tại một số vị trí trong bộ nhớ máy tính của bạn. Khi chúng tôi viết

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

56, chúng tôi đã tạo một mảng trong bộ nhớ. Cái mà biến

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

57 nhận được là địa chỉ, vị trí của mảng đó

Hãy giả sử rằng

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

58 là một kiểu dữ liệu mới được truyền theo giá trị, giống như

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

59 hoặc

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

60. Một

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

58 trỏ đến vị trí, trong bộ nhớ, của một giá trị được truyền theo tham chiếu. Giống như một chuỗi được biểu thị bằng dấu ngoặc kép (

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

62 hoặc

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

63), một

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

58 sẽ được biểu thị bằng dấu ngoặc nhọn,

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Khi chúng ta gán và sử dụng một biến kiểu tham chiếu, những gì chúng ta viết và nhìn thấy là

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Một đại diện của dòng 1 và 2 ở trên trong bộ nhớ là

Lưu ý rằng giá trị, địa chỉ, được chứa bởi biến

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

57 là tĩnh. Mảng trong bộ nhớ là thứ thay đổi. Khi chúng ta sử dụng

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

57 để làm gì đó, chẳng hạn như đẩy một giá trị, công cụ Javascript sẽ chuyển đến vị trí của

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

57 trong bộ nhớ và làm việc với thông tin được lưu trữ ở đó

Chỉ định theo tham chiếu

Khi một giá trị kiểu tham chiếu, một đối tượng, được sao chép sang một biến khác bằng cách sử dụng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

9, địa chỉ của giá trị đó là địa chỉ thực sự được sao chép như thể nó là một biến nguyên thủy. Các đối tượng được sao chép theo tham chiếu thay vì theo giá trị

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Đoạn mã trên trông như thế này trong bộ nhớ

Mỗi biến bây giờ chứa một tham chiếu đến cùng một mảng. Điều đó có nghĩa là nếu chúng ta thay đổi

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

80, thì

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

81 sẽ thấy những thay đổi đó

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Chúng tôi đã đẩy

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

82 vào mảng trong bộ nhớ. Khi chúng tôi sử dụng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

80 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

81, chúng tôi đang trỏ đến cùng một mảng đó

Chỉ định lại một tham chiếu

Gán lại biến tham chiếu thay thế tham chiếu cũ

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Trong trí nhớ

Khi chúng ta có một dòng thứ hai

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Địa chỉ được lưu trữ trong

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

85 thay đổi. Đối tượng đầu tiên vẫn còn trong bộ nhớ và đối tượng tiếp theo cũng vậy

Khi không còn tham chiếu đến một đối tượng, như chúng ta thấy đối với địa chỉ

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

86 ở trên, công cụ Javascript có thể thực hiện thu gom rác. Điều này chỉ có nghĩa là lập trình viên đã mất tất cả các tham chiếu đến đối tượng và không thể sử dụng đối tượng nữa, vì vậy công cụ có thể tiếp tục và xóa nó khỏi bộ nhớ một cách an toàn. Trong trường hợp này, đối tượng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

87 không còn truy cập được nữa và có sẵn cho công cụ để thu gom rác

== và ===

Khi các toán tử đẳng thức,

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

88 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

89, được sử dụng trên các biến kiểu tham chiếu, chúng sẽ kiểm tra tham chiếu. Nếu các biến chứa tham chiếu đến cùng một mục, thì việc so sánh sẽ dẫn đến kết quả là

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Nếu chúng là các đối tượng riêng biệt, ngay cả khi chúng chứa các thuộc tính giống hệt nhau, thì việc so sánh sẽ dẫn đến kết quả là

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Nếu chúng ta có hai đối tượng riêng biệt và muốn xem các thuộc tính của chúng có giống nhau hay không, cách dễ nhất để làm là biến cả hai thành chuỗi rồi so sánh các chuỗi. Khi các toán tử đẳng thức đang so sánh các nguyên hàm, chúng chỉ cần kiểm tra xem các giá trị có giống nhau không

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Một tùy chọn khác là lặp đệ quy qua các đối tượng và đảm bảo rằng mỗi thuộc tính đều giống nhau

Truyền tham số qua hàm

Khi chúng ta chuyển các giá trị nguyên thủy vào một hàm, hàm này sẽ sao chép các giá trị đó vào các tham số của nó. Nó thực sự giống như sử dụng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Trong ví dụ trên, chúng tôi cung cấp cho

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

43 giá trị

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

44. Khi chúng ta chuyển nó vào

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

45, biến

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

5 nhận giá trị đó,

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

44. Giá trị được sao chép như thể chúng ta đã sử dụng phép gán

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

9. Một lần nữa, giá trị của

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

43 không bị ảnh hưởng. Đây là ảnh chụp nhanh bộ nhớ trông như thế nào ngay tại dòng nhận xét TẠM DỪNG trong

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Hàm thuần túy

Chúng tôi coi các chức năng không ảnh hưởng đến bất kỳ thứ gì trong phạm vi bên ngoài là các chức năng thuần túy. Miễn là một hàm chỉ lấy các giá trị nguyên thủy làm tham số và không sử dụng bất kỳ biến nào trong phạm vi xung quanh của nó, thì nó sẽ tự động thuần túy, vì nó không thể ảnh hưởng đến bất kỳ thứ gì trong phạm vi bên ngoài. Tất cả các biến được tạo bên trong đều được thu gom rác ngay khi hàm trả về

Tuy nhiên, một chức năng nhận một Đối tượng có thể thay đổi trạng thái của phạm vi xung quanh nó. Nếu một hàm nhận vào một tham chiếu mảng và thay đổi mảng mà nó trỏ tới, có lẽ bằng cách đẩy tới nó, các biến trong phạm vi xung quanh tham chiếu mảng đó sẽ thấy sự thay đổi đó. Sau khi hàm trả về, những thay đổi mà nó tạo ra vẫn tồn tại ở phạm vi bên ngoài. Điều này có thể gây ra các tác dụng phụ không mong muốn khó theo dõi

Do đó, nhiều hàm mảng gốc, bao gồm

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

51 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

52, được viết dưới dạng hàm thuần túy. Họ lấy một tham chiếu mảng và nội bộ, họ sao chép mảng và làm việc với bản sao thay vì bản gốc. Điều này làm cho bản gốc không bị ảnh hưởng, phạm vi bên ngoài không bị ảnh hưởng và chúng tôi đã trả về một tham chiếu đến một mảng hoàn toàn mới

Hãy đi vào một ví dụ về một so với thuần túy. chức năng không tinh khiết

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Hàm không tinh khiết này nhận vào một đối tượng và thay đổi thuộc tính

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

53 trên đối tượng đó thành 25. Bởi vì nó hoạt động trên tham chiếu nó đã được đưa ra, nó trực tiếp thay đổi đối tượng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

54. Lưu ý rằng khi nó trả về đối tượng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

55, nó sẽ trả về chính đối tượng đã được truyền vào.

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

54 và

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

57 chứa cùng một tham chiếu. Việc trả về biến

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

55 và lưu trữ tham chiếu trong một biến mới là không cần thiết

Hãy xem xét một hàm thuần túy

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Trong chức năng này, chúng tôi sử dụng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

59 để chuyển đổi đối tượng mà chúng tôi truyền vào thành một chuỗi, sau đó phân tích lại thành một đối tượng với

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

20. Bằng cách thực hiện chuyển đổi này và lưu trữ kết quả trong một biến mới, chúng tôi đã tạo một đối tượng mới. Có nhiều cách khác để làm điều tương tự như lặp qua đối tượng ban đầu và gán từng thuộc tính của nó cho một đối tượng mới, nhưng cách này là đơn giản nhất. Đối tượng mới có các thuộc tính giống như đối tượng ban đầu nhưng nó là một đối tượng riêng biệt rõ ràng trong bộ nhớ

Khi chúng tôi thay đổi thuộc tính

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

53 trên đối tượng mới này, bản gốc không bị ảnh hưởng. Chức năng này bây giờ là tinh khiết. Nó không thể ảnh hưởng đến bất kỳ đối tượng nào bên ngoài phạm vi của chính nó, kể cả đối tượng được truyền vào. Đối tượng mới cần được trả về và lưu trữ trong một biến mới, nếu không nó sẽ bị thu gom rác sau khi chức năng hoàn thành, vì đối tượng không còn trong phạm vi

Tự kiểm tra

Giá trị so với. tham chiếu là một khái niệm thường được thử nghiệm trong các cuộc phỏng vấn mã hóa. Cố gắng tự mình tìm ra những gì được ghi ở đây

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Đầu tiên, hàm thay đổi thuộc tính

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

53 trên đối tượng ban đầu mà nó được truyền vào. Sau đó, nó gán lại biến cho một đối tượng hoàn toàn mới và trả về đối tượng đó. Đây là những gì hai đối tượng đã đăng xuất

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Hãy nhớ rằng phép gán thông qua các tham số chức năng về cơ bản giống như phép gán với

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

9. Biến

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

55 trong hàm chứa tham chiếu đến đối tượng

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

25 nên ban đầu nó tác động trực tiếp lên đối tượng đó. Khi chúng tôi gán lại

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

55 cho một đối tượng mới, nó sẽ ngừng ảnh hưởng đến đối tượng ban đầu

Việc gán lại này không thay đổi đối tượng mà

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

25 trỏ tới trong phạm vi bên ngoài.

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

55 có một tham chiếu mới vì nó đã được gán lại nhưng việc gán lại này không thay đổi

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

Một đoạn mã tương đương với khối trên sẽ là

var x = 10;
var y = 'abc';var a = x;
var b = y;console.log(x, y, a, b); // -> 10, 'abc', 10, 'abc'

Sự khác biệt duy nhất là khi chúng ta sử dụng chức năng,

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

55 không còn trong phạm vi sau khi chức năng kết thúc

Đó là nó. Đi viết một số mã

— — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Nếu điều này hữu ích, xin vui lòng đánh vào trái tim và thoải mái kiểm tra công việc khác của tôi

Công việc của tôi

Khóa học trực tuyến

Tôi đã tạo một khóa học trực tuyến về giáo dục. io bao gồm các chủ đề JavaScript trung gian như phạm vi, bao đóng, OOP,

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

41,

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

42,

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

43/

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

44/

var x = 10;
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log(x, y, a, b); // -> 10, 'abc', 5, 'def'

45, mã không đồng bộ, thao tác mảng và đối tượng, và ES2015+

Các lớp có được chuyển qua tham chiếu không?

Đạt một lớp theo tham chiếu . Ngoài việc chuyển lớp theo giá trị, bạn có thể chuyển lớp theo tham chiếu .

JavaScript có được chuyển theo giá trị hoặc tham chiếu không?

JavaScript luôn chuyển từng giá trị . Điều này có nghĩa là mọi thứ trong JavaScript là một loại giá trị và các đối số của hàm luôn được truyền theo giá trị.

Loại JavaScript nào được chuyển qua tham chiếu?

Các loại dữ liệu nguyên thủy như chuỗi, số, null, không xác định và boolean, được truyền theo giá trị trong khi các loại dữ liệu không nguyên thủy như đối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàmđối tượng, mảng và hàm are passed by reference in Javascript.

Các chuỗi JavaScript có được chuyển qua tham chiếu không?

Trên thực tế, Chuỗi trong Javascript thực sự được truyền “theo tham chiếu” . Do đó, việc gọi một hàm bằng một chuỗi không liên quan đến việc sao chép nội dung của chuỗi. Tuy nhiên, Chuỗi JavaScript là bất biến; .