Array methods

const range = (n: number) =>
  Array.from({ length: n }, (_, i) => i);
range(4); // [0, 1, 2, 3]
 
const grid = Array.from({ length: 2 }, () =>
  Array<number>(3).fill(0),
); // [[0,0,0],[0,0,0]], rows are separate arrays

async function* pages() {
  yield "a";
  yield "b";
}
const all = await Array.fromAsync(pages()); // string[]
const upper = await Array.fromAsync(
  pages(),
  (s) => s.toUpperCase(),
); // ["A", "B"]

const xs = [10, 20, 30, 40];
xs.at(-1);        // 40, typed number | undefined
xs.slice(1, 3);   // [20, 30]
xs.slice(-2);     // [30, 40]
let [a, b] = xs;
[a, b] = [b, a];  // swap without a temp

const xs = ["a", "b", "c", "d"];
// returns ["b","c"]; xs is ["a","d"]
xs.splice(1, 2);
xs.splice(1, 0, "x");    // insert at 1; xs is ["a","x","d"]
 
const ys = ["a", "b", "c"];
ys.toSpliced(1, 1);      // ["a","c"]; ys unchanged
ys.toSpliced(1, 0, "z"); // ["a","z","b","c"]
const removeAt = <T,>(arr: readonly T[], i: number) =>
  [...arr.slice(0, i), ...arr.slice(i + 1)];

const words = ["a b", "c"];
words.map((w) => w.length);       // [3, 1]
words.flatMap((w) => w.split(" ")); // ["a", "b", "c"]
[1, [2, [3, [4]]]].flat(2);         // [1, 2, 3, [4]]
 
// flatMap as filter + map in one pass
const nums = ["1", "x", "3"].flatMap((s) => {
  const n = Number(s);
  return Number.isNaN(n) ? [] : [n];
}); // number[]: [1, 3]
 
for (const [i, w] of words.entries()) {
  console.info(i, w);
}

const xs = [1, NaN, 3];
xs.indexOf(NaN);  // -1, since NaN !== NaN
xs.includes(NaN); // true
 
type User = { id: number; admin: boolean };
declare const users: User[];
const u = users.find((u) => u.id === 7); // User | undefined
if (u) u.admin;                          // narrowed
 
[].every((x) => x); // true: vacuous truth
[].some((x) => x);  // false

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };
declare const shapes: Shape[];
 
const circles = shapes.filter(
  (s): s is Extract<Shape, { kind: "circle" }> =>
    s.kind === "circle",
); // { kind: "circle"; r: number }[]

const prices = [3, 4.5, 10];
const total = prices.reduce((sum, p) => sum + p, 0); // 17.5
 
// Type the accumulator with a generic or the initial value
const counts = ["a", "b", "a"]
  .reduce<Record<string, number>>(
    (acc, k) => ({ ...acc, [k]: (acc[k] ?? 0) + 1 }),
    {},
  ); // { a: 2, b: 1 }
 
const byId = new Map(
  [{ id: 1, n: "x" }].map((o) => [o.id, o] as const),
); // Map<number, { id: number; n: string }>
 
[[1, 2], [3]].reduceRight<number[]>(
  (acc, xs) => acc.concat(xs),
  [],
); // [3, 1, 2]

type Item = { name: string; qty: number };
const stock: Item[] = [
  { name: "apple", qty: 0 },
  { name: "pear", qty: 4 },
];
 
const g = Object.groupBy(stock, (i) =>
  i.qty > 0 ? "inStock" : "soldOut",
);
g.inStock; // Item[] | undefined
 
const m = Map.groupBy(stock, (i) => i.qty > 0);
m.get(true); // Item[] | undefined

const n = [10, 9, 1];
n.toSorted((a, b) => a - b); // [1, 9, 10] ascending
n.toSorted((a, b) => b - a); // [10, 9, 1] descending
 
type P = { name: string; age: number };
declare const people: P[];
const sorted = people.toSorted(
  (a, b) => a.age - b.age || a.name.localeCompare(b.name),
); // by age, then by name
 
