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
Javascript có 5 kiểu dữ liệu được truyền theo giá trị.
var x = 10;7,
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;8,
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;9,
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;0, và
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;1. Chúng ta sẽ gọi những kiểu nguyên thủy này
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Javascript có 3 kiểu dữ liệu được truyền theo tham chiếu.
var x = 10;2,
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;3 và
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;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ượngnguyên thủy
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 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ố 8var x = 10;5 chứa
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;6.
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;7 chứa
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;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ớ
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
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;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 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'
Cả
var x = 10;50 và
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;5 hiện có chứa
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;6. Cả
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;53 và
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;7 hiện có chứa
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;8. Chúng tách biệt vì bản thân các giá trị đã được sao chép
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
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;Đối tượng
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Đ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;56, chúng tôi đã tạo một mảng trong bộ nhớ. Cái mà biến
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;57 nhận được là địa chỉ, vị trí của mảng đó
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
Hãy giả sử rằng
var x = 10;58 là một kiểu dữ liệu mới được truyền theo giá trị, giống như
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;59 hoặc
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;60. Một
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;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 y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;62 hoặc
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;63], một
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;58 sẽ được biểu thị bằng dấu ngoặc nhọn,
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;65
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;5
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à
1
2
Lưu ý rằng giá trị, địa chỉ, được chứa bởi biến
var x = 10;57 là tĩnh. Mảng trong bộ nhớ là thứ thay đổi. Khi chúng ta sử dụng
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;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 y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
var x = 10;57 trong bộ nhớ và làm việc với thông tin được lưu trữ ở đó
var y = 'abc';var a = x;
var b = y;console.log[x, y, a, b]; // -> 10, 'abc', 10, 'abc'
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;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 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;6
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 ________ 380, thì ________ 381 sẽ thấy những thay đổi đó
var x = 10;8
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;82 vào mảng trong bộ nhớ. Khi chúng tôi sử dụng
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;80 và
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;81, chúng tôi đang trỏ đến cùng một mảng đó
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
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;4
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;5
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;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
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Khi không còn tham chiếu nào đến một đối tượng, như chúng ta thấy đối với địa chỉ
var x = 10;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 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;87 không còn truy cập được nữa và có sẵn cho công cụ để thu gom rác== và ===
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Khi các toán tử đẳng thức,
var x = 10;88 và
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;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 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;40
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;2
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;41
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;4
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;0
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àmKhi 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;9
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;1
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;43 giá trị
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;44. Khi chúng ta chuyển nó vào
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;45, biến
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;5 nhận giá trị đó,
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;44. Giá trị được sao chép như thể chúng ta đã sử dụng phép gán
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;9. Một lần nữa, giá trị của
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;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 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;45
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;51 và
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;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
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
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;2
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;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 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;54. Lưu ý rằng khi nó trả về đối tượng
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;55, nó sẽ trả về chính đối tượng đã được truyền vào.
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;54 và
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;57 chứa cùng một tham chiếu. Việc trả về biến
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;55 và lưu trữ tham chiếu trong một biến mới là không cần thiết
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Hãy xem xét một hàm thuần túy
var x = 10;3
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;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 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;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ớ
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Khi chúng tôi thay đổi thuộc tính
var x = 10;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
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
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;4
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;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 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;5
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;9. Biến
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;55 trong hàm chứa tham chiếu đến đối tượng
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;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 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;55 cho một đối tượng mới, nó sẽ ngừng ảnh hưởng đến đối tượng ban đầu
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Việc gán lại này không thay đổi đối tượng mà
var x = 10;25 trỏ tới trong phạm vi bên ngoài.
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;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 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;25
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;6
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;55 không còn trong phạm vi sau khi chức năng kết thúc
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'
Đó 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 của tôiKhó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 cấp như phạm vi, bao đóng, OOP,
var x = 10;41,
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;42,
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;43/
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;44/
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;45, mã không đồng bộ, thao tác mảng và đối tượng, và ES2015+
var y = 'abc';var a = x;
var b = y;a = 5;
b = 'def';console.log[x, y, a, b]; // -> 10, 'abc', 5, 'def'