Question

我想要：

document.createElement('div')  //=> true
{tagName: 'foobar something'}  //=> false

在我自己的脚本中，我曾经只是使用它，因为我从来不需要tagName作为属性：

if (!object.tagName) throw ...;

因此，对于第二个对象，我想出了以下作为快速解决方案 - 主要是有效的。 ;）

问题是，它取决于强制执行只读属性的浏览器，而不是全部都这样做。

function isDOM(obj) {
  var tag = obj.tagName;
  try {
    obj.tagName = '';  // Read-only for DOM, should throw exception
    obj.tagName = tag; // Restore for normal objects
    return false;
  } catch (e) {
    return true;
  }
}

有一个很好的替代品吗？

Answer 1

这可能是有意义的：

function isElement(obj) {
  try {
    //Using W3 DOM2 (works for FF, Opera and Chrome)
    return obj instanceof HTMLElement;
  }
  catch(e){
    //Browsers not supporting W3 DOM2 don't have HTMLElement and
    //an exception is thrown and we end up here. Testing some
    //properties that all elements have (works on IE7)
    return (typeof obj==="object") &&
      (obj.nodeType===1) && (typeof obj.style === "object") &&
      (typeof obj.ownerDocument ==="object");
  }
}

这是DOM, Level2。

的一部分

更新2 ：这是我在自己的库中实现它的方式：（之前的代码在Chrome中不起作用，因为Node和HTMLElement是函数而不是预期的对象。此代码在FF3，IE7，Chrome 1和Opera 9中进行测试。）

//Returns true if it is a DOM node
function isNode(o){
  return (
    typeof Node === "object" ? o instanceof Node : 
    o && typeof o === "object" && typeof o.nodeType === "number" && typeof o.nodeName==="string"
  );
}

//Returns true if it is a DOM element    
function isElement(o){
  return (
    typeof HTMLElement === "object" ? o instanceof HTMLElement : //DOM2
    o && typeof o === "object" && o !== null && o.nodeType === 1 && typeof o.nodeName==="string"
);
}

Answer 2

以下IE8兼容，超简单代码完美运行。

accepted answer未检测到所有类型的HTML元素。例如，不支持SVG元素。相比之下，这个答案适用于HTML以及SVG。

在此处查看此行动：https://jsfiddle.net/eLuhbu6r/

function isElement(element) {
    return element instanceof Element || element instanceof HTMLDocument;  
}

Answer 3

上面和下面的所有解决方案（包括我的解决方案）都有可能出错，特别是在IE上 - 很有可能（重新）定义一些对象/方法/属性来模仿DOM节点，使得测试无效。 / p>

所以我经常使用鸭子式的测试：我专门测试我使用的东西。例如，如果我想克隆一个节点，我会像这样测试它：

if(typeof node == "object" && "nodeType" in node &&
   node.nodeType === 1 && node.cloneNode){
  // most probably this is a DOM node, we can clone it safely
  clonedNode = node.cloneNode(false);
}

基本上这是一个小小的理智检查+我计划使用的方法（或财产）的直接测试。

顺便说一句，上面的测试对所有浏览器上的DOM节点都是一个很好的测试。但是，如果您想要安全起见，请始终检查方法和属性的存在并验证其类型。

编辑： IE使用ActiveX对象来表示节点，因此它们的属性不像真正的JavaScript对象，例如：

console.log(typeof node.cloneNode);              // object
console.log(node.cloneNode instanceof Function); // false

虽然它应分别返回“function”和true。测试方法的唯一方法是查看是否已定义。

Answer 4

您可以尝试将其附加到真正的DOM节点......

function isDom(obj)
{
    var elm = document.createElement('div');
    try
    {
        elm.appendChild(obj);
    }
    catch (e)
    {
        return false;
    }

    return true;
}

Answer 5

Lo-Dash's _.isElement怎么样？

$ npm install lodash.iselement

在代码中：

var isElement = require("lodash.iselement");
isElement(document.body);

