Javascript 修改数组而不进行变异

我试图解决一个问题，即删除（删除）数组中的最小数，而不改变最小元素左侧元素的顺序。我的代码是-：

function removeSmallest(numbers){
    var x =  Math.min.apply(null,numbers);
    var y = numbers.indexOf(x);
    numbers.splice(y,1);
    return numbers;
}

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

说明书中严格规定了不要改变原始数组/列表。但是我得到一个错误，说明您已经修改了原始数组/列表。

---

如何删除错误

您可以创建数组的浅拷贝以避免变异

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

---

您可以创建数组的浅拷贝以避免变异

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

---

听着，不要在这里使用拼接。当新手和专家在不考虑效果的情况下互换使用拼接和切片时，他们会犯一个众所周知的错误

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

拼接将变异原始数组，而切片将浅拷贝原始数组，并在给定条件下返回数组的部分

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

在这里，Slice将创建一个新数组

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

const slicedArray = numbers.slice()
const result = slicedArray.splice(y,1);

---

您可以在不改变原始数组的情况下得到结果。

听着，这里不要使用拼接。当新手和专家在不考虑效果的情况下互换使用拼接和切片时，他们会犯一个众所周知的错误

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

拼接将变异原始数组，而切片将浅拷贝原始数组，并在给定条件下返回数组的部分

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

在这里，Slice将创建一个新数组

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

const slicedArray = numbers.slice()
const result = slicedArray.splice(y,1);

---

在不改变原始数组的情况下得到结果。

首先使用创建数组的副本，然后拼接该副本

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

function removeSmallest(numbers){
    var x =  Math.min.apply(null,numbers);
    var y = numbers.indexOf(x);
    return numbers.slice().splice(y,1);
}

---

首先使用创建阵列的副本，然后拼接该副本

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

function removeSmallest(numbers){
    var x =  Math.min.apply(null,numbers);
    var y = numbers.indexOf(x);
    return numbers.slice().splice(y,1);
}

---

让我们集中讨论如何避免变异（我希望你不是指“删除错误”作为“Superss错误消息”或类似的东西）

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

在

数组上有不同的方法。prototype

和大多数不变异数组，但返回新数组作为结果。例如.map、.slice、.filter、.reduce

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

说真话只是很少的变异（比如.splice）

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

所以，根据您可能发现的其他要求，say.map很有用

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

 let newArray = oldArray.filter(el => el !== minimalElementValue);

或者，地图

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

 let newArray = oldArray.map(el => el === minimalElementValue? undefined: el);

---

当然，它们并不相等，但都不会对原始变量进行变异。让我们重点讨论如何避免变异（我希望你不是说“删除错误”是“Superss错误消息”之类的）

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

在

数组上有不同的方法。prototype

和大多数不变异数组，但返回新数组作为结果。例如.map、.slice、.filter、.reduce

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

说真话只是很少的变异（比如.splice）

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

所以，根据您可能发现的其他要求，say.map很有用

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

 let newArray = oldArray.filter(el => el !== minimalElementValue);

或者，地图

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

 let newArray = oldArray.map(el => el === minimalElementValue? undefined: el);

---

当然，它们并不相等，但都不会对原始变量进行变异。我不确定问题的确切背景是什么，但目标可能是学习编写纯数据转换，而不是学习如何复制数组。如果是这种情况，在制作阵列的一次性副本后使用

splice

，可能无法剪切阵列

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

既不改变原始数组也不改变其副本的方法可能如下所示：确定数组最小元素的索引，然后返回该点左右两个子列表的串联：

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

const minIndex=arr=>
arr.reduce(
（p，c，i）=>（p==未定义的？i:c{
常数i=最小索引（arr）；
返回minIndex==未定义
？arr
：[…arr.slice（0，i），…arr.slice（i+1）]；
};
log（removeMin（[1,5,6,0,11]）我不确定问题的确切背景是什么，但目标可能是学习编写纯数据转换，而不是学习如何复制数组。如果是这种情况，在制作阵列的一次性副本后使用
splice
，可能无法剪切阵列

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

既不改变原始数组也不改变其副本的方法可能如下所示：确定数组最小元素的索引，然后返回该点左右两个子列表的串联：

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}


const minIndex=arr=>
arr.reduce(
（p，c，i）=>（p==未定义的？i:c{
常数i=最小索引（arr）；
返回minIndex==未定义
？arr
：[…arr.slice（0，i），…arr.slice（i+1）]；
};
log（removeMin（[1,5,6,0,11]）
array.slice（）
和
[…array]
将创建数组对象的浅层副本

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

“肤浅”“这个词本身就是这么说的。
在我看来，复制阵列对象的解决方案是：

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

var array_copy = copy(array);

// copy function
function copy(object) {
    var output, value, key;
    output = Array.isArray(object) ? [] : {};
    for (key in object) {
        value = object[key];
        output[key] = (typeof value === "object") ? copy(value) : value;
    }
    return output;
}

更新

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

替代解决方案是：-

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

var arr_copy = JSON.parse(JSON.stringify(arr));

array.slice（）

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

“肤浅”“这个词本身就是这么说的。
在我看来，复制阵列对象的解决方案是：

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

var array_copy = copy(array);

// copy function
function copy(object) {
    var output, value, key;
    output = Array.isArray(object) ? [] : {};
    for (key in object) {
        value = object[key];
        output[key] = (typeof value === "object") ? copy(value) : value;
    }
    return output;
}

更新

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

替代解决方案是：-

function removeSmallest(numbers){
    const newNumbers = [...numbers];

    var x =  Math.min.apply(null,newNumbers);
    var y = newNumbers.indexOf(x);
    newNumbers.splice(y,1);

    return newNumbers;
}

var arr_copy = JSON.parse(JSON.stringify(arr));

splice
将变异数组，我认为这就是您的解决方案被拒绝的原因。为了避免对原始数组进行变异，您需要将解决方案表示为从原始数组中构建一个新数组，即sans最小元素。如何在不变异列表的情况下删除一个数字？这个要求对我来说没有意义。删除某个元素几乎总是会改变被删除元素之后的所有内容的位置。我感觉“元素的位置”可能意味着“元素的顺序”？也许“删除”意味着用非数字的东西替换数字，例如
null
或
NaN
？这将保留剩余值的原始顺序和位置。
splice
将变异数组，我认为这就是您的解决方案被拒绝的原因。为了避免对原始数组进行变异，您需要将解决方案表示为从原始数组中构建一个新数组，即sans最小元素。如何在不变异列表的情况下删除一个数字