Benchmark: Bench fast-json-patch vs microdiff

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/fast-json-patch@3.1.1/dist/fast-json-patch.min.js"></script>
<script>
  // Add this in your benchmark setup code
function diff(t,e,r={cyclesFix:!0},s=[]){
  const richTypes={Date:!0,RegExp:!0,String:!0,Number:!0};
  let a=[];
  const c=Array.isArray(t);
  for(const i in t){
    const o=t[i],n=c?+i:i;
    if(!(i in e)){a.push({type:"REMOVE",path:[n],oldValue:t[i]});continue}
    const p=e[i],y="object"==typeof o&&"object"==typeof p&&Array.isArray(o)===Array.isArray(p);
    !(o&&p&&y)||richTypes[Object.getPrototypeOf(o)?.constructor?.name]||r.cyclesFix&&s.includes(o)?o===p||Number.isNaN(o)&&Number.isNaN(p)||y&&(isNaN(o)?o+""==p+"":+o==+p)||a.push({path:[n],type:"CHANGE",value:p,oldValue:o}):a.push.apply(a,diff(o,p,r,r.cyclesFix?s.concat([o]):[]).map((t=>(t.path.unshift(n),t))))
  }
  const i=Array.isArray(e);
  for(const r in e)r in t||a.push({type:"CREATE",path:[i?+r:r],value:e[r]});
  return a
}

// Now you can use 'diff' in your benchmark tests
</script>

Script Preparation code:

obj1= {
        name: "Argentina",
        cities: [
        {
            name: 'Buenos Aires',
            population: 13028000,
        },
        {
            name: 'Cordoba',
            population: 1430023,
        },
        {
            name: 'Rosario',
            population: 1136286,
        },
        {
            name: 'Mendoza',
            population: 901126,
        },
        {
            name: 'San Miguel de Tucuman',
            population: 800000,
        }
        ]
    };
    
obj2= {
        name: "Argentina",
        cities: [
        {
            name: 'Cordoba',
            population: 1430023,
        },
        {
            name: 'Mendoza',
            population: 901126,
        },
        {
            name: 'San Miguel de Tucuman',
            population: 550000,
        }
        ]
    };

Tests:

microdiff
var diff1 = diff(obj1, obj2); /*var objnew = jsonpatch.deepClone(obj1); // jsondiffpatch.unpatch(objnew, diff1);*/
FAST JSON-patch
var diff3 = jsonpatch.compare(obj1, obj2); /*var objnew = jsonpatch.deepClone(obj1); jsonpatch.applyPatch(objnew, diff3, false, true);*/

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
microdiff
FAST JSON-patch

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
microdiff	318247.4 Ops/sec
FAST JSON-patch	1635221.1 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark you are investigating compares the performance of two libraries used for computing differences (or diffs) between two JSON objects in JavaScript: **microdiff** and **fast-json-patch**. These libraries are useful for detecting changes between two JavaScript objects or arrays, which is a common requirement when synchronizing client-side states, optimizing API data transfers, or managing state in UI frameworks.

### Libraries Overview:

1. **microdiff**:
   - **Purpose**: A lightweight library focused on JSON diffing. It provides a simple way to compute differences between two objects or arrays and is designed to be fast.
   - **Benchmarking Note**: The specific benchmark case utilizes a custom `diff` function that is crafted to identify differences between two objects while handling complex cases like cycles in object references.

2. **fast-json-patch**:
   - **Purpose**: This library is a more comprehensive solution for JSON object patching. It supports operations defined by the JSON Patch standard, allowing for CREATE, REMOVE, and REPLACE operations on object properties.
   - **Benchmarking Note**: The `jsonpatch.compare` method compares two objects and produces a patch that describes how to transform the first object into the second. The library also includes methods for applying these patches.

### Benchmark Comparison:

The benchmark runs two specific tests:
1. **microdiff**:
   - Executes the `diff` function to calculate the differences between `obj1` and `obj2`.
   - Key Result: Achieved **318,247.375 Executions per Second**.

2. **FAST JSON-patch**:
   - Uses the `jsonpatch.compare` to find differences between the same two objects.
   - Key Result: Achieved **1,635,221.125 Executions per Second**.

### Performance Insights:

- **Execution Speed**:
  - The results show that `fast-json-patch` significantly outperformed `microdiff` in terms of execution speed. This can be attributed to its optimized algorithms for dealing with more complex objects and a richer set of functionalities it offers.

- **Pros and Cons**:
  - **microdiff Pros**:
    - Lightweight and likely simpler for use cases requiring just basic diff operations.
    - Less overhead, making it suitable for smaller objects or in performance-critical applications where minimal payload is desired.
  
  - **microdiff Cons**:
    - Limited functionality: It may not provide the comprehensive patching features necessary for more complex applications.
  
  - **fast-json-patch Pros**:
    - Supports JSON Patch standard, making it versatile for various use cases where state management and synchronization between client and server are essential.
    - Built to handle larger and more complex nested structures efficiently.

- **fast-json-patch Cons**:
    - More overhead, which could be an issue for very simple scenarios where a lightweight solution suffices.
  
### Other Considerations:

When selecting between these libraries, consider:

- **Complexity of Data**: If you are working with large and complex data structures where changes are minimal, `fast-json-patch` might be the right choice due to its efficiency.
- **Maintenance and Updates**: `fast-json-patch` has broader community support and is more likely to receive regular updates aligned with the ever-evolving JSON-related standards.

### Alternatives:

1. **jsondiffpatch**: Another popular library that not only compares two objects but also can visualize the differences and offers further manipulation capabilities.
2. **deep-diff**: A library that provides a more descriptive output of the differences (additions, deletions, changes) and is capable of handling deeply nested structures.
3. **lodash**: While not specifically designed for diffing, Lodash provides several utility functions that can help manipulate and compare objects.

In conclusion, the choice between `microdiff` and `fast-json-patch` (or other alternatives) depends on specific project needs, the complexity of the data, and performance requirements.

Related benchmarks:

Bench fast-json-patch vs microdiff (version: 1)

Comparing performance of: microdiff vs FAST JSON-patch

Created: one month ago by: Registered User

Jump to the latest result

microdiff

FAST JSON-patch

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):