JavaScript có sử dụng tham chiếu không?

Trong JavaScript, một biến có thể lưu trữ hai loại giá trị, Giá trị nguyên thủy hoặc Giá trị tham chiếu. Bài viết này sẽ mô tả và giúp so sánh cả hai loại giá trị này

giá trị nguyên thủy. JavaScript cung cấp sáu loại giá trị nguyên thủy bao gồm Số, Chuỗi, Boolean, Không xác định, Ký hiệu và. Kích thước của các giá trị Nguyên thủy là cố định, do đó JavaScript lưu trữ giá trị nguyên thủy trong ngăn xếp cuộc gọi [Bối cảnh thực thi]

Khi chúng tôi truy cập một giá trị nguyên thủy, chúng tôi thao tác giá trị thực tế được lưu trữ trong biến đó. Do đó, các biến nguyên thủy được truy cập bởi Giá trị. Khi chúng ta gán một biến lưu trữ giá trị nguyên thủy cho một biến khác, giá trị được lưu trữ trong biến đó được tạo và sao chép vào biến mới

Thí dụ. Hãy để chúng tôi lấy một ví dụ để hiểu giá trị nguyên thủy

giá trị nguyên thủy

Javascript

let age = 30;

let age1 = age;// Pointing to age

 

console.log[`age = ${age}  age1 = ${age1}`];

 

age = 31;// Pointing to new address

 

console.log[`age = ${age}  age1 = ${age1}`];

đầu ra

 age = 30  age1 = 30
 age = 31  age1 = 30

Giá trị tham khảo. JavaScript cung cấp ba loại giá trị Tham chiếu bao gồm Mảng, Đối tượng và Hàm. Kích thước của một giá trị tham chiếu là động do đó Nó được lưu trữ trên Heap

Khi chúng tôi truy cập một giá trị tham chiếu, chúng tôi thao tác nó thông qua tham chiếu, không phải thông qua giá trị thực được lưu trữ của nó. Do đó, các biến là giá trị tham chiếu được truy cập bằng tham chiếu. Khi chúng ta gán một giá trị tham chiếu từ một biến này sang một biến khác, giá trị được lưu trong biến đó cũng được sao chép vào vị trí của biến mới nhưng điểm khác biệt là các giá trị được lưu trong cả hai biến bây giờ là địa chỉ của đối tượng thực được lưu trên biến. . Kết quả là cả hai biến đều tham chiếu đến cùng một đối tượng, vì vậy chúng ta có thể thao tác đối tượng ban đầu từ cả hai biến

Vào ngày đầu tiên học viết mã, ai đó nói với bạn “Một biến số giống như một cái hộp. Viết

word = "world"

6 đặt

word = "world"

7 vào ô

word = "world"

8”. Và đó không thực sự là cách các biến hoạt động, nhưng nó đủ tốt để giúp bạn tiếp tục. Nó giống như trong lớp toán khi họ nói dối bạn về bức tranh đầy đủ, bởi vì bức tranh đầy đủ sẽ khiến bạn nổ tung não ngay bây giờ

Tuy nhiên, một thời gian sau, bạn bắt đầu thấy những vấn đề kỳ lạ. Các biến thay đổi khi bạn không thay đổi chúng. Bóng ma trong máy

“Tôi nghĩ tôi đã tạo một bản sao của nó. Tại sao nó lại thay đổi?”

Đến cuối bài đăng này, bạn sẽ hiểu tại sao điều đó xảy ra và cách khắc phục

Tài liệu tham khảo là gì?

Tài liệu tham khảo ở khắp mọi nơi trong JS, nhưng chúng vô hình. Chúng trông giống như các biến. Một số ngôn ngữ, như C, gọi những thứ này một cách rõ ràng là con trỏ, với cú pháp khởi động riêng của chúng. Nhưng JS không có con trỏ, ít nhất là không có tên đó. Và JS cũng không có bất kỳ cú pháp đặc biệt nào cho chúng

Lấy dòng JavaScript này làm ví dụ. nó tạo ra một biến có tên là

word = "world"

9 lưu trữ chuỗi “xin chào”

let word = "hello"

Lưu ý cách

