मैं जावास्क्रिप्ट में नाम स्थान की घोषणा कैसे करूं?

Question

मैं जावास्क्रिप्ट में एक नाम स्थान कैसे बनाऊं ताकि मेरी वस्तुओं और कार्यों को अन्य समान नाम वाली वस्तुओं और कार्यों द्वारा अधिलेखित न किया जाए? मैंने निम्नलिखित का उपयोग किया है:

if (Foo == null || typeof(Foo) != "object") { var Foo = new Object();}

क्या ऐसा करने का एक और अधिक सुरुचिपूर्ण या संक्षिप्त तरीका है?

Comments

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

— अन्नकूट

एक शीर्ष-स्तरीय "नेमस्पेस" (विंडो प्रॉपर्टी) लें। इसे अपना बनाओ। परीक्षण में संघर्ष का जल्द पता लगाया जाना चाहिए। इन सभी को जोड़ने की जहमत मत उठाइए "क्या होगा अगर" यह डुप्लिकेट "नामस्थान" के लिए एक घातक मुद्दा है और इसे ऐसे ही माना जाना चाहिए । आप एक कस्टम "नेमस्पेस" के निवास की अनुमति देने के लिए jQuery जैसे दृष्टिकोण का पालन कर सकते हैं; लेकिन यह अभी भी एक डिज़ाइन-टाइम मुद्दा है।

कृपया अपने स्वीकृत उत्तर को stackoverflow.com/questions/881515/… पर बदलें , जो एक बहुत अधिक सुरुचिपूर्ण और अद्यतन समाधान है।

— hlfcoding

@ पीयूआई क्या करता है? मेरा मानना ​​है कि वे अपने नाम स्थान में वृद्धि के लिए ठीक यही करते हैं। एक HTTP वातावरण में प्रदर्शन के लिए इस तरह की चाल की आवश्यकता है?

— साइमन_वेअर

प्रदर्शन के मुद्दों के लिए भी stackoverflow.com/questions/2102591/… देखें

— टिम एबेल

Answer 1

यह मुझे पंसद है:

var yourNamespace = {

    foo: function() {
    },

    bar: function() {
    }
};

...

yourNamespace.foo();

Comments

महत्वपूर्ण बात यह है कि एक रूट वेरिएबल से अधिक विस्तार के बारे में धार्मिक होना चाहिए। इससे सब कुछ प्रवाहित होना चाहिए।

— अन्नकूट

यह आपके कोड के लिए क्लोजर नहीं बनाता है - यह आपके अन्य कार्यों को कॉल करने के लिए थकाऊ बनाता है क्योंकि उन्हें हमेशा ऐसा दिखता है: yourNamespace.bar (); मैंने इस डिज़ाइन समस्या को हल करने के लिए एक ओपन सोर्स प्रोजेक्ट JUST बनाया: github.com/mckoss/namespace ।

— मस्कॉस

एनाकाटा: "महत्वपूर्ण बिंदु एक रूट चर से आगे विस्तार के बारे में धार्मिक होना है।" - यह क्यों है?

— user406905

@alex - उथली वस्तु संरचना क्यों होनी चाहिए?

— रियान

@ रेयान का मतलब था कि सब कुछ अंडर होना चाहिए MyApp, जैसे कि MyApp.Views.Profile = {}इसके बजाय MyApp.users = {}और MyViews.Profile = {}। जरूरी नहीं है कि केवल दो स्तरों की गहराई होनी चाहिए।

— एलेक्स

Answer 2

मैं एंटरप्राइज़ jQuery साइट पर पाए गए दृष्टिकोण का उपयोग करता हूं :

यहाँ उनका उदाहरण है कि कैसे निजी और सार्वजनिक संपत्तियों और कार्यों को घोषित किया जाए। सब कुछ एक स्व-निष्पादित अनाम फ़ंक्शन के रूप में किया जाता है।

(function( skillet, $, undefined ) {
    //Private Property
    var isHot = true;

    //Public Property
    skillet.ingredient = "Bacon Strips";

    //Public Method
    skillet.fry = function() {
        var oliveOil;

        addItem( "\t\n Butter \n\t" );
        addItem( oliveOil );
        console.log( "Frying " + skillet.ingredient );
    };

    //Private Method
    function addItem( item ) {
        if ( item !== undefined ) {
            console.log( "Adding " + $.trim(item) );
        }
    }
}( window.skillet = window.skillet || {}, jQuery ));

इसलिए यदि आप सार्वजनिक सदस्यों में से किसी एक का उपयोग करना चाहते हैं तो आप बस जाएंगे skillet.fry()याskillet.ingredients ।

वास्तव में अच्छा यह है कि अब आप सटीक समान सिंटैक्स का उपयोग करके नामस्थान का विस्तार कर सकते हैं।

//Adding new Functionality to the skillet
(function( skillet, $, undefined ) {
    //Private Property
    var amountOfGrease = "1 Cup";

    //Public Method
    skillet.toString = function() {
        console.log( skillet.quantity + " " +
                     skillet.ingredient + " & " +
                     amountOfGrease + " of Grease" );
        console.log( isHot ? "Hot" : "Cold" );
    };
}( window.skillet = window.skillet || {}, jQuery ));

तीसरा undefinedतर्क

