Benchmark: getCookie variations

Script Preparation code:

function getCookieIX(name,str){
  name = name+'=';
  var ck = str || document.cookie;
  var idx = ck.lastIndexOf(name);
  if(idx==-1){ return undefined}
  var nameLength = name.length;
  var p1 = ck.substring(idx+nameLength);
  var idx2 = p1.indexOf(';');
  if(idx2>-1){
    p1 = p1.substring(0,idx2);
  }
  return p1;
}

function getCookie(name) {
  var nameEQ = name + "=";
  var ca = document.cookie.split(";");
  for (var i = 0; i < ca.length; i++) {
    var c = ca[i];
    while (c.charAt(0) == " ") c = c.substring(1, c.length);
    if (c.indexOf(nameEQ) == 0) {
      var d = c.substring(nameEQ.length, c.length);
      d = decodeURIComponent(d);
      return d;
    }
  }
  return undefined;
}

function getCookieM(name) {
  name = name + "";
  var re = new RegExp("(^| )" + name + "=([^;]+)", "gmi");
  var m = document.cookie.match(re);
  if (!!m) {
    m = m.pop();
    m = m.substring(m.indexOf("=") + 1);
    m = !!m ? decodeURIComponent(m) : m;
    return m;
  }
}

function getCookieW(name, str) {
  var str = str || document.cookie;
  var re = new RegExp("(?:^|; )("+name+"+?)(?:=([^;]*))?(?:;|$)", "gi");
  var value;
  var match;
  while ((match = re.exec(str))) {
    re.lastIndex = match.index + match.length - 1;
    var k = match[1];
    var v = decodeURIComponent(match[2]);
    !!v && (value = v);
  }

  return value;
}

document.cookie = "foo=bar";
document.cookie = "foo=nope;domain=measurethat.net";

Tests:

original
getCookie('foo')
Regex
getCookieM('foo')
regexloop
getCookieW('foo')
lastIndexOf
getCookieIX('foo')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
original
Regex
regexloop
lastIndexOf

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 28 days ago):

LLMs can make mistakes. Check important info.

The benchmark from MeasureThat.net focuses on comparing different methods for cookie retrieval in JavaScript, specifically the retrieval of a cookie named "foo" from the `document.cookie` string. The benchmark presents four methods, each with distinct implementations and performance characteristics. Here is an overview of the options tested, their pros and cons, and relevant information regarding the libraries or features used:

### Test Cases and Descriptions

1. **Original Method (`getCookie`):**
   - **Implementation:** This function builds a string matching the cookie name, then splits `document.cookie` by `;` to find the cookie directly.
   - **Pros:** 
     - Simple and readable implementation.
     - Straightforward logic for cookie retrieval.
   - **Cons:** 
     - Uses a linear search through all cookies, which may be less efficient as the number of cookies increases.

2. **Regex Method (`getCookieM`):**
   - **Implementation:** Utilizes a regular expression to match the desired cookie directly within the `document.cookie` string.
   - **Pros:** 
     - More concise for conditions where regex is preferred.
     - Can potentially be faster in cases where complex patterns are required.
   - **Cons:** 
     - Regular expressions can be harder to read and maintain for developers not familiar with regex syntax.
     - Overhead can increase due to regex compilation and execution times, especially in simpler cases where they may not be necessary.

3. **Regex Loop Method (`getCookieW`):**
   - **Implementation:** A regular expression is used within a loop to find and return the value of the cookie, allowing for continued scanning of cookie matches.
   - **Pros:**
     - Can handle edge cases more robustly by continuing to search for matches.
   - **Cons:** 
     - Less efficient than the more direct methods; may suffer from the overhead of repeated regex evaluations.
     - Complexity increases, making it difficult to read and comprehend quickly.

4. **Last Index Of Method (`getCookieIX`):**
   - **Implementation:** Utilizes `lastIndexOf` to find the cookie's position and substring methods to extract its value.
   - **Pros:** 
     - May optimize searching by locating the last occurrence, which could be beneficial in specific scenarios based on the string’s structure.
     - Maintains simplicity and directness in the extraction.
   - **Cons:** 
     - Still performs a linear search which might be less efficient for very long cookie strings compared to other methods.
     
### Benchmark Results

The benchmark results demonstrate the performance of each method in terms of executions per second on a specific environment (Chrome 128 on Windows). Notably, the `lastIndexOf` method achieved the highest execution rate at approximately **1,555,234 executions per second**, indicating this method's efficiency for the given tasks. The `original` method followed with about **790,650 executions per second**, while the regex-utilizing methods (both `Regex` and `regexloop`) showed lesser performance with around **729,703** and **564,110 executions per second**, respectively.

### Considerations and Alternatives

1. **Readability vs Performance:** In scenarios where cookie handling is frequent but performance is less critical, the original method's simplicity may outweigh its slower execution speed. Conversely, if performance is paramount due to numerous cookies, the lastIndexOf method might be more suitable.

2. **Complexity:** Regular expressions, while powerful, can introduce maintenance challenges. Their usage should be justified with concrete performance benefits.

3. **Browser Compatibility:** All methods are compatible with standard browsers, but performance may vary by user agent due to differences in JavaScript engines.

4. **Native JavaScript Alternatives:** Alternatives include using third-party libraries such as **js-cookie**, which simplify the process of handling cookies (allowing for set, get, and remove operations straightforwardly) while abstracting performance concerns about different cookie methods.

This benchmark gives insight into how different JavaScript techniques can affect performance in real-world scenarios. The choice of method should balance trade-offs in performance, readability, and maintainability based on specific application requirements.

Latest run results:

Run details: (Test run date: 28 days ago)

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

Browser/OS: Chrome 128 on Windows

View result in a separate tab

Test name	Executions per second
original	790649.8 Ops/sec
Regex	729702.8 Ops/sec
regexloop	564110.1 Ops/sec
lastIndexOf	1555233.8 Ops/sec

Related benchmarks:

getCookie variations (version: 0)

Comparing performance of: original vs Regex vs regexloop vs lastIndexOf

Created: 28 days ago by: Guest

Jump to the latest result

original

Regex

regexloop

lastIndexOf

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 28 days ago):