क्या जावास्क्रिप्ट के समान कुछ है @import
सीएसएस है जो आपको एक जावास्क्रिप्ट फाइल को दूसरी जावास्क्रिप्ट फाइल के अंदर शामिल करने की अनुमति देता है?
script
टैग का उपयोग करना चाहिए ?
क्या जावास्क्रिप्ट के समान कुछ है @import
सीएसएस है जो आपको एक जावास्क्रिप्ट फाइल को दूसरी जावास्क्रिप्ट फाइल के अंदर शामिल करने की अनुमति देता है?
script
टैग का उपयोग करना चाहिए ?
जवाबों:
जावास्क्रिप्ट के पुराने संस्करणों में कोई आयात, शामिल या आवश्यकता नहीं थी, इसलिए इस समस्या के कई अलग-अलग दृष्टिकोण विकसित किए गए हैं।
लेकिन 2015 (ES6) के बाद से, Node.js में मॉड्यूल आयात करने के लिए जावास्क्रिप्ट में ES6 मॉड्यूल मानक है, जो कि अधिकांश आधुनिक ब्राउज़रों द्वारा भी समर्थित है ।
पुराने ब्राउज़र, जैसे निर्माण उपकरणों के साथ संगतता के लिए Webpack और रोलअप और / या transpilation उपकरण की तरह कोलाहल इस्तेमाल किया जा सकता।
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";
सफारी 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 पर अधिक पढ़ें
पुराने 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 कॉल के साथ एक अतिरिक्त स्क्रिप्ट लोड कर सकते हैं और फिर 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 पुस्तकालय लोड हो रहा है कार्यक्षमता प्रदान करता है एक लाइन में :
$.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;
। सामान्य रूप से जावास्क्रिप्ट लोड करने पर एक शानदार लेख है जो इस पर चर्चा करता है।
जैसा कि इस उत्तर के शीर्ष पर उल्लेख किया गया है, कई डेवलपर्स अपनी परियोजनाओं में पार्सल, वेबपैक या बैबेल जैसे बिल्ड / ट्रांसप्लिकेशन टूल (एस) का उपयोग करते हैं, जिससे उन्हें आगामी जावास्क्रिप्ट सिंटैक्स का उपयोग करने की अनुमति मिलती है, पुराने ब्राउज़रों के लिए पिछड़े संगतता प्रदान करते हैं, फ़ाइलों को जोड़ते हैं, छोटा करते हैं। कोड विभाजन करना आदि।
onreadystatechange
घटना और readyState
संपत्ति) के लिए कुछ संशोधन की आवश्यकता होती है । साथ ही, डायनेमिक स्क्रिप्ट लोडिंग को ब्रोसर के प्रीलोड स्कैनर से लाभ नहीं होता है। इस HTML5Rocks लेख की सिफारिश करें: html5rocks.com/en/tutorials/speed/script-loading
किसी को भी और अधिक उन्नत चीज़ की तलाश में है, तो बाहर की कोशिश 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 से उद्धरण :
आवश्यकता है सादे जावास्क्रिप्ट फ़ाइलें और साथ ही अधिक परिभाषित मॉड्यूल लोड करता है। यह एक वेब वर्कर सहित इन-ब्राउज़र उपयोग के लिए अनुकूलित है, लेकिन इसे राइनो और नोड जैसे अन्य जावास्क्रिप्ट वातावरणों में उपयोग किया जा सकता है। यह एसिंक्रोनस मॉड्यूल एपीआई को लागू करता है।
आवश्यकताएँ / मॉड्यूल को लोड करने के लिए जेआरजे सादे स्क्रिप्ट टैग का उपयोग करता है, इसलिए इसे आसान डिबगिंग के लिए अनुमति देना चाहिए। यह केवल मौजूदा जावास्क्रिप्ट फ़ाइलों को लोड करने के लिए इस्तेमाल किया जा सकता है, इसलिए आप इसे अपनी मौजूदा परियोजना में अपनी जावास्क्रिप्ट फ़ाइलों को फिर से लिखने के बिना जोड़ सकते हैं।
...
वास्तव में एक जावास्क्रिप्ट फ़ाइल को एसिंक्रोनस रूप से लोड करने का एक तरीका है , इसलिए आप इसे लोड करने के ठीक बाद अपनी नई भरी हुई फ़ाइल में शामिल फ़ंक्शन का उपयोग कर सकते हैं, और मुझे लगता है कि यह सभी ब्राउज़रों में काम करता है।
आपको अपने पृष्ठ 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()
फ़ंक्शन को कॉल किया जाता है, और आपको अलर्ट मिलता है।
(यह जवाब ई-सिटिस की टिप्पणी के जवाब में है)।
jQuery.getScript
, इस तरह आप प्लगइन लिखने के बारे में चिंता करने की ज़रूरत नहीं है ...
"
, तो कोड टूट जाएगा
एक और तरीका है, कि मेरी राय में बहुत क्लीनर है, एक <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();
async: false
माना जाता है कि यह पदावनत है। यह नहीं! जैसा कि आपकी बोली में कहा गया है, केवल jqXHR संबंधित सामान है।
आपके लिए एक अच्छी खबर है। बहुत जल्द आप जावास्क्रिप्ट कोड आसानी से लोड कर पाएंगे। यह जावास्क्रिप्ट कोड के मॉड्यूल आयात करने का एक मानक तरीका बन जाएगा और कोर जावास्क्रिप्ट का ही हिस्सा होगा।
आपको बस import cond from 'cond.js';
किसी मैक्रो नाम की cond
फाइल से लोड करने के लिए लिखना होगा cond.js
।
तो आपको किसी भी जावास्क्रिप्ट ढांचे पर भरोसा करने की आवश्यकता नहीं है और न ही आपको स्पष्ट रूप से अजाक्स कॉल करना है।
को देखें:
एक जावास्क्रिप्ट टैग को गतिशील रूप से उत्पन्न करना और इसे अन्य जावास्क्रिप्ट कोड के अंदर से 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");
js.onload = callback;
कथन import
ECMAScript 6 में है।
वाक्य - विन्यास
import name from "module-name";
import { member } from "module-name";
import { member as alias } from "module-name";
import { member1 , member2 } from "module-name";
import { member1 , member2 as alias2 , [...] } from "module-name";
import name , { member [ , [...] ] } from "module-name";
import "module-name" as name;
शायद आप इस फ़ंक्शन का उपयोग कर सकते हैं जो मैंने इस पृष्ठ पर पाया है कि मैं जावास्क्रिप्ट फ़ाइल में जावास्क्रिप्ट फ़ाइल कैसे शामिल करूं? :
function include(filename)
{
var head = document.getElementsByTagName('head')[0];
var script = document.createElement('script');
script.src = filename;
script.type = 'text/javascript';
head.appendChild(script)
}
script.onload = callback;
var
, तो चर वैश्विक होगा?
यहाँ 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
इसकी प्रतिक्रिया में हेडर सेट करना होगा ।
http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStuff/userjs/aagmfunctions.js
)
<script>
टैग के माध्यम से एक स्क्रिप्ट लोड कर सकते हैं , के माध्यम से नहीं XMLHttpRequest
।
const XMLHttpRequest = Components.Constructor("@mozilla.org/xmlextras/xmlhttprequest;1");
मैंने यह जावास्क्रिप्ट कोड ( डोम हेरफेर के लिए प्रोटोटाइप का उपयोग करके ) लिखा है :
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>
यहाँ पर सामान्यीकृत संस्करण है कि फेसबुक अपने सर्वव्यापी लाइक बटन के लिए कैसे करता है:
<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/ पर और पढ़ें ।
यदि आप शुद्ध जावास्क्रिप्ट में चाहते हैं, तो आप उपयोग कर सकते हैं document.write
।
document.write('<script src="myscript.js" type="text/javascript"></script>');
यदि आप jQuery लाइब्रेरी का उपयोग करते हैं, तो आप $.getScript
विधि का उपयोग कर सकते हैं ।
$.getScript("another_script.js");
आप 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
यहाँ दिखाए गए अधिकांश समाधान गतिशील लोडिंग को दर्शाते हैं। मैं एक संकलक के बजाय खोज रहा था जो सभी आउटपुट फ़ाइलों को एक एकल आउटपुट फ़ाइल में इकट्ठा करता है। सीएसएस के साथ कम / सास प्रीप्रोसेसरों के समान है@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(){}
}
};
यदि जावास्क्रिप्ट फ़ाइल लोड करने का आपका उद्देश्य आयातित / शामिल फ़ाइल से फ़ंक्शन का उपयोग कर रहा है , तो आप एक वैश्विक ऑब्जेक्ट को भी परिभाषित कर सकते हैं और फ़ंक्शन को ऑब्जेक्ट आइटम पर सेट कर सकते हैं। उदाहरण के लिए:
A = {};
A.func1 = function() {
console.log("func1");
}
A.func2 = function() {
console.log("func2");
}
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>
यह करना चाहिए:
xhr = new XMLHttpRequest();
xhr.open("GET", "/soap/ajax/11.0/connection.js", false);
xhr.send();
eval(xhr.responseText);
eval
क्या यह गलत है है। से Crockford , " eval
बुराई है। eval
समारोह जावास्क्रिप्ट का सबसे दुरुपयोग की सुविधा है। यह करने से बचें। eval
उपनाम है। का प्रयोग न करें Function
निर्माता। तार पारित मत करो setTimeout
या setInterval
।" यदि आपने उसका "जावास्क्रिप्ट: द गुड पार्ट्स" नहीं पढ़ा है, तो अभी बाहर जाएं और अभी करें। आप होगा यह अफसोस नहीं।
http://web.archive.org/web/20140905044059/http://www.howtocreate.co.uk/operaStuff/userjs/aagmfunctions.js
)
या रन टाइम पर शामिल करने के बजाय, अपलोड करने से पहले एक स्क्रिप्ट का उपयोग करने के लिए संक्षिप्त करें।
मैं Sprockets का उपयोग करता हूं करता हूं (मुझे नहीं पता कि क्या अन्य हैं)। आप अपने जावास्क्रिप्ट कोड को अलग-अलग फाइलों में बनाते हैं और उन टिप्पणियों को शामिल करते हैं जिन्हें Sprockets इंजन द्वारा संसाधित किया जाता है। विकास के लिए आप क्रमिक रूप से फ़ाइलों को शामिल कर सकते हैं, फिर उत्पादन के लिए उन्हें मर्ज कर सकते हैं ...
यह सभी देखें:
मेरे पास एक सरल मुद्दा था, लेकिन मैं इस सवाल के जवाब से चकित था।
मुझे एक जावास्क्रिप्ट फाइल (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 फ़ाइल की आवश्यकता होती है।
<script>
टैग होगा। इससे संगठन को मदद मिल सकती है। यह उत्तर बस वह नहीं है जो प्रश्न पूछ रहा था, और इस संदर्भ में आदर्श नहीं है।
यदि आप वेब वर्कर्स का उपयोग कर रहे हैं और कामगार के दायरे में अतिरिक्त स्क्रिप्ट शामिल करना चाहते हैं, तो स्क्रिप्ट में जोड़ने के बारे में दिए गए अन्य उत्तरhead
टैग में आदि आपके लिए काम नहीं करेंगे।
सौभाग्य से, वेब वर्कर्स का अपना importScripts
कार्य है जो वेब वर्कर के दायरे में एक वैश्विक कार्य है, जो ब्राउज़र के लिए मूल है क्योंकि यह विनिर्देश का हिस्सा है ।
वैकल्पिक रूप से, आपके प्रश्न पर प्रकाश डाला गया दूसरा सबसे बड़ा जवाब है , आवश्यकताएँ भी एक वेब वर्कर के अंदर स्क्रिप्ट सहित संभाल सकती हैं (संभवतः importScripts
खुद को बुला रही है, लेकिन कुछ अन्य उपयोगी सुविधाओं के साथ)।
जाँच के साथ आधुनिक भाषा में यदि स्क्रिप्ट पहले ही लोड हो चुकी है तो यह होगा:
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 => {})
var pi = 3.14
। loadJS () फंक्शन के जरिएloadJs("pi.js").then(function(){ console.log(pi); });
@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
जावास्क्रिप्ट फाइल एक्शन (मिक्सचर बॉयलरप्लेट्स में से एक) में और इसके द्वारा थोड़ा उलझन में होने ("आप ऐसा कर सकते हैं?" मैंने खुद से सोचा)। तब मुझे एहसास हुआ कि यह एक एप्लिकेशन-विशिष्ट फ़ाइल प्रकार (कुछ हद तक निराशाजनक, सहमत) था। फिर भी, लगा कि ज्ञान दूसरों के लिए मददगार हो सकता है।
अद्यतन : मिश्रण अब मुफ़्त (ऑफ़लाइन) है।
अद्यतन : मिश्रण अब बंद कर दिया गया है। पुराने मिश्रण रिलीज अभी भी उपलब्ध हैं
var js = document.createElement("script");
js.type = "text/javascript";
js.src = jsFilePath;
document.body.appendChild(js);
body
जाएगा जब अभी तक मौजूद नहीं है या संशोधित नहीं किया जा सकता है। साथ ही, उत्तरों को समझाने में मदद करता है।
मेरी सामान्य विधि है:
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 का नया स्क्रिप्ट टैग (पहले एक के बाद) बनाता है। यह इसे अतुल्यकालिक मोड पर सेट करता है, इसलिए यह बाकी कोड को ब्लॉक नहीं करता है, लेकिन रेडीस्टेट (लोड होने वाली सामग्री की स्थिति) को 'लोड' में बदलने पर कॉलबैक कॉल करता है।
यद्यपि ये उत्तर महान हैं, एक सरल "समाधान" है जो स्क्रिप्ट लोडिंग के अस्तित्व में आने के बाद से है, और यह अधिकांश लोगों के उपयोग के मामलों के 99.999% को कवर करेगा। बस उस स्क्रिप्ट को शामिल करें जिसकी आपको आवश्यकता है उस स्क्रिप्ट से पहले। अधिकांश परियोजनाओं के लिए यह निर्धारित करने में देर नहीं लगती कि किन लिपियों की जरूरत है और किस क्रम में हैं।
<!DOCTYPE HTML>
<html>
<head>
<script src="script1.js"></script>
<script src="script2.js"></script>
</head>
<body></body>
</html>
अगर Script2 के लिए script1 की आवश्यकता है, तो यह वास्तव में कुछ ऐसा करने का सबसे आसान तरीका है। मुझे बहुत आश्चर्य है कि कोई भी इसे नहीं लाया है, क्योंकि यह सबसे स्पष्ट और सरल उत्तर है जो लगभग हर एक मामले में लागू होगा।
मैंने एक साधारण मॉड्यूल लिखा है जो जावास्क्रिप्ट में मॉड्यूल स्क्रिप्ट सहित / आयात करने के काम को स्वचालित करता है। कोड की विस्तृत व्याख्या के लिए, ब्लॉग पोस्ट को देखें कि जावास्क्रिप्ट की आवश्यकता / आयात / मॉड्यूल शामिल हैं ।
// ----- 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);
};
यह स्क्रिप्ट किसी अन्य <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);
})();
इसमें Head.js भी है । इससे निपटना बहुत आसान है:
head.load("js/jquery.min.js",
"js/jquery.someplugin.js",
"js/jquery.someplugin.css", function() {
alert("Everything is ok!");
});
जैसा कि आप देखते हैं, यह आवश्यकता से अधिक आसान है ।js और jQuery की $.getScript
विधि के रूप में सुविधाजनक है । इसमें कुछ एडवांस फीचर्स भी हैं, जैसे सशर्त लोडिंग, फीचर डिटेक्शन और भी बहुत कुछ ।
इस प्रश्न के लिए कई संभावित उत्तर हैं। मेरा जवाब स्पष्ट रूप से उनमें से कई पर आधारित है। यह वही है जो मैंने सभी उत्तरों के माध्यम से पढ़ने के बाद समाप्त किया।
$.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"
});
जावास्क्रिप्ट में मॉड्यूल को लागू करने के कई तरीके हैं, यहां 2 सबसे लोकप्रिय हैं:
ब्राउज़र्स इस मोडलिंग सिस्टम का समर्थन नहीं करते हैं, इसलिए इस सिंटैक्स का उपयोग करने के लिए आपको वेबपैक जैसे बंडल का उपयोग करना होगा। एक बंडल का उपयोग करना वैसे भी बेहतर है क्योंकि यह आपकी सभी विभिन्न फ़ाइलों को एकल (या युगल संबंधित) फ़ाइलों में संयोजित कर सकता है। यह सर्वर से क्लाइंट तक फ़ाइलों को तेजी से काम करेगा क्योंकि प्रत्येक 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
इस मोड्यूलिंग सिस्टम का उपयोग 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
मैं इस सवाल पर आया क्योंकि मैं उपयोगी जावास्क्रिप्ट प्लगइन्स के संग्रह को बनाए रखने के लिए एक सरल तरीके की तलाश कर रहा था। यहाँ के कुछ समाधानों को देखने के बाद, मैं इसे लेकर आया:
"Plugins.js" (या Extension.js या जो भी आप चाहते हैं) नामक एक फ़ाइल सेट करें। अपनी प्लगइन फ़ाइलों को उस एक मास्टर फ़ाइल के साथ रखें।
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>');
});
<script src="js/plugins/plugins.js"></script>
परंतु:
भले ही सभी प्लगइन्स सिर में टैग हो जाते हैं जिस तरह से वे चाहते हैं, वे हमेशा ब्राउज़र द्वारा नहीं चलाते हैं जब आप पृष्ठ पर क्लिक करते हैं या ताज़ा करते हैं।
मैंने पाया है कि PHP में स्क्रिप्ट टैग को लिखना अधिक विश्वसनीय है। आपको केवल इसे एक बार लिखना है और यह केवल जावास्क्रिप्ट का उपयोग करके प्लगइन को कॉल करने जितना ही काम है।