JQuery $ .getScript () पद्धति का उपयोग करके कई js फ़ाइलों को कैसे शामिल करें


127

मैं अपने js फ़ाइल में जावास्क्रिप्ट फ़ाइलों को गतिशील रूप से शामिल करने की कोशिश कर रहा हूं। मैंने इसके बारे में कुछ शोध किया और पाया कि jQuery $ .getScript () विधि एक वांछित तरीका है।

// jQuery
$.getScript('/path/to/imported/script.js', function()
{
    // script is now loaded and executed.
    // put your dependent JS here.
    // what if the JS code is dependent on multiple JS files? 
});

लेकिन मैं सोच रहा हूं कि क्या यह विधि एक समय में कई स्क्रिप्ट लोड कर सकती है? मैं यह क्यों पूछ रहा हूं क्योंकि कभी-कभी मेरी जावास्क्रिप्ट फाइल एक से अधिक js फाइलों पर निर्भर करती है।

पहले ही, आपका बहुत धन्यवाद।

जवाबों:


315

उत्तर है

आप getScript()सभी लिपियों के लोड होने तक वेट का उपयोग कर सकते हैं, जैसे कुछ:

$.when(
    $.getScript( "/mypath/myscript1.js" ),
    $.getScript( "/mypath/myscript2.js" ),
    $.getScript( "/mypath/myscript3.js" ),
    $.Deferred(function( deferred ){
        $( deferred.resolve );
    })
).done(function(){
    
    //place your code here, the scripts are all loaded
    
});

बेला

उत्तर दें FIDDLE

उपरोक्त कोड में, एक डिफर्ड को जोड़ना और इसे अंदर हल करना $()किसी jQuery कॉल के अंदर किसी अन्य फ़ंक्शन को रखने की तरह है, जैसे $(func), यह वैसा ही है

$(function() { func(); });

यानी यह इंतजार कर रहा है डोम के लिए तैयार होने के लिए है, तो ऊपर के उदाहरण में $.whenसभी स्क्रिप्ट लोड करने के लिए की प्रतीक्षा करता और डोम के लिए की वजह से तैयार होने के लिए$.Deferred कॉल डोम में जो हल तैयार कॉलबैक।


अधिक सामान्य उपयोग के लिए, एक आसान कार्य

एक उपयोगिता फ़ंक्शन जो किसी भी स्क्रिप्ट को स्वीकार करता है उसे इस तरह बनाया जा सकता है:

$.getMultiScripts = function(arr, path) {
    var _arr = $.map(arr, function(scr) {
        return $.getScript( (path||"") + scr );
    });
        
    _arr.push($.Deferred(function( deferred ){
        $( deferred.resolve );
    }));
        
    return $.when.apply($, _arr);
}

जिसका उपयोग इस तरह किया जा सकता है

var script_arr = [
    'myscript1.js', 
    'myscript2.js', 
    'myscript3.js'
];

$.getMultiScripts(script_arr, '/mypath/').done(function() {
    // all scripts loaded
});

जहां पथ सभी लिपियों के लिए पूर्व निर्धारित किया जाएगा, और वैकल्पिक भी है, जिसका अर्थ है कि यदि सरणी में पूर्ण URL है तो यह भी कर सकता है, और सभी को एक साथ छोड़ दें

