JavaScript Array Methods

const marks = [45, 82, 30, 91, 67];

// The callback gets value, index, array - declare only what you use
marks.forEach((value, index) => {
  console.log(index, value);
});

// Non-mutating: the original survives
const doubled = marks.map(m => m * 2);
console.log(doubled);   // [90, 164, 60, 182, 134]
console.log(marks);     // [45, 82, 30, 91, 67] - untouched

// Mutating: the original is reordered for everyone holding it
const copy = [...marks];
copy.sort((a, b) => a - b);
console.log(copy);      // [30, 45, 67, 82, 91]
console.log(marks);     // [45, 82, 30, 91, 67] - safe, because we copied

const students = [
  { id: 1, name: 'Ananya', marks: 82 },
  { id: 2, name: 'Rahul', marks: 68 },
  { id: 3, name: 'Priya', marks: 91 }
];

// Same length out as in
const names = students.map(s => s.name);
console.log(names);          // ['Ananya', 'Rahul', 'Priya']

// Reshape - note the brackets needed around a returned object literal
const summary = students.map(s => ({ name: s.name, passed: s.marks >= 40 }));
console.log(summary[0]);     // { name: 'Ananya', passed: true }

// The classic mistake: braces, but no return
const broken = students.map(s => { s.name; });
console.log(broken);         // [undefined, undefined, undefined]

// The index is the second argument
const ranked = students.map((s, i) => `${i + 1}. ${s.name}`);
console.log(ranked);         // ['1. Ananya', '2. Rahul', '3. Priya']

// map + join is how you build HTML or CSV from data
console.log(names.join(', '));   // 'Ananya, Rahul, Priya'

const students = [
  { id: 1, name: 'Ananya', marks: 82 },
  { id: 2, name: 'Rahul', marks: 38 },
  { id: 3, name: 'Priya', marks: 91 }
];

// filter: any number of results, always an array
const passed = students.filter(s => s.marks >= 40);
console.log(passed.length);                     // 2
console.log(students.filter(s => s.marks > 100));  // [] - empty, not undefined

// find: the first match, or undefined
const rahul = students.find(s => s.id === 2);
console.log(rahul.name);                        // 'Rahul'

const missing = students.find(s => s.id === 9);
console.log(missing);                           // undefined
// console.log(missing.name);                   // TypeError
console.log(missing?.name ?? 'Not found');      // 'Not found'

// findIndex then splice - and check for -1 first
const i = students.findIndex(s => s.id === 2);
if (i !== -1) {
  students.splice(i, 1);
}
console.log(students.length);                   // 2

const marks = [45, 82, 30, 91, 67];

// Sum: the accumulator starts at 0
const total = marks.reduce((sum, m) => sum + m, 0);
console.log(total);                                // 315
console.log((total / marks.length).toFixed(2));    // '63.00'

// Highest, without Math.max
const highest = marks.reduce((best, m) => (m > best ? m : best), marks[0]);
console.log(highest);                              // 91

// Reduce into an object: counting by band
const bands = marks.reduce((counts, m) => {
  const band = m >= 75 ? 'high' : m >= 40 ? 'mid' : 'low';
  counts[band] = (counts[band] ?? 0) + 1;
  return counts;                 // returning the accumulator is essential
}, {});
console.log(bands);                                // { mid: 2, high: 2, low: 1 }

// Build a lookup keyed by id
const students = [{ id: 7, name: 'Ananya' }, { id: 9, name: 'Priya' }];
const byId = students.reduce((acc, s) => {
  acc[s.id] = s;
  return acc;
}, {});
console.log(byId[9].name);                         // 'Priya'

// No initial value on an empty array throws
// console.log([].reduce((a, b) => a + b));        // TypeError
console.log([].reduce((a, b) => a + b, 0));        // 0

const marks = [45, 82, 30, 91, 67];

console.log(marks.some(m => m > 90));      // true  - stops at 91
console.log(marks.every(m => m >= 40));    // false - stops at 30
console.log(marks.includes(82));           // true
console.log(marks.indexOf(82));            // 1
console.log(marks.indexOf(999));           // -1

// Empty arrays: every is true, some is false
console.log([].every(m => m > 100));       // true
console.log([].some(m => m > 100));        // false

// includes handles NaN; indexOf cannot
console.log([NaN].includes(NaN));          // true
console.log([NaN].indexOf(NaN));           // -1

// On objects, includes compares identity - use some for contents
const students = [{ id: 1 }, { id: 2 }];
console.log(students.includes({ id: 1 }));       // false
console.log(students.some(s => s.id === 1));     // true

const students = [
  { name: 'Ananya', marks: 82 },
  { name: 'Rahul', marks: 38 },
  { name: 'Priya', marks: 91 },
  { name: 'Imran', marks: 57 }
];

// One operation per line reads top to bottom
const topPassers = students
  .filter(s => s.marks >= 40)
  .map(s => s.name)
  .join(', ');
console.log(topPassers);        // 'Ananya, Priya, Imran'

// Safe: sort is applied to the array filter just created
const ordered = students
  .filter(s => s.marks >= 40)
  .sort((a, b) => b.marks - a.marks)
  .map(s => s.name);
console.log(ordered);           // ['Priya', 'Ananya', 'Imran']

// Unsafe: this reorders the original students array for everyone
// students.sort((a, b) => b.marks - a.marks);

// Safe version if you must start with a sort
const byMarks = [...students].sort((a, b) => b.marks - a.marks);
console.log(byMarks[0].name);   // 'Priya'
console.log(students[0].name);  // 'Ananya' - original order intact