word = "world"

9 chỉ vào ô có chữ “xin chào”. Có một mức độ gián tiếp ở đây. Biến không phải là hộp. Biến trỏ vào hộp. Hãy để điều đó chìm vào trong khi bạn tiếp tục đọc

Bây giờ, hãy đặt cho biến này một giá trị mới bằng cách sử dụng toán tử gán

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

1

word = "world"

Điều đang thực sự xảy ra ở đây không phải là “xin chào” đang được thay thế bằng “thế giới” - nó giống như một hộp hoàn toàn mới được tạo ra và

word = "world"

9 được chỉ định lại để chỉ vào hộp mới. [và tại một số thời điểm, hộp “xin chào” được dọn sạch bởi bộ thu gom rác vì không có gì đang sử dụng nó]

Nếu bạn đã từng thử gán một giá trị cho một tham số hàm, có lẽ bạn đã nhận ra rằng điều này không thay đổi bất cứ điều gì bên ngoài hàm

Lý do điều này xảy ra là vì việc gán lại tham số hàm sẽ chỉ ảnh hưởng đến biến cục bộ, không ảnh hưởng đến biến ban đầu được truyền vào. Đây là một ví dụ

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

Ban đầu, chỉ có

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

3 trỏ vào giá trị “xin chào”

Tuy nhiên, khi chúng ta ở bên trong hàm, cả

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

3 và

word = "world"

9 đều trỏ vào cùng một hộp

Sau phép gán [

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

6], biến

word = "world"

9 trỏ đến giá trị mới của nó là “thế giới”. Nhưng chúng tôi vẫn chưa thay đổi

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

3. Biến

