programming javascript
Mảng giảm JavaScript

Phương thức
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
5 kết hợp từng phần tử của một mảng, sử dụng hàm rút gọn được chỉ định và trả về một giá trị duy nhất
array.reduce[[accumulator, currentValue, index, array] => {...}, initialValue]
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
5 có hai đối số
Đầu tiên, là hàm rút gọn thực hiện thao tác rút gọn và nhận bốn đối sốconst arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
7 là giá trị trả về từ hàm
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
8 là phần tử được lặp đi lặp lại
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
9 [tùy chọn] là chỉ số của const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
8
Adding with initial value: abcde
1 [tùy chọn] là mảng mà const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
5 đã được gọi
Đối số thứ hai [tùy chọn] là một const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
1 để chuyển đến hàm
Giá trị của 
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
7 tích lũy với mỗi lần lặp qua mảng, dẫn đến một giá trị duy nhất
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',

  
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
Điều này sẽ mang lại đầu ra sau
Adding with initial value: abcde
Ví dụ sau đây sử dụng 
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
5 để trừ các số trong một mảng const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
4 từ giá trị ban đầu của const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
5 được cung cấp
 Trong bài đăng này, bạn sẽ tìm hiểu về thao tác rút gọn và cách sử dụng phương thức 
Adding with initial value: abcde
5 để thực hiện thao tác rút gọn trên mảng
1. Giảm hoạt động
Trước khi đi sâu vào cách sử dụng phương pháp 
Adding with initial value: abcde
6, hãy phân biệt vấn đề mà nó cố gắng giải quyết. giảm một mảng thành một giá trị
Giảm một mảng có nghĩa là thực hiện một thao tác tích lũy cụ thể trên các mục của nó để tính giá trị kết quả
Một ví dụ điển hình về thao tác rút gọn là tính tổng của một mảng, trong đó thao tác tích lũy là phép cộng các mục. Đối với một mảng 
Adding with initial value: abcde
7 rút gọn thành tổng kết quả là javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
0
Một ví dụ khác về rút gọn là xác định phần tử lớn nhất của mảng. Đối với một mảng 
javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
1, việc giảm xuống mục tối đa dẫn đến javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
2
Bây giờ bạn có thể dễ dàng thấy phương thức
Adding with initial value: abcde
6 làm gì — thực hiện thao tác rút gọn
2. mảng. phương pháp giảm []
Adding with initial value: abcde
6 là một phương thức trên mảng chấp nhận 2 đối số
javascript
const value = array.reduce[callback[, initialValue]];
javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;

  
}, 0];
sum; // 12
5 là một đối số bắt buộc là một hàm thực hiện thao tác rút gọn và đối số tùy chọn thứ hai là giá trị ban đầu
JavaScript gọi hàm 
javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
5 theo từng mục của mảng có 4 đối số. giá trị bộ tích lũy, mục mảng hiện tại, chỉ mục mục mảng hiện tại và chính mảng đó. Hàm javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
5 phải trả về giá trị bộ tích lũy được cập nhật
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
3Ví dụ: hãy quay lại mã từ phần giới thiệu
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
4Hãy thử bản trình diễn
javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
8 tính tổng tất cả các phần tử trong mảng
Cuộc gọi lại 
javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
9 được gọi cho mọi mục trong mảng với tổng tích lũy và số lần lặp. Gọi lại javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
9 thêm mục đã lặp vào tổng đã tích lũy và trả về tổng đã cập nhật đó
Đó là cách một mảng giảm thành một tổng
Ngoài ra, hãy lưu ý đối số thứ hai của 
javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12

  
8 — tổng các phần tử mảng được khởi tạo với javascript
const value = array.reduce[callback[, initialValue]];
2
thử thách phụ. bạn sẽ sử dụng phương thức 
Adding with initial value: abcde
6 như thế nào để tìm giá trị lớn nhất của mảng? 
3. Bỏ qua đối số giá trị ban đầu
Bạn cũng có thể bỏ qua đối số thứ hai của 
Adding with initial value: abcde
6. Trong trường hợp như vậy, phương thức rút gọn khởi tạo giá trị bộ tích lũy với mục đầu tiên của mảng và quá trình lặp bắt đầu từ mục thứ hai
Ví dụ: hãy tính tổng các phần tử mảng mà không chỉ ra đối số thứ hai của 
javascript
const value = array.reduce[callback[, initialValue]];
5
const arrayOne = ['a', 'b', 'c', 'd', 'e'];
  arrayOne.reduce[[acc, curr] => acc + curr]