Answer 6

这来自可爱的JavaScript库MooTools：

if (obj.nodeName){
    switch (obj.nodeType){
    case 1: return 'element';
    case 3: return (/\S/).test(obj.nodeValue) ? 'textnode' : 'whitespace';
    }
}

Answer 7

使用找到here的根检测，我们可以确定是否 alert 是对象根目录的成员，后者可能是一个窗口：

function isInAnyDOM(o) { 
  return (o !== null) && !!(o.ownerDocument && (o.ownerDocument.defaultView || o.ownerDocument.parentWindow).alert); // true|false
}

确定对象是否是当前窗口更简单：

function isInCurrentDOM(o) { 
  return (o !== null) && !!o.ownerDocument && (window === (o.ownerDocument.defaultView || o.ownerDocument.parentWindow)); // true|false
}

这似乎比开放主题中的try / catch解决方案便宜。

Don P

Answer 8

旧帖子，但这里有 ie8和ff3.5 用户更新的可能性：

function isHTMLElement(o) {
    return (o.constructor.toString().search(/\object HTML.+Element/) > -1);
}

Answer 9

var IsPlainObject = function ( obj ) { return obj instanceof Object && ! ( obj instanceof Function || obj.toString( ) !== '[object Object]' || obj.constructor.name !== 'Object' ); },
    IsDOMObject = function ( obj ) { return obj instanceof EventTarget; },
    IsDOMElement = function ( obj ) { return obj instanceof Node; },
    IsListObject = function ( obj ) { return obj instanceof Array || obj instanceof NodeList; },

//实际上我更有可能使用这些内联，但有时候设置代码的这些快捷方式很好

Answer 10

这可能会有所帮助： isDOM

//-----------------------------------
// Determines if the @obj parameter is a DOM element
function isDOM (obj) {
    // DOM, Level2
    if ("HTMLElement" in window) {
        return (obj && obj instanceof HTMLElement);
    }
    // Older browsers
    return !!(obj && typeof obj === "object" && obj.nodeType === 1 && obj.nodeName);
}

在上面的代码中，我们使用 double negation 运算符来获取作为参数传递的对象的布尔值，这样我们确保在条件语句中计算的每个表达式都是布尔值，利用 Short-Circuit Evaluation ，因此该函数返回true或false

Answer 11

您可以查看相关对象或节点是否返回字符串类型。

typeof (array).innerHTML === "string" => false
typeof (object).innerHTML === "string" => false
typeof (number).innerHTML === "string" => false
typeof (text).innerHTML === "string" => false

//any DOM element will test as true
typeof (HTML object).innerHTML === "string" => true
typeof (document.createElement('anything')).innerHTML === "string" => true

Answer 12

不需要黑客，你可以问一个元素是否是Element的一个实例：

const isElement = el => el instanceof Element

Answer 13

我建议一种测试变量是否为DOM元素的简单方法

    function isDomEntity(entity) {

        if( typeof entity   === 'object' && entity.nodeType != undefined){
            return true;
        }
        else{
            return false;
        }
    }

Answer 14

对于使用Angular的人：

angular.isElement

https://docs.angularjs.org/api/ng/function/angular.isElement

Answer 15

也许这是另类选择？在Opera 11，FireFox 6，Internet Explorer 8，Safari 5和Google Chrome 16中进行了测试。

function isDOMNode(v) {
  if ( v===null ) return false;
  if ( typeof v!=='object' ) return false;
  if ( !('nodeName' in v) ) return false; 

  var nn = v.nodeName;
  try {
    // DOM node property nodeName is readonly.
    // Most browsers throws an error...
    v.nodeName = 'is readonly?';
  } catch (e) {
    // ... indicating v is a DOM node ...
    return true;
  }
  // ...but others silently ignore the attempt to set the nodeName.
  if ( v.nodeName===nn ) return true;
  // Property nodeName set (and reset) - v is not a DOM node.
  v.nodeName = nn;

  return false;
}

