मैं एक जावास्क्रिप्ट फाइल को दूसरी जावास्क्रिप्ट फाइल में कैसे शामिल करूं?


5192

क्या जावास्क्रिप्ट के समान कुछ है @import सीएसएस है जो आपको एक जावास्क्रिप्ट फाइल को दूसरी जावास्क्रिप्ट फाइल के अंदर शामिल करने की अनुमति देता है?



82
@ डैनियल, मैं AJAX कॉल का उपयोग नहीं करना चाहता।
एलेक स्मार्ट

13
आयातित फ़ाइल को दूसरे के सामने क्यों घोषित नहीं करना चाहिए, जिसके लिए उसे केवल scriptटैग का उपयोग करना चाहिए ?
फाल्सरेला

6
@ कोलियु कुछ भी आयात करने में मदद नहीं करेगा , लेकिन यह भी काम करना चाहिए। यदि आपके पास एक जेएस फाइल है जो किसी अन्य जेएस फाइल पर निर्भर करती है, तो पहले निर्भरता फाइलों के स्क्रिप्ट टैग घोषित करें, इसलिए बाद में पहले से ही इसकी निर्भरता लोड हो जाएगी। यदि आपके पास एक ऐसी स्थिति है जहां यह संभव दृष्टिकोण नहीं है, तो यहां उत्तर सहायक होने चाहिए।
falsarella

1
ऐसा करने का व्यावहारिक लाभ क्या है? किसी भी तरह से जावास्क्रिप्ट फ़ाइल पर निर्भर कोड आधार लोड नहीं होने जा रहा है और किसी भी स्थिति में काम करना शुरू नहीं करेगा!
कइस्टो पाइकर्ज

जवाबों:


4469

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

लेकिन 2015 (ES6) के बाद से, Node.js में मॉड्यूल आयात करने के लिए जावास्क्रिप्ट में ES6 मॉड्यूल मानक है, जो कि अधिकांश आधुनिक ब्राउज़रों द्वारा भी समर्थित है ।

पुराने ब्राउज़र, जैसे निर्माण उपकरणों के साथ संगतता के लिए Webpack और रोलअप और / या transpilation उपकरण की तरह कोलाहल इस्तेमाल किया जा सकता।

ES6 मॉड्यूल

ECMAScript (ES6) मॉड्यूल को v8.5 के बाद से ध्वज के साथ , और कम से कम Node.js v13.8.0 के बाद से Node.js में समर्थित किया गया है --experimental-modules। "ESM" (बनाम Node.js के पिछले कॉमनजेस-स्टाइल मॉड्यूल सिस्टम ["CJS"] को सक्षम करने के लिए या तो आप फ़ाइलों का उपयोग करते "type": "module"हैं package.jsonया एक्सटेंशन देते हैं .mjs। (इसी प्रकार, Node.js के पिछले CJS मॉड्यूल के साथ लिखे गए मॉड्यूल को नाम दिया जा सकता है .cjsयदि आपका डिफ़ॉल्ट ESM है।)

का उपयोग कर package.json:

{
    "type": "module"
}

तब module.js:

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

तब main.js:

import { hello } from './module.js';
let val = hello();  // val is "Hello";

उपयोग करना .mjs, आपके पास होगा module.mjs:

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

तब main.mjs:

import { hello } from './module.mjs';
let val = hello();  // val is "Hello";

ब्राउज़रों में ECMAScript मॉड्यूल

सफारी 10.1, क्रोम 61, फ़ायरफ़ॉक्स 60 और एज 16 के बाद से ब्राउज़र को सीधे ECMAScript मॉड्यूल लोड करने के लिए समर्थन (वेबपैक जैसे कोई टूल की आवश्यकता नहीं) पड़ा हैकैनेयूज़ पर वर्तमान समर्थन की जाँच करें । Node.js के .mjsएक्सटेंशन का उपयोग करने की कोई आवश्यकता नहीं है ; ब्राउज़र मॉड्यूल / स्क्रिप्ट पर फ़ाइल एक्सटेंशन को पूरी तरह से अनदेखा करते हैं।

<script type="module">
  import { hello } from './hello.mjs'; // Or it could be simply `hello.js`
  hello('world');
</script>
// hello.mjs -- or it could be simply `hello.js`
export function hello(text) {
  const div = document.createElement('div');
  div.textContent = `Hello ${text}`;
  document.body.appendChild(div);
}

Https://jakearchibald.com/2017/es-modules-in-browsers/ पर अधिक पढ़ें

ब्राउज़रों में गतिशील आयात

डायनामिक आयात स्क्रिप्ट को आवश्यकतानुसार अन्य स्क्रिप्ट लोड करने देता है:

<script type="module">
  import('hello.mjs').then(module => {
      module.hello('world');
    });
</script>

Https://developers.google.com/web/updates/2017/11/dynamic-import पर अधिक पढ़ें

Node.js की आवश्यकता है

पुराने CJS मॉड्यूल शैली, अभी भी व्यापक रूप से Node.js में उपयोग की जाती है, module.exports/require प्रणाली है।

// mymodule.js
module.exports = {
   hello: function() {
      return "Hello";
   }
}
// server.js
const myModule = require('./mymodule');
let val = myModule.hello(); // val is "Hello"   

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

AJAX लोड हो रहा है

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

लास्ट लोड हो रहा है

डायनामिक आयातों की तरह आप फ़िज़ा इंजेक्शनfetch का उपयोग करके स्क्रिप्ट निर्भरता के निष्पादन के आदेश को नियंत्रित करने के वादे का उपयोग करके कॉल के साथ एक या कई स्क्रिप्ट लोड कर सकते हैं :

fetchInject([
  'https://cdn.jsdelivr.net/momentjs/2.17.1/moment.min.js'
]).then(() => {
  console.log(`Finish in less than ${moment().endOf('year').fromNow(true)}`)
})

jQuery लोड हो रहा है

JQuery पुस्तकालय लोड हो रहा है कार्यक्षमता प्रदान करता है एक लाइन में :

$.getScript("my_lovely_script.js", function() {
   alert("Script loaded but not necessarily executed.");
});

डायनेमिक स्क्रिप्ट लोड हो रही है

आप HTML में स्क्रिप्ट URL के साथ एक स्क्रिप्ट टैग जोड़ सकते हैं। JQuery के ओवरहेड से बचने के लिए, यह एक आदर्श समाधान है।

स्क्रिप्ट एक अलग सर्वर पर भी निवास कर सकती है। इसके अलावा, ब्राउज़र कोड का मूल्यांकन करता है। <script>टैग या तो वेब पेज में इंजेक्ट किया जा सकता <head>है, या बस बंद करने से पहले डाला </body>टैग।

यहाँ एक उदाहरण है कि यह कैसे काम कर सकता है:

function dynamicallyLoadScript(url) {
    var script = document.createElement("script");  // create a script DOM node
    script.src = url;  // set its src to the provided URL

    document.head.appendChild(script);  // add it to the end of the head section of the page (could change 'head' to 'body' to add it to the end of the body section instead)
}

यह फ़ंक्शन <script>पृष्ठ के मुख्य भाग के अंत में एक नया टैग जोड़ेगा , जहां srcविशेषता URL पर सेट की गई है जो फ़ंक्शन को पहले पैरामीटर के रूप में दिया गया है।

इन दोनों समाधानों पर चर्चा की जाती है और जावास्क्रिप्ट पागलपन: गतिशील स्क्रिप्ट लोड हो रहा है

पता लगाया जा रहा है कि स्क्रिप्ट कब निष्पादित की गई है

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

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

उदाहरण के लिए: 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.head;
    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 whatever you want
};

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

