← Shallow vs Deep Copy Map / Filter / Reduce Polyfills →

Advanced Array Methods

🚀 Beyond map(), filter(), and reduce()

Modern JavaScript provides powerful array methods for complex data manipulation, performance optimization, and functional programming patterns.

Array Method Categories

Search Methods

find()/findLast()
findIndex()/findLastIndex()
includes()
indexOf()/lastIndexOf()

Test Methods

some()
every()
filter()

Transformation

map()
flat()/flatMap()
reduce()/reduceRight()

New ES2023+

toReversed()
toSorted()
toSpliced()
with()

Example 1: Beyond Basic Methods

JavaScript Editor

// Beyond map, filter, reduce: Advanced Array Methods

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const users = [
  { id: 1, name: 'Alice', age: 25, department: 'Engineering', skills: ['JS', 'React'] },
  { id: 2, name: 'Bob', age: 30, department: 'Marketing', skills: ['SEO', 'Content'] },
  { id: 3, name: 'Charlie', age: 22, department: 'Engineering', skills: ['Python', 'Django'] },
  { id: 4, name: 'Diana', age: 35, department: 'Sales', skills: ['Negotiation', 'CRM'] },
  { id: 5, name: 'Eve', age: 28, department: 'Engineering', skills: ['Node.js', 'AWS'] },
  { id: 6, name: 'Frank', age: 40, department: 'HR', skills: ['Recruitment', 'Training'] }
];

// 1. find() and findIndex() - Find first matching element
console.log('1. find() and findIndex():');
const firstEngineer = users.find(user => user.department === 'Engineering');
console.log('First engineer:', firstEngineer);

const firstOver35 = users.find(user => user.age > 35);
console.log('First user over 35:', firstOver35);

const eveIndex = users.findIndex(user => user.name === 'Eve');
console.log('Eve index:', eveIndex);

// findLast() and findLastIndex() (ES2023)
if (Array.prototype.findLast) {
  const lastEngineer = users.findLast(user => user.department === 'Engineering');
  console.log('Last engineer:', lastEngineer);
}

// 2. some() and every() - Testing array elements
console.log('\n2. some() and every():');
const hasSenior = users.some(user => user.age > 35);
console.log('Has senior (>35)?', hasSenior);

const allAdults = users.every(user => user.age >= 18);
console.log('All adults?', allAdults);

const allHaveSkills = users.every(user => user.skills && user.skills.length > 0);
console.log('All have skills?', allHaveSkills);

// 3. flat() and flatMap() - Flattening arrays
console.log('\n3. flat() and flatMap():');
const nested = [1, [2, [3, [4, 5]]], 6];
console.log('flat():', nested.flat()); // Default depth: 1
console.log('flat(2):', nested.flat(2));
console.log('flat(Infinity):', nested.flat(Infinity));

const departments = users.flatMap(user => user.skills);
console.log('All skills (flatMap):', departments);

// flatMap() example: Expand and filter
const expandedUsers = users.flatMap(user => 
  user.department === 'Engineering' ? [user, { ...user, role: 'Senior' }] : []
);
console.log('Expanded engineers:', expandedUsers);

// 4. sort() - Advanced sorting
console.log('\n4. Advanced sorting:');
const sortedByAge = [...users].sort((a, b) => a.age - b.age);
console.log('Sorted by age:', sortedByAge);

// Multi-level sorting
const multiSort = [...users].sort((a, b) => {
  // First by department
  if (a.department < b.department) return -1;
  if (a.department > b.department) return 1;
  
  // Then by age (descending)
  return b.age - a.age;
});
console.log('Multi-sort (dept asc, age desc):', multiSort);

// 5. reduce() - Advanced patterns
console.log('\n5. Advanced reduce() patterns:');

// Group by department
const groupedByDept = users.reduce((acc, user) => {
  acc[user.department] = acc[user.department] || [];
  acc[user.department].push(user);
  return acc;
}, {});
console.log('Grouped by department:', groupedByDept);

// Transform array to object
const usersById = users.reduce((acc, user) => {
  acc[user.id] = user;
  return acc;
}, {});
console.log('Users by ID:', usersById);

