Giảm chức năng trong python

Giảm javascript - Qua một cuộc khảo sát về độ khó của các phương pháp thì 90% câu trả lời chính là phương pháp giảm. Không quá bất ngờ, bời vì công dụng giảm thiểu gây hiểu nhầm nhất, và gây cũng khó hiểu nhất trong các phương pháp. Lý do vì sao?

Nói về Giảm thì thật ra đây là một phương pháp được những devjs nhiều kinh nghiệm hay sử dụng nhiều nhất, bởi vì nó có thể thay thế cho nhiều phương pháp khác mà tôi sắp trình bày dưới đây. Cho dù trong bất kỳ khung cảnh nào, ý tôi ở đây là có thể có nhiều trường hợp không thể sử dụng map() hoặc filter(), vậy giảm thay thế là một phương pháp tuyệt vời.  

Qua bài viết về "Mổ xẻ cú pháp rút gọn javascript" thì ở đó bất cứ bạn nào cũng đã hiểu về phương pháp rút gọn cú pháp rồi đấy. Và bây giờ dưới đây sẽ có 25 cách sử dụng reduce trong thực tế để lập trình javascript. Đừng bỏ qua nó, chỉ vì giảm bớt khó sử dụng, hay xem đây

Giảm trong Javascript - 25 cách sử dụng

Có thể sắp xếp các dây bên dưới không phù hợp với mỗi thiết lập mà bạn có thể tùy chỉnh cho các nhân của bạn nếu cần thiết

Tính tổng và tích của mảng sử dụng rút gọn javascript

function Accumulation(...vals) {
    return vals.reduce((t, v) => t + v, 0);
}

function Multiplication(...vals) {
    return vals.reduce((t, v) => t * v, 1);
}

Accumulation(1, 2, 3, 4, 5); // 15
Multiplication(1, 2, 3, 4, 5); // 120

Giảm thay thế Đảo ngược()

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

giảm thay thế bản đồ() hoặc bộ lọc()

const arr = [0, 1, 2, 3];

//map: [0, 2, 4, 6]
const a = arr.map(v => v * 2);
const b = arr.reduce((t, v) => [...t, v * 2], []);

//filter: [2, 3]
const c = arr.filter(v => v > 1);
const d = arr.reduce((t, v) => v > 1 ? [...t, v] : t, []);

// reduce chấp cả hai map + fitler
const e = arr.map(v => v * 2).filter(v => v > 2);
const f = arr.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, []);

giảm thay thế some() hoặc every()

const scores = [
    { score: 45, subject: "chinese" },
    { score: 90, subject: "math" },
    { score: 60, subject: "english" }
];

//some
const isAtLeastOneQualified = scores.reduce((t, v) => t || v.score >= 60, false); // true

//every
const isAllQualified = scores.reduce((t, v) => t && v.score >= 60, true); // false

mảng khối

function Chunk(arr = [], size = 1) {
    return arr.length ? arr.reduce((t, v) => (t[t.length - 1].length === size ? t.push([v]) : t[t.length - 1].push(v), t), [[]]) : [];
}

const arr = [1, 2, 3, 4, 5];
Chunk(arr, 2); // [[1, 2], [3, 4], [5]]

sử dụng giảm tìm phần tử khác nhau giữa hai mảng

function Difference(arr = [], oarr = []) {
    return arr.reduce((t, v) => (!oarr.includes(v) && t.push(v), t), []);
}

const arr1 = [1, 2, 3, 4, 5];
const arr2 = [2, 3, 6]
Difference(arr1, arr2); // [1, 4, 5]

Chèn phần từ vào một mảng cho trước khi sử dụng giảm

function Fill(arr = [], val = "", start = 0, end = arr.length) {
    if (start < 0 || start >= end || end > arr.length) return arr;
    return [
        ...arr.slice(0, start),
        ...arr.slice(start, end).reduce((t, v) => (t.push(val || v), t), []),
        ...arr.slice(end, arr.length)
    ];
}
const arr = [0, 1, 2, 3, 4, 5, 6];
Fill(arr, "aaa", 2, 5); // [0, 1, "aaa", "aaa", "aaa", 5, 6]

Làm phẳng một mảng sử dụng giảm

function Flat(arr = []) {
    return arr.reduce((t, v) => t.concat(Array.isArray(v) ? Flat(v) : v), [])
}
const arr = [0, 1, [2, 3], [4, 5, [6, 7]], [8, [9, 10, [11, 12]]]];
Flat(arr); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Mảng lặp lại phần tử sử dụng giảm