功能不会被例如愚弄这个

isDOMNode( {'nodeName':'fake'} ); // returns false

Answer 16

这就是我想到的：

var isHTMLElement = (function () {
    if ("HTMLElement" in window) {
        // Voilà. Quick and easy. And reliable.
        return function (el) {return el instanceof HTMLElement;};
    } else if ((document.createElement("a")).constructor) {
        // We can access an element's constructor. So, this is not IE7
        var ElementConstructors = {}, nodeName;
        return function (el) {
            return el && typeof el.nodeName === "string" &&
                 (el instanceof ((nodeName = el.nodeName.toLowerCase()) in ElementConstructors 
                    ? ElementConstructors[nodeName] 
                    : (ElementConstructors[nodeName] = (document.createElement(nodeName)).constructor)))
        }
    } else {
        // Not that reliable, but we don't seem to have another choice. Probably IE7
        return function (el) {
            return typeof el === "object" && el.nodeType === 1 && typeof el.nodeName === "string";
        }
    }
})();

为了提高性能，我创建了一个自调用函数，仅测试浏览器的功能一次，并相应地分配相应的函数。

第一个测试应该适用于大多数现代浏览器，这里已经讨论过。它只是测试元素是否是HTMLElement的实例。非常直截了当。

第二个是最有趣的一个。这是它的核心功能：

return el instanceof (document.createElement(el.nodeName)).constructor

它测试el是否是它假装的构造实例。为此，我们需要访问元素的构造函数。这就是我们在if-Statement中测试它的原因。 IE7例如失败了，因为IE7中的(document.createElement("a")).constructor是undefined。

这种方法的问题是document.createElement实际上不是最快的功能，如果用它测试很多元素，可能很容易减慢你的应用程序。为了解决这个问题，我决定缓存构造函数。对象ElementConstructors将nodeNames作为键，其对应的构造函数作为值。如果构造函数已经被缓存，它将从缓存中使用它，否则它会创建Element，缓存其构造函数以供将来访问，然后对其进行测试。

第三个测试是令人不快的后退。它测试el是object，nodeType属性设置为1，字符串是nodeName。当然这不是很可靠，但到目前为止绝大多数用户都不应该退缩。

这是我提出的最可靠的方法，同时仍然保持尽可能高的性能。

Answer 17

在Firefox中，您可以使用instanceof Node。 Node中定义了{{1}}。

但在IE中这并不容易。

“instanceof ActiveXObject”只能告诉它它是一个本机对象。
“typeof document.body.appendChild =='object'”告诉它可能是DOM对象，但也可以是其他具有相同功能的东西。

您只能通过使用DOM函数确保它是DOM元素，并捕获是否有任何异常。但是，它可能有副作用（例如，更改对象内部状态/性能/内存泄漏）

Answer 18

区分原始js对象和HTMLElement

function isDOM (x){
     return /HTML/.test( {}.toString.call(x) );
 }

使用：

isDOM( {a:1} ) // false
isDOM( document.body ) // true

// OR

Object.defineProperty(Object.prototype, "is",
    {
        value: function (x) {
            return {}.toString.call(this).indexOf(x) >= 0;
        }
    });

使用：

o={}; o.is("HTML") // false o=document.body; o.is("HTML") // true

Answer 19

测试obj是否继承自Node。

if (obj instanceof Node){
    // obj is a DOM Object
}

节点是HTMLElement和Text继承的基本Interface。

Answer 20

我认为原型设计不是一个很好的解决方案，但也许这是最快的解决方案：定义此代码块;

Element.prototype.isDomElement = true;
HTMLElement.prototype.isDomElement = true;

检查你的对象isDomElement属性：

if(a.isDomElement){}

我希望这会有所帮助。

Answer 21

每个 DOMElement.constructor 都会返回函数HTML ... Element（）或 [Object HTML ... Element] 所以......