// Flatten skills with counts
const skillCounts = users.reduce((acc, user) => {
  user.skills.forEach(skill => {
    acc[skill] = (acc[skill] || 0) + 1;
  });
  return acc;
}, {});
console.log('Skill counts:', skillCounts);

// 6. Array.from() - Creating arrays
console.log('\n6. Array.from() patterns:');

// Create range
const range = (start, end, step = 1) => 
  Array.from({ length: Math.ceil((end - start) / step) }, (_, i) => start + i * step);
console.log('Range 1-10:', range(1, 11));
console.log('Range 0-100 step 10:', range(0, 101, 10));

// Remove duplicates
const duplicates = [1, 2, 2, 3, 4, 4, 5];
const unique = Array.from(new Set(duplicates));
console.log('Remove duplicates:', unique);

// Convert NodeList/HTMLCollection
const mockNodeList = { 0: 'a', 1: 'b', 2: 'c', length: 3 };
const arrayFromNodeList = Array.from(mockNodeList);
console.log('Convert array-like:', arrayFromNodeList);

// 7. fill() - Filling arrays
console.log('\n7. fill() method:');
const emptyArray = new Array(5);
console.log('Empty array:', emptyArray);

const filled = new Array(5).fill(0);
console.log('Filled with 0:', filled);

const matrix = Array(3).fill().map(() => Array(3).fill(0));
console.log('3x3 matrix:', matrix);

// 8. copyWithin() - Copy within array
console.log('\n8. copyWithin():');
const arr = [1, 2, 3, 4, 5];
arr.copyWithin(0, 3); // Copy elements from index 3 to end to index 0
console.log('copyWithin(0, 3):', arr);

✅ When to Use Which Method

Searching

find() - Get first matching element
findIndex() - Get index of first match
findLast() - Get last matching element (ES2023)
some() - Check if any element matches
every() - Check if all elements match

Transformation

flatMap() - Map then flatten one level
reduce() - Complex aggregations
Array.from() - Create from array-like
fill() - Fill array with value
copyWithin() - Copy within array

Example 2: Performance Optimization

JavaScript Editor

// Performance Optimization with Array Methods

console.log('Performance considerations:\n');

// Create large dataset
const largeArray = Array.from({ length: 1000000 }, (_, i) => ({
  id: i,
  value: Math.random() * 1000,
  category: i % 10 === 0 ? 'special' : 'normal'
}));

// Test 1: Chaining vs Single iteration
console.time('Chained methods');
const chained = largeArray
  .filter(item => item.category === 'special')
  .map(item => ({ ...item, processed: true }))
  .slice(0, 100);
console.timeEnd('Chained methods');

console.time('Single iteration (reduce)');
const reduced = largeArray.reduce((acc, item) => {
  if (item.category === 'special' && acc.length < 100) {
    acc.push({ ...item, processed: true });
  }
  return acc;
}, []);
console.timeEnd('Single iteration (reduce)');

// Test 2: for loop vs forEach vs for...of
console.time('Traditional for loop');
const result1 = [];
for (let i = 0; i < largeArray.length; i++) {
  if (largeArray[i].value > 500) {
    result1.push(largeArray[i]);
  }
}
console.timeEnd('Traditional for loop');

console.time('forEach');
const result2 = [];
largeArray.forEach(item => {
  if (item.value > 500) {
    result2.push(item);
  }
});
console.timeEnd('forEach');

console.time('for...of');
const result3 = [];
for (const item of largeArray) {
  if (item.value > 500) {
    result3.push(item);
  }
}
console.timeEnd('for...of');

// Test 3: Early exit with some() vs every()
const targetValue = 750;
console.time('find for early exit');
const found = largeArray.find(item => item.value > targetValue);
console.timeEnd('find for early exit');

console.time('some for early exit');
let foundSome = null;
largeArray.some(item => {
  if (item.value > targetValue) {
    foundSome = item;
    return true;
  }
  return false;
});
console.timeEnd('some for early exit');

// Test 4: Set operations
const array1 = Array.from({ length: 10000 }, (_, i) => i);
const array2 = Array.from({ length: 10000 }, (_, i) => i * 2);

console.time('Intersection (filter + includes)');
const intersection1 = array1.filter(x => array2.includes(x));
console.timeEnd('Intersection (filter + includes)');

