Cách trả về một đối tượng từ mảng trong javascript

Bạn có thể chỉ cần sử dụng phương thức

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

77 để tìm đối tượng theo giá trị thuộc tính trong một mảng đối tượng trong JavaScript. Phương thức

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

77 trả về phần tử đầu tiên trong mảng đã cho thỏa mãn chức năng kiểm tra được cung cấp. Nếu không có giá trị nào thỏa mãn chức năng kiểm tra, thì trả về

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

79

Ví dụ sau đây cho thấy cách tìm một đối tượng theo id trong một mảng các đối tượng JavaScript

// Sample array
var myArray = [
    {"id": 1, "name": "Alice"},
    {"id": 2, "name": "Peter"},
    {"id": 3, "name": "Harry"}
];

// Get the Array item which matchs the id "2"
var result = myArray.find[item => item.id === 2];

console.log[result.name];  // Prints: Peter

Ngoài ra, nếu bạn muốn tìm chỉ mục của mục phù hợp trong mảng, bạn có thể sử dụng phương thức

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

80 như trong ví dụ sau

Tôi đã hai lần được hỏi, ‘Hãy cầu nguyện, ông. Babbage, nếu bạn đưa vào máy những con số sai, liệu câu trả lời đúng có xuất hiện không?’ [. ] Tôi không thể hiểu đúng loại ý tưởng lộn xộn có thể gây ra một câu hỏi như vậy

Charles Babbage, Passages from the Life of a Philosopher [1864]

Số, Booleans và chuỗi là các nguyên tử mà cấu trúc dữ liệu được xây dựng từ. Nhiều loại thông tin yêu cầu nhiều hơn một nguyên tử, mặc dù. Các đối tượng cho phép chúng ta nhóm các giá trị—bao gồm cả các đối tượng khác—để xây dựng các cấu trúc phức tạp hơn

Các chương trình chúng tôi đã xây dựng cho đến nay đã bị giới hạn bởi thực tế là chúng chỉ hoạt động trên các loại dữ liệu đơn giản. Chương này sẽ giới thiệu các cấu trúc dữ liệu cơ bản. Khi kết thúc, bạn sẽ biết đủ để bắt đầu viết các chương trình hữu ích

Chương này sẽ làm việc thông qua một ví dụ lập trình ít nhiều thực tế, giới thiệu các khái niệm khi chúng áp dụng cho vấn đề hiện tại. Mã ví dụ thường sẽ được xây dựng dựa trên các chức năng và ràng buộc đã được giới thiệu trước đó trong văn bản

con sóc

Thỉnh thoảng, thường là từ 8 giờ tối. m. và 10p. m. , Jacques thấy mình biến thành một loài gặm nhấm lông nhỏ với cái đuôi rậm rạp

Một mặt, Jacques khá vui vì anh ấy không có lycanthropy cổ điển. Biến thành sóc gây ra ít vấn đề hơn biến thành sói. Thay vì phải lo lắng về việc vô tình ăn thịt con hàng xóm [điều đó sẽ rất khó xử], anh ta lo lắng về việc bị con mèo của hàng xóm ăn thịt. Sau hai lần thức dậy trên một cành cây mỏng bấp bênh trên tán cây sồi, trần truồng và mất phương hướng, anh ấy đã khóa cửa ra vào và cửa sổ phòng mình vào ban đêm và đặt một vài quả óc chó trên sàn để giữ cho mình bận rộn.

Điều đó giải quyết các vấn đề về mèo và cây cối. Nhưng Jacques muốn loại bỏ hoàn toàn tình trạng của mình. Sự xuất hiện bất thường của sự biến đổi khiến anh ta nghi ngờ rằng chúng có thể được kích hoạt bởi thứ gì đó. Trong một thời gian, anh tin rằng điều đó chỉ xảy ra vào những ngày anh ở gần những cây sồi. Nhưng tránh cây sồi không ngăn được vấn đề

Chuyển sang một cách tiếp cận khoa học hơn, Jacques đã bắt đầu ghi nhật ký hàng ngày về mọi thứ anh ấy làm trong một ngày nhất định và liệu anh ấy có thay đổi hình thức hay không. Với dữ liệu này, anh ấy hy vọng sẽ thu hẹp các điều kiện kích hoạt các biến đổi

Điều đầu tiên anh ta cần là một cấu trúc dữ liệu để lưu trữ thông tin này

tập dữ liệu

Để làm việc với một đoạn dữ liệu kỹ thuật số, trước tiên chúng ta phải tìm cách thể hiện nó trong bộ nhớ của máy. Ví dụ: giả sử chúng ta muốn biểu diễn tập hợp các số 2, 3, 5, 7 và 11

Chúng ta có thể sáng tạo với các chuỗi—xét cho cùng, các chuỗi có thể có độ dài bất kỳ, vì vậy chúng ta có thể đưa nhiều dữ liệu vào chúng—và sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

2 làm đại diện của chúng ta. Nhưng điều này thật khó xử. Bạn phải bằng cách nào đó trích xuất các chữ số và chuyển đổi chúng trở lại số để truy cập chúng

May mắn thay, JavaScript cung cấp một kiểu dữ liệu đặc biệt để lưu trữ các chuỗi giá trị. Nó được gọi là một mảng và được viết dưới dạng danh sách các giá trị nằm giữa các dấu ngoặc vuông, được phân tách bằng dấu phẩy

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

Ký hiệu để lấy các phần tử bên trong một mảng cũng sử dụng dấu ngoặc vuông. Một cặp dấu ngoặc vuông ngay sau một biểu thức, với một biểu thức khác bên trong chúng, sẽ tra cứu phần tử trong biểu thức bên trái tương ứng với chỉ số được đưa ra bởi biểu thức trong ngoặc

Chỉ số đầu tiên của một mảng là 0, không phải là một. Vì vậy, phần tử đầu tiên được truy xuất bằng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

3. Việc đếm dựa trên số 0 có một truyền thống lâu đời trong công nghệ và theo một số cách nhất định rất có ý nghĩa, nhưng phải mất một thời gian để làm quen. Hãy coi chỉ mục là số lượng mục cần bỏ qua, tính từ đầu mảng

Tính chất

Chúng ta đã thấy một vài biểu thức trông đáng ngờ như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

4 [để lấy độ dài của chuỗi] và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

5 [hàm tối đa] trong các chương trước. Đây là những biểu thức truy cập một thuộc tính của một số giá trị. Trong trường hợp đầu tiên, chúng tôi truy cập thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6 của giá trị trong

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

7. Trong trường hợp thứ hai, chúng ta truy cập thuộc tính có tên

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

8 trong đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9 [là một tập hợp các hằng số và hàm liên quan đến toán học]

