Benchmark: hoek vs lodash - MeasureThat.net

HTML Preparation code:


<script src='https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.5/lodash.min.js'></script>

Script Preparation code:

function reach(obj, chain, options) {

    if (chain === false ||
        chain === null ||
        typeof chain === 'undefined') {

        return obj;
    }

    options = options || {};
    if (typeof options === 'string') {
        options = { separator: options };
    }

    const path = chain.split(options.separator || '.');
    let ref = obj;
    for (let i = 0; i < path.length; ++i) {
        let key = path[i];
        if (key[0] === '-' && Array.isArray(ref)) {
            key = key.slice(1, key.length);
            key = ref.length - key;
        }

        if (!ref ||
            !((typeof ref === 'object' || typeof ref === 'function') && key in ref) ||
            (typeof ref !== 'object' && options.functions === false)) {         // Only object and function can have properties

            exports.assert(!options.strict || i + 1 === path.length, 'Missing segment', key, 'in reach path ', chain);
            exports.assert(typeof ref === 'object' || options.functions === true || typeof ref !== 'function', 'Invalid segment',
key, 'in reach path ', chain);
            ref = options.default;
            break;
        }

        ref = ref[key];
    }

    return ref;
}

function reachTemplate(obj, template, options) {

    return template.replace(/{([^}]+)}/g, ($0, chain) => {

        const value = reach(obj, chain, options);
        return (value === undefined || value === null ? '' : value);
    });
}

_.templateSettings.interpolate = /{([^}]+)}/g;

var str = 'jsdhifhsdl {name} jsdffsjlj sdf sdfsg{name}dsf gdsfds{name}fsdfdgsdfdf{name}dsgsdsds{name}dggsd gsdg{name} sdgsdgsd{name}g'

Tests:

hoek
reachTemplate({name: 'VADIM'}, str)
lodash
var compiled = _.template(str); compiled({name: 'VADIM'});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
hoek
lodash

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):

LLMs can make mistakes. Check important info.

I'll break down the provided benchmarking JSON and explain what's being tested.

**Benchmark Definition**

The benchmark is comparing two JavaScript libraries: Hoek and Lodash.

**Script Preparation Code**

Hoek's `reach` function takes three arguments:

*   `obj`: The object to be processed.
*   `chain`: A string representing the path to traverse within the object.
*   `options`: An object containing configuration options (default is an empty object).

Lodash's template engine uses the `_.template()` method, which takes a string template and returns a function. This function is then called with an object as an argument.

**Individual Test Cases**

There are two test cases:

1.  **Hoek**: The Hoek `reach` function is called with a string template `{name} {name}` and an object `{name: 'VADIM'}`.
2.  **Lodash**: Lodash's template engine is used to compile a template string, which is then called with an object `{name: 'VADIM'}`.

**Options Compared**

In the Hoek `reach` function:

*   The `options` parameter controls various aspects of the path traversal:
    *   `separator`: Determines how path segments are separated (defaults to `.`, but can be a string).
    *   `functions`: A flag indicating whether functions should be treated as objects (default is `false`).

**Pros and Cons**

*   **Hoek**: Provides more flexibility in terms of options, which might be beneficial for complex object paths. However, this also means that the code may become harder to read and maintain if not used carefully.
*   **Lodash**: Offers a simple, concise way to use templates with objects. The default behavior is straightforward, but it may not provide the same level of customization as Hoek.

**Libraries**

*   **Hoek**: A minimalist JavaScript library for working with data and strings.
*   **Lodash**: A comprehensive utility library that provides functions for common tasks, such as template rendering.

**Special JS Features or Syntax**

The code uses a template string syntax, which is specific to JavaScript. This syntax allows for easy string interpolation using curly brackets `{}`.

**Alternatives**

If you're looking for alternative JavaScript libraries for data processing and string manipulation, consider the following options:

*   **Underscore.js**: Similar to Lodash, but with some differences in its API and functionality.
*   **Moment.js**: A popular library for date and time manipulation.
*   **JQuery**: A popular JavaScript library for DOM manipulation and events.

These libraries may not provide the same level of flexibility as Hoek or Lodash, but they can still be useful depending on your specific needs.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.80 Safari/537.36

Browser/OS: Chrome 98 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
hoek	232951.5 Ops/sec
lodash	37046.0 Ops/sec

Related benchmarks:

hoek vs lodash (version: 0)

Comparing performance of: hoek vs lodash

Created: 4 years ago by: Registered User

Jump to the latest result

hoek

lodash

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 27 days ago):