public class DatabaseAccess {
private SQLiteOpenHelper openHelper;

private SQLiteDatabase database;
private static DatabaseAccess instance;

Answer 22

(element instanceof $ && element.get(0) instanceof Element) || element instanceof Element

这将检查即使它是jQuery或JavaScript DOM元素

Answer 23

这是我的版本。它支持来自 iframe 的元素

/**
 * @param {any} value
 * @param {any} view Optional. If the value is from an iframe, provide the iframe content window here.
 * @returns {boolean}
 */
function isHtmlElement(value, view) {
  if (value instanceof HTMLElement) return true
  if (view && value instanceof view.HTMLElement) return true

  return !!(
    value &&
    typeof value === 'object' &&
    value !== null &&
    value.nodeType === 1 &&
    typeof value.nodeName === 'string'
  )
}

Answer 24

根据mdn

Element是Document中所有对象继承的最通用的基类。它仅具有所有元素共有的方法和属性。

我们可以通过原型实现isElement。这是我的建议：

/**
 * @description detect if obj is an element
 * @param {*} obj
 * @returns {Boolean}
 * @example
 * see below
 */
function isElement(obj) {
  if (typeof obj !== 'object') {
    return false
  }
  let prototypeStr, prototype
  do {
    prototype = Object.getPrototypeOf(obj)
    // to work in iframe
    prototypeStr = Object.prototype.toString.call(prototype)
    // '[object Document]' is used to detect document
    if (
      prototypeStr === '[object Element]' ||
      prototypeStr === '[object Document]'
    ) {
      return true
    }
    obj = prototype
    // null is the terminal of object
  } while (prototype !== null)
  return false
}
console.log(isElement(document)) // true
console.log(isElement(document.documentElement)) // true
console.log(isElement(document.body)) // true
console.log(isElement(document.getElementsByTagName('svg')[0])) // true or false, decided by whether there is svg element
console.log(isElement(document.getElementsByTagName('svg'))) // false
console.log(isElement(document.createDocumentFragment())) // false

Answer 25

要确保实际HTMLEement的唯一方法是检查其是否继承自Node，而不仅仅是检查与HTML Element具有相同属性的对象，因为它不可能在Node中创建新的Node（）。 JavaScript。（除非本机的Node函数被覆盖，但是您不走运）。所以：

function isHTML(obj) {
    return obj instanceof Node;
}

console.log(
  isHTML(test),
  isHTML(ok),
  isHTML(p),
  isHTML(o),
  isHTML({
    constructor: {
      name: "HTML"
    }
  }),
  isHTML({
    __proto__: {
      __proto__: {
        __proto__: {
          __proto__: {
            constructor: {
              constructor: { 
                name: "Function"
                
              },
              name: "Node"
            }
          }
        }
      }
    }
  }),
)

<div id=test></div>
<blockquote id="ok"></blockquote>
<p id=p></p>
<br id=o>
<!--think of anything else you want--!>

Answer 26

如果您使用的是jQuery，请尝试

$('<div>').is('*') // true
$({tagName: 'a'}).is('*') // false
$({}).is('*') // false
$([]).is('*') // false
$(0).is('*') // false
$(NaN).is('*') // false

Answer 27

我有一种特殊的方法可以做到这一点，答案中尚未提及。

我的解决方案基于四项测试。如果对象通过了全部四个，则它是一个元素：

该对象不为空。
该对象有一个名为＆＃34; appendChild＆＃34;的方法。
方法＆＃34; appendChild＆＃34;继承自 Node 类，并且不仅仅是冒名顶替方法（用户创建的具有相同名称的属性）。
该对象属于节点类型1（元素）。从节点类继承方法的对象始终是节点，但不一定是元素。

问：我如何检查某个属性是否被继承并且不仅仅是冒名顶替者？

答：一个简单的测试，看一个方法是否真正从 Node 继承，首先要验证该属性是否具有＆＃34;对象＆＃34;或＆＃34;功能＆＃34;。接下来，将属性转换为字符串，并检查结果是否包含文本＆＃34; [Native Code]＆＃34;。如果结果如下所示：

function appendChild(){
[Native Code]
}

然后该方法已从Node对象继承。见https://davidwalsh.name/detect-native-function

最后，将所有测试结合在一起，解决方案是：

function ObjectIsElement(obj) {
    var IsElem = true;
    if (obj == null) {
        IsElem = false;
    } else if (typeof(obj.appendChild) != "object" && typeof(obj.appendChild) != "function") {
        //IE8 and below returns "object" when getting the type of a function, IE9+ returns "function"
        IsElem = false;
    } else if ((obj.appendChild + '').replace(/[\r\n\t\b\f\v\xC2\xA0\x00-\x1F\x7F-\x9F ]/ig, '').search(/\{\[NativeCode]}$/i) == -1) {
        IsElem = false;
    } else if (obj.nodeType != 1) {
        IsElem = false;
    }
    return IsElem;
}

Answer 28

绝对正确的方法，检查目标是真实 html元素主要代码：

