document.defaultView有什么意义？

Question

What's the point of document.defaultView ?

MDN says :

In browsers returns the window object associated with the document or null if none available.

Code like the following (from PPK's site ) makes use of document.defaultView :

function getStyle(el,styleProp)
{
    var x = document.getElementById(el);
    if (x.currentStyle)
        var y = x.currentStyle[styleProp];
    else if (window.getComputedStyle)
        var y = document.defaultView.getComputedStyle(x,null).getPropertyValue(styleProp);
    return y;
}

Code like this can be found in other places, like David Mark's My Library . I'm not sure if people are just copying from PPK or some other source or coming up with this independently, but I don't understand it.

My question is, what is the point of using document.defaultView in cases like this? Wouldn't it be easier to write this as follows:

function getStyle(element, styleProp) {
    if (element === ''+element) element = document.getElementById(element);
    return element.currentStyle ? element.currentStyle[styleProp] :
           getComputedStyle(x,null).getPropertyValue(styleProp);
}

What does document.defaultView.getComputedStyle do that window.getComputedStyle or simply getComputedStyle does not?

---

cwolves' answer got me thinking in the right direction. The original function is silly, missing the point of defaultView . My proposal above is less silly, but also missing the point of defaultView . Here's my new proposal:

function getStyle(element, styleProp) {
    var view = element.ownerDocument && element.ownerDocument.defaultView ?
                element.ownerDocument.defaultView : window;

    return view.getComputedStyle ? 
                view.getComputedStyle(element,null).getPropertyValue(styleProp) : 
            element.currentStyle ? 
                element.currentStyle[styleProp] : null;
}

The element itself must be passed in, not the id. I think this is probably to be preferred anyway. This gets the document containing the node, and the window associated with it. It has a fallback to the current window's getComputedStyle if ownerDocument or defaultView are broken (I vaguely remember getComputedStyle being around before defaultView ). This is probably closer to the intended use of defaultView .

Answer 1

I'm not positive on this, but I imagine that it's the result of fixing a bug from either trying to run code on a detached document (ie something that exists in memory but is not in the page) or trying to run on a document in a different window (eg an iframe or a popup).

According to your quote, when document.defaultView is run on a document that is NOT the current document, you will get the associated window object, thus document.documentView.getComputedStyle !== getComputedStyle since they are in different contexts.

In short, I believe it's akin to document.window which doesn't exist.

Answer 2

The OP asks the question, "What's the point of document.defaultView ", and the answer really doesn't have anything to do with getComputedStyle. The document.defaultView property is simply a way of obtaining the window object if one has a reference to the document object contained in that window . There are cases where the window object you are seeking to reference (or defaultView ) is not in the same window scope as the code you are running.

One example of this is if you have a reference to the document object in an iframe, and wish to conveniently get a reference to the window object of that iframe.

Another case might be where you are running in privileged context in the browser scope (eg, chrome code in Firefox), and you happen to have a reference to the document object of a tabbrowser, or another window.

Or, as Dagg Nabbit points out, if in any of these cases you have a reference to an element within the window, you could access the parent window of that element through element.ownerDocument.defaultView

Answer 3

It is simply an abstraction as far as I can tell, just in case any user agents pop up with a DOM implementation, but don't provide a view in the form of a window. See Views in DOM level 2.

Answer 4

According to MDN getComputedStyle article ,

In many code samples online, getComputedStyle is used from the document.defaultView object.

In nearly all cases, this is needless, as getComputedStyle exists on the window object as well.

It's likely the defaultView pattern was some combination of

1. folks not wanting to write a spec for window and
2. making an API that was also usable in Java.

However, there is a single case where the defaultView 's method must be used: when using Firefox 3.6 to access framed styles.