Benchmark: isOrIn alternatives

isOrIn alternatives (version: 0)

Testing different methods of checking whether an element is or is in another element. Start from the position where you have jquery objects. Make === or parentNodes a function call. Check that alternatives return the correct answer. Try with a container selector rather than element (the main advantage() of closest()). Without redundant check.

Comparing performance of: !!closest.length vs == and parentNodes vs !!closest.length selector vs == and parentNodes selector

Created: 7 years ago by: Guest

Jump to the latest result

HTML Preparation code:

<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-3.1.0.min.js"></script>

AخA
 
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-3.1.0.min.js"></script>

Script Preparation code:

//Add 100,000 elements
var frag = document.createDocumentFragment();
for (var i=0; i<10; i++){
  var outDiv = document.createElement('div');
  for (var j=0; j<100; j++){
    var midDiv = document.createElement('div');
    for (var k=0; k<100; k++){
      var inDiv = document.createElement('div');
      if(i==6 && j==60){
        if(k==60)
          inDiv.id="one";
        else if(k==61)
          inDiv.id="two";
      }
      midDiv.appendChild(inDiv)
    }
    outDiv.appendChild(midDiv)
  }
  frag.appendChild(outDiv);
}
document.body.appendChild(frag);
var $innerOne = $(document.getElementById('one'));
var $body = $(document.body)
var isOrIn = function isOrIn(container, contained){
  var found = false;
  if(typeof container === 'string'){
    if(!container || !contained){
    }else if($(contained).is(container)){
     found=true;
    } else{
      var pointer = contained;
      var parent = pointer.parentNode;

      while(parent){
        if($(parent).is(container)){
            found=true;
            break;
        }
        pointer = parent;
        parent = pointer.parentNode;
      }

    }
  }else{
    if(!container || !contained){
    }else if(contained===container){
     found=true;
    } else{
      var pointer = contained;
      var parent = pointer.parentNode;

      while(parent && pointer!==container){
        if(parent === container){
            found=true;
            break;
        }
        pointer = parent;
        parent = pointer.parentNode;
      }

    }
  }
  return found;
}

​x
 
//Add 100,000 elementsvar frag = document.createDocumentFragment();for (var i=0; i<10; i++){  var outDiv = document.createElement('div');  for (var j=0; j<100; j++){    var midDiv = document.createElement('div');    for (var k=0; k<100; k++){      var inDiv = document.createElement('div');      if(i==6 && j==60){        if(k==60)          inDiv.id="one";        else if(k==61)          inDiv.id="two";      }      midDiv.appendChild(inDiv)    }    outDiv.appendChild(midDiv)  }  frag.appendChild(outDiv);}document.body.appendChild(frag);var $innerOne = $(document.getElementById('one'));var $body = $(document.body)var isOrIn = function isOrIn(container, contained){  var found = false;  if(typeof container === 'string'){    if(!container || !contained){    }else if($(contained).is(container)){     found=true;    } else{      var pointer = contained;      var parent = pointer.parentNode;​      while(parent){        if($(parent).is(container)){            found=true;            break;        }        pointer = parent;        parent = pointer.parentNode;      }​    }  }else{    if(!container || !contained){    }else if(contained===container){     found=true;    } else{      var pointer = contained;      var parent = pointer.parentNode;​      while(parent && pointer!==container){        if(parent === container){            found=true;            break;        }        pointer = parent;        parent = pointer.parentNode;      }​    }  }  return found;}

Tests:

!!closest.length
var found = !!$innerOne.closest($body).length; if(!found)throw new Error('BOOM');
var found = !!$innerOne.closest($body).length;
if(!found)throw new Error('BOOM');
== and parentNodes
var found = isOrIn($body[0],$innerOne[0]); if(!found)throw new Error('BOOM');
var found = isOrIn($body[0],$innerOne[0]);
if(!found)throw new Error('BOOM');
!!closest.length selector
var found = !!$innerOne.closest('body').length; if(!found)throw new Error('BOOM');
var found = !!$innerOne.closest('body').length;
if(!found)throw new Error('BOOM');
== and parentNodes selector
var found = isOrIn('body',$innerOne[0]); if(!found)throw new Error('BOOM');
var found = isOrIn('body',$innerOne[0]);
if(!found)throw new Error('BOOM');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
!!closest.length
== and parentNodes
!!closest.length selector
== and parentNodes selector

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 60 on Windows

View result in a separate tab

Test name	Executions per second
!!closest.length	629035.4 Ops/sec
== and parentNodes	2960543.5 Ops/sec
!!closest.length selector	340532.5 Ops/sec
== and parentNodes selector	167793.9 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

