JavaScript's Array.prototype.filter, map, and reduce are well-known — but what about running the same operations on plain objects? In this post we'll walk through a compact nutrition calculator that wraps those patterns into reusable object utilities, then uses them to power real food math.

The Data: A Nutrition Database

const nutritionDB = {
  tomato:  { calories: 18,  protein: 0.9,   carbs: 3.9,   sugar: 2.6, fiber: 1.2, fat: 0.2   },
  vinegar: { calories: 20,  protein: 0.04,  carbs: 0.6,   sugar: 0.4, fiber: 0,   fat: 0     },
  oil:     { calories: 48,  protein: 0,     carbs: 0,     sugar: 123, fiber: 0,   fat: 151   },
  onion:   { calories: 0,   protein: 1,     carbs: 9,     sugar: 0,   fiber: 0,   fat: 0     },
  garlic:  { calories: 149, protein: 6.4,   carbs: 33,    sugar: 1,   fiber: 2.1, fat: 0.5   },
  paprika: { calories: 282, protein: 14.14, carbs: 53.99, sugar: 1,   fiber: 0,   fat: 12.89 },
  sugar:   { calories: 387, protein: 0,     carbs: 100,   sugar: 100, fiber: 0,   fat: 0     },
  orange:  { calories: 49,  protein: 0.9,   carbs: 13,    sugar: 9,   fiber: 0.2, fat: 0.1   },
};

Each key is a food name. Each value holds nutrients per 100g. A cart will represent how many grams of each item the user is using — and we'll scale everything from there.

The Three Object Utility Functions

Before the food logic, three tiny helpers are defined that mirror array methods but work on objects.

filterEntries — like Array.filter for objects

function filterEntries(object, callback) {
  return Object.fromEntries(
    Object.entries(object).filter(callback)
  );
}

Object.entries converts { a: 1, b: 2 } into [["a", 1], ["b", 2]]. After filtering, Object.fromEntries converts it back. The callback receives each [key, value] pair.

mapEntries — like Array.map for objects

function mapEntries(object, callback) {
  return Object.fromEntries(
    Object.entries(object).map(callback)
  );
}

Same pattern — entries go out as an array, get transformed by the callback, come back as an object. The callback must return a [key, value] pair.

reduceEntries — like Array.reduce for objects

function reduceEntries(object, callback, initialValue) {
  return Object.entries(object).reduce(callback, initialValue);
}

This one doesn't need Object.fromEntries at the end because reduce can return anything — a number, a string, an array, another object.

Why This Pattern?

These three functions are thin wrappers, but they remove the repetitive boilerplate of writing Object.entries(...).map(...).fromEntries(...) every time. You end up with code that reads like intent, not plumbing.

The Nutrition Functions

Now the real logic, built on top of those utilities.

totalCalories — sum calories across a cart

function totalCalories(cart) {
  const total = reduceEntries(cart, (acc, [item, grams]) => {
    return acc + (nutritionDB[item].calories * grams) / 100;
  }, 0);
  return parseFloat(total.toFixed(1));
}

A cart looks like { tomato: 200, garlic: 10 } — ingredient names mapped to grams used.

For each item, it looks up calories per 100g from nutritionDB, scales it to the actual gram amount (* grams / 100), and accumulates the total. toFixed(1) cleans up floating-point noise.

Example:

const cart = { tomato: 200, garlic: 10 };
totalCalories(cart);
// tomato: (18 * 200) / 100 = 36 kcal
// garlic: (149 * 10) / 100 = 14.9 kcal
// Total: 50.9

lowCarbs — filter out high-carb items

function lowCarbs(cart) {
  return filterEntries(cart, ([item, grams]) => {
    return (nutritionDB[item].carbs * grams) / 100 < 50;
  });
}

Returns a new cart object containing only items whose total carb contribution is under 50g. Useful for dietary filtering — keep only what fits a low-carb budget.

Example:

const cart = { tomato: 200, sugar: 100, orange: 150 };
lowCarbs(cart);

// tomato:  (3.9  * 200) / 100 = 7.8g  ✅ kept
// sugar:   (100  * 100) / 100 = 100g  ❌ filtered out
// orange:  (13   * 150) / 100 = 19.5g ✅ kept

// Result: { tomato: 200, orange: 150 }

decimalPlaces — count decimal precision

function decimalPlaces(n) {
  const s = n.toString();
  const dot = s.indexOf('.');
  return dot === -1 ? 0 : s.length - dot - 1;
}

A small helper that counts how many decimal places a number has. It's used by cartTotal to match the precision of the source data.

cartTotal — scale all nutrients for every item

function cartTotal(cart) {
  return mapEntries(cart, ([item, grams]) => {
    const nutrition = nutritionDB[item];
    const scaled = mapEntries(nutrition, ([nutrient, per100g]) => {
      const raw = (per100g * grams) / 100;
      const precision = decimalPlaces(per100g) + 1;
      return [nutrient, parseFloat(raw.toFixed(precision))];
    });
    return [item, scaled];
  });
}

This is the most interesting function — it uses nested mapEntries calls.

The outer map iterates over every item in the cart. The inner map iterates over every nutrient for that item and scales it from per-100g to the actual gram amount used. The precision is dynamically matched to the source value (e.g. if the DB stores 14.14, the scaled value is rounded to 3 decimal places).

Example:

const cart = { garlic: 10 };
cartTotal(cart);

// garlic has 149 cal, 6.4g protein, 33g carbs, etc. per 100g
// Scaled to 10g:
// {
//   garlic: {
//     calories: 14.9,
//     protein:  0.64,
//     carbs:    3.3,
//     sugar:    0.1,
//     fiber:    0.21,
//     fat:      0.05
//   }
// }

Putting It All Together

const myCart = {
  tomato:  200,
  garlic:  10,
  onion:   80,
  paprika: 5,
  orange:  150,
  sugar:   20,
};

console.log("Total calories:", totalCalories(myCart));
// → 124.7

console.log("Low-carb items:", lowCarbs(myCart));
// → { tomato: 200, garlic: 10, onion: 80, paprika: 5 }

console.log("Full breakdown:", cartTotal(myCart));
// → each item with all nutrients scaled to actual grams

Key Patterns to Take Away

Things to Watch Out For

Missing keys — if a cart contains an item not in nutritionDB, nutritionDB[item] returns undefined and the function throws. Add a guard if your cart data is user-supplied:

if (!nutritionDB[item]) return acc; // skip unknown items

Floating-point arithmetic — 0.1 + 0.2 === 0.30000000000000004 in JS. The toFixed calls throughout handle this, but always be explicit about rounding when displaying nutrition data.

Object key order — Object.entries follows insertion order for string keys in modern JS engines, but the spec only guarantees this for integer-like keys. For display purposes it's fine; don't rely on it for logic.

Wrapping Up

This codebase is a great example of how a few well-named utility functions — filterEntries, mapEntries, reduceEntries — can make object manipulation read as cleanly as array operations. The nutrition domain is just the context; the underlying patterns apply anywhere you're working with plain objects as data structures.

Next step: add a sortEntries utility and rank cart items by calorie density.

If you enjoyed this, feel free to check out more of my work on GitHub 👉 keyadaniel56 — always building something new.