function reassignFail[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
reassignFail[test]
console.log[test] // prints "hello"

3 vẫn trỏ về giá trị cũ

Đây là cách gán hoạt động trong JavaScript. Gán lại một biến chỉ thay đổi một biến đó. Nó không thay đổi bất kỳ biến nào khác cũng chỉ vào giá trị đó. Điều này đúng cho dù giá trị là một chuỗi, boolean, số, đối tượng, mảng, hàm… mọi kiểu dữ liệu đều hoạt động theo cách này

Hai Loại Loại

JavaScript có hai loại loại lớn và chúng có các quy tắc khác nhau xung quanh phép gán và đẳng thức tham chiếu. Hãy nói về những

Các kiểu nguyên thủy trong JavaScript

Có các kiểu nguyên thủy như chuỗi, số, boolean [và cả ký hiệu, không xác định và null]. Những cái này là bất biến. một. k. a. chỉ đọc, không thể thay đổi

Khi một biến chứa một trong các kiểu nguyên thủy này, bạn không thể tự sửa đổi giá trị đó. Bạn chỉ có thể gán lại biến đó cho một giá trị mới

Sự khác biệt là tinh tế, nhưng quan trọng

Nói cách khác, khi giá trị bên trong một hộp là một chuỗi/số/boolean/ký hiệu/không xác định/null, bạn không thể thay đổi giá trị. Bạn chỉ có thể tạo hộp mới

Nó không hoạt động như thế này…

Đây là lý do tại sao, ví dụ, tất cả các phương thức trên chuỗi trả về một chuỗi mới thay vì sửa đổi chuỗi và nếu bạn muốn giá trị mới đó, bạn phải lưu trữ nó ở đâu đó

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

Mọi loại khác. Đối tượng, Mảng, v.v.

Danh mục khác là loại đối tượng. Điều này bao gồm các đối tượng, mảng, hàm và các cấu trúc dữ liệu khác như Bản đồ và Tập hợp. Chúng đều là những đối tượng

Sự khác biệt lớn so với các kiểu nguyên thủy là các đối tượng có thể thay đổi. Bạn có thể thay đổi giá trị trong hộp

Bất biến là Dự đoán

Nếu bạn chuyển một giá trị nguyên thủy vào một hàm, thì biến ban đầu mà bạn đã truyền vào được đảm bảo để yên. Chức năng không thể sửa đổi những gì bên trong nó. Bạn có thể yên tâm rằng biến sẽ luôn giống nhau sau khi gọi một hàm – bất kỳ hàm nào

Nhưng với các đối tượng và mảng [và các loại đối tượng khác], bạn không có sự đảm bảo đó. Nếu bạn chuyển một đối tượng vào một hàm, thì hàm đó có thể thay đổi đối tượng của bạn. Nếu bạn truyền một mảng, hàm có thể thêm các mục mới vào mảng đó hoặc xóa hoàn toàn mảng đó

Vì vậy, đây là một lý do tại sao nhiều người trong cộng đồng JS cố gắng viết mã theo cách bất biến. sẽ dễ dàng hơn để tìm ra mã làm gì khi bạn chắc chắn rằng các biến của mình sẽ không thay đổi bất ngờ. Nếu mọi chức năng được viết là bất biến theo quy ước, bạn không bao giờ cần phải tự hỏi điều gì sẽ xảy ra

Hàm không thay đổi đối số của nó hoặc bất kỳ thứ gì bên ngoài chính nó được gọi là hàm thuần túy. Nếu nó cần thay đổi điều gì đó trong một trong các đối số của nó, nó sẽ làm điều đó bằng cách trả về một giá trị mới thay thế. Điều này linh hoạt hơn, bởi vì nó có nghĩa là mã gọi sẽ quyết định phải làm gì với giá trị mới đó

Tóm tắt lại. Các biến trỏ đến hộp và nguyên thủy là bất biến

Chúng ta đã nói về cách gán hoặc gán lại một biến hiệu quả “chỉ nó vào một hộp” có chứa một giá trị. Và cách gán một giá trị bằng chữ [trái ngược với một biến] tạo ra một hộp mới và trỏ biến vào đó

let num = 42
let name = "Dave"
let yes = true
let no = false
let person = {
  firstName: "Dave",
  lastName: "Ceddia"
}
let numbers = [4, 8, 12, 37]

Điều này đúng với các kiểu nguyên thủy và đối tượng, và nó đúng cho dù đó là lần gán đầu tiên hay lần gán lại

Chúng ta đã nói về việc các kiểu nguyên thủy là bất biến như thế nào. Bạn không thể thay đổi chúng, bạn chỉ có thể gán lại biến cho thứ khác

Bây giờ hãy xem điều gì sẽ xảy ra khi bạn sửa đổi một thuộc tính trên một đối tượng

Sửa đổi nội dung của hộp

Chúng ta sẽ bắt đầu với một đối tượng

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 đại diện cho một cuốn sách trong thư viện có thể mượn được. Nó có một lá cờ

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

1 và một lá cờ

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

2 và một lá cờ

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

3

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

Đây là đối tượng của chúng tôi và các giá trị của nó dưới dạng hộp

Và sau đó hãy tưởng tượng chúng ta chạy mã này

book.isCheckedOut = true

Đây là những gì nó làm với đối tượng

Lưu ý cách biến

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 không bao giờ thay đổi. Nó tiếp tục chỉ vào cùng một hộp, giữ cùng một đối tượng. Đó chỉ là một trong những thuộc tính của đối tượng đó đã thay đổi

Lưu ý cách điều này cũng tuân theo các quy tắc giống như trước đó. Sự khác biệt duy nhất là các biến hiện đang ở bên trong một đối tượng. Thay vì biến

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

3 cấp cao nhất, chúng tôi truy cập nó dưới dạng biến

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

6, nhưng việc gán lại biến này hoạt động theo cùng một cách

Điều quan trọng cần hiểu là đối tượng không thay đổi. Trên thực tế, ngay cả khi chúng ta tạo một “bản sao” của cuốn sách bằng cách lưu nó vào một biến khác trước khi sửa đổi nó, thì chúng ta vẫn không tạo một đối tượng mới.

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

let backup = book

book.isCheckedOut = true

console.log[backup === book]  // true!
console.log[backup.isCheckedOut]  // also true!!

Dòng

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

7 sẽ trỏ biến

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

8 vào đối tượng sách hiện có. [nó không thực sự là một bản sao. ]

Đây là cách nó sẽ diễn ra

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

9 ở cuối càng chứng minh quan điểm.

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 vẫn bằng với

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

8, vì chúng trỏ vào cùng một đối tượng và vì việc sửa đổi thuộc tính trên

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 không thay đổi lớp vỏ của đối tượng, nó chỉ thay đổi phần bên trong

Các biến luôn trỏ đến các hộp, không bao giờ trỏ đến các biến khác. Khi chúng tôi chỉ định

let num = 42
let name = "Dave"
let yes = true
let no = false
let person = {
  firstName: "Dave",
  lastName: "Ceddia"
}
let numbers = [4, 8, 12, 37]

3, JS ngay lập tức thực hiện công việc tra cứu điều mà

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 chỉ ra và điểm

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

8 cho điều tương tự. Nó không hướng từ

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

8 đến

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0

Cái này đẹp đấy. điều đó có nghĩa là mọi biến số đều độc lập và chúng ta không cần phải giữ một bản đồ dài trong đầu về biến số nào trỏ đến biến số nào. Điều đó sẽ rất khó để theo dõi

Thay đổi một đối tượng trong một chức năng

Wayyy sao lưu trong phần giới thiệu, tôi đã đề cập đến việc thay đổi một biến bên trong một hàm và đôi khi nó “ở bên trong hàm” và đôi khi nó rò rỉ ra mã gọi và hơn thế nữa

Chúng ta đã nói về cách gán lại một biến bên trong một hàm sẽ không bị rò rỉ ra bên ngoài, miễn là đó là biến cấp cao nhất như

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 hoặc

let num = 42
let name = "Dave"
let yes = true
let no = false
let person = {
  firstName: "Dave",
  lastName: "Ceddia"
}
let numbers = [4, 8, 12, 37]

9 và không phải thuộc tính phụ như

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

6 hoặc

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

1

function doesNotLeak[word] {
  // this assignment does not leak out
  word = "world"
}

let test = "hello"
doesNotLeak[test]
console.log[test] // prints "hello"

Và dù sao đi nữa, ví dụ này đã sử dụng một chuỗi, vì vậy chúng tôi không thể sửa đổi nó ngay cả khi chúng tôi đã cố gắng. [vì chuỗi là bất biến, hãy nhớ]

Nhưng nếu chúng ta có một hàm nhận một đối tượng làm đối số thì sao?

function checkoutBook[book] {
  // this change will leak out!
  book.isCheckedOut = true
}

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

checkoutBook[book];

Đây là những gì xảy ra

Nhìn quen không? . Việc

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

2 xảy ra bên trong hay bên ngoài một hàm không quan trọng, bởi vì phép gán đó sẽ sửa đổi phần bên trong của đối tượng

let name = "Dave"
name.toLowerCase[];
console.log[name] // still capital-D "Dave"

name = name.toLowerCase[]
console.log[name] // now it's "dave"

0 theo bất kỳ cách nào

Nếu bạn muốn ngăn điều đó xảy ra, bạn cần tạo một bản sao, sau đó thay đổi bản sao

word = "world"

0

Nếu bạn muốn tìm hiểu thêm về cách viết các hàm bất biến như thế này, hãy đọc hướng dẫn của tôi về tính bất biến. Nó được viết bằng React và Redux nhưng hầu hết các ví dụ đều là JavaScript đơn giản

Tài liệu tham khảo trong thế giới thực

Với kiến ​​thức mới của bạn về tài liệu tham khảo, hãy xem xét một vài ví dụ có thể gây ra vấn đề. Xem nếu bạn có thể phát hiện ra vấn đề trước khi đọc giải pháp

Trình xử lý sự kiện DOM

Thông tin cơ bản nhanh về cách thức hoạt động của các chức năng trình xử lý sự kiện. để thêm một trình lắng nghe sự kiện, hãy gọi

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

4 với tên sự kiện và một chức năng. Để loại bỏ một trình lắng nghe sự kiện, hãy gọi

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

5 có cùng tên sự kiện và cùng chức năng, như trong cùng tham chiếu chức năng. [nếu không, trình duyệt không thể biết chức năng nào cần xóa, vì một sự kiện có thể có nhiều chức năng được đính kèm]

Hãy nhìn vào mã này. Đây có phải là cách sử dụng chức năng thêm/xóa chính xác không?

word = "world"

1

…

…

…

…

Tìm ra?

Mã này sẽ không bao giờ xóa trình xử lý sự kiện, vì hai hàm mũi tên đó không bằng nhau về mặt tham chiếu. Chúng không giống nhau về chức năng, mặc dù chúng giống hệt nhau về cú pháp

Mỗi khi bạn viết một hàm mũi tên

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

6 hoặc một hàm thông thường

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

7, nó sẽ tạo ra một đối tượng mới [hãy nhớ rằng các hàm là đối tượng]

Chứng minh điều đó. Hãy thử điều này trong bảng điều khiển

word = "world"

2

Nó sẽ in

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

8. Mọi đối tượng mới [mảng, hàm, Tập hợp, Bản đồ, v.v. ] sống trong một chiếc hộp hoàn toàn mới, không bằng mọi chiếc hộp khác

Để làm cho ví dụ về trình xử lý sự kiện hoạt động chính xác, trước tiên hãy lưu trữ hàm trong một biến và chuyển cùng biến đó cho cả việc thêm và xóa

word = "world"

3

Đột biến ngoài ý muốn

Hãy nhìn vào một cái khác. Đây là một hàm tìm mục nhỏ nhất trong một mảng bằng cách sắp xếp nó trước và lấy mục đầu tiên

word = "world"

4

Cái này in cái gì?

…

…

…

…

Nếu bạn nói

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

9 và

book.isCheckedOut = true

0, bạn chỉ đúng một nửa;]

