Làm cách nào để lấy các đối tượng duy nhất từ ​​hai mảng trong JavaScript?

Không giới thiệu thêm, chúng ta hãy đi sâu vào các giải pháp. sử dụng Array.prototype.reduce VÀ (

const uniqueArray = (array) => {
    return Array.from(
        array.reduce((set, e) => set.add(e), new Set())
    )
}

console.log(uniqueArray([1,2,2,3,3,3])) // [1, 2, 3]

//OR simply
const uniqueArray = (array) => Array.from(new Set(array))

0 cho các giá trị nguyên thủy HOẶC

const uniqueArray = (objects, uniqueBy, keepFirst = true) => {
    return Array.from(
        objects.reduce((map, e) => {
            let key = uniqueBy.map(key => [e[key], typeof e[key]]).flat().join('-')
            if (keepFirst && map.has(key)) return map
            return map.set(key, e)
        }, new Map()).values()
    )
}

let array = [
    {a: 1, b: 2, c: 1},
    {a: 1, b: 2, c: 2},
    {a: 1, b: 3, c: 3}
]

console.log(uniqueArray(array, ["a"], true)) // [ { a: 1, b: 2, c: 1 } ]
console.log(uniqueArray(array, ["a"], false)) // [ { a: 1, b: 3, c: 3 } ]
console.log(uniqueArray(array, ["a", "b"], true)) // [ { a: 1, b: 2, c: 1 }, { a: 1, b: 3, c: 3 } ]
console.log(uniqueArray(array, ["a", "b"], false)) // [ { a: 1, b: 2, c: 2 }, { a: 1, b: 3, c: 3 } ]

0 cho các đối tượng)

Đây là mã.
Đối với một mảng các giá trị nguyên thủy

const uniqueArray = (array) => {
    return Array.from(
        array.reduce((set, e) => set.add(e), new Set())
    )
}

console.log(uniqueArray([1,2,2,3,3,3])) // [1, 2, 3]

//OR simply
const uniqueArray = (array) => Array.from(new Set(array))

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Đối với một mảng các đối tượng

const uniqueArray = (objects, uniqueBy, keepFirst = true) => {
    return Array.from(
        objects.reduce((map, e) => {
            let key = uniqueBy.map(key => [e[key], typeof e[key]]).flat().join('-')
            if (keepFirst && map.has(key)) return map
            return map.set(key, e)
        }, new Map()).values()
    )
}

let array = [
    {a: 1, b: 2, c: 1},
    {a: 1, b: 2, c: 2},
    {a: 1, b: 3, c: 3}
]

console.log(uniqueArray(array, ["a"], true)) // [ { a: 1, b: 2, c: 1 } ]
console.log(uniqueArray(array, ["a"], false)) // [ { a: 1, b: 3, c: 3 } ]
console.log(uniqueArray(array, ["a", "b"], true)) // [ { a: 1, b: 2, c: 1 }, { a: 1, b: 3, c: 3 } ]
console.log(uniqueArray(array, ["a", "b"], false)) // [ { a: 1, b: 2, c: 2 }, { a: 1, b: 3, c: 3 } ]

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Lý do chúng tôi cần sử dụng

const uniqueArray = (array) => {
    return Array.from(
        array.reduce((set, e) => set.add(e), new Set())
    )
}

console.log(uniqueArray([1,2,2,3,3,3])) // [1, 2, 3]

//OR simply
const uniqueArray = (array) => Array.from(new Set(array))

0 và

const uniqueArray = (objects, uniqueBy, keepFirst = true) => {
    return Array.from(
        objects.reduce((map, e) => {
            let key = uniqueBy.map(key => [e[key], typeof e[key]]).flat().join('-')
            if (keepFirst && map.has(key)) return map
            return map.set(key, e)
        }, new Map()).values()
    )
}

let array = [
    {a: 1, b: 2, c: 1},
    {a: 1, b: 2, c: 2},
    {a: 1, b: 3, c: 3}
]

console.log(uniqueArray(array, ["a"], true)) // [ { a: 1, b: 2, c: 1 } ]
console.log(uniqueArray(array, ["a"], false)) // [ { a: 1, b: 3, c: 3 } ]
console.log(uniqueArray(array, ["a", "b"], true)) // [ { a: 1, b: 2, c: 1 }, { a: 1, b: 3, c: 3 } ]
console.log(uniqueArray(array, ["a", "b"], false)) // [ { a: 1, b: 2, c: 2 }, { a: 1, b: 3, c: 3 } ]

