[removed] vs <body onload=“”/>

2018-12-31 15:33发布

站内文章 / JavaScript
47 0 0

问题:

What exactly is the difference between the window.onload event and the onload event of the body tag? when do I use which and how should it be done correctly?

回答1:

window.onload = myOnloadFunc and <body onload=\"myOnloadFunc();\"> are different ways of using the same event. Using window.onload is less obtrusive though - it takes your JavaScript out of the HTML.

All of the common JavaScript libraries, Prototype, ExtJS, Dojo, JQuery, YUI, etc. provide nice wrappers around events that occur as the document is loaded. You can listen for the window onLoad event, and react to that, but onLoad is not fired until all resources have been downloaded, so your event handler won\'t be executed until that last huge image has been fetched. In some cases that\'s exactly what you want, in others you might find that listening for when the DOM is ready is more appropriate - this event is similar to onLoad but fires without waiting for images, etc. to download.



回答2:

There is no difference, but you should not use either.

In many browsers, the window.onload event is not triggered until all images have loaded, which is not what you want. Standards based browsers have an event called DOMContentLoaded which fires earlier, but it is not supported by IE (at the time of writing this answer). I\'d recommend using a javascript library which supports a cross browser DOMContentLoaded feature, or finding a well written function you can use. jQuery\'s $(document).ready(), is a good example.



回答3:

window.onload can work without body. Create page with only the script tags and open it in a browser. The page doesn\'t contain any body, but it still works..

<script>
  function testSp()
  {
    alert(\"hit\");
  }
  window.onload=testSp;
</script>


回答4:

I prefer, generally, to not use the <body onload=\"\"> event. I think it\'s cleaner to keep behavior separated from content as much as possible.

That said, there are occasions (usually pretty rare for me) where using body onload can give a slight speed boost.

I like to use Prototype so I generally put something like this in the <head> of my page:

document.observe(\"dom:loaded\", function(){
  alert(\'The DOM is loaded!\');
});

or

Event.observe(window, \'load\', function(){
  alert(\'Window onload\');
});

The above are tricks I learned here. I\'m very fond of the concept of attach event handlers outside of the HTML.

(Edit to correct spelling mistake in code.)



回答5:

\'so many subjective answers to an objective question. \"Unobtrusive\" JavaScript is superstition like the old rule to never use gotos. Write code in a way that helps you reliably accomplish your goal, not according to someone\'s trendy religious beliefs.

Anyone who finds:

 <body onload=\"body_onload();\">

to be overly distracting is overly pretentious and doesn\'t have their priorities straight.

I normally put my JavaScript code in a separate .js file, but I find nothing cumbersome about hooking event handlers in HTML, which is valid HTML by the way.



回答6:

There is no difference ...

So principially you could use both (one at a time !-)

But for the sake of readability and for the cleanliness of the html-code I always prefer the window.onload !o]



回答7:

window.onload - Called after all DOM, JS files, Images, Iframes, Extensions and others completely loaded. This is equal to $(window).load(function() {});

body onload=\"\" - Called once DOM loaded. This is equal to $(document).ready(function() {});



回答8:

If you\'re trying to write unobtrusive JS code (and you should be), then you shouldn\'t use <body onload=\"\">.

It is my understanding that different browsers handle these two slightly differently but they operate similarly. In most browsers, if you define both, one will be ignored.



回答9:

Think of onload like any other attribute. On an input box, for example, you could put:

<input id=\"test1\" value=\"something\"/>

Or you could call:

document.getElementById(\'test1\').value = \"somethingelse\";

The onload attribute works the same way, except that it takes a function as its value instead of a string like the value attribute does. That also explains why you can \"only use one of them\" - calling window.onload reassigns the value of the onload attribute for the body tag.

Also, like others here are saying, usually it is cleaner to keep style and javascript separated from the content of the page, which is why most people advise to use window.onload or like jQuery\'s ready function.



回答10:

<body onload=\"\"> should override window.onload.

With <body onload=\"\">, document.body.onload might be null, undefined or a function depending on the browser (although getAttribute(\"onload\") should be somewhat consistent for getting the body of the anonymous function as a string). With window.onload, when you assign a function to it, window.onload will be a function consistently across browsers. If that matters to you, use window.onload.

window.onload is better for separating the JS from your content anyway. There\'s not much reason to use <body onload=\"\"> anyway when you can use window.onload.

In Opera, the event target for window.onload and <body onload=\"\"> (and even window.addEventListener(\"load\", func, false)) will be the window instead of the document like in Safari and Firefox. But, \'this\' will be the window across browsers.

What this means is that, when it matters, you should wrap the crud and make things consistent or use a library that does it for you.



回答11:

They both work the same. However, note that if both are defined, only one of them will be invoked. I generally avoid using either of them directly. Instead, you can attach an event handler to the load event. This way you can incorporate more easily other JS packages which might also need to attach a callback to the onload event.

Any JS framework will have cross-browser methods for event handlers.



回答12:

It is a accepted standard to have content, layout and behavior separate. So window.onload() will be more suitable to use than <body onload=\"\"> though both do the same work.



回答13:

if you want to manipulate the DOM the definetely use <body onload=\"\">. this way the event will be triggered when the DOM is loaded. Else there is lag between window.onload event and DOM loading so you could wind up manipulating object that doesnot exists. i would suggest using jquery and the $(document).ready(function(){}). This will work for the best



标签： javascript
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~