console.time('Intersection (Set)');
const set2 = new Set(array2);
const intersection2 = array1.filter(x => set2.has(x));
console.timeEnd('Intersection (Set)');

console.time('Union (concat + Set)');
const union = [...new Set([...array1, ...array2])];
console.timeEnd('Union (concat + Set)');

// Test 5: Memory efficient operations
console.log('\nMemory efficient patterns:');

// Lazy evaluation with generators
function* filterGenerator(array, predicate) {
  for (const item of array) {
    if (predicate(item)) {
      yield item;
    }
  }
}

console.time('Generator (lazy)');
const generator = filterGenerator(largeArray, item => item.value > 900);
let count = 0;
for (const item of generator) {
  if (++count >= 100) break;
}
console.timeEnd('Generator (lazy)');

// Reuse arrays when possible
console.time('In-place modification');
const mutableArray = [...largeArray.slice(0, 1000)];
for (let i = mutableArray.length - 1; i >= 0; i--) {
  if (mutableArray[i].value < 100) {
    mutableArray.splice(i, 1);
  }
}
console.timeEnd('In-place modification');

// Best Practices Summary
console.log('\n✅ Best Practices:');
console.log('1. Use single iteration (reduce) for multiple operations');
console.log('2. Use Set for membership tests on large arrays');
console.log('3. Use find()/some() for early exit scenarios');
console.log('4. Consider generators for memory efficiency');
console.log('5. Reuse arrays when mutation is acceptable');
console.log('6. Avoid nested loops with includes() on large arrays');

📊 Performance Comparison Results

Operation	Method 1	Method 2	Winner	Speed Difference
Filter + Map	Chained methods	Single reduce()	reduce()	2-3x faster
Loop types	Traditional for	forEach()	Traditional for	10-20% faster
Membership test	Array.includes()	Set.has()	Set.has()	100x+ faster
Early exit	find()	some()	Equal	Similar
Memory usage	Full copy	Generator	Generator	Minimal memory

Example 3: Advanced Patterns

JavaScript Editor

// Advanced Array Transformations and Patterns

const products = [
  { id: 1, name: 'Laptop', category: 'Electronics', price: 999, stock: 10, tags: ['tech', 'portable'] },
  { id: 2, name: 'Mouse', category: 'Electronics', price: 25, stock: 50, tags: ['tech', 'accessory'] },
  { id: 3, name: 'Desk', category: 'Furniture', price: 299, stock: 5, tags: ['office', 'wood'] },
  { id: 4, name: 'Chair', category: 'Furniture', price: 199, stock: 15, tags: ['office', 'ergonomic'] },
  { id: 5, name: 'Monitor', category: 'Electronics', price: 399, stock: 8, tags: ['tech', 'display'] },
  { id: 6, name: 'Keyboard', category: 'Electronics', price: 79, stock: 30, tags: ['tech', 'accessory'] },
];

// 1. Pipeline Pattern (Functional Programming)
console.log('1. Pipeline Pattern:');

const pipeline = [
  (arr) => arr.filter(p => p.category === 'Electronics'),
  (arr) => arr.filter(p => p.price > 50),
  (arr) => arr.sort((a, b) => a.price - b.price),
  (arr) => arr.map(p => ({ ...p, discountedPrice: p.price * 0.9 }))
];

const processedProducts = pipeline.reduce((acc, fn) => fn(acc), products);
console.log('Pipeline result:', processedProducts);

// 2. Memoization with Caching
console.log('\n2. Memoized expensive operations:');

console.log('First call:', expensiveCalculation(products, p => p.category));
console.log('Second call (cached):', expensiveCalculation(products, p => p.category));

// 3. Lazy Evaluation
console.log('\n3. Lazy evaluation with iterators:');

function* lazyFilter(array, predicate) {
  for (const item of array) {
    if (predicate(item)) {
      yield item;
    }
  }
}

function* lazyMap(array, mapper) {
  for (const item of array) {
    yield mapper(item);
  }
}

const lazyPipeline = lazyMap(
  lazyFilter(products, p => p.price > 100),
  p => ({ name: p.name, price: p.price })
);

console.log('First 3 expensive products:');
let count = 0;
for (const product of lazyPipeline) {
  console.log(product);
  if (++count >= 3) break;
}

// 4. Array Partitioning
console.log('\n4. Array partitioning:');

