It appears that your goal is to enhance a website by implementing ajax functionality to retrieve pages without refreshing the entire page. Is it correct that you aim to avoid reloading script tags except when necessary?

If so, one approach could be to collect all existing script tags before adding new HTML content to the DOM:

// Create a cache of loaded URLs.
var loadedScripts = [];

// Upon receiving the AJAX response
function clearLoadedScripts(response){
   var womb = document.createElement('div');
   womb.innerHTML = response;
   var scripts = womb.getElementsByTagName('script');
   var script, i = scripts.length;
   while (i--) {
      script = scripts[i];
      if (loadedScripts.indexOf(script.src) !== -1) {
          script.parentNode.removeChild(script);
      }
      else {
          loadedScripts.push(script.src);
      }
   }

   // Proceed with manipulating the contents, for instance:
   document.body.innerHTML = womb.getElementsByTagName('body')[0].innerHTML);

}

Fortunate for you, I recently completed extensive research for my own project.

1: The recommended hash event / manager to use is Ben Alman's BBQ:

2: To optimize your website for search engines, adhere to these specific guidelines: http://code.google.com/web/ajaxcrawling/docs/specification.html

I discovered this information late in the game and had to overhaul much of my code. It seems like you may have to do the same, but the result will be well worth it.

Best of luck on your project!

Creating a website of this nature is not something I have experience with, so I cannot say definitively if this is the best course of action. However, my suggestion would be to include some form of control information (such as a comment or HTTP header) in the response. This way, the loader script can effectively handle redundancy and dependency checking, as well as adding the necessary script tags to the header.

Are you able to control the content on those pages that are being loaded? If not, I would suggest embedding the loaded page in an IFrame.

Removing page scripts from their original context and placing them in the header or adding them to a different HTML element could potentially cause issues unless you are familiar with how the page is structured.

If you have complete control over the pages being loaded, it might be beneficial to convert all your HTML to JavaScript. While it may seem unconventional, there are tools available like the Pure JavaScript HTML Parser that can assist in translating HTML to JS code, allowing for DOM manipulation using libraries such as JQuery.

I was considering taking this approach myself for a web application I was working on some time ago. However, I ultimately decided to hand it off to a contractor who converted my pure JS pages into HTML+JQuery. In the end, what matters most is efficiency in daily work tasks, but the idea of a pure JS web app is something I am still interested in exploring in the future.

It appears to me that you are embarking on the creation of a single-page application right from the onset, without any plans to refactor an existing website.

Here are a few strategies that come to mind:

1. Allow the server to determine which script tags should be included. Send a list of script tags that have already been loaded along with the XHR request and let the server decide which additional scripts need to be loaded.
2. Preload all scripts (maybe add them to the DOM after the page has loaded for efficiency) and then don't worry about it. For scripts that require UI initialization, simply have each requested page include a script tag calling a global init function with the page name.
3. Each requested page could invoke a JavaScript function responsible for loading/caching scripts. This function, accessible globally, could be structured as follows:

   require_scripts('page_1_init', 'form_code', 'login_code')

   . The function would maintain a list of loaded scripts and only append DOM script tags for those not yet loaded.

If you're looking to streamline your website's loading process, consider utilizing a script loader such as YUI Loader, LAB.js, or another option like jaf.

Jaf offers a convenient way to load views (HTML snippets) along with their associated JavaScript and CSS files in order to create single page applications. Be sure to explore the example todo list application provided by Jaf. While it may not be fully finished, there are plenty of valuable libraries available for use.

In my opinion, sending JSON data instead of raw HTML is a better approach:

{
    "title": "Services",
    "required": ["sidebar", "contacts"],
    "details": "<div id=…"
}

By transmitting JSON, you can include additional information like an array of necessary scripts along with the content. This allows for efficient loading of only the required scripts using a script loader before rendering the page.

Instead of embedding scripts within the HTML for specific functionalities, it is advisable to utilize pre-defined classes, ids, and attributes on elements that require special treatment. You can trigger an "onrender" event or have individual logic pieces register an on-render callback that will be executed by the page loader after the initial rendering or loading of the page.