loadScript("my_lovely_script.js", myPrettyCode);

ध्यान दें कि स्क्रिप्ट लोड होने के बाद या ब्राउजर के आधार पर और क्या आपने लाइन को शामिल किया है, उसके बाद स्क्रिप्ट निष्पादित हो सकती है script.async = false;सामान्य रूप से जावास्क्रिप्ट लोड करने पर एक शानदार लेख है जो इस पर चर्चा करता है।

स्रोत कोड मर्ज / प्रीप्रोसेसिंग

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


130
नहीं, लेकिन कोई है जो राइनो के रूप में उन्नत के रूप में कुछ का उपयोग करता है या फिर यह सवाल नहीं पूछेगा।
ई-सतीस

192
बस पूर्ण होने के लिए, एक तीसरा तरीका है: कुछ समाधानों में जब आप दोनों जावास्क्रिप्ट फ़ाइलों को नियंत्रित करते हैं, तो आप सिर्फ 1 विशाल जावास्क्रिप्ट फ़ाइल बना सकते हैं जो दोनों फ़ाइलों की सामग्री को जोड़ती है।
ताड़

20
"Document.createElement" ("my_lovely_script.js") नहीं होना चाहिए; " उदाहरण में "document.createElement (" स्क्रिप्ट ") हो?
रसेल सिल्वा

14
अगर यह आपके कोड को निष्पादित कर रहा है, तो eval हैक करने के लिए दरवाजा कैसे खोलता है?
विंस पानुकियो

6
आपके उत्तर के लिए IE ( onreadystatechangeघटना और readyStateसंपत्ति) के लिए कुछ संशोधन की आवश्यकता होती है । साथ ही, डायनेमिक स्क्रिप्ट लोडिंग को ब्रोसर के प्रीलोड स्कैनर से लाभ नहीं होता है। इस HTML5Rocks लेख की सिफारिश करें: html5rocks.com/en/tutorials/speed/script-loading
ruhong

570

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

आप अपनी जावास्क्रिप्ट फ़ाइलों को "मॉड्यूल" में लिख सकते हैं और फिर उन्हें अन्य लिपियों में निर्भरता के रूप में संदर्भित कर सकते हैं। या आप एक सरल "जाओ इस स्क्रिप्ट को प्राप्त करें" समाधान के रूप में आवश्यकताजे का उपयोग कर सकते हैं।

उदाहरण:

मॉड्यूल के रूप में निर्भरता को परिभाषित करें:

कुछ-dependency.js

define(['lib/dependency1', 'lib/dependency2'], function (d1, d2) {

     //Your actual script goes here.   
     //The dependent scripts will be fetched if necessary.

     return libraryObject;  //For example, jQuery object
});

कार्यान्वयन .js आपकी "मुख्य" जावास्क्रिप्ट फ़ाइल है जो कुछ-निर्भरता पर निर्भर करती है। js

require(['some-dependency'], function(dependency) {

    //Your script goes here
    //some-dependency.js is fetched.   
    //Then your script is executed
});

GitHub README से उद्धरण :

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

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

...


1
@ आयदान: मैटडोमो का कारण प्लस यह एक बाहरी पुस्तकालय पर निर्भर करता है जो बदले में स्वीकृत उत्तर पर निर्भर करता है।
डेविड मुल्डर

1
आवश्यकता को दूर करने के लिए। सबसे नवीनतम कोणीय js होगा जो अन्य बाध्यकारी और समृद्ध HTML विशेषताओं के साथ उपयोग करने के लिए अधिक स्थिर और आसान है।
जीशान

5
-1: वे सार - "some_d dependency" - वास्तव में गरीब हैं, जिनमें सूचकांक भ्रम की स्थिति है। मैं यह समझने के लिए संघर्ष करता हूं कि एक वर्किंग कोड उदाहरण कैसा दिखता है। अगर लेखक ने काम करने की मिसाल दी है, तो लगभग कोई भी उसकी जरूरतों को पूरा करने और उसे सामान्य बनाने में सक्षम होगा।
तेगिरी नेनाशी

1
MVC के साथ अच्छी तरह से काम नहीं करता है और स्वचालित खनन के साथ स्क्रिप्ट बंडलिंग
Triynko

1
'जोड़ें .. w / o अपनी जावास्क्रिप्ट फ़ाइलों को फिर से लिखने के लिए'; शांत, लेकिन वास्तव में कैसे? Cur। उत्तर से मुख्य स्क्रिप्ट + ऐसी 'परिभाषित' हर आश्रित फ़ाइल में हाँ, ऐसी 'आवश्यकता' ('अपेक्षित' नहीं?) जोड़ते हैं, हाँ? लेकिन यह है कि आईएस फिर से लिखना तो क्या फिर से नहीं लिखा? आवश्यकता के बाद से कोड की श्रेष्ठता ईई फ़ाइल को सामान्य के रूप में वैश्विक डीआईएस बनाने देती है? -क्या यह? मैंने अभी कोशिश की है कि, + (भूल गए?) < Script src = " requirementjs.org/docs/release/2.2.0/comments/require.js "> </ script>, फिर 'requjs (' ' GoogleDrive.com/host) /...,...इंग्सफंक्शनिंग ( एएएबीबी) {mycode}) ': फायरबग का कहना है कि हर आश्रित लोड किए गए BUT अपने दोषों को मायकोड और उसके बाद परिभाषित नहीं करते हैं।
नियति वास्तुकार

195

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

आपको अपने पृष्ठ jQuery.append()के <head>तत्व पर उपयोग करने की आवश्यकता है , जो है:

$("head").append('<script type="text/javascript" src="' + script + '"></script>');

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

लेकिन अगर वह आपके लिए कोई समस्या नहीं है, तो यह तरीका काम करना चाहिए।

मैंने वास्तव में $ .import_js () नामक jQuery प्लगइन लिखा है जो इस पद्धति का उपयोग करता है:

(function($)
{
    /*
     * $.import_js() helper (for JavaScript importing within JavaScript code).
     */
    var import_js_imported = [];

    $.extend(true,
    {
        import_js : function(script)
        {
            var found = false;
            for (var i = 0; i < import_js_imported.length; i++)
                if (import_js_imported[i] == script) {
                    found = true;
                    break;
                }

            if (found == false) {
                $("head").append('<script type="text/javascript" src="' + script + '"></script>');
                import_js_imported.push(script);
            }
        }
    });

})(jQuery);

जावास्क्रिप्ट आयात करने के लिए आपको बस इतना करना होगा:

$.import_js('/path_to_project/scripts/somefunctions.js');

मैंने उदाहरण के लिए इसके लिए एक सरल परीक्षण भी किया

इसमें main.jsमुख्य HTML में एक फ़ाइल शामिल है और फिर एक अतिरिक्त फ़ाइल को आयात करने के लिए स्क्रिप्ट का main.jsउपयोग $.import_js()किया जाता है included.js, जो इस फ़ंक्शन को परिभाषित करता है:

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

और सही शामिल होने के बाद included.js, hello()फ़ंक्शन को कॉल किया जाता है, और आपको अलर्ट मिलता है।

(यह जवाब ई-सिटिस की टिप्पणी के जवाब में है)।


मैं इस विधि की कोशिश कर रहा हूं, लेकिन मेरे लिए काम नहीं कर रहा है, तत्व सिर्फ हेड टैग में प्रकट नहीं होता है।
साइटें

16
@juanpastas - उपयोग jQuery.getScript, इस तरह आप प्लगइन लिखने के बारे में चिंता करने की ज़रूरत नहीं है ...
MattDMo

6
हम्म, इस लेख के अनुसार , एक scriptतत्व को जोड़ना headयह अतुल्यकालिक रूप से चलाने का कारण होगा, जब तक कि asyncविशेष रूप से सेट नहीं किया जाता है false
फ्लिम

1
स्क्रिप्ट चर को html संस्थाओं को एन्कोड नहीं किया जाना चाहिए? यदि लिंक शामिल है ", तो कोड टूट जाएगा
RedClover

1
@ प्रिय महोदय, मुझे और मेरी टीम को आपकी टिप्पणी के लिए धन्यवाद और मैं व्यक्तिगत रूप से आपको बीयर का भी पैसा देना चाहता हूं अगर हम कभी भी व्यक्ति से मिलते हैं
एलेक्स

155

एक और तरीका है, कि मेरी राय में बहुत क्लीनर है, एक <script>टैग का उपयोग करने के बजाय एक तुल्यकालिक अजाक्स अनुरोध करना है । यह भी है कि Node.js हैंडल कैसे शामिल है।

यहां 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);
        }
    });
}

आप इसे अपने कोड में तब उपयोग कर सकते हैं जब आप आमतौर पर एक शामिल का उपयोग करेंगे:

require("/scripts/subscript.js");

और अगली पंक्ति में आवश्यक स्क्रिप्ट से एक फ़ंक्शन को कॉल करने में सक्षम हो:

subscript.doSomethingCool(); 

1
अच्छा समाधान, सिर शामिल है दुर्भाग्य से async, AJAX समाधान काम करता है।
मट्टियो कोंटा

17
जैसा कि किसी और ने उल्लेख किया है, requjs.org ऐसा करता है और इसमें एक प्री-कंपाइलर भी होता है जो js फाइलों को एक साथ रखता है ताकि वे तेजी से लोड हों। इसे आज़माने की आपकी इच्छा हो सकती है।
एरियल

2
पाया कि मैं क्रोम के लिए फ़ाइल के निचले भाग में इस निर्देश को जोड़कर इसे डीबग कर सकता हूं: // @ sourceURL = view_index.js
टोड वेंस

11
unfortunatelly, async: झूठी अब jQuery में पदावनत है। भविष्य में टूट सकता है, इसलिए मैं बचना चाहिए।
1

3
@katsh हम यहाँ jqXHR वस्तुओं का उपयोग नहीं कर रहे हैं। आपका उद्धरण आपकी पिछली टिप्पणी का समर्थन नहीं करता है, जिसमें कहा गया है कि async: falseमाना जाता है कि यह पदावनत है। यह नहीं! जैसा कि आपकी बोली में कहा गया है, केवल jqXHR संबंधित सामान है।
जीरो 3

101

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

आपको बस import cond from 'cond.js';किसी मैक्रो नाम की condफाइल से लोड करने के लिए लिखना होगा cond.js

तो आपको किसी भी जावास्क्रिप्ट ढांचे पर भरोसा करने की आवश्यकता नहीं है और न ही आपको स्पष्ट रूप से अजाक्स कॉल करना है।

को देखें:


12
आवश्यकता / आयात jsfile पर आने वाले समय में बहुत लंबा है। (IMO)।
rwheadon

6
@rwheadon हाँ लगता है कि यह भाषा का हिस्सा नहीं है! कैसे js लोगों को कुछ भी किया जाता है मेरे से परे है! Im यह करने के लिए नया है और यह पागलपन का सबसे बुरा (कई) बिट्स लगता है
जोनीरा

@ जॉनी-लेड्स बिल्ट-इन मॉड्यूल-लोडिंग के बिना भी, ब्राउज़र में जावास्क्रिप्ट इतना लचीला है कि हम अपने मॉड्यूल प्रबंधन के लिए एक पुस्तकालय की आवश्यकता को लागू कर सकते हैं।
कीन

8
मध्य 2015- फिर भी किसी भी ब्राउज़र में लागू नहीं, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
स्केप