const partition = (array, predicate) => 
  array.reduce(([pass, fail], item) => 
    predicate(item) ? [[...pass, item], fail] : [pass, [...fail, item]]
  , [[], []]);

const [electronics, furniture] = partition(products, p => p.category === 'Electronics');
console.log('Electronics:', electronics.length, 'items');
console.log('Furniture:', furniture.length, 'items');

// 5. Window/Sliding Operations
console.log('\n5. Sliding window operations:');

const slidingWindow = (array, size, step = 1) => {
  const result = [];
  for (let i = 0; i <= array.length - size; i += step) {
    result.push(array.slice(i, i + size));
  }
  return result;
};

const prices = products.map(p => p.price);
const movingAverage = slidingWindow(prices, 3).map(window => 
  window.reduce((sum, price) => sum + price, 0) / window.length
);
console.log('Moving average of prices:', movingAverage);

// 6. Array Diffing
console.log('\n6. Array diffing:');

const oldProducts = [...products];
const newProducts = [
  ...products.slice(0, 3),
  { id: 4, name: 'Ergonomic Chair', category: 'Furniture', price: 249, stock: 10 },
  { id: 7, name: 'Tablet', category: 'Electronics', price: 499, stock: 20 }
];

const diff = arrayDiff(oldProducts, newProducts, p => p.id);
console.log('Added:', diff.added);
console.log('Removed:', diff.removed);
console.log('Changed:', diff.changed);

// 7. Flatten and Group
console.log('\n7. Flatten and group patterns:');

// Get all unique tags with product counts
const tagStats = products
  .flatMap(p => p.tags.map(tag => ({ tag, product: p.name })))
  .reduce((acc, { tag, product }) => {
    acc[tag] = acc[tag] || { count: 0, products: [] };
    acc[tag].count++;
    acc[tag].products.push(product);
    return acc;
  }, {});

console.log('Tag statistics:', tagStats);

🔧 Advanced Array Patterns

Pipeline Pattern

Chain operations in a functional style for complex transformations.

Memoization

Cache expensive array operations for repeated calls.

Lazy Evaluation

Process elements on-demand with generators for memory efficiency.

Partitioning

Split array into groups based on predicates.

Sliding Window

Process data in fixed-size moving windows.

Array Diffing

Find differences between two arrays efficiently.

Example 4: Real-World Use Cases

JavaScript Editor

// Real-World Use Cases and Patterns

// 1. E-commerce Product Filtering
console.log('1. E-commerce filtering system:');

const filter = createProductFilter(products);
const filtered = filter
  .setCategory('Electronics')
  .setPriceRange(50, 500)
  .setInStock(true)
  .getSorted('price', 'desc');

console.log('Filtered products:', filtered);

// 2. Data Aggregation and Reporting
console.log('\n2. Data aggregation for reporting:');

const sales = [
  { date: '2023-01-01', product: 'Laptop', amount: 999, region: 'North' },
  { date: '2023-01-01', product: 'Mouse', amount: 25, region: 'North' },
  { date: '2023-01-02', product: 'Laptop', amount: 999, region: 'South' },
  { date: '2023-01-02', product: 'Keyboard', amount: 79, region: 'South' },
  { date: '2023-01-03', product: 'Monitor', amount: 399, region: 'North' },
];

// Daily sales report
const dailyReport = sales.reduce((report, sale) => {
  const day = sale.date;
  report[day] = report[day] || { total: 0, products: [], regions: new Set() };
  report[day].total += sale.amount;
  report[day].products.push(sale.product);
  report[day].regions.add(sale.region);
  return report;
}, {});

// Convert Set to Array for JSON serialization
Object.keys(dailyReport).forEach(day => {
  dailyReport[day].regions = Array.from(dailyReport[day].regions);
});

console.log('Daily sales report:', dailyReport);

// 3. Form Validation and Data Cleaning
console.log('\n3. Form data validation and cleaning:');

const rawFormData = [
  { field: 'name', value: 'John Doe', required: true, type: 'string' },
  { field: 'email', value: 'john@example.com', required: true, type: 'email' },
  { field: 'age', value: '25', required: true, type: 'number' },
  { field: 'phone', value: '', required: false, type: 'string' },
  { field: 'newsletter', value: 'true', required: false, type: 'boolean' },
];