$.getMultiScripts(script_arr).done(function() { ...

तर्क, त्रुटियाँ आदि।

एक तरफ के रूप में, ध्यान दें कि doneकॉलबैक में स्क्रिप्ट में पारित किए गए मिलान के कई तर्क होंगे, प्रत्येक तर्क एक सरणी का प्रतिनिधित्व करता है जिसमें प्रतिक्रिया होती है

$.getMultiScripts(script_arr).done(function(response1, response2, response3) { ...

जहां प्रत्येक सरणी में कुछ ऐसा होगा [content_of_file_loaded, status, xhr_object]। हम आम तौर पर उन तर्कों का उपयोग करने की आवश्यकता नहीं है क्योंकि लिपियों को वैसे भी स्वचालित रूप से लोड किया जाएगा, और अधिकांश समयdone कॉलबैक यह है कि हम वास्तव में जानते हैं कि सभी स्क्रिप्ट लोड हो चुकी हैं, मैं इसे पूर्णता के लिए जोड़ रहा हूं। , और दुर्लभ अवसरों के लिए जब लोड की गई फ़ाइल से वास्तविक पाठ को एक्सेस करने की आवश्यकता होती है, या जब किसी को प्रत्येक XHR ऑब्जेक्ट या कुछ समान तक पहुंचने की आवश्यकता होती है।

इसके अलावा, यदि कोई स्क्रिप्ट लोड करने में विफल रहती है, तो असफल हैंडलर को बुलाया जाएगा, और बाद की स्क्रिप्ट लोड नहीं की जाएंगी

$.getMultiScripts(script_arr).done(function() {
     // all done
}).fail(function(error) {
     // one or more scripts failed to load
}).always(function() {
     // always called, both on success and error
});

11
महान जवाब के लिए धन्यवाद। क्या आप मुझे समझाएंगे कि $.Deferred(function( deferred ){$( deferred.resolve );})यहाँ क्यों जोड़ा गया है?
sozhen

11
आस्थगित वस्तु का वास्तव में उस वादे से कोई लेना-देना नहीं है जो आपको कई लिपियों को लोड करने और एक फ़ंक्शन करने की अनुमति देता है जब वे सभी काम करते हैं। यह देखने के लिए जाँच करता है कि क्या $ () तैयार है, और यदि यह है, तो हल करता है, दूसरे शब्दों में, यह देखने के लिए जाँचता है कि DOM किसी भी कोड को निष्पादित करने से पहले तैयार है, बहुत दस्तावेज की तरह। पहले से ही होगा, और मुझे संलग्न करने का एक अच्छा उदाहरण मिला ऑनलाइनस्क्रिप्ट प्राप्त करने का वादा करता है जिसके पास कोड में स्थगित DOM तैयार कार्यक्षमता थी, और बस इसे एक अच्छा विचार की तरह लगने का फैसला किया।
एडीनो

4
ऐसा इसलिए है क्योंकि ajax में कैशिंग को jQuery में डिफ़ॉल्ट रूप से बंद कर दिया जाता है, इसे चालू करने के लिए और क्लेरिस्ट्रिंग को हटाने के लिए: $.ajaxSetup({ cache: true });लेकिन यह भी अन्य ajax कॉल को प्रभावित कर सकता है जिसे आप कैश नहीं करना चाहते हैं, डॉक्स में इस पर और भी बहुत कुछ है गेटस्क्रिप्ट , और कैश्डस्क्रिप्ट नामक कैश्ड गेटस्क्रिप्ट फ़ंक्शन बनाने पर भी थोड़ा सा काम करता है।
एडेनो

3
देर से स्वीकृति के लिए क्षमा करें। कभी-कभी आपका तरीका अभी भी काफी काम नहीं कर रहा है। निश्चित नहीं है कि इसका क्या कारण है। मैं एक बार में चार स्क्रिप्ट फ़ाइलों को शामिल करने की कोशिश कर रहा हूं। $.when($.getScript(scriptSrc_1), $.getScript(scriptSrc_2), $.getScript(scriptSrc_3), $.getScript(scriptSrc_4), $.Deferred(function(deferred) { $(deferred.resolve); })).done(function() { ... })
15

1
जो कोई भी इस कार्य को प्राप्त नहीं कर सकता है, वह सुनिश्चित करें कि आपकी जेएस फाइलों में कोई पार्स त्रुटियां नहीं हैं अर्थात परीक्षण करें कि वे ठीक से <स्क्रिप्ट> टैग में लोड हैं। jQuery.getScript () इन त्रुटियों को एक असफल भार मानेंगे और .fail () को .done () के बजाय कहा जाएगा। @SongtaoZ।
चंद्रमा प्रिज्म शक्ति

29

मैंने कई स्क्रिप्ट को समानांतर में लोड करने के लिए एक साधारण फ़ंक्शन लागू किया:

समारोह

function getScripts(scripts, callback) {
    var progress = 0;
    scripts.forEach(function(script) { 
        $.getScript(script, function () {
            if (++progress == scripts.length) callback();
        }); 
    });
}

प्रयोग

getScripts(["script1.js", "script2.js"], function () {
    // do something...
});

1
किसी कारण के लिए, यह एक एमानुएल से बेहतर काम करता है। यह बहुत पारदर्शी कार्यान्वयन है।
टोड

@ शतनाम धन्यवाद :)! शीर्ष उत्तर कुछ लोगों (मेरे सहित) के लिए काम नहीं करता है इसलिए मैंने यह समाधान पोस्ट किया है। और यह बहुत सरल दिखता है।
आंद्रेई

10

पिछले एक की कॉलबैक में निम्न आवश्यक स्क्रिप्ट लोड करें:

$.getScript('scripta.js', function()
{
   $.getScript('scriptb.js', function()
   {
       // run script that depends on scripta.js and scriptb.js
   });
});

1
निश्चित रूप से यह विधि क्रमिक रूप से लिपियों को डाउनलोड करेगी, अंतिम निष्पादन के समय को धीमा कर देगी?
जिमो

1
सही, @ जिंबो - निष्पक्ष होना; यह समय से पहले निष्पादन के लिए बेहतर है। :)
एलिस्टेयर

झरने से लगभग हमेशा बचना चाहिए। getScript एक वादा के साथ आता है ... आप जब वादों को हल करने के लिए सुनने के लिए $ का उपयोग कर सकते हैं।
रूई

@ रोई और किसी और को: यदि मुझे विशिष्ट विवरण में लोड करने के लिए स्क्रिप्ट की आवश्यकता है, तो क्या, मौलिक रूप से बोलना, इस दृष्टिकोण के साथ गलत है? और क्या लाभ, इसलिए, वादा विकल्प लाता है?
इफदी ओकोंकवो

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

9

कभी-कभी एक विशिष्ट क्रम में स्क्रिप्ट को लोड करना आवश्यक होता है। उदाहरण के लिए jQuery को jQuery UI से पहले लोड किया जाना चाहिए। इस पृष्ठ के अधिकांश उदाहरण समानांतर (अतुल्यकालिक) में लिपियों को लोड करते हैं जिसका अर्थ है कि निष्पादन का आदेश गारंटी नहीं है। आदेश के बिना, स्क्रिप्ट yजो निर्भर करती हैx क्या दोनों सफलतापूर्वक लोड होने पर गलत क्रम में टूट सकते हैं।

मैं एक हाइब्रिड दृष्टिकोण का प्रस्ताव करता हूं जो आश्रित लिपियों के क्रमिक लोडिंग + वैकल्पिक समानांतर लोडिंग + आस्थगित वस्तुओं की अनुमति देता है :

/*
 * loads scripts one-by-one using recursion
 * returns jQuery.Deferred
 */
function loadScripts(scripts) {
  var deferred = jQuery.Deferred();

  function loadScript(i) {
    if (i < scripts.length) {
      jQuery.ajax({
        url: scripts[i],
        dataType: "script",
        cache: true,
        success: function() {
          loadScript(i + 1);
        }
      });
    } else {
      deferred.resolve();
    }
  }
  loadScript(0);

  return deferred;
}

/*
 * example using serial and parallel download together
 */

// queue #1 - jquery ui and jquery ui i18n files
var d1 = loadScripts([
  "https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.1/jquery-ui.min.js",
  "https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.1/i18n/jquery-ui-i18n.min.js"
]).done(function() {
  jQuery("#datepicker1").datepicker(jQuery.datepicker.regional.fr);
});

// queue #2 - jquery cycle2 plugin and tile effect plugin
var d2 = loadScripts([
  "https://cdn.rawgit.com/malsup/cycle2/2.1.6/build/jquery.cycle2.min.js",
  "https://cdn.rawgit.com/malsup/cycle2/2.1.6/build/plugin/jquery.cycle2.tile.min.js"

]).done(function() {
  jQuery("#slideshow1").cycle({
    fx: "tileBlind",
    log: false
  });
});

// trigger a callback when all queues are complete
jQuery.when(d1, d2).done(function() {
  console.log("All scripts loaded");
});
@import url("https://ajax.googleapis.com/ajax/libs/jqueryui/1.11.4/themes/blitzer/jquery-ui.min.css");

#slideshow1 {
  position: relative;
  z-index: 1;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>

<p><input id="datepicker1"></p>

<div id="slideshow1">
  <img src="https://dummyimage.com/300x100/FC0/000">
  <img src="https://dummyimage.com/300x100/0CF/000">
  <img src="https://dummyimage.com/300x100/CF0/000">
</div>

दोनों कतारों में लिपियों को समानांतर में डाउनलोड किया जाएगा, हालांकि, प्रत्येक कतार में स्क्रिप्ट क्रम में डाउनलोड करेगा, आदेशित निष्पादन को सुनिश्चित करेगा। झरना चार्ट:

लिपियों का झरना चार्ट


एक बार स्क्रिप्ट को मेमोरी में लोड करने के बाद हमें HTML में स्क्रिप्ट टैग जोड़ने की आवश्यकता नहीं है?
अंकुश जैन

4

Yepnope.js या Modernizr (जिसमें yepnope.js शामिल हैं) का उपयोग करेंModernizr.load

अपडेट करें

बस फॉलो अप करने के लिए, यहाँ पर जो आपने वर्तमान में yepnope का उपयोग किया है, उसका एक अच्छा समकक्ष है, जो कई लिपियों पर निर्भरता दिखाता है:

yepnope({
  load: ['script1.js', 'script2.js', 'script3.js'],
  complete: function () {
      // all the scripts have loaded, do whatever you want here
  }
});

धन्यवाद। क्या मैं yepnope.injectJs( scriptSource )अपनी javascript फ़ाइल की शुरुआत में उसी तरह कई का उपयोग कर सकता हूं जैसे <script>html फ़ाइल में टैग शामिल हैं ?
21

यह नया है, और ईमानदारी से, मुझे समझ नहीं आता कि इसकी आवश्यकता क्यों है। हाल के परिवर्तनों की सूची से थोड़ा नीचे दस्तावेज़ का पालन करें और आप अधिक पारंपरिक उपयोग देखेंगे।
क्रिस प्रैट

+1; ध्यान देने योग्य है कि यह ठीक से निर्भरता का प्रबंधन करता है (यानी एक ही स्क्रिप्ट को दो बार लोड नहीं करेगा) इसके विपरीत $.getScript। यह बड़ा सौदा है।
ov

yepnope.js अब पदावनत हो गया है
स्टेपहान

4

मैं मल्टी स्क्रिप्ट लोडिंग के साथ कई मुद्दों में भाग गया (कम से कम क्रोम में) एक ही डोमेन स्क्रिप्ट को लोड करने वाली स्क्रिप्ट का लोडिंग वास्तव में अजाक्स द्वारा सफलतापूर्वक लोड किए जाने के बाद नहीं चल रहा था जहां क्रॉस डोमेन पूरी तरह से ठीक काम करता है! :(

मूल प्रश्न का चयनित उत्तर मज़बूती से काम नहीं करता है।

कई पुनरावृत्तियों के बाद यहाँ getScript (s) के लिए मेरा अंतिम उत्तर है और एसिंक्रोनस रूप से एकाधिक स्क्रिप्ट लोड करना एक विशिष्ट सख्त क्रम में स्क्रिप्ट लोड किए गए कॉलबैक विकल्प और समग्र कॉलबैक के साथ पूरा होने पर, jQuery 2.1+ और क्रोम, फ़ायरफ़ॉक्स के आधुनिक संस्करणों में परीक्षण किया गया। इंटरनेट एक्सप्लोरर को छोड़ दिया।

मेरा परीक्षण मामला एक THREE.JS वेबलॉग रेंडर के लिए फ़ाइलें लोड कर रहा था, तब रेंडर स्क्रिप्ट को शुरू करना जब THREE वैश्विक एक अनाम चेक कॉल के लिए पारित अंतराल चेक का उपयोग करके उपलब्ध हो गया।

प्रोटोटाइप फ़ंक्शन (getScripts)

function getScripts( scripts, onScript, onComplete )
{
    this.async = true;
    this.cache = false;
    this.data = null;
    this.complete = function () { $.scriptHandler.loaded(); };
    this.scripts = scripts;
    this.onScript = onScript;
    this.onComplete = onComplete;
    this.total = scripts.length;
    this.progress = 0;
};

getScripts.prototype.fetch = function() {
    $.scriptHandler = this;
    var src = this.scripts[ this.progress ];
    console.log('%cFetching %s','color:#ffbc2e;', src);

    $.ajax({
        crossDomain:true,
        async:this.async,
        cache:this.cache,
        type:'GET',
        url: src,
        data:this.data,
        statusCode: {
            200: this.complete
        },
        dataType:'script'
    });
};

getScripts.prototype.loaded = function () {
    this.progress++;
    if( this.progress >= this.total ) {
        if(this.onComplete) this.onComplete();
    } else {
        this.fetch();
    };
    if(this.onScript) this.onScript();
};

कैसे इस्तेमाल करे

var scripts = new getScripts(
    ['script1.js','script2.js','script.js'],
    function() {
        /* Optional - Executed each time a script has loaded (Use for Progress updates?) */
    },
    function () {
        /* Optional - Executed when the entire list of scripts has been loaded */
    }
);
scripts.fetch();

फ़ंक्शन ऐसा है जैसा कि मैंने पाया है कि मैंने Deferred (अब पदावनत?) का उपयोग किया है, जब, सफलता और पूर्णता मेरे परीक्षणों में 100% विश्वसनीय नहीं है!?, इसलिए उदाहरण के लिए यह फ़ंक्शन और स्टेटसकोड का उपयोग।

यदि आप चाहें तो आप त्रुटि / असफल हैंडलिंग व्यवहार में जोड़ना चाह सकते हैं।


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

2

आप $.whenनिम्नलिखित फ़ंक्शन आज़माकर -method का उपयोग कर सकते हैं :

function loadScripts(scripts) {
  scripts.forEach(function (item, i) {
    item = $.getScript(item);
  });
  return $.when.apply($, scripts);
}

इस फ़ंक्शन का उपयोग इस तरह किया जाएगा:

loadScripts(['path/to/script-a.js', 'path/to/script-b.js']).done(function (respA, respB) {
    // both scripts are loaded; do something funny
});

यह वादा करने और ओवरहेड का न्यूनतम उपयोग करने का तरीका है।


क्या यह सुनिश्चित करता है कि स्क्रिप्ट अनुक्रम में भरी हुई हैं?
साइबरमोंक

2

शानदार जवाब, एडेनेओ।

मुझे यह पता लगाने में थोड़ा समय लगा कि आपके उत्तर को और अधिक सामान्य कैसे बनाया जाए (ताकि मैं कोड-परिभाषित स्क्रिप्ट का एक भार लोड कर सकूं)। सभी स्क्रिप्ट्स को लोड और निष्पादित करने पर कॉलबैक को कॉल किया जाता है। यहाँ मेरा समाधान है:

    function loadMultipleScripts(scripts, callback){
        var array = [];

        scripts.forEach(function(script){
            array.push($.getScript( script ))
        });

        array.push($.Deferred(function( deferred ){
                    $( deferred.resolve );
                }));

        $.when.apply($, array).done(function(){
                if (callback){
                    callback();
                }
            });
    }

2

स्क्रिप्ट को Async = false के साथ जोड़ें

यहाँ एक अलग, लेकिन सुपर सरल दृष्टिकोण है। कई लिपियों को लोड करने के लिए आप उन्हें केवल शरीर में जोड़ सकते हैं।

  • उन्हें अतुल्यकालिक रूप से लोड करता है, क्योंकि यह है कि ब्राउज़र पृष्ठ लोडिंग को कैसे अनुकूलित करते हैं
  • स्क्रिप्ट को क्रम में निष्पादित करता है, क्योंकि ब्राउज़र HTML टैग को पार्स करता है
  • कॉलबैक की कोई आवश्यकता नहीं है, क्योंकि स्क्रिप्ट को क्रम में निष्पादित किया जाता है। बस एक और स्क्रिप्ट जोड़ें, और इसे अन्य स्क्रिप्ट के बाद निष्पादित किया जाएगा

यहाँ अधिक जानकारी: https://www.html5rocks.com/en/tutorials/speed/script-loading/

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

1

आप जो देख रहे हैं वह एक एएमडी कंप्लेंट लोडर है (जैसे आवश्यकता.जेएस)।

http://requirejs.org/

http://requirejs.org/docs/whyamd.html

यदि आप इसे देखते हैं तो कई अच्छे स्रोत हैं। मूल रूप से यह आपको कोड के एक मॉड्यूल को परिभाषित करने की अनुमति देता है, और यदि यह कोड के अन्य मॉड्यूल पर निर्भर है, तो यह तब तक इंतजार करेगा जब तक कि उन मॉड्यूल को चलाने से पहले डाउनलोड करना समाप्त न हो जाए। इस तरह आप 10 मॉड्यूलों को असिंक्रोनस रूप से लोड कर सकते हैं और कोई समस्या नहीं होनी चाहिए, भले ही एक दूसरे को चलाने के लिए कुछ पर निर्भर हो।


1

यह फ़ंक्शन सुनिश्चित करेगा कि निर्भरता फ़ाइल पूरी तरह से लोड होने के बाद एक फ़ाइल लोड की गई है। आपको बस अन्य फ़ाइलों पर निर्भरता को ध्यान में रखते हुए फाइलों को एक अनुक्रम में प्रदान करना होगा।

function loadFiles(files, fn) {
    if (!files.length) {
        files = [];
    }
    var head = document.head || document.getElementsByTagName('head')[0];

    function loadFile(index) {
        if (files.length > index) {
            var fileref = document.createElement('script');
            fileref.setAttribute("type", "text/javascript");
            fileref.setAttribute("src", files[index]);
            head.appendChild(fileref);
            index = index + 1;
            // Used to call a callback function
            fileref.onload = function () {
                loadFile(index);
            }
        } else if(fn){
            fn();
        }
    }
    loadFile(0);
}

शायद स्वीकृत उत्तर से बेहतर है क्योंकि यह फाइलों को क्रम में लोड करता है। अगर script2 को script1 को लोड करने की आवश्यकता है तो ऑर्डर करना आवश्यक है।
सलमान ए

1

यह मेरे लिए काम करता है:

function getScripts(scripts) {
    var prArr = [];
    scripts.forEach(function(script) { 
        (function(script){
            prArr .push(new Promise(function(resolve){
                $.getScript(script, function () {
                    resolve();
                });
            }));
        })(script);
    });
    return Promise.all(prArr, function(){
        return true;
    });
}

और इसका उपयोग करें:

var jsarr = ['script1.js','script2.js'];
getScripts(jsarr).then(function(){
...
});

1

यहाँ Maciej Sawicki एक का उपयोग कर और Promiseकॉलबैक के रूप में लागू करने का जवाब है :

function loadScripts(urls, path) {
    return new Promise(function(resolve) {
        urls.forEach(function(src, i) {

            let script = document.createElement('script');        
            script.type = 'text/javascript';
            script.src = (path || "") + src;
            script.async = false;

            // If last script, bind the callback event to resolve
            if(i == urls.length-1) {                    
                // Multiple binding for browser compatibility
                script.onreadystatechange = resolve;
                script.onload = resolve;
            }

            // Fire the loading
            document.body.appendChild(script);
        });
    });
}

उपयोग:

let JSDependencies = ["jquery.js",
                      "LibraryNeedingJquery.js",
                      "ParametersNeedingLibrary.js"];

loadScripts(JSDependencies,'JavaScript/').then(taskNeedingParameters);

सभी जावास्क्रिप्ट फ़ाइलों को जितनी जल्दी हो सके डाउनलोड किया जाता है और दिए गए क्रम में निष्पादित किया जाता है। फिर taskNeedingParametersकहा जाता है।


0

ऊपर एंड्रयू मार्क न्यूटन के व्यापक उत्तर का छोटा संस्करण। यह एक सफलता के लिए स्थिति कोड की जांच नहीं करता है, जिसे आपको अपरिभाषित UI व्यवहार से बचने के लिए करना चाहिए।

यह एक कष्टप्रद प्रणाली के लिए था, जहाँ मैं jQuery की गारंटी दे सकता था, लेकिन इसमें कोई अन्य शामिल नहीं था, इसलिए मैं चाहता था कि एक ऐसी तकनीक को पर्याप्त रूप से तैयार किया जाए जिसे बाहरी स्क्रिप्ट में शामिल न किया जा सके। (आप पहले "पुनरावर्ती" कॉल के सूचकांक 0 को पारित करके इसे और भी कम बना सकते हैं लेकिन शैली की आदतों के बल ने मुझे चीनी मिलाया)।

मैं एक मॉड्यूल नाम के लिए निर्भरता सूची भी प्रदान कर रहा हूं, इसलिए इस ब्लॉक को "मॉड्यूल 1" की आवश्यकता के अनुसार कहीं भी शामिल किया जा सकता है और स्क्रिप्ट और आश्रित आरंभीकरण को केवल एक बार शामिल किया जाएगा / आप indexकॉलबैक में लॉग इन कर सकते हैं और एक एकल आदेश देख सकते हैं AJAX अनुरोधों के चलने का सेट)

if(typeof(__loaders) == 'undefined') __loaders = {};

if(typeof(__loaders.module1) == 'undefined')
{
    __loaders.module1 = false;

    var dependencies = [];

    dependencies.push('/scripts/loadmefirst.js');
    dependencies.push('/scripts/loadmenext.js');
    dependencies.push('/scripts/loadmelast.js');

    var getScriptChain  = function(chain, index)        
    {
        if(typeof(index) == 'undefined')
            index = 0;

        $.getScript(chain[index], 
            function()
            {
                if(index == chain.length - 1)
                {
                    __loaders.module1 = true;

                    /* !!!
                        Do your initialization of dependent stuff here 
                    !!! */
                }
                else 
                    getScriptChain(chain, index + 1);
            }
        );
    };

    getScriptChain(dependencies);       
}

0

वहाँ एक प्लगइन है जो jQuery के गेटस्क्रिप्ट विधि का विस्तार करता है। अतुल्यकालिक और तुल्यकालिक लोडिंग के लिए अनुमति देता है और jQuery के कैशिंग तंत्र का उपयोग करता है। पूरा खुलासा, मैंने यह लिखा है। अगर आपको बेहतर तरीका मिले तो कृपया बेझिझक योगदान दें।

https://github.com/hudsonfoo/jquery-getscripts


0

लोड n स्क्रिप्ट एक के बाद एक (उपयोगी अगर उदाहरण 2 फ़ाइल के लिए 1 एक की जरूरत है):

(function self(a,cb,i){
    i = i || 0; 
    cb = cb || function(){};    
    if(i==a.length)return cb();
    $.getScript(a[i++],self.bind(0,a,cb,i));                    
})(['list','of','script','urls'],function(){console.log('done')});

0

ऊपर दिए गए @adeneo के उत्तर के आधार पर: css और js फ़ाइलों को लोड करना दोनों को संयोजित करना

सुधार के लिए कोई सुझाव ??

// Usage
//$.getMultiResources(['script-1.js','style-1.css'], 'assets/somePath/')
//  .done(function () {})
//  .fail(function (error) {})
//  .always(function () {});

(function ($) {
  $.getMultiResources = function (arr, pathOptional, cache) {
    cache = (typeof cache === 'undefined') ? true : cache;
    var _arr = $.map(arr, function (src) {
      var srcpath = (pathOptional || '') + src;
      if (/.css$/i.test(srcpath)) {
        return $.ajax({
          type: 'GET',
          url: srcpath,
          dataType: 'text',
          cache: cache,
          success: function () {
            $('<link>', {
              rel: 'stylesheet',
              type: 'text/css',
              'href': srcpath
            }).appendTo('head');
          }
        });

      } else {
        return $.ajax({
          type: 'GET',
          url: srcpath,
          dataType: 'script',
          cache: cache
        });
      }
    });
    //
    _arr.push($.Deferred(function (deferred) {
      $(deferred.resolve);
    }));
    //
    return $.when.apply($, _arr);
  };
})(jQuery);

0

आप इसे पुनरावर्ती का उपयोग करके आज़मा सकते हैं। यह उन्हें सिंक में डाउनलोड करेगा, एक के बाद एक जब तक वह पूरी सूची को डाउनलोड नहीं करता।

var queue = ['url/links/go/here'];

ProcessScripts(function() { // All done do what ever you want

}, 0);

function ProcessScripts(cb, index) {
    getScript(queue[index], function() {
        index++;
        if (index === queue.length) { // Reached the end
            cb();
        } else {
            return ProcessScripts(cb, index);
        }
    });
}

function getScript(script, callback) {
    $.getScript(script, function() {
        callback();
    });
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.