गतिशील रूप से एक जावास्क्रिप्ट फ़ाइल लोड करें


167

आप कैसे मज़बूती से और गतिशील रूप से एक जावास्क्रिप्ट फ़ाइल लोड कर सकते हैं? यह एक मॉड्यूल या घटक को लागू करने के लिए इस्तेमाल किया जा सकता है कि जब 'इनिशियलाइज्ड' घटक गतिशील रूप से मांग पर सभी आवश्यक जावास्क्रिप्ट लाइब्रेरी स्क्रिप्ट को लोड करेगा।

घटक का उपयोग करने वाले क्लाइंट को सभी लाइब्रेरी स्क्रिप्ट फ़ाइलों को लोड करने की आवश्यकता नहीं है (और मैन्युअल रूप <script>से अपने वेब पेज में टैग डालें ) जो इस घटक को लागू करते हैं - बस 'मुख्य' घटक स्क्रिप्ट फ़ाइल।

जावास्क्रिप्ट मुख्यधारा कैसे इसे पूरा करती है (प्रोटोटाइप, jQuery, आदि)? क्या ये उपकरण एक स्क्रिप्ट फ़ाइल के एकल पुनर्वितरण योग्य 'बिल्ड' संस्करण में कई जावास्क्रिप्ट फ़ाइलों को मर्ज करते हैं? या वे सहायक 'पुस्तकालय' लिपियों का कोई गतिशील लोडिंग करते हैं?

इस प्रश्न के अतिरिक्त: क्या डायनेमिक रूप से शामिल जावास्क्रिप्ट फ़ाइल लोड होने के बाद घटना को संभालने का एक तरीका है? प्रोटोटाइप में document.observeदस्तावेज़-विस्तृत घटनाओं के लिए है। उदाहरण:

document.observe("dom:loaded", function() {
  // initially hide all containers for tab content
  $$('div.tabcontent').invoke('hide');
});

एक स्क्रिप्ट तत्व के लिए उपलब्ध घटनाएं क्या हैं?


जवाबों:


84

आप डायनामिक स्क्रिप्ट टैग ( प्रोटोटाइप का उपयोग करके ) लिख सकते हैं :

new Element("script", {src: "myBigCodeLibrary.js", type: "text/javascript"});

यहाँ समस्या यह है कि हम नहीं जानते कि बाहरी स्क्रिप्ट फ़ाइल कब पूरी तरह से भरी हुई है।

हम अक्सर बहुत अगली पंक्ति पर अपना निर्भर कोड चाहते हैं और कुछ लिखना पसंद करते हैं:

if (iNeedSomeMore) {
    Script.load("myBigCodeLibrary.js"); // includes code for myFancyMethod();
    myFancyMethod(); // cool, no need for callbacks!
}

कॉलबैक की आवश्यकता के बिना स्क्रिप्ट निर्भरता को इंजेक्ट करने का एक स्मार्ट तरीका है। आपको बस एक तुल्यकालिक AJAX अनुरोध के माध्यम से स्क्रिप्ट को खींचना होगा और वैश्विक स्तर पर स्क्रिप्ट को निकालना होगा ।

यदि आप Script.load विधि प्रोटोटाइप का उपयोग करते हैं तो ऐसा दिखता है:

var Script = {
    _loadedScripts: [],
    include: function(script) {
        // include script only once
        if (this._loadedScripts.include(script)) {
            return false;
        }
        // request file synchronous
        var code = new Ajax.Request(script, {
            asynchronous: false,
            method: "GET",
            evalJS: false,
            evalJSON: false
        }).transport.responseText;
        // eval code on global level
        if (Prototype.Browser.IE) {
            window.execScript(code);
        } else if (Prototype.Browser.WebKit) {
            $$("head").first().insert(Object.extend(
                new Element("script", {
                    type: "text/javascript"
                }), {
                    text: code
                }
            ));
        } else {
            window.eval(code);
        }
        // remember included script
        this._loadedScripts.push(script);
    }
};

क्रॉस-डोमेन के लिए काम करने के लिए मैं क्या कर सकता हूं? (लोडिंग स्क्रिप्ट से http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStu‌​ff/userjs/aagmfunctions.js)
user2284570


@Ciastopiekarz: मेरा नियंत्रण नहीं है web.archive.org
user2284570

फिर आपको उस डेटा को परिमार्जन करना होगा जिसे आप किसी अन्य प्रोग्राम का उपयोग करके एक्सेस करना चाहते हैं और इसे स्वयं को प्रदान करते हैं
डेविड शुमन

Ajax.Request क्या है ??
ब्लूजैके

72

जावास्क्रिप्ट में कोई आयात / शामिल / आवश्यकता नहीं है, लेकिन जो आप चाहते हैं उसे प्राप्त करने के दो मुख्य तरीके हैं:

1 - आप इसे AJAX कॉल के साथ लोड कर सकते हैं फिर eval का उपयोग कर सकते हैं।

यह सबसे सीधा तरीका है, लेकिन यह जावास्क्रिप्ट सुरक्षा सेटिंग्स के कारण आपके डोमेन तक सीमित है, और eval का उपयोग बग और हैक्स के लिए दरवाजा खोल रहा है।

2 - HTML में स्क्रिप्ट URL के साथ एक स्क्रिप्ट टैग जोड़ें।

निश्चित रूप से सबसे अच्छा तरीका है। आप एक विदेशी सर्वर से भी स्क्रिप्ट को लोड कर सकते हैं, और कोड का मूल्यांकन करने के लिए ब्राउज़र पार्सर का उपयोग करते हुए यह साफ है। आप टैग को वेब पेज के मुख्य भाग या शरीर के निचले भाग में रख सकते हैं।

इन दोनों समाधानों पर चर्चा और चित्रण यहाँ किया गया है।

अब, एक बड़ा मुद्दा है जिसके बारे में आपको पता होना चाहिए। ऐसा करने से तात्पर्य है कि आप दूर से कोड लोड करते हैं। आधुनिक वेब ब्राउज़र फ़ाइल को लोड करेंगे और आपकी वर्तमान स्क्रिप्ट को निष्पादित करते रहेंगे क्योंकि प्रदर्शन को बेहतर बनाने के लिए वे सब कुछ अतुल्यकालिक रूप से लोड करते हैं।

इसका मतलब है कि यदि आप इन ट्रिक्स का सीधे उपयोग करते हैं, तो आप इसे लोड करने के लिए कहने के बाद अपने नए लोड किए गए कोड का उपयोग नहीं कर पाएंगे, क्योंकि यह अभी भी लोड हो रहा है।

उदा: my_lovely_script.js में MySuperObject शामिल है

var js = document.createElement("script");

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

document.body.appendChild(js);

var s = new MySuperObject();

Error : MySuperObject is undefined

फिर आप F5 मार पृष्ठ को पुनः लोड करें। और यह काम करता है! भ्रमित ...

तो इसके बारे में क्या करना है?

ठीक है, आप उस लेखक के हैक का उपयोग कर सकते हैं जो मैंने आपको दिए लिंक में दिया है। सारांश में, जल्दी में लोगों के लिए, वह स्क्रिप्ट के लोड होने पर कॉलबैक फ़ंक्शन को चलाने के लिए एन इवेंट का उपयोग करता है। तो आप कॉलबैक फ़ंक्शन में रिमोट लाइब्रेरी का उपयोग करके सभी कोड डाल सकते हैं। ईजी:

function loadScript(url, 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 = callback;
   script.onload = callback;

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

फिर आप उस कोड को लिखते हैं जिसे आप उपयोग करना चाहते हैं स्क्रिप्ट के लिए एक लंबो फ़ंक्शन में लोड किया गया है:

var myPrettyCode = function() {
    // here, do what ever you want
};

तब आप वह सब चलाते हैं:

loadScript("my_lovely_script.js", myPrettyCode);

ठीक है मैंने समझ लिया। लेकिन यह सब कुछ लिखने के लिए एक दर्द है।

ठीक है, उस स्थिति में, आप हमेशा शानदार फ्री jQuery फ्रेमवर्क के रूप में उपयोग कर सकते हैं, जो आपको एक पंक्ति में एक ही काम करने देता है:

$.getScript("my_lovely_script.js", function() {
    alert("Script loaded and executed.");
    // here you can use anything you defined in the loaded script
});

11
विश्वास नहीं कर सकता कि यह उत्तर कितना कम है। धन्यवाद।
नाफ्टालीमिच

2
मुझे यकीन है कि यह इसलिए है क्योंकि लोग पहली पंक्ति को पढ़ना पसंद नहीं करते हैं, जब तक यह वादा नहीं करता कि वे अमीर होंगे यदि वे "सफलता के लिए इन तीन गुप्त चरणों का पालन करते हैं।"
कोस्टा

यह काम। मुझे उम्मीद है कि यहां अपना अनुभव साझा करने से आपका समय बचता है क्योंकि मैंने इस पर कई घंटे बिताए हैं। मैं एंगुलर 6 और एप्लाइड टेम्प्लेट (html, css, jquery) का उपयोग कर रहा हूं। समस्या यह है कि टेम्प्लेट में एक js फाइल है जो html एलिमेंट्स को श्रोताओं के ईवेंट को लोड करने के बाद लोड करता है। कोणीय एप्लिकेशन लोड होने के बाद उस js फ़ाइल को निष्पादित करना कठिन था। इसे कोणीय ऐप (angular.json) स्क्रिप्ट टैग में जोड़ने से उन्हें बंडल किया जाएगा लेकिन लोड करने के बाद उस js फ़ाइल को निष्पादित नहीं किया जाएगा। यह टाइपस्क्रिप्ट में फिर से लिखने के लिए बहुत अधिक कोड है तो यह बहुत मदद थी। अगली टिप्पणी मैं उदाहरण के लिए डालूंगा टिप्पणी की लंबाई का विस्तार
नूर लाबाबिदी

मैंने केवल इस कोड का अनुसरण किया है: ngAfterViewInit () {डीबगर; $ .getScript ("/ आस्तियों / js / jquery.app.js", फ़ंक्शन () {चेतावनी ("स्क्रिप्ट लोड और निष्पादित";); // यहां आप लोड की गई स्क्रिप्ट में परिभाषित किसी भी चीज़ का उपयोग कर सकते हैं)); }
नूर लाबाबिदी

कोणीय में '$' के लिए मैंने इसका अनुसरण किया: stackoverflow.com/questions/32050645/…
Nour Lababidi

28

मैंने jQuery के साथ हाल ही में बहुत कम जटिल संस्करण का उपयोग किया :

<script src="scripts/jquery.js"></script>
<script>
  var js = ["scripts/jquery.dimensions.js", "scripts/shadedborder.js", "scripts/jqmodal.js", "scripts/main.js"];
  var $head = $("head");
  for (var i = 0; i < js.length; i++) {
    $head.append("<script src=\"" + js[i] + "\"></scr" + "ipt>");
  }
</script>

यह मेरे द्वारा परीक्षण किए गए प्रत्येक ब्राउज़र में बहुत अच्छा काम करता है: IE6 / 7, फ़ायरफ़ॉक्स, सफारी, ओपेरा।

अपडेट: jQuery- कम संस्करण:

<script>
  var js = ["scripts/jquery.dimensions.js", "scripts/shadedborder.js", "scripts/jqmodal.js", "scripts/main.js"];
  for (var i = 0, l = js.length; i < l; i++) {
    document.getElementsByTagName("head")[0].innerHTML += ("<script src=\"" + js[i] + "\"></scr" + "ipt>");
  }
</script>

25
यह बहुत अच्छा है ... जब तक आप jquery को लोड करने की कोशिश नहीं कर रहे हैं।

1
ऐसा लगता है कि jQuery भविष्य की रिलीज़ के लिए jQuery कोर में आवश्यकता प्लगइन में रोल करने जा रहा है: plugins.jquery.com/project/require
एडम

1
JQuery का उपयोग करने का एक और बेहतर तरीका उपयोग करना है $.getScript। मेरा जवाब देखिए।
मुहम्मद

1
मॉडर्निज़र (yepnope.js) या lab.js इसके लिए उपयुक्त समाधान हैं। भारी स्क्रिप्ट लाइब्रेरी का उपयोग करना (जो पहले लोड करना होगा) मोबाइल या कई अन्य स्थितियों के लिए सबसे उपयुक्त उत्तर नहीं है।
1nfiniti

2
@MaulikGangani पुराने ब्राउज़र और HTML सत्यापनकर्ता स्क्रिप्ट को समाप्त करने के लिए टोकन के रूप में व्याख्या करेंगे।
ट्रैविस

20

मैंने मूल रूप से वही काम किया है जो आपने एडम से किया था, लेकिन यह सुनिश्चित करने के लिए कि मैं काम करने के लिए हेड टैग में थोड़ा संशोधन कर रहा हूं। मैंने स्क्रिप्ट और सीएसएस दोनों फाइलों को संभालने के लिए बस एक फंक्शन (नीचे कोड) बनाया।

यह फ़ंक्शन यह सुनिश्चित करने के लिए भी जाँच करता है कि स्क्रिप्ट या CSS फ़ाइल पहले ही गतिशील रूप से लोड नहीं हुई है। यह हाथ से कोडित मूल्यों की जांच नहीं करता है और ऐसा करने का एक बेहतर तरीका हो सकता है, लेकिन इसने उद्देश्य को पूरा किया।

function include( url, type ){
    // First make sure it hasn't been loaded by something else.
    if( Array.contains( includedFile, url ) )
        return;

    // Determine the MIME-type
    var jsExpr = new RegExp( "js$", "i" );
    var cssExpr = new RegExp( "css$", "i" );
    if( type == null )
        if( jsExpr.test( url ) )
            type = 'text/javascript';
        else if( cssExpr.test( url ) )
            type = 'text/css';

    // Create the appropriate element.
    var tag = null;
    switch( type ){
        case 'text/javascript' :
            tag = document.createElement( 'script' );
            tag.type = type;
            tag.src = url;
            break;
        case 'text/css' :
            tag = document.createElement( 'link' );
            tag.rel = 'stylesheet';
            tag.type = type;
            tag.href = url;
            break;
    }

    // Insert it to the <head> and the array to ensure it is not
    // loaded again.
    document.getElementsByTagName("head")[0].appendChild( tag );
    Array.add( includedFile, url );
}

उस अचार से अधिक संदर्भ के बिना, मुझे डर है कि मेरे पास कोई सुझाव नहीं है। ऊपर दिए गए कोड के रूप में काम करता है, यह एक कामकाज परियोजना से सीधे खींच लिया गया था।
पालेहोरसे

5
@palehorse, माइक और मुहम्मद, सही हैं, यह आपकी परियोजना में काम कर सकता है, लेकिन इसलिए कि "शामिल" और "सरणी" चर को आपकी परियोजना में कहीं और परिभाषित किया जाना चाहिए, यह कोड अपने आप नहीं चलेगा, यह हो सकता है इसे संपादित करने के लिए बेहतर है ताकि यह आपकी परियोजना के संदर्भ के बाहर काम कर सके, या कम से कम एक टिप्पणी जोड़कर बताए कि जो अपरिभाषित चर हैं (टाइप आदि)
user280109

14

एक और भयानक जवाब

$.getScript("my_lovely_script.js", function(){


   alert("Script loaded and executed.");
  // here you can use anything you defined in the loaded script

 });

https://stackoverflow.com/a/950146/671046


2
क्रॉस-डोमेन के लिए काम करने के लिए मैं क्या कर सकता हूं? (लोडिंग स्क्रिप्ट से http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStu‌​ff/userjs/aagmfunctions.js)
user2284570

9

यहाँ कुछ उदाहरण कोड मैंने पाया है ... क्या किसी के पास बेहतर तरीका है?

  function include(url)
  {
    var s = document.createElement("script");
    s.setAttribute("type", "text/javascript");
    s.setAttribute("src", url);
    var nodes = document.getElementsByTagName("*");
    var node = nodes[nodes.length -1].parentNode;
    node.appendChild(s);
  }

क्रॉस-डोमेन के लिए काम करने के लिए मैं क्या कर सकता हूं? (लोडिंग स्क्रिप्ट से http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStu‌​ff/userjs/aagmfunctions.js)
user2284570

6

यदि आपके पास पहले से ही jQuery लोड है, तो आपको $ .getScript का उपयोग करना चाहिए ।

इससे यहां अन्य उत्तरों पर एक फायदा है कि आपके पास एक बिल्ट इन कॉलबैक फ़ंक्शन है (यह गारंटी देने के लिए कि स्क्रिप्ट निर्भर कोड चलने से पहले लोड हो गई है) और आप कैशिंग को नियंत्रित कर सकते हैं।


4

यदि आप एक SYNC स्क्रिप्ट लोड करना चाहते हैं , तो आपको सीधे HTML HEAD टैग में स्क्रिप्ट टेक्स्ट जोड़ना होगा। इसे जोड़ने पर ASYNC लोड बढ़ेगा । बाह्य फ़ाइल से स्क्रिप्ट टेक्स्ट को सिंक्रोनाइज़ करने के लिए, XHR का उपयोग करें। एक त्वरित नमूने के नीचे (यह और अन्य पोस्ट में अन्य उत्तरों के कुछ हिस्सों का उपयोग कर रहा है):

/*sample requires an additional method for array prototype:*/

if (Array.prototype.contains === undefined) {
Array.prototype.contains = function (obj) {
    var i = this.length;
    while (i--) { if (this[i] === obj) return true; }
    return false;
};
};

/*define object that will wrap our logic*/
var ScriptLoader = {
LoadedFiles: [],

LoadFile: function (url) {
    var self = this;
    if (this.LoadedFiles.contains(url)) return;

    var xhr = new XMLHttpRequest();
    xhr.onload = function () {
        if (xhr.readyState === 4) {
            if (xhr.status === 200) {
                self.LoadedFiles.push(url);
                self.AddScript(xhr.responseText);
            } else {
                if (console) console.error(xhr.statusText);
            }
        }
    };
    xhr.open("GET", url, false);/*last parameter defines if call is async or not*/
    xhr.send(null);
},

AddScript: function (code) {
    var oNew = document.createElement("script");
    oNew.type = "text/javascript";
    oNew.textContent = code;
    document.getElementsByTagName("head")[0].appendChild(oNew);
}
};

/*Load script file. ScriptLoader will check if you try to load a file that has already been loaded (this check might be better, but I'm lazy).*/

ScriptLoader.LoadFile("Scripts/jquery-2.0.1.min.js");
ScriptLoader.LoadFile("Scripts/jquery-2.0.1.min.js");
/*this will be executed right after upper lines. It requires jquery to execute. It requires a HTML input with id "tb1"*/
$(function () { alert($('#tb1').val()); });

3

किसी को भी एक बेहतर तरीका है?

मुझे लगता है कि सिर्फ स्क्रिप्ट को शरीर से जोड़ना आसान होगा और फिर इसे पृष्ठ पर अंतिम नोड में जोड़ दिया जाएगा। इस बारे में कैसा है:

function include(url) {
  var s = document.createElement("script");
  s.setAttribute("type", "text/javascript");
  s.setAttribute("src", url);
  document.body.appendChild(s);
}

क्रॉस-डोमेन के लिए काम करने के लिए मैं क्या कर सकता हूं? (लोडिंग स्क्रिप्ट से http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStu‌​ff/userjs/aagmfunctions.js)
user2284570

3

मैंने अभी तक नेट पर पाए जाने वाले एक और समाधान का उपयोग किया है ... यह एक क्रिएटिवकॉम के तहत है और यह जांचता है कि क्या स्रोत को कॉल करने से पहले शामिल किया गया था ...

आप यहाँ फ़ाइल पा सकते हैं: शामिल हैं। js

/** include - including .js files from JS - bfults@gmail.com - 2005-02-09
 ** Code licensed under Creative Commons Attribution-ShareAlike License 
 ** http://creativecommons.org/licenses/by-sa/2.0/
 **/              
var hIncludes = null;
function include(sURI)
{   
  if (document.getElementsByTagName)
  {   
    if (!hIncludes)
    {
      hIncludes = {}; 
      var cScripts = document.getElementsByTagName("script");
      for (var i=0,len=cScripts.length; i < len; i++)
        if (cScripts[i].src) hIncludes[cScripts[i].src] = true;
    }
    if (!hIncludes[sURI])
    {
      var oNew = document.createElement("script");
      oNew.type = "text/javascript";
      oNew.src = sURI;
      hIncludes[sURI]=true;
      document.getElementsByTagName("head")[0].appendChild(oNew);
    }
  }   
} 

क्रॉस-डोमेन के लिए काम करने के लिए मैं क्या कर सकता हूं? (लोडिंग स्क्रिप्ट से http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStu‌​ff/userjs/aagmfunctions.js)
user2284570

3

बस YUI 3 (पूर्वावलोकन रिलीज में उपलब्ध लेखन के समय) में एक महान विशेषता के बारे में पता चला । आप आसानी से बहुत अधिक कोड के बिना YUI पुस्तकालयों और "बाहरी" मॉड्यूल (जो आप ढूंढ रहे हैं) के लिए निर्भरता सम्मिलित कर सकते हैं: यूलर लोडर

यह फ़ंक्शन के बारे में आपके दूसरे प्रश्न का उत्तर भी देता है जिसे बाहरी मॉड्यूल लोड होने के बाद कहा जाता है।

उदाहरण:

YUI({
    modules: {
        'simple': {
            fullpath: "http://example.com/public/js/simple.js"
        },
        'complicated': {
            fullpath: "http://example.com/public/js/complicated.js"
            requires: ['simple']  // <-- dependency to 'simple' module
        }
    },
    timeout: 10000
}).use('complicated', function(Y, result) {
    // called as soon as 'complicated' is loaded
    if (!result.success) {
        // loading failed, or timeout
        handleError(result.msg);
    } else {
        // call a function that needs 'complicated'
        doSomethingComplicated(...);
    }
});

मेरे लिए पूरी तरह से काम किया है और निर्भरता के प्रबंधन का लाभ है। YUI 2 कैलेंडर के साथ एक उदाहरण के लिए YUI प्रलेखन देखें ।


यह संभवतया आदर्श है सिवाय YUI के कि यह कार्यक्षमता के लिए अश्लील रूप से बड़ा है।
मुदित

3

हाल ही में क्रोम और सफारी में शामिल किए गए एक नए प्रस्तावित ईसीएमए मानक को डायनामिक आयात कहा गया है।

const moduleSpecifier = './dir/someModule.js';

import(moduleSpecifier)
   .then(someModule => someModule.foo()); // executes foo method in someModule

2

जिस तकनीक का हम काम में उपयोग करते हैं वह एक AJAX अनुरोध और फिर वापसी () वापसी का उपयोग करके जावास्क्रिप्ट फ़ाइल का अनुरोध करना है। यदि आप प्रोटोटाइप लाइब्रेरी का उपयोग कर रहे हैं, तो वे अपने Ajax.Request कॉल में इस कार्यक्षमता का समर्थन करते हैं।


2

jquery ने इसे मेरे लिए अपने .append () फ़ंक्शन के साथ हल किया - इसका उपयोग पूरा jquery ui पैकेज को लोड करने के लिए किया

/*
 * FILENAME : project.library.js
 * USAGE    : loads any javascript library
 */
    var dirPath = "../js/";
    var library = ["functions.js","swfobject.js","jquery.jeditable.mini.js","jquery-ui-1.8.8.custom.min.js","ui/jquery.ui.core.min.js","ui/jquery.ui.widget.min.js","ui/jquery.ui.position.min.js","ui/jquery.ui.button.min.js","ui/jquery.ui.mouse.min.js","ui/jquery.ui.dialog.min.js","ui/jquery.effects.core.min.js","ui/jquery.effects.blind.min.js","ui/jquery.effects.fade.min.js","ui/jquery.effects.slide.min.js","ui/jquery.effects.transfer.min.js"];

    for(var script in library){
        $('head').append('<script type="text/javascript" src="' + dirPath + library[script] + '"></script>');
    }

उपयोग करने के लिए - आपके html / php / etc के सिर में jquery.js आयात करने के बाद आप इसे अपनी लाइब्रेरी में पूरी तरह से लोड करने के लिए इस एक फाइल को शामिल करेंगे, जो इसे सिर पर जोड़ देगा ...

<script type="text/javascript" src="project.library.js"></script>

2

इसे अच्छा, छोटा, सरल और बनाए रखें! :]

// 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]);
    }
}

यह कोड केवल एक छोटा कार्यात्मक उदाहरण है जिसे किसी भी (या दिए गए) प्लेटफ़ॉर्म पर पूर्ण समर्थन के लिए अतिरिक्त सुविधा कार्यक्षमता की आवश्यकता हो सकती है।


2

डायनामिक मॉड्यूल आयात फ़ायरफ़ॉक्स 67+ में उतरा

(async () => {
   await import('./synth/BubbleSynth.js')
})()

त्रुटि से निपटने के साथ:

(async () => {
    await import('./synth/BubbleSynth.js').catch((error) => console.log('Loading failed' + error))
})()

यह किसी भी प्रकार के गैर-मॉड्यूल पुस्तकालयों के लिए भी काम करता है, इस मामले में विंडो ऑब्जेक्ट, पुराने तरीके से, लेकिन केवल मांग पर ही देय है, जो अच्छा है।

उदाहरण suncalc.js का उपयोग करते हुए , सर्वर को इस तरह से काम करने में सक्षम होना चाहिए !

(async () => {
 await import('https://cdnjs.cloudflare.com/ajax/libs/suncalc/1.8.0/suncalc.min.js')
 .then(function(){
   let times = SunCalc.getTimes(new Date(), 51.5,-0.1);
   console.log("Golden Hour today in London: " + times.goldenHour.getHours() + ':' + times.sunrise.getMinutes() + ". Take your pics!")
  })
})()

https://caniuse.com/#feat=es6-module-dynamic-import


1

ऐसी स्क्रिप्ट्स हैं जो विशेष रूप से इस उद्देश्य के लिए डिज़ाइन की गई हैं।

yepnope.js को Modernizr में बनाया गया है, और lab.js एक अधिक अनुकूलित (लेकिन कम उपयोगकर्ता के अनुकूल संस्करण) है।

मैं एक बड़े पुस्तकालय जैसे jquery या प्रोटोटाइप के माध्यम से ऐसा करने की अनुमति नहीं दूंगा - क्योंकि स्क्रिप्ट लोडर के प्रमुख लाभों में से स्क्रिप्ट को जल्दी लोड करने की क्षमता है - आपको jquery तक इंतजार नहीं करना चाहिए और आपके सभी प्रमुख तत्वों को लोड होने से पहले यह देखने के लिए कि क्या आप किसी स्क्रिप्ट को डायनामिक रूप से लोड करना चाहते हैं, चेक चला रहा है।


1

मैंने एक साधारण मॉड्यूल लिखा है जो जावास्क्रिप्ट में मॉड्यूल स्क्रिप्ट सहित / आयात करने के काम को स्वचालित करता है। इसे आज़माएं और कृपया कुछ प्रतिक्रिया दें! :) कोड की विस्तृत व्याख्या के लिए इस ब्लॉग पोस्ट को देखें: http://stamat.wordpress.com/2013/04/12/javascript-require-import-include-modules/

var _rmod = _rmod || {}; //require module namespace
_rmod.on_ready_fn_stack = [];
_rmod.libpath = '';
_rmod.imported = {};
_rmod.loading = {
    scripts: {},
    length: 0
};

_rmod.findScriptPath = function(script_name) {
    var script_elems = document.getElementsByTagName('script');
    for (var i = 0; i < script_elems.length; i++) {
        if (script_elems[i].src.endsWith(script_name)) {
            var href = window.location.href;
            href = href.substring(0, href.lastIndexOf('/'));
            var url = script_elems[i].src.substring(0, script_elems[i].length - script_name.length);
            return url.substring(href.length+1, url.length);
        }
    }
    return '';
};

_rmod.libpath = _rmod.findScriptPath('script.js'); //Path of your main script used to mark the root directory of your library, any library


_rmod.injectScript = function(script_name, uri, callback, prepare) {

    if(!prepare)
        prepare(script_name, uri);

    var script_elem = document.createElement('script');
    script_elem.type = 'text/javascript';
    script_elem.title = script_name;
    script_elem.src = uri;
    script_elem.async = true;
    script_elem.defer = false;

    if(!callback)
        script_elem.onload = function() {
            callback(script_name, uri);
        };

    document.getElementsByTagName('head')[0].appendChild(script_elem);
};

_rmod.requirePrepare = function(script_name, uri) {
    _rmod.loading.scripts[script_name] = uri;
    _rmod.loading.length++;
};

_rmod.requireCallback = function(script_name, uri) {
    _rmod.loading.length--;
    delete _rmod.loading.scripts[script_name];
    _rmod.imported[script_name] = uri;

    if(_rmod.loading.length == 0)
        _rmod.onReady();
};

_rmod.onReady = function() {
    if (!_rmod.LOADED) {
        for (var i = 0; i < _rmod.on_ready_fn_stack.length; i++){
            _rmod.on_ready_fn_stack[i]();
        });
        _rmod.LOADED = true;
    }
};

//you can rename based on your liking. I chose require, but it can be called include or anything else that is easy for you to remember or write, except import because it is reserved for future use.
var require = function(script_name) {
    var np = script_name.split('.');
    if (np[np.length-1] === '*') {
        np.pop();
        np.push('_all');
    }

    script_name = np.join('.');
    var uri = _rmod.libpath + np.join('/')+'.js';
    if (!_rmod.loading.scripts.hasOwnProperty(script_name) 
     && !_rmod.imported.hasOwnProperty(script_name)) {
        _rmod.injectScript(script_name, uri, 
            _rmod.requireCallback, 
                _rmod.requirePrepare);
    }
};

var ready = function(fn) {
    _rmod.on_ready_fn_stack.push(fn);
};

// ----- USAGE -----

require('ivar.util.array');
require('ivar.util.string');
require('ivar.net.*');

ready(function(){
    //do something when required scripts are loaded
});

1

मैं इन सभी नमूनों में खो गया हूं, लेकिन आज मुझे अपने मुख्य .js से एक बाहरी .js लोड करने की आवश्यकता थी और मैंने यह किया:

document.write("<script src='https://www.google.com/recaptcha/api.js'></script>");

आप लिंक पर एक नज़र डाल सकते हैं: उत्तर
asmmahmud

1

यहाँ कॉलबैक और IE समर्थन के साथ एक सरल एक है:

function loadScript(url, callback) {

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

    if (script.readyState) { //IE
        script.onreadystatechange = function () {
            if (script.readyState == "loaded" || script.readyState == "complete") {
                script.onreadystatechange = null;
                callback();
            }
        };
    } else { //Others
        script.onload = function () {
            callback();
        };
    }

    script.src = url;
    document.getElementsByTagName("head")[0].appendChild(script);
}

loadScript("https://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js", function () {

     //jQuery loaded
     console.log('jquery loaded');

});

1

मुझे पता है कि इस सवाल के लिए मेरा उत्तर थोड़ा देर से है, लेकिन, यहां www.html5rocks.com में एक शानदार लेख है - स्क्रिप्ट लोडिंग के पानी में गहरे गोता

उस लेख में यह निष्कर्ष निकाला गया है कि ब्राउज़र समर्थन के संबंध में, सामग्री प्रतिपादन को अवरुद्ध किए बिना जावास्क्रिप्ट फ़ाइल को गतिशील रूप से लोड करने का सबसे अच्छा तरीका निम्न प्रकार है:

आपके द्वारा नामित चार लिपियों को ध्यान में रखते हुए आप इसे async = false पर लागूscript1.js, script2.js, script3.js, script4.js कर सकते हैं :

[
  'script1.js',
  'script2.js',
  'script3.js',
  'script4.js'
].forEach(function(src) {
  var script = document.createElement('script');
  script.src = src;
  script.async = false;
  document.head.appendChild(script);
});

अब, Spec का कहना है : एक साथ डाउनलोड करें, सभी डाउनलोड होते ही क्रम में निष्पादित करें।

फ़ायरफ़ॉक्स <3.6, ओपेरा का कहना है: मुझे नहीं पता कि यह "async" बात क्या है, लेकिन यह सिर्फ इतना होता है कि मैं जेएस के माध्यम से जोड़े गए स्क्रिप्ट को निष्पादित कर रहा हूं ताकि वे जोड़ रहे हैं।

Safari 5.0 कहता है: मैं "async" को समझता हूं, लेकिन JS के साथ इसे "झूठे" पर सेट करना नहीं समझता। जैसे ही वे भूमि पर आएँगे, मैं आपकी लिपियों पर अमल करूँगा।

IE <10 कहते हैं: "async" के बारे में कोई विचार नहीं है, लेकिन "onreadystatechange" का उपयोग कर एक समाधान है।

बाकी सब कुछ कहता है: मैं तुम्हारा दोस्त हूं, हम किताब से ऐसा करने जा रहे हैं।

अब, IE <10 समाधान के साथ पूर्ण कोड:

var scripts = [
  'script1.js',
  'script2.js',
  'script3.js',
  'script4.js'
];
var src;
var script;
var pendingScripts = [];
var firstScript = document.scripts[0];

// Watch scripts load in IE
function stateChange() {
  // Execute as many scripts in order as we can
  var pendingScript;
  while (pendingScripts[0] && pendingScripts[0].readyState == 'loaded') {
    pendingScript = pendingScripts.shift();
    // avoid future loading events from this script (eg, if src changes)
    pendingScript.onreadystatechange = null;
    // can't just appendChild, old IE bug if element isn't closed
    firstScript.parentNode.insertBefore(pendingScript, firstScript);
  }
}

// loop through our script urls
while (src = scripts.shift()) {
  if ('async' in firstScript) { // modern browsers
    script = document.createElement('script');
    script.async = false;
    script.src = src;
    document.head.appendChild(script);
  }
  else if (firstScript.readyState) { // IE<10
    // create a script and add it to our todo pile
    script = document.createElement('script');
    pendingScripts.push(script);
    // listen for state changes
    script.onreadystatechange = stateChange;
    // must set src AFTER adding onreadystatechange listener
    // else we’ll miss the loaded event for cached scripts
    script.src = src;
  }
  else { // fall back to defer
    document.write('<script src="' + src + '" defer></'+'script>');
  }
}

कुछ तरकीबें और बाद में, यह 362 बाइट्स है

!function(e,t,r){function n(){for(;d[0]&&"loaded"==d[0][f];)c=d.shift(),c[o]=!i.parentNode.insertBefore(c,i)}for(var s,a,c,d=[],i=e.scripts[0],o="onreadystatechange",f="readyState";s=r.shift();)a=e.createElement(t),"async"in i?(a.async=!1,e.head.appendChild(a)):i[f]?(d.push(a),a[o]=n):e.write("<"+t+' src="'+s+'" defer></'+t+">"),a.src=s}(document,"script",[
  "//other-domain.com/1.js",
  "2.js"
])

मैं ऊपर दृष्टिकोण का उपयोग कर रहा हूँ यह क्रोम और फ़ायरफ़ॉक्स में ठीक काम कर रहा है, लेकिन IE ब्राउज़र में समस्याओं का सामना कर रहा है
श्री रोशन

1

कुछ इस तरह...

<script>
     $(document).ready(function() {
          $('body').append('<script src="https://maps.googleapis.com/maps/api/js?key=KEY&libraries=places&callback=getCurrentPickupLocation" async defer><\/script>');
     });
</script>

1

जेएस फ़ाइलों को लोड करने के लिए एक फ़ंक्शन के लिए यहां एक सरल उदाहरण है। प्रासंगिक बिंदु:

  • आपको jQuery की आवश्यकता नहीं है, इसलिए आप इसे शुरू में jQuery.js फ़ाइल को लोड करने के लिए भी उपयोग कर सकते हैं
  • यह कॉलबैक के साथ async है
  • यह सुनिश्चित करता है कि यह केवल एक बार लोड हो, क्योंकि यह लोड किए गए url के रिकॉर्ड के साथ संलग्न रहता है, इस प्रकार नेटवर्क के उपयोग से बचता है
  • jQuery के विपरीत $.ajaxया $.getScriptआप गैर-उपयोग कर सकते हैं, इस प्रकार CSP के साथ समस्याएँ हल कर सकते हैं unsafe-inline। बस संपत्ति का उपयोग करेंscript.nonce
var getScriptOnce = function() {

    var scriptArray = []; //array of urls (closure)

    //function to defer loading of script
    return function (url, callback){
        //the array doesn't have such url
        if (scriptArray.indexOf(url) === -1){

            var script=document.createElement('script');
            script.src=url;
            var head=document.getElementsByTagName('head')[0],
                done=false;

            script.onload=script.onreadystatechange = function(){
                if ( !done && (!this.readyState || this.readyState == 'loaded' || this.readyState == 'complete') ) {
                    done=true;
                    if (typeof callback === 'function') {
                        callback();
                    }
                    script.onload = script.onreadystatechange = null;
                    head.removeChild(script);

                    scriptArray.push(url);
                }
            };

            head.appendChild(script);
        }
    };
}();

अब आप इसे बस द्वारा उपयोग करें

getScriptOnce("url_of_your_JS_file.js");

1

एक बेतुका वन-लाइनर, उन लोगों के लिए जो सोचते हैं कि js लाइब्रेरी लोड करना कोड की एक से अधिक पंक्ति नहीं लेना चाहिए: P

await new Promise((resolve, reject) => {let js = document.createElement("script"); js.src="mylibrary.js"; js.onload=resolve; js.onerror=reject; document.body.appendChild(js)});

जाहिर है यदि आप जिस स्क्रिप्ट को आयात करना चाहते हैं वह एक मॉड्यूल है, तो आप import(...)फ़ंक्शन का उपयोग कर सकते हैं ।


1

वादों के साथ आप इसे इस तरह सरल बना सकते हैं। लोडर समारोह:

  const loadCDN = src =>
    new Promise((resolve, reject) => {
      if (document.querySelector(`head > script[src="${src}"]`) !== null) return resolve()
      const script = document.createElement("script")
      script.src = src
      script.async = true
      document.head.appendChild(script)
      script.onload = resolve
      script.onerror = reject
    })

उपयोग (async / प्रतीक्षा):

await loadCDN("https://.../script.js")

उपयोग (वादा):

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

ध्यान दें: एक समान समाधान था, लेकिन यह जाँच नहीं करता है कि स्क्रिप्ट पहले से लोड है और स्क्रिप्ट को हर बार लोड करता है। यह एक src संपत्ति की जाँच करता है।


0

जावास्क्रिप्ट, प्रोटोटाइप, YUI जैसी सभी प्रमुख जावास्क्रिप्ट पुस्तकालयों में स्क्रिप्ट फ़ाइलों को लोड करने के लिए समर्थन है। उदाहरण के लिए, YUI में, कोर लोड करने के बाद आप कैलेंडर नियंत्रण को लोड करने के लिए निम्न कार्य कर सकते हैं

var loader = new YAHOO.util.YUILoader({

    require: ['calendar'], // what components?

    base: '../../build/',//where do they live?

    //filter: "DEBUG",  //use debug versions (or apply some
                        //some other filter?

    //loadOptional: true, //load all optional dependencies?

    //onSuccess is the function that YUI Loader
    //should call when all components are successfully loaded.
    onSuccess: function() {
        //Once the YUI Calendar Control and dependencies are on
        //the page, we'll verify that our target container is 
        //available in the DOM and then instantiate a default
        //calendar into it:
        YAHOO.util.Event.onAvailable("calendar_container", function() {
            var myCal = new YAHOO.widget.Calendar("mycal_id", "calendar_container");
            myCal.render();
        })
     },

    // should a failure occur, the onFailure function will be executed
    onFailure: function(o) {
        alert("error: " + YAHOO.lang.dump(o));
    }

 });

// Calculate the dependency and insert the required scripts and css resources
// into the document
loader.insert();

आप लिंक पर एक नज़र डाल सकते हैं: उत्तर
asmmahmud

0

मैंने उपरोक्त कुछ पोस्ट को काम करने के उदाहरण के साथ ट्विक किया है। यहाँ हम एक ही एरे में css और js भी दे सकते हैं।

$(document).ready(function(){

if (Array.prototype.contains === undefined) {
Array.prototype.contains = function (obj) {
    var i = this.length;
    while (i--) { if (this[i] === obj) return true; }
    return false;
};
};

/* define object that will wrap our logic */
var jsScriptCssLoader = {

jsExpr : new RegExp( "js$", "i" ),
cssExpr : new RegExp( "css$", "i" ),
loadedFiles: [],

loadFile: function (cssJsFileArray) {
    var self = this;
    // remove duplicates with in array
    cssJsFileArray.filter((item,index)=>cssJsFileArray.indexOf(item)==index)
    var loadedFileArray = this.loadedFiles;
    $.each(cssJsFileArray, function( index, url ) {
            // if multiple arrays are loaded the check the uniqueness
            if (loadedFileArray.contains(url)) return;
            if( self.jsExpr.test( url ) ){
                $.get(url, function(data) {
                    self.addScript(data);
                });

            }else if( self.cssExpr.test( url ) ){
                $.get(url, function(data) {
                    self.addCss(data);
                });
            }

            self.loadedFiles.push(url);
    });

    // don't load twice accross different arrays

},
addScript: function (code) {
    var oNew = document.createElement("script");
    oNew.type = "text/javascript";
    oNew.textContent = code;
    document.getElementsByTagName("head")[0].appendChild(oNew);
},
addCss: function (code) {
    var oNew = document.createElement("style");
    oNew.textContent = code;
    document.getElementsByTagName("head")[0].appendChild(oNew);
}

};


//jsScriptCssLoader.loadFile(["css/1.css","css/2.css","css/3.css"]);
jsScriptCssLoader.loadFile(["js/common/1.js","js/2.js","js/common/file/fileReader.js"]);
});

0

उन लोगों के लिए, जो वन-लाइनर्स से प्यार करते हैं:

import('./myscript.js');

संभावना है कि आपको एक त्रुटि मिल सकती है, जैसे:

मूल ' http://127.0.0.1 ' से ' http: //..../myscript.js ' पर स्क्रिप्ट तक पहुंच को CorS नीति द्वारा अवरोधित किया गया है: कोई 'Access-Control-Allow-Origin' हेडर पर मौजूद नहीं है अनुरोधित संसाधन।

किस स्थिति में, आप निम्न कर सकते हैं:

fetch('myscript.js').then(r => r.text()).then(t => new Function(t)());
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.