Hầu như tất cả các giá trị JavaScript đều có thuộc tính. Các trường hợp ngoại lệ là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

00 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

01. Nếu bạn cố truy cập một thuộc tính trên một trong những giá trị không phải giá trị này, thì bạn sẽ gặp lỗi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

2

Hai cách chính để truy cập các thuộc tính trong JavaScript là bằng dấu chấm và bằng dấu ngoặc vuông. Cả

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

02 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

03 đều truy cập một thuộc tính trên

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

04—nhưng không nhất thiết phải cùng một thuộc tính. Sự khác biệt là cách

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

05 được giải thích. Khi sử dụng dấu chấm, từ sau dấu chấm là tên theo nghĩa đen của thuộc tính. Khi sử dụng dấu ngoặc vuông, biểu thức giữa các dấu ngoặc được đánh giá để lấy tên thuộc tính. Trong khi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

02 lấy thuộc tính của

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

04 có tên là “x”, thì

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

03 cố gắng đánh giá biểu thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

05 và sử dụng kết quả, được chuyển đổi thành một chuỗi, làm tên thuộc tính

Vì vậy, nếu bạn biết rằng thuộc tính mà bạn quan tâm được gọi là màu sắc, bạn nói

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

10. Nếu bạn muốn trích xuất thuộc tính được đặt tên theo giá trị được giữ trong ràng buộc

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

11, bạn nói

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

12. Tên thuộc tính là chuỗi. Chúng có thể là bất kỳ chuỗi nào, nhưng ký hiệu dấu chấm chỉ hoạt động với các tên trông giống như tên ràng buộc hợp lệ. Vì vậy, nếu bạn muốn truy cập thuộc tính có tên 2 hoặc John Doe, bạn phải sử dụng dấu ngoặc vuông.

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

13 hoặc

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

14

Các phần tử trong một mảng được lưu trữ dưới dạng các thuộc tính của mảng, sử dụng các số làm tên thuộc tính. Bởi vì bạn không thể sử dụng ký hiệu dấu chấm với các số và thường muốn sử dụng một liên kết chứa chỉ mục, bạn phải sử dụng ký hiệu dấu ngoặc để truy cập chúng

Thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6 của một mảng cho chúng ta biết nó có bao nhiêu phần tử. Tên thuộc tính này là một tên ràng buộc hợp lệ và chúng tôi biết trước tên của nó, vì vậy để tìm độ dài của một mảng, bạn thường viết

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

16 vì viết như vậy dễ hơn

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

17

phương pháp

Cả giá trị chuỗi và mảng đều chứa, ngoài thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6, một số thuộc tính chứa giá trị hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

0

Mỗi chuỗi có thuộc tính

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

19. Khi được gọi, nó sẽ trả về một bản sao của chuỗi trong đó tất cả các chữ cái đã được chuyển thành chữ hoa. Ngoài ra còn có

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

20, đi theo con đường khác

Điều thú vị là, mặc dù lời gọi tới _____219 không truyền bất kỳ đối số nào, nhưng bằng cách nào đó, hàm này có quyền truy cập vào chuỗi _____322, giá trị có thuộc tính mà chúng ta đã gọi. Cách thức hoạt động của nó được mô tả trong Chương 6

Các thuộc tính chứa các hàm thường được gọi là các phương thức của giá trị mà chúng thuộc về, như trong “

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

19 là một phương thức của một chuỗi”

Ví dụ này minh họa hai phương pháp bạn có thể sử dụng để thao tác với mảng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6

Phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

24 thêm giá trị vào cuối mảng và phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

25 thực hiện ngược lại, loại bỏ giá trị cuối cùng trong mảng và trả về giá trị đó

Những cái tên hơi ngớ ngẩn này là thuật ngữ truyền thống cho các hoạt động trên ngăn xếp. Ngăn xếp, trong lập trình, là một cấu trúc dữ liệu cho phép bạn đẩy các giá trị vào đó và bật chúng ra một lần nữa theo thứ tự ngược lại để thứ được thêm vào cuối cùng sẽ bị xóa trước. Đây là những điều phổ biến trong lập trình—bạn có thể nhớ ngăn xếp cuộc gọi hàm từ chương trước, đây là một ví dụ về cùng một ý tưởng

Các đối tượng

Trở lại sóc đất. Một tập hợp các mục nhật ký hàng ngày có thể được biểu diễn dưới dạng một mảng. Nhưng các mục nhập không chỉ bao gồm một số hoặc một chuỗi—mỗi mục nhập cần lưu trữ một danh sách các hoạt động và một giá trị Boolean cho biết Jacques có biến thành sóc hay không. Lý tưởng nhất là chúng tôi muốn nhóm các giá trị này lại với nhau thành một giá trị và sau đó đặt các giá trị được nhóm đó vào một mảng các mục nhập nhật ký

Các giá trị của đối tượng kiểu là tập hợp các thuộc tính tùy ý. Một cách để tạo đối tượng là sử dụng dấu ngoặc nhọn làm biểu thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9

Bên trong dấu ngoặc nhọn, có một danh sách các thuộc tính được phân tách bằng dấu phẩy. Mỗi thuộc tính có một tên theo sau bởi một dấu hai chấm và một giá trị. Khi một đối tượng được viết trên nhiều dòng, việc thụt vào nó như trong ví dụ sẽ giúp dễ đọc hơn. Các thuộc tính có tên không phải là tên ràng buộc hợp lệ hoặc số hợp lệ phải được trích dẫn

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

Điều này có nghĩa là dấu ngoặc nhọn có hai nghĩa trong JavaScript. Khi bắt đầu một câu lệnh, họ bắt đầu một khối câu lệnh. Ở bất kỳ vị trí nào khác, họ mô tả một đối tượng. May mắn thay, hiếm khi hữu ích khi bắt đầu một câu lệnh với một đối tượng trong dấu ngoặc nhọn, vì vậy sự mơ hồ giữa hai điều này không phải là vấn đề lớn

Đọc thuộc tính không tồn tại sẽ cung cấp cho bạn giá trị

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

01

Có thể gán giá trị cho biểu thức thuộc tính bằng toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

27. Điều này sẽ thay thế giá trị của thuộc tính nếu nó đã tồn tại hoặc tạo một thuộc tính mới trên đối tượng nếu nó không tồn tại

Quay trở lại mô hình ràng buộc xúc tu của chúng ta một cách ngắn gọn—các ràng buộc thuộc tính cũng tương tự. Chúng nắm bắt các giá trị, nhưng các ràng buộc và thuộc tính khác có thể đang nắm giữ các giá trị đó. Bạn có thể nghĩ về các vật thể như những con bạch tuộc với bất kỳ số lượng xúc tu nào, mỗi xúc tu đều có một cái tên được xăm trên đó

