如何在另一个JavaScript文件中包含JavaScript文件？_Javascript_File_Import_Include

如何在另一个JavaScript文件中包含JavaScript文件？

javascript file import

如何在另一个JavaScript文件中包含JavaScript文件？,javascript,file,import,include,Javascript,File,Import,Include,JavaScript中是否有类似于CSS中的@import的内容，允许您在另一个JavaScript文件中包含JavaScript文件？可以动态生成JavaScript标记，并从其他JavaScript代码中将其附加到HTML文档中。这将加载目标JavaScript文件 function includeJs(jsFilePath) { var js = document.createElement("script"); js.type = "text/javascript";

JavaScript中是否有类似于CSS中的@import的内容，允许您在另一个JavaScript文件中包含JavaScript文件？

可以动态生成JavaScript标记，并从其他JavaScript代码中将其附加到HTML文档中。这将加载目标JavaScript文件

function includeJs(jsFilePath) {
    var js = document.createElement("script");

    js.type = "text/javascript";
    js.src = jsFilePath;

    document.body.appendChild(js);
}

includeJs("/path/to/some/file.js");

也许你可以使用我在本页找到的这个函数：

JavaScript的旧版本没有导入、包含或要求，因此开发了许多不同的方法来解决这个问题

但自2015年ES6以来，JavaScript已经有了在Node.js中导入模块的标准，这也是受支持的

为了与旧浏览器兼容，可以使用和/或透明工具等构建工具

ES6模块 ECMAScript ES6模块从v8.5开始使用，带有-experimental modules标志，并且从Node.js v13.8.0开始至少没有该标志。要启用ESM vs.Node.js以前的CommonJS样式模块系统[CJS]，可以在package.json中使用type:module，或者为文件提供扩展名.mjs。类似地，如果默认为ESM，则使用Node.js以前的CJS模块编写的模块可以命名为.CJS

使用package.json：

{ 类型：模块 } 然后module.js：

导出函数你好{ 回复你好； } 然后main.js：

<html>
    <body onload="bodyReady();" >

        <script src="myvariables.js" > </script>
        <script src="main.js" > </script>

        <!-- Some other code -->
    </body>
</html>

使用.mjs，您将拥有module.mjs：

然后main.mjs：

浏览器中的ECMAScript模块浏览器支持直接加载ECMAScript模块，没有像Webpack required Safari 10.1、Chrome 61、Firefox 60和Edge 16这样的工具。在上检查当前支持。不需要使用Node.js'.mjs扩展名；浏览器完全忽略模块/脚本上的文件扩展名

从“./hello.mjs”导入{hello}；//也可以是简单的“hello.js”` “世界”你好； //hello.mjs-也可以是简单的“hello.js”` 导出函数hellotext{ const div=document.createElement'div'； div.textContent=`Hello${text}`； document.body.appendChilddiv； } 阅读更多

浏览器中的动态导入动态导入允许脚本根据需要加载其他脚本：

导入'hello.mjs'。然后模块=>{ 你好，世界； }; 阅读更多

Node.js需要在Node.js中仍然广泛使用的较旧的CJS模块样式是系统

//mymodule.js module.exports={ 您好：功能{ 回复你好； } } //server.js const myModule=require'/myModule'；让val=myModule.hello；//瓦尔你好 JavaScript还有其他方法可以在不需要预处理的浏览器中包含外部JavaScript内容

AJAX加载您可以通过AJAX调用加载其他脚本，然后使用eval运行它。这是最简单的方法，但由于JavaScript沙盒安全模型，它仅限于您的域。使用eval还打开了漏洞、黑客和安全问题的大门

提取装载与动态导入一样，您可以通过使用承诺的获取调用加载一个或多个脚本，以使用库控制脚本依赖项的执行顺序：

jQuery加载该库提供加载功能：

$.getScriptmy_lovely_script.js，函数{ alertScript已加载，但不一定执行。； }; 动态脚本加载您可以将带有脚本URL的脚本标记添加到HTML中。为了避免jQuery的开销，这是一个理想的解决方案

脚本甚至可以驻留在不同的服务器上。此外，浏览器还会评估代码。可以将标记插入网页，也可以在结束标记之前插入

下面是一个如何工作的示例：

函数dynamicallyadscripturl{ var script=document.createElementscript；//创建脚本DOM节点 script.src=url；//将其src设置为提供的url document.head.appendChildscript；//将其添加到页面的head部分末尾可能会将“head”更改为“body”，以将其添加到body部分末尾 } 此函数将在页面的head部分的末尾添加一个新标记，其中src属性设置为作为第一个参数提供给函数的URL

中讨论并说明了这两种解决方案

检测脚本何时执行现在，有一个大问题你必须知道。这样做意味着您可以远程加载代码。现代web浏览器将加载文件并继续执行当前脚本，因为它们异步加载所有内容以提高性能。这适用于jQuery方法和手动动态脚本加载方法

这意味着如果您直接使用这些技巧，您将无法在请求加载代码后的下一行使用新加载的代码，因为它仍在加载

例如：my_lovely_script.js包含MySuperObject：

var js=document.createElementscript； js.type=text/javascript； js.src=jsFilePath；文件 t、 body.appendChildjs； var s=新的MySuperObject；错误：MySuperObject未定义然后按F5重新加载页面。而且它有效！迷惑

那怎么办呢

好吧，你可以使用作者在我给你的链接中建议的黑客。总之，对于匆忙的人，他使用事件在加载脚本时运行回调函数。因此，您可以使用远程库将所有代码放入回调函数中。例如：

函数loadScripturl，回调 { //按照前面的建议将脚本标记添加到头部 var head=document.head； var script=document.createElement'script'； script.type='text/javascript'； script.src=url； //然后将事件绑定到回调函数。 //跨浏览器兼容性有几个事件。 script.onreadystatechange=回调； script.onload=回调； //开炮 head.childscript； } 然后，编写脚本加载到中后要使用的代码：

var myPrettyCode=函数{ //来，你想干什么就干什么 }; 然后运行所有这些：

loadScriptmy_lovely_script.js，myPrettyCode；请注意，该脚本可能在加载DOM之后执行，也可能在加载之前执行，具体取决于浏览器以及是否包含行脚本。async=false；。有一篇文章讨论了这一点

源代码合并/预处理

如本答案顶部所述，许多开发人员在其项目中使用构建/传输工具，如Parcel、Webpack或Babel，允许他们使用即将推出的JavaScript语法，为旧浏览器提供向后兼容性，合并文件，缩小，执行代码拆分等。

我刚刚编写了此JavaScript代码，用于操作：

var require = (function() {
    var _required = {};
    return (function(url, callback) {
        if (typeof url == 'object') {
            // We've (hopefully) got an array: time to chain!
            if (url.length > 1) {
                // Load the nth file as soon as everything up to the
                // n-1th one is done.
                require(url.slice(0, url.length - 1), function() {
                    require(url[url.length - 1], callback);
                });
            } else if (url.length == 1) {
                require(url[0], callback);
            }
            return;
        }
        if (typeof _required[url] == 'undefined') {
            // Haven't loaded this URL yet; gogogo!
            _required[url] = [];

            var script = new Element('script', {
                src: url,
                type: 'text/javascript'
            });
            script.observe('load', function() {
                console.log("script " + url + " loaded.");
                _required[url].each(function(cb) {
                    cb.call(); // TODO: does this execute in the right context?
                });
                _required[url] = true;
            });

            $$('head')[0].insert(script);
        } else if (typeof _required[url] == 'boolean') {
            // We already loaded the thing, so go ahead.
            if (callback) {
                callback.call();
            }
            return;
        }

        if (callback) {
            _required[url].push(callback);
        }
    });
})();

用法：

<script src="prototype.js"></script>
<script src="require.js"></script>
<script>
    require(['foo.js','bar.js'], function () {
        /* Use foo.js and bar.js here */
    });
</script>

要点：。

您还可以使用以下方法组装脚本：

文件main.js.php：

实际上，有一种方法可以非异步加载JavaScript文件，因此您可以在加载新加载的文件后立即使用其中包含的函数，我认为它适用于所有浏览器

您需要在页面的元素上使用jQuery.append，即：

$("head").append($("<script></script>").attr("src", url));

/* Note that following line of code is incorrect because it doesn't escape the
 * HTML attribute src correctly and will fail if `url` contains special characters:
 * $("head").append('<script src="' + url + '"></script>');
 */

我也做了一个简单的测试

它在主HTML中包含一个main.js文件，然后main.js中的脚本使用$.import_js导入另一个名为include.js的文件，该文件定义了此函数：

function hello()
{
    alert("Hello world!");
}

在包含include.js之后，会调用hello函数，您会收到警报

这个答案是对e-satis的评论的回应。

另一种方法，我认为更简洁，就是发出同步Ajax请求，而不是使用标记。这也是句柄包含的方式

下面是一个使用jQuery的示例：

function require(script) {
    $.ajax({
        url: script,
        dataType: "script",
        async: false,           // <-- This is the key
        success: function () {
            // all good...
        },
        error: function () {
            throw new Error("Could not load script " + script);
        }
    });
}

并且能够从下一行中所需的脚本调用函数：

subscript.doSomethingCool();

我提出这个问题是因为我在寻找一种简单的方法来维护一组有用的JavaScript插件。在看到这里的一些解决方案后，我提出了以下建议：

设置一个名为plugins.js或extensions.js的文件或任何您想要的文件。把你的插件文件和那个主文件放在一起

plugins.js将有一个名为pluginNames[]的数组，我们将对每个数组进行迭代，然后在每个插件的头部添加一个标签

//设置添加或删除插件文件时要更新的数组 var pluginNames=[字母、fittext、butterjam等]； //每个插件有一个脚本标签 $.eachpluginNames，函数{ $'head'。追加； }; 手动调用您头脑中的一个文件：但是：

即使所有的插件都以它们应该的方式被放到head标签中，但当你点击页面或刷新时，它们并不总是被浏览器运行

我发现在PHP include中编写脚本标记更可靠。您只需编写一次，这与使用JavaScript调用插件的工作量一样多。

我创建了一个函数，允许您使用与C/Java类似的措辞来包含JavaScript文件。我甚至从另一个JavaScript文件内部对它进行了一点测试，它似乎可以工作。不过，它确实需要jQuery，以便在最后发挥一点魔力

我把这段代码放在脚本目录根目录下的一个文件中，我把它命名为global.js，但是你可以使用任何你想要的东西。除非我弄错了，否则jQuery应该是给定页面上唯一需要的脚本。请记住，除了一些基本用法之外，这在很大程度上是未经测试的，因此我所使用的方法可能有任何问题，也可能没有任何问题；使用时请自行承担风险yadda yadda如果你把事情搞砸了，我不负责yadda yadda：

/**
* @fileoverview This file stores global functions that are required by other libraries.
*/

if (typeof(jQuery) === 'undefined') {
    throw 'jQuery is required.';
}

/** Defines the base script directory that all .js files are assumed to be organized under. */
var BASE_DIR = 'js/';

/**
* Loads the specified file, outputting it to the <head> HTMLElement.
*
* This method mimics the use of using in C# or import in Java, allowing
* JavaScript files to "load" other JavaScript files that they depend on
* using a familiar syntax.
*
* This method assumes all scripts are under a directory at the root and will
* append the .js file extension automatically.
*
* @param {string} file A file path to load using C#/Java "dot" syntax.
*
* Example Usage:
* imports('core.utils.extensions');
* This will output: <script type="text/javascript" src="/js/core/utils/extensions.js"></script>
*/
function imports(file) {
    var fileName = file.substr(file.lastIndexOf('.') + 1, file.length);

    // Convert PascalCase name to underscore_separated_name
    var regex = new RegExp(/([A-Z])/g);
    if (regex.test(fileName)) {
        var separated = fileName.replace(regex, ",$1").replace(',', '');
        fileName = separated.replace(/[,]/g, '_');
    }

    // Remove the original JavaScript file name to replace with underscore version
    file = file.substr(0, file.lastIndexOf('.'));

    // Convert the dot syntax to directory syntax to actually load the file
    if (file.indexOf('.') > 0) {
        file = file.replace(/[.]/g, '/');
    }

    var src = BASE_DIR + file + '/' + fileName.toLowerCase() + '.js';
    var script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = src;

    $('head').find('script:last').append(script);
}

或者，在上传之前，使用脚本连接，而不是在运行时包含

我用我不知道是否还有其他人。您可以在单独的文件中构建JavaScript代码，并将链轮引擎处理的注释包括在内。对于开发，您可以按顺序包含文件，然后对于生产，您可以合并这些文件

另见：

如果有人想要更高级的东西，试试看 . 您将获得额外的好处，如依赖关系管理、更好的并发性和避免重复（即多次检索脚本）

您可以在模块中编写JavaScript文件，然后在其他脚本中将它们作为依赖项引用。或者您可以使用RequireJS作为一个简单的go-get脚本解决方案

例如：

将依赖项定义为模块：

some-dependency.js

implementation.js是依赖于some-dependency.js的主JavaScript文件

自述文件摘录：

RequireJS加载普通JavaScript文件以及更多定义的JavaScript文件模块。它针对浏览器中的使用进行了优化，包括在Web中 Worker，但它可以用于其他JavaScript环境，如犀牛和淋巴结。它实现了异步模块API

RequireJS使用纯脚本标记加载模块/文件，因此它应该允许轻松调试。它可以简单地用于加载现有的 JavaScript文件，因此您可以将其添加到现有项目中，而无需必须重新编写JavaScript文件

有个好消息要告诉你。很快，您将能够轻松加载JavaScript代码。它将成为导入JavaScript代码模块的标准方式，并将成为核心JavaScript本身的一部分

您只需从“cond.js”编写导入cond；从文件cond.js加载名为cond的宏

因此，您不必依赖任何JavaScript框架，也不必显式地进行调用

参考：

这应该做到：

xhr = new XMLHttpRequest();
xhr.open("GET", "/soap/ajax/11.0/connection.js", false);
xhr.send();
eval(xhr.responseText);

我编写了一个简单的模块，它可以自动在JavaScript中导入/包含模块脚本。有关代码的详细解释，请参阅博客文章

我通常的方法是：

var require = function (src, cb) {
    cb = cb || function () {};

    var newScriptTag = document.createElement('script'),
        firstScriptTag = document.getElementsByTagName('script')[0];
    newScriptTag.src = src;
    newScriptTag.async = true;
    newScriptTag.onload = newScriptTag.onreadystatechange = function () {
        (!this.readyState || this.readyState === 'loaded' || this.readyState === 'complete') && (cb());
    };
    firstScriptTag.parentNode.insertBefore(newScriptTag, firstScriptTag);
}

它的工作原理很好，我不需要重新加载页面。我尝试过其他答案之一的AJAX方法，但它似乎对我没有那么好的效果

下面解释了代码是如何为那些好奇的人工作的：本质上，它在URL的第一个之后创建了一个新的脚本标记。它将其设置为异步模式，这样就不会阻塞其余的代码，而是在readyState将要加载的内容的状态更改为“已加载”时调用回调。

此处显示的大多数解决方案都意味着动态加载。我搜索的是一个编译器，它将所有依赖的文件组装成一个单独的输出文件。与/preprocessor处理CSS@import at规则相同。因为我没有找到任何像样的东西，所以我写了一个简单的工具来解决这个问题

下面是编译器，它用请求的文件内容安全地替换$importfile path。下面是相应的插件：

在jQuery主分支上，它们只是将原子源文件连接成一个以intro.js开始，以outtro.js结束的文件。这不适合我，因为它在源代码设计上没有灵活性。查看它如何与jsic协同工作：

src/main.js

src/Form/Input/Tel.js

现在我们可以运行编译器：

node jsic.js src/main.js build/mail.js

并获取合并文件

build/main.js

此脚本将在任何其他标记的顶部添加一个JavaScript文件：

如果您想要纯JavaScript，可以使用document.write

以下是不带jQuery的同步版本：

请注意，要使此跨域工作，服务器需要在其响应中设置allow origin header。

可以通过其特殊的.mix文件类型使用Mixed等工具使用@import语法来实现类似CSS的JavaScript导入。我假设应用程序通过上述方法之一来实现这一点

从.mix文件的混合文档中：

Mix文件只是带有.Mix的.js或.css文件。在文件名中。A. 混合文件只是扩展了普通样式或脚本文件，并允许您导入和合并

下面是一个将多个.js文件合并为一个的.mix文件示例：

// scripts-global.mix.js
// Plugins - Global

@import "global-plugins/headroom.js";
@import "global-plugins/retina-1.1.0.js";
@import "global-plugins/isotope.js";
@import "global-plugins/jquery.fitvids.js";

Mixed将其输出为scripts-global.js，也输出为精简版scripts-global.min.js

注意：除了将它用作前端开发工具之外，我与Mixed没有任何关联。当我看到一个.mix JavaScript文件在一个混合样板中运行时，我遇到了这个问题，对此感到有点困惑，你能做到吗？我心里想。然后我意识到它是一种特定于应用程序的文件类型，这有点令人失望。然而，我认为这些知识可能对其他人有所帮助

注：混合物在2015/04/12开源后于2016/07/26停止使用。

如果您正在使用并希望在工作人员的范围内包含其他脚本，则提供的关于将脚本添加到标题标签等的其他答案将不适用于您

幸运的是，这是Web Worker范围内的一个全局函数，是浏览器本身固有的

或者，还可以处理在Web工作程序中包含脚本，该工作程序可能会调用importScripts本身，但还有一些其他有用的特性。

语句位于ECMAScript 6中

语法

import name from "module-name";
import { member } from "module-name";
import { member as alias } from "module-name";
import { member1 , member2 } from "module-name";
import { member1 , member2 as alias2 , [...] } from "module-name";
import name , { member [ , [...] ] } from "module-name";
import "module-name" as name;

以下是Facebook为其无处不在的按钮所做的概括版本：

var firstScript=document.getElementsByTagName'script'[0]， js=document.createElement'script'； js.src=https://cdnjs.cloudflare.com/ajax/libs/Snowstorm/20131208/snowstorm-min.js'; js.onload=函数{ //使用动态加载的脚本执行一些操作 snowStorm.snowColor='99ccff'； }; firstScript.parentNode.insertBeforejs，firstScript；

我有一个简单的问题，但我对这个问题的回答感到困惑

我必须在另一个JavaScript文件main.js中使用一个JavaScript文件myvariables.js中定义的变量myVar1

为此，我做了如下工作：

将JavaScript代码以正确的顺序加载到HTML文件中，首先是myvariables.js，然后是main.js：

<html>
    <body onload="bodyReady();" >

        <script src="myvariables.js" > </script>
        <script src="main.js" > </script>

        <!-- Some other code -->
    </body>
</html>

文件：main.js

// ...
function bodyReady() {
    // ...
    alert (myVar1);    // This shows "I am variable from myvariables.js", which I needed
    // ...
}
// ...

正如您所看到的，我在一个JavaScript文件和另一个JavaScript文件中使用了一个变量，但我不需要在另一个JavaScript文件中包含一个变量。我只需要确保第一个JavaScript文件在第二个JavaScript文件之前加载，并且第一个JavaScript文件的变量在第二个JavaScript文件中可以自动访问

这救了我一天。我希望这会有所帮助。

如果要加载JavaScript文件，您需要使用导入/包含文件中的函数，还可以定义一个全局对象，并将函数设置为对象项。例如：

global.js file1.js file2.js main.js 在HTML文件中包含脚本时，只需小心。顺序应如下所示：

<head>
  <script type="text/javascript" src="global.js"></script>
  <script type="text/javascript" src="file1.js"></script>
  <script type="text/javascript" src="file2.js"></script>
  <script type="text/javascript" src="main.js"></script>
</head>

在现代语言中，检查脚本是否已加载，它将是：

function loadJs( url ){
  return new Promise(( resolve, reject ) => {
    if (document.querySelector( `head > script[ src = "${url}" ]`) !== null ){
        console.warn( `script already loaded: ${url}` );
        resolve();
    }
    const script = document.createElement( "script" );
    script.src = url;
    script.onload = resolve;
    script.onerror = function( reason ){
        // This can be useful for your error-handling code
        reason.message = `error trying to load script ${url}`;
        reject( reason );
    };
    document.head.appendChild( script );
  });
}

用法异步/等待：

try { await loadJs("https://.../script.js"); }
catch(error) { console.log(error); }

或

使用承诺：

loadJs( "https://.../script.js" ).then( res => {} ).catch( err => {} );

尽管这些答案很好，但自从存在脚本加载以来，就有了一个简单的解决方案，它将覆盖99.999%的大多数人的用例。只需在需要脚本之前包含所需脚本。对于大多数项目，确定需要哪些脚本以及脚本的顺序并不需要很长时间

<!DOCTYPE HTML>
<html>
    <head>
        <script src="script1.js"></script>
        <script src="script2.js"></script>
    </head>
    <body></body>
</html>

如果script2需要script1，那么这确实是做类似事情最简单的方法。我很惊讶没有人提到这一点，因为这是最明显、最简单的答案，几乎适用于每一种情况。

在JavaScript中实现模块有几种方法。以下是两个最受欢迎的：

ES6模块浏览器还不支持这种模块化系统，所以为了使用这种语法，必须使用类似bundler的绑定器。无论如何，使用bundler会更好，因为这样可以将所有不同的文件合并到一个或多个相关文件中。这将更快地将文件从服务器发送到客户机，因为每个HTTP请求都伴随着一些相关的开销。因此，通过减少总体HTTP请求，我们可以提高性能。以下是ES6模块的示例：

// main.js file

export function add (a, b) {
  return a + b;
}

export default function multiply (a, b) {
  return a * b;
}


// test.js file

import {add}, multiply from './main';   // For named exports between curly braces {export1, export2}
                                        // For default exports without {}

console.log(multiply(2, 2));  // logs 4

console.log(add(1, 2));  // logs 3

Node.js中使用的CommonJS Node.js中使用了此模块化系统。基本上将导出添加到名为module.exports的对象。然后，您可以通过require'modulePath'访问此对象。这里很重要的一点是要意识到这些模块正在被缓存，因此如果您需要某个模块两次，它将返回已经创建的模块

// main.js file

function add (a, b) {
  return a + b;
}

module.exports = add;  // Here we add our 'add' function to the exports object


// test.js file

const add = require('./main');

console.log(add(1,2));  // logs 3

ES6模块是，在脚本标记中使用type=module：

在“module.js”中，您必须确保要导入：

export function hello() {
    return "Hello World";
}

一个有效的方法。

如果您不想卷入模块，不想使用回调函数，但想使用async/await，这是非常好的。url需要在这里正确转义：`head>script[src=${url}]`这是一个很好的答案。它可能被遗漏了，因为它不能直接回答问题，但理解“你通常不需要这样做”也很重要。特别是因为其他的解决方案都很混乱，但这只适用于网络浏览器？那么离线单元测试呢，比如说，在Node.js下？我通过单击菜单动态加载了div，而没有使用URL哈希加载页面。我的问题是，当我点击相同的页面2/3次时，js加载2/3次。这就是为什么每个事件都会发生多次。在添加代码之前，我想检查已经加载到footer/head中的js文件：var js=document.createElementscript；js.type=text/javascript；js.src=jsFilePath；document.body.appendChildjs；天哪，你刚刚写了一整篇论文！非常感谢！你是个传奇人物谢谢你的意见。是否有必要在头部的开头插入脚本？这一定是我见过的最长的答案。你也可以使用类似Gulp的方法对它们进行预处理，输出为一个名为。例如：a将多个JavaScript文件连接成一个，b使用Babel使其向后兼容，c使用minify/uglify删除注释、空格等。然后，您不仅组织了这些文件，而且还通过i

启动管道可能会对其他文件格式（如css和图像）执行相同的操作。最好避免将修订历史记录中的元信息更新到此文章。相反，将其应用于本帖子以外的内容，例如，Mixed于2015-04-12开放源码，并于2016-07-26终止。当你有很多单独的文件时，这不是一个好主意；您创建的文件越多，从客户端发送的请求就越多，这会延长加载时间，也可能会影响页面SEO。这是一个服务器端解决方案，而不是客户端解决方案。请注意，如果pluginNames包含特殊字符，这将不起作用，甚至可能导致安全漏洞。您需要在此处使用正确的转义：$'head'。append；很抱歉，我不使用jQuery。七年后，这个答案不起作用：SyntaxError：导入声明可能只出现在模块的顶层。请分享您的代码您正在尝试做的事情。好的，下面是运行良好的代码：function IncludejsFilePath{var js=d.createElementscript；js.type=text/javascript；js.src=jsFilePath；d.body.appendChildjs；}//包括一个优雅、可靠、简短的答案！

function() {
    return {
          prop: "",
          method: function(){}
    }
}

node jsic.js src/main.js build/mail.js

var foo = function() {
    return {
          prop: "",
          method: function(){}
    }
};

(function () {
    var li = document.createElement('script'); 
    li.type = 'text/javascript'; 
    li.src = "http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"; 
    li.async = true; 
    var s = document.getElementsByTagName('script')[0]; 
    s.parentNode.insertBefore(li, s);
})();

document.write('<script src="myscript.js" type="text/javascript"></script>');

$.getScript("another_script.js");

function myRequire( url ) {
    var ajax = new XMLHttpRequest();
    ajax.open( 'GET', url, false ); // <-- the 'false' makes it synchronous
    ajax.onreadystatechange = function () {
        var script = ajax.response || ajax.responseText;
        if (ajax.readyState === 4) {
            switch( ajax.status) {
                case 200:
                    eval.apply( window, [script] );
                    console.log("script loaded: ", url);
                    break;
                default:
                    console.log("ERROR: script not loaded: ", url);
            }
        }
    };
    ajax.send(null);
}

// scripts-global.mix.js
// Plugins - Global

@import "global-plugins/headroom.js";
@import "global-plugins/retina-1.1.0.js";
@import "global-plugins/isotope.js";
@import "global-plugins/jquery.fitvids.js";

import name from "module-name";
import { member } from "module-name";
import { member as alias } from "module-name";
import { member1 , member2 } from "module-name";
import { member1 , member2 as alias2 , [...] } from "module-name";
import name , { member [ , [...] ] } from "module-name";
import "module-name" as name;

<html>
    <body onload="bodyReady();" >

        <script src="myvariables.js" > </script>
        <script src="main.js" > </script>

        <!-- Some other code -->
    </body>
</html>

var myVar1 = "I am variable from myvariables.js";

// ...
function bodyReady() {
    // ...
    alert (myVar1);    // This shows "I am variable from myvariables.js", which I needed
    // ...
}
// ...

A = {};

A.func1 = function() {
  console.log("func1");
}

A.func2 = function() {
  console.log("func2");
}

A.func1();
A.func2();

<head>
  <script type="text/javascript" src="global.js"></script>
  <script type="text/javascript" src="file1.js"></script>
  <script type="text/javascript" src="file2.js"></script>
  <script type="text/javascript" src="main.js"></script>
</head>

function loadJs( url ){
  return new Promise(( resolve, reject ) => {
    if (document.querySelector( `head > script[ src = "${url}" ]`) !== null ){
        console.warn( `script already loaded: ${url}` );
        resolve();
    }
    const script = document.createElement( "script" );
    script.src = url;
    script.onload = resolve;
    script.onerror = function( reason ){
        // This can be useful for your error-handling code
        reason.message = `error trying to load script ${url}`;
        reject( reason );
    };
    document.head.appendChild( script );
  });
}

try { await loadJs("https://.../script.js"); }
catch(error) { console.log(error); }

await loadJs( "https://.../script.js" ).catch( err => {} );

loadJs( "https://.../script.js" ).then( res => {} ).catch( err => {} );

<!DOCTYPE HTML>
<html>
    <head>
        <script src="script1.js"></script>
        <script src="script2.js"></script>
    </head>
    <body></body>
</html>

// main.js file

export function add (a, b) {
  return a + b;
}

export default function multiply (a, b) {
  return a * b;
}


// test.js file

import {add}, multiply from './main';   // For named exports between curly braces {export1, export2}
                                        // For default exports without {}

console.log(multiply(2, 2));  // logs 4

console.log(add(1, 2));  // logs 3

// main.js file

function add (a, b) {
  return a + b;
}

module.exports = add;  // Here we add our 'add' function to the exports object


// test.js file

const add = require('./main');

console.log(add(1,2));  // logs 3

<script type="module" src="script.js"></script>

import { hello } from './module.js';
...
// alert(hello());

export function hello() {
    return "Hello World";
}