MapReduce with MongoDB in NodeJS

Aggregate data from MongoDB with Node.js and mongoose

This example demonstrates how to calculate an account balance by aggregating embedded financial records in MongoDB using Node.js and Mongoose. It defines Account and Record schemas, inserts sample data, and runs an aggregation pipeline with `$match`, `$unwind`, and `$group` to sum record amounts via `AccountModel.aggregate()`. The code also shows CRUD operations for accounts and records, with results logged to the console.

70% match

Gist 737033

This example demonstrates a MapReduce aggregation over a MongoDB collection of crime records, showing the count of crimes grouped by property name. The code first seeds a `crimes` collection with sample data, then defines a `map` function that emits each property name with a value of 1, and a `reduce` function that sums the emitted values. The MapReduce operation runs via `db.crimes.mapReduce()` and outputs the results as a JSON array using `printjson`. It uses MongoDB’s JavaScript shell API for data insertion, mapping, reduction, and result retrieval.

CCaged

67% match

Notify socket.io users when MongoDB data collection changes

This example shows how MongoDB data changes are streamed to connected Socket.io users in real time. It uses the MongoDB `User.watch()` change stream to monitor collection modifications, and on each change, queries all users via `User.find({})` before emitting the updated dataset through `socket.emit('users', data)`. The code integrates with an Express app and a Socket.io server, logging connection events and collection changes to the console. No visualization library is involved; the focus is on the backend data pipeline that pushes fresh data to clients.

57% match

MongoDB Aggregation Framework way for "select count (distinct fieldName) from someTable" for large collections

This example shows how to compute the equivalent of a SQL “select count (distinct fieldName) from someTable” using MongoDB’s Aggregation Framework for large collections. The code uses the `db.someCollection.aggregate()` method with two `$group` stages: the first groups documents by the distinct value of `fieldName` (assigned to `_id`), and the second groups all results into a single document (`_id: 1`) while summing the number of groups with `$sum: 1` to produce the final count. The snippet is written as a JavaScript gist and relies solely on MongoDB’s native aggregation pipeline, with no external visualization library.

55% match

map/reduce/pipe in 3m

This example demonstrates the functional programming concepts of `map`, `reduce`, and `pipe` in under three minutes using JavaScript. The code defines custom `reduce` and `map` functions, where `map` is built on top of `reduce` to transform array elements, and a `pipe` function that chains multiple functions together by sequentially passing an input through each one. The implementation uses iterable `for...of` loops and arrow functions, showing how these higher-order utilities operate on arrays and function compositions without relying on external libraries.

RRestuta

Implementation of Native JavaScript Methods (forEach, Map, Filter, Reduce, Every, Some)

This example shows how to reimplement six core JavaScript array methods—forEach, map, filter, reduce, every, and some—using native loops and callbacks. The code defines custom prototypes like `Array.prototype.myEach` and `Array.prototype.myMap`, then tests each with sample arrays and console output. It demonstrates the underlying logic of these standard APIs, including handling initial values in `myReduce` and context binding in `myFilter`. The implementation relies solely on plain JavaScript syntax, with no external libraries, and uses console logging to display results.

Notify socket.io users when MongoDB data collection changes

This example shows a real-time notification system that pushes MongoDB collection changes to connected socket.io clients. The code sets a watch on the User collection using MongoDB’s changeStream API, then listens for socket connections. Upon any change event, it queries the full User collection with `User.find({})` and emits the updated data to the client via `socket.emit('users', data)`. It demonstrates live data synchronization between a MongoDB backend and browser clients through socket.io’s event-driven communication.

Gist 444255

This example demonstrates a Node.js server that queries MongoDB collections and logs their contents to the console, primarily as a backend testing or debugging tool. The code uses the `mongo.Db` and `mongo.Server` APIs to connect to a local MongoDB instance on port 27017, then defines HTTP routes via a `get()` handler. For each route, it retrieves documents from specific collections—`some-collection` and `another-collection` (the latter with a limit of 10)—and prints each item using `sys.puts` and `sys.inspect`. The visualization aspect is absent; the example focuses on database interaction and response handling.

CCaged