Comment définir des variables globales dans CoffeeScript?

Sur Coffeescript.org:

bawbag = (x, y) ->
    z = (x * y)

bawbag(5, 10) 

compilerait pour:

var bawbag;
bawbag = function(x, y) {
  var z;
  return (z = (x * y));
};
bawbag(5, 10);

la compilation via coffee-script sous node.js enveloppe ainsi:

(function() {
  var bawbag;
  bawbag = function(x, y) {
    var z;
    return (z = (x * y));
  };
  bawbag(5, 10);
}).call(this);

Les documents disent:

Si vous souhaitez créer des variables de niveau supérieur pour d'autres scripts à utiliser, attachez-les en tant que propriétés sur la fenêtre ou sur l'objet exports dans CommonJS. L'opérateur existentiel (décrit ci-dessous) vous donne un moyen fiable de savoir où les ajouter, si vous ciblez à la fois CommonJS et le navigateur: root = exports? ce

Comment puis-je définir des variables globales dans CoffeeScript. Que signifie «les attacher en tant que propriétés sur la fenêtre»?

Étant donné que le script coffee n'a pas de vardéclaration, il l'insère automatiquement pour toutes les variables dans le script coffee, de cette façon, il empêche la version JavaScript compilée de tout divulguer dans l' espace de noms global .

Donc, puisqu'il n'y a aucun moyen de faire quelque chose "fuir" dans l' espace de noms global du côté café-script des choses, vous devez définir vos variables globales en tant que propriétés de l' objet global .

les attacher en tant que propriétés sur la fenêtre

Cela signifie que vous devez faire quelque chose comme window.foo = 'baz';, qui gère le cas du navigateur, car l' objet global est le window.

Node.js

Dans Node.js, il n'y a pas d' windowobjet, mais plutôt l' exportsobjet qui est passé dans le wrapper qui enveloppe le module Node.js (Voir: https://github.com/ry/node/blob/master/src/node.js# L321 ), donc dans Node.js ce que vous devez faire est exports.foo = 'baz';.

Voyons maintenant ce qu'il indique dans votre citation de la documentation:

... ciblant à la fois CommonJS et le navigateur: root = exports? ce

Ceci est évidemment un script de café, alors regardons ce que cela compile réellement:

var root;
root = (typeof exports !== "undefined" && exports !== null) ? exports : this;

Tout d'abord, il vérifiera si exportsest défini, car essayer de référencer une variable inexistante en JavaScript produirait sinon une SyntaxError (sauf lorsqu'elle est utilisée avectypeof )

Donc, s'il exportsexiste, ce qui est le cas dans Node.js (ou dans un site Web mal écrit ...), la racine pointera exports, sinon this. Alors quoi this?

(function() {...}).call(this);

L'utilisation .calld'une fonction liera l' thisintérieur de la fonction au premier paramètre passé, dans le cas où le navigateur thisserait maintenant l' windowobjet, dans le cas de Node.js, ce serait le contexte global qui est également disponible en tant globalqu'objet.

Mais puisque vous avez la requirefonction dans Node.js, il n'est pas nécessaire d'affecter quelque chose à l' globalobjet dans Node.js, à la place vous attribuez à l' exportsobjet qui est ensuite renvoyé par la requirefonction.

Café-Script

Après toutes ces explications, voici ce que vous devez faire:

root = exports ? this
root.foo = -> 'Hello World'

Cela déclarera notre fonction foodans l'espace de noms global (quel qu'il soit).
C'est tout :)

Il me semble que @atomicules a la réponse la plus simple, mais je pense qu'elle peut être simplifiée un peu plus. Vous devez mettre un @avant tout ce que vous voulez être global, afin qu'il se compile this.anythinget fasse thisréférence à l'objet global.

alors...

@bawbag = (x, y) ->
    z = (x * y)

bawbag(5, 10)

compile pour ...

this.bawbag = function(x, y) {
  var z;
  return z = x * y;
};
bawbag(5, 10);

et fonctionne à l'intérieur et à l'extérieur du wrapper donné par node.js

(function() {
    this.bawbag = function(x, y) {
      var z;
      return z = x * y;
    };
    console.log(bawbag(5,13)) // works here
}).call(this);

console.log(bawbag(5,11)) // works here

Ivo l'a cloué, mais je mentionnerai qu'il y a une sale astuce que vous pouvez utiliser, bien que je ne le recommande pas si vous recherchez des points de style: vous pouvez incorporer du code JavaScript directement dans votre CoffeeScript en l'échappant avec des astuces.

Cependant, voici pourquoi il s'agit généralement d'une mauvaise idée: le compilateur CoffeeScript ne connaît pas ces variables, ce qui signifie qu'elles n'obéiront pas aux règles de cadrage CoffeeScript normales. Alors,

`foo = 'bar'`
foo = 'something else'

compile en

foo = 'bar';
var foo = 'something else';

et maintenant vous avez deux foos dans des portées différentes. Il n'y a aucun moyen de modifier le global à foo partir du code CoffeeScript sans référencer l'objet global, comme Ivy l'a décrit.

Bien sûr, cela n'est un problème que si vous effectuez une affectation foodans CoffeeScript - si vous foodevenez en lecture seule après avoir reçu sa valeur initiale (c'est-à-dire qu'il s'agit d'une constante globale), alors l'approche de la solution JavaScript intégrée peut être un peu acceptable (bien que toujours non recommandé).

Vous pouvez passer l'option -b lorsque vous compilez du code via coffee-script sous node.js. Le code compilé sera le même que sur coffeescript.org.

Pour ajouter à la réponse d'Ivo Wetzel

Il semble y avoir une syntaxe abrégée pour exports ? thislaquelle je ne peux trouver que documenté / mentionné sur une publication de groupe Google .

C'est-à-dire que dans une page Web pour rendre une fonction disponible globalement, vous déclarez à nouveau la fonction avec un @préfixe:

<script type="text/coffeescript">
    @aglobalfunction = aglobalfunction = () ->
         alert "Hello!"
</script>

<a href="javascript:aglobalfunction()" >Click me!</a>

Je pense que ce que vous essayez de réaliser peut simplement être fait comme ceci:

Pendant que vous compilez le coffeescript, utilisez le paramètre "-b".

-b/ --bare Compilez le JavaScript sans le wrapper de sécurité de fonction de niveau supérieur.

Donc quelque chose comme ça: coffee -b --compile somefile.coffee whatever.js

Cela affichera votre code comme sur le site CoffeeScript.org.

Si vous êtes une mauvaise personne (je suis une mauvaise personne), vous pouvez être aussi simple que cela: (->@)()

Un péché,

(->@)().im_a_terrible_programmer = yes
console.log im_a_terrible_programmer

Cela fonctionne, car lorsque vous invoquez un Referencevers un Function'nu' (c'est-à-dire func(), au lieu de new func()ou obj.func()), quelque chose communément appelé le 'modèle d'invocation d'appel de fonction', se lie toujoursthis à l'objet global pour ce contexte d'exécution .

Le CoffeeScript ci-dessus se compile simplement en (function(){ return this })(); nous exerçons donc ce comportement pour accéder de manière fiable à l'objet global.

Comme coffeescript est rarement utilisé seul, vous pouvez utiliser une globalvariable fournie par node.js ou browserify (et tout descendant comme coffeeify, gulp build scripts, etc.).

Dans node.js globalest l'espace de noms global.

Dans browserify globalest égal à window.

Donc, juste:

somefunc = ->
  global.variable = 123