Let's dive into the explanation.

Benchmark Definition JSON: The provided JSON defines a benchmark for testing different methods of checking whether an element is or is in another element. The script preparation code creates a large document fragment with multiple nested elements, and then defines two functions: isOrIn (a custom function) and closest. The HTML preparation code includes the jQuery library.

Function Being Tested: The primary function being tested is isOrIn, which takes two arguments: container and contained. It checks if contained is inside or in any ancestor of container.

Comparison Options:

=== (strict equality): Compares the types of both operands.
== (loose equality): Compares only the values, ignoring type differences.
parentNodes: Returns an array of all parent nodes of contained.

Pros and Cons:

=== (strict equality)
- Pros:
  - Fast and efficient
  - Provides strong type checking
- Cons:
  - May return incorrect results for non-numeric values
  - Requires explicit type conversion
== (loose equality)
- Pros:
  - More permissive, allowing for type conversions
  - Less prone to false negatives due to type mismatches
- Cons:
  - May return incorrect results for certain numeric values
  - Slower than strict equality checks
parentNodes
- Pros:
  - Efficient and lightweight
  - Suitable for cases where exact value comparison is not necessary
- Cons:
  - Returns an array, which may be unnecessary in some cases
  - Does not account for cases where the element or container are not found

Additional Considerations:

When working with nested elements, parentNodes can be a good option to traverse up the DOM tree.
In cases where exact value comparison is crucial (e.g., searching for a specific HTML element), === may be more suitable.

Other Alternatives: For checking if an element is inside or in any ancestor of another element, you could consider using:

contains(): A jQuery method that checks if an element contains another element.
hasChild(): An alternative to ===, it returns whether the current DOM node has a child matching a given selector.

In summary, the choice of comparison option depends on your specific use case and requirements. If you need exact value comparison, === might be the best choice. However, if you need to check for containment or proximity in the DOM tree, parentNodes could be a suitable alternative.

Libraries Used:

jQuery: A popular JavaScript library used for DOM manipulation and event handling.
Safari: A web browser that implemented certain JavaScript features before they were widely adopted by other browsers.

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**Benchmark Definition JSON:**
The provided JSON defines a benchmark for testing different methods of checking whether an element is or is in another element. The script preparation code creates a large document fragment with multiple nested elements, and then defines two functions: `isOrIn` (a custom function) and `closest`. The HTML preparation code includes the jQuery library.

**Function Being Tested:**
The primary function being tested is `isOrIn`, which takes two arguments: `container` and `contained`. It checks if `contained` is inside or in any ancestor of `container`.

**Comparison Options:**

1. **`===` (strict equality)**: Compares the types of both operands.
2. **`==` (loose equality)**: Compares only the values, ignoring type differences.
3. **`parentNodes`**: Returns an array of all parent nodes of `contained`.

**Pros and Cons:**

*   **`===` (strict equality)**
    *   Pros:
        *   Fast and efficient
        *   Provides strong type checking
    *   Cons:
        *   May return incorrect results for non-numeric values
        *   Requires explicit type conversion
*   **`==` (loose equality)** 
    *   Pros:
        *   More permissive, allowing for type conversions
        *   Less prone to false negatives due to type mismatches
    *   Cons:
        *   May return incorrect results for certain numeric values
        *   Slower than strict equality checks

*   **`parentNodes`**
    *   Pros:
        *   Efficient and lightweight
        *   Suitable for cases where exact value comparison is not necessary
    *   Cons:
        *   Returns an array, which may be unnecessary in some cases
        *   Does not account for cases where the element or container are not found

**Additional Considerations:**

*   When working with nested elements, `parentNodes` can be a good option to traverse up the DOM tree.
*   In cases where exact value comparison is crucial (e.g., searching for a specific HTML element), `===` may be more suitable.

**Other Alternatives:**
For checking if an element is inside or in any ancestor of another element, you could consider using:

*   **`contains()`**: A jQuery method that checks if an element contains another element.
*   **`hasChild()`:**   An alternative  to `===`, it returns whether the current DOM node has a child matching a given selector.

In summary, the choice of comparison option depends on your specific use case and requirements. If you need exact value comparison, `===` might be the best choice. However, if you need to check for containment or proximity in the DOM tree, `parentNodes` could be a suitable alternative.

**Libraries Used:**
*   **jQuery**: A popular JavaScript library used for DOM manipulation and event handling.
*   **Safari**: A web browser that implemented certain JavaScript features before they were widely adopted by other browsers.

Related benchmarks: