Val

The Val Type comprises utility methods primarily focusing on value operations, including comparisons, Type checks, and conversions. These functions are crucial for developers handling data processing, validation, and transformation. By leveraging these utilities, developers can ensure data integrity, perform complex data manipulations, and enhance the robustness of their applications.

The compareValues function compares two values, handling scenarios involving null values and different data types. This function is essential for sorting algorithms, equality checks, and when implementing custom comparison logic.

Val.compareValues(null, null) === 0
Val.compareValues(null, 'a') < 0
Val.compareValues(12, null) > 0
Val.compareValues(1, 1.2) < 0

In a real-world scenario, such as sorting an array of objects based on a property which might have null or undefined values, compareValues can be used as a custom comparator.

const data = [{
    age: 30
}, { 
    age: null
}, { 
    age: 25
}];
data.sort((a, b) => Val.compareValues(a.age, b.age));

You can encounter scenarios where data consistency and type handling are critical. For instance, in financial applications where precise numerical comparisons are required, or in data processing tasks where sorting and grouping of heterogeneous data types is common. Here, the Val Type functions assist by providing reliable and efficient ways to handle these operations.

Copy link to this section

Useful code snippets

Copy link to this section

compareValues Function

• Val.compareValues(null, null) === 0: Compares two null values, which are considered equal, hence the result is 0.
• Val.compareValues(null, null, true) === 0: Similar comparison as above, possibly with an additional argument that doesn't alter the outcome.
• Val.compareValues(null, null, false) === 0: Same as above, indicating that the third argument does not impact the comparison of two null values.
• Val.compareValues(null, 'a') < 0: Compares null with a string 'a'. By this function's logic, null is considered "less than" any non-null value, resulting in a negative value.
• Val.compareValues(null, 'a', true) > 0: With the third argument true, the comparison logic is inverted, making null "greater than" non-null values.
• Val.compareValues(12, null) > 0: Compares an integer 12 with null. The integer is considered "greater than" null, resulting in a positive value.
• Val.compareValues(12, null, true) < 0: With the third argument true, the comparison is inverted; 12 is now "less than" null.
• Val.compareValues(1, 1) === 0: Compares two identical integers, which are considered equal.
• Val.compareValues(1, 1.0) === 0: Compares an integer and a floating-point number with the same value, considered equal.
• Val.compareValues(1.2, 1.2) === 0: Compares two identical floating-point numbers.
• Val.compareValues(1, 1.2) < 0: Compares an integer and a floating-point number. The integer is "less than" the floating-point number.
• Val.compareValues(1.2, 1) > 0: Inverts the previous comparison; the floating-point number is "greater than" the integer.
• Val.compareValues(1.2, 1.1) > 0: Compares two floating-point numbers; 1.2 is "greater than" 1.1.
• Val.compareValues('a', 'b') < 0: Compares two strings; 'a' is considered "less than" 'b'.
• Val.compareValues('aa', 'ab') < 0: Compares two strings; 'aa' is "less than" 'ab'.
• Val.compareValues('aab', 'aaaa') > 0: Compares two strings; 'aab' is "greater than" 'aaaa'.

Copy link to this section

isEmpty

The isEmpty function checks if a given value is "empty," which includes null, empty strings, empty collections, and objects without enumerable properties.

Val.isEmpty(null) // returns true
Val.isEmpty('') // returns true
Val.isEmpty('x') // returns false
Val.isEmpty({}) // returns true
Val.isEmpty({ x: 1 }) // returns false

Checking if a response object from an API call is empty:

function isResponseEmpty(response) {
    return Val.isEmpty(response.data);
}

Useful in API data handling, where checking for empty responses is crucial to avoid processing errors.

Copy link to this section

Useful code snippets

• Val.isEmpty(null) === true: Checks if null is considered empty, which it is.
• Val.isEmpty('') === true: Checks if an empty string is considered empty, which it is.
• Val.isEmpty(' ') === true: Checks if a string with only spaces is considered empty.
• Val.isEmpty('x') === false: A non-empty string is not considered empty.
• Val.isEmpty(Bin.zeroes(0)) === true: Checks if a binary representation with zero length is empty.
• Val.isEmpty({}) === true: An empty object is considered empty.
• Val.isEmpty({ x: 1 }) === false: An object with properties is not considered empty.

Copy link to this section

Checking for equality

The isPolyStrictEqual function in the Val Type implements a strict equality test similar to the === operator in JavaScript. This function ensures that both operands have the same type and value. It is specifically designed to work with "made" objects, meaning custom or specific object instances, and the comparison is commutative, indicating that the order of the operands does not affect the result.

Copy link to this section

Key Characteristics of isPolyStrictEqual

• Strict Type and Value Comparison: Similar to the === operator, isPolyStrictEqual checks for both type and value equality. This means that two values will only be considered equal if they are of the same type and have the same value.

• Designed for Custom Objects: The function is tailored for comparisons involving custom-made objects, ensuring that the comparison is meaningful and accurate for these types of data structures.

• Commutative Comparison: The function is commutative, which means that the order of the operands does not impact the outcome of the comparison. Val.isPolyStrictEqual(a, b) will yield the same result as Val.isPolyStrictEqual(b, a).

• isPolyStrictEqual is particularly useful in scenarios where precise comparison between complex objects is required, such as in unit testing, data validation, or when implementing custom data structures. Its strict nature makes it an excellent tool for ensuring data integrity and for debugging purposes, where understanding the exact nature of the data is crucial.

This function represents a valuable addition to the JavaScript developer's toolkit, especially when dealing with complex and custom data types where standard comparison operators might not provide the necessary level of precision or clarity.

Copy link to this section

The compareValues function

Suppose we have an array of product objects, and we need to sort them by their price. Some products may not have a price listed (price is null).

const products = [
  { name: "Laptop", price: 900 },
  { name: "Phone", price: null },
  { name: "Camera", price: 450 }
];

products.sort((a, b) => Val.compareValues(a.price, b.price));

// After sorting, products with 'null' prices will be at the end of the array

This code sorts an array of products based on their price using Val.compareValues. Products without a price (where price is null) are considered lesser in value and are sorted accordingly.

Copy link to this section

The isEmpty function

Real-World Use Case: Validating Form Input In a web application, checking if the user has left a form input field empty before submitting the form.

function validateFormInput(input) {
  if (Val.isEmpty(input)) {
    alert("Input cannot be empty");
    return false;
  }
  return true;
}

// Usage
validateFormInput(userInput);

The validateFormInput function uses Val.isEmpty to check if the input is empty (such as an empty string, null, or an object with no properties). If the input is empty, the user is alerted, and the form submission is halted.

Copy link to this section

The isPolyStrictEqual function

In an application, comparing two user profile objects to determine if they are identical.

const userProfile1 = { name: "Alice", age: 30 };
const userProfile2 = { name: "Alice", age: 30 };

const areProfilesIdentical = Val.isPolyStrictEqual(userProfile1, userProfile2);

// This will return 'true' or 'false' based on whether the profiles are identical

This example demonstrates using Val.isPolyStrictEqual to compare two user profile objects. It checks if both objects have the same type and value for each property, which in this case are name and age.

Each of these examples demonstrates how the Val Type functions can be applied in practical situations, showcasing their utility in handling comparisons, validations, and data integrity checks in JavaScript applications.

The is* Predicates section in the Val Type provides a series of functions for type checking and validation. These predicates are crucial for ensuring that variables or data structures are of expected types, enhancing the robustness and reliability of the code.

Copy link to this section

Predicate functions

The predicates like isArray, isMap, isSet, isCollection, isInstance, isInstanceOf, isWithType, isObj, isType, isTuple, isNamedTuple, and isUnnamedTuple are used to check if a given variable is of a specific type or structure.

The is* Predicates in the Val Type provide a powerful set of tools for type checking and validation, which are crucial in many programming scenarios, especially where type safety is paramount. Whether it's for validating API responses, distinguishing between different object types in a game, or other use cases, these functions add a layer of security and robustness to JavaScript applications.