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.
| Input | Output |
|---|---|
18 |
0 |
0.9 |
1 |
14.14 |
2 |
53.99 |
2 |
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
| Pattern | Function used | What it demonstrates |
|---|---|---|
| Object → filter → Object |
filterEntries + lowCarbs
|
Declarative filtering with Object.entries / fromEntries
|
| Object → reduce → scalar |
reduceEntries + totalCalories
|
Aggregating object values into a single number |
| Object → map → Object |
mapEntries + cartTotal
|
Transforming every value while keeping the shape |
| Nested map |
cartTotal (inner mapEntries) |
Operating on nested objects without mutation |
| Dynamic precision | decimalPlaces |
Matching output precision to input precision |
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.
Top comments (0)