Người vận hành

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

28 cắt một xúc tu từ một con bạch tuộc như vậy. Đó là một toán tử đơn nguyên, khi được áp dụng cho một thuộc tính đối tượng, sẽ xóa thuộc tính được đặt tên khỏi đối tượng. Đây không phải là một điều phổ biến để làm, nhưng nó có thể

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

0

Toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

29 nhị phân, khi được áp dụng cho một chuỗi và một đối tượng, sẽ cho bạn biết liệu đối tượng đó có thuộc tính có tên đó hay không. Sự khác biệt giữa việc đặt thuộc tính thành

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

01 và thực sự xóa nó là, trong trường hợp đầu tiên, đối tượng vẫn có thuộc tính [chỉ là nó không có giá trị rất thú vị], trong khi trong trường hợp thứ hai, thuộc tính không còn nữa

Để biết một đối tượng có những thuộc tính nào, bạn có thể sử dụng hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

83. Bạn cung cấp cho nó một đối tượng và nó trả về một mảng các chuỗi—tên thuộc tính của đối tượng

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

1

Có một hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

84 sao chép tất cả các thuộc tính từ đối tượng này sang đối tượng khác

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

2

Mảng, sau đó, chỉ là một loại đối tượng chuyên dùng để lưu trữ các chuỗi sự vật. Nếu bạn đánh giá ________ 485, nó tạo ra ________ 486. Bạn có thể thấy chúng là những con bạch tuộc dẹt, dài với tất cả các xúc tu xếp thành một hàng ngay ngắn, được đánh số

Chúng tôi sẽ đại diện cho nhật ký mà Jacques lưu giữ dưới dạng một mảng các đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

8

khả năng biến đổi

Chúng ta sẽ sớm bắt đầu lập trình thực tế ngay bây giờ. Đầu tiên, có thêm một phần lý thuyết để hiểu

Chúng tôi đã thấy rằng các giá trị đối tượng có thể được sửa đổi. Các loại giá trị được thảo luận trong các chương trước, chẳng hạn như số, chuỗi và Boolean, đều là bất biến—không thể thay đổi giá trị của các loại đó. Bạn có thể kết hợp chúng và lấy các giá trị mới từ chúng, nhưng khi bạn lấy một giá trị chuỗi cụ thể, giá trị đó sẽ luôn giữ nguyên. Văn bản bên trong không thể thay đổi. Nếu bạn có một chuỗi chứa

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

87, mã khác không thể thay đổi một ký tự trong chuỗi của bạn để biến nó thành chính tả

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

88

Các đối tượng hoạt động khác nhau. Bạn có thể thay đổi các thuộc tính của chúng, khiến một giá trị đối tượng có nội dung khác vào các thời điểm khác nhau

Khi chúng ta có hai số, 120 và 120, chúng ta có thể coi chúng chính xác là cùng một số, cho dù chúng có đề cập đến cùng một bit vật lý hay không. Với các đối tượng, có sự khác biệt giữa việc có hai tham chiếu đến cùng một đối tượng và việc có hai đối tượng khác nhau chứa các thuộc tính giống nhau. Hãy xem xét đoạn mã sau

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

20

Các ràng buộc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

89 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

200 nắm bắt cùng một đối tượng, đó là lý do tại sao thay đổi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

89 cũng thay đổi giá trị của

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

200. Họ được cho là có cùng bản sắc. Liên kết

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

203 trỏ đến một đối tượng khác, ban đầu chứa các thuộc tính giống như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

89 nhưng sống một cuộc sống riêng biệt

Các ràng buộc cũng có thể thay đổi hoặc không đổi, nhưng điều này khác với cách các giá trị của chúng hoạt động. Mặc dù các giá trị số không thay đổi, bạn có thể sử dụng liên kết

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

205 để theo dõi một số đang thay đổi bằng cách thay đổi giá trị của các điểm liên kết tại. Tương tự, mặc dù liên kết

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

206 với một đối tượng không thể tự thay đổi và sẽ tiếp tục trỏ đến cùng một đối tượng, nhưng nội dung của đối tượng đó có thể thay đổi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

21

Khi bạn so sánh các đối tượng với toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

207 của JavaScript, nó sẽ so sánh theo danh tính. nó sẽ chỉ tạo ra

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

208 nếu cả hai đối tượng đều có cùng giá trị. So sánh các đối tượng khác nhau sẽ trả về

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

82, ngay cả khi chúng có thuộc tính giống hệt nhau. Không có thao tác so sánh “sâu” nào được tích hợp trong JavaScript, so sánh các đối tượng theo nội dung, nhưng bạn có thể tự viết thao tác đó [đây là một trong những bài tập ở cuối chương này]

Nhật ký lycanthrope

Vì vậy, Jacques khởi động trình thông dịch JavaScript của mình và thiết lập môi trường mà anh ấy cần để viết nhật ký.

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

22

Lưu ý rằng đối tượng được thêm vào tạp chí trông hơi lạ. Thay vì khai báo các thuộc tính như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

210, nó chỉ đưa ra một tên thuộc tính. Đây là cách viết tắt có nghĩa giống nhau—nếu tên thuộc tính trong ký hiệu dấu ngoặc nhọn không có giá trị theo sau, thì giá trị của thuộc tính đó được lấy từ liên kết có cùng tên

Vì vậy, mỗi tối lúc 10 giờ. m. —hoặc đôi khi vào sáng hôm sau, sau khi leo xuống từ ngăn trên cùng của tủ sách—Jacques ghi lại ngày hôm đó

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

23

Sau khi có đủ điểm dữ liệu, anh ấy dự định sử dụng số liệu thống kê để tìm ra sự kiện nào trong số những sự kiện này có thể liên quan đến quá trình sóc hóa

Tương quan là thước đo sự phụ thuộc giữa các biến thống kê. Một biến thống kê không hoàn toàn giống như một biến lập trình. Trong thống kê, bạn thường có một tập hợp các phép đo và mỗi biến được đo cho mọi phép đo. Mối tương quan giữa các biến thường được thể hiện dưới dạng giá trị nằm trong khoảng từ -1 đến 1. Tương quan bằng không có nghĩa là các biến không liên quan. Mối tương quan của một chỉ ra rằng hai cái có liên quan hoàn hảo với nhau—nếu bạn biết cái này thì bạn cũng biết cái kia. Một phủ định cũng có nghĩa là các biến có liên quan hoàn hảo nhưng chúng đối lập nhau khi một biến đúng, biến kia sai

Để tính độ đo tương quan giữa hai biến Boolean, chúng ta có thể sử dụng hệ số phi [ϕ]. Đây là một công thức có đầu vào là một bảng tần số chứa số lần các tổ hợp biến khác nhau được quan sát. Đầu ra của công thức là một số từ -1 đến 1 mô tả mối tương quan

