小开

使用for循环很容易完成。

for (var i = 0; i < items.length; i++)
if (items[i] == 3452)
items[i] = 1010;

小开

使用indexOf查找元素。

var i = items.indexOf(3452);
items[i] = 1010;

小开

您可以使用索引编辑列表中的任意数量

例如:

items[0] = 5;
items[5] = 100;

小开

最佳答案

var index = items.indexOf(3452);


if (index !== -1) {
items[index] = 1010;
}

另外，建议不要使用构造函数方法来初始化数组。相反，使用文字语法:

var items = [523, 3452, 334, 31, 5346];

如果你喜欢简洁的JavaScript，想要缩短-1的比较，你也可以使用~操作符:

var index = items.indexOf(3452);


if (~index) {
items[index] = 1010;
}

有时我甚至喜欢写一个contains函数来抽象这个检查，使它更容易理解发生了什么。令人惊叹的是，这对数组和字符串都有效:

var contains = function (haystack, needle) {
return !!~haystack.indexOf(needle);
};


// can be used like so now:
if (contains(items, 3452)) {
// do something else...
}

从字符串的ES6/ES2015开始，到数组的ES2016建议，你可以更容易地确定一个源是否包含另一个值:

if (haystack.includes(needle)) {
// do your thing
}

小开

Array.indexOf()方法将替换第一个实例。要获取每个实例，请使用Array.map():

a = a.map(function(item) { return item == 3452 ? 1010 : item; });

当然，这会创建一个新数组。如果你想在适当的地方做，使用Array.forEach():

a.forEach(function(item, i) { if (item == 3452) a[i] = 1010; });

小开

最简单的方法是使用一些库，如underscorejs和map方法。

var items = Array(523,3452,334,31,...5346);


_.map(items, function(num) {
return (num == 3452) ? 1010 : num;
});
=> [523, 1010, 334, 31, ...5346]

小开

var items = Array(523,3452,334,31,5346);

如果你知道它的价值，

items[items.indexOf(334)] = 1010;

如果你想知道这个值是否存在，那么使用，

var point = items.indexOf(334);


if (point !== -1) {
items[point] = 1010;
}

如果你知道地点(位置)，那么直接使用，

items[--position] = 1010;

如果你想替换一些元素，你知道起始位置只意味着，

items.splice(2, 1, 1010, 1220);

有关.splice的更多信息

小开

首先，像这样重写数组:

var items = [523,3452,334,31,...5346];

接下来，通过索引号访问数组中的元素。确定索引号的公式是:n-1

要替换数组中的第一项(n=1)，写入:

items[0] = Enter Your New Number;

在你的例子中，数字3452位于第二个位置(n=2)。所以确定索引号的公式是2-1 = 1。因此，编写以下代码将3452替换为1010:

items[1] = 1010;

小开

下面是一个可重用函数的基本答案:

function arrayFindReplace(array, findValue, replaceValue){
while(array.indexOf(findValue) !== -1){
let index = array.indexOf(findValue);
array[index] = replaceValue;
}
}

小开

我建议的解决方案是:

items.splice(1, 1, 1010);

拼接操作将从索引1开始，删除数组中的一项(即3452)，并将其替换为新项1010。

小开

我用for循环解决了这个问题，遍历原始数组，并将匹配arreas的位置添加到另一个数组，然后遍历该数组，并在原始数组中更改它，然后返回它，我使用了一个箭头函数，但一个常规函数也可以工作。

var replace = (arr, replaceThis, WithThis) => {
if (!Array.isArray(arr)) throw new RangeError("Error");
var itemSpots = [];
for (var i = 0; i < arr.length; i++) {
if (arr[i] == replaceThis) itemSpots.push(i);
}


for (var i = 0; i < itemSpots.length; i++) {
arr[itemSpots[i]] = WithThis;
}


return arr;
};

小开

如果使用一个复杂的对象(甚至是一个简单的对象)并且可以使用es6， Array.prototype.findIndex是一个很好的对象。对于OP的数组，他们可以这样做，

const index = items.findIndex(x => x === 3452)
items[index] = 1010

对于更复杂的对象，这真的很管用。例如,

const index =
items.findIndex(
x => x.jerseyNumber === 9 && x.school === 'Ohio State'
)


items[index].lastName = 'Utah'
items[index].firstName = 'Johnny'

小开

替换可以在一行中完成:

var items = Array(523, 3452, 334, 31, 5346);


items[items.map((e, i) => [i, e]).filter(e => e[1] == 3452)[0][0]] = 1010


console.log(items);

或者创建一个函数来重用:

Array.prototype.replace = function(t, v) {
if (this.indexOf(t)!= -1)
this[this.map((e, i) => [i, e]).filter(e => e[1] == t)[0][0]] = v;
};


//Check
var items = Array(523, 3452, 334, 31, 5346);
items.replace(3452, 1010);
console.log(items);

小开

使用ES6展开操作符和.slice方法替换列表中元素的不可变方法。

const arr = ['fir', 'next', 'third'], item = 'next'


const nextArr = [
...arr.slice(0, arr.indexOf(item)),
'second',
...arr.slice(arr.indexOf(item) + 1)
]

验证它是否有效

console.log(arr)     // [ 'fir', 'next', 'third' ]
console.log(nextArr) // ['fir', 'second', 'third']

小开

var index = Array.indexOf(Array value);
if (index > -1) {
Array.splice(index, 1);
}

从这里你可以删除一个特定的值从数组和基于相同的索引

 Array.splice(index, 0, Array value);

小开

