Đối tượng Array cho phép bạn lưu trữ nhiều giá trị trong một biến duy nhất. Nó lưu trữ một tập hợp các phần tử cùng loại có kích thước cố định. Một mảng được sử dụng để lưu trữ một tập hợp dữ liệu, nhưng sẽ hữu ích hơn khi nghĩ về một mảng như một tập hợp các biến cùng loại
cú pháp
Sử dụng cú pháp sau để tạo một đối tượng Array -
var fruits = new Array[ "apple", "orange", "mango" ];
Tham số Mảng là danh sách các chuỗi hoặc số nguyên. Khi bạn chỉ định một tham số số duy nhất với hàm tạo Mảng, bạn chỉ định độ dài ban đầu của mảng. Độ dài tối đa được phép cho một mảng là 4.294.967.295
Bạn có thể tạo mảng bằng cách chỉ định các giá trị như sau -
var fruits = [ "apple", "orange", "mango" ];
Bạn sẽ sử dụng các số thứ tự để truy cập và thiết lập các giá trị bên trong một mảng như sau
fruits[0] is the first element fruits[1] is the second element fruits[2] is the third element
Thuộc tính mảng
Dưới đây là danh sách các thuộc tính của đối tượng Array cùng với mô tả của chúng
Sr. Không. Thuộc tính & Mô tả1constructorTrả về một tham chiếu đến hàm mảng đã tạo đối tượng
2mục lục
Thuộc tính đại diện cho chỉ mục dựa trên số 0 của trận đấu trong chuỗi
3đầu vào
Thuộc tính này chỉ xuất hiện trong các mảng được tạo bởi các đối sánh biểu thức chính quy
4 chiều dàiPhản ánh số lượng phần tử trong một mảng
5 nguyên mẫuThuộc tính nguyên mẫu cho phép bạn thêm các thuộc tính và phương thức vào một đối tượng
Trong các phần tiếp theo, chúng ta sẽ có một vài ví dụ để minh họa việc sử dụng các thuộc tính của Array
Phương thức mảng
Dưới đây là danh sách các phương thức của đối tượng Array cùng với mô tả của chúng
Sr. Không. Phương thức và Mô tả 1 Concat[]Trả về một mảng mới bao gồm mảng này được nối với [các] mảng và/hoặc [các] giá trị khác
2mọi[]Trả về true nếu mọi phần tử trong mảng này thỏa mãn chức năng kiểm tra được cung cấp
3bộ lọc[]Tạo một mảng mới với tất cả các phần tử của mảng này mà hàm lọc được cung cấp trả về true
4forEach[]Gọi một hàm cho từng phần tử trong mảng
5indexOf[]Trả về chỉ mục đầu tiên [ít nhất] của một phần tử trong mảng bằng với giá trị đã chỉ định hoặc -1 nếu không tìm thấy
6tham gia[]Nối tất cả các phần tử của một mảng thành một chuỗi
7lastIndexOf[]Trả về chỉ số cuối cùng [lớn nhất] của một phần tử trong mảng bằng với giá trị đã chỉ định hoặc -1 nếu không tìm thấy
8bản đồ[]Tạo một mảng mới với kết quả gọi một hàm được cung cấp trên mọi phần tử trong mảng này
9pop[]Loại bỏ phần tử cuối cùng khỏi một mảng và trả về phần tử đó
10 lần đẩy[]Thêm một hoặc nhiều phần tử vào cuối mảng và trả về độ dài mới của mảng
11giảm[]Áp dụng đồng thời một hàm đối với hai giá trị của mảng [từ trái sang phải] để giảm nó thành một giá trị duy nhất
12reduceRight[]Áp dụng đồng thời một hàm đối với hai giá trị của mảng [từ phải sang trái] để giảm nó thành một giá trị duy nhất
13đảo ngược[]Đảo ngược thứ tự các phần tử của một mảng -- phần tử đầu tiên trở thành phần tử cuối cùng và phần tử cuối cùng trở thành phần tử đầu tiên
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
Của cải
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 một chuỗi] và
let descriptions = { work: "Went to work", "touched tree": "Touched a tree" };5 [hàm cực đại] 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 cách 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àm và hằng số 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true0 và
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true1. 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
null.length; // → TypeError: null has no properties
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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true2 và
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true3 đều truy cập vào một thuộc tính trên
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true4—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 giải thích
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true5. 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true2 lấy thuộc tính của
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true4 có tên là “x”, thì
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true3 cố gắng đánh giá biểu thức
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true5 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
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]0. Nếu bạn muốn trích xuất tài sản được đặt tên theo giá trị được giữ trong ràng buộc
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]1, bạn nói
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]2. 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.
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]3 hoặc
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]4
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
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]6 vì viết như vậy dễ hơn
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]7
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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH
Mỗi chuỗi có một thuộc tính
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]9. 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 objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}0, đi theo hướng khác
Điều thú vị là, mặc dù lệnh gọi tới ____23_______9 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 ____34_______2, giá trị có thuộc tính mà chúng ta đã gọi. Cách thức hoạt động này được mô tả trong
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 “
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]9 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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]
Phương thức
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}4 thêm giá trị vào cuối mảng và phương thức
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}5 làm 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 lệnh gọi hàm từ , đây là một ví dụ của 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 day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false
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ẽ cho bạn giá trị
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true1
Có thể gán giá trị cho biểu thức thuộc tính bằng toán tử
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}7. Đ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 điều khiển
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}8 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true
Toán tử
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}9 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true1 và thực sự xóa thuộc tính đó 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ị thú vị lắm], trong khi ở 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 journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];3. 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
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]
Có một hàm
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];4 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 objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}
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á
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];5, nó sẽ tạo ra
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];6. 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 journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];
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 journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];7, 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 journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];8
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
null.length; // → TypeError: null has no properties0
Các ràng buộc
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];9 và
null.length; // → TypeError: null has no properties00 nắm bắt cùng một đối tượng, đó là lý do tại sao việc thay đổi
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];9 cũng thay đổi giá trị của
null.length; // → TypeError: null has no properties00. Họ được cho là có cùng bản sắc. Ràng buộc
null.length; // → TypeError: null has no properties03 trỏ đến một đối tượng khác, ban đầu chứa các thuộc tính giống như
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];9 nhưng sống một cuộc đời 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. Ngay cả khi các giá trị số không thay đổi, bạn có thể sử dụng liên kết
null.length; // → TypeError: null has no properties05 để 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ù một liên kết
null.length; // → TypeError: null has no properties06 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
null.length; // → TypeError: null has no properties1
Khi bạn so sánh các đối tượng với toán tử
null.length; // → TypeError: null has no properties07 của JavaScript, nó sẽ so sánh theo danh tính. nó sẽ tạo ra
null.length; // → TypeError: null has no properties08 chỉ khi 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 journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];2, 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 thao tác ở cuối chương này]
Nhật ký của 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ý.
null.length; // → TypeError: null has no properties2
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ư
null.length; // → TypeError: null has no properties10, 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 đó
null.length; // → TypeError: null has no properties3
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ử [
null.length; // → TypeError: null has no properties11]. Chúng ta cũng có thể sử dụng các biểu diễn khác, chẳng hạn như một mảng chứa hai mảng hai phần tử [
null.length; // → TypeError: null has no properties12] hoặc một đối tượng có các tên thuộc tính như
null.length; // → TypeError: null has no properties13 và
null.length; // → TypeError: null has no properties14, nhưng mảng phẳng thì đơ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
null.length; // → TypeError: null has no properties15 đề 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ì hệ nhị phân
null.length; // → TypeError: null has no properties15 là 2 trong ký hiệu thập phân, nên chúng ta sẽ lưu số này ở chỉ số 2 của mảng
Đây là hàm tính hệ số ϕ từ một mảng như vậy
null.length; // → TypeError: null has no properties4
Đây là bản dịch trực tiếp của công thức ϕ sang JavaScript.
null.length; // → TypeError: null has no properties17 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 phần dành cho chương này, nơi nó được lưu trữ trong ràng buộc
null.length; // → TypeError: null has no properties19 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
null.length; // → TypeError: null has no properties5
Mảng có một phương thức
null.length; // → TypeError: null has no properties20 để 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
null.length; // → TypeError: null has no properties21 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
null.length; // → TypeError: null has no properties21, có một vòng lặp như thế này
null.length; // → TypeError: null has no properties6
Loại vòng lặp này phổ biến trong JavaScript cổ điển—đi qua từng mảng một phần tử là 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
null.length; // → TypeError: null has no properties7
Khi một vòng lặp
null.length; // → TypeError: null has no properties23 trông như thế này, với từ
null.length; // → TypeError: null has no properties24 sau định nghĩa biến, nó sẽ lặp qua các phần tử của giá trị đã cho sau
null.length; // → TypeError: null has no properties24. Đ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 thức hoạt động của nó 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
null.length; // → TypeError: null has no properties8
Bằng cách duyệt qua tất cả các sự kiện và thêm những sự kiện chưa có vào mảng
null.length; // → TypeError: null has no properties26, 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
null.length; // → TypeError: null has no properties9
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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH0
à 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ể
Thú vị. Hãy thử một cái gì đó
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH1
Đó 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 objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}4 và
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}5, thêm và xóa các phần tử ở cuối một mảng, trong chương này. Các phương thức tương ứng để thêm và bớt những thứ ở đầu mảng được gọi là
null.length; // → TypeError: null has no properties29 và
null.length; // → TypeError: null has no properties30
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH2
Chương trình đó quản lý một hàng các nhiệm vụ. Bạn thêm các nhiệm vụ vào cuối hàng đợi bằng cách gọi
null.length; // → TypeError: null has no properties31 và khi bạn đã sẵn sàng làm điều gì đó, bạn gọi
null.length; // → TypeError: null has no properties32 để lấy [và xóa] mục phía trước khỏi hàng đợi. Hàm
null.length; // → TypeError: null has no properties33 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
null.length; // → TypeError: null has no properties34. 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ự được gọi là
null.length; // → TypeError: null has no properties35
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH3
Cả
null.length; // → TypeError: null has no properties34 và
null.length; // → TypeError: null has no properties35 đều lấy đố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à
null.length; // → TypeError: null has no properties38, 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH4
Khi chỉ mục kết thúc không được cung cấp,
null.length; // → TypeError: null has no properties38 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
null.length; // → TypeError: null has no properties40 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ử
null.length; // → TypeError: null has no properties41 thực hiện đối với các chuỗi
Ví dụ sau đây cho thấy cả
null.length; // → TypeError: null has no properties40 và
null.length; // → TypeError: null has no properties38 đ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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH5
Nếu bạn vượt qua một đối số
null.length; // → TypeError: null has no properties40 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à
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]9 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH6
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à
null.length; // → TypeError: null has no properties38 và
null.length; // → TypeError: null has no properties34, giống với các phương thức mảng cùng tên
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH7
Một điểm khác biệt là một chuỗi
null.length; // → TypeError: null has no properties34 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH8
Phương thức
null.length; // → TypeError: null has no properties50 xóa khoảng trắng [dấu cách, dòng mới, tab và các ký tự tương tự] ở đầu và cuối chuỗi
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH9
Hàm
null.length; // → TypeError: null has no properties51 từ chương trước cũng tồn tại như một phương thức. Nó được gọi là
null.length; // → TypeError: null has no properties52 và lấy ký tự đệm và độ dài mong muốn làm đối số
let sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]0
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
null.length; // → TypeError: null has no properties53 và nối lại chuỗi đó với
null.length; // → TypeError: null has no properties54
let sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]1
Một chuỗi có thể được lặp lại bằng phương thức
null.length; // → TypeError: null has no properties55, 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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]2
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 phần ]
let sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]3
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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]4
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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]5
Đ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
null.length; // → TypeError: null has no properties59
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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]6
đố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],
null.length; // → TypeError: null has no properties62 [tối thiểu] và
null.length; // → TypeError: null has no properties17 [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
null.length; // → TypeError: null has no properties05 hoặc
null.length; // → TypeError: null has no properties06 nhưng—ngược lại—không phải cho các ràng buộc tiêu chuẩn cũng như cho các ràng buộc được khai báo bằng
null.length; // → TypeError: null has no properties71 hoặc
null.length; // → TypeError: null has no properties72
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
null.length; // → TypeError: null has no properties75 [cosine],
null.length; // → TypeError: null has no properties76 [sin] và
null.length; // → TypeError: null has no properties77 [tiếp tuyến], cũng như các hàm nghịch đảo của chúng, lần lượt là
null.length; // → TypeError: null has no properties78,
null.length; // → TypeError: null has no properties79 và
null.length; // → TypeError: null has no properties80. Số π [pi]—hoặc ít nhất là giá trị gần đúng nhất phù hợp với số JavaScript—có sẵn dưới dạng
null.length; // → TypeError: null has no properties81. 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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]7
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 , tôi sẽ giải thích chúng
Ví dụ trước đã sử dụng
null.length; // → TypeError: null has no properties82. Đâ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 sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]8
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
null.length; // → TypeError: null has no properties83 [làm tròn xuống số nguyên gần nhất] trên kết quả của
null.length; // → TypeError: null has no properties82
let sequence = [1, 2, 3]; sequence.push[4]; sequence.push[5]; console.log[sequence]; // → [1, 2, 3, 4, 5] console.log[sequence.pop[]]; // → 5 console.log[sequence]; // → [1, 2, 3, 4]9
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ì
null.length; // → TypeError: null has no properties83 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
null.length; // → TypeError: null has no properties86 [đối với “trần”, làm tròn đến một số nguyên],
null.length; // → TypeError: null has no properties87 [đến số nguyên gần nhất] và
null.length; // → TypeError: null has no properties88, 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 các giá trị dương
hủy diệt
Hãy quay lại hàm
null.length; // → TypeError: null has no properties89 trong giây lát
let day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false0
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à,
null.length; // → TypeError: null has no properties90, v.v. May mắn thay, có một cách ngắn gọn để làm điều này trong JavaScript
let day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false1
Điều này cũng hoạt động đối với các ràng buộc được tạo bằng
null.length; // → TypeError: null has no properties05,
null.length; // → TypeError: null has no properties71 hoặc
null.length; // → TypeError: null has no properties06. 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 day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false2
Lưu ý rằng nếu bạn cố gắng hủy cấu trúc
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true0 hoặc
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true1, 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 day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false3
JavaScript cung cấp cho chúng ta các hàm
null.length; // → TypeError: null has no properties96 và
null.length; // → TypeError: null has no properties97 để 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 day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false4
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 đặt 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true0 và
let anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true1. Thuộc tính được truy cập bằng cách sử dụng
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH00 hoặc
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH01. 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 khác nhau 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
null.length; // → TypeError: null has no properties23—
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH04
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 day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false5
Viết hàm
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH05 nhận hai đối số,
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH06 và
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH07, rồi trả về một mảng chứa tất cả các số từ
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH06 đến [và bao gồm]
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH07
Tiếp theo, hãy viết một hàm
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH10 nhận vào một mảng các số và trả về tổng của các số này. Chạy chương trình ví dụ và xem nó có thực sự trả về 55 không
Như một nhiệm vụ bổ sung, hãy sửa đổi hàm
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH05 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH12 sẽ trả về
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH13. Đảm bảo rằng nó cũng hoạt động với các giá trị bước âm để
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH14 tạo ra
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH15
let day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false6
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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH16 [một mảng mới, trống] và liên tục gọi phương thức
let objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}4 của nó để thêm một giá trị. Đừng quên trả về mảng ở cuối hàm
Vì ranh giới cuối là bao gồm, bạn sẽ cần sử dụng toán tử
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH18 thay vì
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH19 để kiểm tra điểm cuối của vòng lặp
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 objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}7] thành 1
Để
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH05 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 vòng lặp để đếm lên và một vòng lặp để đếm ngược—vì phép so sánh để kiểm tra xem vòng lặp đã kết thúc hay chưa cần phải là
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH22 thay vì
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH18 khi đếm ngược
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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH24 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ô hạ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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH25 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH26 và
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH27. Đầu tiên,
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH26, 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH27, thực hiện những gì mà phương thức
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH25 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH25 tiêu chuẩn
Nghĩ lại các ghi chú về tác dụng phụ và chức năng thuần túy trong , bạn mong muốn biến thể nào sẽ hữu ích trong nhiều tình huống hơn?
let day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false7
Có hai cách rõ ràng để triển khai
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH26. Đầ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
null.length; // → TypeError: null has no properties29 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 objectA = {a: 1, b: 2}; Object.assign[objectA, {b: 3, c: 4}]; console.log[objectA]; // → {a: 1, b: 3, c: 4}4. 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ử]
null.length; // → TypeError: null has no properties23, như
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH36
Đả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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH26 hoặc sao chép toàn bộ mảng [
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH38 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ể thực hiện việc này bằng cách lặp trên một nửa độ dài của mảng [sử dụng
null.length; // → TypeError: null has no properties83 để 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ố lượng phần tử lẻ] và hoán đổi phần tử ở vị trí
console.log[Object.keys[{x: 0, y: 0, z: 2}]]; // → ["x", "y", "z"]1 với vị trí thứ nhất. . Bạn có thể sử dụng một 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í từng là hình ảnh phản chiếu.
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 day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false8
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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH42 và
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH43 [với
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH44 đề 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 gốc cũng vẫn là danh sách ba phần tử hợp lệ
Viết một hàm
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH45 xây dựng cấu trúc danh sách giống như cấu trúc được hiển thị khi đưa ra đối số _______32_______46. Đồng thời viết một hàm
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH47 để tạo một mảng từ một danh sách. Sau đó, thêm một hàm trợ giúp
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH48, 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH49, 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH49
let day1 = { squirrel: false, events: ["work", "touched tree", "pizza", "running"] }; console.log[day1.squirrel]; // → false console.log[day1.wolf]; // → undefined day1.wolf = false; console.log[day1.wolf]; // → false9
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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH45 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH53 để thêm phần tử
Để chạy qua một danh sách [trong
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH47 và
let doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH49], có thể sử dụng đặc tả vòng lặp
null.length; // → TypeError: null has no properties23 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH57 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH49 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true4 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 anObject = {left: 1, right: 2}; console.log[anObject.left]; // → 1 delete anObject.left; console.log[anObject.left]; // → undefined console.log["left" in anObject]; // → false console.log["right" in anObject]; // → true4 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH63 của danh sách này
So sánh sâu sắc
Toán tử
null.length; // → TypeError: null has no properties07 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH65 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH65
Để 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH67 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH68. Nếu nó tạo ra
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];6 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH70 cũng tạo ra
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];6
Hàm
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];3 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH73. 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 doh = "Doh"; console.log[typeof doh.toUpperCase]; // → function console.log[doh.toUpperCase[]]; // → DOH67
Sử dụng
let journal = [ {events: ["work", "touched tree", "pizza", "running", "television"], squirrel: false}, {events: ["work", "ice cream", "cauliflower", "lasagna", "touched tree", "brushed teeth"], squirrel: false}, {events: ["weekend", "cycling", "break", "peanuts", "beer"], squirrel: true}, /* and so on.. */ ];3 để 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