Chúng ta có thể lấy sự kiện ăn bánh pizza và đặt nó vào một bảng tần suất như thế này, trong đó mỗi con số biểu thị số lần sự kết hợp đó xảy ra trong các phép đo của chúng ta

Nếu chúng ta gọi bảng đó là n, chúng ta có thể tính ϕ bằng công thức sau

ϕ =

n11n00−n10n01

√ n1•n0•n•1n•0

[Nếu tại thời điểm này, bạn đang đặt cuốn sách xuống để tập trung vào một đoạn hồi tưởng khủng khiếp về lớp toán lớp 10—hãy chờ đã. Tôi không có ý định tra tấn bạn bằng vô số trang ký hiệu khó hiểu—hiện tại chỉ có một công thức này. Và ngay cả với cái này, tất cả những gì chúng tôi làm là biến nó thành JavaScript. ]

Ký hiệu n01 cho biết số phép đo trong đó biến đầu tiên [độ sóc] là sai [0] và biến thứ hai [pizza] là đúng [1]. Trong bảng pizza, n01 là 9

Giá trị n1• đề cập đến tổng của tất cả các phép đo trong đó biến đầu tiên là đúng, là 5 trong bảng ví dụ. Tương tự như vậy, n•0 đề cập đến tổng của các phép đo trong đó biến thứ hai là sai

Vì vậy, đối với bảng pizza, phần phía trên đường chia [số bị chia] sẽ là 1×76−4×9 = 40 và phần phía dưới nó [số chia] sẽ là căn bậc hai của 5×85×10×80 . Điều này dẫn đến ϕ ≈ 0. 069, nhỏ xíu. Ăn pizza dường như không có ảnh hưởng đến sự biến đổi

tính toán tương quan

Chúng ta có thể biểu diễn một bảng hai nhân hai trong JavaScript bằng một mảng bốn phần tử [

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

211]. Chúng ta cũng có thể sử dụng các cách biểu diễn khác, chẳng hạn như một mảng chứa hai mảng hai phần tử [

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

212] hoặc một đối tượng có các tên thuộc tính như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

213 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

214, nhưng mảng phẳng đơn giản và làm cho các biểu thức truy cập bảng trở nên ngắn gọn dễ chịu. Chúng tôi sẽ giải thích các chỉ số cho mảng dưới dạng số nhị phân hai bit, trong đó chữ số ngoài cùng bên trái [quan trọng nhất] đề cập đến biến con sóc và chữ số ngoài cùng bên phải [ít quan trọng nhất] đề cập đến biến sự kiện. Ví dụ: số nhị phân

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

215 đề cập đến trường hợp Jacques đã biến thành một con sóc, nhưng sự kiện [ví dụ: “pizza”] đã không xảy ra. Điều này đã xảy ra bốn lần. Và vì mã nhị phân

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

215 là 2 trong ký hiệu thập phân, chúng tôi sẽ lưu trữ số này ở chỉ mục 2 của mảng

Đây là hàm tính hệ số ϕ từ một mảng như vậy

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

24

Đây là bản dịch trực tiếp của công thức ϕ sang JavaScript.

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

217 là hàm căn bậc hai, được cung cấp bởi đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9 trong môi trường JavaScript tiêu chuẩn. Chúng ta phải thêm hai trường từ bảng để có được các trường như n1• vì tổng của các hàng hoặc cột không được lưu trữ trực tiếp trong cấu trúc dữ liệu của chúng ta

Jacques giữ nhật ký của mình trong ba tháng. Tập dữ liệu kết quả có sẵn trong hộp cát mã hóa cho chương này, nơi dữ liệu được lưu trữ trong liên kết

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

219 và trong một tệp có thể tải xuống

Để trích xuất bảng hai nhân hai cho một sự kiện cụ thể từ nhật ký, chúng ta phải lặp lại tất cả các mục nhập và kiểm đếm số lần sự kiện xảy ra liên quan đến các phép biến đổi sóc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

25

Mảng có một phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

220 để kiểm tra xem một giá trị đã cho có tồn tại trong mảng hay không. Hàm sử dụng điều đó để xác định xem tên sự kiện mà nó quan tâm có phải là một phần của danh sách sự kiện cho một ngày nhất định hay không

Phần thân của vòng lặp trong

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

221 chỉ ra ô nào trong bảng mà mỗi mục nhật ký rơi vào bằng cách kiểm tra xem mục nhập đó có chứa sự kiện cụ thể mà nó quan tâm hay không và liệu sự kiện đó có xảy ra cùng với sự cố sóc hay không. Vòng lặp sau đó thêm một vào ô đúng trong bảng

Bây giờ chúng ta có các công cụ cần thiết để tính toán các mối tương quan riêng lẻ. Bước duy nhất còn lại là tìm mối tương quan cho mọi loại sự kiện đã được ghi lại và xem liệu có điều gì nổi bật không

vòng lặp mảng

Trong hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

221 có một vòng lặp như thế này

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

26

Loại vòng lặp này phổ biến trong JavaScript cổ điển—đi qua từng phần tử của mảng là một thứ xuất hiện rất nhiều và để làm được điều đó, bạn sẽ chạy một bộ đếm theo chiều dài của mảng và lần lượt chọn ra từng phần tử

Có một cách đơn giản hơn để viết các vòng lặp như vậy trong JavaScript hiện đại

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

27

Khi một vòng lặp

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

223 trông như thế này, với từ

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

224 sau một định nghĩa biến, nó sẽ lặp qua các phần tử của giá trị đã cho sau

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

224. Điều này không chỉ hoạt động đối với mảng mà còn đối với chuỗi và một số cấu trúc dữ liệu khác. Chúng ta sẽ thảo luận về cách nó hoạt động trong Chương 6

phân tích cuối cùng

Chúng ta cần tính toán mối tương quan cho mọi loại sự kiện xảy ra trong tập dữ liệu. Để làm điều đó, trước tiên chúng ta cần tìm mọi loại sự kiện

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

28

Bằng cách xem qua tất cả các sự kiện và thêm những sự kiện chưa có vào mảng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

226, hàm sẽ thu thập mọi loại sự kiện

Sử dụng điều đó, chúng ta có thể thấy tất cả các mối tương quan

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

29

Hầu hết các mối tương quan dường như nằm gần bằng không. Ăn cà rốt, bánh mì hoặc bánh pudding dường như không kích hoạt sóc lycanthropy. Nó dường như xảy ra thường xuyên hơn vào cuối tuần. Hãy lọc kết quả để chỉ hiển thị các mối tương quan lớn hơn 0. 1 hoặc nhỏ hơn -0. 1

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

00

