JavaScript 객체가 DOM 객체인지 어떻게 확인합니까?

나는 노력하고있다 :

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

좋은 대체물이 있습니까?

이것은 관심이있을 수 있습니다 :

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 : 이것은 내 라이브러리에서 구현 한 방법입니다. (노드와 HTMLElement가 예상 객체 대신 함수이기 때문에 이전 코드는 Chrome에서 작동하지 않았습니다.이 코드는 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"
);
}

다음 IE8 호환 초간단 코드는 완벽하게 작동합니다.

허용 대답은 HTML 요소의 모든 유형을 감지하지 않습니다. 예를 들어 SVG 요소는 지원되지 않습니다. 대조적으로,이 답변은 SVG뿐만 아니라 HTML에도 효과적입니다.

https://jsfiddle.net/eLuhbu6r/ 에서 실제 작업을 확인하십시오.

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

위와 아래의 모든 솔루션 (내 솔루션 포함)은 특히 IE에서 부정확 할 가능성이 있습니다. 테스트를 무효화하는 DOM 노드를 모방하기 위해 일부 객체 / 메소드 / 속성을 재정의하는 것이 가능합니다.

일반적으로 오리 타이핑 스타일 테스트를 사용합니다. 사용하는 것을 구체적으로 테스트합니다. 예를 들어 노드를 복제하려면 다음과 같이 테스트하십시오.

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각각을 반환해야합니다 . 메소드를 테스트하는 유일한 방법은 메소드가 정의되어 있는지 확인하는 것입니다.

실제 DOM 노드에 추가 할 수 있습니다 ...

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

    return true;
}

해킹이 필요하지 않습니다. 요소가 DOM 요소 의 인스턴스인지 물어볼 수 있습니다 .

const isDOM = el => el instanceof Element

방법에 대한 소호 - 대시의_.isElement ?

$ npm install lodash.iselement

그리고 코드에서 :

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

이것은 멋진 JavaScript 라이브러리 MooTools 에서 가져온 것입니다 .

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

여기에 있는 근 탐지 기능을 사용하여 예를 들어 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 솔루션보다 저렴합니다.

돈 피

오래된 스레드이지만 다음은 ie8 및 ff3.5 사용자에게 업데이트 된 가능성입니다 .

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

변수가 DOM 요소인지 테스트하는 간단한 방법을 제안합니다

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

또는 HTMLGuy가 제안한대로 :

const isDomEntity = entity => {
  return typeof entity   === 'object' && entity.nodeType !== undefined
}

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

// 사실이 인라인을 사용하지 않을 가능성이 높지만 설치 코드에 대한 단축키를 사용하는 것이 좋습니다

도움이 될 수 있습니다 : 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);
}

위의 코드에서, 우리는 사용하는 이중 부정 의 활용 인수로 전달 된 객체의 부울 값을 얻기 위해 운영자, 우리는 조건문에서 평가 각 표현식은 부울 수 있도록 이러한 방법으로, 단락 회로 평가 하여, 기능을 반품 true또는false

해당 객체 또는 노드가 문자열 유형을 반환하는지 확인할 수 있습니다.

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

Angular를 사용하는 사람들의 경우 :

angular.isElement

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

프로토 타이핑은 그다지 좋은 해결책은 아니지만 아마도 가장 빠른 해결책이라고 생각합니다.이 코드 블록을 정의하십시오.

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

객체 isDomElement 속성을 확인하는 것보다 :

if(a.isDomElement){}

이게 도움이 되길 바란다.

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

나는 당신이해야 할 일은 항상 dom 요소에있을 일부 속성을 철저히 확인하는 것이지만 그 조합은 다른 객체에 있을 가능성 이 거의 없습니다 .

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

Firefox에서는을 사용할 수 있습니다 instanceof Node. 이는 DOM1에Node 정의되어 있습니다.

그러나 IE에서는 그렇게 쉽지 않습니다.

1. "ActiveX의 인스턴스"는 그것이 기본 객체임을 알 수 있습니다.
2. "typeof document.body.appendChild == 'object'"는 DOM 객체 일 수도 있지만 동일한 기능을 가진 다른 객체 일 수도 있습니다.

