JavaScript utility functions: strings, arrays, objects

How it works: capitalize upper-cases just the first character and leaves the rest untouched; capitalizeWords uses a regex matching the first letter of every word boundary (\b\w) to title-case a whole sentence.

function capitalize(str) {
  if (!str) return str
  return str.charAt(0).toUpperCase() + str.slice(1)
}

function capitalizeWords(str) {
  return str.replace(/\b\w/g, (char) => char.toUpperCase())
}

// Example usage
capitalize('hello world')      // "Hello world"
capitalizeWords('hello world') // "Hello World"

How it works: it divides the dot product by the product of both vectors' magnitudes, so the result stays in the same -1, 1 range regardless of vector length — 1 means identical direction (very similar meaning), 0 means unrelated, -1 means opposite.

function cosineSimilarity(a, b) {
  let dot = 0
  let normA = 0
  let normB = 0
  const len = Math.min(a.length, b.length)

  for (let i = 0; i < len; i++) {
    dot += a[i] * b[i]
    normA += a[i] * a[i]
    normB += b[i] * b[i]
  }

  const magnitude = Math.sqrt(normA) * Math.sqrt(normB)
  return magnitude === 0 ? 0 : dot / magnitude
}

// Example usage — compare a query embedding against a stored chunk
const similarity = cosineSimilarity(queryEmbedding, chunkEmbedding)
// closer to 1 = more similar

Note: if your embedding provider (e.g. OpenAI) guarantees unit-normalized vectors, a plain dot product alone already equals cosine similarity and is cheaper to compute at scale — this version handles the general case where vectors aren't pre-normalized.

How it works: addTag routes through a Set to dedupe, removeTag just filters — both re-sort before returning, so the array is always in a predictable order for rendering as chips.

function addTag(tags, tag) {
  const set = new Set(tags)
  set.add(tag)
  return Array.from(set).sort()
}

function removeTag(tags, tag) {
  return tags.filter((t) => t !== tag).sort()
}

// Example usage
let tags = ['vue', 'css']
tags = addTag(tags, 'javascript') // ['css', 'javascript', 'vue']
tags = removeTag(tags, 'css')     // ['javascript', 'vue']

How it works: structuredClone (Node 17+, all modern browsers) correctly copies Date, Map, Set, ArrayBuffer, and circular references. The JSON fallback is simpler but drops undefined, Date objects, functions, and special types.

function deepClone(value) {
  if (typeof structuredClone === 'function') {
    return structuredClone(value)
  }
  // Fallback for old environments (loses Date, undefined, functions)
  return JSON.parse(JSON.stringify(value))
}

// Example usage
const original = { user: { name: 'Alice', tags: ['admin'] }, createdAt: new Date() }
const clone = deepClone(original)

clone.user.tags.push('editor')
console.log(original.user.tags) // ['admin'] — original untouched

How it works: it checks the number's magnitude (billions, millions, thousands) and divides accordingly, trimming a trailing ".0" so "2.0M" reads as "2M".

function formatCompactNumber(n) {
  const abs = Math.abs(n)
  if (abs >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(1).replace(/\.0$/, '')}B`
  if (abs >= 1_000_000) return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, '')}M`
  if (abs >= 1_000) return `${(n / 1_000).toFixed(1).replace(/\.0$/, '')}K`
  return `${n}`
}

// Example usage
formatCompactNumber(600000)   // "600K"
formatCompactNumber(2000000)  // "2M"
formatCompactNumber(1200)     // "1.2K"

How it works: first transliterates Cyrillic to Latin, then lowercases the string, strips all characters except letters, digits, and hyphens, and replaces whitespace with hyphens.