हां आप सही हैं। अब मैं इसके लिए बुरा महसूस करने लगा हूं :(। तूह, एक बार सभी ब्राउज़रों में लागू होने के बाद यह जावास्क्रिप्ट में निर्मित एक महान विशेषता होगी।
इमदाद

96

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

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");

8
@ ई-सतीस - दरअसल, यह एक फायदा है, एक सिंक स्क्रिप्ट अवरुद्ध हो जाएगा। पाठ्यक्रमों के लिए घोड़े, लेकिन 10 में 9 बार आप गैर-अवरुद्ध विकल्प चाहते हैं।
अन्नकूट

@Svitlana - इस तरह से बनाए गए स्क्रिप्ट तत्व async हैं। वर्तमान में इसे खामियों के शोषण के रूप में देखा जा सकता है, इसलिए यह भविष्य का प्रमाण नहीं हो सकता है, मैंने किसी भी मानक में ऐसा कुछ नहीं देखा है जो इसे स्पष्ट करता हो।
अन्नकूट

वास्तव में मैं इसे वापस लेता हूं, मैंने देखा है कि आप सिर के बजाय शरीर से अपील कर रहे हैं।
अन्नकूट

@ कन्नकटा: क्या अंतर है? BTW, याहू शरीर के अंत में स्क्रिप्ट टैग जोड़ने का सुझाव देता है, इसलिए गतिशील रूप से जोड़ते समय इसके साथ कुछ भी गलत नहीं होना चाहिए।
स्वितलाना मकसिमचुक

7
@ ई-सतीस अतुल्यकालिक अच्छा है क्योंकि यह आपके पृष्ठ को फ्रीज नहीं करेगा। कॉलबैक का उपयोग तब करें जब इसे पूरा किया जाएjs.onload = callback;
Vitim.us

74

कथन importECMAScript 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;

... लेकिन आपके द्वारा लिंक किए गए पृष्ठ पर संगतता तालिका के अनुसार, आज तक किसी भी ब्राउज़र द्वारा समर्थित नहीं है।
जीरो 3

6
अब आप ES6 कोड लिख सकते हैं और अपने पसंदीदा वर्तमान मॉड्यूल सिस्टम (CommonJS / AMD / UMD): babeljs.io/docs/usage/musules
जेरेमी हैरिस

@ Zero3 जाहिर तौर पर नया IE (एज) केवल एक ही है
जूलियन अवार

2019 में IE अभी भी किसी भी रूप में इसका समर्थन नहीं करता है। Microsoft को प्रयोज्य के खिलाफ क्यों होना चाहिए?
ग्रेहाउज

61

शायद आप इस फ़ंक्शन का उपयोग कर सकते हैं जो मैंने इस पृष्ठ पर पाया है कि मैं जावास्क्रिप्ट फ़ाइल में जावास्क्रिप्ट फ़ाइल कैसे शामिल करूं? :

function include(filename)
{
    var head = document.getElementsByTagName('head')[0];

    var script = document.createElement('script');
    script.src = filename;
    script.type = 'text/javascript';

    head.appendChild(script)
}

5
जोड़ने के लिए उपयोगी होना चाहिएscript.onload = callback;
विटीम.स

@SvitlanaMaksymchuk तो, अगर मैं उपयोग नहीं करता var, तो चर वैश्विक होगा?
फ्रांसिस्को कॉर्लेस मोरेल्स

@FranciscoCorrales हाँ।
क्रिस्टोफर चिचे

यह वैश्विक रूप से वर के साथ समाप्त होता है :)
वेदरन मैरिसविक।


54

यहाँ jQuery के बिना एक तुल्यकालिक संस्करण है :

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

ध्यान दें कि यह कार्य क्रॉस-डोमेन प्राप्त करने के लिए, सर्वर को allow-originइसकी प्रतिक्रिया में हेडर सेट करना होगा ।


उत्कृष्ट समारोह! शरीर के बाद किसी भी अतिरिक्त JS को लिखे जाने से पहले जावास्क्रिप्ट को लोड करें। कई स्क्रिप्ट लोड करते समय बहुत महत्वपूर्ण है।
tfont

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