à há. Có hai yếu tố có mối tương quan rõ ràng mạnh hơn các yếu tố khác. Ăn đậu phộng có tác động tích cực mạnh mẽ đến cơ hội biến thành sóc, trong khi đánh răng có tác động tiêu cực đáng kể

Hấp dẫn. Hãy thử một cái gì đó

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

01

Đó là một kết quả mạnh mẽ. Hiện tượng xảy ra chính xác khi Jacques ăn đậu phộng và không đánh răng. Giá như anh ấy không phải là một người lười biếng trong việc vệ sinh răng miệng, anh ấy thậm chí sẽ không bao giờ nhận ra căn bệnh của mình

Biết được điều này, Jacques ngừng ăn đậu phộng hoàn toàn và thấy rằng sự biến đổi của anh ấy không quay trở lại

Trong một vài năm, mọi thứ trở nên tuyệt vời đối với Jacques. Nhưng đến một lúc nào đó anh ta mất việc. Bởi vì anh ấy sống ở một đất nước tồi tệ, nơi không có việc làm đồng nghĩa với không có dịch vụ y tế, anh ấy buộc phải làm việc cho một rạp xiếc nơi anh ấy biểu diễn với vai The Incredible Squirrelman, nhét bơ đậu phộng vào miệng trước mỗi buổi biểu diễn.

Một ngày nọ, chán ngấy với sự tồn tại đáng thương này, Jacques không thể biến trở lại hình dạng con người của mình, nhảy qua một vết nứt trong lều xiếc và biến mất trong rừng. Anh ấy không bao giờ được nhìn thấy nữa

Mảng hơn nữa

Trước khi kết thúc chương này, tôi muốn giới thiệu với bạn một vài khái niệm liên quan đến đối tượng. Tôi sẽ bắt đầu bằng cách giới thiệu một số phương thức mảng thường hữu ích

Chúng ta đã thấy

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

24 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

25, thêm và xóa các phần tử ở cuối một mảng, ở đầu chương này. Các phương thức tương ứng để thêm và xóa mọi thứ ở đầu mảng được gọi là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

229 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

230

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

02

Chương trình đó quản lý một hàng các nhiệm vụ. Bạn thêm nhiệm vụ vào cuối hàng đợi bằng cách gọi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

231 và khi bạn sẵn sàng làm điều gì đó, bạn gọi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

232 để lấy [và xóa] mục phía trước khỏi hàng đợi. Hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

233 cũng thêm một tác vụ nhưng thêm nó vào phía trước thay vì phía sau hàng đợi

Để tìm kiếm một giá trị cụ thể, mảng cung cấp phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

234. Phương thức tìm kiếm thông qua mảng từ đầu đến cuối và trả về chỉ mục tại đó giá trị được yêu cầu được tìm thấy—hoặc -1 nếu không tìm thấy. Để tìm kiếm từ cuối thay vì bắt đầu, có một phương pháp tương tự gọi là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

235

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

03

Cả

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

234 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

235 đều có đối số thứ hai tùy chọn cho biết nơi bắt đầu tìm kiếm

Một phương thức mảng cơ bản khác là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

238, lấy các chỉ số bắt đầu và kết thúc và trả về một mảng chỉ có các phần tử ở giữa chúng. Chỉ mục bắt đầu bao gồm, chỉ mục kết thúc loại trừ

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

04

Khi chỉ mục kết thúc không được cung cấp,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

238 sẽ lấy tất cả các phần tử sau chỉ mục bắt đầu. Bạn cũng có thể bỏ qua chỉ mục bắt đầu để sao chép toàn bộ mảng

Phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

240 có thể được sử dụng để dán các mảng lại với nhau để tạo một mảng mới, tương tự như những gì toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

241 thực hiện đối với các chuỗi

Ví dụ sau đây cho thấy cả

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

240 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

238 đang hoạt động. Nó nhận một mảng và một chỉ mục, và nó trả về một mảng mới là bản sao của mảng ban đầu với phần tử tại chỉ mục đã cho đã bị xóa

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

05

Nếu bạn chuyển ____1240 một đối số không phải là một mảng, thì giá trị đó sẽ được thêm vào mảng mới như thể nó là một mảng một phần tử

Chuỗi và thuộc tính của chúng

Chúng ta có thể đọc các thuộc tính như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6 và

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

19 từ các giá trị chuỗi. Nhưng nếu bạn cố gắng thêm một thuộc tính mới, nó sẽ không dính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

06

Các giá trị của kiểu chuỗi, số và Boolean không phải là các đối tượng và mặc dù ngôn ngữ không phàn nàn nếu bạn cố đặt các thuộc tính mới trên chúng, nhưng nó không thực sự lưu trữ các thuộc tính đó. Như đã đề cập trước đó, các giá trị như vậy là bất biến và không thể thay đổi

Nhưng những loại này có các thuộc tính tích hợp. Mỗi giá trị chuỗi có một số phương thức. Một số cái rất hữu ích là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

238 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

234, giống với các phương thức mảng cùng tên

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

07

Một điểm khác biệt là một chuỗi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

234 có thể tìm kiếm một chuỗi chứa nhiều hơn một ký tự, trong khi phương thức mảng tương ứng chỉ tìm kiếm một phần tử duy nhất

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

08

Phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

250 xóa khoảng trắng [dấu cách, dòng mới, tab và các ký tự tương tự] khỏi đầu và cuối chuỗi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

09

Hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

251 từ chương trước cũng tồn tại như một phương thức. Nó được gọi là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

252 và lấy ký tự đệm và độ dài mong muốn làm đối số

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

60

Bạn có thể tách một chuỗi trên mỗi lần xuất hiện của một chuỗi khác với

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

253 và nối lại chuỗi đó với

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

254

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

61

Một chuỗi có thể được lặp lại bằng phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

255, phương thức này tạo ra một chuỗi mới chứa nhiều bản sao của chuỗi ban đầu, được dán lại với nhau

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

62

Chúng ta đã thấy thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6 của kiểu chuỗi. Truy cập các ký tự riêng lẻ trong một chuỗi giống như truy cập các phần tử của mảng [với một lưu ý mà chúng ta sẽ thảo luận trong Chương 5]

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

63

Thông số nghỉ ngơi

Nó có thể hữu ích cho một hàm chấp nhận bất kỳ số lượng đối số nào. Ví dụ:

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

5 tính toán tối đa tất cả các đối số mà nó đưa ra

Để viết một hàm như vậy, bạn đặt ba dấu chấm trước tham số cuối cùng của hàm, như thế này

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

64

Khi một hàm như vậy được gọi, tham số còn lại được liên kết với một mảng chứa tất cả các đối số khác. Nếu có các tham số khác trước nó, giá trị của chúng không phải là một phần của mảng đó. Khi, như trong

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

