You have to search in the array like:

function changeDesc( value, desc ) {
   for (var i in projects) {
     if (projects[i].value == value) {
        projects[i].desc = desc;
        break; //Stop this loop, we found it!
     }
   }
}

and use it like

var projects = [ ... ];
changeDesc ( 'jquery-ui', 'new description' );

UPDATE:

To get it faster:

var projects = {
   jqueryUi : {
      value:  'lol1',
      desc:   'lol2'
   }
};

projects.jqueryUi.desc = 'new string';

(In according to Frédéric's comment you shouldn't use hyphen in the object key, or you should use "jquery-ui" and projects["jquery-ui"] notation.)

The Array.indexOf() method will replace the first instance. To get every instance use Array.map():

a = a.map(item => item == 3452 ? 1010 : item);

Of course, that creates a new array. If you want to do it in place, use Array.forEach():

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

You could use Array.reduce to copy the array with the new devices disabled:

const devices = [ /* ... */ ];

const newDevices = devices.reduce((ds, d) => {
  let newD = d;
  if (d.deviceID === 'eI2K-6iUvVw:APA') {
    newD = Object.assign({}, d, { enabled: false });
  }
  return ds.concat(newD);
}, []);

There is always going to be a good debate on time vs space, however these days I've found using space is better for the long run.. Mathematics aside let look at a one practical approach to the problem using hashmaps, dictionaries, or associative array's whatever you feel like labeling the simple data structure..

    var marr2 = new Map(arr2.map(e => [e.id, e]));
    arr1.map(obj => marr2.has(obj.id) ? marr2.get(obj.id) : obj);

I like this approach because though you could argue with an array with low numbers you are wasting space because an inline approach like @Tushar approach performs indistinguishably close to this method. However I ran some tests and the graph shows how performant in ms both methods perform from n 0 - 1000. You can decide which method works best for you, for your situation but in my experience users don't care to much about small space but they do care about small speed.

Here is my performance test I ran for source of data

var n = 1000;
var graph = new Array();
for( var x = 0; x < n; x++){
  var arr1s = [...Array(x).keys()];
  var arr2s = arr1s.filter( e => Math.random() > .5);
  var arr1 = arr1s.map(e => {return {id: e, name: 'bill'}});
  var arr2 = arr2s.map(e => {return {id: e, name: 'larry'}});
  // Map 1
  performance.mark('p1s');
  var marr2 = new Map(arr2.map(e => [e.id, e]));
  arr1.map(obj => marr2.has(obj.id) ? marr2.get(obj.id) : obj);
  performance.mark('p1e');
  // Map 2
  performance.mark('p2s');
  arr1.map(obj => arr2.find(o => o.id === obj.id) || obj);
  performance.mark('p2e');
  graph.push({ x: x, r1: performance.measure('HashMap Method', 'p1s', 'p1e').duration, r2: performance.measure('Inner Find', 'p2s','p2e').duration});
}

You can do it with .map() method

    const A = [{
      x: 'a',
      y: 10
    }, {
      x: 'b',
      y: 5
    }, {
      x: 'c',
      y: 50
    }];

const B = ['2022-06-15', '2022-06-16', '2022-06-17'];

x represents each element inside your A array and i the index, that you will use to loop thru your second array B

const C = A.map((x, i) => ({
  x: B[i],
  y: x.y
}));

console.log(C);

You can use spread and Array#map to do something like this perhaps:

const test = [
  {
    marketType: 90,
    displayName: "FT Total Match {scoreType} Over / Under 0.75 Remove",
},
{
    marketType: 90,
    displayName: "FT Total Match {scoreType} Over / Under 1 Remove",
},
]

newTest = test.map(obj => ({...obj, displayName: obj.displayName.replace('{scoreType}', 'goals')}))
console.log(newTest);