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: 8 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>

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;
}

Tests:

!!closest.length
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');
!!closest.length selector
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');

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

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: