Lodash vs Radash vs Native JavaScript 2026

// ❌ Old: lodash
import { groupBy, cloneDeep, sortBy, uniq, chunk, flatten } from "lodash"

// ✅ New: Native JS (ES2024+)

// _.groupBy → Object.groupBy (ES2024)
const packages = [
  { name: "react", category: "ui" },
  { name: "vue", category: "ui" },
  { name: "express", category: "server" },
]
const grouped = Object.groupBy(packages, (p) => p.category)
// { ui: [{...}, {...}], server: [{...}] }

// _.cloneDeep → structuredClone (Node 17+, browsers 2022+)
const original = { data: { nested: { value: 42 } } }
const copy = structuredClone(original)
copy.data.nested.value = 99
console.log(original.data.nested.value)  // 42 — deep clone

// _.sortBy → Array.toSorted (non-mutating, ES2023)
const sorted = packages.toSorted((a, b) => a.name.localeCompare(b.name))

// _.findLast → Array.findLast (ES2023)
const lastUi = packages.findLast((p) => p.category === "ui")

// _.uniq → new Set([...])
const downloads = [100, 200, 100, 300, 200]
const unique = [...new Set(downloads)]  // [100, 200, 300]

// _.flatten (1 level) → Array.flat()
const nested = [[1, 2], [3, 4], [5]]
const flat = nested.flat()  // [1, 2, 3, 4, 5]

// _.flatMap → Array.flatMap()
const packages2 = [{ name: "react", tags: ["ui", "popular"] }, { name: "lodash", tags: ["utils"] }]
const allTags = packages2.flatMap((p) => p.tags)  // ["ui", "popular", "utils"]

// _.chunk → native (no built-in, but trivial to implement)
function chunk<T>(arr: T[], size: number): T[][] {
  return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
    arr.slice(i * size, i * size + size)
  )
}

// _.omit / _.pick → native destructuring
const { id, __v, ...rest } = dbDocument  // "omit" id and __v
const { name, email } = user  // "pick" name and email

// _.merge → structuredClone + Object.assign (for most cases)
const defaults = { timeout: 5000, retries: 3, verbose: false }
const config = { ...defaults, ...userConfig }  // shallow merge

// ❌ Bundles entire Lodash (~70KB gzipped ~24KB)
import _ from "lodash"
const result = _.merge({}, defaults, config)

// ✅ Only imports the merge function (~1KB)
import merge from "lodash/merge"
const result = merge({}, defaults, config)

// ✅ Or named imports (same as above with tree-shaking bundlers)
import { merge, debounce, throttle } from "lodash-es"  // ESM version

import debounce from "lodash/debounce"
import throttle from "lodash/throttle"
import memoize from "lodash/memoize"
import merge from "lodash/merge"

// Deep merge (structuredClone is clone-only, not merge):
const config = merge({}, defaultConfig, environmentConfig, userConfig)
// Lodash merge recursively merges nested objects — spread only does shallow

// Debounce (no native equivalent):
const searchPackages = debounce(async (query: string) => {
  const results = await fetchPackages(query)
  setResults(results)
}, 300)

// Throttle API calls:
const logActivity = throttle((event: string) => {
  analytics.track(event)
}, 1000)  // Max once per second

// Memoize expensive calculations:
const getPackageScore = memoize((packageData: PackageData): number => {
  // expensive computation
  return calculateHealthScore(packageData)
})

// Template literals (Lodash's _.template for dynamic strings):
import template from "lodash/template"
const compiled = template("Hello <%= name %>! Your package <%= pkg %> has <%= downloads %> downloads.")
const message = compiled({ name: "Royce", pkg: "react", downloads: "25M" })

import get from "lodash/get"
import set from "lodash/set"
import has from "lodash/has"
import cloneDeepWith from "lodash/cloneDeepWith"

// Safe deep property access with default (before optional chaining + nullish coalescing):
const city = get(user, "address.city", "Unknown")  // Now: user?.address?.city ?? "Unknown"

// Deep set (mutates — useful for dynamic paths):
const path = "settings.notifications.email"
set(config, path, true)

// Custom deep clone (e.g., omit certain types):
const cloned = cloneDeepWith(obj, (value) => {
  if (value instanceof Date) return new Date(value.getTime())
  // Return undefined to use default cloning for other types
})

