jizzy

Старый добрый for вам поможет:

var obj = {};

for (var n = 0; n < array.length; n++) {
    obj[array[n]['name']] = array[n]['value'];
}

console.dir(obj);

result.map(({ products: { newArray }, ...item}) => ({ ...item, products: newArray }))

Или если не уверен что весде есть свойство 'products':

result.map((item) => ({ ...item, products: item?.products?.newArray }))

const objects = [...];
const ids = [1,2,3,8,9];

const missed = objects.filter(obj => !ids.includes(obj.id));

// проиндексируем по ключам
const [rootIndex, idIndex] = array.reduce(([roots, ids], obj) => {
  (roots[obj.root_id] ??= []).push(obj);
  ids[obj.id] = obj;
  return [roots, ids];
}, [{}, {}]);
// и найдем по нему нужные объекты:
const objectsWithoutExistingParent = Object.keys(rootIndex).filter(key => !idIndex.hasOwnProperty(key)).flatMap(key => rootIndex[key]);
console.log(objectsWithoutExistingParent);

Конечно чуть больше кода, чем у 0xD34F, зато с линейной сложностью
P.S. а я все жду, когда 0xD34F начнет впаривать факториальную сложность новичкам, а то с квадратичной веб конечно тормозит, но не такими темпами...

Если делать ровно то, что спрошено:

const roots = [];

COLLECT_ROOTS:
for (const n of arr) {
  for (const m of arr) {
    if (m.id === n.root_id) {
      continue COLLECT_ROOTS;
    }
  }

  roots.push(n);
}

// или

const roots = arr.filter(function(n) {
  return !this.has(n.root_id);
}, new Set(arr.map(n => n.id)));

// или

const roots = (function get(i, n = arr[i]) {
  return n
    ? [].concat(arr.every(m => m.id !== n.root_id) ? n : [], get(-~i))
    : []
})(0);

Но вообще, дерево-то можно и собрать, результатом как раз будет массив искомых объектов (конечно, не без дополнения в виде вложенных массивов):

function createTree({
  data,
  key = 'id',
  parentKey = 'parentId',
  childrenKey = 'children',
}) {
  const tree = Object.fromEntries(data.map(n => [
    n[key],
    { ...n, [childrenKey]: [] },
  ]));

  return Object.values(tree).filter(n => (
    !tree[n[parentKey]]?.[childrenKey].push(n)
  ));
}

const tree = createTree({
  data: arr,
  parentKey: 'root_id',
});

const groupSubarrays = (arr, idKey, subarrKey) =>
  Object.values(arr.reduce((acc, n) => (
    (acc[n[idKey]] ??= { ...n, [subarrKey]: [] })[subarrKey].push(...n[subarrKey]),
    acc
  ), {}));


const result = groupSubarrays(arr, 'id', 'array1');

const mapIds = {}
const filtered = array.filter(elem => {
  const existingElement = mapIds[elem.id]
  if (!existingElement) 
    mapIds[elem.id] = elem
  else  
    existingElement.array1.push(...elem.array1)

  return !existingElement
})

Либо если выпендриться с filter в одну строчку, то

const mapIds = {}
const filtered = array.filter(elem => 
  (!mapIds[elem.id] && (mapIds[elem.id] = elem)) || !mapIds[elem.id].array1.push(...elem.array1)
)

Какое свойство смотрим, какие значения хотим увидеть:

const key = 'workplace';
const values = [ 'office', 'hotel' ];

Достаём объекты:

const result = arr.filter(function(n) {
  return this.has(n[key]);
}, new Set(values));

// или

const result = values.flatMap(((grouped, n) => grouped[n] ?? []).bind(
  null,
  arr.reduce((acc, n) => ((acc[n[key]] = acc[n[key]] ?? []).push(n), acc), {})
));

// или

const result = [];
for (const n of arr) {
  for (const m of values) {
    if (m === n[key]) {
      result.push(n);
      break;
    }
  }
}

// или

const result = [];
for (let i = 0; i < arr.length; i++) {
  if (~values.indexOf(arr[i][key])) {
    result[result.length] = arr[i];
  }
}

// или

const result = (function get(i, n = arr[i]) {
  return n
    ? [].concat(values.includes(n[key]) ? n : [], get(-~i))
    : [];
})(0);

var arr = [{ "Name": "Alex", "sex":"man","age":50,"workplace":"office"},
{"Name": "Katya", "sex":"woman","age":33,"workplace":"office"},
{"Name": "Igor", "sex":"man","age":22,"workplace":"park"},
{"Name": "Olga", "sex":"woman","age":19,"workplace":"park"},
{"Name": "Maks", "sex":"man","age":40,"workplace":"hotel"}
var arr2 = [];

for(var prop in arr){
if(arr[prop].workplace == "office" || arr[prop].workplace == "hotel"){
arr2.push(arr[prop]);
}
}