["é", "z", "a"].toSorted((a, b) => a.localeCompare(b));
// ["a", "é", "z"]; default sort gives ["a", "z", "é"]
 
const coll = new Intl.Collator("en", { numeric: true });
["v10", "v9", "v1"].toSorted(coll.compare); // v1, v9, v10
 
const xs = ["a", "b", "c"];
xs.with(-1, "z");  // ["a", "b", "z"]
xs.toReversed();   // ["c", "b", "a"]

const frozen: readonly number[] = [3, 1, 2];
// @ts-expect-error: sort does not exist on readonly number[]
frozen.sort();
frozen.toSorted(); // fine: returns number[]

function* naturals() {
  let n = 0;
  while (true) yield n++;
}
 
const evens = naturals()
  .filter((n) => n % 2 === 0)
  .map((n) => n * 10)
  .take(3)
  .toArray(); // [0, 20, 40]
 
const ages = new Map([["ann", 31], ["bo", 17]]);
const adults = ages
  .entries()
  .filter(([, age]) => age >= 18)
  .map(([name]) => name)
  .toArray(); // ["ann"]
 
const firstBig = Iterator.from(new Set([1, 50, 200]))
  .find((n) => n > 10); // 50

type Point = [x: number, y: number];
const p: Point = [1, 2];
const [x, y] = p;
 
type Row = [id: string, ...scores: number[]];
const r: Row = ["ann", 9, 7];
 
const dirs = ["n", "e", "s", "w"] as const;
// readonly ["n", "e", "s", "w"]
type Dir = (typeof dirs)[number]; // "n" | "e" | "s" | "w"
 
function sum(xs: readonly number[]) {
  return xs.reduce((a, b) => a + b, 0);
} // accepts number[] and readonly number[]

const maybe = [1, undefined, 3];
const nums = maybe.filter((n) => n !== undefined);
// number[] (was (number | undefined)[] before 5.5)
 
const mixed = ["a", null, "b"];
const strs = mixed.filter((s) => s != null); // string[]
 
// filter(Boolean) still does not narrow
const loose = mixed.filter(Boolean); // (string | null)[]

declare const names: string[];
const first = names[0];
// string without the flag, string | undefined with it
if (first !== undefined) first.toUpperCase();

const a: string[] = [];     // annotate empty arrays
const b = [] as number[];   // or assert
 
const c = [];               // evolving array: any[] so far
c.push(1);
c.push("x");
const d = c;                // (string | number)[]

function uniqueBy<T, K>(
  xs: readonly T[],
  key: (x: T) => K,
): T[] {
  const seen = new Set<K>();
  return xs.filter((x) => {
    const k = key(x);
    if (seen.has(k)) return false;
    seen.add(k);
    return true;
  });
}
 
type User = { id: number; email: string };
declare const users: User[];
uniqueBy(users, (u) => u.email.toLowerCase()); // first wins
 
// last wins: later Map entries overwrite earlier ones
const byId = new Map(users.map((u) => [u.id, u]));
const lastWins = [...byId.values()];

function chunk<T>(xs: readonly T[], size: number): T[][] {
  if (!Number.isInteger(size) || size < 1) {
    throw new RangeError(`size must be >= 1, got ${size}`);
  }
  return Array.from(
    { length: Math.ceil(xs.length / size) },
    (_, i) => xs.slice(i * size, i * size + size),
  );
}
 
chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
 
declare const ids: string[];
declare function deleteMany(ids: string[]): Promise<void>;
for (const batch of chunk(ids, 100)) await deleteMany(batch);

function zip<A, B>(
  as: readonly A[],
  bs: readonly B[],
): [A, B][] {
  const n = Math.min(as.length, bs.length);
  return Array.from(
    { length: n },
    (_, i) => [as[i], bs[i]] as [A, B],
  );
}
 
zip(["a", "b", "c"], [1, 2]); // [["a", 1], ["b", 2]]
 
// unzip back into two arrays
const pairs = zip(["x", "y"], [10, 20]);
const names = pairs.map(([n]) => n);   // string[]
const values = pairs.map(([, v]) => v); // number[]
 
