You can use Array#map with Array#find.

arr1.map(obj => arr2.find(o => o.id === obj.id) || obj);

Show code snippet

var arr1 = [{
    id: '124',
    name: 'qqq'
}, {
    id: '589',
    name: 'www'
}, {
    id: '45',
    name: 'eee'
}, {
    id: '567',
    name: 'rrr'
}];

var arr2 = [{
    id: '124',
    name: 'ttt'
}, {
    id: '45',
    name: 'yyy'
}];

var res = arr1.map(obj => arr2.find(o => o.id === obj.id) || obj);

console.log(res);

Here, arr2.find(o => o.id === obj.id) will return the element i.e. object from arr2 if the id is found in the arr2. If not, then the same element in arr1 i.e. obj is returned.

You're not using assignment. As Doc explains, forEach run the provided function for each element, and your function simply return a boolean if x.DataSource exist, a string otherwise.

If your goal is to change your array you can either modify your function with an assignment:

this.localData.forEach(x =>  {
   x.DataSource = x.DataSource ? '' || 'XXX' : 'MyVAL'
});

or simply use the map function

this.localData = this.localData.map( item => {
   item.DataSource = item.DataSource ? '' || 'XXX' : 'MyVAL'
   return item;
});

Clarification: in your code line

this.localData.forEach(x => x.DataSource ? '' || 'XXX' : 'MyVAL');

the ternary operator is gonna return 'MyVAL' if x.DataSource is undefined or the empty string, and always 'XXX' if all the other cases. If i get it right, you want to do something like:

x.DataSource && x.DataSource !== 'XXX' ? 'MyVAL' : x.DataSource;

which can be read as: if DataSource is evaluated and it's different from 'XXX' assign 'MyVal', keep it as it is otherwise.

EDIT: clarification

You can use Array#map with Array#find.

arr1.map(obj => arr2.find(o => o.id === obj.id) || obj);

Show code snippet

var arr1 = [{
    id: '124',
    name: 'qqq'
}, {
    id: '589',
    name: 'www'
}, {
    id: '45',
    name: 'eee'
}, {
    id: '567',
    name: 'rrr'
}];

var arr2 = [{
    id: '124',
    name: 'ttt'
}, {
    id: '45',
    name: 'yyy'
}];

var res = arr1.map(obj => arr2.find(o => o.id === obj.id) || obj);

console.log(res);

Here, arr2.find(o => o.id === obj.id) will return the element i.e. object from arr2 if the id is found in the arr2. If not, then the same element in arr1 i.e. obj is returned.

It can be done cleanly in a single loop with reduce. Note this returns a new array, it won't mutate the original. But you can always reassign arr to the new one if you want.

With reduce you can access the current accumulation which is very useful here as you can get the previous rolling value to build on for each item.

const arrayWithSummary = arr.reduce((summary, currentLineItem, index) => {
    return [...summary, { ...currentLineItem, newBalance: currentLineItem.value + (summary?.[index - 1]?.newBalance ?? 0)}]
}, [])

The result is in arrayWithSummary.

Some notes:

1. With map, you return the object you want the new array to contain. Assigning to the parameter e just changes the value of the parameter, which isn't retained anywhere.

2. There's no need for Object.assign there, just create the object directly, so:

   const replaced = album.songs.map(e => { return { _id : e }; } );
   

   or the concise form:

   const replaced = album.songs.map(e => ({ _id : e }) );
   

   Note that since we want to return an object created with an object initializer, and the { in the initializer would start a function body, we wrap the value we want to return in ().

3. We can even take advantage of shorthand property notation if we change the name of the parameter to _id:

   const replaced = album.songs.map(_id => ({ _id }) );
   

Live Example:

Show code snippet

const album = {songs: [1234545, 43524]};
const replaced = album.songs.map(_id => ({ _id }) );
console.log(replaced);

var index = items.indexOf(3452);

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

Also it is recommend you not use the constructor method to initialize your arrays. Instead, use the literal syntax:

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

You can also use the ~ operator if you are into terse JavaScript and want to shorten the -1 comparison:

var index = items.indexOf(3452);

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

Sometimes I even like to write a contains function to abstract this check and make it easier to understand what's going on. What's awesome is this works on arrays and strings both:

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

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

Starting with ES6/ES2015 for strings, and proposed for ES2016 for arrays, you can more easily determine if a source contains another value:

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