Benchmark: JS - Optional chaining vs try catch

Script Preparation code:

const testObj = {
  axaFrInsuranceAgreement: {
    partyRoleInAgreementGroup: {
      agreementHolder: {
		relatedParty: {
          organization: {
            establishment: [
              {
                organizationDetailGroup: {
                  organizationInsuranceExperience: [
                    {
                      claimInPeriodRecords: [
                        {
                          effectivePeriod: {
                            startDateTime: "string"
                          }
                        }
                      ],
                    }
                  ],
                },
              }
            ],
          }
        }
      },
    },
  },
};

const tryGetFnSafely = (fn, defaultVal) => {
  try {
    return fn();
  } catch (e) {
    return defaultVal;
  }
};

Tests:

Optional chaining
const testObj = { axaFrInsuranceAgreement: { partyRoleInAgreementGroup: { agreementHolder: { relatedParty: { organization: { establishment: [ { organizationDetailGroup: { organizationInsuranceExperience: [ { claimInPeriodRecords: [ { effectivePeriod: { startDateTime: "string" } } ], } ], }, } ], } } }, }, }, }; const testValueOk = testObj?.axaFrInsuranceAgreement?.partyRoleInAgreementGroup?.agreementHolder?.relatedParty?.organization?.establishment?.[0]?.organizationDetailGroup?.organizationInsuranceExperience?.[0]?.claimInPeriodRecords?.[0]?.effectivePeriod?.startDateTime; const testValueErr = testObj?.axaFrInsuranceAgreement?.partyRoleInAgreementGroup?.agreementHolder?.relatedParty?.organization?.establishment?.[1]?.organizationDetailGroup?.organizationInsuranceExperience?.[1]?.claimInPeriodRecords?.[0]?.effectivePeriod?.startDateTime;
Try catch
const testObj = { axaFrInsuranceAgreement: { partyRoleInAgreementGroup: { agreementHolder: { relatedParty: { organization: { establishment: [ { organizationDetailGroup: { organizationInsuranceExperience: [ { claimInPeriodRecords: [ { effectivePeriod: { startDateTime: "string" } } ], } ], }, } ], } } }, }, }, }; const tryGetFnSafely = (fn, defaultVal) => { try { return fn(); } catch (e) { return defaultVal; } }; const testValueOk = tryGetFnSafely(() => testObj.axaFrInsuranceAgreement.partyRoleInAgreementGroup.agreementHolder.relatedParty.organization.establishment[0].organizationDetailGroup.organizationInsuranceExperience[0].claimInPeriodRecords[0].effectivePeriod.startDateTime, null); const testValueErr = tryGetFnSafely(() => testObj.axaFrInsuranceAgreement.partyRoleInAgreementGroup.agreementHolder.relatedParty.organization.establishment[1].organizationDetailGroup.organizationInsuranceExperience[1].claimInPeriodRecords[0].effectivePeriod.startDateTime, null);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Optional chaining
Try catch

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark compares the performance of two approaches: Optional Chaining (nullish coalescing operator, `?.`) and Try-Catch blocks in JavaScript. The test case creates a nested object with multiple levels of inheritance and checks if the paths exist or not.

**Optional Chaining**

Optional Chaining is a feature introduced in ECMAScript 2020 that allows you to safely navigate through nested objects without throwing errors when a property is missing. In this benchmark, Optional Chaining is used to access a specific value in the deeply nested object.

```javascript
const testValueOk = testObj?.axaFrInsuranceAgreement?.partyRoleInAgreementGroup?.agreementHolder?.relatedParty?.organization?.establishment?.[0]?.organizationDetailGroup?.organizationInsuranceExperience?.[0]?.claimInPeriodRecords?.[0]?.effectivePeriod?.startDateTime;
```

The `?.` operator returns the value if it exists, or null/undefined if it doesn't. This approach is faster because it avoids the overhead of a try-catch block.

**Try-Catch**

The Try-Catch approach uses a separate function to check if the property exists and throws an error if it's missing.

```javascript
const testValueOk = tryGetFnSafely(() => testObj.axaFrInsuranceAgreement.partyRoleInAgreementGroup.agreementHolder.relatedParty.organization.establishment[0].organizationDetailGroup.organizationInsuranceExperience[0].claimInPeriodRecords[0].effectivePeriod.startDateTime, null);
```

This approach is slower because it involves the overhead of creating and executing a try-catch block.

**Pros and Cons**

* **Optional Chaining**:
	+ Pros: faster, more concise, and safer (avoiding errors)
	+ Cons: may not be supported in older browsers or environments
* **Try-Catch**:
	+ Pros: widely supported, can handle errors, but slower
	+ Cons: more verbose, potentially slower

**Library/Function**

In this benchmark, the `tryGetFnSafely` function is a custom implementation of a try-catch block. It's not a standard JavaScript library, but rather a utility function created to demonstrate the Try-Catch approach.

**Other Considerations**

* The benchmark uses a fixed value for the nested object, which might limit its representativeness.
* The test case only checks if the path exists or not; it doesn't perform any actual computations or operations on the data.
* The benchmark is likely intended to measure the performance of the Optional Chaining feature in JavaScript.

**Alternatives**

Other approaches to safely navigate through nested objects without throwing errors include:

1. Using `in` operator to check if a property exists.
```javascript
if (testObj.axaFrInsuranceAgreement.partyRoleInAgreementGroup.agreementHolder.relatedParty.organization.establishment[0].organizationDetailGroup.organizationInsuranceExperience[0].claimInPeriodRecords[0].effectivePeriod.startDateTime in testObj.axaFrInsuranceAgreement.partyRoleInAgreementGroup.agreementHolder.relatedParty.organization.establishment[0].organizationDetailGroup.organizationInsuranceExperience[0].claimInPeriodRecords[0].effectivePeriod.startDateTime) {
  const value = testObj.axaFrInsuranceAgreement.partyRoleInAgreementGroup.agreementHolder.relatedParty.organization.establishment[0].organizationDetailGroup.organizationInsuranceExperience[0].claimInPeriodRecords[0].effectivePeriod.startDateTime;
}
```
2. Using a library like `lodash` or `underscore`, which provide utility functions for working with nested objects.

Keep in mind that these alternatives might have different performance characteristics and trade-offs compared to Optional Chaining or Try-Catch approaches.

Latest run results:

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

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

Browser/OS: Chrome 129 on Windows

View result in a separate tab

Test name	Executions per second
Optional chaining	7924569.5 Ops/sec
Try catch	125881.5 Ops/sec

Related benchmarks:

JS - Optional chaining vs try catch (version: 0)

Check if there is any response time difference between the optional chaining and the try catch in javascript.

Comparing performance of: Optional chaining vs Try catch

Created: 2 months ago by: Guest

Jump to the latest result

Optional chaining

Try catch

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):