const validationResult = validateAndClean(rawFormData);
console.log('Validation result:', validationResult);

// 4. Pagination System
console.log('\n4. Pagination implementation:');

const allItems = Array.from({ length: 47 }, (_, i) => `Item ${i + 1}`);
const paginator = createPaginator(allItems, 10);

console.log('Page 3 items:', paginator.getPage(3));
console.log('Page 3 info:', paginator.getPageInfo(3));
console.log('All pages:', paginator.getAllPages());

// 5. Search and Highlight
console.log('\n5. Search with highlighting:');

const searchResults = searchInArray(products, 'tech', ['name', 'category', 'tags']);
console.log('Search results for "tech":', searchResults);

🎯 Industry Applications

E-commerce

Product filtering and sorting
Shopping cart operations
Inventory management
Recommendation engines

Data Processing

ETL pipelines
Data validation and cleaning
Report generation
Real-time analytics

UI/UX

Form handling
Search and filtering
Pagination
Sorting and grouping

Backend

API response transformation
Database query results processing
Authentication and authorization
Log processing

Example 5: Modern ES2023+ Methods

JavaScript Editor

// Modern ES2023+ Array Methods and Future

console.log('ES2023+ Array Methods:\n');

// 1. findLast() and findLastIndex()
const numbers = [1, 2, 3, 4, 5, 4, 3, 2, 1];

if (Array.prototype.findLast) {
  const lastEven = numbers.findLast(n => n % 2 === 0);
  console.log('1. findLast() - Last even number:', lastEven);
  
  const lastEvenIndex = numbers.findLastIndex(n => n % 2 === 0);
  console.log('   findLastIndex() - Index:', lastEvenIndex);
}

// 2. toReversed(), toSorted(), toSpliced() (ES2023)
// Immutable versions of reverse(), sort(), splice()
const original = [3, 1, 4, 1, 5, 9];

if (Array.prototype.toReversed) {
  const reversed = original.toReversed();
  console.log('\n2. toReversed():');
  console.log('   Original:', original);
  console.log('   Reversed:', reversed);
  console.log('   Same array?', original === reversed); // false
}

if (Array.prototype.toSorted) {
  const sorted = original.toSorted((a, b) => a - b);
  console.log('\n3. toSorted():');
  console.log('   Original:', original);
  console.log('   Sorted:', sorted);
}

if (Array.prototype.toSpliced) {
  const spliced = original.toSpliced(2, 2, 10, 11);
  console.log('\n4. toSpliced():');
  console.log('   Original:', original);
  console.log('   Spliced (replace index 2-3):', spliced);
}

// 3. with() method (ES2023) - Immutable update
if (Array.prototype.with) {
  const updated = original.with(2, 100); // Replace index 2 with 100
  console.log('\n5. with() method:');
  console.log('   Original:', original);
  console.log('   Updated (index 2 → 100):', updated);
}

// 4. Grouping methods (Stage 3 Proposal - might change)
console.log('\n6. Grouping (proposal):');

// Polyfill for grouping if not available
if (!Array.prototype.groupBy) {
  Array.prototype.groupBy = function(keyFn) {
    return this.reduce((acc, item) => {
      const key = keyFn(item);
      acc[key] = acc[key] || [];
      acc[key].push(item);
      return acc;
    }, {});
  };
}

const grouped = products.groupBy(p => p.category);
console.log('   Grouped by category:', grouped);

// 5. Performance-focused patterns
console.log('\n7. Performance patterns:');

// Typed Arrays for numeric operations
console.log('Typed Arrays for math:');
const floatArray = new Float64Array(1000000);
for (let i = 0; i < floatArray.length; i++) {
  floatArray[i] = Math.random();
}

console.time('Float64Array sum');
const typedSum = floatArray.reduce((sum, val) => sum + val, 0);
console.timeEnd('Float64Array sum');

console.time('Regular Array sum');
const regularArray = Array.from(floatArray);
const regularSum = regularArray.reduce((sum, val) => sum + val, 0);
console.timeEnd('Regular Array sum');

// 6. Array methods on other collections
console.log('\n8. Array methods on other collections:');

