Advanced JavaScript Indexing Strategies for High-Performance Data Retrieval

// Creating a basic index using an Object function createUserIndex(users) { const userIndex = {}; for (const user of users) { userIndex[user.id] = user; } return userIndex; } // Usage const users = [ { id: 1, name: "Sarah", department: "Engineering" }, { id: 2, name: "Michael", department: "Marketing" }, // ...thousands more users ]; const userIndex = createUserIndex(users); // O(1) lookup instead of O(n) search const user = userIndex[42]; // Instant access 

// Using Map for more flexible indexing function createMultiIndex(users) { const idIndex = new Map(); const emailIndex = new Map(); for (const user of users) { idIndex.set(user.id, user); emailIndex.set(user.email, user); } return { byId: idIndex, byEmail: emailIndex }; } // Example usage const indexes = createMultiIndex(users); const userById = indexes.byId.get(42); const userByEmail = indexes.byEmail.get("sarah@example.com"); 

function createCompositeIndex(products) { const index = new Map(); for (const product of products) { // Create composite key for category + price range const priceRange = Math.floor(product.price / 100) * 100; // Group by $100 ranges const key = `${product.category}:${priceRange}`; if (!index.has(key)) { index.set(key, []); } index.get(key).push(product); } return index; } // Example usage const productIndex = createCompositeIndex(products); // Quickly find all electronics between $200-$299 const electronicsMidRange = productIndex.get("electronics:200"); 

function createInvertedIndex(documents) { const index = new Map(); documents.forEach((doc, docId) => { // Tokenize, normalize, and remove stop words const words = doc.text.toLowerCase() .replace(/[^\w\s]/g, '') .split(/\s+/) .filter(word => word.length > 2); // Add to inverted index for (const word of new Set(words)) { // Use Set to count each word once per document if (!index.has(word)) { index.set(word, new Set()); } index.get(word).add(docId); } }); return index; } // Search function using the index function search(index, query) { const searchTerms = query.toLowerCase() .replace(/[^\w\s]/g, '') .split(/\s+/) .filter(word => word.length > 2); if (searchTerms.length === 0) return []; // Find documents containing all search terms const matchingSets = searchTerms .map(term => index.get(term) || new Set()) .filter(set => set.size > 0); if (matchingSets.length === 0) return []; // Find intersection of all matching document sets const result = [...matchingSets[0]].filter(docId => matchingSets.every(set => set.has(docId)) ); return result; } 

class BTreeNode { constructor(isLeaf = true) { this.keys = []; this.children = []; this.isLeaf = isLeaf; } } class BTree { constructor(degree = 3) { this.root = new BTreeNode(); this.degree = degree; // Minimum degree } search(key, node = this.root) { let i = 0; while (i < node.keys.length && key > node.keys[i].key) { i++; } if (i < node.keys.length && key === node.keys[i].key) { return node.keys[i].value; } if (node.isLeaf) { return null; } return this.search(key, node.children[i]); } // Range query to find all items between minKey and maxKey rangeQuery(minKey, maxKey, node = this.root, result = []) { let i = 0; // Find the first key >= minKey while (i < node.keys.length && minKey > node.keys[i].key) { i++; } // Add all keys in range from this node while (i < node.keys.length && node.keys[i].key <= maxKey) { result.push(node.keys[i].value); i++; } // If not a leaf, search relevant children if (!node.isLeaf) { let childIndex = 0; // Find first child that could contain keys >= minKey while (childIndex < node.keys.length && minKey > node.keys[childIndex].key) { childIndex++; } // Search children that might contain keys in our range while (childIndex < node.children.length && (childIndex === 0 || node.keys[childIndex-1].key <= maxKey)) { this.rangeQuery(minKey, maxKey, node.children[childIndex], result); childIndex++; } } return result; } // Insert method would be implemented here // For brevity, I've omitted the complex insertion logic } 

class TrieNode { constructor() { this.children = new Map(); this.isEndOfWord = false; this.data = null; } } class Trie { constructor() { this.root = new TrieNode(); } insert(word, data = true) { let current = this.root; for (const char of word) { if (!current.children.has(char)) { current.children.set(char, new TrieNode()); } current = current.children.get(char); } current.isEndOfWord = true; current.data = data; } search(word) { let current = this.root; for (const char of word) { if (!current.children.has(char)) { return false; } current = current.children.get(char); } return current.isEndOfWord ? current.data : false; } findAllWithPrefix(prefix) { const results = []; let current = this.root; // Navigate to the node representing the prefix for (const char of prefix) { if (!current.children.has(char)) { return results; } current = current.children.get(char); } // Collect all words starting from this node this._collectWords(current, prefix, results); return results; } _collectWords(node, prefix, results) { if (node.isEndOfWord) { results.push({ word: prefix, data: node.data }); } for (const [char, childNode] of node.children) { this._collectWords(childNode, prefix + char, results); } } } // Example usage for autocomplete const productTrie = new Trie(); // Index product names products.forEach(product => { productTrie.insert(product.name.toLowerCase(), product); }); // Search as user types function autocomplete(prefix) { return productTrie.findAllWithPrefix(prefix.toLowerCase()) .slice(0, 10); // Limit to 10 suggestions } 

function createSparseIndex(items, shouldIndex) { const indexes = new Map(); items.forEach((item, id) => { // Only index fields that meet our criteria for (const [field, value] of Object.entries(item)) { if (shouldIndex(field, value, item)) { const indexKey = `${field}:${value}`; if (!indexes.has(indexKey)) { indexes.set(indexKey, new Set()); } indexes.get(indexKey).add(id); } } }); return indexes; } // Example usage const productIndex = createSparseIndex(products, (field, value, product) => { // Only index high-value or frequently queried fields return field === 'category' || field === 'brand' || (field === 'price' && value > 1000); }); // Find expensive Samsung products function findExpensiveSamsungProducts() { const brandSet = productIndex.get('brand:Samsung') || new Set(); const priceSet = productIndex.get('price:1000') || new Set(); // Intersection of sets for products matching both criteria return [...brandSet].filter(id => priceSet.has(id)) .map(id => products[id]); } 

class LazyIndexedCollection { constructor(items) { this.items = items; this.indexes = new Map(); this.indexBuilders = new Map(); } registerIndexBuilder(indexName, builder) { this.indexBuilders.set(indexName, builder); return this; } ensureIndex(indexName) { // Build index on first use if (!this.indexes.has(indexName)) { if (!this.indexBuilders.has(indexName)) { throw new Error(`No builder registered for index: ${indexName}`); } console.time(`Building index: ${indexName}`); const builder = this.indexBuilders.get(indexName); this.indexes.set(indexName, builder(this.items)); console.timeEnd(`Building index: ${indexName}`); } return this.indexes.get(indexName); } query(indexName, key) { const index = this.ensureIndex(indexName); return index.get(key) || []; } } // Example usage const collection = new LazyIndexedCollection(products) .registerIndexBuilder('byCategory', items => { // Complex index building logic here const index = new Map(); for (const item of items) { if (!index.has(item.category)) { index.set(item.category, []); } index.get(item.category).push(item); } return index; }) .registerIndexBuilder('byPrice', items => { // Another complex index const index = new Map(); // ...indexing logic return index; }); // Index is only built when first queried const electronicsProducts = collection.query('byCategory', 'electronics'); 

class IndexedCollection { constructor(items = []) { this.items = new Map(items.map(item => [item.id, item])); this.categoryIndex = new Map(); this.rebuildIndexes(); } rebuildIndexes() { // Clear existing indexes this.categoryIndex.clear(); // Rebuild from scratch for (const [id, item] of this.items) { this.addToIndexes(item); } } addToIndexes(item) { if (!this.categoryIndex.has(item.category)) { this.categoryIndex.set(item.category, new Set()); } this.categoryIndex.get(item.category).add(item.id); } removeFromIndexes(item) { const categorySet = this.categoryIndex.get(item.category); if (categorySet) { categorySet.delete(item.id); // Clean up empty sets if (categorySet.size === 0) { this.categoryIndex.delete(item.category); } } } // CRUD operations that maintain indexes add(item) { this.items.set(item.id, item); this.addToIndexes(item); return item; } update(id, updates) { const item = this.items.get(id); if (!item) return null; // If category changed, update indexes if (updates.category && updates.category !== item.category) { this.removeFromIndexes(item); const updatedItem = { ...item, ...updates }; this.items.set(id, updatedItem); this.addToIndexes(updatedItem); } else { // Simple update without index changes Object.assign(item, updates); } return this.items.get(id); } delete(id) { const item = this.items.get(id); if (!item) return false; this.removeFromIndexes(item); return this.items.delete(id); } findByCategory(category) { const ids = this.categoryIndex.get(category) || new Set(); return [...ids].map(id => this.items.get(id)); } } 

class TransactionalIndexManager { constructor(indexes) { this.indexes = indexes; this.pendingChanges = new Map(); } scheduleUpdate(indexName, key, addIds = [], removeIds = []) { const changeKey = `${indexName}:${key}`; if (!this.pendingChanges.has(changeKey)) { this.pendingChanges.set(changeKey, { indexName, key, addIds: [], removeIds: [] }); } const change = this.pendingChanges.get(changeKey); change.addIds.push(...addIds); change.removeIds.push(...removeIds); } commit() { for (const { indexName, key, addIds, removeIds } of this.pendingChanges.values()) { const index = this.indexes.get(indexName); if (!index) continue; if (!index.has(key)) { index.set(key, new Set()); } const set = index.get(key); for (const id of addIds) { set.add(id); } for (const id of removeIds) { set.delete(id); } if (set.size === 0) { index.delete(key); } } this.pendingChanges.clear(); } rollback() { this.pendingChanges.clear(); } }