@ user2284570: यदि आप विदेशी डोमेन के मालिक हैं: सर्वर उत्तर में `अनुमति-मूल 'शीर्षक सेट करें। यदि आप मालिक नहीं हैं: कुछ भी नहीं। माफ़ करना! यह क्रॉस-ऑरिजिन-पॉलिसी है।
हेनोब

2
@ user2284570: मैं आपकी टिप्पणी को इस तरह से समझता हूं, कि आप उस डोमेन के मालिक नहीं हैं, जिससे आप स्क्रिप्ट को लोड करना चाहते हैं। उस स्थिति में आप केवल एक सम्मिलित <script>टैग के माध्यम से एक स्क्रिप्ट लोड कर सकते हैं , के माध्यम से नहीं XMLHttpRequest
हेनब

2
फ़ायरफ़ॉक्स में इसका उपयोग करने की योजना बनाने वालों के लिए (imacros स्क्रिप्टिंग के लिए कहो), इस लाइन को फ़ाइल के शीर्ष पर जोड़ें:const XMLHttpRequest = Components.Constructor("@mozilla.org/xmlextras/xmlhttprequest;1");
Kwestion

49

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

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>

सार: http://gist.github.com/284442


7
jrburke ने इसे आवश्यकताएँ के रूप में लिखा था। Github: requirementjs.org/docs/requirements.html
माइक कारन

क्या यह लोड की गई स्क्रिप्ट को उस दायरे से बाहर नहीं रखा जा रहा है जहाँ आवश्यकता होती है () कहा जाता है? इवैल्यूशन (जैसे) को स्कोप के भीतर करने का एकमात्र तरीका है। क्या कोई और तरीका है?
त्रिकुट्र

44

यहाँ पर सामान्यीकृत संस्करण है कि फेसबुक अपने सर्वव्यापी लाइक बटन के लिए कैसे करता है:

<script>
  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 = function () {
    // do stuff with your dynamically loaded script
    snowStorm.snowColor = '#99ccff';
  };
  firstScript.parentNode.insertBefore(js, firstScript);
</script>

अगर यह फेसबुक के लिए काम करता है, तो यह आपके लिए काम करेगा।

इसके scriptबजाय हम पहले तत्व की तलाश करते हैं headया bodyऐसा इसलिए है क्योंकि कुछ ब्राउज़र गायब होने पर एक नहीं बनाते हैं, लेकिन हमें एक scriptतत्व होने की गारंटी है - यह एक। Http://www.jspatterns.com/the-ridiculous-case-of-adding-a-script-element/ पर और पढ़ें ।


3
बहुत अच्छा! यहां कुछ विधियां भी काम करती हैं, लेकिन एक गतिशील सेटिंग के तहत यह सबसे अच्छा काम करता है।
tfont

मैंने आपकी स्क्रिप्ट को विस्तारित करने के लिए बढ़ा दिया
Kamil

39

यदि आप शुद्ध जावास्क्रिप्ट में चाहते हैं, तो आप उपयोग कर सकते हैं document.write

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

यदि आप jQuery लाइब्रेरी का उपयोग करते हैं, तो आप $.getScriptविधि का उपयोग कर सकते हैं ।

$.getScript("another_script.js");

8
document.write सब कुछ नहीं हटाएगा?
आइसा आदिल

30

आप PHP का उपयोग करके अपनी स्क्रिप्ट भी इकट्ठा कर सकते हैं :

फ़ाइल main.js.php:

<?php
    header('Content-type:text/javascript; charset=utf-8');
    include_once("foo.js.php");
    include_once("bar.js.php");
?>

// Main JavaScript code goes here

16
लगता है कि बिंदु के सामने अंत में जावास्क्रिप्ट में यह सब रखने के लिए है
एरियल

1
यह याद दिलाने के लिए धन्यवाद। आप अपने HTML हेडर में PHP लेखन <script> टैग भी कर सकते हैं, ताकि आपके द्वारा आवश्यक js फ़ाइलों (और केवल उन) को लोड किया जा सके।
रॉल्फ

29

यहाँ दिखाए गए अधिकांश समाधान गतिशील लोडिंग को दर्शाते हैं। मैं एक संकलक के बजाय खोज रहा था जो सभी आउटपुट फ़ाइलों को एक एकल आउटपुट फ़ाइल में इकट्ठा करता है। सीएसएस के साथ कम / सास प्रीप्रोसेसरों के समान है@import पर नियम। चूंकि मुझे इस तरह का कुछ भी अच्छा नहीं लगा, इसलिए मैंने इस मुद्दे को हल करने वाला एक सरल उपकरण लिखा।

तो यहाँ संकलक है, https://github.com/dsheiko/jsic , जो $import("file-path")अनुरोधित फ़ाइल सामग्री के साथ सुरक्षित रूप से प्रतिस्थापित करता है। यहाँ संगत ग्रन्ट प्लगइन है: https://github.com/dsheiko/grunt-jsic

JQuery मास्टर ब्रांच पर, वे परमाणु स्रोत फ़ाइलों को एक एकल में शुरू करते हैं, जिसके साथ शुरू intro.jsऔर समाप्त होता हैouttro.js । यह मुझे सूट नहीं करता है क्योंकि यह स्रोत कोड डिज़ाइन पर कोई लचीलापन प्रदान नहीं करता है। देखें कि यह किस तरह से काम करता है:

src / main.js

var foo = $import("./Form/Input/Tel");

src / प्रपत्र / इनपुट / Tel.js

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

अब हम कंपाइलर चला सकते हैं:

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

और संयुक्त फाइल प्राप्त करें

निर्माण / main.js

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

2
इस पोस्ट के बाद से मैं बहुत बेहतर समाधान के साथ आया - कॉमनजस मॉड्यूल कंपाइलर - github.com/dsheiko/cjsc तो आप बस कॉमन जे या नोड्स मॉड्यूल लिख सकते हैं और एक दूसरे को एक्सेस कर सकते हैं फिर भी उन्हें अलग-अलग स्कोप में रख सकते हैं। लाभ: प्रदर्शन को प्रभावित करने वाले कई HTTP अनुरोधों की कोई आवश्यकता नहीं है आपको मॉड्यूल कोड को मैन्युअल रूप से लपेटने की आवश्यकता नहीं है - यह संकलक की जिम्मेदारी है (इसलिए बेहतर स्रोत कोड पठनीयता) आपको किसी भी बाहरी पुस्तकालयों की आवश्यकता नहीं है यह UMD- के साथ संगत है और NodeJs मॉड्यूल (जैसे आप अपने कोड को छुए बिना मॉड्यूल के रूप में jQuery, बैकबोन को संबोधित कर सकते हैं)
दिमित्री शिको

26

यदि जावास्क्रिप्ट फ़ाइल लोड करने का आपका उद्देश्य आयातित / शामिल फ़ाइल से फ़ंक्शन का उपयोग कर रहा है , तो आप एक वैश्विक ऑब्जेक्ट को भी परिभाषित कर सकते हैं और फ़ंक्शन को ऑब्जेक्ट आइटम पर सेट कर सकते हैं। उदाहरण के लिए:

global.js

A = {};

file1.js

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

file2.js

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

main.js

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

जब आप 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>

22

यह करना चाहिए:

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

5
evalक्या यह गलत है है। से Crockford , " evalबुराई है। evalसमारोह जावास्क्रिप्ट का सबसे दुरुपयोग की सुविधा है। यह करने से बचें। evalउपनाम है। का प्रयोग न करें Functionनिर्माता। तार पारित मत करो setTimeoutया setInterval।" यदि आपने उसका "जावास्क्रिप्ट: द गुड पार्ट्स" नहीं पढ़ा है, तो अभी बाहर जाएं और अभी करें। आप होगा यह अफसोस नहीं।
मैटडामो

13
@MattDMo "किसी ने कहा कि यह बुरा था" वास्तव में एक तर्क नहीं है।
केसी

4
@emodendroket मुझे लगता है कि डगलस क्रॉकफ़ोर्ड कौन है, यह आप नहीं जानते ।
मट्टडामो

13
@MattDMo मैं पूरी तरह से जानता हूं कि वह कौन है, लेकिन वह इंसान है, भगवान नहीं।
केसी 19

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

21

या रन टाइम पर शामिल करने के बजाय, अपलोड करने से पहले एक स्क्रिप्ट का उपयोग करने के लिए संक्षिप्त करें।

मैं Sprockets का उपयोग करता हूं करता हूं (मुझे नहीं पता कि क्या अन्य हैं)। आप अपने जावास्क्रिप्ट कोड को अलग-अलग फाइलों में बनाते हैं और उन टिप्पणियों को शामिल करते हैं जिन्हें Sprockets इंजन द्वारा संसाधित किया जाता है। विकास के लिए आप क्रमिक रूप से फ़ाइलों को शामिल कर सकते हैं, फिर उत्पादन के लिए उन्हें मर्ज कर सकते हैं ...

यह सभी देखें:


Browserify , Sprockets की तुलना में अधिक लोकप्रिय है।
डेन डैस्कलेस्कु

18

मेरे पास एक सरल मुद्दा था, लेकिन मैं इस सवाल के जवाब से चकित था।

मुझे एक जावास्क्रिप्ट फाइल (myVar1) को एक जावास्क्रिप्ट फाइल (myvariables.js) में परिभाषित एक और जावास्क्रिप्ट फाइल (main.js) में उपयोग करना था।

इसके लिए मैंने नीचे दिया है:

HTML फ़ाइल में जावास्क्रिप्ट कोड लोड किया गया है, सही क्रम में, myvariables.js पहले, फिर main.js:

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

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

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

फ़ाइल: myvariables.js

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

फ़ाइल: main.js

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

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

इससे मेरा दिन बच गया। आशा है कि ये आपकी मदद करेगा।


इस जवाब के साथ समस्या यह है कि यह कुछ ऐसा नहीं है import। एक js फ़ाइल से दूसरे में सामान प्राप्त करने के लिए आपको एक HTML फ़ाइल की आवश्यकता होती है।
कैनाईडाइड

सच सच। यही कारण है कि कुछ अन्य उत्तर इसे समाधान के रूप में दे रहे हैं। हालाँकि मेरे पास दो जेएस फाइलें थीं, एक को अन्य जेएस के चर का उपयोग करना चाहिए। कोई नोड .js, next.js, express.js, आदि, इसलिए आयात या आवश्यकता काम नहीं करेगी, बस सादे .js फाइलें थीं।
मनोहर रेड्डी पोरेड्डी

समझ में आता है, हालांकि, सवाल वास्तव में एक जावास्क्रिप्ट फ़ाइल को दूसरी फाइल के भीतर आयात करने के लिए कह रहा है, न कि केवल HTML फ़ाइल का उपयोग करके इसके चर का उपयोग करना। उदाहरण के लिए, मान लें कि आप एक बटन के लिए कार्यक्षमता बना रहे हैं, और आप तीन अलग-अलग जेएस फ़ाइलों का उपयोग करते हैं, एक क्लिक हैंडलिंग के लिए, एक होवर हैंडलिंग के लिए, एक अन्य दो में से प्रत्येक के लिए कॉलबैक के लिए। तीसरे js में अन्य दो js को आयात करना उपयोगी होगा, और केवल एक <script>टैग होगा। इससे संगठन को मदद मिल सकती है। यह उत्तर बस वह नहीं है जो प्रश्न पूछ रहा था, और इस संदर्भ में आदर्श नहीं है।
कैनीडाइड

जब मैंने अपनी समस्या का हल खोजा, तो मैंने सही तरीका खोजा, हालाँकि Google को लगता है कि यह सही पृष्ठ है इसलिए मैं यहाँ उतरा। इसलिए मैंने अपना उत्तर यहाँ लिखा। लगता है, मैंने ठीक किया, ऊपर 15 अपवोट्स के कारण। अन्य लोगों के समय को बर्बाद न करने के लिए, मैंने एक स्पष्ट शुरुआत की है कि मेरा परिदृश्य क्या है - पहले HTML कोड रखा है - जो मदद की तरह दिखता है, क्योंकि आपने उत्तर दिया था और कहा था कि HTML आपका परिदृश्य नहीं है। आशा है कि स्पष्ट किया।
मनोहर रेड्डी पोरेड्डी

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

16

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

सौभाग्य से, वेब वर्कर्स का अपना importScriptsकार्य है जो वेब वर्कर के दायरे में एक वैश्विक कार्य है, जो ब्राउज़र के लिए मूल है क्योंकि यह विनिर्देश का हिस्सा है

वैकल्पिक रूप से, आपके प्रश्न पर प्रकाश डाला गया दूसरा सबसे बड़ा जवाब है , आवश्यकताएँ भी एक वेब वर्कर के अंदर स्क्रिप्ट सहित संभाल सकती हैं (संभवतः importScriptsखुद को बुला रही है, लेकिन कुछ अन्य उपयोगी सुविधाओं के साथ)।


16

जाँच के साथ आधुनिक भाषा में यदि स्क्रिप्ट पहले ही लोड हो चुकी है तो यह होगा:

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

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

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 => {})

अच्छा लगा। अच्छा समाधान।
नौफाली उर्फ ​​नील

संक्षिप्त और केवल ES5 की जरूरत है, और सुरुचिपूर्ण ढंग से औपचारिक रूप से कॉल बैक होने से बचा जाता है। शुक्रिया दिमित्री!
यूरेका

वाह, सर्वर के बिना ब्राउज़र में काम करता है। pi.js = बस var pi = 3.14। loadJS () फंक्शन के जरिएloadJs("pi.js").then(function(){ console.log(pi); });
zipzit

14

@importजावास्क्रिप्ट सीएसएस की तरह आयात प्राप्त करने के लिए इस तरह के वाक्य रचना के माध्यम से उनके विशेष मिश्रण के रूप में एक उपकरण का उपयोग संभव है .mixफ़ाइल प्रकार (देखें यहाँ )। मुझे लगता है कि आवेदन केवल उपरोक्त तरीकों में से एक का उपयोग करता है, हालांकि मुझे नहीं पता।

.mixफ़ाइलों पर मिश्रण प्रलेखन से :

मिक्स फाइलें .mix के साथ बस .js या .css फाइलें होती हैं। फ़ाइल नाम में। एक मिक्स फ़ाइल बस एक सामान्य शैली या स्क्रिप्ट फ़ाइल की कार्यक्षमता का विस्तार करती है और आपको आयात और संयोजन करने की अनुमति देती है।

यहाँ एक उदाहरण .mixफ़ाइल है जो कई .jsफ़ाइलों को एक में जोड़ती है :

// 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";

मिक्सचर इसे scripts-global.jsऔर मिनिफायड वर्जन ( scripts-global.min.js) के रूप में भी आउटपुट करता है ।

नोट: मैं किसी भी तरह से मिक्सचर से संबद्ध नहीं हूं, इसे फ्रंट-एंड डेवलपमेंट टूल के रूप में उपयोग करने के अलावा। मुझे यह देखकर एक सवाल आया.mix जावास्क्रिप्ट फाइल एक्शन (मिक्सचर बॉयलरप्लेट्स में से एक) में और इसके द्वारा थोड़ा उलझन में होने ("आप ऐसा कर सकते हैं?" मैंने खुद से सोचा)। तब मुझे एहसास हुआ कि यह एक एप्लिकेशन-विशिष्ट फ़ाइल प्रकार (कुछ हद तक निराशाजनक, सहमत) था। फिर भी, लगा कि ज्ञान दूसरों के लिए मददगार हो सकता है।

अद्यतन : मिश्रण अब मुफ़्त (ऑफ़लाइन) है।

अद्यतन : मिश्रण अब बंद कर दिया गया है। पुराने मिश्रण रिलीज अभी भी उपलब्ध हैं


यदि यह एक नोड मॉड्यूल था तो यह बहुत बढ़िया होगा।
b01

@ b01 एक चुनौती की तरह लगता है;) अगर केवल मेरे पास समय होता ... शायद कोई और करता?
इसहाक ग्रेगसन

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

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

document.body.appendChild(js);

2
यह सबसे सरल कोड है, लेकिन कुछ किनारे के मामलों में विफल होbody जाएगा जब अभी तक मौजूद नहीं है या संशोधित नहीं किया जा सकता है। साथ ही, उत्तरों को समझाने में मदद करता है।
डेन डैस्कलेस्कु

13

मेरी सामान्य विधि है:

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 का नया स्क्रिप्ट टैग (पहले एक के बाद) बनाता है। यह इसे अतुल्यकालिक मोड पर सेट करता है, इसलिए यह बाकी कोड को ब्लॉक नहीं करता है, लेकिन रेडीस्टेट (लोड होने वाली सामग्री की स्थिति) को 'लोड' में बदलने पर कॉलबैक कॉल करता है।


13

यद्यपि ये उत्तर महान हैं, एक सरल "समाधान" है जो स्क्रिप्ट लोडिंग के अस्तित्व में आने के बाद से है, और यह अधिकांश लोगों के उपयोग के मामलों के 99.999% को कवर करेगा। बस उस स्क्रिप्ट को शामिल करें जिसकी आपको आवश्यकता है उस स्क्रिप्ट से पहले। अधिकांश परियोजनाओं के लिए यह निर्धारित करने में देर नहीं लगती कि किन लिपियों की जरूरत है और किस क्रम में हैं।

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

अगर Script2 के लिए script1 की आवश्यकता है, तो यह वास्तव में कुछ ऐसा करने का सबसे आसान तरीका है। मुझे बहुत आश्चर्य है कि कोई भी इसे नहीं लाया है, क्योंकि यह सबसे स्पष्ट और सरल उत्तर है जो लगभग हर एक मामले में लागू होगा।


1
मैं अपने आप सहित कई लोगों के लिए अनुमान लगा रहा हूं, हमें गतिशील फ़ाइल नाम की आवश्यकता है।
स्टुअर्ट मैकइंटायर

1
उस स्थिति में @StuartMcIntyre, रनटाइम पर स्क्रिप्ट टैग के src विशेषता को सेट करता है, और ऑनलोड घटना की प्रतीक्षा करें (निश्चित रूप से 2019 में उस मामले में बेहतर समाधान हैं)।
KthProg

12

मैंने एक साधारण मॉड्यूल लिखा है जो जावास्क्रिप्ट में मॉड्यूल स्क्रिप्ट सहित / आयात करने के काम को स्वचालित करता है। कोड की विस्तृत व्याख्या के लिए, ब्लॉग पोस्ट को देखें कि जावास्क्रिप्ट की आवश्यकता / आयात / मॉड्यूल शामिल हैं

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

require('ivar.util.string');
require('ivar.net.*');
require('ivar/util/array.js');
require('http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js');

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

    //--------------------

var _rmod = _rmod || {}; //Require module namespace
_rmod.LOADED = false;
_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;
    }
};

_.rmod = namespaceToUri = function(script_name, url) {
    var np = script_name.split('.');
    if (np.getLast() === '*') {
        np.pop();
        np.push('_all');
    }

    if(!url)
        url = '';

    script_name = np.join('.');
    return  url + np.join('/')+'.js';
};

//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 uri = '';
    if (script_name.indexOf('/') > -1) {
        uri = script_name;
        var lastSlash = uri.lastIndexOf('/');
        script_name = uri.substring(lastSlash+1, uri.length);
    } 
    else {
        uri = _rmod.namespaceToUri(script_name, ivar._private.libpath);
    }

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

10

यह स्क्रिप्ट किसी अन्य <script>टैग के शीर्ष पर जावास्क्रिप्ट फ़ाइल जोड़ देगी :

(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);
})();

10

इसमें Head.js भी है । इससे निपटना बहुत आसान है:

head.load("js/jquery.min.js",
          "js/jquery.someplugin.js",
          "js/jquery.someplugin.css", function() {
  alert("Everything is ok!");
});

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


10

इस प्रश्न के लिए कई संभावित उत्तर हैं। मेरा जवाब स्पष्ट रूप से उनमें से कई पर आधारित है। यह वही है जो मैंने सभी उत्तरों के माध्यम से पढ़ने के बाद समाप्त किया।

$.getScriptलोडिंग पूरी होने पर कॉलबैक के लिए समस्या और वास्तव में किसी अन्य समाधान की आवश्यकता होती है, यदि आपके पास कई फाइलें हैं जो इसका उपयोग करते हैं और एक दूसरे पर निर्भर हैं, तो आपके पास अब यह जानने का कोई तरीका नहीं है कि सभी स्क्रिप्ट लोड किए गए हैं (एक बार वे नेस्टेड हैं कई फाइलों में)।

उदाहरण:

file3.js

var f3obj = "file3";

// Define other stuff

file2.js:

var f2obj = "file2";
$.getScript("file3.js", function(){

    alert(f3obj);

    // Use anything defined in file3.
});

file1.js:

$.getScript("file2.js", function(){
    alert(f3obj); //This will probably fail because file3 is only guaranteed to have loaded inside the callback in file2.
    alert(f2obj);

    // Use anything defined in the loaded script...
});

आप सही हैं जब आप कहते हैं कि आप Ajax को सिंक्रोनाइज़ करने के लिए निर्दिष्ट कर सकते हैं या XMLHttpRequest का उपयोग कर सकते हैं , लेकिन वर्तमान प्रवृत्ति तुल्यकालिक अनुरोधों को हटाने के लिए प्रतीत होती है, इसलिए हो सकता है कि आपको अभी या भविष्य में पूर्ण ब्राउज़र समर्थन न मिले।

आप $.whenआस्थगित वस्तुओं की एक सरणी की जाँच करने के लिए उपयोग करने का प्रयास कर सकते हैं, लेकिन अब आप हर फ़ाइल में ऐसा कर रहे हैं और $.whenकॉलबैक निष्पादित होने पर निष्पादित नहीं होने पर file2 को लोड माना जाएगा , इसलिए फ़ाइल 3 लोड होने से पहले फ़ाइल 1 अभी भी निष्पादन जारी रखता है। । यह वास्तव में अभी भी एक ही समस्या है।

मैंने आगे की बजाय पीछे की तरफ जाने का फैसला किया। आपका धन्यवाद document.writeln। मुझे पता है कि यह वर्जित है, लेकिन जब तक इसका सही ढंग से उपयोग किया जाता है तब तक यह अच्छी तरह से काम करता है। आप उस कोड के साथ समाप्त होते हैं जिसे आसानी से डीबग किया जा सकता है, DOM में सही तरीके से दिखाता है और यह सुनिश्चित कर सकता है कि निर्भरता सही तरीके से लोड की गई हो।

आप निश्चित रूप से $ ("बॉडी") का उपयोग कर सकते हैं। एपेंडेंड (), लेकिन फिर आप अब किसी भी अधिक सही ढंग से डिबग नहीं कर सकते।

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

मुझे jQuery के विस्तार का विचार पसंद आया, लेकिन जाहिर है कि आपको इसकी आवश्यकता नहीं है।

कॉल करने से पहले document.writeln, यह सुनिश्चित करने के लिए जांच करता है कि सभी स्क्रिप्ट तत्वों का मूल्यांकन करके स्क्रिप्ट पहले से लोड नहीं किया गया है।

मैं मानता हूं कि किसी स्क्रिप्ट को तब तक पूरी तरह से निष्पादित नहीं किया जाता है जब तक कि उसके document.readyइवेंट को निष्पादित नहीं किया गया हो। (मुझे पता है कि उपयोग करने document.readyकी आवश्यकता नहीं है, लेकिन कई लोग इसका उपयोग करते हैं, और इसे संभालना एक सुरक्षा उपाय है।)

जब अतिरिक्त फ़ाइलों को लोड किया जाता है तो document.readyकॉलबैक गलत क्रम में निष्पादित हो जाएगा। यह पता करने के लिए कि कोई स्क्रिप्ट वास्तव में भरी हुई है या नहीं, जो स्क्रिप्ट आयात की गई है, उसे फिर से आयात किया गया और निष्पादन रोक दिया गया। यह उत्पन्न करने वाली फ़ाइल के कारण अब document.readyकिसी भी स्क्रिप्ट से आयात होने के बाद उसका कॉलबैक निष्पादित होता है।

इस दृष्टिकोण के बजाय आप jQuery को संशोधित करने का प्रयास कर सकते हैं readyList, लेकिन यह एक बदतर समाधान की तरह लग रहा था।

समाधान:

$.extend(true,
{
    import_js : function(scriptpath, reAddLast)
    {
        if (typeof reAddLast === "undefined" || reAddLast === null)
        {
            reAddLast = true; // Default this value to true. It is not used by the end user, only to facilitate recursion correctly.
        }

        var found = false;
        if (reAddLast == true) // If we are re-adding the originating script we do not care if it has already been added.
        {
            found = $('script').filter(function () {
                return ($(this).attr('src') == scriptpath);
            }).length != 0; // jQuery to check if the script already exists. (replace it with straight JavaScript if you don't like jQuery.
        }

        if (found == false) {

            var callingScriptPath = $('script').last().attr("src"); // Get the script that is currently loading. Again this creates a limitation where this should not be used in a button, and only before document.ready.

            document.writeln("<script type='text/javascript' src='" + scriptpath + "'></script>"); // Add the script to the document using writeln

            if (reAddLast)
            {
                $.import_js(callingScriptPath, false); // Call itself with the originating script to fix the order.
                throw 'Readding script to correct order: ' + scriptpath + ' < ' + callingScriptPath; // This halts execution of the originating script since it is getting reloaded. If you put a try / catch around the call to $.import_js you results will vary.
            }
            return true;
        }
        return false;
    }
});

उपयोग:

file3:

var f3obj = "file3";

// Define other stuff
$(function(){
    f3obj = "file3docready";
});

करें 2:

$.import_js('js/file3.js');
var f2obj = "file2";
$(function(){
    f2obj = "file2docready";
});

file1:

$.import_js('js/file2.js');

// Use objects from file2 or file3
alert(f3obj); // "file3"
alert(f2obj); // "file2"

$(function(){
    // Use objects from file2 or file3 some more.
    alert(f3obj); //"file3docready"
    alert(f2obj); //"file2docready"
});

यह वास्तव में वर्तमान में स्वीकृत उत्तर बताता है: बस पर्याप्त नहीं है।
२३

मुख्य अंतर यह है कि यदि कोई लापता निर्भरता है, तो यह निर्भरता के लिए स्क्रिप्ट टैग को जोड़ देगा, फिर कॉलिंग फ़ाइल के लिए स्क्रिप्ट टैग भी जोड़ देगा, और एक त्रुटि फेंक देगा जो निष्पादन को रोकती है। यह स्क्रिप्ट को संसाधित करने और सही क्रम में चलाने का कारण बनता है और कॉलबैक की आवश्यकता को हटा देता है। तो निर्भर स्क्रिप्ट को नेस्टिंग का समर्थन करते हुए कॉलिंग स्क्रिप्ट से पहले लोड और निष्पादित किया जाएगा।
curlyhairedgenius

जैसा कि "वर्तमान प्रवृत्ति समकालिक अनुरोधों को कम करने के लिए प्रतीत होती है," यह केवल सच है क्योंकि कई डेवलपर्स ने उनका दुरुपयोग किया है और उपयोगकर्ताओं को अनावश्यक रूप से इंतजार किया है। हालाँकि, यदि अनुरोध स्वाभाविक रूप से समकालिक है, जैसे एक विवरण शामिल करें, तो सरल तुल्यकालिक अजाक्स ठीक है। मैंने एक सामान्य जावास्क्रिप्ट एक्सटेंशन फ़ंक्शन बनाया है जो एक फाइल को पढ़ने जैसे फ़ंक्शन को निष्पादित करता है जो PHP "सर्वर" फ़ाइल चलाकर जावास्क्रिप्ट का हिस्सा नहीं है, और जावास्क्रिप्ट का उपयोग करते हुए एप्लिकेशन लिखते समय इसे बहुत उपयोगी लगता है। ऐसे अजाक्स के लिए किसी स्थानीय वेबसर्वर की आवश्यकता नहीं है।
डेविड स्पेक्टर

10

जावास्क्रिप्ट में मॉड्यूल को लागू करने के कई तरीके हैं, यहां 2 सबसे लोकप्रिय हैं:

ES6 मॉड्यूल

ब्राउज़र्स इस मोडलिंग सिस्टम का समर्थन नहीं करते हैं, इसलिए इस सिंटैक्स का उपयोग करने के लिए आपको वेबपैक जैसे बंडल का उपयोग करना होगा। एक बंडल का उपयोग करना वैसे भी बेहतर है क्योंकि यह आपकी सभी विभिन्न फ़ाइलों को एकल (या युगल संबंधित) फ़ाइलों में संयोजित कर सकता है। यह सर्वर से क्लाइंट तक फ़ाइलों को तेजी से काम करेगा क्योंकि प्रत्येक 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

9

मैं इस सवाल पर आया क्योंकि मैं उपयोगी जावास्क्रिप्ट प्लगइन्स के संग्रह को बनाए रखने के लिए एक सरल तरीके की तलाश कर रहा था। यहाँ के कुछ समाधानों को देखने के बाद, मैं इसे लेकर आया:

  1. "Plugins.js" (या Extension.js या जो भी आप चाहते हैं) नामक एक फ़ाइल सेट करें। अपनी प्लगइन फ़ाइलों को उस एक मास्टर फ़ाइल के साथ रखें।

  2. plugins.js के पास एक सरणी pluginNames[]होगी जिसे हम ओवररेट करेंगे each(), फिर <script>प्रत्येक प्लगइन के लिए एक टैग को सिर पर जोड़ देंगे

//set array to be updated when we add or remove plugin files
var pluginNames = ["lettering", "fittext", "butterjam", etc.];

//one script tag for each plugin
$.each(pluginNames, function(){
    $('head').append('<script src="js/plugins/' + this + '.js"></script>');
});
  1. मैन्युअल रूप से अपने सिर में केवल एक फ़ाइल कॉल करें:
    <script src="js/plugins/plugins.js"></script>

परंतु:

भले ही सभी प्लगइन्स सिर में टैग हो जाते हैं जिस तरह से वे चाहते हैं, वे हमेशा ब्राउज़र द्वारा नहीं चलाते हैं जब आप पृष्ठ पर क्लिक करते हैं या ताज़ा करते हैं।

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


@ क्या, आपका समाधान खदान की तुलना में बहुत साफ दिखता है और मुझे चिंता है कि अगर मैं मेरा उपयोग करता हूं तो कुछ त्रुटियां हो सकती हैं, क्योंकि यह .append () का उपयोग करता है। तो इसका उपयोग करने के लिए, आप बस उस फ़ंक्शन को एक बार कॉल कर सकते हैं, जिसमें प्रत्येक प्लगइन फ़ाइल जिसे आप शामिल करना चाहते हैं?
rgb_life
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.