lodash._pickbyarray - Internal Pick By Array Function (v3)

Common errors

• TypeError: pickByArray is not a function

  cause Attempting to use `pickByArray` after an incorrect import, or if the package was not installed/resolved properly. This can also occur if `import pickByArray from 'lodash._pickbyarray';` is used in a CJS context.
  fix Ensure the package is correctly installed (`npm install lodash._pickbyarray`) and imported using CommonJS `require`: `const pickByArray = require('lodash._pickbyarray');`. For modern usage, consider switching to `_.pickBy` from the main `lodash` package.

• SyntaxError: Cannot use import statement outside a module

  cause You are attempting to use ES module `import` syntax (`import pickByArray from '...'`) with this CommonJS-only package in a script or environment that does not support ES modules or is not configured to transpile them.
  fix Change your import statement to `const pickByArray = require('lodash._pickbyarray');` for CommonJS compatibility. For modern ES module usage, you should instead use `import { pickBy } from 'lodash-es';` from the actively maintained Lodash ES module build.

• [TS] Module '"lodash._pickbyarray"' has no default export.

  cause In a TypeScript project, the compiler is correctly identifying that this CommonJS module directly exports a function, which is not treated as a 'default export' in the ES module sense by TypeScript.
  fix If you must use this legacy package, either use `const pickByArray = require('lodash._pickbyarray');` directly in your TypeScript file, or add a declaration file (`d.ts`) to inform TypeScript about its CJS export (e.g., `declare module 'lodash._pickbyarray' { function pickByArray<T>(object: T, props: string[], predicate?: (value: T[keyof T], key: keyof T, object: T) => boolean): Partial<T>; export = pickByArray; }`). However, the recommended and type-safe solution is to migrate to `import { pickBy } from 'lodash';` or `import { pickBy } from 'lodash-es';` which have official TypeScript definitions.

Warnings

• breaking This package is abandoned and has not received updates since the Lodash v3 era (published around 2015). Using it in modern applications may lead to compatibility issues with newer JavaScript features, lack of new features, and potential security vulnerabilities present in older Lodash versions that have since been patched in v4.x.
  Fix: Migrate to using the actively maintained full `lodash` or `lodash-es` package (current stable v4.18.1). Access the public `_.pickBy` utility (for filtering by predicate) or `_.pick` (for picking specific keys) directly. This ensures you benefit from active maintenance, security patches, and modern ES module support.
• gotcha This package exports `pickByArray`, an *internal* Lodash utility function with a specific signature (object, array of keys, optional predicate). It is distinct from the public `_.pickBy` function, which filters an object's properties based on a predicate applied to all properties. `pickByArray` is not intended for general application-level use as a direct replacement for `_.pickBy`.
  Fix: For filtering object properties based on a predicate, use `_.pickBy(object, predicate)` from the main `lodash` package. For picking specific keys without a predicate, use `_.pick(object, ['key1', 'key2'])`. Do not attempt to replicate `_.pickBy` functionality using this internal module.
• deprecated The strategy of modularizing internal Lodash functions into individual npm packages (e.g., `lodash._pickbyarray`) was primarily part of Lodash's v3 distribution. In Lodash v4 and later, these granular internal modules are no longer maintained or recommended. Modern JavaScript bundlers, when combined with `lodash-es` (the ES module build of Lodash), provide efficient tree-shaking capabilities, making the full `lodash-es` package the preferred and equally performant option for modular usage.
  Fix: Refactor imports to use either `import { pickBy } from 'lodash-es';` for ESM environments with tree-shaking, or `const pickBy = require('lodash/pickBy');` for CJS environments, or the full `_` object (`const _ = require('lodash');`).

Install

• npm install lodash._pickbyarray npm
• yarn add lodash._pickbyarray yarn
• pnpm add lodash._pickbyarray pnpm

Imports

• pickByArray
  wrong:

  import pickByArray from 'lodash._pickbyarray';

  correct:

  const pickByArray = require('lodash._pickbyarray');

  This package is CommonJS-only and exports the function directly. Using 'import' will result in a 'SyntaxError' or 'TypeError' in most modern environments unless transpiled or configured for CJS interop. It has not been updated since Lodash v3.
• pickBy
  wrong:

  const pickBy = require('lodash._pickbyarray');

  correct:

  import { pickBy } from 'lodash-es';

  This is the modern, publicly exposed equivalent for filtering object properties based on a predicate, available from the actively maintained 'lodash' or 'lodash-es' library. It is not available or related to the `pickByArray` function in this legacy package.
• _
  wrong:

  import _ from 'lodash._pickbyarray';

  correct:

  import _ from 'lodash'; // for ESM
  const _ = require('lodash'); // for CommonJS

  For general Lodash utilities and accessing `_.pickBy` (the public equivalent), import the main 'lodash' or 'lodash-es' package. This package only exports `pickByArray`, not the full Lodash object.

Quickstart

Shows how to use the legacy CommonJS `lodash._pickbyarray` module and contrasts its internal usage with the modern, public `_.pickBy` from the main Lodash package.

// This example demonstrates the usage of the legacy lodash._pickbyarray module (v3.x).
// This internal utility was designed for specific use cases within the Lodash core
// when an array of keys needed to be processed and optionally filtered.
// For general object filtering based on a predicate, use the public _.pickBy from the main 'lodash' package (v4.x+).

const pickByArray = require('lodash._pickbyarray');

const sourceObject = {
  id: 1,
  name: 'Widget',
  price: 9.99,
  category: 'Electronics',
  stock: 150
};

// Simulate an array of keys that might be selected by another internal Lodash process.
const keysToConsider = ['name', 'price', 'stock', 'nonExistentKey'];

// Use pickByArray: it typically takes the object, an array of keys to process,
// and an optional iteratee/predicate applied to values of those specific keys.
const pickedSubset = pickByArray(sourceObject, keysToConsider, (value, key) => {
  // This predicate filters *among the provided keys*.
  // Only pick keys where the value is a number and greater than 10.
  return typeof value === 'number' && value > 10;
});

console.log('Original object:', sourceObject);
console.log('Keys considered by internal logic:', keysToConsider);
console.log('Result using legacy lodash._pickbyarray (filtered subset):', pickedSubset);
// Expected output: { stock: 150 } (as 9.99 is not > 10)

// For comparison, using the modern, public `_.pickBy` from the main Lodash library:
const _ = require('lodash'); // Using require for consistency with the example, but import { pickBy } from 'lodash-es' is preferred for ESM
const publicPickByResult = _.pickBy(sourceObject, (value) => {
  // `_.pickBy` filters the entire object based on the predicate.
  return typeof value === 'number' && value > 10;
});
console.log('Result using modern _.pickBy (entire object filtered):', publicPickByResult);
// Expected output: { stock: 150 }