Como defino variáveis ​​globais no CoffeeScript?

No Coffeescript.org:

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

bawbag(5, 10) 

compilaria para:

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

compilar via coffee-script em node.js envolve o seguinte:

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

Os documentos dizem:

Se você deseja criar variáveis ​​de nível superior para uso de outros scripts, anexe-as como propriedades na janela ou no objeto de exportação no CommonJS. O operador existencial (abordado abaixo) fornece uma maneira confiável de descobrir onde adicioná-los, se você estiver direcionando o CommonJS e o navegador: root = export? isto

Como defino Variáveis ​​Globais, em seguida, no CoffeeScript. O que significa 'anexá-los como propriedades na janela'?

Como o script coffee não possui nenhuma varinstrução, ele o insere automaticamente para todas as variáveis ​​no script coffee-coffee, dessa forma evita que a versão JavaScript compilada vaze tudo para o diretório espaço de nomes global .

Portanto, como não há como "vazar" algo no espaço para nome global a partir do lado do script de café, você precisa definir suas variáveis ​​globais como propriedades do objeto global .

anexá-los como propriedades na janela

Isso significa que você precisa fazer algo como window.foo = 'baz';, que lida com o caso do navegador, já que existe o objeto global é o window.

Node.js

No Node.js, não há windowobjeto, mas o exportsobjeto que é passado para o wrapper que envolve o módulo Node.js. (Veja: https://github.com/ry/node/blob/master/src/node.js# L321 ), então no Node.js o que você precisa fazer é exports.foo = 'baz';.

Agora, vamos dar uma olhada no que ele diz em sua citação dos documentos:

... visando o CommonJS e o navegador: root = exportações? isto

Obviamente, isso é um script de café, então vamos dar uma olhada no que isso realmente compila:

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

Primeiro, ele verificará se exports está definido, pois tentar fazer referência a uma variável inexistente no JavaScript produziria um SyntaxError (exceto quando usado com typeof)

Portanto, se exportsexistir, como é o caso do Node.js (ou em um site mal gravado ...), a raiz apontará para o exportscontrário this. Então o que é this?

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

O uso .callde uma função vinculará a thisfunção interna ao primeiro parâmetro passado, no caso do navegador thisagora ser o windowobjeto; no caso do Node.js, seria o contexto global que também está disponível como globalobjeto.

Mas como você tem a requirefunção no Node.js., não há necessidade de atribuir algo ao globalobjeto no Node.js. Em vez disso, você o atribui ao exportsobjeto que é retornado pela requirefunção.

Coffee-Script

Depois de toda essa explicação, aqui está o que você precisa fazer:

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

Isso declarará nossa função foono espaço de nomes global (o que quer que seja).
Isso é tudo :)

Para mim, parece que @atomicules tem a resposta mais simples, mas acho que pode ser simplificada um pouco mais. Você precisa colocar um @antes de qualquer coisa que queira que seja global, para que seja compilado this.anythinge thisse refira ao objeto global.

tão...

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

bawbag(5, 10)

compila para ...

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

e funciona dentro e fora do wrapper fornecido pelo 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

O Ivo acertou em cheio, mas vou mencionar que há um truque sujo que você pode usar, embora eu não o recomende se você estiver procurando por pontos de estilo: você pode incorporar o código JavaScript diretamente no seu CoffeeScript, escapando-o com retalhos.

No entanto, eis o motivo pelo qual essa geralmente é uma má idéia: O compilador CoffeeScript não tem conhecimento dessas variáveis, o que significa que elas não obedecerão às regras normais de escopo do CoffeeScript. Assim,

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

compila para

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

e agora você tem dois foosegundos em escopos diferentes. Não há como modificar o global foo do código CoffeeScript sem fazer referência ao objeto global, como Ivy descreveu.

Obviamente, isso é apenas um problema se você fizer uma atribuição foono CoffeeScript - se se footornar somente leitura depois de receber seu valor inicial (ou seja, é uma constante global), a abordagem da solução JavaScript incorporada poderá ser meio aceitável (embora ainda seja não recomendado).

Você pode passar a opção -b ao compilar o código via coffee-script em node.js. O código compilado será o mesmo que no coffeescript.org.

Para adicionar à resposta de Ivo Wetzel

Parece haver uma sintaxe abreviada para a exports ? thisqual só consigo encontrar documentado / mencionado em uma postagem do grupo do Google .

Ou seja, em uma página da web para disponibilizar uma função globalmente, você declara a função novamente com um @prefixo:

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

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

Eu acho que o que você está tentando alcançar pode ser feito simplesmente assim:

Enquanto você estiver compilando o coffeescript, use o parâmetro "-b".

-b/ --bare Compile o JavaScript sem o wrapper de segurança da função de nível superior.

Então, algo como isto: coffee -b --compile somefile.coffee whatever.js

Isso produzirá seu código exatamente como no site CoffeeScript.org.

Se você é uma pessoa má (eu sou uma pessoa má.), Você pode ser simples assim: (->@)()

Como em,

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

Isso funciona porque, ao chamar a Referencepara Function'bare' (ou seja, em func()vez de new func()ou obj.func()), algo geralmente chamado de 'padrão de chamada de função', sempre se liga thisao objeto global para esse contexto de execução .

O CoffeeScript acima simplesmente compila para (function(){ return this })(); portanto, estamos exercitando esse comportamento para acessar de maneira confiável o objeto global.

Como o coffeescript raramente é usado por si só, você pode usar a globalvariável fornecida pelo node.js ou pelo browserify (e quaisquer descendentes como coffeeify, scripts de construção do gulp, etc.).

No node.js globalestá o espaço para nome global.

No browserify globalé igual a window.

Então apenas:

somefunc = ->
  global.variable = 123