const CYRILLIC_MAP = {
  а:'a',б:'b',в:'v',г:'g',д:'d',е:'e',ё:'yo',ж:'zh',з:'z',и:'i',
  й:'j',к:'k',л:'l',м:'m',н:'n',о:'o',п:'p',р:'r',с:'s',т:'t',
  у:'u',ф:'f',х:'kh',ц:'ts',ч:'ch',ш:'sh',щ:'shch',ъ:'',ы:'y',ь:'',
  э:'e',ю:'yu',я:'ya',
}

function transliterate(str) {
  return str
    .split('')
    .map((ch) => CYRILLIC_MAP[ch.toLowerCase()] ?? ch)
    .join('')
}

function generateSlug(str) {
  return transliterate(str)
    .toLowerCase()
    .trim()
    .replace(/[^\w\s-]/g, '')
    .replace(/[\s_]+/g, '-')
    .replace(/^-+|-+$/g, '')
}

// Example usage
generateSlug('Hello World 2026') // 'hello-world-2026'
generateSlug('  --foo bar--  ')  // 'foo-bar'

How it works: crypto.randomUUID() (Node 14.17+, all modern browsers) is cryptographically random and RFC 4122 v4-compliant; the fallback reproduces the same format for older runtimes but is NOT cryptographically secure.

function generateUuid() {
  if (typeof crypto !== 'undefined' && crypto.randomUUID) {
    return crypto.randomUUID()
  }
  // Fallback for environments without crypto.randomUUID (older Node/browsers)
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (Math.random() * 16) | 0
    const v = c === 'x' ? r : (r & 0x3) | 0x8
    return v.toString(16)
  })
}

// Example usage
generateUuid() // "3f9a1c2e-8b3d-4c1a-9f2e-6d8b1a4c7e9f"

How it works: pickKeys keeps only the requested keys, omitKeys keeps everything except them — both build a fresh object rather than mutating the original.

function pickKeys(obj, keys) {
  if (!obj) return {}
  return keys.reduce((acc, key) => {
    if (key in obj) acc[key] = obj[key]
    return acc
  }, {})
}

function omitKeys(obj, keys) {
  if (!obj) return {}
  return Object.entries(obj).reduce((acc, [key, value]) => {
    if (!keys.includes(key)) acc[key] = value
    return acc
  }, {})
}

// Example usage
const user = { id: 1, name: 'Alex', password: 'secret', email: '[email protected]' }
pickKeys(user, ['id', 'name']) // { id: 1, name: 'Alex' }
omitKeys(user, ['password'])   // { id: 1, name: 'Alex', email: '[email protected]' }

How it works: Intl.PluralRules classifies a count into a plural category ('one', 'few', 'many', 'other', ...) per locale rules; you map each category to the right word form instead of hardcoding an "add s" rule that only works for English.

function pluralize(count, singular, options = {}) {
  const { locale = 'en-US', plural, forms = {} } = options
  const category = new Intl.PluralRules(locale).select(count)

  const word = forms[category] || (category === 'one' ? singular : plural || `${singular}s`)
  return `${count} ${word}`
}

// Example usage
pluralize(1, 'apple') // "1 apple"
pluralize(5, 'apple') // "5 apples"

// Russian needs multiple forms (one/few/many)
pluralize(3, 'яблоко', {
  locale: 'ru-RU',
  forms: { one: 'яблоко', few: 'яблока', many: 'яблок' }
}) // "3 яблока"

How it works: Set only stores unique values, so spreading it back into an array dedupes primitives in one line; for objects (which are never "equal" to each other by reference), you instead track seen key values manually while filtering.

// Primitives — numbers, strings, etc.
const unique = [...new Set([1, 2, 2, 3, 3, 3])] // [1, 2, 3]

// Objects — dedupe by a specific key
function uniqueByKey(items, key) {
  const seen = new Set()
  return items.filter((item) => {
    if (seen.has(item[key])) return false
    seen.add(item[key])
    return true
  })
}

// Example usage
uniqueByKey(
  [{ id: 1, name: 'A' }, { id: 2, name: 'B' }, { id: 1, name: 'A (dup)' }],
  'id'
) // [{ id: 1, name: 'A' }, { id: 2, name: 'B' }]