DOM 함수를 사용하여 DOM 요소인지 확인하고 예외가 있으면 catch 할 수 있습니다. 그러나 부작용이있을 수 있습니다 (예 : 객체 내부 상태 / 성능 / 메모리 누수 변경)

아마도 이것이 대안입니까? Opera 11, FireFox 6, Internet Explorer 8, Safari 5 및 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

이것이 내가 알아 낸 것입니다.

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 문에서 이것을 테스트하는 이유입니다. 예를 들어 IE7에 있기 때문에 IE7 (document.createElement("a")).constructor은 이것을 실패합니다 undefined.

이 방법의 문제점 document.createElement은 실제로 가장 빠른 기능이 아니며 많은 요소를 테스트하는 경우 응용 프로그램 속도를 쉽게 늦출 수 있다는 것입니다. 이를 해결하기 위해 생성자를 캐시하기로 결정했습니다. 객체 ElementConstructors는 nodeNames를 키로 사용하고 해당 생성자를 값으로 사용합니다. 생성자가 이미 캐시 된 경우 캐시에서 생성자를 사용합니다. 그렇지 않으면 요소를 작성하고 나중에 액세스 할 수 있도록 생성자를 캐시 한 다음 이에 대해 테스트합니다.

세 번째 테스트는 불쾌한 폴백입니다. el이 object이고 nodeType속성이로 설정되어 1있고 문자열이로 설정되어 있는지 테스트합니다 nodeName. 물론 이것은 신뢰할 만하지는 않지만 대다수의 사용자는 지금까지 다시 넘어서는 안됩니다.

이것은 가능한 한 성능을 계속 유지하면서 내가 찾은 가장 신뢰할만한 접근법입니다.

Nodeobj 에서 상속 되는지 테스트하십시오 .

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

노드는 HTMLElement와 Text를 상속 하는 기본 인터페이스 입니다.

원시 js 객체를 HTMLElement와 차별화

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

사용하다:

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

// 또는

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

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

}

ES5 호환 브라우저 외에 다른 것들을 망치지 말고 다음과 같은 이유는 무엇입니까?

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

TextNodes에서 작동하지 확인 등 그림자 DOM 또는 DocumentFragments 약하지만하지 않음 것이다 거의 모든 HTML 태그 요소에 작동합니다.

이것은 거의 모든 브라우저에서 작동합니다. (여기서 요소와 노드를 구별하지 않음)

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

절대적으로 올바른 방법, 검사 대상은 실제 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);

각 DOMElement.constructor 는 HTML ... Element () 또는 [Object HTML ... Element] 함수를 반환 합니다 .

function isDOM(getElem){
    if(getElem===null||typeof getElem==="undefined") return false;
    var c = getElem.constructor.toString();
    var html = c.search("HTML")!==-1;
    var element = c.search("Element")!==-1;
    return html&&element;
}

답변에 아직 언급되지 않은 특별한 방법이 있습니다.

내 솔루션은 네 가지 테스트를 기반으로합니다. 객체가 네 개를 모두 통과하면 요소입니다.

1. 객체가 null이 아니다

2. 이 개체에는 "appendChild"라는 메서드가 있습니다.

3. "appendChild"메소드는 Node 클래스 에서 상속되었으며 단순한 임 포스터 메소드 (같은 이름의 사용자 작성 특성)가 아닙니다.

4. 오브젝트는 노드 유형 1 (요소)입니다. Node 클래스 에서 메소드를 상속받는 객체 는 항상 노드이지만 반드시 요소는 아닙니다.

Q : 주어진 속성이 상속되고 단순한 사기가 아닌지 어떻게 확인합니까?

A : 메소드가 Node 에서 실제로 상속 되었는지 확인 하는 간단한 테스트 는 먼저 속성에 "object"또는 "function"유형이 있는지 확인하는 것입니다. 그런 다음 속성을 문자열로 변환하고 결과에 "[Native Code]"텍스트가 포함되어 있는지 확인하십시오. 결과가 다음과 같은 경우 :

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

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

jQuery 또는 JavaScript DOM 요소 인 경우에도 확인합니다.

HTML 요소와 동일한 속성을 가진 객체뿐만 아니라 실제 HTMLEement를 확인하는 유일한 방법은 JavaScript에서 새 Node ()를 만들 수 없기 때문에 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--!>