0 là vì hiệu suất. Bạn có thể đã bắt gặp nhiều cách triển khai để nhận các giá trị duy nhất từ ​​một mảng trong Javascript. Nhiều người trong số họ sẽ trông như thế này

• Tạo một mảng mới, kiểm tra nếu phần tử không có trong mảng mới thì đẩy nó vào mảng mới hoặc

let array = [1,2,2,3,3,3]
let uniqueArray = []

array.forEach(e => {
   if (!uniqueArray.includes(e)) uniqueArray.push(e)
})

console.log(uniqueArray) // [1, 2, 3]

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

• Sử dụng bộ lọc, kiểm tra xem phần tử có xuất hiện lần đầu tiên trong mảng không thì giữ nguyên hoặc

let array = [1,2,2,3,3,3]
let uniqueArray = array.filter((e, index) => array.indexOf(e) === index)

console.log(uniqueArray) // [1, 2, 3]

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

• Sử dụng rút gọn, kiểm tra xem phần tử không có trong mảng mới hay không, sau đó sử dụng hủy mảng với phần tử mới

let array = [1,2,2,3,3,3]
let uniqueArray = array.reduce((newArray, e) => {
    if (newArray.includes(e)) return newArray;
    return [...newArray, e]
}, [])

console.log(uniqueArray) // [1, 2, 3]

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Vấn đề là. họ chậm. Hãy làm một điểm chuẩn nhanh. Điểm chuẩn bên dưới tạo 5 mảng với 100.000 phần tử mỗi mảng. Mảng đầu tiên chứa tất cả các phần tử duy nhất. Mảng thứ 2 mỗi phần tử xuất hiện 2 lần. Mảng thứ ba có mỗi phần tử xuất hiện 3 lần, v.v. Tất cả các mảng được xáo trộn trước khi nhận được các giá trị duy nhất. Chúng ta sẽ sử dụng các phương thức khác nhau để lấy các giá trị duy nhất trong mảng

const usePush = (array) => {
    let uniqueArray = []
    array.forEach(e => {
        if (!uniqueArray.includes(e)){
            uniqueArray.push(e)
        }
    })
    return uniqueArray
}

const useFilter = (array) => {
    return array.filter((e, index) => array.indexOf(e) === index)
}

const useReduceDestruct = (array) => {
    return array.reduce((pre, cur) => {
        if (pre.includes(cur)) return pre;
        return [...pre, cur]
    }, [])
}

const useReduceSet = (array) => {
    return Array.from(
        array.reduce((set, e) => set.add(e), new Set())
    )
}

//Create 5 big arrays with different number of duplicates for each element
let bigArrays = [1,2,3,4,5].map(duplicates => {
    //duplicates = 1 means the array is unique
    //duplicates = 2 means each element appears 2 times, and so on
    return new Array(100000).fill(0)
        .map((_, i) => ({
            rand : Math.random(),
            value : i - i % duplicates
        }))
        .sort((a,b) => a.rand - b.rand)//the array is random shuffled
        .map(e => e.value)
})

bigArrays.forEach((array, index) =>{
    console.log(`${index + 1} duplicate(s):`);

    [usePush, useFilter, useReduceDestruct, useReduceSet].forEach(fn =>{
        let startTime = Date.now()
        fn(array)
        console.log(`${fn.name}${' '.repeat(20 - fn.name.length)} finished in ${((Date.now() - startTime)/1000).toFixed(3)} seconds`)
    })
})

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

đầu ra

________số 8

Vào chế độ toàn màn hình Thoát chế độ toàn màn hình

Rõ ràng là chúng ta càng có nhiều bản sao trong mảng, mã chạy càng nhanh. Rõ ràng là sử dụng Array.prototype.reduce và

const uniqueArray = (array) => {
    return Array.from(
        array.reduce((set, e) => set.add(e), new Set())
    )
}

console.log(uniqueArray([1,2,2,3,3,3])) // [1, 2, 3]

//OR simply
const uniqueArray = (array) => Array.from(new Set(array))

0 là nhanh nhất trong số tất cả

Làm cách nào để lấy các đối tượng duy nhất từ ​​2 mảng trong JavaScript?

Làm cách nào để nhận các giá trị duy nhất từ ​​​​mảng trong JavaScript?

Làm cách nào để in các phần tử duy nhất trong hai mảng trong Java?

Làm cách nào để có được sự khác biệt giữa hai mảng đối tượng trong JavaScript?