तीसरा, undefinedतर्क मूल्य के चर का स्रोत है undefined। मुझे यकीन नहीं है कि यह आज भी प्रासंगिक है, लेकिन पुराने ब्राउज़रों / जावास्क्रिप्ट मानकों (एक्मास्क्रिप्ट 5, जावास्क्रिप्ट <1.8.5 ~ फ़ायरफ़ॉक्स 4) के साथ काम करते समय, वैश्विक-गुंजाइश चरundefined लेखन योग्य है, इसलिए कोई भी इसके मूल्य को फिर से लिख सकता है। तीसरा तर्क (जब कोई मान पारित नहीं किया जाता है) एक चर बनाता है जिसका नाम undefinedनेमस्पेस / फ़ंक्शन पर रखा जाता है। क्योंकि जब आपने नाम स्थान बनाया था, तो कोई मान पारित नहीं किया गया था, यह मूल्य के लिए चूक है undefined।

Comments

इस बेहतरीन नमूने के लिए +1। रुचि रखने वाले किसी भी व्यक्ति के लिए, यह नमूना मिक्स 2011 में एलियाह मनोर की उत्कृष्ट प्रस्तुति का हिस्सा था (शीर्षक को अनदेखा करें) live.visitmix.com/MIX11/Session/Speaker/Elijah-Manor

— डैरेन लुईस

एलिजा के लेख से, यहाँ इस दृष्टिकोण के पक्ष और विपक्ष हैं, जो विरोधाभासी हैं। पेशेवरों: 1. सार्वजनिक और निजी संपत्तियों और तरीकों, 2. बोझिल OLN का उपयोग नहीं करता है, 3. अनिर्धारित की रक्षा करता है। 4. सुनिश्चित करता है कि $ jQuery को संदर्भित करता है, 5. Namespace फ़ाइलों को जोड़ सकता है, विपक्ष: OLN

— जेके बेक की

इसे आज आईआईएफई ( तत्काल आमंत्रित कार्य अभिव्यक्ति ) कहा जाता है । आपके उत्तर के लिए धन्यवाद +1!

— गुस्तावो गोंडिम २५'१३

@ चेक: निश्चित नहीं है कि अभी भी प्रासंगिक है, लेकिन तीसरा, undefinedतर्क मूल्य के चर का स्रोत है undefined। पुराने ब्राउज़रों / जावास्क्रिप्ट मानक (एक्मास्क्रिप्ट 5, जावास्क्रिप्ट <1.8.5 ~ फ़ायरफ़ॉक्स 4) के साथ काम करते समय, वैश्विक-स्कोप वैरिएबल undefinedलेखन योग्य है, इसलिए कोई भी इसके मूल्य को फिर से लिख सकता है। तीसरा, अतिरिक्त तर्क जो आप नहीं दे रहे हैं undefined, उसका मूल्य बनता है , इसलिए आप नेमस्पेस-स्कोप बना रहे थे undefinedजो कि बाहर के स्रोतों द्वारा दोबारा नहीं लिखे जाएंगे।

— mrówa

@SapphireSun का लाभ window.skillet = window.skillet || {}यह है कि यह कई लिपियों को सुरक्षित रूप से एक ही नामस्थान में जोड़ने की अनुमति देता है जब वे पहले से नहीं जानते हैं कि वे किस क्रम में निष्पादित करेंगे। यह या तो सहायक हो सकता है यदि आप अपने कोड को तोड़ने के बिना मनमाने ढंग से अपनी स्क्रिप्ट समावेशन को पुन: व्यवस्थित करने में सक्षम होना चाहते हैं, या यदि आप स्क्रिप्ट को अतुल्य विशेषता के साथ अतुल्यकालिक रूप से लोड करना चाहते हैं और इसलिए निष्पादन आदेश के बारे में कोई गारंटी नहीं है। देखें stackoverflow.com/questions/6439579/…

— मार्क अमेरी

Answer 3

इसे करने का एक और तरीका, जिसे मैं इसे वस्तु शाब्दिक रूप से थोड़ा कम प्रतिबंधक मानता हूं, यह है:

var ns = new function() {

    var internalFunction = function() {

    };

    this.publicFunction = function() {

    };
};

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

Comments

1. ओएलएन और मॉड्यूल पैटर्न के बीच अंतर है। 2. मुझे ओएलएन / हमेशा की तरह नहीं है / जैसा कि आपको याद रखना होगा कि आखिरी ट्रेलिंग कॉमा नहीं डालना है और आपके सभी विशेषताओं को एक मूल्य (जैसे अशक्त या अपरिभाषित) के साथ आरंभीकृत किया जाना चाहिए। इसके अलावा, यदि आपको सदस्य कार्यों के लिए क्लोजर की आवश्यकता है, तो आपको उन तरीकों में से प्रत्येक के लिए छोटे फ़ंक्शन कारखानों की आवश्यकता होगी। एक और बात यह है कि आपको अपने सभी नियंत्रण संरचनाओं को कार्यों के अंदर संलग्न करना होगा, जबकि उपरोक्त रूप वह नहीं है। यह कहना नहीं है कि मैं ओएलएन का उपयोग नहीं करता हूं, बस यही है कि कभी-कभी मुझे यह पसंद नहीं है।

— इओनु

मुझे यह दृष्टिकोण पसंद है क्योंकि यह निजी कार्यों, चर, और छद्म स्थिरांक (यानी var API_K_ = 12345;) के लिए अनुमति देता है।

— लॉरेंस बरसांती

मुझे यह कॉमा से अलग किए गए ऑब्जेक्ट कंटेनर से बेहतर लगता है जिसे उच्च वोट दिया गया है। मैं तुलना में कोई कमी नहीं देखता, या तो। क्या मैं कुछ भूल रहा हूँ?

— ल्यूसेंट

जेएस नौसिखिया यहाँ ... ऐसा क्यों है कि मुझे टाइप नहीं करना है ns().publicFunction(), वह है ... ns.publicFunction()काम करता है।