How it works: null/undefined/empty-string input is treated as "no value" and returns null immediately; anything else goes through a try/catch so malformed JSON returns null instead of throwing.

function safeJsonParse(raw) {
  if (raw === null || raw === undefined || raw === '') return null

  try {
    return JSON.parse(raw)
  } catch {
    return null
  }
}

// Example usage — instead of a try/catch at every call site
const session = safeJsonParse(await redis.get('session:123'))
if (!session) {
  // treat as "no session" rather than crashing
}

How it works: string values are lowercased and trimmed, then checked against configurable truthy/falsy word lists; numbers are truthy unless they're 0 or NaN; anything else falls back to plain Boolean(value).

function toBoolean(value, options = {}) {
  const {
    truthyValues = ['true', 'yes', 'on', 'y', '1'],
    falsyValues = ['false', 'no', 'off', 'n', '0', '']
  } = options

  if (typeof value === 'string') {
    const normalized = value.toLowerCase().trim()
    if (truthyValues.includes(normalized)) return true
    if (falsyValues.includes(normalized)) return false
  }

  if (typeof value === 'number') return value !== 0 && !Number.isNaN(value)

  return Boolean(value)
}

// Example usage
toBoolean('yes') // true
toBoolean('0')   // false
toBoolean(process.env.FEATURE_FLAG) // works great for env vars

How it works: splits the string on whitespace, counts words. If the word count is within the limit, returns the original unchanged. Otherwise slices to the desired word count and appends the suffix.

function truncateWords(text, maxWords, suffix = '…') {
  const words = text.trim().split(/\s+/)
  if (words.length <= maxWords) return text
  return words.slice(0, maxWords).join(' ') + suffix
}

function truncateChars(text, maxChars, suffix = '…') {
  if (text.length <= maxChars) return text
  return text.slice(0, maxChars).trimEnd() + suffix
}

// Example usage
truncateWords('The quick brown fox jumped', 3) // 'The quick brown…'
truncateWords('Short', 10)                     // 'Short'
truncateChars('Hello World', 7)                // 'Hello W…'

The regex checks a common address shape with @ and a dotted domain. It is a heuristic: it can reject unusual valid addresses and accept invalid ones. The example counts JavaScript string units, not SMTP byte limits. Send a confirmation email to verify ownership. The ASCII variant below is not a complete standards validator either.

function isValidEmail(email) {
  if (!email || typeof email !== 'string') return false
  const trimmed = email.trim()
  if (trimmed.length > 254) return false
  return /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(trimmed)
}

// Simplified ASCII variant; IDNs may be represented in Punycode
function isValidEmailStrict(email) {
  const re = /^[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}$/
  return re.test((email ?? '').trim().toLowerCase())
}

// Example usage
isValidEmail('[email protected]')    // true
isValidEmail('[email protected]')  // true
isValidEmail('notanemail')          // false
isValidEmail('missing@tld')         // false

How it works: isValidHttpsUrl relies on the URL constructor throwing on malformed input rather than hand-rolling a regex; isMediaUrl checks the extension against a known list, also allowing for a trailing query string (photo.jpg?size=large).

function isValidHttpsUrl(url) {
  if (!url) return false
  try {
    return new URL(url).protocol === 'https:'
  } catch {
    return false
  }
}

function isMediaUrl(url) {
  if (!url) return false
  const extensions = ['.jpg', '.jpeg', '.png', '.gif', '.mp4', '.mp3', '.ogg', '.wav']
  const lower = url.toLowerCase()
  return extensions.some((ext) => lower.endsWith(ext) || lower.includes(`${ext}?`))
}

// Example usage
isValidHttpsUrl('https://example.com/photo.jpg') && isMediaUrl('https://example.com/photo.jpg')
// true — safe to treat as a media attachment