    (function (scope) {
        if (!scope.window) {//May not run in window scope
            return;
        }
        var HTMLElement = window.HTMLElement || window.Element|| function() {};

        var tempDiv = document.createElement("div");
        var isChildOf = function(target, parent) {

            if (!target) {
                return false;
            }
            if (parent == null) {
                parent = document.body;
            }
            if (target === parent) {
                return true;
            }
            var newParent = target.parentNode || target.parentElement;
            if (!newParent) {
                return false;
            }
            return isChildOf(newParent, parent);
        }
        /**
         * The dom helper
         */
        var Dom = {
            /**
             * Detect if target element is child element of parent
             * @param {} target The target html node
             * @param {} parent The the parent to check
             * @returns {} 
             */
            IsChildOf: function (target, parent) {
                return isChildOf(target, parent);
            },
            /**
             * Detect target is html element
             * @param {} target The target to check
             * @returns {} True if target is html node
             */
            IsHtmlElement: function (target) {
                if (!X.Dom.IsHtmlNode(target)) {
                    return false;
                }
                return target.nodeType === 1;
            },
            /**
             * Detect target is html node
             * @param {} target The target to check
             * @returns {} True if target is html node
             */
            IsHtmlNode:function(target) {
                if (target instanceof HTMLElement) {
                    return true;
                }
                if (target != null) {
                    if (isChildOf(target, document.documentElement)) {
                        return true;
                    }
                    try {
                        tempDiv.appendChild(target.cloneNode(false));
                        if (tempDiv.childNodes.length > 0) {
                            tempDiv.innerHTML = "";
                            return true;
                        }
                    } catch (e) {

                    }
                }
                return false;
            }
        };
        X.Dom = Dom;
    })(this);

Answer 29

这适用于几乎所有浏览器。（这里没有元素和节点之间的区别）

function dom_element_check(element){
    if (typeof element.nodeType !== 'undefined'){
        return true;
    }
    return false;
}

Answer 30

除了符合ES5标准的浏览器之外，不要为了这个或任何事情而采取行动，为什么不只是：

function isDOM(e) {
  return (/HTML(?:.*)Element/).test(Object.prototype.toString.call(e).slice(8, -1));
}

无法处理TextNodes并且不确定Shadow DOM或DocumentFragments等，但将几乎适用于所有HTML标记元素。

Answer 31

这是使用jQuery的技巧

var obj = {};
var element = document.getElementById('myId'); // or simply $("#myId")

$(obj).html() == undefined // true
$(element).html() == undefined // false

所以把它放在一个函数中：

function isElement(obj){

   return (typeOf obj === 'object' && !($(obj).html() == undefined));

}

Answer 32

我认为你要做的就是彻底检查一些总是在dom元素中的属性，但是它们的组合不会很可能在另一个对象中，就像这样：

var isDom = function (inp) {
    return inp && inp.tagName && inp.nodeName && inp.ownerDocument && inp.removeAttribute;
};

Answer 33

大多数答案使用某种鸭子类型，例如检查对象是否具有nodeType属性。但这还不够，因为非节点也可以具有类似节点的属性。

另一种常见的方法是instanceof，它会产生误报，例如使用Object.create(Node)，尽管继承了节点属性，但它不是节点。

此外，上述两种方法都称为内部基本方法，这可能是有问题的，例如：如果测试值是代理。

相反，我建议借用一个节点方法并在我们的对象上调用它。浏览器可能会通过查看代理中无法自定义的内部插槽来检查该值是否为节点，因此即使他们也无法干扰我们的检查。

function isNode(value) {
  try {
    Node.prototype.cloneNode.call(value, false);
    return true;
  } catch(err) {
    return false;
  }
}

如果您愿意，也可以使用属性getter。

＆＃13;

function isNode(value) {
  try {
    Object.getOwnPropertyDescriptor(Node.prototype,'nodeType').get.call(value);
    return true;
  } catch(err) {
    return false;
  }
}

＆＃13;

同样，如果要测试值是否为元素，可以使用

function isElement(value) {
  try {
    Element.prototype.getAttribute.call(value, '');
    return true;
  } catch(err) {
    return false;
  }
}

function isHTMLElement(value) {
  try {
    HTMLElement.prototype.click.call(value);
    return true;
  } catch(err) {
    return false;
  }
}

Answer 34

检测元素是否属于HTML DOM的最简单和跨浏览器的方法如下：

function inHTMLDom(myelement){
    if(myelement.ownerDocument.documentElement.tagName.toLowerCase()=="html"){
        return true;
    }else{
        return false;
    }
}

inHTMLDom(<your element>); // <your element>:element you are interested in checking.

在IE6，IE7，IE8，IE9，IE10，FF，Chrome，Safari，Opera中测试过。

Answer 35

var isElement = function(e){
    try{
        // if e is an element attached to the DOM, we trace its lineage and use native functions to confirm its pedigree
        var a = [e], t, s, l = 0, h = document.getElementsByTagName('HEAD')[0], ht = document.getElementsByTagName('HTML')[0];
        while(l!=document.body&&l!=h&&l.parentNode) l = a[a.push(l.parentNode)-1];
        t = a[a.length-1];
        s = document.createElement('SCRIPT');   // safe to place anywhere and it won't show up
        while(a.length>1){  // assume the top node is an element for now...
            var p = a.pop(),n = a[a.length-1];
            p.insertBefore(s,n);
        }
        if(s.parentNode)s.parentNode.removeChild(s);
        if(t!=document.body&&t!=h&&t!=ht)
            // the top node is not attached to the document, so we don't have to worry about it resetting any dynamic media
            // test the top node
            document.createElement('DIV').appendChild(t).parentNode.removeChild(t);
        return e;
    }
    catch(e){}
    return null;
}

我在Firefox，Safari，Chrome，Opera和IE9上测试了这个。我无法找到破解它的方法从理论上讲，它通过在它之前插入一个脚本标记来测试所提出元素的每个祖先以及元素本身。
如果它的第一个祖先追溯到一个已知元素，例如<html>，<head>或<body>，并且它没有引发错误，那么我们就有了一个元素。 /> 如果第一个祖先没有附加到文档，我们创建一个元素并尝试将建议的元素放在其中，（然后将其从新元素中删除）。
因此，它要么追溯到已知元素，成功附加到已知元素，要么失败它返回元素，如果它不是元素，则返回null。

Answer 36

我使用这个功能：

function isHTMLDOMElement(obj) {
  if (Object.prototype.toString.call(obj).slice(-8) === 'Element]') {
    if (Object.prototype.toString.call(obj).slice(0, 12) === '[object HTML') {
      return true;
    }
    return false;
  }
  return false;
}

https://jsfiddle.net/1qazxsw2/wz7e0fvj/9/

JavaScript isDOM - 如何检查JavaScript对象是否是DOM对象？

36 个答案: