text: Q:
  
  Force javascript onload handler to the back of the queue
  
  I want to add a javascript file to very end of footer.php with an wordpress plugin. i tried it using 'add_action' Hook. But this hook is adding javascript nearby </body> tag.
  add_action('wp_footer', 'my_fucntion()');
  
  How can i push my javascript to very end of footer.php 
  
  A:
  
  Update
  There's a better way, the one below should work, but this one should be safer, still (and it's easier, IMO).
  Given that JS is single-threaded, an event will push the handler to the back of the queue anyway, so if your onload handler ends up being called prior to another handler, dispatching a new event, that calls a handler that actually does the work you want/need to do is probably your best bet:
  window.addEventListener('load', function rmMe()
  {
      var handler = function()
      {
          window.removeEventListener('click', handler, false);//remove this listener, too
          var i, links = document.querySelectorAll('a');
          for (i=0;i<links.length;++i)
          {
              //do stuff with links
          }
      };
      window.removeEventListener('load', rmMe, false);
      window.addEventListener('click', handler, false);//bind new listener
      window.dispatchEvent(new Event('click'));//calls handler, last handler in queue
  },false);
  
  That might be your best bet...
  
  After those endless comments, it would apear that you're looking for a way to guarantee that your JS gets executed after the page has loaded, and all other possible onload event handlers have been called.
  The simple answer is: you can't. Not really. JS's event loop is beyond your control, but there are a few tricks that do work in most cases:
  
  Add your script to the bottom of the body tag
  Bind your event listener but wrap it in a setTimeout with zero or 1 ms delay
  to be safe, let the event handler set another timeout that actually calls the function that does the work, this time, use a timeout that allows for a queued handler to be called. This is optional, because the queue is probably empty already
  important make sure (or hope) that other handlers don't call stopPropagation on the event: this'll result in your listener not getting called. That's why the first method is preferable: it pushes a new handler to the back of the queue, allowing you to bind your listener first.
  
  Code example:
  setTimeout(function()
  {
      window.onload = function()
      {
          var handler = function()
          {
              var i, links = document.querySelectorAll('a');
              for (i=0;i<links.length;++i)
              {
                  //do stuff with links
              }
          };
          return function()
          {//fake, initial handler
              setTimeout(handler, 40);//optional, return handler; should suffice
          };
      };
  },1);
  
  That's all there is too it. This code, to be clear, goes here in the DOM:
          <script>
              //code here
          </script>
      </body>
  </html>
  
  This is not 100% reliable, but most browsers queue event handlers as they are being bound:
  window.addEventListener('load', function(){}, false);//likely to be called first
  window.addEventListener('load', function(){}, false);//likely to be called second
  
  and so on. Not sure about this, but I wouldn't be surprised if listeners that are bound using the window.addEventListener are more likely to be appended to the end of the queue, as the addEventListener call may cause overhead. Probably use:
  setTimeout(function()
  {
      window.addEventListener('load', function tmpLoad()
      {
          var handler = function()
          {
              var i, links = document.querySelectorAll('a');
              for (i=0;i<links.length;++i)
              {
                  //do stuff with links
              }
          };
          return function()
          {//fake, initial handler
              window.removeEventListener('load', tmpLoad, false);//adds overhead and time
              setTimeout(handler, 40);//optional, return handler; should suffice
          };
      },false);
  },1);
  
  You could also consider manually dispatching an event, after a timeout, bind a new listener, and then do: window.dispatchEvent(new Event('load')); to call the handler.
  
  