________số 8

Giảm thay thế max() và min()

function Max(arr = []) {
    return arr.reduce((t, v) => t > v ? t : v);
}

function Min(arr = []) {
    return arr.reduce((t, v) => t < v ? t : v);
}
const arr = [12, 45, 21, 65, 38, 76, 108, 43];
Max(arr); // 108
Min(arr); // 12

Tách phần tử trong Array theo đúng loại

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

0

Đếm số lượng giống nhau trong một mảng sử dụng recude

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

1

nhóm theo cách sử dụng giảm

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

2

Thống kê xem các từ khóa có trong mảng hay không?

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

3

Reducation the number of composit

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

4

Phân tích cú pháp sử dụng url giảm

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

5

Phân tích một đối tượng sang url params

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

6

Get value of key of a Object for before

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

7

Chuyển đổi một đối tượng mảng sang đối tượng sử dụng giảm

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

8

Hiệu suất khi sử dụng javascript giảm

Có nhiều câu hỏi tôi thường thấy và cũng có nhiều câu hỏi tương tự như vậy đó là hiệu quả khi thay thế giảm như thế nào khi sử dụng. Câu trả lời là khó nhận biết, bởi vì nó tùy thuộc và trường hợp bạn sử dụng, vào hoàn cảnh. Nhưng tôi có thể lấy một ví dụ dưới đây bằng cách sử dụng 4 phương pháp đó là

const arr = [0, 1, 2, 3];

//map: [0, 2, 4, 6]
const a = arr.map(v => v * 2);
const b = arr.reduce((t, v) => [...t, v * 2], []);

//filter: [2, 3]
const c = arr.filter(v => v > 1);
const d = arr.reduce((t, v) => v > 1 ? [...t, v] : t, []);

// reduce chấp cả hai map + fitler
const e = arr.map(v => v * 2).filter(v => v > 2);
const f = arr.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, []);

0,

const arr = [0, 1, 2, 3];

//map: [0, 2, 4, 6]
const a = arr.map(v => v * 2);
const b = arr.reduce((t, v) => [...t, v * 2], []);

//filter: [2, 3]
const c = arr.filter(v => v > 1);
const d = arr.reduce((t, v) => v > 1 ? [...t, v] : t, []);

// reduce chấp cả hai map + fitler
const e = arr.map(v => v * 2).filter(v => v > 2);
const f = arr.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, []);

1,______22 và

const arr = [0, 1, 2, 3];

//map: [0, 2, 4, 6]
const a = arr.map(v => v * 2);
const b = arr.reduce((t, v) => [...t, v * 2], []);

//filter: [2, 3]
const c = arr.filter(v => v > 1);
const d = arr.reduce((t, v) => v > 1 ? [...t, v] : t, []);

// reduce chấp cả hai map + fitler
const e = arr.map(v => v * 2).filter(v => v > 2);
const f = arr.reduce((t, v) => v * 2 > 2 ? [...t, v * 2] : t, []);

3.

function Reverse(arr = []) {
    return arr.reduceRight((t, v) => (t.push(v), t), []);
}
Reverse([1, 2, 3, 4, 5]); // [5, 4, 3, 2, 1]

9

Kết quả kiểm tra

cho vòng lặp javascript

giảm vòng lặp javascript

bản đồ javascript

Và kết quả hình ảnh cho ta thấy giảm trong trường hợp này là có hiệu quả tốt hơn hẳn. Chính vì vậy tôi cũng đã nói nó phụ thuộc vào nhiều yếu tố hay kỹ năng của bạn. Ví dụ bạn khai báo độ dài trước khi sử dụng cho kết quả có thể cho khác đấy. Chú ý kết quả kiểm tra trên bảng điều khiển chrome 83. Macbook 2019. Chú ý kết quả kiểm tra trên bảng điều khiển chrome 83. Macbook 2019 .

Vì vậy, rất nhiều bài viết về "giảm javascript" và có thể đến đây là bạn có thể nhẹ nhàng thở khi vào một trường hợp nào đó bắt buộc bạn phải sử dụng giảm trong ứng dụng của bạn. Bài viết chỉ khám phá bản thân cũng như tổng hợp kiến ​​thức. Nếu bạn có câu hỏi hay có ý kiến ​​gì thì vui lòng pm vào fan page tips javascript. cảm ơn đã đọc bài viết