// pairs to an object
Object.fromEntries(pairs); // { x: 10, y: 20 }

function partition<T, S extends T>(
  xs: readonly T[],
  pred: (x: T) => x is S,
): [S[], Exclude<T, S>[]];
function partition<T>(
  xs: readonly T[],
  pred: (x: T) => boolean,
): [T[], T[]];
function partition<T>(
  xs: readonly T[],
  pred: (x: T) => boolean,
): [T[], T[]] {
  const yes: T[] = [];
  const no: T[] = [];
  for (const x of xs) (pred(x) ? yes : no).push(x);
  return [yes, no];
}
 
const isEven = (n: number) => n % 2 === 0;
const [evens, odds] = partition([1, 2, 3, 4], isEven);
const mixed: (string | number)[] = ["a", 1, "b"];
const [strs, nums] = partition(
  mixed,
  (x) => typeof x === "string",
); // string[], number[]

type Num<T> = (x: T) => number;
 
const sumBy = <T>(xs: readonly T[], f: Num<T>) =>
  xs.reduce((total, x) => total + f(x), 0);
const averageBy = <T>(xs: readonly T[], f: Num<T>) =>
  xs.length === 0 ? Number.NaN : sumBy(xs, f) / xs.length;
 
function maxBy<T>(xs: readonly T[], f: Num<T>) {
  return xs.reduce<T | undefined>(
    (best, x) =>
      best === undefined || f(x) > f(best) ? x : best,
    undefined,
  );
}
 
type Line = { sku: string; price: number; qty: number };
declare const cart: Line[];
sumBy(cart, (l) => l.price * l.qty);  // order total
averageBy(cart, (l) => l.price);      // NaN when empty
maxBy(cart, (l) => l.qty)?.sku;       // biggest line
Math.max(...cart.map((l) => l.price)); // -Infinity if empty

type Key<T> = (x: T) => string | number | Date;
type Dir = "asc" | "desc";
 
function by<T>(
  ...keys: [Key<T>, Dir?][]
): (a: T, b: T) => number {
  return (a, b) => {
    for (const [key, dir = "asc"] of keys) {
      const x = key(a).valueOf();
      const y = key(b).valueOf();
      if (x === y) continue;
      const cmp = x < y ? -1 : 1;
      return dir === "asc" ? cmp : -cmp;
    }
    return 0;
  };
}
 
type Task = { done: boolean; due: Date; title: string };
declare const tasks: Task[];
tasks.toSorted(by<Task>(
  [(t) => Number(t.done)],     // open first
  [(t) => t.due, "asc"],       // then soonest
  [(t) => t.title.toLowerCase()],
));

const before = ["ann", "bo", "cy"];
const after = ["bo", "cy", "di"];
const a = new Set(before);
const b = new Set(after);
 
[...b.difference(a)];          // ["di"]   added
[...a.difference(b)];          // ["ann"]  removed
[...a.intersection(b)];        // ["bo", "cy"] kept
[...a.union(b)];               // all four
[...a.symmetricDifference(b)]; // ["ann", "di"] changed
a.isSubsetOf(b);               // false
 
// objects: diff by key, keep the full items
type Row = { id: number; name: string };
declare const oldRows: Row[];
declare const newRows: Row[];
const oldIds = new Set(oldRows.map((r) => r.id));
const added = newRows.filter((r) => !oldIds.has(r.id));

function move<T>(
  xs: readonly T[],
  from: number,
  to: number,
): T[] {
  const item = xs[from];
  if (item === undefined) return [...xs];
  return xs.toSpliced(from, 1).toSpliced(to, 0, item);
}
 
move(["a", "b", "c", "d"], 0, 2); // ["b", "c", "a", "d"]
move(["a", "b", "c", "d"], 3, 0); // ["d", "a", "b", "c"]
 
// e.g. a drag-and-drop list in React state
declare function setItems(
  update: (prev: string[]) => string[],
): void;
setItems((prev) => move(prev, 1, 0));