Как включить файл JavaScript в другой файл JavaScript?

Есть ли в JavaScript что-то похожее на @import в CSS, что позволяет включать файл JavaScript в другой файл JavaScript?

+4829
источник поделиться
61 ответ
  • 1
  • 2
  • 3

Я создал функцию, которая позволит вам использовать словоблудие, аналогичное С#/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);
}
+7
источник

Вот обходной путь для браузеров (не Node.js), использующих импорт HTML.

Во- первых, все классы JavaScript и скрипты не в .js файлах, но в .js.html файлы (.js. html только распознавать между HTML - страниц и полных JavaScript сценариев/классы), внутри <script> теги, как это:

MyClass.js.html:

<script>
   class MyClass {

      // Your code here..

   }

</script>

Затем, если вы хотите импортировать свой класс, вам просто нужно использовать импорт HTML:

<link rel="import" href="relative/path/to/MyClass.js.html"/>

<script>
   var myClass = new MyClass();
   // Your code here..
</script>

РЕДАКТИРОВАТЬ: импорт HTML будет прекращен

Импорт HTML отброшен в пользу модулей ES6. Вы должны использовать модули ES6.

+7
источник

Существует несколько способов реализации модулей в Javascript. Вот два наиболее популярных из них:

ES6 Модули

Браузеры пока не поддерживают эту систему модуляции, поэтому для использования этого синтаксиса вы должны использовать такой пакет, как webpack. В любом случае лучше использовать упаковщик, потому что он может объединить все ваши разные файлы в один (или пару связанных) файлов. Это позволит быстрее передавать файлы с сервера на клиент, поскольку с каждым 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

CommonJS (используется в NodeJS)

Эта система модуляции используется в NodeJS. Вы в основном добавляете свои экспорты к объекту, который называется module.exports. Затем вы можете получить доступ к этому объекту через require('modulePath'). Важно понимать, что эти модули кэшируются, поэтому, если вам require() определенный модуль дважды, он вернет уже созданный модуль.

// 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
+7
источник

Лучше использовать способ JQuery. Чтобы отложить событие готовности, сначала вызовите $.holdReady(true). Пример (источник):

$.holdReady(true);
$.getScript("myplugin.js", function() {
    $.holdReady(false);
});
+6
источник

Вот плагин Grunt, позволяющий вам использовать @import "path/to/file.js"; синтаксис в любом файле, включая файлы JavaScript. Это может быть в паре с Uglify или часы или любой другой плагин.

Его можно установить с помощью npm install: https://npmjs.org/package/grunt-import

+6
источник

Делайте это красиво, коротко, просто и легко! :]

// 3rd party plugins / script (don't forget the full path is necessary)
var FULL_PATH = '', s =
[
    FULL_PATH + 'plugins/script.js'      // Script example
    FULL_PATH + 'plugins/jquery.1.2.js', // jQuery Library 
    FULL_PATH + 'plugins/crypto-js/hmac-sha1.js',      // CryptoJS
    FULL_PATH + 'plugins/crypto-js/enc-base64-min.js'  // CryptoJS
];

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

 // initialize a single load 
load('plugins/script.js');

// initialize a full load of scripts
if (s.length > 0)
{
    for (i = 0; i < s.length; i++)
    {
        load(s[i]);
    }
}

Этот код является просто кратким функциональным примером, который может потребовать дополнительных функциональных возможностей для полной поддержки на любой (или данной) платформе.

+6
источник

Я делаю это следующим образом, создавая новый элемент и прикрепляя его к заголовку:

var x = document.createElement('script');
x.src = 'http://example.com/test.js';
document.getElementsByTagName("head")[0].appendChild(x);

В jQuery:

// jQuery
$.getScript('/path/to/imported/script.js', function()
{
    // Script is now loaded and executed.
    // Put your dependent JavaScript code here.
});
+6
источник

Только для NodeJS, это сработало для меня лучше всего!

Я попробовал большинство решений здесь, но ни одно из них не помогло мне просто загрузить другой файл без изменения области действия. Наконец-то я это использовал. Который сохраняет сферу и все. Это так же хорошо, как ваш код в этой точке.

const fs = require('fs');
eval(fs.readFileSync('file.js')+'');
+6
источник

Да, есть...

Продолжайте читать, в ES6 мы можем export и import часть или весь файл JavaScript в другой файл...

Но подождите, ES6 поддерживается не во всех браузерах, так что вам нужно перенести его, например, с помощью babel.js...

