Est-il possible de créer un espace de noms dans jQuery?

YUI a un bon moyen de créer un espace de noms pour vos méthodes, etc. en javascript.

Est-ce que jQuery a quelque chose de similaire?

lpfavreau offre la solution pour étendre l’object jQuery avec vos propres méthodes (afin que leur fonctionnalité s’applique au contexte d’object jQuery réel).

Si vous cherchez juste à nommer votre code, vous pouvez utiliser le symbole dollar comme ceci:

$.myNamespace = { .. }; 

ou le “jQuery”:

 jQuery.myNamespace = { .. }; 

Soyez prudent avec l’espace de noms que vous choisissez, car cela peut écraser les méthodes jQuery existantes (je vous conseille de rechercher d’abord dans le code jQuery pour ne pas le faire).

Vous pouvez suivre ce lien: http://www.zachleat.com/web/2007/08/28/namespacing-outside-of-the-yahoo-namespace/

Voyez comme il est facile de créer votre propre fonction pour reproduire ce que fait YUI:

 // include jQuery first. jQuery.namespace = function() { var a=arguments, o=null, i, j, d; for (i=0; i 

Voici comment je crée des espaces de noms pour mes plugins:

 (function ($) { // do not overwrite the namespace, if it already exists $.MyNamespace = $.MyNamespace || {}; $.MyNamespace.MyPlugin = function () {/*here's the logic*/} })($); 

Et alors:

 $.MyNamespace.MyPlugin (); 

jQuery a un tas de plugins qui étendent la fonctionnalité de base. Il y a ce plugin pour les espaces de noms faciles.

Le plug-in d’ espace de nommage est totalement inutile! Le truc le plus ancien au monde, l’utilisation de arguments.callee, Function.prototype et l’appel d’une nouvelle instance Function, vous permettent de créer des espaces de noms nesteds avec $ .fn.extend!

Voici un exemple simple et simple:

  ;(function($){ var options= { root: function(){ //you don't have to call it 'root', of course :) //identify the function from within itself with arguments.callee var fn= arguments.callee; //'this' at this level is the jquery object list matching your given selector //we equate fn.prototype to this //thus when we call a new instance of root, we are returned 'this' fn.prototype= this; fn.value= function(){ //Note: "new this" will work in the below line of code as well, //because in the current context, 'this' is fn; //I use fn to make the code more intuitive to understand; var context= new fn; console.log(context, fn.prototype); //test return context.html(); //test } return this; } } //you can obviously append additional nested properties in this manner as well options.root.position= function(){ var context= new this; //in this context, fn is undefined, so we leverage 'this' console.log(context, this.prototype); //test return context.offset(); //test } //don't forget to extend in the end :) $.fn.extend(options); })(jQuery); ;$(function(){ var div= $('div#div') .root(); console.log(div.root.value()); console.log(div.root.position()); }); 

Si vous souhaitez utiliser jQuery de cette manière:

 $("*").namespace.do(); 

alors, actuellement, il n’y a pas de plugins qui font ça. (Je ne trouve pas le plugin jquery.space de John Resig qui semble avoir cessé de fonctionner dans jQuery 1.4, ni le plugin Gilberto Saraiva qui apparemment ne fonctionnait pas comme prévu). Je serais ravi de regarder la fonction de John pour voir pourquoi il a cessé de fonctionner, et ce qui peut être fait pour le faire fonctionner et, franchement, ce serait la meilleure approche pour créer des espaces de noms non encombrés.

Selon http://malnotna.wordpress.com/2009/01/12/jquery-namespace-support/, une autre approche consiste à faire de l’espace de noms (en utilisant jQuery.Modularize par Ariel Flesler):

 $("*").namespace().do() 

mais cette syntaxe n’est pas “jolie”. Nous transmettons également les résultats d’une fonction à l’autre.

Mon approche pour créer des espaces de noms ne consiste pas à placer des espaces de noms à la fin, mais au début de $, notre syntaxe d’espace de noms $ (‘*’) devient:

 $.namespace("*").do() 

Bizarrement, je ne sais pas pourquoi une telle approche n’est pas mentionnée, car cela vous permet de créer facilement des espaces de noms non-écrasés sans écraser les fonctions déjà existantes (en utilisant $ .sub ()). En outre, le faire fonctionner ne nécessite rien. Alors:

 (function($){ $.namespace = $.sub(); $.fn.test = function(){ return 1 }; $.namespace.fn.test = function() { return 2}; })(jQuery); console.log($('*').test(), $.namespace('*').test()); 

Et vous êtes prêt à partir.

Selon ce que vous essayez de faire, l’architecture des plug-ins de jQuery peut être ce que vous recherchez:

 $.fn.myPlugin = function() { return $(this).each(function() { // do stuff }); }; 

ou …

 $.fn.myPlugin = function() { var myNamespace = { // your stuff }; }; 

En fait, cela dépend de ce que vous essayez de faire.

http://docs.jquery.com/Plugins/Authoring

consultez ce blog: http://javascriptweblog.wordpress.com/2010/12/07/namespacing-in-javascript/

l’espace de nommage dynamic auto-appelant est ce que j’avais déjà utilisé:

 var myApp = {}; (function(context) { var id = 0; context.next = function() { return id++; }; context.reset = function() { id = 0; } })(myApp); window.console && console.log( myApp.next(), myApp.next(), myApp.reset(), myApp.next() ); //0, 1, undefined, 0 

Tout le crédit à @Diego Fluery, je viens de prendre son jeu de diapositives et fait un prototype de code exécutable, mais cela pourrait vous faire économiser quelques minutes si vous allez dans cette voie: