The accepted answer is NOT correct.

Loading a file synchronously is not the same as executing the file synchronously - which is what the OP requested.

The accepted answer loads the file sync, but does nothing more than append a script tag to the DOM. Just because appendChild() has returned does not in anyway guarantee that the script has finished executing and it's members are initialised for use.

The only (see caveat) way to achieve the OPs question is to sync load the script over XHR as stated, then read as text and pass into either eval() or a new Function() call and wait for that function to return. This is the only way to guarantee the script is loaded AND executed synchronously.

I make no comment as to whether this is a wise thing to do either from a UI or security perspective, but there are certainly use cases that justify a sync load & execute.

Caveat:
Unless you're using web workers in which case just call loadScripts();

This is the code that I'm using for multiple file load in my app.

Utilities.require = function (file, callback) {

    callback = callback ||

    function () {};

    var filenode;

    var jsfile_extension = /(.js)$/i;

    var cssfile_extension = /(.css)$/i;



    if (jsfile_extension.test(file)) {

        filenode = document.createElement('script');

        filenode.src = file;

        // IE

        filenode.onreadystatechange = function () {

            if (filenode.readyState === 'loaded' || filenode.readyState === 'complete') {

                filenode.onreadystatechange = null;

                callback();

            }

        };

        // others

        filenode.onload = function () {

            callback();

        };

        document.head.appendChild(filenode);

    } else if (cssfile_extension.test(file)) {

        filenode = document.createElement('link');

        filenode.rel = 'stylesheet';

        filenode.type = 'text/css';

        filenode.href = file;

        document.head.appendChild(filenode);

        callback();

    } else {

        console.log("Unknown file type to load.")

    }

};



Utilities.requireFiles = function () {

    var index = 0;

    return function (files, callback) {

        index += 1;

        Utilities.require(files[index - 1], callBackCounter);



        function callBackCounter() {

            if (index === files.length) {

                index = 0;

                callback();

            } else {

                Utilities.requireFiles(files, callback);

            }

        };

    };

}();

And this utilities can be used by

Utilities.requireFiles(["url1", "url2",....], function(){

    //Call the init function in the loaded file.

    })

The most Node.js-like implementation I could come up with was able to load JS files synchonously, and use them as objects/modules

var scriptCache = ;

var paths = ;

function Import(path)

{

    var index = 0;

    if((index = paths.indexOf(path)) != -1) //If we already imported this module

    {

        return scriptCache [index];

    }



    var request, script, source;

    var fullPath = window.location.protocol + '//' + window.location.host + '/' + path;



    request = new XMLHttpRequest();

    request.open('GET', fullPath, false);

    request.send();



    source = request.responseText;



    var module = (function concealedEval() {

        eval(source);

        return exports;

    })();



    scriptCache.push(module);

    paths.push(path);



    return module;

}

An example source (addobjects.js):

function AddTwoObjects(a, b)

{

    return a + b;

}



this.exports = AddTwoObjects;

And use it like this:

var AddTwoObjects = Import('addobjects.js');

alert(AddTwoObjects(3, 4)); //7

//or even like this:

alert(Import('addobjects.js')(3, 4)); //7

I had the following problem(s) with the existing answers to this question (and variations of this question on other stackoverflow threads):

• None of the loaded code was debuggable


• Many of the solutions required callbacks to know when loading was finished instead of truly blocking, meaning I would get execution errors from immediately calling loaded (ie loading) code.

Or, slightly more accurately:

• None of the loaded code was debuggable (except from the HTML script tag block, if and only if the solution added a script elements to the dom, and never ever as individual viewable scripts.) => Given how many scripts I have to load (and debug), this was unacceptable.


• Solutions using 'onreadystatechange' or 'onload' events failed to block, which was a big problem since the code originally loaded dynamic scripts synchronously using 'require([filename, 'dojo/domReady']);' and I was stripping out dojo.

My final solution, which loads the script before returning, AND has all scripts properly accessible in the debugger (for Chrome at least) is as follows:

WARNING: The following code should PROBABLY be used only in 'development' mode. (For 'release' mode I recommend prepackaging and minification WITHOUT dynamic script loading, or at least without eval).

//Code User TODO: you must create and set your own 'noEval' variable



require = function require(inFileName)

{

    var aRequest

        ,aScript

        ,aScriptSource

        ;



    //setup the full relative filename

    inFileName = 

        window.location.protocol + '//'

        + window.location.host + '/'

        + inFileName;



    //synchronously get the code

    aRequest = new XMLHttpRequest();

    aRequest.open('GET', inFileName, false);

    aRequest.send();



    //set the returned script text while adding special comment to auto include in debugger source listing:

    aScriptSource = aRequest.responseText + 'n////# sourceURL=' + inFileName + 'n';



    if(noEval)//<== **TODO: Provide + set condition variable yourself!!!!**

    {

        //create a dom element to hold the code

        aScript = document.createElement('script');

        aScript.type = 'text/javascript';



        //set the script tag text, including the debugger id at the end!!

        aScript.text = aScriptSource;



        //append the code to the dom

        document.getElementsByTagName('body')[0].appendChild(aScript);

    }

    else

    {

        eval(aScriptSource);

    }

};

var xhrObj = new XMLHttpRequest();

xhrObj.open('GET', '/filename.js', false);

xhrObj.send(null);

eval(xhrObj.responseText);

If this is a cross-domain request, it will not work. In that case you have to upload the requested file to your server, or make a mirror php that outputs it, and require that php.

With jquery (works with cross-domain request too):

$.getScript('/filename.js',callbackFunction);

callbackFunction will be called synchronously.

For loading more scripts see this thread.

If you need to load an arbitrary number of scripts and only proceed when the last one is done, and you cannot use XHR (e.g. due to CORS limitations) you can do the following. It is not synchronous, but does allow a callback to occur exactly when the last file is done loading:

// Load <script> elements for all uris

// Invoke the whenDone callback function after the last URI has loaded

function loadScripts(uris,whenDone){

  if (!uris.length) whenDone && whenDone();

  else{

    for (var wait=,i=uris.length;i--;){

      var tag  = document.createElement('script');

      tag.type = 'text/javascript';

      tag.src  = uris[i];

      if (whenDone){

        wait.push(tag)

        tag.onload = maybeDone; 

        tag.onreadystatechange = maybeDone; // For IE8-

      }

      document.body.appendChild(tag);

    }

  }

  function maybeDone(){

    if (this.readyState===undefined || this.readyState==='complete'){

      // Pull the tags out based on the actual element in case IE ever

      // intermingles the onload and onreadystatechange handlers for the same

      // script block before notifying for another one.

      for (var i=wait.length;i--;) if (wait[i]==this) wait.splice(i,1);

      if (!wait.length) whenDone();

    }

  }

}

Edit: Updated to work with IE7, IE8, and IE9 (in quirks mode). These IE versions do not fire an onload event, but do for onreadystatechange. IE9 in standards mode fires both (with onreadystatechange for all scripts firing before onload for any).

Based on this page there may be a small chance that old versions of IE will never send an onreadystatechange event with readyState=='complete'; if this is the case (I could not reproduce this problem) then the above script will fail and your callback will never be invoked.

You can't and shouldn't perform server operations synchronously for obvious reasons. What you can do, though, is to have an event handler telling you when the script is loaded:

tag.onreadystatechange = function() { if (this.readyState == 'complete' || this.readyState == 'loaded') this.onload({ target: this }); };



tag.onload = function(load) {/*init code here*/}

onreadystatechange delegation is, from memory, a workaround for IE, which has patchy support for onload.

same as Sean's answer, but instead of creating a script tag, just evaluate it. this ensures that the code is actually ready to use.

My strategy, classic example when load jQuery UI, i hope this can help you

( function( tools, libs ){

	

    // Iterator

    var require = function( scripts, onEnd ){

        

        onEnd = onEnd || function(){};

        

        if( !scripts || scripts.length < 1 )return onEnd();

        

        var src    = scripts.splice( 0, 1),

            script = document.createElement( "script" );

        

        script.setAttribute( "src", src );

        

        tools.addEvent( "load", script, function(){

            

            require( scripts, onEnd );

            

        } );

        

        document.getElementsByTagName( "head" )[ 0 ].appendChild( script );

        

    };

    

    // Install all scripts with a copy of scripts

    require( libs.slice(), function(){

    

        alert( "Enjoy :)" );

    

    } );

    

    // Timeout information

    var ti = setTimeout( function(){

        

        if( !window.jQuery || !window.jQuery.ui )alert( "Timeout !" );

        

        clearTimeout( ti );

        

    }, 5000 );



} )(



    { // Tools

    

        addEvent : function( evnt, elem, func ){

        

            try{



                if( elem.addEventListener ){



                    elem.addEventListener( evnt, func, false );



                }else if( elem.attachEvent ){



                     var r = elem.attachEvent( "on" + evnt, func );



                }



                return true;



            }catch( e ){



                return false;



            }		    



        }

    

    },

    [ // Scripts

    

        "https://cdnjs.cloudflare.com/ajax/libs/jquery/3.0.0-alpha1/jquery.min.js",

        "https://cdnjs.cloudflare.com/ajax/libs/jqueryui/1.11.4/jquery-ui.min.js"

        

    ]



);

When using Angular you can take advantage of the fact that every Provider is instantiated before other services are instantiated. You can combine this fact with using xhr and the eval() as mentioned by @Neil. The code would be following:

app.provider('SomeScriptSyncLoader', function() {



    var resourceUrl =  'http://some/script.js';

    var dummy = {};



    this.$get = function() {



        var q = jQuery.ajax({

            type: 'GET', url: resourceUrl, cache: false, async: false

        });



        if (q.status === 200) {

            eval(q.responseText); // execute some script synchronously as inline script - eval forces sync processing

        }

        return dummy;

    };

});

To force the Provider to be inialized you need to inject it in at least one other directive/service. Preferably this would be the service which takes advantage of the code loaded by script.

app.directive('myDirective', ['SomeScriptSyncLoader', function(someScriptSyncLoader) {



return {

    restrict: 'E',

    link: function(scope, element, attrs) {

        // some ode

    },

    template: "this is my template"

   };

}]);

I know this is an old question, but maybe someone else read this and find it useful !
Just created a new components uses ES6 to load scripts dynamically in synchronous way.
The Project details and source code are on GitHub https://github.com/amgadfahmi/scripty

I may be late to answering this question.

My current solution is to recursively add <script> tags such that the addition of the subsequent script is in the callback of its predecessor. It assumes that each function contains one function and that function is the same as the file name (minus the extension). This probably isn't the best way to do things, but it works ok.

Code to consider

Code directory structure:

- directory

---- index.html

---- bundle.js

---- test_module/

-------- a.js

-------- b.js

-------- log_num.js

-------- many_parameters.js

index.html

<head>

  <script src="bundle.js"></script>

</head>

bundle.js

// Give JS arrays the .empty() function prototype

if (!Array.prototype.empty){

    Array.prototype.empty = function(){

        return this.length == 0;

    };

};



function bundle(module_object, list_of_files, directory="") {

  if (!list_of_files.empty()) {

    var current_file = list_of_files.pop()

    var [function_name, extension] = current_file.split(".")

    var new_script = document.createElement("script")

    document.head.appendChild(new_script)



    new_script.src = directory + current_file



    new_script.onload = function() {

      module_object[function_name] = eval(function_name)

      bundle(module_object, list_of_files, directory)

      /*

      nullify the function in the global namespace as - assumed -  last

      reference to this function garbage collection will remove it. Thus modules

      assembled by this function - bundle(obj, files, dir) - must be called

      FIRST, else one risks overwritting a funciton in the global namespace and

      then deleting it

      */

      eval(function_name + "= undefined")

    }

  }

}



var test_module = {}

bundle(test_module, ["a.js", "b.js", "log_num.js", "many_parameters.js"], "test_module/")

a.js

function a() {

  console.log("a")

}

b.js

function b() {

  console.log("b")

}

log_num.js

// it works with parameters too

function log_num(num) {

  console.log(num)

}

many_parameters.js

function many_parameters(a, b, c) {

  var calc = a - b * c

  console.log(calc)

}

There actually is a way to load a list of scripts and execute them synchronously. You need to insert each script tag into the DOM, explicitly setting its async attribute to false:

script.async = false;

Scripts that have been injected into the DOM are executed asynchronously by default, so you have to set the async attribute to false manually to work around this.

Example

<script>

(function() {

  var scriptNames = [

    "https://code.jquery.com/jquery.min.js",

    "example.js"

  ];

  for (var i = 0; i < scriptNames.length; i++) {

    var script = document.createElement('script');

    script.src = scriptNames[i];

    script.async = false; // This is required for synchronous execution

    document.head.appendChild(script);

  }

  // jquery.min.js and example.js will be run in order and synchronously

})();

</script>



<!-- Gotcha: these two script tags may still be run before `jquery.min.js`

     and `example.js` -->

<script src="example2.js"></script>

<script>/* ... */<script>

References

• There is a great article by Jake Archibald of Google about this called Deep dive into the murky waters of script loading.


• The WHATWG spec on the tag is a good and thorough description of how tags are loaded.

the accepted answer is not correct:

the script.async = false; directive only means that html parsing will be paused during script execution. this does not guarantee in which order javascript code will run. see https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/loading-third-party-javascript/

the easiest and most elegant solution which was yet to be mentioned here is using promises, like so:

    function loadScript(url) {

      return new Promise((resolve, reject) => {

        var script = document.createElement('script')

        script.src = url

        script.onload = () => {

          resolve()

        }

        script.onerror = () => {

          reject('cannot load script '+ url)

        }

        document.body.appendChild(script)

      })

    }

and then when you want to execute scripts in order:

        loadScript('myfirstscript.js').then(() => {

          console.log('first script ran');

          loadScript('index.js').then(() => {

            console.log('second script ran');

          })

        })

I use jquery load method applied to div element. something like

<div id="js">

<!-- script will be inserted here --> 

</div>



...



$("#js").load("path", function() {  alert("callback!" });

You can load scripts several times and each time one script will completely replace the one loaded earlier