What is the best method for eliminating duplicate objects in an array using 2 specific properties?

Question

What is the best method for eliminating duplicate objects in an array using 2 specific properties?

I am currently dealing with an array of room objects and my task involves removing duplicate objects based on their room_rate_type_id property:

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = rooms.filter((room, index, array) => {
  const roomRateTypeIds = rooms.map(room => room.room_rate_type_id);
  // Returns the first index found.
  return roomRateTypeIds.indexOf(room.room_rate_type_id) === index;
});

console.log(newRooms);

In addition to eliminating duplicates based on the room_rate_type_id, I now have a requirement to include price comparison as well when removing objects.

While I grasp the concept of using the filter method in this scenario, I am seeking guidance on how to efficiently incorporate a price check along with room_rate_type_id match, preferably utilizing ES6 syntax.

javascript arrays filter ecmascript-6

Answer 1

Answer №1

To accomplish this task, you can use the following JavaScript code:

const rooms = [
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

let result = rooms.filter((e, i) => {
    return rooms.findIndex((x) => {
    return x.room_rate_type_id == e.room_rate_type_id && x.price == e.price;}) == i;

});

console.log(result);

This code snippet will filter out all duplicates except for the first occurrence of any object in the array.

Answer 2

To accomplish this task, you can use the following JavaScript code:

const rooms = [
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

let result = rooms.filter((e, i) => {
    return rooms.findIndex((x) => {
    return x.room_rate_type_id == e.room_rate_type_id && x.price == e.price;}) == i;

});

console.log(result);

This code snippet will filter out all duplicates except for the first occurrence of any object in the array.

Answer 3

Answer №2

To transform the array into a Map object, you can generate a unique key using properties from each element and then add the element to the Map only if the key is not already present. Finally, convert the values of the Map back into an array using the spread operator:

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = [...rooms.reduce((m, r) => {
  const key = `${r.room_rate_type_id}-${r.price}`; // create a unique key by combining both properties
  return m.has(key) ? m : m.set(key, r); // skip if key exists, else add to map
}, new Map()).values()]; // retrieve map values and convert them back to an array

console.log(newRooms);

Answer 4

To transform the array into a Map object, you can generate a unique key using properties from each element and then add the element to the Map only if the key is not already present. Finally, convert the values of the Map back into an array using the spread operator:

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = [...rooms.reduce((m, r) => {
  const key = `${r.room_rate_type_id}-${r.price}`; // create a unique key by combining both properties
  return m.has(key) ? m : m.set(key, r); // skip if key exists, else add to map
}, new Map()).values()]; // retrieve map values and convert them back to an array

console.log(newRooms);

Answer 5

Answer №3

To handle a small array efficiently, you can filter out matching rooms by checking for duplicates:

const newRooms = rooms.filter((room, index) => {
  // Include room only if no previous room matches it
  return !rooms.some((r, i) =>
    i < index &&
    r.room_rate_type_id == room.room_rate_type_id &&
    r.price == room.price
  );
});

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = rooms.filter((room, index) => {
  // Only include this room if there isn't another room earlier
  // in the array that has the same values
  return !rooms.some((r, i) =>
    i < index &&
    r.room_rate_type_id == room.room_rate_type_id &&
    r.price == room.price
  );
});

console.log(newRooms);

.as-console-wrapper {
  max-height: 100% !important;
}

If dealing with a large array, it's more efficient to store seen combinations and avoid rechecking every time:

const seenRooms = Object.create(null);
const newRooms = rooms.filter((room, index) => {
  const key = room.room_rate_type_id + "**" + room.price;
  if (seenRooms[key]) {
    return false;
  }
  seenRooms[key] = true;
  return true;
});

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const seenRooms = Object.create(null);
const newRooms = rooms.filter((room, index) => {
  const key = room.room_rate_type_id + "**" + room.price;
  if (seenRooms[key]) {
    return false;
  }
  seenRooms[key] = true;
  return true;
});

console.log(newRooms);

.as-console-wrapper {
  max-height: 100% !important;
}

The examples are written for clarity; feel free to simplify them further as needed.

Answer 6

To handle a small array efficiently, you can filter out matching rooms by checking for duplicates:

const newRooms = rooms.filter((room, index) => {
  // Include room only if no previous room matches it
  return !rooms.some((r, i) =>
    i < index &&
    r.room_rate_type_id == room.room_rate_type_id &&
    r.price == room.price
  );
});

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = rooms.filter((room, index) => {
  // Only include this room if there isn't another room earlier
  // in the array that has the same values
  return !rooms.some((r, i) =>
    i < index &&
    r.room_rate_type_id == room.room_rate_type_id &&
    r.price == room.price
  );
});

console.log(newRooms);

.as-console-wrapper {
  max-height: 100% !important;
}

If dealing with a large array, it's more efficient to store seen combinations and avoid rechecking every time:

const seenRooms = Object.create(null);
const newRooms = rooms.filter((room, index) => {
  const key = room.room_rate_type_id + "**" + room.price;
  if (seenRooms[key]) {
    return false;
  }
  seenRooms[key] = true;
  return true;
});

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const seenRooms = Object.create(null);
const newRooms = rooms.filter((room, index) => {
  const key = room.room_rate_type_id + "**" + room.price;
  if (seenRooms[key]) {
    return false;
  }
  seenRooms[key] = true;
  return true;
});

console.log(newRooms);

.as-console-wrapper {
  max-height: 100% !important;
}

The examples are written for clarity; feel free to simplify them further as needed.

Answer 7

Answer №4

An easy method: creating a unique key by combining the room_rate_type_id and price values:

const rooms = [
    {room_rate_type_id: 303, price: 150},{room_rate_type_id: 305, price: 200}, {room_rate_type_id: 303, price: 150}
];

const roomKeys = [];
const filteredRooms = rooms.filter((room, index, arr) => {
    let key = room.room_rate_type_id + "" + room.price;
    if (roomKeys.indexOf(key) === -1) {
        roomKeys.push(key);
        return room;
    }
});

console.log(filteredRooms);

Answer 8

An easy method: creating a unique key by combining the room_rate_type_id and price values:

const rooms = [
    {room_rate_type_id: 303, price: 150},{room_rate_type_id: 305, price: 200}, {room_rate_type_id: 303, price: 150}
];

const roomKeys = [];
const filteredRooms = rooms.filter((room, index, arr) => {
    let key = room.room_rate_type_id + "" + room.price;
    if (roomKeys.indexOf(key) === -1) {
        roomKeys.push(key);
        return room;
    }
});

console.log(filteredRooms);

Answer 9

Answer №5

If you're looking for a solution, the following code snippet should help:

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = rooms.reduce((uniqueRooms, room) => {
  let foundRoom = uniqueRooms.filter(r => {
    return r.room_rate_type_id === room.room_rate_type_id && r.price === room.price;
  });
  if (foundRoom.length === 0) {
    return [...uniqueRooms, room];
  }
  return uniqueRooms;
}, [rooms[0]]);

console.log(newRooms);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 10

If you're looking for a solution, the following code snippet should help:

const rooms = [{
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 200
  },
  {
    room_rate_type_id: 202,
    price: 189
  },
  {
    room_rate_type_id: 190,
    price: 200
  }
];

const newRooms = rooms.reduce((uniqueRooms, room) => {
  let foundRoom = uniqueRooms.filter(r => {
    return r.room_rate_type_id === room.room_rate_type_id && r.price === room.price;
  });
  if (foundRoom.length === 0) {
    return [...uniqueRooms, room];
  }
  return uniqueRooms;
}, [rooms[0]]);

console.log(newRooms);

.as-console-wrapper { max-height: 100% !important; top: 0; }

Answer 11

Answer №6

const roomList = [
  {
    id: 101,
    rate: 150
  },
  {
    id: 101,
    rate: 150
  },
  {
    id: 101,
    rate: 175
  },
  {
    id: 111,
    rate: 200
  }
];

let filteredRooms = roomList.filter((room, index, array) => array.findIndex(x => x.id === room.id && x.rate === room.rate) === index);


console.log(filteredRooms);

Answer 12

const roomList = [
  {
    id: 101,
    rate: 150
  },
  {
    id: 101,
    rate: 150
  },
  {
    id: 101,
    rate: 175
  },
  {
    id: 111,
    rate: 200
  }
];

let filteredRooms = roomList.filter((room, index, array) => array.findIndex(x => x.id === room.id && x.rate === room.rate) === index);


console.log(filteredRooms);

What is the best method for eliminating duplicate objects in an array using 2 specific properties?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Similar questions

The error callback in Jquery ajax is triggered despite receiving a 200 status code in the response

Determining the Width of an Image Following the Application of a CSS Class Using Javascript

What is the best method to retrieve a secure httponly cookie in a Next.js application?

Is there a way to include this function in an array without triggering it right away?

What is the secret to remaining on the same spot even after the page is reloaded?

Connect the value of the input field to the dataset

Uploading files with Ajax in PHP

Conceal information on-the-fly using React

Having trouble launching an Angular 2 project

collection of elements and lineage

Java Script Event Handling Creating Array with Numerous Duplicates

Harnessing the power of jQuery.load() and ajax dataFilter() for dynamic content loading

Can you provide me with the sequelize query that is equivalent to this raw query?

What leads to the occurrence of the "maximum call stack size exceeded" error?

Guidelines for setting the Id and value for a Hidden field

What is causing the TouchSwipe jQuery plugin not to function in my code?

Manage the orientation of the text for entering dates

What are the best methods for saving long-term offline data in Progressive Web Apps using browser storage?

"Exploring the concept of undefined within object-oriented programming and its role in

The search text box is mysteriously absent from each column in the datatables