CODEWITHSUNDEEP
javascriptfirefox
Hanson
Hanson

Reputation: 923

event.path is undefined running in Firefox

When I run event.path[n].id in Firefox, I get this error. It works in other browsers.

event.path undefined

Upvotes: 89

Views: 64006

Answers (5)

T.J. Crowder
T.J. Crowder

Reputation: 1074248

The path property of Event objects is non-standard. The standard equivalent is the composedPath method. But it was new when the question was asked (2016); it's well-established as of this update in January 2023.

So you may want to try composedPath and fall back to path (or just use composedPath now it's established):

// Written in ES5 for compatibility with browsers that weren't obsolete
// yet when the question was posted, although they are now
var path = event.composedPath ? event.composedPath() : event.path;
if (path) {
    // You got some path information
} else {
    // This browser doesn't supply path information
}

Obviously that won't give you path information if the browser doesn't supply it, but it allows for both the old way and the new, standard way, and so will do its best cross-browser.

Example:

// Written in ES5 for compatibility with browsers that weren't obsolete
// yet when the question was posted, although they are now
document.getElementById("target").addEventListener("click", function (e) {
    // Just for demonstration purposes
    if (e.path) {
        if (e.composedPath) {
            console.log("Supports `path` and `composedPath`");
        } else {
            console.log("Supports `path` but not `composedPath`");
        }
    } else if (e.composedPath) {
        console.log("Supports `composedPath` (but not `path`)");
    } else {
        console.log("Supports neither `path` nor `composedPath`");
    }

    // Per the above, get the path if we can, first using the standard
    // method if possible, falling back to non-standard `path`
    var path = event.composedPath ? event.composedPath() : event.path;

    // Show it if we got it
    if (path) {
        console.log("Path (" + path.length + ")");
        Array.prototype.forEach.call(path, function(entry) {
            console.log(entry === window ? "window" : entry.nodeName);
        });
    }
});
.as-console-wrapper {
    max-height: 100% !important;
}
<div id="target">Click me</div>

According to MDN, all major browsers support composedPath as of January 2023. Chrome (and other Chromium-based browsers) supported both path (it was a Chrome innovation) and composedPath until v109 when path was removed. (The obsolete browsers IE11 and Legacy Edge [Microsoft Edge prior to v79 when it became a Chromium-based browser] didn't support either of them.)

If you ran into a browser that doesn't support either of them, I don't think you can get the path information as of when the event was triggered. You can get the path via e.target.parentNode and each subsequent parentNode, which is usually the same, but of course the point of composedPath is that it's not always the same (if something modifies the DOM after the event was triggered but before your handler got called).

Upvotes: 180

Benjamin Pe&#241;a Olvera
Benjamin Pe&#241;a Olvera

Reputation: 41

I had the same issue. I need the name of the HTML element. In Chrome I get the name with path. In Firefox I tried with composedPath, but it returns a different value.

For solving my problem, I used e.target.nodeName. With target function you can retrieve the HTML element in Chrome, Firefox and Safari.

This is my function in Vue.js:

selectFile(e) {
        this.nodeNameClicked = e.target.nodeName
        if (this.nodeNameClicked === 'FORM' || this.nodeNameClicked === 'INPUT' || this.nodeNameClicked === 'SPAN') {
          this.$refs.singlefile.click()
      }
    }

Upvotes: 1

Komal
Komal

Reputation: 1097

Use composePath() and use a polyfill for IE: https://gist.github.com/rockinghelvetica/00b9f7b5c97a16d3de75ba99192ff05c

include above file or paste code:

// Event.composedPath
(function(e, d, w) {
  if(!e.composedPath) {
    e.composedPath = function() {
      if (this.path) {
        return this.path;
      } 
    var target = this.target;

    this.path = [];
    while (target.parentNode !== null) {
      this.path.push(target);
      target = target.parentNode;
    }
    this.path.push(d, w);
    return this.path;
    }
  }
})(Event.prototype, document, window);

and then use:

var path = event.path || (event.composedPath && event.composedPath());

Upvotes: 5

Mr.7
Mr.7

Reputation: 2713

This function serves as a polyfill for Event.composedPath() or Event.Path

function eventPath(evt) {
    var path = (evt.composedPath && evt.composedPath()) || evt.path,
        target = evt.target;

    if (path != null) {
        // Safari doesn't include Window, but it should.
        return (path.indexOf(window) < 0) ? path.concat(window) : path;
    }

    if (target === window) {
        return [window];
    }

    function getParents(node, memo) {
        memo = memo || [];
        var parentNode = node.parentNode;

        if (!parentNode) {
            return memo;
        }
        else {
            return getParents(parentNode, memo.concat(parentNode));
        }
    }

    return [target].concat(getParents(target), window);
}

Upvotes: 12

Guillaume Jasmin
Guillaume Jasmin

Reputation: 1139

You can create your own composedPath function if it's not implemented in the browser:

function composedPath (el) {

    var path = [];

    while (el) {

        path.push(el);

        if (el.tagName === 'HTML') {

            path.push(document);
            path.push(window);

            return path;
       }

       el = el.parentElement;
    }
}

The returned value is equivalent to event.path of Google Chrome.

Example:

document.getElementById('target').addEventListener('click', function(event) {

    var path = event.path || (event.composedPath && event.composedPath()) || composedPath(event.target);
});

Upvotes: 27

Related Questions