Phương thức

book.isCheckedOut = true

1 trên mảng sắp xếp mảng tại chỗ, nghĩa là nó thay đổi thứ tự trên mảng ban đầu mà không cần sao chép nó

Ví dụ này in

let book = {
  title: "Tiny Habits",
  author: "BJ Fogg",
  isCheckedOut: false
}

9 và

book.isCheckedOut = true

3

Bây giờ, đây có thể là những gì bạn muốn. Nhưng có lẽ là không, phải không?

Loại hành vi này có thể đặc biệt gây nhầm lẫn khi hàm nằm trong một tệp khác hoặc trong thư viện, nơi mã không ở ngay trước mặt bạn

Để khắc phục điều này, hãy tạo một bản sao của mảng trước khi sắp xếp nó, như trong mã bên dưới. Ở đây, chúng tôi đang sử dụng toán tử trải rộng để tạo một bản sao của mảng [phần

book.isCheckedOut = true

5]. Điều này thực sự đang tạo ra một mảng hoàn toàn mới và sau đó sao chép mọi phần tử từ mảng cũ

word = "world"

5

Go Forth và tham khảo tốt

Những thứ này xuất hiện mọi lúc, nhưng nó cũng là một trong những thứ mà bạn có thể hiểu nhầm mà không biết nó hoạt động như thế nào

Có thể mất một chút thời gian để bạn hiểu khái niệm về “con trỏ”, các biến trỏ đến các giá trị và giữ cho các tham chiếu thẳng hàng. Nếu bộ não của bạn cảm thấy như đang chìm trong sương mù ngay bây giờ, hãy đánh dấu bài viết này và quay lại sau một tuần

Sau khi bạn có nó, bạn đã có nó và nó sẽ giúp tất cả quá trình phát triển JS của bạn diễn ra suôn sẻ hơn

Bài viết này là bài đầu tiên trong loạt bài về cấu trúc dữ liệu và giải thuật trong JS. Tiếp theo là Danh sách được liên kết trong JavaScript. Bây giờ bạn đã biết cách hoạt động của tham chiếu, danh sách được liên kết sẽ dễ hiểu hơn nhiều

Tôi đang làm bài tiếp theo trong loạt bài này, về cây nhị phân. Bỏ email của bạn vào hộp nếu bạn muốn được thông báo khi hết

JavaScript có tham chiếu hoặc giá trị không?

JavaScript có chuyển qua tham chiếu hoặc sao chép không?

JavaScript có chuyển chuỗi theo tham chiếu không?

Làm cách nào để sử dụng tài liệu tham khảo trong JS?