Scrivere una libreria Javascript che è il completamento del codice e del codice di ispezione amichevole

Question

Di recente ho fatto la mia libreria Javascript e inizialmente ho utilizzato il seguente schema:

var myLibrary = (function () {

  var someProp = "...";

  function someFunc() {
    ...
  }

  function someFunc2() {
    ...
  }

  return {
     func: someFunc,
     fun2: someFunc2,
     prop: someProp;
  }

}());

Il problema è che non riesco a utilizzare il completamento del codice, perché l'IDE non conosce la proprietà che la funzione letterale è il ritorno (sto usando IntelliJ IDEA 9 by the way).

Ho guardato il codice jQuery e ho provato a fare questo:

(function(window, undefined) {
    var myLibrary = (function () {

      var someProp = "...";

      function someFunc() {
        ...
      }

      function someFunc2() {
        ...
      }

      return {
         func: someFunc,
         fun2: someFunc2,
         prop: someProp;
      }

    }());

    window.myLibrary = myLibrary;
}(window));

Ho provato questo, ma ora ho un problema diverso.L'IDE non davvero prendere sul myLibrary sia.

Il modo in cui sto risolvendo il problema ora è questo modo:

var myLibrary = {
   func: function() { },
   func2: function() { },
   prop: ""
};

myLibrary = (function () {

  var someProp = "...";

  function someFunc() {
    ...
  }

  function someFunc2() {
    ...
  }

  return {
     func: someFunc,
     fun2: someFunc2,
     prop: someProp;
  }

}());

Ma anche questo mi sembra un pò goffo, e non riesco proprio a capire come jQuery sta facendo.Un'altra domanda che ho è come gestire funzioni con numeri arbitrari di parametri.

Per esempio, jQuery.bind si può prendere 2 o 3 parametri, e l'IDE non sembra lamentarsi.Ho provato a fare la stessa cosa con la mia libreria, dove una funzione può richiedere 0 argomenti o 1 argomento.Tuttavia, l'IDE si lamenta e avverte che il numero corretto di parametri non vengono inviati.Come faccio a gestire questo?

MODIFICA

Sto iniziando a chiedermi se questo è un Idea9 problema, perché jQuery ha lo stesso problema.Non mi sembra di avere questo problema in altri progetti, però.

Answer 1

Sto usando IDEA con il modello del modulo Yahoo e le mie opere di completamento automatico. Google per il modello di modulo di yahoo.

http://www.yuiblog.com/blog/ 2007/06/12 / module-pattern /

http://ajaxian.com/archives/a-javascript-module-pattern

---

TEST = function() {
    var SOME_CONSTANT='asd';

    function privateStuff(){
        var a = 'asd';
        return a;
    }

    return{
        someArray:[],

        someMethod: function(foo, bar){

            var foo = *1
        }
        ,

        myProperty:'test'
    }
}();

TEST.*2

con * 1 e * 2 ho segnato luoghi in cui ho cercato di completamento automatico.

in * 1 ottengo SOME_CONSTANT e metodo privateStuff, e se metto questa. (Autocomplete) ottengo accesso a tutti i metodi e le proprietà all'interno di rendimento {} blocco

quando provo completamento automatico su * 2 ottengo tutti i metodi e le proprietà all'interno di ritorno {} blocco. SOME_CONSTANT e il metodo privateStuff sono invisibile lì, perché sono "private".

Per me quel livello di completamento automatico è abbastanza bene.

Answer 2

Credo che sarà grande se leggete qualcosa su Douglas Crockford. Egli è l'architetto in Yahou quadro YUI. E dopo che si può avere una migliore idea di come costruire un grande quadro. E per il parametro ci sono 2 opzioni. 1.- inviare via esempio oggetto

{ option :{ var1 : "value" , var2:"value"}, var3 : "value" }

E la si può verificare se l'opzione esistono.

Il secondo non è grande controllo se il parametro non è definito.

function foo(var1,var2){
   var var1_this = null;
     if(var1 != undefined)
      var1_this = var1;
}

e solo un commento per questo costruire un nuovo framework javascript? uso Prototype, JQuery, Mootols, YUI. perché reinventare la ruota?

Answer 3

Questo è in risposta ai commenti di mwilcox post.

Che esempio effettivamente lavoro.Dal myLibrary viene definito senza var, esso viene automaticamente messo in lo spazio dei nomi globale e accessibile in quanto tale.Attraverso la chiusura creata da sé che l'esecuzione della funzione, le variabili private e metodi sono ancora accessibili myLibrary i metodi.Si può facilmente provare questo fuori mettendo in Firebug o Rhino.

In questi giorni, io non tendono a nascondere il mio variabili, cioèIo uso il Pseudoclassical modello o il modello Prototipale e il prefisso mio inteso metodi privati con un _:

// Pseudoclassical pattern
function Hello() {}
Hello.prototype = {
    method1: function() {},
    method2: function() {},
    _pseudeoPrivate: function() {}
};

/* Prototypal pattern. To create multiple instances of this object,
   you need a helper function such as
    function beget(o) {
        var F = function() {};
        F.prototype = o;
        return new F;
    }
    var instance = beget(world);
*/
var world = {
    method1: function() {},
    method2: function() {}
};

Per evitare che il mio codice di inquinanti nello spazio dei nomi globale, ho un processo di costruzione che avvolge il mio moduli di chiusura e le esportazioni le api pubbliche per lo spazio dei nomi.Questa tecnica è utilizzata anche da jQuery.Si può vedere che nel loro codice sorgente (guarda intro.js & outro.js) su Github.

Questo consentirebbe di utilizzare un modello che permette al vostro IDE (o ctags con vim) per vedere le api, ma anche prevenire l'inquinamento del namespace globale.

Answer 4

scrivo le mie librerie in questo modo:

function MyLibrary() {
    // code
}
MyLibrary.prototype.memberFunc = function() {
    // code
}
MyLibrary.prototype.memberVar = 5;

new MyLibrary();

In questo modo, in Geany (che utilizza ctags) MyLibrary è ben noto (per la maggior parte, per esempio, memberVar viene riconosciuta come una funzione) e completamento automatico sembra funzionare. Non so su IDEA9, ma si potrebbe provare in questo modo (ho la sensazione che sia un po 'più evoluto di ctags).

Answer 5

Vi consiglio di non utilizzare variabili private, ma capisco che vuoi che nascosti al intellisense. Questo è come lo farei:

(function(){
    var privateVar = "shhhh!";
    var privateMethod = function(){}


    myLibray = {
        prop:42,
        foo: function(){
            return privateMethod()
        },
        bar: function(){
            return privateVar;
        }
    }

})();

In questo modo si può avere la tua roba privata in una chiusura e la libreria dovrebbe essere accessibile.

[modificato. Io maldestramente non ho incluso MyLibrary in funzione anonima e non riuscivo a vedere i vars privati. oops. ]

cattivo proposito, le mie ragioni per essere variabili private: http: // clubajax. org / javascript--variabili private-sono-il male /