// _.mergeWith for custom merge logic:
import mergeWith from "lodash/mergeWith"
const merged = mergeWith({}, base, override, (objValue, srcValue) => {
  if (Array.isArray(objValue)) return objValue.concat(srcValue)  // Concat arrays instead of replace
})

import { map, mapLimit, parallel, tryit, retry, sleep } from "radash"

// map: typed async map
const packageStats = await map(["react", "vue", "angular"], async (name) => {
  const stats = await fetchPackageStats(name)
  return { name, ...stats }
})

// mapLimit: concurrency-limited async map (like p-limit but built-in)
const results = await mapLimit(
  packageNames,   // Array of items
  5,              // Max 5 concurrent
  async (name) => fetchPackageData(name)
)

// parallel: object version — like Promise.all for named results
const { user, packages, stats } = await parallel({
  user: fetchUser(userId),
  packages: fetchUserPackages(userId),
  stats: fetchUsageStats(userId),
})
// All three fetches run concurrently, result is fully typed

// tryit: error handling without try/catch
const [error, data] = await tryit(fetchPackageData)("react")
if (error) {
  console.error("Failed:", error.message)
} else {
  console.log(data.downloads)
}

// retry: retry with backoff
const data = await retry(
  { times: 3, delay: 1000 },  // 3 retries, 1s delay
  async () => {
    const response = await fetch("https://api.pkgpulse.com/packages")
    if (!response.ok) throw new Error(`HTTP ${response.status}`)
    return response.json()
  }
)

// sleep: typed promise-based sleep
await sleep(500)  // Pause 500ms (vs new Promise(r => setTimeout(r, 500)))

import { pick, omit, shake, crush, construct } from "radash"

// pick: typed subset (Lodash _.pick but TypeScript-native)
const userInput = pick(formData, ["name", "email", "role"])
// TypeScript infers the return type as { name: string; email: string; role: string }

// omit: typed exclusion
const publicUser = omit(user, ["passwordHash", "internalId"])

// shake: remove null/undefined/falsy values
const cleaned = shake({ name: "react", author: null, version: "18.0.0", deprecated: undefined })
// { name: "react", version: "18.0.0" }

// crush: flatten nested object to dot-notation keys
const flat = crush({ user: { name: "Royce", address: { city: "NYC" } } })
// { "user.name": "Royce", "user.address.city": "NYC" }

// construct: reverse of crush
const nested = construct({ "user.name": "Royce", "user.address.city": "NYC" })
// { user: { name: "Royce", address: { city: "NYC" } } }

import { group, cluster, unique, diff, intersect, zip, first, last, flat } from "radash"

// group: like Object.groupBy but TypeScript-native
const byCategory = group(packages, (p) => p.category)
// Map<string, Package[]> — typed, handles missing keys

// cluster: chunk into balanced groups (more flexible than _.chunk)
const batches = cluster(packageNames, 10)  // Groups of 10

// unique: by identity or key
const uniqueByName = unique(packages, (p) => p.name)

// diff: array set difference
const removed = diff(previousPackages, currentPackages, (p) => p.id)

// zip: typed tuple zip
const pairs = zip(["react", "vue"], [25000000, 8000000])
// [["react", 25000000], ["vue", 8000000]]

import { pascal, camel, snake, title, trim, uid } from "radash"

// String case conversion (TypeScript-safe):
pascal("hello world")   // "HelloWorld"
camel("hello-world")    // "helloWorld"
snake("helloWorld")     // "hello_world"
title("npm package")    // "Npm Package"

// Generate unique IDs:
const id = uid(16)      // 16-char random alphanumeric
const longId = uid(32, "0123456789abcdef")  // Hex ID

// Before (Lodash):
import { groupBy, cloneDeep, sortBy, uniq, merge, debounce, mapSeries } from "lodash"

// After:
// groupBy → native
const grouped = Object.groupBy(items, (i) => i.category)

// cloneDeep → native
const copy = structuredClone(obj)

// sortBy → native
const sorted = items.toSorted((a, b) => a.name.localeCompare(b.name))

// uniq → native
const unique = [...new Set(ids)]

// merge → still use lodash/merge (no native equivalent for deep merge)
import merge from "lodash/merge"

// debounce → still use lodash/debounce or write your own
import debounce from "lodash/debounce"

// mapSeries (sequential async map) → radash
import { map } from "radash"  // radash map is sequential by default
// Or use mapLimit for controlled concurrency:
import { mapLimit } from "radash"
await mapLimit(items, 1, processor)  // limit=1 is sequential