8, nó là tham số duy nhất, nó sẽ giữ tất cả các đối số

Bạn có thể sử dụng ký hiệu dấu ba chấm tương tự để gọi một hàm với một mảng đối số

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

65

Điều này "trải rộng" ra mảng vào lệnh gọi hàm, chuyển các phần tử của nó dưới dạng các đối số riêng biệt. Có thể bao gồm một mảng như vậy cùng với các đối số khác, như trong

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

259

Ký hiệu mảng dấu ngoặc vuông tương tự cho phép toán tử dấu ba chấm trải một mảng khác sang mảng mới

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

66

đối tượng Toán học

Như chúng ta đã thấy,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9 là một tập hợp các hàm tiện ích liên quan đến số, chẳng hạn như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

5 [tối đa],

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

262 [tối thiểu] và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

217 [căn bậc hai]

Đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9 được sử dụng như một thùng chứa để nhóm một loạt các chức năng liên quan. Chỉ có một đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9 và nó hầu như không bao giờ hữu ích như một giá trị. Thay vào đó, nó cung cấp một không gian tên để tất cả các chức năng và giá trị này không phải là các ràng buộc toàn cầu

Có quá nhiều ràng buộc toàn cục “làm ô nhiễm” không gian tên. Càng nhiều tên được sử dụng, bạn càng có nhiều khả năng vô tình ghi đè lên giá trị của một số ràng buộc hiện có. Ví dụ: bạn không muốn đặt tên thứ gì đó là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

8 trong một trong các chương trình của mình. Vì hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

8 tích hợp sẵn của JavaScript được giấu an toàn bên trong đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9, nên chúng ta không phải lo lắng về việc ghi đè lên nó

Nhiều ngôn ngữ sẽ ngăn bạn hoặc ít nhất là cảnh báo bạn khi bạn đang xác định một liên kết có tên đã được sử dụng. JavaScript thực hiện điều này đối với các ràng buộc mà bạn đã khai báo bằng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

205 hoặc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

206 nhưng—ngược lại—không phải đối với các ràng buộc tiêu chuẩn cũng như các ràng buộc được khai báo bằng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

271 hoặc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

272

Quay lại đối tượng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9. Nếu bạn cần làm lượng giác,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

9 có thể giúp. Nó chứa

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

275 [cosine],

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

276 [sin] và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

277 [tiếp tuyến], cũng như các hàm nghịch đảo của chúng, lần lượt là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

278,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

279 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

280. Số π [pi]—hoặc ít nhất là giá trị gần đúng nhất phù hợp với một số JavaScript—có sẵn dưới dạng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

281. Có một truyền thống lập trình cũ là viết hoa tất cả các tên của các giá trị không đổi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

67

Nếu sin và cosin không phải là thứ bạn quen thuộc, đừng lo lắng. Khi chúng được sử dụng trong cuốn sách này, trong Chương 14, tôi sẽ giải thích chúng

Ví dụ trước đã sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

282. Đây là một hàm trả về một số giả ngẫu nhiên mới giữa 0 [bao gồm] và một [độc quyền] mỗi khi bạn gọi nó

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

68

Mặc dù máy tính là cỗ máy xác định—chúng luôn phản ứng theo cùng một cách nếu được cung cấp cùng một đầu vào—chúng có thể tạo ra các số xuất hiện ngẫu nhiên. Để làm điều đó, máy sẽ giữ một số giá trị ẩn và bất cứ khi nào bạn yêu cầu một số ngẫu nhiên mới, nó sẽ thực hiện các phép tính phức tạp trên giá trị ẩn này để tạo ra một giá trị mới. Nó lưu trữ một giá trị mới và trả về một số số bắt nguồn từ nó. Bằng cách đó, nó có thể tạo ra những con số mới, khó dự đoán theo cách có vẻ như ngẫu nhiên

Nếu chúng ta muốn một số nguyên ngẫu nhiên thay vì một số phân số, chúng ta có thể sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

283 [làm tròn xuống số nguyên gần nhất] trên kết quả của

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

282

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

69

Nhân số ngẫu nhiên với 10 sẽ cho ta một số lớn hơn hoặc bằng 0 và nhỏ hơn 10. Vì

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

283 làm tròn xuống, biểu thức này sẽ tạo ra, với cơ hội như nhau, bất kỳ số nào từ 0 đến 9

Ngoài ra còn có các hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

286 [đối với “trần”, làm tròn lên đến một số nguyên],

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

287 [đến số nguyên gần nhất] và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

288, lấy giá trị tuyệt đối của một số, nghĩa là nó phủ định các giá trị âm nhưng để lại giá trị dương

hủy diệt

Hãy quay lại hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

289 trong giây lát

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

90

Một trong những lý do khiến hàm này khó đọc là chúng ta có một liên kết trỏ vào mảng của mình, nhưng chúng tôi muốn có các liên kết cho các phần tử của mảng hơn, nghĩa là,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

290, v.v. May mắn thay, có một cách ngắn gọn để làm điều này trong JavaScript

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

91

Điều này cũng hoạt động đối với các ràng buộc được tạo bằng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

205,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

271 hoặc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

206. Nếu bạn biết giá trị mà bạn đang ràng buộc là một mảng, bạn có thể sử dụng dấu ngoặc vuông để “nhìn vào bên trong” giá trị, ràng buộc nội dung của nó

Một thủ thuật tương tự hoạt động với các đối tượng, sử dụng dấu ngoặc nhọn thay vì dấu ngoặc vuông

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

92

Lưu ý rằng nếu bạn cố gắng hủy cấu trúc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

00 hoặc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

01, bạn sẽ gặp lỗi, tương tự như khi bạn cố gắng truy cập trực tiếp vào thuộc tính của các giá trị đó

JSON

Bởi vì các thuộc tính chỉ nắm bắt giá trị của chúng, thay vì chứa nó, các đối tượng và mảng được lưu trữ trong bộ nhớ của máy tính dưới dạng các chuỗi bit chứa địa chỉ—vị trí trong bộ nhớ—của nội dung của chúng. Vì vậy, một mảng với một mảng khác bên trong nó bao gồm [ít nhất] một vùng bộ nhớ cho mảng bên trong và một vùng khác cho mảng bên ngoài, chứa [trong số những thứ khác] một số nhị phân biểu thị vị trí của mảng bên trong

Nếu bạn muốn lưu dữ liệu trong một tệp để sử dụng sau này hoặc gửi dữ liệu đó đến một máy tính khác qua mạng, bạn phải bằng cách nào đó chuyển đổi các địa chỉ bộ nhớ lộn xộn này thành một mô tả có thể được lưu trữ hoặc gửi đi. Tôi cho rằng bạn có thể gửi toàn bộ bộ nhớ máy tính của mình cùng với địa chỉ của giá trị mà bạn quan tâm, nhưng đó có vẻ không phải là cách tiếp cận tốt nhất

