Quelle est la meilleure façon d'exporter une méthode de bibliothèque, lorsque l'on utilise Closure Compiler ?

Question

La documentation du compilateur Closure indique clairement : "N'utilisez pas d'Externs au lieu d'Exports". Parce que les Externs sont très pratiques à utiliser, j'ai rencontré un problème :

function Lib(){ 
  //some initialization  
}
Lib.prototype = {
  invoke : function(str){
     //this function is called from outside to invoke some of Lib's events
  }  
}

Lorsque vous utilisez Closure Compiler avec OPTIMISATIONS AVANCÉES L'invocation de la fonction est supprimée de la source. Cela peut être évité de deux façons : En ajoutant la ligne après la définition du prototype :

Lib.prototype['invoke'] = Lib.prototype.invoke;

Mais cela ajoute une vilaine paix de code à la fin du code de sortie :

Lib.prototype.invoke = Lib.prototype.g;

J'ai réussi à m'en débarrasser en ajoutant cette ligne au constructeur :

this.invoke = this.invoke;

Et cette ligne dans le fichier externs :

/**
* @param {String} str
*/ 
Lib.prototype.invoke = function(str){};

De cette façon, Closure Compiler ne peut pas supprimer la fonction invoke du code de sortie, car elle est assignée par elle-même dans le constructeur, et aussi, il ne peut pas la renommer, car elle est définie dans le fichier externs. Alors quelle méthode est la meilleure ?

Answer 1

Si vous utilisez JSDoc de manière cohérente, vous pouvez utiliser la fonction @export étiquette :

/**
* @param {String} str
* @export
*/ 
Lib.prototype.invoke = function(str){
     //this function is called from outside to invoke some of Lib's events
};

et appeler le compilateur avec l'option --generate_exports drapeau.

Pour cela, vous devez soit inclure base.js à partir de la bibliothèque Google Closure, ou pour copier goog.exportSymbol y goog.exportProperty à votre base de code.

Answer 2

Personnellement, j'aime définir des interfaces dans le fichier externs et faire en sorte que mes classes internes les mettent en œuvre.

// Externs

/** @interface */
function IInvoke {};
IInvoke.prototype.invoke;

/** 
 *  @constructor
 *  @implements {IInvoke}
 */
function Lib(){ 
  //some initialization  
}
Lib.prototype = {
  invoke : function(str){
     //this function is called from outside to invoke some of Lib's events
  }  
}

Vous exportez toujours le constructeur lui-même, mais pas les méthodes de l'interface.