Javascript 使用sort（）方法比较两个数组

我有下一个应该比较数组的代码

功能比较（arr）{
const sorted=arr.sort（（a，b）=>a-b）；
const unsorted=arr.join（'，'）
console.log（排序==unsorted）//true
}
比较（[1,16,7]）

尝试使用spread Operator复制阵列

请注意，数组是就地排序的，不进行复制

功能比较（arr）{
const sorted=[…arr].sort（（a，b）=>a-b.join（'，'）；
const unsorted=arr.join（'，'）
console.log（排序==unsorted）//true
}
比较（[1,16,7]）

尝试使用spread Operator复制阵列

请注意，数组是就地排序的，不进行复制

功能比较（arr）{
const sorted=[…arr].sort（（a，b）=>a-b.join（'，'）；
const unsorted=arr.join（'，'）
console.log（排序==unsorted）//true
}
比较（[1,16,7]）

原因是您正在比较相同的字符串。 怎么是同一根弦？好的，

.sort（）

就地排序-这意味着它不会返回新的排序数组，但相同的数组只会被排序。因此，对于

unsorted

，您将加入相同的排序数组。

---

您可以尝试切换赋值顺序，结果应该不同，原因是您正在比较相同的字符串。 怎么是同一根弦？好的，

.sort（）

就地排序-这意味着它不会返回新的排序数组，但相同的数组只会被排序。因此，对于

unsorted

，您将加入相同的排序数组。

---

您可以尝试切换分配的顺序，结果应根据MDN有所不同。

sort（）

将修改原始数组！

---

根据MDN

排序（）

将修改原始数组！

---

由于您正在对数组进行排序，因此几乎不可能检查它们是否相等。 如果您不想检查存在的所有值是否与两个数组相同，您可以尝试这样的方法

    function compare(arr) {
    const unsorted = arr.slice()
    const sorted = arr.sort((a,b)=> a -b)

    console.log(sorted)
    console.log(unsorted)

    if(checkIfValuesAreEqual(sorted, unsorted))
        console.log("they are equal")
    else
        console.log("they are not equal")
}

checkIfValuesAreEqual = (sorted, unsorted) => {
    if(sorted.length != unsorted.length)
        return false

    let sortedObj = {}
    let unsortedObj = {}

    for(const value of sorted){
        if(value in sortedObj)
            sortedObj[value] += 1
        else
            sortedObj[value] = 1
    }

    for(const value of unsorted){
        if(value in unsortedObj)
            unsortedObj[value] += 1
        else
            unsortedObj[value] = 1    
    }

    const keysSorted = Object.keys(sortedObj)
    const keysUnSorted = Object.keys(unsortedObj)


    if(keysSorted.length != keysUnSorted.length)
        return false


    for(const key of keysSorted){
        if(sortedObj[key] != unsortedObj[key])
            return false
    }

    return true

}

compare([1, 16, 7])

必须更改一些内容，如unsorted=arr.slice（），Javascript通过引用放置所有内容，因此未排序的n个排序都是相同的。要检查两者是否相同，我需要进行循环，以便将它们作为数组而不是字符串

---

我认为如果一个字符串已排序，另一个未排序，则无法比较两个字符串，因为某些值交换位置。

由于您正在对数组进行排序，因此几乎不可能检查它们是否相等。 如果您不想检查存在的所有值是否与两个数组相同，您可以尝试这样的方法

    function compare(arr) {
    const unsorted = arr.slice()
    const sorted = arr.sort((a,b)=> a -b)

    console.log(sorted)
    console.log(unsorted)

    if(checkIfValuesAreEqual(sorted, unsorted))
        console.log("they are equal")
    else
        console.log("they are not equal")
}

checkIfValuesAreEqual = (sorted, unsorted) => {
    if(sorted.length != unsorted.length)
        return false

    let sortedObj = {}
    let unsortedObj = {}

    for(const value of sorted){
        if(value in sortedObj)
            sortedObj[value] += 1
        else
            sortedObj[value] = 1
    }

    for(const value of unsorted){
        if(value in unsortedObj)
            unsortedObj[value] += 1
        else
            unsortedObj[value] = 1    
    }

    const keysSorted = Object.keys(sortedObj)
    const keysUnSorted = Object.keys(unsortedObj)


    if(keysSorted.length != keysUnSorted.length)
        return false


    for(const key of keysSorted){
        if(sortedObj[key] != unsortedObj[key])
            return false
    }

    return true

}

compare([1, 16, 7])

必须更改一些内容，如unsorted=arr.slice（），Javascript通过引用放置所有内容，因此未排序的n个排序都是相同的。要检查两者是否相同，我需要进行循环，以便将它们作为数组而不是字符串

我认为，如果一个字符串已排序，而另一个未排序，则无法比较两个字符串，因为有些值会交换位置。

会就地排序。因此，在排序之前加入数组：

功能比较（arr）{
const unsorted=arr.join（'，'）；//上移
const sorted=arr.sort（（a，b）=>a-b）；
console.log（排序==未排序）//false
}
比较（[1,16,7]）

适当排序。因此，在排序之前加入数组：

功能比较（arr）{
const unsorted=arr.join（'，'）；//上移
const sorted=arr.sort（（a，b）=>a-b）；
console.log（排序==未排序）//false
}
比较（[1,16,7]）

我很确定排序会更改原始数组。旁注：如果您想检查数组是否已排序，那么有更有效的方法可以做到这一点：）@evolutionxbox，我也这么认为，但为什么？或者即使在函数内部我会调用

console.log（arr）

，我还将有一个排序数组。@AskMen因为array.prototype.sort（）是就地方法，意味着它会影响原始数组。我很确定排序会更改原始数组。旁注：如果你想检查数组是否已排序，那么有更有效的方法：）@evolutionxbox，我也这么认为，但为什么？，或者，即使在函数内部我将调用

console.log（arr）

，我也将有一个排序数组。@AskMen因为array.prototype.sort（）是就地方法，意味着它会影响它正在处理的原始数组。为了清楚起见，“就地排序”意味着原始数组被修改

array.sort（…）

与

array=array.sort（…）

具有相同的效果，这可能导致意外设置原始变量。为清楚起见，“就地排序”表示修改原始数组

array.sort（…）

与

array=array.sort（…）

具有相同的效果，这可能导致意外设置原始变量。