presentPrompt(id,productqty) {
let alert = this.forgotCtrl.create({
title: 'Test',
inputs: [
{
name: 'pickqty',
placeholder: 'pick quantity'
},
{
name: 'state',
value: 'verified',
disabled:true,
placeholder: 'state',


}
],
buttons: [
{
text: 'Ok',
role: 'cancel',
handler: data => {


console.log('dataaaaname',data.pickqty);
console.log('dataaaapwd',data.state);




for (var i = 0; i < this.cottonLists.length; i++){


if (this.cottonLists[i].id == id){
this.cottonLists[i].real_stock = data.pickqty;


}
}


for (var i = 0; i < this.cottonLists.length; i++){


if (this.cottonLists[i].id == id){
this.cottonLists[i].state = 'verified';


}
}
//Log object to console again.
console.log("After update: ", this.cottonLists)
console.log('Ok clicked');
}
},


]
});
alert.present();
}


As per your requirement you can change fields and array names.
thats all. Enjoy your coding.

小开

最简单的方法是这样。

var items = Array(523,3452,334,31, 5346);
var replaceWhat = 3452, replaceWith = 1010;
if ( ( i = items.indexOf(replaceWhat) ) >=0 ) items.splice(i, 1, replaceWith);


console.log(items);
>>> (5) [523, 1010, 334, 31, 5346]

小开

第一个方法

在一行中替换或更新数组项的最佳方法

array.splice(array.indexOf(valueToReplace), 1, newValue)

例如:

let items = ['JS', 'PHP', 'RUBY'];


let replacedItem = items.splice(items.indexOf('RUBY'), 1, 'PYTHON')


console.log(replacedItem) //['RUBY']
console.log(items) //['JS', 'PHP', 'PYTHON']

第二种方法

另一种简单的方法是:

items[items.indexOf(oldValue)] = newValue

小开

如果有人对如何从数组的下标替换一个对象感兴趣，这里有一个解决方案。

通过id查找对象的索引:

const index = items.map(item => item.id).indexOf(objectId)

使用object .assign()方法替换该对象:

Object.assign(items[index], newValue)

小开

ES6道:

const items = Array(523, 3452, 334, 31, ...5346);

我们想用1010替换3452，解决方案:

const newItems = items.map(item => item === 3452 ? 1010 : item);

当然，这个问题是许多年前的问题，现在我只喜欢使用不可变的解决方案，当然，它对于ReactJS是非常棒的。

为了经常使用，我提供以下功能:

const itemReplacer = (array, oldItem, newItem) =>
array.map(item => item === oldItem ? newItem : item);

小开

这里有一句话。它假设项将在数组中。

var items = [523, 3452, 334, 31, 5346]
var replace = (arr, oldVal, newVal) => (arr[arr.indexOf(oldVal)] = newVal, arr)
console.log(replace(items, 3452, 1010))

小开

如果你想要一个简单的糖纸，你可以:

(elements = elements.filter(element => element.id !== updatedElement.id)).push(updatedElement);

如:

let elements = [ { id: 1, name: 'element one' }, { id: 2, name: 'element two'} ];
const updatedElement = { id: 1, name: 'updated element one' };

如果你没有id，你可以像这样字符串化元素:

(elements = elements.filter(element => JSON.stringify(element) !== JSON.stringify(updatedElement))).push(updatedElement);

小开

来自@gilly3的回答很棒。

替换数组中的对象，保持数组顺序不变

当我从服务器获取数据时，我更喜欢以下方式将新的更新记录更新到我的记录数组中。它保持秩序完整，相当直截了当的一行。

users = users.map(u => u.id !== editedUser.id ? u : editedUser);

var users = [
{id: 1, firstname: 'John', lastname: 'Ken'},
{id: 2, firstname: 'Robin', lastname: 'Hood'},
{id: 3, firstname: 'William', lastname: 'Cook'}
];


var editedUser = {id: 2, firstname: 'Michael', lastname: 'Angelo'};


users = users.map(u => u.id !== editedUser.id ? u : editedUser);


console.log('users -> ', users);

小开

 items[items.indexOf(3452)] = 1010

非常适合简单的交换。试试下面的代码片段

const items = Array(523, 3452, 334, 31, 5346);
console.log(items)


items[items.indexOf(3452)] = 1010
console.log(items)

小开

javascript中替换数组元素的函数式方法:

const replace = (array, index, ...items) => [...array.slice(0, index), ...items, ...array.slice(index + 1)];

小开

当你的数组有许多旧项替换新项时，你可以这样使用:

function replaceArray(array, oldItem, newItem) {
for (let i = 0; i < array.length; i++) {
const index = array.indexOf(oldItem);
if (~index) {
array[index] = newItem;
}
}
return array
}


console.log(replaceArray([1, 2, 3, 2, 2, 8, 1, 9], 2, 5));
console.log(replaceArray([1, 2, 3, 2, 2, 8, 1, 9], 2, "Hi"));

小开

这个就行了

Array.prototype.replace = function(a, b) {
return this.map(item => item == a ? b : item)
}

用法:

let items = ['hi', 'hi', 'hello', 'hi', 'hello', 'hello', 'hi']
console.log(items.replace('hello', 'hi'))

输出:

['hi', 'hi', 'hi', 'hi', 'hi', 'hi', 'hi']

好处是，每个数组都有.replace()属性。

小开

const items = Array(1, 2, 3, 4, 5);
console.log(items)


items[items.indexOf(2)] = 1010
console.log(items)

如何在数组中替换项目?

第一个方法

第二种方法