Những gì chúng ta có thể làm là tuần tự hóa dữ liệu. Điều đó có nghĩa là nó được chuyển đổi thành một mô tả phẳng. Một định dạng tuần tự hóa phổ biến được gọi là JSON [phát âm là “Jason”], viết tắt của JavaScript Object Notation. Nó được sử dụng rộng rãi như một định dạng lưu trữ và giao tiếp dữ liệu trên Web, ngay cả trong các ngôn ngữ khác ngoài JavaScript

JSON trông tương tự như cách viết mảng và đối tượng của JavaScript, với một số hạn chế. Tất cả các tên thuộc tính phải được bao quanh bởi dấu ngoặc kép và chỉ các biểu thức dữ liệu đơn giản mới được phép—không gọi hàm, liên kết hoặc bất kỳ thứ gì liên quan đến tính toán thực tế. Nhận xét không được phép trong JSON

Một mục nhật ký có thể trông như thế này khi được biểu diễn dưới dạng dữ liệu JSON

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

93

JavaScript cung cấp cho chúng ta các hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

296 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

297 để chuyển đổi dữ liệu sang và từ định dạng này. Cái đầu tiên lấy một giá trị JavaScript và trả về một chuỗi được mã hóa JSON. Cái thứ hai lấy một chuỗi như vậy và chuyển đổi nó thành giá trị mà nó mã hóa

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

94

Tóm lược

Các đối tượng và mảng [là một loại đối tượng cụ thể] cung cấp các cách để nhóm một số giá trị thành một giá trị duy nhất. Về mặt khái niệm, điều này cho phép chúng ta bỏ nhiều thứ có liên quan vào một chiếc túi và chạy xung quanh với chiếc túi, thay vì vòng tay ôm lấy tất cả những thứ riêng lẻ và cố gắng giữ chúng riêng lẻ

Hầu hết các giá trị trong JavaScript đều có thuộc tính, ngoại lệ là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

00 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

01. Các thuộc tính được truy cập bằng cách sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

000 hoặc

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

001. Các đối tượng có xu hướng sử dụng tên cho các thuộc tính của chúng và lưu trữ ít nhiều một bộ cố định của chúng. Mặt khác, các mảng thường chứa các lượng giá trị giống hệt nhau về mặt khái niệm và sử dụng các số [bắt đầu từ 0] làm tên của các thuộc tính của chúng

Có một số thuộc tính được đặt tên trong mảng, chẳng hạn như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

6 và một số phương thức. Phương thức là các hàm sống trong các thuộc tính và [thường] hành động dựa trên giá trị mà chúng là thuộc tính của

Bạn có thể lặp qua các mảng bằng cách sử dụng một loại vòng lặp đặc biệt

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

223—

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

004

bài tập

tổng của một phạm vi

Phần giới thiệu của cuốn sách này đề cập đến những điều sau đây như một cách hay để tính tổng của một dãy số

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

95

Viết một hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

005 nhận hai đối số,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

006 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

007, rồi trả về một mảng chứa tất cả các số từ

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

006 đến [và bao gồm]

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

007

Tiếp theo, hãy viết hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

010 nhận vào một mảng số và trả về tổng của những số này. Chạy chương trình ví dụ và xem nó có thực sự trả về 55 không

Là một nhiệm vụ bổ sung, hãy sửa đổi hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

005 của bạn để nhận một đối số thứ ba tùy chọn cho biết giá trị "bước" được sử dụng khi xây dựng mảng. Nếu không có bước nào được đưa ra, các phần tử sẽ tăng lên từng bước một, tương ứng với hành vi cũ. Hàm gọi

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

012 sẽ trả về

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

013. Đảm bảo rằng nó cũng hoạt động với các giá trị bước âm để

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

014 tạo ra

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

015

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

96

Việc xây dựng một mảng được thực hiện dễ dàng nhất bằng cách trước tiên khởi tạo một liên kết tới

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

016 [một mảng mới, trống] và liên tục gọi phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

24 của nó để thêm một giá trị. Đừng quên trả về mảng ở cuối hàm

Vì đã bao gồm ranh giới kết thúc, nên bạn sẽ cần sử dụng toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

018 thay vì

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

019 để kiểm tra kết thúc vòng lặp của mình

Tham số bước có thể là một tham số tùy chọn mặc định [sử dụng toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

27] thành 1

Để

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

005 hiểu các giá trị bước âm có lẽ được thực hiện tốt nhất bằng cách viết hai vòng lặp riêng biệt—một để đếm lên và một để đếm xuống—vì so sánh để kiểm tra xem vòng lặp có kết thúc hay không cần phải là

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

022 thay vì

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

018 khi đếm xuống

Cũng có thể đáng để sử dụng một bước mặc định khác, cụ thể là -1, khi phần cuối của phạm vi nhỏ hơn phần đầu. Bằng cách đó,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

024 trả về một cái gì đó có ý nghĩa, thay vì bị mắc kẹt trong một vòng lặp vô tận. Có thể tham khảo các tham số trước đó trong giá trị mặc định của tham số

Đảo ngược một mảng

Mảng có phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

025 thay đổi mảng bằng cách đảo ngược thứ tự xuất hiện các phần tử của mảng. Đối với bài tập này, hãy viết hai hàm,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

026 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

027. Đầu tiên,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

026, lấy một mảng làm đối số và tạo một mảng mới có cùng các phần tử theo thứ tự nghịch đảo. Phương thức thứ hai,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

027, thực hiện những gì mà phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

025 thực hiện. nó sửa đổi mảng được cho làm đối số bằng cách đảo ngược các phần tử của nó. Không thể sử dụng phương pháp

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

025 tiêu chuẩn

Nghĩ lại những lưu ý về tác dụng phụ và chức năng thuần túy trong chương trước, biến thể nào bạn mong đợi sẽ hữu ích trong nhiều tình huống hơn?

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

97

Có hai cách rõ ràng để triển khai

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

026. Đầu tiên là chỉ cần đi qua mảng đầu vào từ trước ra sau và sử dụng phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

229 trên mảng mới để chèn từng phần tử vào đầu của nó. Cách thứ hai là lặp ngược mảng đầu vào và sử dụng phương thức

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

24. Lặp lại một mảng ngược yêu cầu một đặc điểm kỹ thuật [hơi khó xử]

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

223, như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

036

Đảo ngược mảng tại chỗ khó hơn. Bạn phải cẩn thận để không ghi đè lên các phần tử mà sau này bạn sẽ cần. Sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

026 hoặc sao chép toàn bộ mảng [

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

038 là một cách hay để sao chép một mảng] hoạt động nhưng gian lận

