Mẫu tích lũy trong Python
|
Mẫu tích lũy là một cách xây dựng hoặc tích lũy dữ liệu. Ví dụ đơn giản nhất về bộ tích lũy là một vòng lặp trên Mảng số để tính tổng các giá trị của chúng. Ở đây chúng tôi đang giảm một Mảng các phần tử số thành một phần tử số duy nhất Show Trước tiên hãy xem xét nó từ cách tiếp cận bắt buộc const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = sum + number; } console.log(sum); Điều gì sẽ xảy ra nếu khối vòng lặp được biến thành một chức năng? . Nói cách khác, nó nhận một phần tử tích lũy và phần tử tiếp theo trong mảng và trả về phần tử tích lũy mới const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum); Điều gì sẽ xảy ra nếu chúng ta biến toàn bộ hoạt động, cả vòng lặp và khối bên trong của nó, thành một hàm. Những loại đối số nó sẽ mất? . Một là Mảng các phần tử số và phần còn lại là giá trị ban đầu cho bộ tích lũy (tổng của chúng tôi) const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum); Với định nghĩa cuối cùng này, chúng ta đã tiến gần đến cách thức hoạt động của phương thức const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 thực tế. Một điểm khác biệt chính là nó nhận được một Mảng được truyền dưới dạng đối số trong khi phương thức const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 được gọi trên Mảng như const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);1 Hãy xem chức năng này đang làm gì. Nó nhận được một Mảng để lặp lại. Nó khai báo một biến bộ tích lũy (có thể gán lại bởi const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);2) và gán cho nó một giá trị ban đầu, trong trường hợp này là 0 cho bộ tích lũy const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);3 của chúng ta. Sau đó, nó lặp lại Mảng và gán lại const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);3 trước đó cho một giá trị mới được lấy từ const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);3 trước đó và phần tử hiện tại Nói cách khác, nó gán lại giá trị bộ tích lũy cho giá trị được trả về bởi hàm gọi lại, const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);6. Trong trường hợp này, chúng tôi đã xác định cuộc gọi lại là cộng tổng trước đó vào số hiện tại. Nhưng chúng ta có thể dễ dàng định nghĩa nó có bất kỳ hướng dẫn nào khác Tất cả các bộ giảm tốc của chúng tôi, const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);7 quan tâm đến là một Mảng giá trị và một hàm gọi lại xác định cách đánh giá tích lũy Để làm bằng chứng, hãy cho thấy việc hoán đổi một hàm gọi lại mới hiện tính toán tích của các số trong Mảng dễ dàng như thế nào. Trong khi cũng sử dụng cùng một hàm rút gọn để tính tổng như chúng ta đã có trước đây Chúng tôi sẽ giữ nguyên tất cả các logic khác bên cạnh việc khái quát hóa cách đặt tên của chúng tôi để giúp chúng tôi hiểu rõ hơn về const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);3 Bây giờ rõ ràng mục đích của const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 là gì. lặp lại một Mảng và giảm các phần tử của nó thành một phần tử duy nhất. Trong những trường hợp này, chúng tôi rút gọn một Mảng số thành tích và tổng (phần tử số). Nhưng chúng ta sẽ thấy nhiều ví dụ khác trong tương lai làm tăng độ phức tạp nhưng cung cấp mức giảm mã tương đương Hai điểm khác biệt chính giữa ví dụ của chúng ta và bản thân const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 là các tham số const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);31 và const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);32. Khi sử dụng phương thức const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 của chúng tôi, chúng tôi gọi nó trên Mảng và giá trị ban đầu được cung cấp dưới dạng đối số. Tuy nhiên, giá trị ban đầu không được xác định và gán bên ngoài, bạn chỉ cần cung cấp giá trị và phương thức sẽ quản lý việc gán và gán lại trong khi lặp lại. Điều này giúp chúng tôi tránh các đột biến bên ngoài của các biến chống mẫu Cuối cùng chúng ta hãy khám phá cách thức hoạt động của phương thức const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 từ chữ ký hàm của nó đến hàm gọi lại. Giảm có một chữ ký duy nhất trong số tất cả các phương thức Array, nó nhận cả giá trị gọi lại và giá trị ban đầu
const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);5 Bây giờ bạn đã biết giảm đến từ đâu và cách nó hoạt động về mặt khái niệm, hãy xem một số trường hợp sử dụng thú vị hơn lọcconst numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);8 Lưu ý trong trường hợp này, bộ tích lũy của chúng ta là một Mảng chứ không phải là một số. Để tích lũy Mảng của chúng tôi, chúng tôi đẩy các giá trị mới vào đó một cách có điều kiện. Sau khi đẩy số chẵn vào const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);52, chúng tôi trả về giá trị bộ tích lũy mới này. Trong trường hợp lẻ, chúng ta chỉ cần trả về giá trị const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);52 hiện tại vì số đó không phải là số chẵn (có nghĩa là nó không được cộng dồn) Tuy nhiên, việc thay đổi các đối số hoặc bất kỳ thứ gì được xác định bên ngoài một hàm là một cách làm không tốt. Điều này có thể dẫn đến sự cố với các biến bên ngoài có giá trị không mong muốn khi chúng được sử dụng sau này trong mã (vì việc gán lại chúng bị ẩn trong một hàm) Thay vào đó, tốt nhất là tạo các bản sao của các đối số và thao tác trên các đối số đó. Đây là một lý do khác khiến các phương thức Array rất hữu ích - bên cạnh const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);54 và const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);55, tất cả các phương thức đều trả về một Mảng được sao chép, không bao giờ ảnh hưởng đến bản gốc Một cách dễ dàng để tránh thay đổi đối số bộ tích lũy là sử dụng cú pháp trải rộng của Arrays. Ở đây, chúng tôi trả về một Mảng mới mỗi lần chứa tất cả các phần tử đã tích lũy trước đó (thông qua trải rộng) và phần tử mới. Cú pháp trải rộng const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);56 trải rộng tất cả các phần tử trong Mảng vào Mảng mới xung quanh nó. Bằng cách trải rộng, chúng tôi không bao giờ thay đổi giá trị của Mảng ban đầu mà vẫn giữ nguyên mẫu tích lũy của mình Đây chỉ là một trong nhiều cách sử dụng toán tử trải phổ. Chúng ta sẽ khám phá một số trong số chúng sau nhưng nếu bạn muốn tìm hiểu thêm bây giờ thì đây là một nơi tốt để bắt đầu const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);4 Hãy xem xét việc rút gọn thành một Đối tượng. Ví dụ này dành cho bộ đếm tần số của các ký tự trong Chuỗi. Chúng tôi sẽ tạo một đối tượng có thuộc tính const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);57 để lưu trữ tần số ký tự của chúng tôi const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);6 Chuỗi phương phápĐối với ví dụ cuối cùng, hãy xem cách const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9 có thể thay thế cả lệnh gọi const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);59 và const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);80. Mục tiêu của chúng ta ở đây là nhân mỗi số với 5 ( const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);81) và chỉ const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);82 các kết quả chẵn Trước tiên, hãy xem làm thế nào chúng ta có thể thực hiện điều này bằng cách sử dụng const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);59 và const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);80 liên kết với nhau. Chuỗi phương thức là một cách gọi một phương thức "trên" một phương thức khác bằng cách sử dụng toán tử dấu chấm. công việc này miễn là
Ví dụ: giả sử chúng ta gọi const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);59 trên một mảng. const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);88 Ở bên trái của const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);85 là một kiểu Mảng const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);6 và bên phải là một phương thức Mảng const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);59 mong đợi một Mảng hoạt động. Đây là cú pháp hợp lệ vì cả bên trái và bên phải của const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);85 đều thuộc loại chính xác Điều gì sẽ xảy ra nếu chúng ta call, hoặc chain, const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);80 vào cuộc gọi const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);59? Điều này có vẻ khó hiểu, nó sẽ giúp nhớ lại cách JavaScript đánh giá các biểu thức Đầu tiên tuyên bố trong trường hợp này là gì? const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);8 Mọi thứ đang diễn ra ở phía bên phải của bài tập (______349) như cách diễn đạt của chúng ta. JavaScript sẽ đánh giá biểu thức từ trái sang phải cho đến khi kết thúc chuỗi và trả về giá trị đó Một cách dễ dàng để hiểu điều này là chia nhỏ nó thành các bước. Lưu ý rằng sau mỗi bước được đánh giá, bất cứ thứ gì nó trả về sẽ được đưa cho bước tiếp theo. Nếu chúng ta chia nhỏ điều này thành các bước đánh giá thì nó trông như thế này
Vì vậy, trong mỗi bước đánh giá, các lệnh gọi phương thức được chuyển đổi thành kiểu trả về của chúng (một Mảng). Nếu chúng ta đi từ trái sang phải, chúng ta có thể thấy rằng mỗi bước trước đó trả về loại (Mảng) dự kiến cần cho bước gọi phương thức tiếp theo Dưới đây là một ví dụ về cách đảo ngược Chuỗi (một đoạn phỏng vấn cổ điển). Lưu ý rằng chúng tôi đang trộn cả hai phương thức Chuỗi và Mảng trong chuỗi. Điều này có vẻ không chính xác nhưng hãy nhớ rằng mỗi phương thức đang nhận chính xác loại mà nó mong đợi Chúng ta sẽ xâu chuỗi 3 phương thức lại với nhau để. tách Chuỗi thành một mảng, đảo ngược các phần tử của Mảng đó và cuối cùng nối Mảng (đã đảo ngược) đó lại với nhau để tạo Chuỗi đảo ngược const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);6 Trải rộng trên nhiều dòng để dễ đọc const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);0 Hãy chia nhỏ các bước đánh giá một lần nữa để xem tại sao điều này lại hiệu quả
Bây giờ chúng ta đã hiểu về chuỗi, hãy xem cách nó có thể được sử dụng để đạt được mục tiêu của chúng ta const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);1 Hãy chia phần này thành nhiều dòng để thêm một số ngữ cảnh. Đây là một cách phổ biến để viết các lời gọi phương thức chuỗi để mỗi lời gọi chiếm một dòng riêng và chúng ta có thể đọc nó theo thứ tự đánh giá. Lưu ý rằng JavaScript bỏ qua khoảng trắng giữa mỗi lệnh gọi const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);2 Vì const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);64 là giá trị được trả về cuối cùng từ chuỗi nên nó trở thành giá trị được gán cho const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);85 Một số người thích sử dụng chuỗi để dễ đọc. Nó đọc khá rõ ràng, lấy một số số và ánh xạ (biến đổi) chúng theo tích của 5 rồi lọc kết quả. Tuy nhiên, hãy xem xét tác động của các mảng lớn. Hãy nhớ rằng mỗi phương thức Mảng lặp đi lặp lại trên toàn bộ Mảng. Vì vậy, nếu chúng ta có một Mảng có độ dài 10.000 phần tử. Điều đó có nghĩa là chúng tôi đã thực hiện 10.000 lần lặp cho lệnh gọi const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);59 và 10.000 lần lặp khác cho lệnh gọi const numbers = [1, 2, 3, 4]; const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const reduceSum = (arr, accumulatorCallback, initialValue) => { for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; initialValue = accumulatorCallback(initialValue, number); } return initialValue; } let sum = 0; const finalSum = reduceSum(numbers, getNewSum, sum); console.log(finalSum);80. Đó là 20.000 lần lặp lại Điều gì sẽ xảy ra nếu chúng ta có thể vừa chuyển đổi vừa lọc trong một lần lặp? . Nhập người bạn của chúng tôi const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9, giống như các phương thức Array lặp khác, lặp lại Mảng đã cho. Sử dụng const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);9, chúng tôi có thể đạt được kết quả tương tự nhưng chỉ sử dụng một lần lặp trên Aray const getNewSum = (previousSum, currentElement) => { return previousSum + currentElement; } const numbers = [1, 2, 3, 4]; let sum = 0; for (let index = 0; index < numbers.length; ++index) { const number = numbers[index]; sum = getNewSum(sum, number); } console.log(sum);3 Hãy sáng tạo và thử giảm một số Mảng thành các loại bộ tích lũy khác nhau. Hãy nhớ rằng tất cả những gì bộ giảm tốc quan tâm là một cuộc gọi lại trả về một giá trị bộ tích lũy mới và một đối tượng bộ tích lũy ban đầu. Việc bạn định nghĩa thế nào là tích lũy và cách bạn sẽ lưu trữ nó như một công cụ tích lũy hoàn toàn phụ thuộc vào bạn Một ví dụ về mô hình tích lũy là gì?Số lần lặp lại là nơi số thứ hai phát huy tác dụng. Ví dụ: nếu chúng ta muốn nhân ba với năm, chúng ta có thể coi đó là phép cộng ba với chính nó năm lần . Ba cộng ba là sáu, cộng ba là chín, cộng ba là 12, cuối cùng cộng ba là 15.
Lập trình tích lũy là gì?Bộ tích lũy chủ yếu được sử dụng làm thanh ghi trong CPU để lưu trữ dữ liệu logic hoặc số học trung gian trong phép tính nhiều bước . Đối với các tính toán như vậy, nó hoạt động như một vị trí lưu trữ tạm thời.
Bộ tích lũy trong vòng lặp là gì?Tuy nhiên, với lập trình, chúng ta phải lưu trữ rõ ràng một giá trị như vậy trong một biến. mẫu khởi tạo một biến thành một giá trị trống hoặc cơ bản nào đó và cập nhật nó trong một vòng lặp thường được gọi là mẫu bộ tích lũy. Chúng tôi gọi biến là bộ tích lũy.
Bộ tích lũy là gì Khởi tạo và cập nhật bộ tích lũy trong một chương trình có nghĩa là gì?Mẫu tích lũy là một chiến lược gồm 1) khởi tạo một biến 2) lặp lại trên một tập hợp dữ liệu, một phạm vi hoặc cho đến khi một điều kiện được thỏa mãn và 3) cập nhật . Biến được xác định bên ngoài phép lặp được gọi là bộ tích lũy. . The variable that is defined outside of the iteration is referred to as the accumulator. |