Итак, вы создаете класс, как показано ниже:

class Person {
  constructor(name) {
    this.name = name;
  }

  build() {
    return new Person(this);
  }
}

module.exports = Person;

в другом файле JavaScript выполните импорт следующим образом:

import { Person } from 'Person';

Вы также можете потребовать файл как:

const Person = require('./Person');

Если вы используете более старую версию JavaScript, вы можете использовать requirejs:

requirejs(["helper/util"], function(util) {
    //This function is called when scripts/helper/util.js is loaded.
    //If util.js calls define(), then this function is not fired until
    //util dependencies have loaded, and the util argument will hold
    //the module value for "helper/util".
});

Если вы хотите придерживаться более старых версий таких вещей, как jQuery, вы также можете использовать что-то вроде getScript:

jQuery.getScript('./another-script.js', function() {
    // Call back after another-script loaded
});

И последнее, но не менее важное: не забывайте, что вы можете сделать традиционный способ объединения сценариев, используя <script>...

<script src="./first-script.js"></script>
<script src="./second-script.js"></script>
<script src="./third-script.js"></script>

Есть также атрибут async и defer, о котором я должен упомянуть здесь...

Примечание. Существует несколько способов выполнения внешнего скрипта:

  • Если присутствует асинхронность: сценарий выполняется асинхронно с остальной частью страницы (сценарий будет выполняться, пока страница продолжает анализ)
  • Если async отсутствует, а defer присутствует: скрипт выполняется после завершения анализа страницы
  • Если нет ни асинхронного, ни отсроченного: скрипт извлекается и выполняется немедленно, прежде чем браузер продолжит синтаксический анализ страницы.
+5
источник

У меня есть требование асинхронно загружать массив файлов JavaScript и в конце сделать обратный вызов. В основном мой лучший подход заключается в следующем:

// Load a JavaScript file from other JavaScript file
function loadScript(urlPack, callback) {
    var url = urlPack.shift();
    var subCallback;

    if (urlPack.length == 0) subCallback = callback;
    else subCallback = function () {
        console.log("Log script: " + new Date().getTime());
        loadScript(urlPack, callback);
    }

    // Adding the script tag to the head as suggested before
    var head = document.getElementsByTagName('head')[0];
    var script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = url;

    // Then bind the event to the callback function.
    // There are several events for cross browser compatibility.
    script.onreadystatechange = subCallback;
    script.onload = subCallback;

    // Fire the loading
    head.appendChild(script);
}

Пример:

loadScript(
[
    "js/DataTable/jquery.dataTables.js",
    "js/DataTable/dataTables.bootstrap.js",
    "js/DataTable/dataTables.buttons.min.js",
    "js/DataTable/dataTables.colReorder.min.js",
    "js/DataTable/dataTables.fixedHeader.min.js",
    "js/DataTable/buttons.bootstrap.min.js",
    "js/DataTable/buttons.colVis.min.js",
    "js/DataTable/buttons.html5.min.js"
], function() { gpLoad(params); });

Второй скрипт не загрузится, пока первый полностью не загрузится, и так...

Результаты:

Result

+4
источник

Если вы используете Angular, то модуль плагина $ ocLazyLoad может помочь вам сделать это.

Вот некоторые цитаты из его документации:

Загрузите один или несколько модулей и компонентов с несколькими файлами:

$ocLazyLoad.load(['testModule.js', 'testModuleCtrl.js', 'testModuleService.js']);

Загрузите один или несколько модулей с несколькими файлами и укажите необходимый тип: Примечание. При использовании форматирования в стиле requireJS (например, с js! В начале) не указывайте расширение файла. Используйте один или другой.

$ocLazyLoad.load([
  'testModule.js',
   {type: 'css', path: 'testModuleCtrl'},
   {type: 'html', path: 'testModuleCtrl.html'},
   {type: 'js', path: 'testModuleCtrl'},
   'js!testModuleService',
   'less!testModuleLessFile'
]);

Вы можете загрузить внешние библиотеки (не угловые):

$ocLazyLoad.load(['testModule.js', 
   'bower_components/bootstrap/dist/js/bootstrap.js', 'anotherModule.js']);

Вы также можете загрузить файлы CSS и шаблонов:

 $ocLazyLoad.load([
     'bower_components/bootstrap/dist/js/bootstrap.js',
     'bower_components/bootstrap/dist/css/bootstrap.css',
     'partials/template1.html'
 ]);
+4
источник

Импорт и экспорт модулей с использованием ES6, которые работают с Node.js

Назовите файлы с расширением .mjs вместо .js

Создавать файлы

touch main.mjs lib.mjs

main.js

import { add } from './lib.mjs';
console.log(add(40, 2));

lib.mjs

export let add = (x,y) => {
  return x + y
}

Бежать

node --experimental-modules main.js
+4
источник

В прошлом проекте я довольно успешно использовал ajile для импорта повторно используемых файлов JavaScript. Я всегда хотел, чтобы была функция для этого встроенная в сам JavaScript.

+3
источник

Не забудьте проверить LAB.js !

<script type="text/javascript">
       $LAB
       .script("jquery-1.8.3.js").wait()
       .script("scripts/clientscript.js");      
</script>
+3
источник

Теперь я могу быть совершенно заблуждающимся, но вот что я недавно начал делать... Запустите и завершите ваши файлы JavaScript с помощью возврата каретки, вставьте в скрипт PHP, а затем еще один возврат каретки. Комментарий JavaScript "//" игнорируется PHP, поэтому включение происходит в любом случае. Целью возврата каретки является то, что первая строка вашего включенного JavaScript не закомментирована.

Технически, вам не нужен комментарий, но он публикует сообщения об ошибках в Dreamweaver, которые меня раздражают. Если вы пишете сценарий в среде IDE, которая не публикует сообщения об ошибках, вам не нужны комментарии или возврат каретки.

\n
//<?php require_once("path/to/javascript/dependency.js"); ?>

function myFunction(){
    // stuff
}
\n
+3
источник
var s=["Hscript.js","checkRobert.js","Hscript.js"];
for(i=0;i<s.length;i++){
  var script=document.createElement("script");
  script.type="text/javascript";
  script.src=s[i];
  document.getElementsByTagName("head")[0].appendChild(script)
};
+3
источник

Я также написал менеджер зависимостей JavaScript для веб-приложений Java: JS-Class-Loader.

+3
источник

Это очень просто. Предположим, вы хотите импортировать файл A.js в файл B.js.

Теперь убедитесь, что вы связали B.js в файле HTML, а затем просто связывайте A.js перед B.js в этом файле HTML. Тогда открытые переменные A.js будут доступны внутри B.js

Это не требует сложного ответа.

+3
источник

Я пробовал эту проблему с другим подходом,

Порядок импорта скриптов здесь никак не сказывается.

index.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Trials</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <script src="main.js"></script>
    <script src="scriptA.js"></script>
</head>

<body>
<h3>testing js in js (check console logs)</h3>
<button onclick="fnClick()">TEST</button>
</body>

</html>

main.js

function fnClick() {
  console.log('From\tAAAAA');
  var pro = myExpo.hello();
  console.log(pro);
}

scriptA.js

myExpo = {
    hello: function () {
        console.log('From\tBBBBB');
        return "Hello";
    }
}

и результат

From    AAAAA
From    BBBBB
Hello
+3
источник

Вы не можете импортировать, но вы можете ссылаться.

PhpShtorm IDE. Для ссылки в одном файле .js на другой файл .js просто добавьте это в начало файла:

<reference path="../js/file.js" />

Конечно, вы должны использовать свой собственный путь к файлу JavaScript.

Я не знаю, будет ли это работать в других IDE. Наверное, да, просто попробуйте. Это должно работать и в Visual Studio.

+2
источник

Вот, может быть, другой путь! В Node.js вы делаете это, как показано ниже! http://requirejs.org/docs/node.html

sub.js

module.exports = {
  log: function(string) {
    if(console) console.log(string);
  }
  mylog: function(){
    console.log('just for log test!');
  }
}

main.js

var mylog =require('./sub');

mylog.log('Hurray, it works! :)');
mylog.mylog();
+2
источник

Другой подход заключается в использовании импорта HTML. Они могут содержать ссылки на скрипты, а также ссылки на таблицы стилей.

Вы можете просто связать файл HTML, как

<link rel="import" href="vendorScripts.html"/>

В файле vendorScripts.html вы можете включить ссылки на свои скрипты, например:

<script src="scripts/vendors/jquery.js"></script>
<script src="scripts/vendors/bootstrap.js"></script>
<script src="scripts/vendors/angular.js"></script>
<script src="scripts/vendors/angular-route.js"></script>

Посмотрите на HTML Imports для более подробной информации.

К сожалению, это работает только в Chrome.

+2
источник

Динамическая загрузка нескольких скриптов по порядку

Вышеприведенная функция прекрасно работает, если вы загружаете только один скрипт или вам не нужен порядок загрузки нескольких скриптов. Если у вас есть некоторые сценарии, которые зависят от других, вам нужно использовать Promise, чтобы указать порядок загрузки. Причиной этого является то, что Javascript асинхронно загружает такие ресурсы, как сценарии и изображения. Последовательность загрузки не зависит от последовательности асинхронных вызовов, а это означает, что не будет гарантированно загружаться script1 перед script2, даже если вы вызовите dynamicallyLoadScript("scrip1") перед вызовом dynamicallyLoadScript("scrip2")

Итак, вот еще одна версия dynamicicallyLoadScript, который гарантирует порядок загрузки:

// Based on: https://javascript.info/promise-basics#example-loadscript
function dynamicallyLoadScript(url) {
        return new Promise(function(resolve, reject) {
        var script = document.createElement("script");
        script.src = url;
        script.onload = resolve;
        script.onerror = () => reject(new Error('Error when loading ${url}!'));
        document.body.appendChild(script);
    });

Подробнее об обещаниях смотрите на этой превосходной странице.

Использование этого нового dynamicicallyLoadScript очень просто:

dynamicallyLoadScript("script1.js")
.then(() => dynamicallyLoadScript("script2.js"))
.then(() => dynamicallyLoadScript("script3.js"))
.then(() => dynamicallyLoadScript("script4.js"))
.then(() => dynamicallyLoadScript("script5.js"))
//...

Теперь скрипты загружаются в следующем порядке: script1.js, script2.js, script3.js и т.д.

Запуск зависимого кода после загрузки скрипта

Кроме того, вы можете сразу запустить код, который использует скрипты после их загрузки. Просто добавьте еще один .then после загрузки скрипта:

dynamicallyLoadScript("script1.js")
.then(() => dynamicallyLoadScript("script2.js"))
.then(() => foo()) // foo can be a function defined in either script1, script2
.then(() => dynamicallyLoadScript("script3.js"))
.then(() => {
     if (var1){ // var1 can be a global variable defined in either script1, script2, or script3
          bar(var1); // bar can be a function defined in either script1, script2, or script3
     } else {
          foo(var1);
     }
})
//more .then chains...

Обрабатывать ошибки загрузки

Для отображения необработанного обещания отбраковки (ошибки загрузки скриптов и т.д.), поставить этот unhandledrejection слушатель событий в верхней части коды:

// Based on: https://javascript.info/promise-error-handling#unhandled-rejections
window.addEventListener('unhandledrejection', function(event) {
     // the event object has two special properties:
     console.error(event.promise);// the promise that generated the error
     console.error(event.reason); // the unhandled error object
});

Теперь вы будете уведомлены о любых ошибках загрузки скрипта.


Функция быстрого доступа

Если вы загружаете много скриптов без выполнения кода сразу после загрузки, эта сокращенная функция может пригодиться:

function dynamicallyLoadScripts(urls){
        if (urls.length === 0){
            return;
        }
        let promise = dynamicallyLoadScript(urls[0]);
        urls.slice(1).forEach(url => {
            promise = promise.then(() => dynamicallyLoadScript(url));
        });
    }

Чтобы использовать его, просто передайте массив URL-адресов скриптов, например:

const scriptURLs = ["dist/script1.js", "dist/script2.js", "dist/script3.js"];
dynamicallyLoadScripts(scriptURLs);

Скрипты будут загружены в порядке их появления в массиве.

+1
источник

ES6: ДА использовать type = "module" в теге script (поддержка)

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

А в файле script.js есть еще один файл, подобный этому:

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

В 'module.js' вы должны экспортировать функцию/класс, который вы будете импортировать

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

Рабочий пример здесь.

+1
источник
var xxx = require("../lib/your-library.js")

или же

import xxx from "../lib/your-library.js" //get default export
import {specificPart} from '../lib/your-library.js' //get named export
import * as _name from '../lib/your-library.js'  //get full export to alias _name
0
источник

Обратите внимание, что мы обычно используем статические скрипты. Итак, мы хотим, чтобы из кеша как можно больше брались. Это экономит сетевой трафик и ускоряет посадку.

использование

$.cachedScript( "ajax/test.js" ).done(function( script, textStatus ) {
  console.log( textStatus );
});

Параметр cache: true добавлен в метод ajax

0
источник

Если вы обнаружите, что два или более сценария занимают одну и ту же функцию при вызове, мы не можем включить их в одно и то же время, нам нужно сделать это динамически по выбору пользователя.

Включение других файлов в jQuery с использованием $.getScript работает, так как скрипт не будет кэшироваться по умолчанию. Таким образом, мы сохраняем, чтобы вызывать другие сценарии. Звонки могут быть организованы так:

HTML

<select class="choice">
  <option value="script1" selected>Script-1</option>
  <option value="script2">Script-2</option>
</select>

JS

  $(".choice").change(on_change);

    var url = "https://example.com";
    $.url1 = url + "/script1.js";
    $.url2 = url + "/script2.js";

  function on_change() {
    if ($(".choice").val()=="script1") {
        script1();
    } else {
        script2();
    }

    // script1
    function script1() {   
      $.getScript($.url1, function( data, textStatus, jqxhr ) {
          //excecute here
      });  
    }

    // script2
    function script2() {
       $.getScript($.url2, function( data, textStatus, jqxhr ) {
          //excecute here
      });  
    }
0
источник

Вы можете использовать мой модуль loadScript ES для загрузки файлов javaScript.

Использование:

В теге head включите следующий код:

<script src="https://raw.githack.com/anhr/loadScriptNodeJS/master/build/loadScript.js"></script>

или же

<script src="https://raw.githack.com/anhr/loadScriptNodeJS/master/build/loadScript.min.js"></script>

Теперь вы можете использовать window.loadScript для загрузки ваших файлов JavaScript.

loadScript.async(src, [options])

Асинхронная загрузка файла JavaScript.

src: URL-адрес внешнего файла сценария или массив имен файлов сценария.

опции: доступны следующие опции

onload: function () The onload event occurs when a script has been loaded. Default is undefined.

onerror: function ( str, e ) The onerror event occurs when an error has been occured. Default is undefined.

    str: error details

    e: event

appendTo: The node to which the new script will be append. Default is head node.

Например

loadScript.async( "JavaScript.js",
        {
            onload: function () {

                var str = 'file has been loaded successfully';
                console.log( str );

            },
            onerror: function ( str, e ) {

                console.error( str );

            },

        } );

Пример использования

0
источник

Немного расширились, чтобы освободить от ответа @Dan Dascalescu взято из идеи Facebook.

(function() {   
var __ = {};
this._ = function(name, callback) {
    if(__[name]==undefined) {
        __[name] = true;
        var firstScript = document.getElementsByTagName('script')[0],
          js = document.createElement('script');
          js.src =  name;
          js.onload = callback;
          firstScript.parentNode.insertBefore(js, firstScript);
    }
}
})();

(new _('https://cdnjs.cloudflare.com/ajax/libs/Snowstorm/20131208/snowstorm-min.js', function() {
 snowStorm.snowColor = '#99ccff';
}));
0
источник

Так что это крайний случай. Но если вам нужно загрузить JavaScript из удаленного источника, большинство современных браузеров блокируют ваши межсайтовые запросы. Так нормально

<script src="https://another-domain.com/example.js"></script>

Не сработает. И выполнение document.createElement('script').src = '...' тоже не сработает. Вместо этого вы можете загрузить java-скрипт как ресурс с помощью стандартного запроса GET и сделать это:

<script type="text/javascript">
    var script = document.createElement('script');
    script.type = 'text/javascript';

    let xhr = new XMLHttpRequest();
    xhr.open("GET", 'https://raw.githubusercontent.com/Torxed/slimWebSocket/master/slimWebSocket.js', true);
    xhr.onreadystatechange = function() {
        if (this.readyState === XMLHttpRequest.DONE && this.status === 200) {
            script.innerHTML = this.responseText; // <-- This one
            document.head.appendChild(script);
        }
    }
    xhr.send();
</script>

Взяв контент самостоятельно, браузер не заметит злонамеренных намерений и позволит вам выполнить запрос. Затем вы добавляете его в <script> innerHTML. Это все еще заставляет браузер (по крайней мере, проверенный в Chrome) анализировать/выполнять скрипт.

Опять же, это крайний случай использования. И у вас, вероятно, не будет обратной совместимости или совместимости с браузером. Но веселье/полезная вещь, чтобы знать о.

0
источник
  • 1
  • 2
  • 3

Посмотрите другие вопросы по меткам или Задайте вопрос