Thủ thuật là hoán đổi phần tử đầu tiên và phần tử cuối cùng, sau đó là phần tử thứ hai và phần tử thứ hai với phần tử cuối cùng, v.v. Bạn có thể làm điều này bằng cách lặp trên một nửa chiều dài của mảng [sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

283 để làm tròn xuống—bạn không cần chạm vào phần tử ở giữa trong một mảng có số phần tử lẻ] và hoán đổi phần tử ở vị trí

let listOfNumbers = [2, 3, 5, 7, 11];
console.log[listOfNumbers[2]];
// → 5
console.log[listOfNumbers[0]];
// → 2
console.log[listOfNumbers[2 - 1]];
// → 3

11 với phần tử ở vị trí thứ nhất. . Bạn có thể sử dụng liên kết cục bộ để giữ nhanh một trong các phần tử, ghi đè lên phần tử đó bằng hình ảnh phản chiếu của nó, sau đó đặt giá trị từ liên kết cục bộ vào vị trí mà hình ảnh phản chiếu từng là

Một danh sách

Các đối tượng, như các đốm giá trị chung, có thể được sử dụng để xây dựng tất cả các loại cấu trúc dữ liệu. Một cấu trúc dữ liệu phổ biến là danh sách [đừng nhầm với mảng]. Danh sách là một tập hợp các đối tượng lồng nhau, với đối tượng đầu tiên giữ tham chiếu đến đối tượng thứ hai, đối tượng thứ hai đến đối tượng thứ ba, v.v.

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

98

Các đối tượng kết quả tạo thành một chuỗi, như thế này

Một điều thú vị về danh sách là chúng có thể chia sẻ các phần trong cấu trúc của chúng. Ví dụ: nếu tôi tạo hai giá trị mới

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

042 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

043 [với

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

044 đề cập đến ràng buộc được xác định trước đó], cả hai đều là danh sách độc lập nhưng chúng có chung cấu trúc tạo nên ba phần tử cuối cùng của chúng. Danh sách ban đầu vẫn là danh sách ba phần tử hợp lệ

Viết hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

045 xây dựng cấu trúc danh sách giống như cấu trúc được hiển thị khi cho đối số _____3046. Đồng thời viết một hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

047 để tạo một mảng từ một danh sách. Sau đó, thêm một hàm trợ giúp

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

048, hàm này nhận một phần tử và một danh sách rồi tạo một danh sách mới thêm phần tử vào phía trước danh sách đầu vào và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

049, hàm này nhận một danh sách và một số rồi trả về phần tử ở vị trí đã cho trong

Nếu bạn chưa viết, hãy viết một phiên bản đệ quy của

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

049

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

99

Xây dựng danh sách dễ dàng hơn khi thực hiện từ trước ra sau. Vì vậy,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

045 có thể lặp lại mảng ngược [xem bài tập trước] và, đối với mỗi phần tử, thêm một đối tượng vào danh sách. Bạn có thể sử dụng liên kết cục bộ để giữ phần danh sách đã được tạo cho đến nay và sử dụng phép gán như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

053 để thêm phần tử

Để chạy qua một danh sách [trong

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

047 và

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

049], có thể sử dụng đặc tả vòng lặp

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

223 như thế này

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

0

Bạn có thể thấy nó hoạt động như thế nào không? . Khi kết thúc một lần lặp,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

057 chuyển sang danh sách con tiếp theo. Khi đó là null, chúng tôi đã đến cuối danh sách và vòng lặp kết thúc

Tương tự, phiên bản đệ quy của

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

049 sẽ xem xét một phần nhỏ hơn bao giờ hết của “đuôi” của danh sách và đồng thời đếm ngược chỉ mục cho đến khi nó bằng 0, tại thời điểm đó, nó có thể trả về thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

04 của nút đó. . Để lấy phần tử thứ 0 của danh sách, bạn chỉ cần lấy thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

04 của nút đầu của nó. Để lấy phần tử N + 1, bạn lấy phần tử thứ N của danh sách nằm trong thuộc tính

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

063 của danh sách này

So sánh sâu sắc

Toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

207 so sánh các đối tượng theo danh tính. Nhưng đôi khi bạn muốn so sánh các giá trị thuộc tính thực tế của chúng

Viết một hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

065 nhận hai giá trị và chỉ trả về true nếu chúng có cùng giá trị hoặc là các đối tượng có cùng thuộc tính, trong đó giá trị của các thuộc tính bằng nhau khi so sánh với lệnh gọi đệ quy tới

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

065

Để tìm hiểu xem các giá trị có nên được so sánh trực tiếp hay không [sử dụng toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

067 cho điều đó] hoặc so sánh các thuộc tính của chúng, bạn có thể sử dụng toán tử

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

068. Nếu nó tạo ra

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

86 cho cả hai giá trị, bạn nên so sánh sâu. Nhưng bạn phải tính đến một ngoại lệ ngớ ngẩn. vì một tai nạn lịch sử,

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

070 cũng tạo ra

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

86

Hàm

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

83 sẽ hữu ích khi bạn cần xem qua các thuộc tính của các đối tượng để so sánh chúng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

1

Bài kiểm tra xem bạn có đang xử lý một đối tượng thực hay không sẽ trông giống như

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

073. Hãy cẩn thận chỉ so sánh các thuộc tính khi cả hai đối số đều là đối tượng. Trong tất cả các trường hợp khác, bạn có thể ngay lập tức trả lại kết quả của việc áp dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

067

Sử dụng

let descriptions = {
  work: "Went to work",
  "touched tree": "Touched a tree"
};

83 để xem qua các thuộc tính. Bạn cần kiểm tra xem cả hai đối tượng có cùng một bộ tên thuộc tính hay không và liệu các thuộc tính đó có giá trị giống nhau không. Một cách để làm điều đó là đảm bảo rằng cả hai đối tượng đều có cùng số thuộc tính [độ dài của danh sách thuộc tính giống nhau]. Và sau đó, khi lặp qua một trong các thuộc tính của đối tượng để so sánh chúng, trước tiên hãy luôn đảm bảo rằng đối tượng kia thực sự có thuộc tính theo tên đó. Nếu chúng có cùng số lượng thuộc tính và tất cả các thuộc tính trong cái này cũng tồn tại trong cái kia, thì chúng có cùng một bộ tên thuộc tính

Trả về giá trị chính xác từ hàm được thực hiện tốt nhất bằng cách trả về false ngay lập tức khi tìm thấy giá trị không khớp và trả về true ở cuối hàm

Làm cách nào để lấy một đối tượng từ một mảng trong JavaScript?

Làm cách nào để trả về một mục trong một mảng JavaScript?

Làm cách nào để trả lại đối tượng trong JavaScript?