Benchmark: Diffenent ways to get cookie

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 getCookieIX2(name, str) {
  name = name + "=";
  var ck = str || document.cookie;
  ck = "; " + ck;
  // support if the 
  var ckLC = ck.toLowerCase();
  var idx = ckLC.lastIndexOf("; " + name.toLowerCase());
  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);
    p1 = decodeURIComponent(p1);
    return p1;
  }
  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')
LastindexOf2
getCookieIX2('foo')

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Original
Regex
RegexLoop
LastIndexOf
LastindexOf2

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON tests different methods for retrieving cookies from the browser's document. The cookie retrieval methods compared in this benchmark include:

1. **Original** - `getCookie('foo')`: This method splits the `document.cookie` string into an array of individual cookies, iterates over them, and checks for the desired cookie name. If found, it returns the decoded value.

2. **Regex** - `getCookieM('foo')`: This method utilizes a regular expression to search for the cookie directly. The regex matches the format of a cookie in the `document.cookie` string. Upon finding a match, it extracts and decodes the value.

3. **RegexLoop** - `getCookieW('foo')`: Similar to the previous regex approach but it employs a while loop to search through the cookie string, catching multiple instances as it scans through the string.

4. **LastIndexOf** - `getCookieIX('foo')`: This method finds the last occurrence of the cookie name using `lastIndexOf`, then extracts the substring afterward until the next semicolon. It effectively handles the parsing without splitting the entire string upfront.

5. **LastIndexOf2** - `getCookieIX2('foo')`: An extension of the LastIndexOf method which converts the entire cookie string to lowercase. This is done to ensure case-insensitivity when searching for the cookie name. It also handles decoding right after retrieval.

### Pros and Cons of Each Approach:

1. **Original Method:**
   - **Pros**: Simple and straightforward; easy to understand and implement.
   - **Cons**: Performance can degrade with a large number of cookies because it splits the string into an array, then iterates through it.

2. **Regex Method (getCookieM):** 
   - **Pros**: Efficient for searching patterns; can handle more complex cookie formats and perform case-insensitive searches.
   - **Cons**: Regular expressions can be harder to read and maintain. They may also perform poorly if the regex is not optimized.

3. **Regex Loop Method (getCookieW):**
   - **Pros**: More flexible as it finds multiple matches, thus can handle scenarios with duplicate cookie names better.
   - **Cons**: More complex due to the additional looping logic. Performance may suffer if there are many unnecessary matches.

4. **LastIndexOf Method (getCookieIX):**
   - **Pros**: Provides better performance by not creating an array and looking for the cookie name efficiently.
   - **Cons**: Less readable as it relies on string manipulation techniques that may be less intuitive for someone less familiar with JavaScript.

5. **LastIndexOf2 Method (getCookieIX2):**
   - **Pros**: Adds case insensitivity and decoding right away, improving reliability when dealing with cookie names.
   - **Cons**: Similar drawbacks to LastIndexOf, such as readability, and would maintain slightly lower performance due to the string conversions.

### Key Library/Feature Use:
These methods do not reference any external library; they solely rely on built-in JavaScript functionality. Key JavaScript capabilities leveraged here include:
- **String methods** like `indexOf`, `lastIndexOf`, `substring`, and `split` for cookie handling.
- **Regular expressions** for searching within strings, providing a powerful tool for pattern matching.

### Other Considerations:
- **Security**: When retrieving cookies, understanding the security considerations (like HttpOnly and Secure flags) is vital, especially with sensitive information. The methods do not account for these properties.
- **Browser Differences**: Performance can vary across browser engines, so results from benchmarks should be considered in a context-specific manner.
- **Alternatives**: As alternatives to these methods, one could use third-party libraries such as `js-cookie`, which abstracts away the complexity of cookie handling while providing a simpler API. It can ensure better compatibility and handle edge cases gracefully.

In summary, this benchmark is an important tool for developers looking to optimize their cookie handling in JavaScript by comparing the performance of different retrieval methods. Understanding the pros and cons of each approach can guide the selection of the most suitable method for their application's needs.

Latest run results:

Run details: (Test run date: 27 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	745670.6 Ops/sec
Regex	657166.3 Ops/sec
RegexLoop	543653.2 Ops/sec
LastIndexOf	1489295.8 Ops/sec
LastindexOf2	895241.8 Ops/sec

Related benchmarks:

Diffenent ways to get cookie (version: 0)

Comparing performance of: Original vs Regex vs RegexLoop vs LastIndexOf vs LastindexOf2

Created: 27 days ago by: Guest

Jump to the latest result

Original

Regex

RegexLoop

LastIndexOf

LastindexOf2

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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