// Using array methods on strings
const str = 'Hello World';
const chars = Array.from(str);
const reversedStr = chars.reverse().join('');
console.log('String reversed:', reversedStr);

// Using array methods on Map/Set
const userMap = new Map([
  [1, 'Alice'],
  [2, 'Bob'],
  [3, 'Charlie']
]);

const userNames = Array.from(userMap.values());
const filteredNames = userNames.filter(name => name.length > 3);
console.log('Names from Map:', filteredNames);

// 7. Future: Array methods with async
console.log('\n9. Async array methods:');

async function asyncMap(array, asyncFn) {
  const results = [];
  for (const item of array) {
    results.push(await asyncFn(item));
  }
  return results;
}

async function asyncFilter(array, asyncPredicate) {
  const results = [];
  for (const item of array) {
    if (await asyncPredicate(item)) {
      results.push(item);
    }
  }
  return results;
}

// Simulate async operations
const asyncProducts = products.map(async p => ({
  ...p,
  asyncPrice: await Promise.resolve(p.price * 1.1)
}));

Promise.all(asyncProducts).then(results => {
  console.log('Async processed products:', results.slice(0, 2));
});

// 8. Custom array methods
console.log('\n10. Custom array utilities:');

// Add custom methods to Array prototype (carefully!)
if (!Array.prototype.unique) {
  Array.prototype.unique = function() {
    return [...new Set(this)];
  };
}

if (!Array.prototype.chunk) {
  Array.prototype.chunk = function(size) {
    const chunks = [];
    for (let i = 0; i < this.length; i += size) {
      chunks.push(this.slice(i, i + size));
    }
    return chunks;
  };
}

if (!Array.prototype.pluck) {
  Array.prototype.pluck = function(key) {
    return this.map(item => item[key]);
  };
}

const testArray = [1, 2, 2, 3, 3, 3, 4];
console.log('Unique:', testArray.unique());
console.log('Chunked:', testArray.chunk(3));
console.log('Pluck names:', products.pluck('name'));

// Best Practices
console.log('\n✅ Modern Array Best Practices:');
console.log('1. Use immutable methods (toReversed, toSorted) when possible');
console.log('2. Use findLast() for reverse searching');
console.log('3. Consider TypedArrays for numeric operations');
console.log('4. Use grouping methods for data aggregation');
console.log('5. Implement custom methods judiciously');

Exercise: Build Array Utility Library

JavaScript Editor

// Build a comprehensive array utility library

class ArrayUtils {
  // 1. Statistics
  static mean(array) {
    // Return mean/average
  }
  
  static median(array) {
    // Return median
  }
  
  static mode(array) {
    // Return mode (most frequent)
  }
  
  static standardDeviation(array) {
    // Return standard deviation
  }
  
  // 2. Set Operations
  static union(arr1, arr2) {
    // Return union of two arrays
  }
  
  static intersection(arr1, arr2) {
    // Return intersection
  }
  
  static difference(arr1, arr2) {
    // Return elements in arr1 not in arr2
  }
  
  static symmetricDifference(arr1, arr2) {
    // Return elements in either but not both
  }
  
  // 3. Data Manipulation
  static groupBy(array, keyFn) {
    // Group by key function
  }
  
  static partition(array, predicate) {
    // Split into [true, false] arrays
  }
  
  static zip(...arrays) {
    // Zip multiple arrays
  }
  
  static transpose(matrix) {
    // Transpose 2D array
  }
  
  // 4. Search and Filter
  static findIndices(array, predicate) {
    // Return all indices where predicate true
  }
  
  static findDuplicates(array, keyFn = x => x) {
    // Find duplicate values
  }
  
  static findMissing(array, completeArray) {
    // Find missing elements
  }
  
  // 5. Performance
  static batchProcess(array, batchSize, processFn) {
    // Process in batches (async friendly)
  }
  
  static memoizedTransform(array, transformFn, cacheKeyFn) {
    // Memoized transformation
  }
  
  // 6. Validation
  static isSorted(array, comparator = (a, b) => a - b) {
    // Check if array is sorted
  }
  
  static hasDuplicates(array) {
    // Check for duplicates
  }
  
  // 7. Transformation
  static flattenDeep(array) {
    // Flatten recursively
  }
  
  static rotate(array, positions) {
    // Rotate array
  }
  
