String methods

const name = "Ada";
const msg = `Hi ${name},
you have ${2 + 3} messages`; // keeps the newline
 
function html(
  strings: TemplateStringsArray,
  ...values: unknown[]
): string {
  return strings.reduce((out, s, i) => {
    const v = i < values.length
      ? esc(String(values[i]))
      : "";
    return out + s + v;
  }, "");
}
const esc = (s: string) =>
  s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
 
html`<p>${"<b>"}</p>`; // "<p>&#60;b&#62;</p>"
String.raw`C:\new\t${1 + 1}`; // "C:\new\t2"

const s = "a😀";
s.length;             // 3: "a" + two surrogate halves
s.charCodeAt(1);      // 55357 (a lone high surrogate)
s.codePointAt(1);     // 128512
[...s];               // ["a", "😀"]
String.fromCodePoint(0x1f600); // "😀"
 
for (const ch of s) {
  // iterates code points: "a", "😀"
}

const log = "GET /a 200, POST /b 404";
log.includes("POST");              // true
log.search(/\d{3}/);               // 7
 
const m = log.match(/(?<verb>[A-Z]+) (?<path>\S+)/);
m?.groups?.verb;                   // "GET"
log.match(/\d{3}/g);               // ["200", "404"]
 
for (const hit of log.matchAll(/(\w+) (\S+) (\d+)/g)) {
  const [, verb, path, code] = hit;
  console.info(hit.index, verb, path, code);
}

const csvLine = "id, name ,  email";
const cols = csvLine.split(",").map((c) => c.trim());
// ["id", "name", "email"]
 
const [user, domain = ""] = "ada@example.com".split("@");
const ext = "photo.final.jpg".split(".").at(-1); // "jpg"

"2026-09-25".replace(/(\d+)-(\d+)-(\d+)/, "$3/$2/$1");
// "25/09/2026"
 
"2026-09".replace(
  /(?<y>\d{4})-(?<m>\d{2})/,
  "$<m>/$<y>",
); // "09/2026"
 
"price: $5".replace("$5", "$$10"); // "price: $10"
 
// Function replacer: (match, ...groups, offset, input)
const camel = "a-b_c d".replace(
  /[-_ ](\w)/g,
  (_, c: string) => c.toUpperCase(),
); // "aBCD"
 
"a.b.c".replaceAll(".", "/"); // "a/b/c" (string, no regex)

const collator = new Intl.Collator("en", {
  numeric: true,       // "file2" before "file10"
  sensitivity: "base", // ignore case and accents
});
const files = ["file10", "File2", "file1"];
files.toSorted(collator.compare); // file1, File2, file10
 
const eqI = (a: string, b: string) =>
  collator.compare(a, b) === 0;
eqI("Résumé", "resume"); // true

const date = /(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/d;
const r = date.exec("on 2026-09-25");
r?.groups?.y;           // "2026"
r?.indices?.groups?.m;  // [8, 10]
 
/\d+(?=px)/.exec("12px 3em")?.[0];  // "12"
/(?<=\$)\d+/.exec("cost $40")?.[0]; // "40"
 
/[\p{L}--[a-z]]/v.test("B");        // true: letter, not a-z
// true: whole family emoji
/^\p{RGI_Emoji}$/v.test("👨‍👩‍👧");
 
const escaped = RegExp.escape("1+1=2?"); // ES2025
new RegExp(`^${escaped}$`).test("1+1=2?"); // true

const seg = new Intl.Segmenter("en", {
  granularity: "grapheme", // also "word", "sentence"
});
const graphemes = (s: string) =>
  Array.from(seg.segment(s), (x) => x.segment);
 
graphemes("👨‍👩‍👧!").length;         // 2
const reverse = (s: string) =>
  graphemes(s).toReversed().join(""); // emoji-safe
 
const words = Array.from(
  new Intl.Segmenter("en", { granularity: "word" })
    .segment("Hi, you!"),
).filter((x) => x.isWordLike).map((x) => x.segment);
// ["Hi", "you"]

const usd = new Intl.NumberFormat("en-US", {
  style: "currency",
  currency: "USD",
});
usd.format(1234.5); // "$1,234.50"
 
new Intl.NumberFormat("de-DE", {
  style: "currency",
  currency: "EUR",
}).format(1234.5); // "1.234,50 €"
 
const compact = new Intl.NumberFormat("en", {
  notation: "compact",
});
compact.format(1_234_567); // "1.2M"
 
new Intl.NumberFormat("en", {
  style: "unit",
  unit: "kilometer-per-hour",
}).format(50); // "50 km/h"
 
new Intl.NumberFormat("en", {
  style: "percent",
  maximumFractionDigits: 1,
}).format(0.256); // "25.6%"

const d = new Date(Date.UTC(2026, 8, 25, 14, 30));
 
new Intl.DateTimeFormat("en-US", {
  dateStyle: "medium",
  timeStyle: "short",
  timeZone: "America/New_York",
}).format(d); // "Sep 25, 2026, 10:30 AM"
 
new Intl.DateTimeFormat("en-GB", {
  dateStyle: "long",
  timeZone: "UTC",
}).format(d); // "25 September 2026"
 
const rtf = new Intl.RelativeTimeFormat("en", {
  numeric: "auto",
});
rtf.format(-1, "day"); // "yesterday"
rtf.format(3, "week"); // "in 3 weeks"
 
new Intl.ListFormat("en", { type: "disjunction" })
  .format(["tea", "coffee"]); // "tea or coffee"

const ordinal = new Intl.PluralRules("en", {
  type: "ordinal",
});
const suffix: Record<Intl.LDMLPluralRule, string> = {
  zero: "th", one: "st", two: "nd",
  few: "rd", many: "th", other: "th",
};
const nth = (n: number) =>
  `${n}${suffix[ordinal.select(n)]}`;
nth(1);  // "1st"
nth(22); // "22nd"
nth(11); // "11th"

type Method = "GET" | "POST";
let m: Method = "GET";
// @ts-expect-error: "PUT" is not a Method
m = "PUT";
 
const verb = "GET";  // type "GET" (const infers literal)
let v2 = "GET";      // type string (let widens)
 
type Px = `${number}px`;
const w: Px = "12px";
// @ts-expect-error: "12em" does not match `${number}px`
const bad: Px = "12em";
 
type UiEvent = "click" | "focus";
type Handler = `on${Capitalize<UiEvent>}`;
// "onClick" | "onFocus"
 
type Axis = "x" | "y";
type Prop = `${Axis}${"Min" | "Max"}`;
// "xMin" | "xMax" | "yMin" | "yMax"

type Param<S extends string> =
  S extends `${string}:${infer P}/${infer Rest}`
    ? P | Param<`/${Rest}`>
    : S extends `${string}:${infer P}`
      ? P
      : never;
 
type P = Param<"/users/:id/posts/:postId">;
// "id" | "postId"
 
type Getters<T> = {
  [K in keyof T & string as `get${Capitalize<K>}`]:
    () => T[K];
};
type G = Getters<{ name: string; age: number }>;
// { getName: () => string; getAge: () => number }

type Email = string & { readonly __brand: "Email" };
 
function toEmail(s: string): Email {
  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s)) {
    throw new Error(`Invalid email: ${s}`);
  }
  return s as Email;
}
 
function send(to: Email) {
  return to.toLowerCase(); // all string methods still work
}
 
send(toEmail("ada@example.com"));
// @ts-expect-error: plain string is not an Email
send("ada@example.com");