ජාවාස්ක්‍රිප්ට් හි නාම අවකාශයක් නිර්මාණය කරන්නේ කෙසේද, එවිට මගේ වස්තූන් සහ කාර්යයන් වෙනත් එකම නම් කරන ලද වස්තූන් හා ශ්‍රිතයන් විසින් නැවත ලියනු නොලැබේ. මම පහත සඳහන් දෑ භාවිතා කර ඇත:

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

මෙය කිරීමට වඩා අලංකාර හෝ සංක්ෂිප්ත ක්‍රමයක් තිබේද?

මම මෙයට කැමතියි:

var yourNamespace = {

    foo: function() {
    },

    bar: function() {
    }
};

...

yourNamespace.foo();

ව්‍යවසාය 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. එය අදටත් අදාළදැයි මට විශ්වාස නැත, නමුත් පැරණි බ්‍රව්සර් / ජාවාස්ක්‍රිප්ට් ප්‍රමිතීන් සමඟ වැඩ කරන අතරතුර (ecmascript 5, javascript <1.8.5 ~ firefox 4), ගෝලීය විෂය පථයේ විචල්‍යය undefinedලිවිය හැකි බැවින් ඕනෑම කෙනෙකුට එහි වටිනාකම නැවත ලිවිය හැකිය. තෙවන තර්කය (අගයක් සම්මත නොකළ විට) නම් undefinedඅවකාශයට / ශ්‍රිතයට විෂය පථයක් ලෙස නම් කර ඇති විචල්‍යයක් නිර්මාණය කරයි . ඔබ නාම අවකාශය නිර්මාණය කරන විට කිසිදු අගයක් සම්මත නොවූ හෙයින්, එය අගයට පෙරනිමිය undefined.

එය කළ හැකි තවත් ක්‍රමයක් නම්, එය වස්තු වචනානුගත ස්වරූපයට වඩා ටිකක් අඩුවෙන් සීමා කිරීමක් ලෙස මම සලකමි.

var ns = new function() {

    var internalFunction = function() {

    };

    this.publicFunction = function() {

    };
};

ඉහත එච්චරමයි වගේ මෙම මොඩියුලය රටාව හා යන්න ඔබ ඒ වගේ හෝ නොවන වස්තුවක ප්රායෝගික පැවති නොවෙනස් ව්යුහය මග අතර, එය, ඔබට මහජන ලෙස ඔබේ සියලු ම කටයුතු හෙළිදරව් කිරීමට ඉඩ දෙයි.

මෙය කිරීමට වඩා අලංකාර හෝ සංක්ෂිප්ත ක්‍රමයක් තිබේද?

ඔව්. උදාහරණයක් වශයෙන්:

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

මම සාමාන්‍යයෙන් එය වසා දමන්නේ:

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

මේ ආකාරයෙන් මට පොදු API සහ ක්‍රියාත්මක කිරීම තේරුම් ගැනීමට පහසු වේ. ආපසු ප්‍රකාශය ක්‍රියාත්මක කිරීම සඳහා පොදු අතුරු මුහුණතක් ලෙස සිතන්න.

ඔබට ජාවාස්ක්‍රිප්ට් හි විවිධ ලිපිගොනු ලිවිය හැකි අතර පසුව ඒවා යෙදුමක ඒකාබද්ධ කිරීම හෝ ඒකාබද්ධ නොකිරීම නිසා, සෑම ලිපිගොනුවකටම වෙනත් ලිපිගොනු වල කාර්යයට හානි නොකර නාම අවකාශ වස්තුව නැවත ලබා ගැනීමට හෝ තැනීමට හැකි විය යුතුය ...

එක් ගොනුවක් නාම අවකාශය භාවිතා කිරීමට අදහස් කරයි 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(){}

මෙම ලිපිගොනු දෙක එකිනෙක ගැටීමෙන් තොරව එකට හෝ වෙන්ව ජීවත් විය හැකිය.

