Coming from Lodash

Each heading is a Lodash function. The Perkakas equivalent is checked against @vinicunca/perkakas v1.17.1. Names that Remeda documents but Perkakas does not ship are called out. In-page links such as #reverse jump to that Lodash section.

add

Lodash add → add.

assign

Lodash assign → merge.

• In Lodash the merge is done in-place, on the first argument to the function. In Perkakas a new object is always returned, and none of the input objects are mutated.
• In Lodash assign can be used to merge any number of objects by accepting a variadic argument list. In Perkakas, if you are merging only 2 objects use merge, but if you need to merge more than 2 objects use mergeAll instead, which takes an Array of objects.

// Lodash
const DATA = { a: 1, b: 2 };
assign(DATA, b);
assign(DATA, b, c, d, e);

// Perkakas
let DATA = { a: 1, b: 2 };
DATA = merge(DATA, b);
DATA = mergeAll([DATA, b, c, d, e]);

camelCase

Lodash camelCase → toCamelCase.

• Lodash attempts pseudo-linguistic word splitting to handle special characters, which might lead to inaccurate results. Perkakas uses a simpler word splitting approach based on type-fest's definition that should only be used for simple strings like identifiers and internal keys. For linguistic processing where language and locale nuances matter, use the built-in Intl.Segmenter instead.
• Perkakas treats consecutive uppercase characters differently from Lodash. Use { preserveConsecutiveUppercase: false } as the second parameter to get the same results.
• Lodash performs normalization on the input before splitting it, including deburr and removing apostrophes. Perkakas's word splitting is simpler and doesn't include these normalizations, so they need to be done manually if required.
• Lodash allows calling camelCase without any input, or with an undefined input, which isn't supported in Perkakas. Handle these cases before calling the function.

Simple strings

// Lodash
_.camelCase(input);

// Perkakas
toCamelCase(input, { preserveConsecutiveUppercase: false });

Normalized

// Lodash
_.camelCase(input);

