Làm cách nào để tính tổng khóa đối tượng trong JavaScript?

Tôi sẽ giả định trước rằng nhiều cuộc kiểm tra trung thực mà bạn đang thực hiện [e. g. .. || 0] chỉ đơn giản là để kiểm tra xem một giá trị có phải là không xác định hay không và bạn không thực sự mong đợi các giá trị sai lệch khác trong tham số của mình. Sử dụng giả định này, tôi sẽ thoải mái thay thế phần lớn logic của || 0 bằng các tham số mặc định. Nếu giả định này là sai, bạn chỉ cần ném các tham số mặc định và thêm lại các kiểm tra falsey vào

Một nguồn phức tạp chính ở đây là thực tế là mỗi .reduce[] đang cố cập nhật hai giá trị độc lập [key1 và

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

0]. Tôi thấy nó sạch hơn nhiều nếu tôi tính riêng giá trị key1 kết quả với giá trị

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

0 một cách độc lập, thay vì cố gắng tính cả hai giá trị đó cùng một lúc

Ví dụ, tôi đã thay đổi logic để tính toán đối tượng

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

1 thành

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

Lưu ý cách tôi có chức năng rút gọn khác nhau cho mỗi phím? . Trong đoạn mã trước, tôi nhận thấy rằng tôi có thể chia mỗi .reduce[] thành hai bước, một. Bước 03, sau đó là bước 8

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

Những .reduce[] đó bây giờ không gì khác hơn là một tổng đơn giản, vì vậy tôi có thể hoán đổi chúng để lấy một hàm tổng

const sum = array => array.reduce[[acc, el] => acc + el, 0]

const totalsSum = {
    key1: sum[
        totals.map[[{ num = 0, gross }] => computeVal[num, gross]]
    ],
    key2: sum[
        totals.map[[{ num = 0, net }] => computeVal[num, net]]
    ],
};

Tôi đã đơn giản hóa các khu vực khác của mã theo cách rất giống nhau và thực hiện một số đơn giản hóa khác ngoài điều đó, cho đến khi tôi đạt được giải pháp khá ngắn gọn này

const sum = array => array.reduce[[acc, el] => acc + el, 0];

const sumUpKeys = [objects, totals = []] => [{
    key1: sum[[
        ...totals.map[[{ num = 0, gross }] => num * gross],
        ...objects.map[[{ num = 0, items }] => sum[
            items.map[[{ key1 }] => num * key1]
        ]]
    ]],
    key2: sum[[
        ...totals.map[[{ num = 0, net }] => num * net],
        ...objects.map[[{ num = 0, items }] => sum[
            items.map[[{ key2 }] => num * key2]
        ]]
    ]],
}];

Từ đây, bạn sẽ nhận thấy có khá nhiều logic lặp đi lặp lại. Nếu bạn nghĩ nó hợp lý, bạn có thể trích xuất một hàm trợ giúp có khả năng tính tổng cho một khóa riêng lẻ, sau đó sử dụng hàm trợ giúp đó cho cả hai khóa. Tôi đã chọn không làm điều này, một phần vì tôi không biết đủ về trường hợp sử dụng cụ thể để biết liệu loại cấu trúc lại này có hợp lý hay không, nhưng đó là một tùy chọn

[Cuối cùng, tôi thực sự thích kết quả cuối cùng của @morbusg hơn. Tuy nhiên, tôi nghĩ rằng tôi sẽ chia sẻ quá trình tái cấu trúc mà tôi đã thực hiện, để hy vọng đưa ra ý tưởng về cách làm sạch mã như thế này trong tương lai]

Ban đầu

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

6 là chỉ số của phần tử áp chót của mảng nên

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

7 là phần tử xâu áp chót và

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

8 là phần tử xâu cuối cùng của mảng

Sau

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

9, mảng chuỗi trở thành

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

0. Ở vòng lặp đầu tiên của vòng lặp 'for', các khóa

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

1 và

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

2 sẽ có giá trị chuỗi là "v". Dòng mã dài sau đó tính tổng các giá trị của hai khóa và cập nhật phần tử áp chót với giá trị mới. vì vậy phần tử áp chót trở thành “v. 7”. Phần tử cuối cùng của mảng [“v. 5”] sau đó bị xóa. Vì vậy, chúng ta có thể nói rằng hai phần tử mảng cuối cùng đã được 'hợp nhất' [thuật ngữ của tôi]

Ở vòng lặp tiếp theo của vòng lặp 'for',

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

1 sẽ là "a" và

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

2 sẽ là "v" nên mã trong khối điều kiện 'if' sẽ không được thực thi. Tương tự cho vòng lặp tiếp theo, đây sẽ là vòng lặp cuối cùng

Ví dụ, nếu mảng được thay đổi thành ______25, thì sau khi sắp xếp[], nó sẽ trở thành

const totalsSum = {
    key1: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.gross]
    ], 0],
    key2: totals.reduce[[totalsAcc, currentTotalsItem] => [
        totalsAcc + computeVal[currentTotalsItem.num || 0, currentTotalsItem.net]
    ], 0],
};

70. Vòng lặp đầu tiên của vòng lặp 'for' sẽ hoạt động như trước và hai phần tử sẽ được 'hợp nhất'. Trong vòng lặp thứ hai,

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

1 và

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

2 sẽ khác nhau nên khối điều kiện 'if' sẽ không được thực thi. Trong vòng lặp thứ ba, cả

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

1 và

const totalsSum = {
    key1: totals
        .map[[{ num = 0, gross }] => computeVal[num, gross]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
    key2: totals
        .map[[{ num = 0, net }] => computeVal[num, net]]
        .reduce[[totalsAcc, x] => totalsAcc + x, 0],
};

2 sẽ là “s” nên các phần tử mảng sẽ được ‘hợp nhất’

Làm cách nào để tính tổng hai đối tượng trong JavaScript?

Làm cách nào để tổng hợp mảng giá trị đối tượng trong JavaScript?

Khóa đối tượng có thể là số trong JS không?

Làm cách nào để đếm giá trị đối tượng trong JavaScript?