— जॉन क्राफ्ट

@ जॉन क्राफ्ट, यह newकीवर्ड के सामने कीवर्ड का नेकॉज है function। मूल रूप से, यह क्या कर रहा है कि यह एक अनाम फ़ंक्शन (और एक फ़ंक्शन के रूप में, यह एक अच्छी तरह से एक कंस्ट्रक्टर है) की घोषणा कर रहा है, और यह तुरंत एक कंस्ट्रक्टर के रूप में इसका उपयोग करता है new। जैसे, अंतिम मूल्य जो अंदर जमा हो जाता nsहै, उस गुमनाम कंस्ट्रक्टर का एक (अनोखा) उदाहरण है। आशा है कि यह समझ में आता है।

— आयनोन जी। स्टेन स्टेन

Answer 4

क्या ऐसा करने का एक और अधिक सुरुचिपूर्ण या संक्षिप्त तरीका है?

हाँ। उदाहरण के लिए:

var your_namespace = your_namespace || {};

तब आपके पास हो सकता है

var your_namespace = your_namespace || {};
your_namespace.Foo = {toAlert:'test'};
your_namespace.Bar = function(arg) 
{
    alert(arg);
};
with(your_namespace)
{
   Bar(Foo.toAlert);
}

Comments

यह मुझे IE7 में एक त्रुटि देता है। var your_namespace = (टाइप करें your_namespace == "अपरिभाषित" || आपका? @_amespace)? {}: your_namespace; बेहतर काम करता है।

— mjallday

इसे var your_namespace = your_namespace = your_namespace होना चाहिए || {(हर ब्राउज़र में काम करता है;)

— पालो

मुझ से +1! पतली एक ही फाइल के अंदर अलग-अलग फाइल या अलग-अलग जगहों पर एक लाइब्रेरी का विस्तार करके जैको प्रीटोरियस जवाब के रूप में काम करता है। बस शानदार!

— सेंटुरियन

@Palo क्या आप बता सकते हैं कि ऐसा क्यों होना चाहिए? var your_namespace = your_namespace = your_namespace || {}

— श्रीराम

आपको विभिन्न js फ़ाइलों में your_namespace ऑब्जेक्ट का विस्तार करने की संभावना होगी। जब var का उपयोग करते हुए your_namespace = {} आप ऐसा नहीं कर सकते हैं, जैसा कि प्रत्येक फ़ाइल द्वारा ऑब्जेक्ट ओवरराइड किया जाएगा

— एलेक्स पचुरार

Answer 5

मैं इसे सामान्य रूप से एक क्लोजर में बनाता हूं:

var MYNS = MYNS || {};

MYNS.subns = (function() {

    function privateMethod() {
        // Do private stuff, or build internal.
        return "Message";
    }

    return {
        someProperty: 'prop value',
        publicMethod: function() {
            return privateMethod() + " stuff";
        }
    };
})();

वर्षों से मेरी शैली में इसे लिखने के बाद से एक सूक्ष्म बदलाव आया है, और मैं अब खुद को इस तरह से बंद लिखते हुए पाता हूं:

var MYNS = MYNS || {};

MYNS.subns = (function() {
    var internalState = "Message";

    var privateMethod = function() {
        // Do private stuff, or build internal.
        return internalState;
    };
    var publicMethod = function() {
        return privateMethod() + " stuff";
    };

    return {
        someProperty: 'prop value',
        publicMethod: publicMethod
    };
})();

इस तरह मैं सार्वजनिक एपीआई और कार्यान्वयन को आसानी से समझ पाता हूं। कार्यान्वयन के लिए एक सार्वजनिक इंटरफ़ेस होने के रूप में रिटर्न स्टेटमेंट के बारे में सोचें।

Comments

क्या आपको जांच नहीं करनी चाहिए MYNS.subns = MYNS.subns || {}??

— मिरको

एक अच्छा बिंदु जो डेवलपर्स के इरादे के लिए व्यायाम होना चाहिए। आपको यह विचार करने की आवश्यकता है कि जब यह मौजूद होता है तो क्या करना है, इसे बदलें, त्रुटि, मौजूदा या संस्करण की जाँच करें और सशर्त रूप से प्रतिस्थापित करें। मेरे पास अलग-अलग स्थितियां हैं जो प्रत्येक संस्करण के लिए कॉल करती हैं। ज्यादातर मामलों में आपके पास संभवतः यह एक कम जोखिम वाले किनारे के मामले के रूप में होता है और प्रतिस्थापित करना फायदेमंद हो सकता है, एक दुष्ट मॉड्यूल पर विचार करें जिसने एनएस को अपहृत करने की कोशिश की।

— ब्रेट रयान

पुस्तक "स्पीकिंग जावास्क्रिप्ट" में इस दृष्टिकोण की व्याख्या पृष्ठ 412 पर है यदि किसी के पास है, तो "क्विक एंड डर्टी मॉड्यूल" शीर्षक के तहत।

— सोफिरियो

अनुकूलन टिप: जबकि var foo = functionऔर function fooसमान हैं, निजी होने के नाते; जावास्क्रिप्ट की गतिशील-टाइप की प्रकृति के कारण, उत्तरार्द्ध थोड़ा तेज है क्योंकि यह अधिकांश दुभाषियों की पाइपलाइनों में कुछ निर्देशों को छोड़ देता है। इसके साथ var foo, टाइप सिस्टम को यह पता लगाने के लिए आमंत्रित करना होता है कि उक्त संस्करण को किस प्रकार को सौंपा जा रहा है, जबकि function foo, टाइप सिस्टम स्वचालित रूप से जानता है कि यह एक फ़ंक्शन है, इसलिए एक युगल फ़ंक्शन कॉल स्किप हो जाता है, जो सीपीयू निर्देशों के कम इनवोकेशन में अनुवाद करता है जैसे jmp, pushq, popq, आदि, जो एक छोटी सीपीयू पाइप लाइन के लिए अनुवाद।

— ब्रैडेन सर्वश्रेष्ठ

@ उफ़। आप सही हे। मैं एक अलग स्क्रिप्टिंग भाषा के बारे में सोच रहा था। हालांकि मैं अभी भी function fooवाक्य रचना पर जोर देता हूं कि यह अधिक पठनीय है। और मुझे अभी भी मेरा संस्करण पसंद है।

— ब्रैडेन बेस्ट

Answer 6

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

एक फ़ाइल नामस्थान का उपयोग करने का इरादा कर सकती है namespace.namespace1:

namespace = window.namespace || {};
namespace.namespace1 = namespace.namespace1 || {};

namespace.namespace1.doSomeThing = function(){}

कोई अन्य फ़ाइल नाम स्थान का उपयोग करना चाह सकती है namespace.namespace2:

namespace = window.namespace || {};
namespace.namespace2 = namespace.namespace2 || {};

namespace.namespace2.doSomeThing = function(){}

ये दोनों फाइलें आपस में या बिना टकराए एक साथ रह सकती हैं।

Comments

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

— DVK

कई फाइलों के लिए विशेष रूप से पूछ रहे सवाल: stackoverflow.com/questions/5150124/…

— Ciro Santilli 审查 files files files '18

Answer 7

यहां बताया गया है कि स्टोअन स्टेफानोव ने अपनी जावास्क्रिप्ट पैटर्न बुक में यह कैसे किया जो मुझे बहुत अच्छा लगा (यह भी पता चलता है कि वह कैसे टिप्पणियां करता है जो ऑटो-जनरेट किए गए एपीआई प्रलेखन के लिए अनुमति देता है, और कस्टम ऑब्जेक्ट के प्रोटोटाइप के लिए एक विधि कैसे जोड़ें):

/**
* My JavaScript application
*
* @module myapp
*/

/** @namespace Namespace for MYAPP classes and functions. */
var MYAPP = MYAPP || {};

/**
* A maths utility
* @namespace MYAPP
* @class math_stuff
*/
MYAPP.math_stuff = {

    /**
    * Sums two numbers
    *
    * @method sum
    * @param {Number} a First number
    * @param {Number} b Second number
    * @return {Number} Sum of the inputs
    */
    sum: function (a, b) {
        return a + b;
    },

    /**
    * Multiplies two numbers
    *
    * @method multi
    * @param {Number} a First number
    * @param {Number} b Second number
    * @return {Number} The inputs multiplied
    */
    multi: function (a, b) {
        return a * b;
    }
};

/**
* Constructs Person objects
* @class Person
* @constructor
* @namespace MYAPP
* @param {String} First name
* @param {String} Last name
*/
MYAPP.Person = function (first, last) {

    /**
    * First name of the Person
    * @property first_name
    * @type String
    */
    this.first_name = first;

    /**
    * Last name of the Person
    * @property last_name
    * @type String
    */
    this.last_name = last;
};

/**
* Return Person's full name
*
* @method getName
* @return {String} First name + last name
*/
MYAPP.Person.prototype.getName = function () {
    return this.first_name + ' ' + this.last_name;
};

Answer 8

मैं इस दृष्टिकोण का उपयोग करता हूं:

var myNamespace = {}
myNamespace._construct = function()
{
    var staticVariable = "This is available to all functions created here"

    function MyClass()
    {
       // Depending on the class, we may build all the classes here
       this.publicMethod = function()
       {
          //Do stuff
       }
    }

    // Alternatively, we may use a prototype.
    MyClass.prototype.altPublicMethod = function()
    {
        //Do stuff
    }

    function privateStuff()
    {
    }

    function publicStuff()
    {
       // Code that may call other public and private functions
    }

    // List of things to place publically
    this.publicStuff = publicStuff
    this.MyClass = MyClass
}
myNamespace._construct()

// The following may or may not be in another file
myNamespace.subName = {}
myNamespace.subName._construct = function()
{
   // Build namespace
}
myNamespace.subName._construct()

बाहरी कोड तब हो सकता है:

var myClass = new myNamespace.MyClass();
var myOtherClass = new myNamepace.subName.SomeOtherClass();
myNamespace.subName.publicOtherStuff(someParameter);

Comments

बहुत अच्छी जानकारी! धन्यवाद! बस सोच रहा था कि आपका Namespace.js पर क्या प्रभाव है। मैंने कभी भी इसका उपयोग नहीं किया है, इसलिए मैं सोच रहा हूं कि क्या आपके ज्ञान / कौशल / अनुभव के साथ कोई इसका उपयोग करने पर विचार करेगा।

— जॉन

मुझें यह पसंद है! दूसरी ओर मुझे इस बाहरी कोड की पहली पंक्ति पर यह कहते हुए अपवाद मिलता है कि: 'myNameSpace.MyClass' [अपरिभाषित] कंस्ट्रक्टर नहीं है। शायद यह जेएस कार्यान्वयन में निर्भर करता है? : /

— योशिबा

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

— एंथनीवजोन

@Anthony var का उपयोग करने के लिए बेहतर है MYNAMESPACE = MYNAMESPACE || {}; बस var myNamespace = {} का उपयोग करना असुरक्षित है और इसके नाम को कैपस में घोषित करने के लिए बेहतर है

— paul

@ अंपुल: "बेहतर" काफी व्यक्तिपरक हो सकता है। मुझे उस कोड को पढ़ने से नफरत है जो मुझ पर SHOUTS है इसलिए मैं उन पहचानकर्ताओं का उपयोग करने से बचता हूं जो सभी अपरकेस का उपयोग करते हैं। जबकि ns = ns || {}अधिक रक्षात्मक लग सकता है यह अन्य अप्रत्याशित परिणाम पैदा कर सकता है।

— एंथनीवजोन

Answer 9

यह N10pace.js के उपयोगकर्ता 106826 के लिंक का अनुवर्ती है। ऐसा लगता है कि परियोजना GitHub में स्थानांतरित हो गई है । यह अब smith / namespacedotjs है ।

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

यह आपको नामस्थान की घोषणा करने की अनुमति देता है, फिर उस नामस्थान में वस्तुओं / मॉड्यूल को परिभाषित करता है:

Namespace('my.awesome.package');
my.awesome.package.WildClass = {};

एक और विकल्प एक ही बार में नाम स्थान और उसकी सामग्री की घोषणा करना है:

Namespace('my.awesome.package', {
    SuperDuperClass: {
        saveTheDay: function() {
            alert('You are welcome.');
        }
    }
});

अधिक उपयोग उदाहरणों के लिए, स्रोत में example.js फ़ाइल देखें ।

Comments

जब तक आपको याद है कि इसमें कुछ प्रदर्शन निहितार्थ हैं, हर बार जब आप my.awesome.package.Wild का उपयोग करते हैं, तो आप मेरे, मेरे। की शानदार संपत्ति, और Wild.ass की संपत्ति का उपयोग कर रहे हैं। पैकेज।

— समस्टीफेन्स

Answer 10

नमूना:

var namespace = {};
namespace.module1 = (function(){

    var self = {};
    self.initialized = false;

    self.init = function(){
        setTimeout(self.onTimeout, 1000)
    };

    self.onTimeout = function(){
        alert('onTimeout')
        self.initialized = true;
    };

    self.init(); /* If it needs to auto-initialize, */
    /* You can also call 'namespace.module1.init();' from outside the module. */
    return self;
})()

आप वैकल्पिक रूप से एक localचर घोषित कर सकते हैं same, जैसे selfऔर local.onTimeoutयदि आप चाहते हैं कि यह निजी हो तो असाइन करें ।

Answer 11

आप नाम स्थान प्रदान करने के लिए एक साधारण फ़ंक्शन की घोषणा कर सकते हैं।

function namespace(namespace) {
    var object = this, tokens = namespace.split("."), token;

    while (tokens.length > 0) {
        token = tokens.shift();

        if (typeof object[token] === "undefined") {
            object[token] = {};
        }

        object = object[token];
    }

    return object;
}

// Usage example
namespace("foo.bar").baz = "I'm a value!";

Answer 12

यदि आपको निजी क्षेत्र की आवश्यकता है:

var yourNamespace = (function() {

  //Private property
  var publicScope = {};

  //Private property
  var privateProperty = "aaa"; 

  //Public property
  publicScope.publicProperty = "bbb";

  //Public method
  publicScope.publicMethod = function() {
    this.privateMethod();
  };

  //Private method
  function privateMethod() {
    console.log(this.privateProperty);
  }

  //Return only the public parts
  return publicScope;
}());

yourNamespace.publicMethod();

यदि आप कभी भी निजी क्षेत्र का उपयोग नहीं करेंगे:

var yourNamespace = {};

yourNamespace.publicMethod = function() {
    // Do something...
};

yourNamespace.publicMethod2 = function() {
    // Do something...
};

yourNamespace.publicMethod();

Answer 13

मॉड्यूल पैटर्न को मूल रूप से पारंपरिक सॉफ्टवेयर इंजीनियरिंग में कक्षाओं के लिए निजी और सार्वजनिक इनकैप्सुलेशन दोनों प्रदान करने के तरीके के रूप में परिभाषित किया गया था।

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

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

var myNamespace = (function () {

  var myPrivateVar, myPrivateMethod;

  // A private counter variable
  myPrivateVar = 0;

  // A private function which logs any arguments
  myPrivateMethod = function( foo ) {
      console.log( foo );
  };

  return {

    // A public variable
    myPublicVar: "foo",

    // A public function utilizing privates
    myPublicFunction: function( bar ) {

      // Increment our private counter
      myPrivateVar++;

      // Call our private method using bar
      myPrivateMethod( bar );

    }
  };

})();

लाभ

मॉड्यूल पैटर्न एक अच्छा विकल्प क्यों है? शुरुआत के लिए, यह डेवलपर्स के लिए बहुत साफ-सुथरा है जो ऑब्जेक्ट के उन्मुख पृष्ठभूमि से वास्तविक एनकैप्सुलेशन के विचार से आता है, कम से कम जावास्क्रिप्ट परिप्रेक्ष्य से।

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

नुकसान

मॉड्यूल पैटर्न के नुकसान यह है कि जब हम सार्वजनिक और निजी दोनों सदस्यों को अलग-अलग तरीके से एक्सेस करते हैं, जब हम दृश्यता को बदलना चाहते हैं, तो हमें वास्तव में उस स्थान पर बदलाव करना होगा जहां सदस्य का उपयोग किया गया था।

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

खुलासा मॉड्यूल पैटर्न

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

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

उनके प्रयासों का परिणाम एक अद्यतन पैटर्न था जहां हम बस अपने सभी कार्यों और चर को निजी दायरे में परिभाषित करेंगे और एक अनाम वस्तु को पॉइंटर्स के साथ निजी कार्यक्षमता में लौटाएंगे जिसे हम सार्वजनिक रूप से प्रकट करना चाहते थे।

रिवाइलिंग मॉड्यूल पैटर्न का उपयोग करने का एक उदाहरण नीचे पाया जा सकता है

var myRevealingModule = (function () {

        var privateVar = "Ben Cherry",
            publicVar = "Hey there!";

        function privateFunction() {
            console.log( "Name:" + privateVar );
        }

        function publicSetName( strName ) {
            privateVar = strName;
        }

        function publicGetName() {
            privateFunction();
        }


        // Reveal public pointers to
        // private functions and properties

        return {
            setName: publicSetName,
            greeting: publicVar,
            getName: publicGetName
        };

    })();

myRevealingModule.setName( "Paul Kinlan" );

लाभ

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

नुकसान

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

सार्वजनिक ऑब्जेक्ट सदस्य जो निजी चर का उल्लेख करते हैं, वे भी बिना पैच नियम नोट के अधीन हैं।

Answer 14

मैंने नाम स्थान बनाया जो कि एर्लांग के मॉड्यूल से प्रेरित है। यह एक बहुत ही कार्यात्मक दृष्टिकोण है, लेकिन यह है कि मैं इन दिनों अपना जावास्क्रिप्ट कोड कैसे लिखता हूं।

यह एक वैश्विक नामस्थान को बंद कर देता है और उस बंद के भीतर एक निर्धारित सेट फ़ंक्शन को उजागर करता है।

(function(){

  namespace("images", previous, next);
  // ^^ This creates or finds a root object, images, and binds the two functions to it.
  // It works even though those functions are not yet defined.

  function previous(){ ... }

  function next(){ ... }

  function find(){ ... } // A private function

})();

Answer 15

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

global_namespace.Define('startpad.base', function(ns) {
    var Other = ns.Import('startpad.other');
    ....
});

लाभों का विवरण मेरे ब्लॉग पोस्ट पर है । आप यहां स्रोत कोड को पकड़ सकते हैं ।

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

Comments

मैंने नामस्थान लाइब्रेरी का एक उन्नत संस्करण (2.0) बनाया है: code.google.com/p/pageforest/source/browse/appengine/static/src/…

— mckoss

आपके सभी लिंक मृत प्रतीत होते हैं

— स्नोबो डॉग

Answer 16

मैं नाम स्थान के लिए निम्न सिंटैक्स का उपयोग करता हूं।

var MYNamespace = MYNamespace|| {};

 MYNamespace.MyFirstClass = function (val) {
        this.value = val;
        this.getValue = function(){
                          return this.value;
                       };
    }

var myFirstInstance = new MYNamespace.MyFirstClass(46);
alert(myFirstInstance.getValue());

jsfiddle: http://jsfiddle.net/rpaul/4dngxwb3/1/

Answer 17

मैं पार्टी में 7 साल की देरी से आया हूं, लेकिन इस 8 साल पहले काफी काम किया है:

• http://blogger.ziesemer.com/2008/05/javascript-namespace-function.html
• http://blogger.ziesemer.com/2007/10/respecting-javascript-global-namespace.html

जावास्क्रिप्ट ग्लोबल नेमस्पेस (नेमस्पेस प्रदूषण को रोकना) का सम्मान करते हुए, और ऐसा करते समय नामपट्स पथ में अपनी मौजूदा वस्तुओं को बंद नहीं करने के साथ, एक जटिल वेब एप्लिकेशन को व्यवस्थित और प्रबंधनीय रखने के लिए आसानी से और कुशलता से कई नेस्टेड नामस्थान बनाने में सक्षम होना महत्वपूर्ण है। ।

ऊपर से, यह मेरा लगभग 2008 का समाधान था:

var namespace = function(name, separator, container){
  var ns = name.split(separator || '.'),
    o = container || window,
    i,
    len;
  for(i = 0, len = ns.length; i < len; i++){
    o = o[ns[i]] = o[ns[i]] || {};
  }
  return o;
};

यह एक नाम स्थान नहीं बना रहा है, लेकिन नाम स्थान बनाने के लिए एक फ़ंक्शन प्रदान करता है।

यह एक की-लाइनर के लिए संघनित हो सकता है:

var namespace=function(c,f,b){var e=c.split(f||"."),g=b||window,d,a;for(d=0,a=e.length;d<a;d++){g=g[e[d]]=g[e[d]]||{}}return g};

उपयोग का उदाहरण:

namespace("com.example.namespace");
com.example.namespace.test = function(){
  alert("In namespaced function.");
};

या, एक बयान के रूप में:

namespace("com.example.namespace").test = function(){
  alert("In namespaced function.");
};

या तो के रूप में निष्पादित किया जाता है:

com.example.namespace.test();

यदि आपको विरासत ब्राउज़रों के लिए समर्थन की आवश्यकता नहीं है, तो एक अद्यतन संस्करण:

const namespace = function(name, separator, container){
    var o = container || window;
    name.split(separator || '.').forEach(function(x){
        o = o[x] = o[x] || {};
    });
    return o;
};

अब, मैं namespaceवैश्विक नामस्थान पर खुद को उजागर करने की कोशिश करूंगा । (बहुत बुरा आधार भाषा हमारे लिए यह प्रदान नहीं करता है!) तो मैं आम तौर पर एक बंद में खुद का उपयोग करेंगे, जैसे:

(function(){
	const namespace = function(name, separator, container){
		var o = container || window;
		name.split(separator || '.').forEach(function(x){
			o = o[x] = o[x] || {};
		});
		return o;
	};
	const ns = namespace("com.ziesemer.myApp");
	
	// Optional:
	ns.namespace = ns;
	
	// Further extend, work with ns from here...
}());

console.log("\"com\":", com);

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

Answer 18

मुझे जैको प्रीटोरियस का समाधान पसंद है, लेकिन मैं मॉड्यूल / नेमस्पेस ऑब्जेक्ट को इंगित करके "इस" कीवर्ड को थोड़ा अधिक उपयोगी बनाना चाहता था। स्किलेट का मेरा संस्करण:

(function ($, undefined) {

    console.log(this);

}).call(window.myNamespace = window.myNamespace || {}, jQuery);

Answer 19

मेरा पसंदीदा पैटर्न हाल ही में यह बन गया है:

var namespace = (function() {
  
  // expose to public
  return {
    a: internalA,
    c: internalC
  }

  // all private
  
  /**
   * Full JSDoc
   */
  function internalA() {
    // ...
  }
  
  /**
   * Full JSDoc
   */
  function internalB() {
    // ...
  }
  
  /**
   * Full JSDoc
   */
  function internalC() {
    // ...
  }
  
  /**
   * Full JSDoc
   */
  function internalD() {
    // ...
  }
  
})();

बेशक, वापसी अंत में हो सकती है, लेकिन यदि केवल फ़ंक्शन घोषणाएं इसका पालन करती हैं, तो यह देखना बहुत आसान है कि सभी नाम क्या हैं, और एपीआई क्या है।

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

Comments

नमस्ते, आप अपने स्निपेट से सार्वजनिक कार्यों को कैसे कहते हैं? मैंने कोशिश की हैnamespace.a();

— olimart

@olivier हाँ, यही विचार है। हालाँकि अब ES6 के साथ, मैं आमतौर पर ऑब्जेक्ट शाब्दिक शब्दों के शॉर्टहैंड सिंटैक्स ( ponyfoo.com/articles/es6-object-literal-features-in-depth ) का उपयोग करता हूं

— Nomaed

Answer 20

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

namespace => namespace.split(".").reduce((last, next) => (last[next] = (last[next] || {})), window);

कोशिश करो :

// --- definition ---
const namespace = namespace => namespace.split(".").reduce((last, next) => (last[next] = (last[next] || {})), window);

// --- Use ----
let myNamespace = namespace("a.b.c");
myNamespace.MyClass = class MyClass {};

// --- see ----
console.log("a : ", a);

Answer 21

यदि मेकफाइल का उपयोग कर आप ऐसा कर सकते हैं।

// prelude.hjs
billy = new (
    function moduleWrapper () {
    const exports = this;

// postlude.hjs
return exports;
})();

// someinternalfile.js
function bob () { console.log('hi'); }
exports.bob = bob;

// clientfile.js
billy.bob();

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

मेकफाइल का उपयोग करते समय ब्राउज़र में लाइव विकास के लिए एक शेल स्क्रिप्ट:

while (true); do make; sleep 1; done

इसे मेक टास्क 'गो' के रूप में जोड़ें और कोड के रूप में अपने बिल्ड को अपडेट रखने के लिए आप 'गो' बना सकते हैं।

Answer 22

Ionuț G. Stan के उत्तर का अनुगमन करें, लेकिन उपयोग करके अशुद्ध कोड के लाभों को दिखाते हुए var ClassFirst = this.ClassFirst = function() {...}, जो समान नामस्थान में कक्षाओं के लिए कम नाम स्थान अव्यवस्था के लिए जावास्क्रिप्ट के बंद होने का फायदा उठाते हैं।

var Namespace = new function() {
    var ClassFirst = this.ClassFirst = function() {
        this.abc = 123;
    }

    var ClassSecond = this.ClassSecond = function() {
        console.log("Cluttered way to access another class in namespace: ", new Namespace.ClassFirst().abc);
        console.log("Nicer way to access a class in same namespace: ", new ClassFirst().abc);
    }
}

var Namespace2 = new function() {
    var ClassFirst = this.ClassFirst = function() {
        this.abc = 666;
    }

    var ClassSecond = this.ClassSecond = function() {
        console.log("Cluttered way to access another class in namespace: ", new Namespace2.ClassFirst().abc);
        console.log("Nicer way to access a class in same namespace: ", new ClassFirst().abc);
    }
}

new Namespace.ClassSecond()
new Namespace2.ClassSecond()

आउटपुट:

Cluttered way to access another class in namespace: 123
Nicer way to access a class in same namespace: 123
Cluttered way to access another class in namespace: 666
Nicer way to access a class in same namespace: 666

Answer 23

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

फ़ाइल hello.js

Package("hello", [], function() {
  function greeting() {
    alert("Hello World!");
  }
  // Expose function greeting to other packages
  Export("greeting", greeting);
});

फ़ाइल उदाहरण। Js

Package("example", ["hello"], function(greeting) {
  // Greeting is available here
  greeting();  // Alerts: "Hello World!"
});

पेज में केवल दूसरी फाइल को शामिल करने की आवश्यकता है। इसकी निर्भरताएं ( इस उदाहरण में फ़ाइल hello.js ) स्वचालित रूप से लोड की जाएंगी और उन निर्भरता से निर्यात की गई वस्तुओं का उपयोग कॉलबैक फ़ंक्शन के तर्कों को आबाद करने के लिए किया जाएगा।

आप संबंधित परियोजना को JS में पा सकते हैं ।

Comments

@ peter-mortensen '11 से मेरे जवाब के लिए ये संपादन वास्तव में आवश्यक थे? यह निश्चित रूप से बर्बरता नहीं है कि आप क्या कर रहे हैं, मुझे गलत मत समझिए, लेकिन वे बहुत सतही हैं। जब तक आप वास्तव में कुछ अच्छा नहीं जोड़ते, मैं इन जैसे पदों का एकमात्र लेखक रहना पसंद करूंगा।

— स्टिजन डे विट डिक

Answer 24

हम इसे इस तरह से स्वतंत्र रूप से उपयोग कर सकते हैं:

var A = A|| {};
A.B = {};

A.B = {
    itemOne: null,
    itemTwo: null,
};

A.B.itemOne = function () {
    //..
}

A.B.itemTwo = function () {
    //..
}

Answer 25

मेरी आदत फंक्शन myName () को प्रॉपर्टी स्टोरेज के रूप में इस्तेमाल करने की है , और फिर myName को "मेथड" होल्डर के रूप में ...

यह पर्याप्त वैध है या नहीं, मुझे हरा दो! मैं अपने PHP तर्क पर हर समय भरोसा कर रहा हूं, और चीजें बस काम करती हैं। : डी

function myObj() {
    this.prop1 = 1;
    this.prop2 = 2;
    this.prop3 = 'string';
}

var myObj = (
 (myObj instanceof Function !== false)
 ? Object.create({

     $props: new myObj(),
     fName1: function() { /* code..  */ },
     fName2: function() { /* code ...*/ }
 })
 : console.log('Object creation failed!')
);

if (this !== that) myObj.fName1(); else myObj.fName2();

आप इसे ऑब्जेक्ट के निर्माण से पहले जांचने के लिए 'इसके विपरीत' तरीके से भी कर सकते हैं जो बहुत बेहतर है :

function myObj() {
    this.prop1 = 1;
    this.prop2 = 2;
    this.prop3 = 'string';
}

var myObj = (
    (typeof(myObj) !== "function" || myObj instanceof Function === false)
    ? new Boolean()
    : Object.create({
        $props: new myObj(),
        init: function () { return; },
        fName1: function() { /* code..  */ },
        fName2: function() { /* code ...*/ }
    })
);

if (myObj instanceof Boolean) {
    Object.freeze(myObj);
    console.log('myObj failed!');
    debugger;
}
else
    myObj.init();

इसका संदर्भ: जावास्क्रिप्ट: ऑब्जेक्ट क्रिएशन के साथ ऑब्जेक्ट बनाना ()

Answer 26

जावास्क्रिप्ट में नामस्थानों का उपयोग करने के लिए कोई पूर्वनिर्धारित विधियाँ नहीं हैं। जावास्क्रिप्ट में हमें NameSpaces को परिभाषित करने के लिए अपने तरीके बनाने होंगे। यहाँ एक प्रक्रिया है जिसका पालन हम Oodles प्रौद्योगिकियों में करते हैं।

एक नाम स्थान पंजीकृत करें नाम स्थान को पंजीकृत करने का कार्य निम्नलिखित है

//Register NameSpaces Function
function registerNS(args){
 var nameSpaceParts = args.split(".");
 var root = window;

 for(var i=0; i < nameSpaceParts.length; i++)
 {
  if(typeof root[nameSpaceParts[i]] == "undefined")
   root[nameSpaceParts[i]] = new Object();

  root = root[nameSpaceParts[i]];
 }
}

Namespace को पंजीकृत करने के लिए, उपरोक्त फ़ंक्शन को तर्क के साथ नाम स्थान '.'(डॉट) द्वारा अलग किए गए स्थान के रूप में कॉल करें । उदाहरण के लिए आपका एप्लिकेशन नाम oodles है। आप निम्न विधि से नाम स्थान बना सकते हैं

registerNS("oodles.HomeUtilities");
registerNS("oodles.GlobalUtilities");
var $OHU = oodles.HomeUtilities;
var $OGU = oodles.GlobalUtilities;

मूल रूप से यह बैकएंड में नीचे की तरह आपकी NameSpaces संरचना बनाएगा:

var oodles = {
    "HomeUtilities": {},
    "GlobalUtilities": {}
};

उपर्युक्त फ़ंक्शन में आपने नाम "oodles.HomeUtilities"और नाम दर्ज किया है "oodles.GlobalUtilities"। इन नामस्थान हम एक चर यानी वर कर कॉल करने के लिए $OHUऔर वर $OGU।

ये चर कुछ भी नहीं हैं, जो नामस्थान पर कब्जा करने के लिए एक उपनाम हैं। अब, जब भी आप किसी समारोह की घोषणा करते हैं, तो आप HomeUtilitiesनिम्न की तरह उसे घोषित करेंगे:

$OHU.initialization = function(){
    //Your Code Here
};

ऊपर फ़ंक्शन नाम आरंभीकरण है और इसे एक नाम स्थान में रखा गया है $OHU। और स्क्रिप्ट फ़ाइलों में कहीं भी इस फ़ंक्शन को कॉल करने के लिए। बस निम्नलिखित कोड का उपयोग करें।

$OHU.initialization();

इसी तरह, दूसरे NameSpaces के साथ।

आशा है ये मदद करेगा।

Answer 27

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

function func1() {
    console.log("This is a first definition");

}
function func1() {
    console.log("This is a second definition");
}
func1(); // This is a second definition

यह हमेशा दूसरे फ़ंक्शन की परिभाषा कहता है। इस स्थिति में, नाम स्थान टकराव की समस्या को हल करेगा।