  static shuffle(array) {
    // Fisher-Yates shuffle
  }
  
  // 8. Functional Programming
  static pipe(array, ...fns) {
    // Apply functions in sequence
  }
  
  static compose(array, ...fns) {
    // Apply functions in reverse order
  }
}

// Test your implementation
const testArray = [1, 2, 3, 4, 5, 4, 3, 2, 1];
const testObjects = [
  { id: 1, category: 'A', value: 10 },
  { id: 2, category: 'B', value: 20 },
  { id: 3, category: 'A', value: 30 },
  { id: 4, category: 'B', value: 40 },
  { id: 5, category: 'A', value: 50 }
];

console.log('=== Testing Statistics ===');
console.log('Mean:', ArrayUtils.mean(testArray));
console.log('Median:', ArrayUtils.median(testArray));
console.log('Mode:', ArrayUtils.mode(testArray));

console.log('\n=== Testing Set Operations ===');
console.log('Union:', ArrayUtils.union([1, 2, 3], [3, 4, 5]));
console.log('Intersection:', ArrayUtils.intersection([1, 2, 3], [3, 4, 5]));
console.log('Difference:', ArrayUtils.difference([1, 2, 3], [3, 4, 5]));

console.log('\n=== Testing Data Manipulation ===');
console.log('Group by category:', ArrayUtils.groupBy(testObjects, obj => obj.category));
console.log('Partition by value > 25:', ArrayUtils.partition(testObjects, obj => obj.value > 25));

console.log('\n=== Testing Search ===');
console.log('Find indices > 2:', ArrayUtils.findIndices(testArray, x => x > 2));
console.log('Find duplicates:', ArrayUtils.findDuplicates(testArray));

console.log('\n=== Testing Validation ===');
console.log('Is sorted?', ArrayUtils.isSorted([1, 2, 3, 4, 5]));
console.log('Has duplicates?', ArrayUtils.hasDuplicates(testArray));

console.log('\n=== Testing Transformations ===');
console.log('Rotate by 2:', ArrayUtils.rotate([1, 2, 3, 4, 5], 2));
console.log('Shuffled:', ArrayUtils.shuffle([1, 2, 3, 4, 5]));

console.log('\n=== Performance Testing ===');
const largeArray = Array.from({ length: 10000 }, (_, i) => i);
console.time('Batch process');
ArrayUtils.batchProcess(largeArray, 100, batch => batch.map(x => x * 2));
console.timeEnd('Batch process');

💡 Best Practices Summary

Use find()/some() for early exit scenarios
Prefer Set for membership tests on large arrays
Use reduce() for complex aggregations and transformations
Consider generators for memory efficiency with large datasets
Use flatMap() for map+flatten operations
Adopt ES2023+ immutable methods (toSorted(), etc.)
Benchmark performance-critical array operations
Implement custom utilities for repeated complex operations

🎯 Interview Questions on Advanced Arrays

What's the difference between find() and filter()?
How would you implement pagination using array methods?
What are the performance implications of chaining array methods?
How does flatMap() differ from map() followed by flat()?
How would you find all duplicates in an array efficiently?
What are the new array methods in ES2023 and why are they useful?
How would you implement memoization for expensive array operations?
What's the difference between Array.from() and spread syntax?
How would you handle async operations in array methods?
What are typed arrays and when would you use them?

← Shallow vs Deep Copy Map / Filter / Reduce Polyfills →

JavaScript Tutorial

Advanced Array Methods

🚀 Beyond map(), filter(), and reduce()

Array Method Categories

Search Methods

Test Methods

Transformation

New ES2023+

Example 1: Beyond Basic Methods

✅ When to Use Which Method

Searching

Transformation

Example 2: Performance Optimization

📊 Performance Comparison Results

Example 3: Advanced Patterns

🔧 Advanced Array Patterns

Pipeline Pattern

Memoization

Lazy Evaluation

Partitioning

Sliding Window

Array Diffing

Example 4: Real-World Use Cases

🎯 Industry Applications

E-commerce

Data Processing

UI/UX

Backend

Example 5: Modern ES2023+ Methods

Exercise: Build Array Utility Library

💡 Best Practices Summary

🎯 Interview Questions on Advanced Arrays

Follow Us

Our Tools

Our Company

Special Tools