// Perkakas + Native
toCamelCase(
  input
    // "Promote" diacritics to be independent characters in the string.
    .normalize('NFD')
    // Remove apostrophes and all independent diacritic characters.
    .replace(/['\u2019\u0300-\u036F]/g, ''),
  { preserveConsecutiveUppercase: false },
);

Missing input

// Lodash
_.camelCase();
_.camelCase(input);

// Perkakas
('');
input !== undefined
  ? toCamelCase(input, { preserveConsecutiveUppercase: false })
  : '';

// Or
toCamelCase(input ?? '', { preserveConsecutiveUppercase: false });

capitalize

Lodash capitalize → capitalize.

• Lodash converts the entire string to lowercase first, while Perkakas only capitalizes the first character. To match Lodash behavior, call toLowerCase first.
• For display purposes, prefer using CSS; use text-transform: lowercase on the element, then use ::first-letter to target just the first letter of the word, and use text-transform: uppercase to capitalize it.

Runtime

// Lodash
_.capitalize(input);

// Perkakas
capitalize(toLowerCase(input));

CSS

// Lodash
<div>{_.capitalize(input)}</div>

// CSS
<style>
  .capitalize {
    text-transform: lowercase;
  }

  .capitalize::first-letter {
    text-transform: uppercase;
  }
</style>
<div class="capitalize">{input}</div>

ceil

Lodash ceil → ceil.

chunk

Lodash chunk → chunk.

clamp

Lodash clamp → clamp.

cloneDeep

Lodash cloneDeep → clone.

compact

Lodash compact → filter.

Use isTruthy as the predicate.

// Lodash
compact(DATA);

// Perkakas
filter(DATA, isTruthy);

concat

Lodash concat → concat.

cond

Lodash cond → conditional.

constant

Lodash constant → constant.

countBy

Lodash countBy → countBy.

debounce

Lodash debounce → funnel.

• debounce can be implemented using the funnel utility. A reference implementation is provided below, and a more expanded version with inline documentation and tests is available in the test file funnel.lodash-debounce.test.ts.
• A more complete reference implementation that also maintains Lodash's capability to store the callback's return value is available below, and in funnel.lodash-debounce-with-cached-value.test.ts.
• These implementations can be copied as-is into your project, but might contain redundant parts which are not relevant for your specific use cases. By inlining only the parts you need you can take advantage of capabilities not available in Lodash. To copy the expanded versions from the test files instead, take everything between the REFERENCE START and REFERENCE END markers.

Reference

import { funnel } from '@vinicunca/perkakas';

function debounce<F extends (...args: any) => void>(
  func: F,
  wait = 0,
  {
    leading = false,
    trailing = true,
    maxWait,
  }: {
    readonly leading?: boolean;
    readonly trailing?: boolean;
    readonly maxWait?: number;
  } = {},
) {
  const {
    call,
    isIdle: _isIdle,
    ...rest
  } = funnel(
    () => {
      if (leading || trailing) {
        func();
      }
    },
    {
      minQuietPeriodMs: wait,
      ...(maxWait !== undefined && { maxBurstDurationMs: maxWait }),
      ...(trailing
        ? leading
          ? { triggerAt: 'both' }
          : { triggerAt: 'end' }
        : { triggerAt: 'start' }),
    },
  );
  return Object.assign(call, rest);
}

With call arguments

import { funnel } from '@vinicunca/perkakas';

function debounce<F extends (...args: any) => void>(
  func: F,
  wait = 0,
  {
    leading = false,
    trailing = true,
    maxWait,
  }: {
    readonly leading?: boolean;
    readonly trailing?: boolean;
    readonly maxWait?: number;
  } = {},
) {
  const {
    call,
    isIdle: _isIdle,
    ...rest
  } = funnel(
    (args: Parameters<F>) => {
      if (leading || trailing) {
        func(...args);
      }
    },
    {
      reducer: (_, ...args: Parameters<F>) => args,
      minQuietPeriodMs: wait,
      ...(maxWait !== undefined && { maxBurstDurationMs: maxWait }),
      ...(trailing
        ? leading
          ? { triggerAt: 'both' }
          : { triggerAt: 'end' }
        : { triggerAt: 'start' }),
    },
  );
  return Object.assign(call, rest);
}

With cached value

import { funnel } from '@vinicunca/perkakas';

function debounce<F extends (...args: any) => any>(
  func: F,
  wait = 0,
  {
    leading = false,
    trailing = true,
    maxWait,
  }: {
    readonly leading?: boolean;
    readonly trailing?: boolean;
    readonly maxWait?: number;
  } = {},
) {
  let cachedValue: ReturnType<F> | undefined;

  const { call, flush, cancel } = funnel(
    (args: Parameters<F>) => {
      if (leading || trailing) {
        cachedValue = func(...args) as ReturnType<F>;
      }
    },
    {
      reducer: (_, ...args: Parameters<F>) => args,
      minQuietPeriodMs: wait,
      ...(maxWait !== undefined && { maxBurstDurationMs: maxWait }),
      ...(trailing
        ? leading
          ? { triggerAt: 'both' }
          : { triggerAt: 'end' }
        : { triggerAt: 'start' }),
    },
  );
  return Object.assign(
    (...args: Parameters<F>) => {
      call(...args);
      return cachedValue;
    },
    {
      flush: () => {
        flush();
        return cachedValue;
      },

      cancel,
    },
  );
}

deburr

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

deburr uses hard-coded heuristics which can lead to inaccurate results:

• Misses some accented characters (e.g., ḩ, ố, ῷ and й).
• Erroneously "simplifies" ligatures that don't formally have any diacritics that require "deburring" (e.g., Æ, IJ, Œ, and ʼn).
• Swaps characters because they look similar although they are semantically unrelated to each other (e.g., Ð, Ø, Þ, ß, ſ).

We strongly recommend using linguistically-aware alternatives instead that are purpose-built for this task:

• When comparing strings, prefer Intl.Collator with sensitivity: 'base' to compare them while ignoring accents and case.
• When simplifying strings, prefer normalize("NFD") to decompose characters, then use replace to remove diacritics. This solution is more accurate, but is not a drop-in replacement for deburr because of the differences mentioned above.
• When querying for a string, prefer purpose built collations and other built-in mechanisms of databases and other systems that offer more robust query normalization.

Comparison

// Lodash
_.deburr('café') === 'cafe';

// Native JS
const collator = new Intl.Collator('en', { sensitivity: 'base' });
collator.compare('café', 'cafe') === 0;

Simplifying

// Lodash
_.deburr(input);

// Native JS
input
  .normalize('NFD')
  .replace(
    /[\u0300-\u036F]/g /* The "Combining Diacritical Marks" Unicode block. */,
    '',
  );

defaultTo

Lodash defaultTo → defaultTo.

• Number.NaN is not considered nullish and would not result in returning the default value. Use when with the built-in Number.isNaN and a constant for the fallback value.
• Unlike in Perkakas, Lodash allows the fallback value to be of any type, even those that are incompatible with the data type. It also allows the data type to be non-nullish; for those cases use the built-in Nullish coalescing operator ?? directly, or use when with isNullish and constant.

Nullish

const DATA: number | undefined | null;

// Lodash
_.defaultTo(DATA, 456);

// Perkakas
defaultTo(DATA, 456);

NaN

const DATA = Number.NaN;

// Lodash
_.defaultTo(DATA, 10);

// Perkakas
when(DATA, Number.isNaN, constant(10));

Both

const DATA: number | null | undefined;

// Lodash
_.defaultTo(DATA, 10);

// Perkakas
when(
  DATA,
  (x) => x === undefined || x === null || Number.isNaN(x),
  constant(10),
);

Non-matching fallback

const DATA: string | null | undefined;

// Lodash
_.defaultTo(DATA, 123);

// Perkakas
when(DATA, isNullish, constant(123));

// or natively
DATA ?? 123;

difference

Lodash difference → difference.

• Perkakas's difference treats the inputs as multisets/bags which respect item duplication, whereas in Lodash all matching values are filtered out. This means Perkakas removes only one copy of each matching item, while Lodash removes all copies.
• When the input arrays might contain duplicates and you want to filter all values use a composition of filter, isNot, and isIncludedIn to replicate the Lodash semantics.
• Lodash's difference accepts multiple values arrays as separate arguments and flattens them, while Perkakas's difference takes a single values array. When migrating these arrays need to be flattened or spread into a single array manually.
• Lodash supports calling difference trivially, with no exclusion array at all which results in a shallow clone of the input array. In Perkakas the exclusion array is required.
• Lodash accepts null and undefined values for the array (and treats them as an empty array). In Perkakas this nullish value needs to be handled explicitly either by skipping the call to difference, or by coalescing the input to an empty array.

Without duplicate values (unique)

// Lodash
_.difference(uniqueData, uniqueValues);

// Perkakas
difference(uniqueData, uniqueValues);

With duplicate values

// Lodash
_.difference(dataWithDuplicates, uniqueValues);
_.difference(uniqueData, valuesWithDuplicates);
_.difference(dataWithDuplicates, valuesWithDuplicates);

// Perkakas
filter(dataWithDuplicates, isNot(isIncludedIn(uniqueValues)));
filter(uniqueData, isNot(isIncludedIn(valuesWithDuplicates)));
filter(dataWithDuplicates, isNot(isIncludedIn(valuesWithDuplicates)));

// valuesWithDuplicates doesn't need to be deduped when used inside
// `isIncludedIn`, but can be for efficiency if needed via `unique`
filter(dataWithDuplicates, isNot(isIncludedIn(unique(valuesWithDuplicates))));

Multiple exclusion arrays

// Lodash
_.difference(DATA, a, b, c);

// Perkakas
difference(DATA, [...a, ...b, ...c]);

Missing 2nd (exclusions) parameter

// Lodash
_.difference(DATA);

// Perkakas
difference(DATA, []);

// Or directly via Native JS:
[...DATA];

Nullish inputs

// Lodash
_.difference(DATA, values);

// Perkakas
isNonNullish(DATA) ? difference(DATA, values) : [];

// Or
difference(DATA ?? [], values);

differenceBy

Lodash differenceBy → filter.

Not provided by Perkakas.

• Use a composition based on filter, isNotisIncludedIn, and map to recreate the logic for differenceBy.
• Additionally, when the iteratee parameter is defined as a property name, use prop as the iteratee function instead.
• Lodash accepts null and undefined values for the array (and treats them as an empty array). In Perkakas this nullish value needs to be handled explicitly either by skipping the call to differenceBy, or by coalescing the input to an empty array.
• When the iteratee parameter is not provided to the Lodash differenceBy function (or is provided as undefined) it behaves like a call to difference.

Function iteratee

// Lodash
_.differenceBy(DATA, values, iteratee);

// Perkakas
filter(DATA, piped(iteratee, isNot(isIncludedIn(map(values, iteratee)))));

// the mapped values don't need to be deduped when used inside `isIncludedIn`,
// but could be for efficiency if needed via `unique`
filter(
  DATA,
  piped(iteratee, isNot(isIncludedIn(unique(map(values, iteratee))))),
);

Property iteratee

// Lodash
_.differenceBy(DATA, values, 'x');

// Perkakas
filter(DATA, piped(prop('x'), isNot(isIncludedIn(map(values, prop('x'))))));

// the mapped values don't need to be deduped when used inside `isIncludedIn`,
// but could be for efficiency if needed via `unique`
filter(
  DATA,
  piped(prop('x'), isNot(isIncludedIn(unique(map(values, prop('x')))))),
);

Multiple exclusion arrays

// Lodash
_.differenceBy(DATA, a, b, c, iteratee);

// Perkakas
filter(
  DATA,
  piped(iteratee, isNot(isIncludedIn(map([...a, ...b, ...c], iteratee)))),
);

// the mapped values don't need to be deduped when used inside `isIncludedIn`,
// but could be for efficiency if needed via `unique`
filter(
  DATA,
  piped(
    iteratee,
    isNot(isIncludedIn(unique(map([...a, ...b, ...c], iteratee)))),
  ),
);

Nullish inputs

// Lodash
_.differenceBy(DATA, values, iteratee);

// Perkakas
isNonNullish(DATA)
  ? filter(DATA, piped(iteratee, isNot(isIncludedIn(map(values, iteratee)))))
  : [];

// Or
filter(DATA ?? [], piped(iteratee, isNot(isIncludedIn(map(values, iteratee)))));

Missing iteratee function

// Lodash
_.differenceBy(DATA, values);

// Convert to Lodash's `difference` and then refer to the `difference` migration
// docs
_.difference(DATA, values);

differenceWith

Lodash differenceWith → differenceWith.

• Lodash's differenceWith accepts a variadic list of values arrays which are then effectively flattened, but Perkakas only accepts a single values array; Multiple arrays need to be spread manually instead.
• Lodash accepts null and undefined values for the array (and treats them as an empty array). In Perkakas this nullish value needs to be handled explicitly either by skipping the call to differenceWith, or by coalescing the input to an empty array.
• When the comparator parameter is not provided to the Lodash differenceWith function (or is provided as undefined) it behaves like a call to difference.

Single exclusion array

// Lodash
_.differenceWith(DATA, values, comparator);

// Perkakas
differenceWith(DATA, values, comparator);

Multiple exclusion arrays

// Lodash
_.differenceWith(DATA, a, b, c, comparator);

// Perkakas
differenceWith(DATA, [...a, ...b, ...c], comparator);

Nullish inputs

// Lodash
_.differenceWith(DATA, values, comparator);

// Perkakas
isNonNullish(DATA) ? differenceWith(DATA, values, comparator) : [];

// Or
differenceWith(DATA ?? [], values, comparator);

Missing iteratee function

// Lodash
_.differenceWith(DATA, values);

// Convert to Lodash's `difference` and then refer to the `difference` migration
// docs
_.difference(DATA, values);

divide

Lodash divide → divide.

drop

Lodash drop → drop.

dropRight

Lodash dropRight → dropLast.

dropRightWhile

Lodash dropRightWhile → dropLastWhile.

dropWhile

Lodash dropWhile → dropWhile.

endsWith

Lodash endsWith → endsWith.

• Lodash supports an optional position parameter to check only part of the string, while Perkakas doesn't support this parameter. To replicate this behavior, use sliceString to truncate the string before checking.
• Lodash allows the suffix to be undefined (converts to "undefined" string) but this is not supported by Perkakas and needs to be handled explicitly.

Basic usage

// Lodash
_.endsWith(input, suffix);

// Perkakas
endsWith(input, suffix);

// Native
input.endsWith(suffix);

Position parameter

// Lodash
_.endsWith(input, suffix, position);

// Perkakas
endsWith(sliceString(input, 0, position), suffix);

// Native
input.endsWith(suffix, position);

Undefined suffix

// Lodash
_.endsWith(input, suffix);

// Perkakas
suffix !== undefined && endsWith(input, suffix);

escape

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

escape is not needed in the vast majority of modern web development - all modern frameworks and tools perform this kind of escaping (and more!) automatically wherever it matters. If you are working on a low-level application that writes directly to the DOM, prefer libraries that take a holistic approach to this problem (like DOMPurify) instead of basic string substitutions. In the rare case you must have an escaping function, copy the reference code below as-is:

const ESCAPED: Readonly<Record<string, `&${string};`>> = {
  // https://github.com/lodash/lodash/blob/main/lodash.js#L399-L403
  '&': '&amp;',
  '<': '&lt;',
  '>': '&gt;',
  '"': '&quot;',
  '\'': '&#39;',
};

const CHARS_RE = new RegExp(`[${Object.keys(ESCAPED).join('')}]`, 'g');

function escape(input: string): string {
  return input.replace(CHARS_RE, (char) => ESCAPED[char]!);
}

escapeRegExp

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• Use the native RegExp.escape instead.
• When unavailable, escapeRegExp could also be replicated using String.prototype.replace to replace matches of /[\\^$.*+?()[\]{}|]/g (which matches on the characters: ^, $, ., *, +, ?, (), {}, , and |) with a backslash-escaped version of the match (using the "\\$&" replacement pattern).

// Lodash
_.escapeRegExp(input);

// Native
RegExp.escape(input);

// Or
input.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&');

every

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

Use the native JS Array.prototype.every instead.

@see "You don't need Lodash"

// Lodash
every(DATA, predicate);

// Native
DATA.every(predicate);

filter

Lodash filter → filter.

find

Lodash find → find.

findIndex

Lodash findIndex → findIndex.

findLast

Lodash findLast → findLast.

findLastIndex

Lodash findLastIndex → findLastIndex.

flatMap

Lodash flatMap → flatMap.

flatMapDeep

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

This function could be recreated in Perkakas via a composition of map, and flat with a large, const depth parameter.

// Lodash
flatMapDeep(DATA, mappingFunction);

// Perkakas
flat(map(DATA, mappingFunction), 10 /* depth */);

// Or as a pipe
pipe(DATA, map(mappingFunction), flat(10 /* depth */));

flatMapDepth

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

This function could be recreated in Perkakas via map, flatMap, or flat (or a combination of them, depending on the parameters used).

// Lodash
flatMapDepth(DATA);

// Perkakas
flat(DATA);

// Lodash
flatMapDepth(DATA, mappingFunction);

// Perkakas
flatMap(DATA, mappingFunction);

// Lodash
flatMapDepth(DATA, mappingFunction, depth);

// Perkakas
flat(map(DATA, mappingFunction), depth);

// Or as a pipe
pipe(DATA, map(mappingFunction), flat(depth));

flatten

Lodash flatten → flat.

Either use with no params, or with a depth of 1.

// Lodash
flatten(DATA);

// Perkakas
flat(DATA);
flat(DATA, 1 /* depth */);

flattenDeep

Lodash flattenDeep → flat.

Unlike flatten in Lodash, the Perkakas flat function is always bound by the depth param. To replicate the Lodash behavior use a high, const value. Infinity and Number.MAX_INTEGER are not consts and would result in inefficient typing.

// Lodash
flattenDeep(DATA);

// Perkakas
flat(DATA, 100); // ✅
flat(DATA, Infinity); // ❌

floor

Lodash floor → floor.

flow

Lodash flow → pipe.

forEach

Lodash forEach → forEach.

• In Lodash forEach first checks if the data argument is array-like (by looking for a length prop). In Perkakas the function only accepts arrays and calling it with an object would result in a TypeScript error. Use forEachObj instead for those cases.
• In Lodash forEach stops iterating early when the callback returns false. In Perkakas the callback cannot return a value (it must return void) and this feature isn't available. You can build a pipe that would replicate this logic.

Array

// Lodash
forEach([1, 2, 3], (item) => console.log(item));

// Perkakas
forEach([1, 2, 3], (item) => {
  console.log(item);
});

Object

// Lodash
forEach({ a: 1, b: 2, c: 3 }, (value) => console.log(value));

// Perkakas
forEachObj({ a: 1, b: 2, c: 3 }, (value) => {
  console.log(value);
});

Early exit

// Lodash
forEach([1, 2, 3], (item) => (item === 2 ? false : console.log(item)));

// Perkakas
// ❌ You can't return a value in a forEach callback in Perkakas:
forEach([1, 2, 3], (item) => (item === 2 ? false : console.log(item)));

// ✅ Instead you can rely on lazy evaluation of pipes:
pipe(
  [1, 2, 3],
  takeWhile((item) => item !== 2),
  forEach((item) => {
    console.log(item);
  }),
);

forEachRight

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• This function could be replicated using a native JS for loop.
• If the order of iteration doesn't matter, you can use forEach for arrays, or forEachObj for objects.
• The order in which object properties are iterated over is well-defined, but might not be the order you expect (MDN); nevertheless, entries maintains the same order, and could be used to replicate forEachRight.
• If the native solution doesn't suffice please open an issue at Perkakas's GitHub project so we can learn about your use-case.

Arrays

const DATA = [1, 2, 3];

// Lodash
forEachRight(DATA, (item) => (item === 2 ? false : console.log(item)));

// Native
for (const index = DATA.length - 1; index >= 0; index--) {
  const item = DATA[item]!;
  if (item === 2) {
    break;
  }

  console.log(item);
}

Objects

const DATA = { a: 1, b: 2, c: 3 };

// Lodash
forEachRight(DATA, (value) => (value === 2 ? false : console.log(value)));

// Native
const keys = Object.keys(DATA);
for (const index = keys.length - 1; index >= 0; index--) {
  const value = DATA[key]!;
  if (value === 2) {
    break;
  }

  console.log(value);
}

forOwn

Lodash forOwn → forEachObj.

fromPairs

Lodash fromPairs → fromEntries.

get

Lodash get → prop.

• In Lodash get takes an array where each element is a property in the path to a deeply-nested property (e.g. ['a', 'b', '0', 'c']). In Perkakas the path is provided directly as a variadic arguments list.
• In Lodash all property keys are string, even when accessing numbers. In Perkakas the exact type of each prop should be used instead (e.g., number when accessing arrays).
• Lodash also supports a string that defines the path to the deeply-nested property (e.g., a.b[0].c). In Perkakas this isn't supported directly; instead, use the helper function stringToPath to convert the path string to a path array, which could then be spread into prop.
• Lodash supports an optional last argument to get which defines a default fallback in cases where the prop being accessed does not exist on the input object. To achieve this wrap your call to prop with a call to defaultTo, or use the native Nullish coalescing operator ?? instead if the fallback is of a different type.

Shallow Access

const DATA = { a: 123 };

// Lodash
_.get(DATA, ['a']);

// Perkakas
prop(DATA, 'a');

Array indices

const DATA = [1, 2, 3];

// Lodash
_.get(DATA, ['0']);

// Perkakas
prop(DATA, 0);

Path Arrays

const DATA = { a: [{ b: { c: 3 } }] };

// Lodash
_.get(DATA, ['a', '0', 'b', 'c']);

// Perkakas
prop(DATA, 'a', 0, 'b', 'c');

Path Strings

const DATA = { a: [{ b: { c: 3 } }] };

// Lodash
_.get(DATA, 'a[0].b.c');

// Perkakas
prop(DATA, ...stringToPath('a[0].b.c'));

Default Fallback

const DATA = { a: [] as Array<{ b: number }> };

// Lodash
_.get(DATA, ['a', '0', 'b'], 'default');

// Perkakas
defaultTo(prop(DATA, 'a', 0, 'b'), 123);
// Or natively
prop(DATA, 'a', 0, 'b') ?? 'default';

groupBy

Lodash groupBy → groupBy.

• When using groupBy with a callback function use Perkakas's groupBy function.
• When using groupBy on an array of objects and with a property name use Perkakas's groupByProp instead.
• When using groupBy on an array of primitives (e.g., string) and with a property name use Perkakas's groupBy composed with prop.

Callback

const DATA = [6.1, 4.2, 6.3];

// Lodash
groupBy(DATA, Math.floor);

// Perkakas
groupBy(DATA, Math.floor);

Property Name (on objects)

const DATA = [
  { type: 'cat', name: 'felix' },
  { type: 'dog', toys: 3 },
];

// Lodash
groupBy(DATA, 'type');

// Perkakas
groupByProp(DATA, 'type');

Property Name (on primitives)

const DATA = ['one', 'two', 'three'];

// Lodash
groupBy(DATA, 'length');

// Perkakas
groupBy(DATA, prop('length'));

has

Lodash has → hasProp.

• Lodash's has accepts deep paths ("a.b.c" or ["a", "b", "c"]). Perkakas's hasProp only checks a single key.

// Lodash
has(obj, 'a');

// Perkakas
hasProp(obj, 'a');

hasIn

Lodash hasIn → hasProp.

• Lodash's hasIn uses the in operator which returns true for inherited properties. Perkakas uses Object.hasOwn which ignores them.
• Lodash's hasIn accepts deep paths ("a.b.c" or ["a", "b", "c"]). Perkakas's hasProp only checks a single key.

Own properties

// Lodash
hasIn(obj, 'a');

// Perkakas
hasProp(obj, 'a');

Inherited properties

// Lodash
hasIn({}, 'toString'); // => true

// Perkakas
hasProp({}, 'toString'); // => false

head

Lodash head → first.

identity

Lodash identity → identity.

In Perkakas the identity function is a factory that creates an identity function; it needs to be called to be used.

// Lodash
map(identity);

// Perkakas
map(identity());

includes

Lodash includes → isIncludedIn.

• In Lodash includes also works on strings and objects; In Perkakas only arrays are supported. For objects, use values first. For strings prefer the native JS String.prototype.includes.
• The 3rd optional parameter fromIndex isn't supported in Perkakas. You can replicate it's usage with drop (for non-negative indices), or takeLast (for non-positive indices).
• The order of the parameters is flipped in Perkakas, the item is first, and then the array.

Arrays

// Lodash
includes([1, 2, 3], 1);

// Perkakas
isIncludedIn(1, [1, 2, 3]);

Objects

// Lodash
includes({ a: 1, b: 2 }, 1);

// Perkakas
isIncludedIn(1, values({ a: 1, b: 2 }));

Strings

const DATA = 'Hello, World!';

// Lodash
includes(DATA, 'lo');

// Native
DATA.includes('lo');

fromIndex: non-negative

// Lodash
includes([1, 2, 3], 1, 2);

// Perkakas
isIncludedIn(1, drop([1, 2, 3], 2));

fromIndex: non-positive

// Lodash
includes([1, 2, 3], 1, -2);

// Perkakas
isIncludedIn(1, takeLast([1, 2, 3], 2));

intersection

Lodash intersection → intersection.

In Perkakas intersection treats the inputs as multisets/bags which respect item duplication, whereas in Lodash the result is always de-dupped. This only matters for cases where both arrays might have duplicate values. To achieve the same output pass the result to unique.

No duplicates

// Lodash
intersection([2, 1], [2, 3]);

// Perkakas
intersection([2, 1], [2, 3]);

With duplicates

// Lodash
intersection([1, 1], [1, 1]);

// Perkakas
unique(intersection([1, 1], [1, 1]));

intersectionWith

Lodash intersectionWith → intersectionWith.

invert

Lodash invert → invert.

invokeMap

Lodash invokeMap → map.

• map can be used instead of invokeMap by using a callback functions instead of (string) function names.
• If you need to invoke functions dynamically via a provided function name, narrow the name first (so you can handle errors explicitly), and then use the name to access the object.

No arguments

// Lodash
invokeMap(
  [
    [5, 1, 7],
    [3, 2, 1],
  ],
  'sort',
);

// Perkakas
map(
  [
    [5, 1, 7],
    [3, 2, 1],
  ],
  (array) => array.sort(),
);

With arguments

// Lodash
invokeMap([123, 456], String.prototype.split, '');

// Perkakas
map([123, 456], (num) => num.toString().split(''));

Dynamic

const DATA = [
  { foo: (x: number) => x + 1, bar: (x: number) => x - 1 },
  { foo: (x: number) => x * 2, bar: (x: number) => x / 2 },
] as const;

// Lodash
invokeMap(DATA, funcName, 3);

// Perkakas
if (funcName === 'foo' || funcName === 'bar') {
  map(DATA, ({ [funcName]: func }) => func(3));
} else {
  // Error!
}

// Or
map(DATA, (obj) => {
  if (funcName === 'foo' || funcName === 'bar') {
    return obj[funcName](3);
  } else {
    // Error
  }
});

isArray

Lodash isArray → isArray.

isBoolean

Lodash isBoolean → isBoolean.

isDate

Lodash isDate → isDate.

isEmpty

Lodash isEmpty → isEmptyish.

isEqual

Lodash isEqual → isDeepEqual.

isError

Lodash isError → isError.

isFunction

Lodash isFunction → isFunction.

isMatch

Lodash isMatch → hasSubObject.

isNil

Lodash isNil → isNullish.

isNumber

Lodash isNumber → isNumber.

isObjectLike

Lodash isObjectLike → isObjectType.

isPlainObject

Lodash isPlainObject → isPlainObject.

isString

Lodash isString → isString.

isSymbol

Lodash isSymbol → isSymbol.

join

Lodash join → join.

kebabCase

Lodash kebabCase → toKebabCase.

• Lodash attempts pseudo-linguistic word splitting to handle special characters, which might lead to inaccurate results. Perkakas uses a simpler word splitting approach based on type-fest's definition that should only be used for simple strings like identifiers and internal keys. For linguistic processing where language and locale nuances matter, use the built-in Intl.Segmenter instead.
• Lodash performs normalization on the input before splitting it, including deburr and removing apostrophes. Perkakas's word splitting is simpler and doesn't include these normalizations, so they need to be done manually if required.
• Lodash allows calling kebabCase without any input, or with an undefined input, which isn't supported in Perkakas. Handle these cases before calling the function.

Simple strings

// Lodash
_.kebabCase(input);

// Perkakas
toKebabCase(input);

Normalized

// Lodash
_.kebabCase(input);

// Perkakas + Native
toKebabCase(
  input
    // "Promote" diacritics to be independent characters in the string.
    .normalize('NFD')
    // Remove apostrophes and all independent diacritic characters.
    .replace(/['\u2019\u0300-\u036F]/g, ''),
);

Missing input

// Lodash
_.kebabCase();
_.kebabCase(input);

// Perkakas
('');
input !== undefined ? toKebabCase(input) : '';

// Or
toKebabCase(input ?? '');

keyBy

Lodash keyBy → indexBy.

keys

Lodash keys → keys.

last

Lodash last → last.

lowerCase

Lodash lowerCase → toTitleCase.

• Use toLowerCase on the results of toTitleCase, which reformats the string into space-delimited words.
• Lodash attempts pseudo-linguistic word splitting to handle special characters, which might lead to inaccurate results. Perkakas uses a simpler word splitting approach based on type-fest's definition that should only be used for simple strings like identifiers and internal keys. For linguistic processing where language and locale nuances matter, use the built-in Intl.Segmenter instead.
• Lodash performs normalization on the input before splitting it, including deburr and removing apostrophes. Perkakas's word splitting is simpler and doesn't include these normalizations, so they need to be done manually if required.
• Lodash allows calling lowerCase without any input, or with an undefined input, which isn't supported in Perkakas. Handle these cases before calling the function.

Basic usage

// Lodash
_.lowerCase(input);

// Perkakas
toLowerCase(toTitleCase(input));

Normalized

// Lodash
_.lowerCase(input);

// Perkakas + Native
toLowerCase(
  toTitleCase(
    input
      // "Promote" diacritics to be independent characters in the string.
      .normalize('NFD')
      // Remove apostrophes and all independent diacritic characters.
      .replace(/['\u2019\u0300-\u036F]/g, ''),
  ),
);

Missing input

// Lodash
_.lowerCase();
_.lowerCase(input);

// Perkakas
('');
input !== undefined ? toLowerCase(toTitleCase(input)) : '';

// Or
toLowerCase(toTitleCase(input ?? ''));

lowerFirst

Lodash lowerFirst → uncapitalize.

• For display purposes, prefer using CSS; use ::first-letter to target just the first letter of the word and text-transform: lowercase to lowercase it.
• Lodash allows calling lowerFirst without any input (or with an undefined input), which results in an empty string "". Perkakas's uncapitalize requires a string input.

Basic usage

// Lodash
_.lowerFirst(input);

// Perkakas
uncapitalize(input);

CSS

// Lodash
<div>{_.lowerFirst(input)}</div>

// CSS
<style>
  .lowerFirst::first-letter {
    text-transform: lowercase;
  }
</style>
<div class="lowerFirst">{input}</div>

Missing input data

// Lodash
_.lowerFirst();
_.lowerFirst(input);

// Perkakas
input !== undefined ? uncapitalize(input) : '';

// Or
uncapitalize(input ?? '');

map

Lodash map → map.

mapKeys

Lodash mapKeys → mapKeys.

mapValues

Lodash mapValues → mapValues.

max

Lodash max → firstBy.

Use identity as the criteria and "desc" as the direction.

// Lodash
max(DATA);

// Perkakas
firstBy(DATA, [identity(), 'desc']);

maxBy

Lodash maxBy → firstBy.

Use "desc" as the direction.

// Lodash
maxBy(DATA, criteria);

// Perkakas
firstBy(DATA, [criteria, 'desc']);

mean

Lodash mean → mean.

meanBy

Lodash meanBy → meanBy.

min

Lodash min → firstBy.

Use identity as the criteria.

// Lodash
min(DATA);

// Perkakas
firstBy(DATA, identity());

minBy

Lodash minBy → firstBy.

multiply

Lodash multiply → multiply.

negate

Lodash negate → isNot.

• Unlike Lodash's negate, isNot preserves type predicates: negating a type-guard returns a type-guard which excludes the guarded type, so the result of filter stays narrowed.
• Lodash's negate forwards every argument it receives to the predicate, and invokes it with the same this. isNot only takes a single-parameter predicate and passes just the first argument through; wrap multi-parameter functions with the native logical NOT operator ! instead.
• Lodash's negate negates the truthiness of any return value, whereas isNot requires a predicate that returns a boolean. Compose with isTruthy to get the Lodash semantics.

Predicates

// Lodash
_.negate(predicate);

// Perkakas
isNot(predicate);

Filtering

// Lodash
_.filter(DATA, _.negate(_.isString));

// Perkakas
filter(DATA, isNot(isString));

Multiple parameters

// Lodash
_.negate(isGreaterThan);

// Native
(a: number, b: number) => !isGreaterThan(a, b);

Non-boolean predicates

// Lodash
_.negate(getLength);

// Perkakas
isNot(piped(getLength, isTruthy));

// Or directly via Native JS:
(data: string) => !getLength(data);

noop

Lodash noop → doNothing.

• If a return value is needed, use constant with undefined.
• Otherwise, use doNothing (which returns void).

// Lodash
noop;

// Perkakas
constant(undefined);
doNothing();

nth

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• For index 0 use first.
• For index -1 use last.
• For arbitrary non-negative indices use the native JS data[n].
• Or use Array.prototype.at for any index.

// Lodash
nth(DATA);
nth(DATA, 0);

// Perkakas
first(DATA);

// Lodash
nth(DATA, 1);

// Native
DATA[1];
DATA.at(1);

// Lodash
nth(DATA, -1);

// Perkakas
last(DATA);

// Lodash
nth(DATA, -2);

// Native
DATA.at(-2);

omit

Lodash omit → omit.

omitBy

Lodash omitBy → omitBy.

once

Lodash once → once.

orderBy

Lodash orderBy → sortBy.

Unlike in Lodash, in Perkakas the sort criteria can only be a callback (and not a prop name), it is paired with the order modifier ("asc"/"desc", if needed), and it's provided as a variadic argument and not two array arguments.

const DATA = [
  { user: 'fred', age: 48 },
  { user: 'barney', age: 34 },
  { user: 'fred', age: 40 },
  { user: 'barney', age: 36 },
];

// Lodash
orderBy(DATA, ['user', 'age'], ['asc', 'desc']);

// Perkakas
sortBy(DATA, prop('user'), [prop('age'), 'desc']);

pad

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• If pad is used with whitespace padding (which is also the default) in order to center text within an HTML component, prefer using CSS instead. Use width with a length in ch units, and text-align: center.
• For other uses pad could be replicated via padStart and padEnd, by computing the amount of effective padding you need on one side.

CSS

// Lodash
<pre>{_.pad(input, 20)}</pre>

// CSS
<div style="text-align:center;width:20ch">{input}</div>

Reference Implementation

function pad(data: string, length: number, padding = ' ') {
  return data.padStart((length + data.length) / 2, padding).padEnd(length, padding);
}

padEnd

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• Use native String.prototype.padEnd instead.
• If padEnd is used with whitespace padding (which is also the default) in order to position text within an HTML component, prefer using CSS instead. Use width with a length in ch units, and text-align: left.

Basic Usage

// Lodash
_.padEnd(input, n);
_.padEnd(input, n, padding);

// Native
input.padEnd(n);
input.padEnd(n, padding);

CSS

// Lodash
<pre>{_.padEnd(input, 20)}</pre>

// CSS
<div style="text-align:left;width:20ch">{input}</div>

padStart

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• Use native String.prototype.padStart instead.
• If padStart is used with whitespace padding (which is also the default) in order to position text within an HTML component, prefer using CSS instead. Use width with a length in ch units, and text-align: right.

Basic Usage

// Lodash
_.padStart(input, n);
_.padStart(input, n, padding);

// Native
input.padStart(n);
input.padStart(n, padding);

CSS

// Lodash
<pre>{_.padStart(input, 20)}</pre>

// CSS
<div style="text-align:right;width:20ch">{input}</div>

parseInt

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

• Use native Number.parseInt instead.
• When used as a callback, parseInt protects against the index parameter unintentionally redefining the radix. To avoid this issue, wrap the callback with an arrow function.

Basic usage

// Lodash
_.parseInt(input);
_.parseInt(input, radix);

// Native
Number.parseInt(input);
Number.parseInt(input, radix);

Callback

// Lodash
data.map(_.parseInt);

// Native
data.map((item) => Number.parseInt(item, 10)); // ✅
data.map(Number.parseInt); // ❌

partial

Lodash partial → partialBind.

The placeholder argument _ is not supported. Some cases can be written as partialLastBind; otherwise, use an arrow function.

function greet(greeting, firstName, lastName) {
  return `${greeting} ${firstName} ${lastName}`;
}

// Lodash
_.partial(greet, _, 'john', 'doe');
_.partial(greet, 'hi', _, 'doe');

// Perkakas
partialLastBind(greet, 'john', 'doe');
// (not supported)

// Native
(greeting) => greet(greeting, 'john', 'doe');
(firstName) => greet('hi', firstName, 'doe');

partialRight

Lodash partialRight → partialLastBind.

The placeholder argument _ is not supported. Some cases can be written as partialBind; otherwise, use an arrow function.

function greet(greeting, firstName, lastName) {
  return `${greeting} ${firstName} ${lastName}`;
}

// Lodash
_.partialRight(greet, 'hi', 'john', _);
_.partialRight(greet, 'hi', _, 'doe');

// Perkakas
partialBind(greet, ['hi', 'john']);
// (not supported)

// Native
(lastName) => greet('hi', 'john', lastName);
(firstName) => greet('hi', firstName, 'doe');

partition

Lodash partition → partition.

pick

Lodash pick → pick.

pickBy

Lodash pickBy → pickBy.

pull

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

CAUTION: pull mutates the input array in-place! All functions in Perkakas are pure and never mutate the input. These mutations might introduce side-effects and implicit dependencies in your codebase that need to be handled before migrating to Perkakas!

• pull is equivalent to Lodash's difference function. To migrate to Perkakas first migrate calls to Lodash _.difference and then use the migration docs for difference to complete the migration. IMPORTANT: The Perkakas difference function isn't a drop-in replacement for the Lodash _.difference function, we do not recommend migrating directly from pull to Perkakas's difference.
• pull takes a variadic array of items to remove; difference take an explicit array instead. You will need to wrap your items in an array when migrating.
• If the mutability of the input array is desired, make sure the variable is assignable (e.g., using let instead of const), and assign back the result of difference back to it. Note that if the input array is part of an object or nested array, you will need to manually reconstruct this outer containing object with the updated array manually.
• If mutability wasn't desired, and instead the input was cloned (shallowly) before calling pull, that cloning is now redundant.

Exclusion Items

// pull
_.pull(DATA, a, b, c, ...additional);

// difference
_.difference(DATA, [a, b, c, ...additional]);

In-place mutation

// pull
const DATA = ['a', 'b', 'c', 'd'];
_.pull(DATA, ...values);

// difference
let DATA = ['a', 'b', 'c', 'd'];
DATA = _.difference(DATA, values);

Non-mutating usage

// pull
const pulled = _.pull([...DATA], ...values);

// difference
const pulled = _.difference(DATA, values);

Nested inside an object

// pull
const DATA = { a: ['a', 'b', 'c'], b: 'hello, world' };
_.pull(DATA.a, ...values);

// difference
let DATA = { a: ['a', 'b', 'c'], b: 'hello, world' };
DATA = { ...DATA, a: _.difference(DATA.a, values) };

pullAll

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

CAUTION: pullAll mutates the input array in-place! All functions in Perkakas are pure and never mutate the input. These mutations might introduce side-effects and implicit dependencies in your codebase that need to be handled before migrating to Perkakas!

• pullAll is equivalent to Lodash's difference function. To migrate to Perkakas first migrate calls to Lodash _.difference and then use the migration docs for difference to complete the migration. IMPORTANT: The Perkakas difference function isn't a drop-in replacement for the Lodash _.difference function, we do not recommend migrating directly from pullAll to Perkakas's difference.
• If the mutability of the input array is desired, make sure the variable is assignable (e.g., using let instead of const), and assign back the result of difference back to it. Note that if the input array is part of an object or nested array, you will need to manually reconstruct this outer object with the updated array manually.
• If mutability wasn't desired, and instead the input was cloned (shallowly) before calling pullAll, that cloning is now redundant.

In-place mutation

// pullAll
const DATA = ['a', 'b', 'c', 'd'];
_.pullAll(DATA, values);

// difference
let DATA = ['a', 'b', 'c', 'd'];
DATA = _.difference(DATA, values);

Non-mutating usage

// pullAll
const pulled = _.pullAll([...DATA], values);

// difference
const pulled = _.difference(DATA, values);

Nested inside an object

// pullAll
const DATA = { a: ['a', 'b', 'c'], b: 'hello, world' };
_.pullAll(DATA.a, values);

// difference
let DATA = { a: ['a', 'b', 'c'], b: 'hello, world' };
DATA = { ...DATA, a: _.difference(DATA.a, values) };

pullAllBy

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

CAUTION: pullAllBy mutates the input array in-place! All functions in Perkakas are pure and never mutate the input. These mutations might introduce side-effects and implicit dependencies in your codebase that need to be handled before migrating to Perkakas!

• pullAllBy is equivalent to Lodash's differenceBy function. To migrate to Perkakas first migrate calls to Lodash _.differenceBy and then use the migration docs for differenceBy to complete the migration.
• If the mutability of the input array is desired, make sure the variable is assignable (e.g., using let instead of const), and assign back the result of differenceBy back to it. Note that if the input array is part of an object or nested array, you will need to manually reconstruct this outer object with the updated array manually.
• If mutability wasn't desired, and instead the input was cloned (shallowly) before calling pullAllBy, that cloning is now redundant.

In-place mutation

// pullAllBy
const DATA = [{ x: 1 }, { x: 2 }, { x: 3 }];
_.pullAllBy(DATA, values, iteratee);

// differenceBy
let DATA = [{ x: 1 }, { x: 2 }, { x: 3 }];
DATA = _.differenceBy(DATA, values, iteratee);

Non-mutating usage

// pullAllBy
const pulled = _.pullAllBy([...DATA], values, iteratee);

// differenceBy
const pulled = _.differenceBy(DATA, values, iteratee);

Nested inside an object

// pullAllBy
const DATA = { items: [{ x: 1 }, { x: 2 }], meta: 'info' };
_.pullAllBy(DATA.items, values, iteratee);

// differenceBy
let DATA = { items: [{ x: 1 }, { x: 2 }], meta: 'info' };
DATA = { ...DATA, items: _.differenceBy(DATA.items, values, iteratee) };

pullAllWith

No direct Perkakas helper. Use the notes below, or native JavaScript.

Not provided by Perkakas.

CAUTION: pullAllWith mutates the input array in-place! All functions in Perkakas are pure and never mutate the input. These mutations might introduce side-effects and implicit dependencies in your codebase that need to be handled before migrating to Perkakas!

• pullAllWith is equivalent to Lodash's differenceWith function. To migrate to Perkakas first migrate calls to Lodash _.differenceWith and then use the migration docs for differenceWith to complete the migration. IMPORTANT: The Perkakas differenceWith function isn't a drop-in replacement for the Lodash _.differenceWith function, we do not recommend migrating directly from pullAllWith to Perkakas's differenceWith.
• If the mutability of the input array is desired, make sure the variable is assignable (e.g., using let instead of const), and assign back the result of differenceWith back to it. Note that if the input array is part of an object or nested array, you will need to manually reconstruct this outer object with the updated array manually.
• If mutability wasn't desired, and instead the input was cloned (shallowly) before calling pullAllWith, that cloning is now redundant.

In-place mutation

// pullAllWith
const DATA = [{ x: 1 }, { x: 2 }, { x: 3 }];
_.pullAllWith(DATA, values, comparator);

// differenceWith
let DATA = [{ x: 1 }, { x: 2 }, { x: 3 }];
DATA = _.differenceWith(DATA, values, comparator);

Non-mutating usage

// pullAllWith
const pulled = _.pullAllWith([...DATA], values, comparator);

// differenceWith
const pulled = _.differenceWith(DATA, values, comparator);

Nested inside an object

// pullAllWith
const DATA = { items: [{ x: 1 }, { x: 2 }], meta: 'info' };
_.pullAllWith(DATA.items, values, comparator);

// differenceWith
let DATA = { items: [{ x: 1 }, { x: 2 }], meta: 'info' };
DATA = { ...DATA, items: _.differenceWith(DATA.items, values, comparator) };

random

Lodash random → randomInteger.

• When Lodash's random function is called with a non-integer param it returns any number, not just integers (e.g. 2.5)! Perkakas's randomInteger function always returns integers, effectively rounding the parameters to fit the range of possible integers.
• If you want to generate any number in the range (and not just integers) see the solutions provided in "You don't need Lodash".
• Lodash's random parameters are optional. In Perkakas all parameters are required.

Two integer params

// Lodash
random(1, 10);

// Perkakas
randomInteger(1, 10);

Single integer param

// Lodash
random(10);

// Perkakas
randomInteger(0, 10);

No params