const arrayTwo = ['b', 'c', 'd', 'e'];
  'Adding with initial value:',
  arrayTwo.reduce[[acc, curr] => acc + curr, 'a']
const arrayThree = [{ x: 1 }, { x: 2 }, { x: 4 }];
  arrayThree.reduce[[acc, curr] => acc + curr.x, 0]
1Hãy thử bản trình diễn
Đối số giá trị ban đầu bị bỏ qua, do đó bộ tích lũy được khởi tạo với giá trị của mục đầu tiên [số 
javascript
const value = array.reduce[callback[, initialValue]];
6]. Lặp lại bắt đầu từ mục thứ hai
4. Phần kết luận
Adding with initial value: abcde
6 là một phương thức hữu ích giúp giảm một mảng thành một giá trị
Adding with initial value: abcde
5 chấp nhận 2 đối số. hàm javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
5 cập nhật giá trị bộ tích lũy và giá trị ban đầu của bộ tích lũy. Adding with initial value: abcde
6 sau đó gọi javascript
const numbers = [2, 4, 6];
const sum = numbers.reduce[function[sum, number] {
  const updatedSum = sum + number;
  return updatedSum;
}, 0];
sum; // 12
5 cho từng mục của mảng, cập nhật bộ tích lũy ở mỗi bước
Bạn cũng có thể bỏ qua đối số giá trị ban đầu, trong trường hợp đó, giá trị bộ tích lũy được khởi tạo với mục đầu tiên của mảng và quá trình lặp lại bắt đầu từ mục thứ hai
Bạn có muốn đọc thêm về phương pháp mảng? 
Thích bài viết? 
đề xuất cải tiến
Bài đăng chất lượng vào hộp thư đến của bạn
Tôi thường xuyên xuất bản bài viết có chứa
Các khái niệm JavaScript quan trọng được giải thích bằng các từ đơn giản
Tổng quan về các tính năng JavaScript mới
Cách sử dụng TypeScript và cách gõ
Thiết kế phần mềm và thực hành mã hóa tốt
Đăng ký nhận bản tin của tôi để nhận chúng ngay trong hộp thư đến của bạn
Đặt mua
Tham gia cùng 6719 người đăng ký khác
Giới thiệu về Dmitri Pavlutin
Nhà văn và huấn luyện viên công nghệ. Thói quen hàng ngày của tôi bao gồm [nhưng không giới hạn] uống cà phê, viết mã, viết, huấn luyện, vượt qua sự nhàm chán 😉
 
			Giảm mảng trong JavaScript là gì?
			Mảng Javascript. phương thức reduce[] trong JavaScript được  dùng để giảm mảng thành một giá trị duy nhất và thực thi một hàm được cung cấp cho từng giá trị của mảng [từ trái sang phải] và giá trị trả về của . .
		
			Làm cách nào để giảm kích thước mảng trong JavaScript?
			Phương thức reduce[] thực thi hàm rút gọn cho phần tử mảng . Phương thức reduce[] trả về một giá trị duy nhất. kết quả tích lũy của hàm. Phương thức reduce[] không thực thi hàm đối với các phần tử mảng trống. Phương thức reduce[] không thay đổi mảng ban đầu. 
		
			Giảm một mảng là gì?
			Giảm mảng trong JavaScript là  một phương thức được xác định trước được sử dụng để giảm mảng thành một giá trị duy nhất bằng cách chuyển hàm gọi lại trên từng phần tử của mảng. It accepts a function executed on all the items of the specified array in the left-to-right sequence. The returned single value is stored in the accumulator.
		
			Bạn có thể giảm một mảng thành một đối tượng không?
			reduce là một phương pháp hữu ích để giảm tập dữ liệu thành các giá trị có ý nghĩa. Một điều không rõ ràng là  bạn cũng có thể rút gọn mảng thành đối tượng , không chỉ là số.