Managing numerous incoming inquiry requests

Question

Managing numerous incoming inquiry requests

My API serves JSON data. Currently, accessing api/weapons will provide all available weapons, while api/weapons/weaponName gives information about a specific weapon. My goal is to filter results using parameters like

api/weapons?type=sword&rarity=5

. I have managed to filter by type and rarity individually with api/weapons?type=sword and api/weapons?rarity=5 but not together.

This is my current approach:

  let filtered = [];
  if (query.type) {
    filtered = filtered.concat((await weapons).filter(w => formatName(w.weaponType) === formatName(query.type)));
  }
  if (query.rarity) {
    filtered = filtered.concat((await weapons).filter(w => w.rarity == query.rarity));
  }
  if (!filtered.length) filtered = [await weapons];
  res.status(HttpStatusCodes.ACCEPTED).send(filtered);

formatName is simply a function that converts a string to lowercase, trims it, and removes spaces.

If we consider the example

api/weapons?type=sword&rarity=5

, the current behavior is:

Retrieve all weapons of type "sword"
Retrieve all weapons with rarity "5"
Combine both sets of results, showing all swords regardless of rarity and all weapons with rarity 5 regardless of type.

I aim to only display weapons that match both the specified rarity AND type criteria, such as swords with a rarity of 5. What would be the most efficient way to achieve this filtering?

javascript express

Answer 1

Answer №1

To improve efficiency, it is recommended to fetch "weapons" once and apply filters separately without combining the results:

let filtered = [ ...(await weapons) ];

if (query.type) {
  filtered = filtered.filter(w => formatName(w.weaponType) === formatName(query.type));
}

if (query.rarity) {
  filtered = filtered.filter(w => w.rarity == query.rarity);
}

res.status(HttpStatusCodes.ACCEPTED).send(filtered);

Answer 2

To improve efficiency, it is recommended to fetch "weapons" once and apply filters separately without combining the results:

let filtered = [ ...(await weapons) ];

if (query.type) {
  filtered = filtered.filter(w => formatName(w.weaponType) === formatName(query.type));
}

if (query.rarity) {
  filtered = filtered.filter(w => w.rarity == query.rarity);
}

res.status(HttpStatusCodes.ACCEPTED).send(filtered);

Answer 3

Answer №2

Your current approach involves testing if one constraint OR another matches, but what you actually need to do is perform an AND operation. This means that the test should be conducted in a single pass of the filter method.

To achieve this, I suggest making some slight modifications to your code so that all constraints are compared. You can even further adjust the logic to include a logical operator for checking whether the rarity is greater than or equal to (>=) or less than or equal to (<=) a certain number, for instance.

const weapons = [{
    type: 'sword',
    name: 'swift blade of zek',
    rarity: 5
  },
  {
    type: 'mace',
    name: 'hammer of kromzek kings',
    rarity: 1
  },
  {
    type: 'sword',
    name: 'split blade of thunder',
    rarity: 2
  },
  {
    type: 'sword',
    name: 'blade of carnage',
    rarity: 5
  },
]

const getWeapons = (query = {}) => {
  let filtered = [];
  let constraints = [];

  // Instead of hardcoding, we could dynamically build this object
  // However, for demonstration purposes, I am following your current approach
  if (query.hasOwnProperty('type')) {
    constraints.push({
      name: 'type',
      value: query.type
    })
  }

  if (query.hasOwnProperty('rarity')) {
    constraints.push({
      name: 'rarity',
      value: query.rarity
    })
  }

  // Compare all the conditions and only return weapons that satisfy all specified constraints
  filtered = weapons.filter(w => {
    let matches = 0
    constraints.forEach(c => {
      if (w[c.name] === c.value) {
        matches += 1
      }
    })
    // Return only complete matches
    return matches === constraints.length
  });

  return filtered
}

console.log(getWeapons({
  type: 'sword',
  rarity: 5
}))

Answer 4

Your current approach involves testing if one constraint OR another matches, but what you actually need to do is perform an AND operation. This means that the test should be conducted in a single pass of the filter method.

To achieve this, I suggest making some slight modifications to your code so that all constraints are compared. You can even further adjust the logic to include a logical operator for checking whether the rarity is greater than or equal to (>=) or less than or equal to (<=) a certain number, for instance.