මෙන්න ස්ටොයාන් ස්ටෙෆනොව් ඔහුගේ ජාවාස්ක්‍රිප්ට් රටා පොතේ එය ඉතා හොඳ බව මට පෙනී ගියේය (එය ස්වයංක්‍රීයව ජනනය කරන ලද ඒපීඅයි ප්‍රලේඛනය සඳහා ඉඩ දෙන අදහස් දක්වන ආකාරය සහ අභිරුචි වස්තුවක මූලාකෘතියට ක්‍රමයක් එකතු කරන්නේ කෙසේද යන්න ද පෙන්වයි):

/**
* 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;
};

මම මෙම ප්‍රවේශය භාවිතා කරමි:

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

මෙය පරිශීලක 106826 හි Namespace.js වෙත සබැඳියකි. ව්‍යාපෘතිය GitHub වෙත ගෙන ගිය බව පෙනේ . එය දැන් ස්මිත් / නම් අවකාශය වේ.

මගේ කුඩා ව්‍යාපෘතිය සඳහා මම මෙම සරල ජාවාස්ක්‍රිප්ට් සහායකය භාවිතා කර ඇති අතර, මේ දක්වා එය නාම අවකාශය සහ පැටවීමේ මොඩියුල / පන්ති හැසිරවීමට තරම් සැහැල්ලු නමුත් බහුකාර්ය බව පෙනේ . ගෝලීය නාම අවකාශයට පමණක් නොව, මගේ අභිමතය පරිදි නාම අවකාශයකට පැකේජයක් ආනයනය කිරීමට එය මට ඉඩ දෙන්නේ නම් එය ඉතා හොඳ වේ ... සුසුම්ලන්න, නමුත් එය කාරණයට අමතරව.

එය ඔබට නාම අවකාශය ප්‍රකාශ කිරීමට ඉඩ දී එම නාම අවකාශයේ ඇති වස්තු / මොඩියුල නිර්වචනය කරයි:

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

තවත් විකල්පයක් නම් නාම අවකාශය සහ එහි අන්තර්ගතය එකවර ප්‍රකාශ කිරීමයි:

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

තවත් භාවිත උදාහරණ සඳහා, ප්‍රභවයේ example.js ගොනුව බලන්න .

නියැදිය:

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එය පුද්ගලික වීමට අවශ්‍ය නම් පැවරිය හැකිය.

නාම අවකාශයන් සැපයීම සඳහා ඔබට සරල ශ්‍රිතයක් ප්‍රකාශ කළ හැකිය.

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

ඔබට පෞද්ගලික විෂය පථය අවශ්‍ය නම්:

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

මොඩියුල රටාව මුලින් අර්ථ දැක්වුනේ සාම්ප්‍රදායික මෘදුකාංග ඉංජිනේරු විද්‍යාවේ පන්ති සඳහා පුද්ගලික හා පොදු සංවර්‍ධනය සැපයීමේ ක්‍රමයක් ලෙස ය.

මොඩියුල රටාව සමඟ වැඩ කරන විට, එය ආරම්භ කිරීම සඳහා අප භාවිතා කරන සරල අච්චුවක් නිර්වචනය කිරීම අපට ප්‍රයෝජනවත් විය හැකිය. මෙන්න නම-පරතරය, රාජ්‍ය සහ පෞද්ගලික විචල්‍යයන් ආවරණය කරන එකක්.

ජාවාස්ක්‍රිප්ට් හි, මොඩියුල රටාව භාවිතා කරනුයේ පන්ති පිළිබඳ සංකල්පය තවදුරටත් අනුකරණය කිරීමට ය. එමඟින් අපට පොදු / පෞද්ගලික ක්‍රම සහ විචල්‍යයන් එකම වස්තුවක් තුළට ඇතුළත් කළ හැකි වන අතර එමඟින් විශේෂිත කොටස් ගෝලීය විෂය පථයෙන් ආරක්ෂා වේ. මෙහි ප්‍රති results ලය වනුයේ පිටුවේ ඇති අතිරේක ස්ක්‍රිප්ට් වල අර්ථ දක්වා ඇති අනෙකුත් ශ්‍රිත සමඟ ගැටෙන අපගේ ශ්‍රිත නාමවල සම්භාවිතාව අඩු කිරීමයි.

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

    }
  };

})();

වාසි

මොඩියුල රටාව හොඳ තේරීමක් වන්නේ ඇයි? ආරම්භකයින් සඳහා, අවම වශයෙන් ජාවාස්ක්‍රිප්ට් දෘෂ්ටිකෝණයකින් වුවද, සත්‍ය සංසරණය පිළිබඳ අදහසට වඩා වස්තු-නැඹුරු පසුබිමකින් පැමිණෙන සංවර්ධකයින් සඳහා එය පිරිසිදු ය.

දෙවනුව, එය පුද්ගලික දත්ත සඳහා සහය දක්වයි - එබැවින්, මොඩියුලයේ රටාව තුළ, අපගේ කේතයේ පොදු කොටස් පුද්ගලික කොටස් ස්පර්ශ කිරීමට සමත් වේ, කෙසේ වෙතත් බාහිර ලෝකයට පන්තියේ පුද්ගලික කොටස් ස්පර්ශ කිරීමට නොහැකි වේ.

අවාසි

මොඩියුලයේ රටාවේ අවාසි නම්, අපි රාජ්‍ය හා පෞද්ගලික සාමාජිකයින්ට වෙනස් ආකාරයකින් ප්‍රවේශ වන විට, දෘශ්‍යතාව වෙනස් කිරීමට අපේක්ෂා කරන විට, ඇත්ත වශයෙන්ම සාමාජිකයා භාවිතා කළ සෑම ස්ථානයකම වෙනස්කම් සිදු කළ යුතුය.

පසුකාලීනව වස්තුවට එකතු කරන ක්‍රම මඟින් අපට පුද්ගලික සාමාජිකයින්ට ප්‍රවේශ විය නොහැක . බොහෝ අවස්ථාවන්හීදී මොඩියුල රටාව තවමත් බෙහෙවින් ප්‍රයෝජනවත් වන අතර නිවැරදිව භාවිතා කරන විට අපගේ යෙදුමේ ව්‍යුහය වැඩි දියුණු කිරීමේ හැකියාව ඇත.

හෙළිදරව් කිරීමේ මොඩියුල රටාව

දැන් අපි මොඩියුල රටාව ගැන මඳක් හුරුපුරුදු බැවින්, තරමක් වැඩිදියුණු කළ අනුවාදයක් දෙස බලමු - ක්‍රිස්ටියන් හෙල්මන්ගේ හෙළිදරව් කිරීමේ මොඩියුල රටාව.

හෙළිදරව් කිරීමේ මොඩියුල රටාව ඇති වූයේ, අපට එක් පොදු ක්‍රමයක් වෙනත් ස්ථානයකින් ඇමතීමට හෝ පොදු විචල්‍යයන්ට ප්‍රවේශ වීමට අවශ්‍ය වූ විට ප්‍රධාන වස්තුවේ නම පුනරාවර්තනය කිරීමට සිදුවීම ගැන හෙල්මන් කලකිරීමට පත්වීමෙනි. මොඩියුලයේ රටාවේ අවශ්‍යතාවය ඔහු අකමැති විය. ඔහු ප්‍රසිද්ධ කිරීමට අදහස් කළ දේවල් සඳහා වචනාර්ථයෙන් අංකනය කිරීමට විරුද්ධ වීම.

ඔහුගේ උත්සාහයේ ප්‍රති result ලය යාවත්කාලීන කරන ලද රටාවක් වන අතර, අපගේ සියලු කාර්යයන් සහ විචල්‍යයන් පුද්ගලික විෂය පථය තුළ සරලව නිර්වචනය කර, අප විසින් ප්‍රසිද්ධියේ හෙළි කිරීමට බලාපොරොත්තු වූ පුද්ගලික ක්‍රියාකාරිත්වයට දර්ශකයන් සහිත නිර්නාමික වස්තුවක් නැවත ලබා දෙන්නෙමු.

හෙළිදරව් කිරීමේ මොඩියුල රටාව භාවිතා කරන්නේ කෙසේද යන්න පිළිබඳ උදාහරණයක් පහත දැක්වේ

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

වාසි

මෙම රටාව අපගේ ස්ක්‍රිප්ට් වල වාක්‍ය ඛණ්ඩය වඩාත් අනුකූල වීමට ඉඩ දෙයි. අපගේ මොඩියුලය අවසානයේ දී කියවිය හැකි පහසුව සලසන අපගේ කාර්යයන් සහ විචල්‍යයන් ප්‍රසිද්ධියේ ප්‍රවේශ කළ හැකි දේ ද එය වඩාත් පැහැදිලි කරයි.

අවාසි

මෙම රටාවේ අවාසියක් නම්, පුද්ගලික ශ්‍රිතයක් පොදු ශ්‍රිතයක් ගැන සඳහන් කරන්නේ නම්, පැච් එකක් අවශ්‍ය නම් එම පොදු කාර්යය අභිබවා යා නොහැක. මෙයට හේතුව පුද්ගලික ශ්‍රිතය පුද්ගලික ක්‍රියාත්මක කිරීම වෙත යොමු වන අතර රටාව මහජන සාමාජිකයින්ට අදාළ නොවන අතර කාර්යයන් සඳහා පමණි.

පුද්ගලික විචල්‍යයන් වෙත යොමු වන පොදු වස්තු සාමාජිකයින් ද ඉහත සඳහන් කළ රීති සටහන් වලට යටත් නොවේ.

මම නාම අවකාශයක් නිර්මාණය කළ අතර එය එර්ලැන්ග්ගේ මොඩියුල වලින් ආශ්වාදයක් ලැබීය. එය ඉතා ක්‍රියාකාරී ප්‍රවේශයකි, නමුත් මේ දිනවල මම මගේ ජාවාස්ක්‍රිප්ට් කේතය ලියන්නේ එලෙසිනි.

එය වසා දැමීමකට ගෝලීය නාම අවකාශයක් ලබා දෙන අතර එම වසා දැමීම තුළ නිර්වචනය කරන ලද කාර්යයන් හෙළි කරයි.

(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

})();

මගේ පුස්තකාල කිහිපයක් විවිධ ව්‍යාපෘති වෙත ගෙනයාමෙන් පසුව සහ ඉහළ මට්ටමේ (සංඛ්‍යානමය වශයෙන් නම් කරන ලද) නාම අවකාශය නිරන්තරයෙන් වෙනස් කිරීමෙන් පසුව, නාම අවකාශයන් නිර්වචනය කිරීම සඳහා මෙම කුඩා (විවෘත මූලාශ්‍ර) උපකාරක ශ්‍රිතය භාවිතා කිරීමට මම මාරු වී සිටිමි.

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

ප්‍රතිලාභ පිළිබඳ විස්තර මගේ බ්ලොග් සටහනේ ඇත. ඔබට මෙහි ප්‍රභව කේතය ලබා ගත හැකිය .

මම සැබවින්ම කැමති ප්‍රතිලාභවලින් එකක් වන්නේ බර පැටවීමේ අනුපිළිවෙලට සාපේක්ෂව මොඩියුල අතර හුදකලා වීමයි. බාහිර මොඩියුලයක් පූරණය වීමට පෙර ඔබට එය යොමු කළ හැකිය. කේතය ඇති විට ඔබට ලැබෙන වස්තු යොමු කිරීම පුරවනු ලැබේ.

නාම අවකාශය සඳහා මම පහත සින්ටැක්ස් භාවිතා කරමි.

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/

මම සාදයට අවුරුදු 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;
};

මෙය නාම අවකාශයක් නිර්මාණය කිරීමක් නොව නාම අවකාශයන් නිර්මාණය කිරීම සඳහා ශ්‍රිතයක් සපයයි.

මෙය අවම එක් ලයිනර් එකකට ensed නීභවනය කළ හැකිය:

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

විශාල යෙදුමක, මෙය අර්ථ දැක්විය යුත්තේ පිටු පැටවීමක ආරම්භයේ එක් වරක් පමණි (සේවාදායකයා පදනම් කරගත් වෙබ් යෙදුම් සඳහා). අතිරේක ලිපිගොනු තබා ඇති නම් නාම අවකාශයේ ක්‍රියාකාරිත්වය නැවත භාවිතා කළ හැකිය (ඉහත සඳහන් "විකල්ප" ලෙස ඇතුළත් කර ඇත). නරකම දෙය නම්, මෙම ශ්‍රිතය කිහිප වතාවක් නැවත ප්‍රකාශයට පත් කරන්නේ නම් - එය කේත පේළි කිහිපයක් පමණක් වන අතර අවම නම් අඩුය.

මම හිතන්නේ ඔබ සියලු දෙනාම එවැනි සරල ගැටළුවක් සඳහා ඕනෑවට වඩා කේත භාවිතා කරයි. ඒ සඳහා රෙපෝ එකක් සෑදීමට අවශ්‍ය නැත. මෙන්න තනි පේළි ශ්‍රිතයක්.

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

මම ජැකෝ ප්‍රිටෝරියස්ගේ විසඳුමට කැමතියි, නමුත් මොඩියුලය / නාම අවකාශ වස්තුව වෙත යොමු කිරීමෙන් "මෙම" මූල පදය ටිකක් ප්‍රයෝජනවත් කිරීමට මට අවශ්‍ය විය. මගේ skillet අනුවාදය:

(function ($, undefined) {

    console.log(this);

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

මගේ ප්‍රියතම රටාව මෑතකදී මෙය බවට පත්ව ඇත:

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

ඇත්ත වශයෙන්ම, නැවත පැමිණීම අවසානයේ විය හැකිය, නමුත් ශ්‍රිත ප්‍රකාශන පමණක් එය අනුගමනය කරන්නේ නම්, නාම අවකාශය කුමක්ද සහ API නිරාවරණය වන්නේ කුමක් දැයි බැලීම වඩා පහසුය.

එවැනි අවස්ථාවන්හිදී ක්‍රියාකාරී ප්‍රකාශන භාවිතා කිරීමේ රටාව මඟින් සමස්ත කේතය ඉක්මවා නොයා නිරාවරණය වන ක්‍රම මොනවාදැයි දැන ගැනීමට නොහැකි වේ.

Makefile භාවිතා කරන්නේ නම් ඔබට මෙය කළ හැකිය.

// 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 ක් පමණ ලබා ගත් පසු කෙසේ හෝ මේක්ෆයිල් එකක් භාවිතා කිරීමට මම කැමැත්තෙමි, මන්ද මේක්ෆයිල් හි එක් පේළියක් ඉවත් කිරීමෙන් විශාල කේත ප්‍රමාණයක් effectively ලදායී ලෙස ප්‍රකාශ කළ හැකිය. එමඟින් දේවල් සමඟ ගැටීම පහසු කරයි. එසේම, මෙම තාක්‍ෂණය සමඟ නාම අවකාශය පෙරවදනෙහි එක් වරක් පමණක් දිස්වන බැවින් එය වෙනස් කිරීම පහසු වන අතර පුස්තකාල කේතය තුළ එය නැවත නොකිරීමට අවශ්‍ය නොවේ.

Makefile භාවිතා කරන විට බ්‍රව්සරයේ සජීවී සංවර්ධනය සඳහා ෂෙල් පිටපතක්:

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

මෙය 'යන්න' සෑදීමේ කාර්යයක් ලෙස එක් කරන්න, ඔබ කේත කරන විට ඔබේ ගොඩනැගීම යාවත්කාලීනව තබා ගැනීමට ඔබට 'යන්න' හැකිය.

අයෝනු ජී. ස්ටැන්ගේ පිළිතුර තරමක් පසු විපරම් කිරීම, නමුත් 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

වෙනත් භාෂාවල ඇති පැකේජ / ඒකක මෙන් මඳක් වැඩ කරන තවත් නාම අවකාශ පුස්තකාලයක් මා ලියා ඇත. එය ඔබට ජාවාස්ක්‍රිප්ට් කේතයේ පැකේජයක් නිර්මාණය කිරීමට ඉඩ සලසයි.

ගොනුව hello.js

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

ගොනුව Example.js

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

පිටුවට ඇතුළත් කළ යුත්තේ දෙවන ගොනුව පමණි. එහි පරායත්තතා (ගොනුව මෙම උදාහරණයේ ඇති hello.js ) ස්වයංක්‍රීයව පටවනු ලබන අතර එම පරායත්තතාවයන්ගෙන් අපනයනය කරන ලද වස්තූන් ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතයේ තර්ක ජනනය කිරීමට යොදා ගනී.

ඇසුරුම් JS හි ඔබට අදාළ ව්‍යාපෘතිය සොයාගත හැකිය .

අපට එය මේ ආකාරයෙන් ස්වාධීනව භාවිතා කළ හැකිය:

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

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

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

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

මගේ පුරුද්ද වන්නේ myName () ශ්‍රිතය දේපල ආචයනය ලෙස භාවිතා කිරීමයි , ඉන්පසු var myName "method" දරන්නා ලෙස ...

මෙය ප්‍රමාණවත් තරම් නීත්‍යානුකූල වුවත් නැතත්, මට පහර දෙන්න! මම නිතරම මගේ 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();

මේ සඳහා යොමුව: JavaScript: Object.create () සමඟ වස්තුව නිර්මාණය කිරීම

ජාවාස්ක්‍රිප්ට් හි නාම අවකාශ භාවිතා කිරීමට පූර්ව නිශ්චිත ක්‍රම නොමැත. ජාවාස්ක්‍රිප්ට් හි අපි නාම අවකාශයන් අර්ථ දැක්වීම සඳහා අපේම ක්‍රමවේදයන් නිර්මාණය කළ යුතුය. ඔඩල්ස් තාක්ෂණයන්හි අප අනුගමනය කරන ක්‍රියා පටිපාටිය මෙන්න.

නාම අවකාශයක් ලියාපදිංචි කරන්න පහත දැක්වෙන්නේ නාම අවකාශයක් ලියාපදිංචි කිරීමේ කාර්යයයි

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

නාම අවකාශයක් ලියාපදිංචි කිරීම සඳහා ඉහත ශ්‍රිතය තර්කය සමඟ නාම අවකාශය '.'(dot) මගින් වෙන් කරන්න . උදාහරණ සඳහා ඔබේ යෙදුමේ නම oodles වේ. පහත දැක්වෙන ක්‍රමවේදය මඟින් ඔබට නාම අවකාශයක් සෑදිය හැකිය

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

මූලික වශයෙන් එය ඔබගේ නාම අවකාශ ව්‍යුහය පහත දැක්වෙන ආකාරයට නිර්මාණය කරයි:

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

ඉහත කාර්යය ඔබ නමින් නාම ලියාපදිංචි කර "oodles.HomeUtilities"සහ "oodles.GlobalUtilities". මෙම නාම අවකාශයන් ඇමතීම සඳහා අපි විචල්‍යයක් සාදන්නෙමු var එනම් $OHUvar $OGU.

මෙම විචල්‍යයන් නාම අවකාශය අන්තර්ග්‍රහණය කිරීමේ අන්වර්ථයක් මිස අන් කිසිවක් නොවේ. දැන්, ඔබට අයත් ශ්‍රිතයක් ප්‍රකාශ කරන සෑම විටම HomeUtilitiesඑය පහත පරිදි ප්‍රකාශ කරනු ඇත:

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

ඉහත දැක්වෙන්නේ ශ්‍රිත නාමය ආරම්භ කිරීම වන අතර එය නාම අවකාශයකට දමා ඇත $OHU. ස්ක්‍රිප්ට් ලිපිගොනු වල ඕනෑම තැනක මෙම ශ්‍රිතය ඇමතීමට. පහත කේතය භාවිතා කරන්න.

$OHU.initialization();

ඒ හා සමානව, තවත් නාම අවකාශයක් සමඟ.

එය උපකාරී වේ යැයි සිතමි.

ජාවාස්ක්‍රිප්ට් පෙරනිමියෙන් නාම අවකාශයට සහය නොදක්වයි. එබැවින් ඔබ කිසියම් මූලද්‍රව්‍යයක් (ශ්‍රිතය, ක්‍රමය, වස්තුව, විචල්‍යය) නිර්මාණය කරන්නේ නම් එය ගෝලීය බවට පත් වී ගෝලීය නාම අවකාශය දූෂණය කරයි. නාම අවකාශයක් නොමැතිව ශ්‍රිත දෙකක් අර්ථ දැක්වීම පිළිබඳ උදාහරණයක් බලමු,

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

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

එය සෑම විටම දෙවන ශ්‍රිත අර්ථ දැක්වීම ලෙස හැඳින්වේ. මෙම අවස්ථාවේ දී, නාම අවකාශය නාම ision ට්ටන ගැටළුව විසඳනු ඇත.