or run

tessl search

Version

Files

docs

tile.json

tessl/npm-lodash--baseisequal

Deep equality comparison utility function for comprehensive value equality checking in JavaScript

Workspace: tessl
Visibility: Public
Created: 4 months ago
Last updated: 4 months ago
Describes: pkg:npm/lodash._baseisequal@3.0.x

To install, run

tessl install tessl/npm-lodash--baseisequal@3.0.0

lodash._baseisequal

lodash._baseisequal provides the internal baseIsEqual function from the lodash utility library as a standalone module for deep equality comparisons between JavaScript values. It implements a sophisticated equality algorithm that handles primitives, objects, arrays, dates, regular expressions, typed arrays, and other complex data types with proper circular reference detection and type-specific comparison logic.

Package Information

Package Name: lodash._baseisequal
Package Type: npm
Language: JavaScript
Installation: npm install lodash._baseisequal

Core Imports

var baseIsEqual = require('lodash._baseisequal');

Basic Usage

var baseIsEqual = require('lodash._baseisequal');

// Basic equality comparisons
baseIsEqual('hello', 'hello'); // true
baseIsEqual(123, 123); // true
baseIsEqual(true, true); // true

// Deep object comparison
baseIsEqual({a: 1, b: 2}, {a: 1, b: 2}); // true
baseIsEqual({a: 1, b: 2}, {a: 1, b: 3}); // false

// Array comparison
baseIsEqual([1, 2, 3], [1, 2, 3]); // true
baseIsEqual([1, 2, 3], [1, 2, 4]); // false

// Complex nested structures
var obj1 = {
  user: {
    name: 'Alice',
    settings: {
      theme: 'dark',
      notifications: true
    },
    tags: ['admin', 'user']
  }
};

var obj2 = {
  user: {
    name: 'Alice', 
    settings: {
      theme: 'dark',
      notifications: true
    },
    tags: ['admin', 'user']
  }
};

baseIsEqual(obj1, obj2); // true

Capabilities

Deep Equality Comparison

Performs comprehensive deep equality comparison between two values, handling all JavaScript data types with proper circular reference detection.

/**
 * The base implementation of _.isEqual without support for `this` binding
 * `customizer` functions.
 * 
 * @param {*} value - The value to compare
 * @param {*} other - The other value to compare  
 * @param {Function} [customizer] - The function to customize comparing values
 * @param {boolean} [isLoose] - Specify performing partial comparisons
 * @param {Array} [stackA] - Tracks traversed value objects
 * @param {Array} [stackB] - Tracks traversed other objects
 * @returns {boolean} Returns true if the values are equivalent, else false
 */
function baseIsEqual(value, other, customizer, isLoose, stackA, stackB);

Supported Data Types:

Primitives: Strings, numbers, booleans, null, undefined
Objects: Plain objects with constructor checking and property comparison
Arrays: Regular and sparse arrays with element-by-element comparison
Dates: Timestamp-based comparison
Regular Expressions: Source pattern and flags comparison
Error Objects: Name and message comparison
Typed Arrays: Element-wise comparison for typed array types
Arguments Objects: Treated as regular objects for comparison
Functions: Identity comparison (===)

Special Features:

Circular Reference Detection: Safely handles objects with circular references
NaN Handling: Treats NaN === NaN as true (unlike native ===)
Negative Zero: Distinguishes between +0 and -0 when appropriate
Constructor Checking: Validates object constructors for non-Object instances
Partial Comparison: Optional loose mode for partial matching

Usage Examples:

var baseIsEqual = require('lodash._baseisequal');

// Handle circular references safely
var obj1 = {name: 'test'};
obj1.self = obj1;
var obj2 = {name: 'test'};
obj2.self = obj2;
baseIsEqual(obj1, obj2); // true

// Date comparison
baseIsEqual(new Date('2023-01-01'), new Date('2023-01-01')); // true
baseIsEqual(new Date('2023-01-01'), new Date('2023-01-02')); // false

// RegExp comparison
baseIsEqual(/hello/gi, /hello/gi); // true
baseIsEqual(/hello/gi, /hello/g); // false

// Error objects
var err1 = new Error('test message');
var err2 = new Error('test message');
baseIsEqual(err1, err2); // true

// Typed arrays
baseIsEqual(new Int32Array([1, 2, 3]), new Int32Array([1, 2, 3])); // true

// NaN handling (different from native ===)
baseIsEqual(NaN, NaN); // true
baseIsEqual(0, -0); // true

Custom Comparison Logic

When provided with a customizer function, allows for specialized equality logic while maintaining the robust foundation of the base comparison algorithm.

/**
 * Custom comparison example with customizer function
 * @param {*} value - First value to compare
 * @param {*} other - Second value to compare  
 * @param {Function} customizer - Function that returns comparison result or undefined to defer to default logic
 * @returns {boolean} Comparison result
 */
baseIsEqual(value, other, customizer);

Usage Example:

// Custom comparison that ignores case for string values
function customizer(objValue, othValue) {
  if (typeof objValue === 'string' && typeof othValue === 'string') {
    return objValue.toLowerCase() === othValue.toLowerCase();
  }
  // Return undefined to defer to default comparison logic
  return undefined;
}

baseIsEqual('Hello', 'hello', customizer); // true
baseIsEqual({msg: 'Hello'}, {msg: 'hello'}, customizer); // true

Partial Comparison Mode

Supports partial comparison mode via the isLoose parameter for scenarios where partial matching is required.

/**
 * Partial comparison example
 * @param {*} value - Value to compare
 * @param {*} other - Other value to compare
 * @param {Function} [customizer] - Optional customizer function
 * @param {boolean} isLoose - Enable partial comparison mode
 * @returns {boolean} Comparison result allowing partial matches
 */
baseIsEqual(value, other, customizer, isLoose);