javascript packer versus minifier
Je me demandais quelles sont les différences/avantages de l'emballeur vs le minifier ont été, à savoir, si vous déployez des paniers ou version minifiée dans votre application web?
Exemple de code:
var layout = {
NAVVISIBLE : 1,
Init : function()
{
this.Resize();
},
Dimensions : function()
{
var d = document, s = self, w, h;
if (s.innerHeight)
{ w = s.innerWidth; h = s.innerHeight; }
else if (d.documentElement && d.documentElement.clientHeight)
{ w = d.documentElement.clientWidth; h = d.documentElement.clientHeight; }
else if (d.body)
{ w = d.body.clientWidth; h = d.body.clientHeight; }
return new Array(parseInt(w), parseInt(h));
},
Resize : function()
{
var dim = this.Dimensions();
try
{
$('tbl_container').width = px(dim[0] - 25);
$('row_container').height = px(dim[1] - 100);
$('dat_container').width = px(dim[0] - (this.NAVVISIBLE ? 275 : 25));
$('dat_container').height = px(dim[1] - 100);
}
catch(e) {}
},
GoSideways : function()
{
var nc = $('nav_container');
var dc = $('dat_container');
nc.style.display = this.NAVVISIBLE ? 'none' : '';
dc.width = px(parseInt(dc.width) + (this.NAVVISIBLE ? 250 : -250));
this.NAVVISIBLE ^= 1;
},
FrameLoad : function(url)
{
if (url)
content_frame.document.location = url;
}
};
minifiés:
var layout={NAVVISIBLE:1,Init:function()
{this.Resize();},Dimensions:function()
{var d=document,s=self,w,h;if(s.innerHeight)
{w=s.innerWidth;h=s.innerHeight;}
else if(d.documentElement&&d.documentElement.clientHeight)
{w=d.documentElement.clientWidth;h=d.documentElement.clientHeight;}
else if(d.body)
{w=d.body.clientWidth;h=d.body.clientHeight;}
return new Array(parseInt(w),parseInt(h));},Resize:function()
{var dim=this.Dimensions();try
{$('tbl_container').width=px(dim[0]-25);$('row_container').height=px(dim[1]-100);$('dat_container').width=px(dim[0]-(this.NAVVISIBLE?275:25));$('dat_container').height=px(dim[1]-100);}
catch(e){}},GoSideways:function()
{var nc=$('nav_container');var dc=$('dat_container');nc.style.display=this.NAVVISIBLE?'none':'';dc.width=px(parseInt(dc.width)+(this.NAVVISIBLE?250:-250));this.NAVVISIBLE^=1;},FrameLoad:function(url)
{if(url)
content_frame.document.location=url;}};
emballé:
eval(function(p,a,c,k,e,d){e=function(c){return(c<a?'':e(parseInt(c/a)))+((c=c%a)>35?String.fromCharCode(c+29):c.toString(36))};if(!''.replace(/^/,String)){while(c--){d[e(c)]=k[c]||e(c)}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('5 B={3:1,C:6(){2.n()},v:6(){5 d=k,s=y,w,h;9(s.u){w=s.A;h=s.u}r 9(d.a&&d.a.c){w=d.a.p;h=d.a.c}r 9(d.b){w=d.b.p;h=d.b.c}D z x(g(w),g(h))},n:6(){5 7=2.v();F{$(\'N\').8=4(7[0]-o);$(\'P\').m=4(7[1]-l);$(\'i\').8=4(7[0]-(2.3?E:o));$(\'i\').m=4(7[1]-l)}L(e){}},H:6(){5 t=$(\'I\');5 j=$(\'i\');t.J.G=2.3?\'Q\':\'\';j.8=4(g(j.8)+(2.3?q:-q));2.3^=1},M:6(f){9(f)O.k.K=f}};',53,53,'||this|NAVVISIBLE|px|var|function|dim|width|if|documentElement|body|clientHeight|||url|parseInt||dat_container|dc|document|100|height|Resize|25|clientWidth|250|else||nc|innerHeight|Dimensions||Array|self|new|innerWidth|layout|Init|return|275|try|display|GoSideways|nav_container|style|location|catch|FrameLoad|tbl_container|content_frame|row_container|none'.split('|'),0,{}))
source d'informationauteur user318747
Vous devez vous connecter pour publier un commentaire.
Paniers est plus petit, mais est plus lent.
Et encore plus difficile à déboguer.
La plupart bien connu, les cadres et les plugins ne sont minifiés.
Prendre un coup d'oeil à google minifier: http://code.google.com/intl/en-EN/closure/compiler/
Ils offrent un plugin firebug pour le débogage minifiés code.
Packer n'est plus que juste de renommer les vars et les arguments, il fait les cartes du code source à l'aide Base62 qui doit être reconstruit sur le côté client via la fonction eval() pour être utilisable.
Côté intensification de la fonction eval() est mal de questions ici, cela peut également créer une grande quantité de frais généraux sur le client pendant le chargement de la page lorsque vous commencez à emballer de plus grandes bibliothèques JS comme jQuery. Ce pourquoi ne le font rapetisser sur votre production JS est recommandé, car si vous avez assez de code avoir besoin de faire de l'emballage ou de rapetisser, vous avez assez de code pour faire la fonction eval() étouffer le client pendant le chargement de la page.
Pour une bonne minifier, je chercherais à l'aide de Google Closure compiler
http://code.google.com/closure/compiler/
La SIMPLE_OPTIMIZATIONS mode est ce que je vous conseille d'utiliser, il nettoie les espaces/commentaires et munges(réduit) des variables. Il fait aussi quelques simples modifications du code qui, en gros, quantité de code de nettoyer et de micro-optimisations. Vous pouvez voir plus à ce sujet sur la mise en route avec le Compilateur de Fermeture de l'Application
ou la vérification de la emballés README.
YUI Compressor est une autre option(de Yahoo), mais il ne réduit pas la taille du fichier d'autant que CC n'.
Il existe également un outil de Microsoft, le nom m'échappe à l'instant, mais qui, apparemment, fournit des résultats similaires à CC. Que l'on pouvait être un meilleur ou pour le pire option, en fonction de votre environnement. Je ne l'ai lu à ce sujet en passant, de sorte que de nouvelles investigations seraient nécessaires.
Si votre serveur de fichiers gzip fichiers avant de les envoyer au navigateur (qui est très souvent le cas), alors packer est pas le chemin à parcourir. J'ai testé un certain nombre de fichiers, et même si packer fait des fichiers plus petits que minification, il fait de plus gros fichiers zippés. Alors que je ne suis pas un expert, je pense que la raison en est assez simple.
Une grande partie de la compression est de trouver plusieurs séquences de caractères et de les remplacer par des plus courts place de titulaire à être déballé plus tard. C'est la même chose packer, sauf zip algorithmes sont beaucoup plus efficaces. Donc, lorsque vous compressez un fichier, vous êtes dans une sorte de pré-compression, mais avec un algorithme qui est moins efficace qu'un fichier zip. Cela laisse moins de travail pour le zip de l'algorithme à faire, avec une diminution de l'efficacité de la compression.
Donc si vous êtes à la compression de fichiers, puis packer produira plus gros téléchargements. Ajoutez à cela le supplémentaires inconvénients de packer mentionnés dans les réponses ci-dessus, et il n'y a vraiment aucune bonne raison de l'utiliser packer.
Vise à la fois à réduire la taille de l'activer JavaScript pour téléchargement rapide sur le navigateur client.
Minifier ne supprime des choses inutiles comme des caractères espace et le renommage de variables pour les petits noms dans la mesure du possible. Mais un Packer va plus loin et fait tout ce qu'il peut faire pour réduire la taille de JavaScript. Pour, par exemple, il convertit le code source de Base62 tout en préservant c'est mappages d'être évalué par le client.
Selon le code des paniers, des paniers solution ca entraîner script-erreurs, tandis que les minifiés fonctionne.
Donc de tester avec différents navigateurs, après l'emballage de votre code. Si il ne fonctionne plus, essayez la version minifiée, qui doit toujours travailler.
Un "packer" est le même comme un "minifier". L'outil le plus commun qui appelle lui-même un "packer" est http://dean.edwards.name/packer/ qui donne de l'option (activée par défaut) pour base62 de l'encodage. Base62 encodage est probablement une mauvaise idée: https://stackoverflow.com/a/1351624/24267.