Googles
Closure Compiler

Anwendungsszenarien, Ökosystem, Features

Martin Läuter
3. Juli 2014

Was ist der Closure Compiler?

Ziele

Features

Implementierung

auch online unter
http://closure-compiler.appspot.com/

Drei Modi

JavaScript lässt zu viele Paradigmen zu, um für alle Programme beweisbar die Semantik gleich zu lassen.

Deshalb gibt es drei Modi, die unterschiedlich weit optimieren und entsprechend mehr oder weniger Kooperation des Entwicklers erfordern.

Man schreibt aber immer gültiges JavaScript, d. h. der Code läuft auch uncompiliert.

WHITESPACE

WHITESPACE
SIMPLE_OPTIMIZATION
ADVANCED_OPTIMIZATION

– entfernt nur Kommentare, überflüssige Kommas, Semikola, Leerzeichen, Zeilenenden.

SIMPLE_OPTIMIZATION

WHITESPACE
SIMPLE_OPTIMIZATION
ADVANCED_OPTIMIZATION

– zus. kürzere lokale Bezeichner (Basisminifizierung).

ADVANCED_OPTIMIZATION

WHITESPACE
SIMPLE_OPTIMIZATION
ADVANCED_OPTIMIZATION

– zus. globales Renaming, Dead Code Elimination, Inlining.

Beispiel

function unusedFunction(note) {
  alert(note['text']);
}

function displayNoteTitle(note) {
  alert(note['title']);
}

var flowerNote = {};
flowerNote['title'] = "Flowers";
displayNoteTitle(flowerNote);

Ausgabe

SIMPLE_OPTIMIZATION

function unusedFunction(a){alert(a.text)}function d
isplayNoteTitle(a){alert(a.title)}var flowerNote={t
itle:"Flowers"};displayNoteTitle(flowerNote);

ADVANCED_OPTIMIZATION

alert("Flowers");

Wie sieht die Kooperation aus?

Wie sieht die Kooperation aus? II

Das Ökosystem

Annotation von Typen I

/**
 * My namespace's favorite kind of beer.
 * @const
 * @type {string}
 */
mynamespace.MY_BEER = 'stout';

/**
 * A rectangle.
 * @constructor
 */
function GM_Rect() { ... }

/**
 * Enum for tri-state values.
 * @enum {number}
 */
project.TriState = {
  TRUE: 1,
  FALSE: -1,
  MAYBE: 0
};

Annotation von Typen II

/** @typedef {(string|number)} */
goog.NumberLike;

/**
 * The message hex ID.
 * @type {string}
 */
var hexId = hexId;
          
@type {(number|boolean)}
@type {Array.<string>}
@type {?number}
@type {!Object}
@type {{myNum: number, myObject}} 
@type {function(this:goog.ui.Menu, string)}

@param {number=} opt_argument

Klassen und Vererbung

goog.provide('myNS.A');
goog.provide('myNS.B');

/** @constructor */ myNS.A = function() {
  goog.base.call(this);
  this.nr=5;
};

/** @constructor
 * @extends {myNS.A} */ myNS.B = function() {
  myNS.A.call(this);
};
goog.inherits(myNS.B, myNS.A);

myNS.B.prototype.bumpNr = function() {
  ++this.nr;
}

/** @type {myNS.B} */ var instB = new myNS.B();
alert(''+instB.nr); instB.bumpNr(); alert(''+instB.nr);

// @use_closure_library true

Namespaces

In der CL heißen die Methoden goog.dom.create(). Namespaces können requiret goog.require('myNS'); und providet goog.provide('myNS');werden.

var foo = {};
foo.bar = function (a) { this.bad = a; }; // BAD
foo.bar("hello");
compiliert zu
var foo$bar = function (a) { this.bad = a; };
foo$bar("hello");

Anwendungen

Der Closure Compiler ist also ein JS-JS-Transpiler.

Achtung!

Trivia

Gibt es Fragen?

Link zur Präsentation www.laeuter.de/martin/jstalk/jstalk.html