const weapons = [{
    type: 'sword',
    name: 'swift blade of zek',
    rarity: 5
  },
  {
    type: 'mace',
    name: 'hammer of kromzek kings',
    rarity: 1
  },
  {
    type: 'sword',
    name: 'split blade of thunder',
    rarity: 2
  },
  {
    type: 'sword',
    name: 'blade of carnage',
    rarity: 5
  },
]

const getWeapons = (query = {}) => {
  let filtered = [];
  let constraints = [];

  // Instead of hardcoding, we could dynamically build this object
  // However, for demonstration purposes, I am following your current approach
  if (query.hasOwnProperty('type')) {
    constraints.push({
      name: 'type',
      value: query.type
    })
  }

  if (query.hasOwnProperty('rarity')) {
    constraints.push({
      name: 'rarity',
      value: query.rarity
    })
  }

  // Compare all the conditions and only return weapons that satisfy all specified constraints
  filtered = weapons.filter(w => {
    let matches = 0
    constraints.forEach(c => {
      if (w[c.name] === c.value) {
        matches += 1
      }
    })
    // Return only complete matches
    return matches === constraints.length
  });

  return filtered
}

console.log(getWeapons({
  type: 'sword',
  rarity: 5
}))

Answer 5

Answer №3

To implement filtering functionality, create an object containing functions that specify the evaluation criteria for each filter you want to apply.

const filters = {
  type: (weapon, type) => formatName(weapon.weaponType) === formatName(type),
  rarity: (weapon, rarity) => weapon.rarity === rarity,
};

Next, iterate through the weapons using the filter method. Within this loop, go through the keys of the query object using the every method, which returns true only if all evaluations are met.

Within the every loop, select the corresponding filter function from the filters object based on the key in the query. Pass the weapon and query values to these functions and return the result.

This approach allows utilizing one, multiple, or no filters at all. Additionally, new filters can easily be added to the filters object.

const filteredWeapons = weapons.filter((weapon) =>
  Object.keys(query).every((filterKey) => {
    if (!(filterKey in filters)) {
      return false;
    }

    const filter = filters[filterKey]
    const value = query[filterKey]
    return filter(weapon, value);
  })
);

res.status(HttpStatusCodes.ACCEPTED).send(filteredWeapons);

Answer 6

To implement filtering functionality, create an object containing functions that specify the evaluation criteria for each filter you want to apply.

const filters = {
  type: (weapon, type) => formatName(weapon.weaponType) === formatName(type),
  rarity: (weapon, rarity) => weapon.rarity === rarity,
};

Next, iterate through the weapons using the filter method. Within this loop, go through the keys of the query object using the every method, which returns true only if all evaluations are met.

Within the every loop, select the corresponding filter function from the filters object based on the key in the query. Pass the weapon and query values to these functions and return the result.

This approach allows utilizing one, multiple, or no filters at all. Additionally, new filters can easily be added to the filters object.

const filteredWeapons = weapons.filter((weapon) =>
  Object.keys(query).every((filterKey) => {
    if (!(filterKey in filters)) {
      return false;
    }

    const filter = filters[filterKey]
    const value = query[filterKey]
    return filter(weapon, value);
  })
);

res.status(HttpStatusCodes.ACCEPTED).send(filteredWeapons);

Managing numerous incoming inquiry requests

Answer №1

Answer №2

Answer №3

Similar questions

Implement admin-on-rest framework within my current project

To add an object to an array in Javascript, use the following format: [{...}, {...}]

Arranging information extracted from an XML document following an ajax request

A guide to implementing SSR layout using Next-Auth

I am looking to dynamically add values into a hash map

Changing guid bytes into a string using JavaScript

Problem with sorting when using $in operator in MongoDB

Troubleshooting npm audit error involving loadVirtual and ENOLOCK

Dealing with a 404 error after accepting a slack modal submission using nodeJS and express

Discovering the magic of obtaining a random element in Vue.js

Understanding the process of extracting triangle and vertex information from an STL file

What is the best way to pass a prop into the <router-link>?

Setting the ng-class attribute on an AngularJS accordion-heading element seems ineffective

The speed at which Laravel loads local CSS and JS resources is notably sluggish

Retrieve a specific line of code from a snippet of JavaScript

Optimizing logical expressions in C++

Triggering a hover effect by invoking a jQuery function when a href is clicked

Storing an array of dates in a Rails database by saving each date on a separate row within the table

Implementing Angular $resource to prepopulate a form with data

Combine two arrays of objects while avoiding objects with duplicate ID properties