variáveis ​​globais do node.js.?

Eu perguntei aqui: node.js requer herança?

e me disseram que eu posso definir variáveis ​​para o escopo global deixando de fora o var.

Isso não funciona para mim.

ou seja:

_ = require('underscore');

Não disponibiliza o _ nos arquivos necessários. Eu posso definir com expresso app.sete tê-lo disponível em outro lugar embora.

Alguém pode confirmar que isso deve funcionar? Obrigado.

Você pode usar globalassim:

global._ = require('underscore')

No nó, você pode definir variáveis ​​globais por meio do objeto "global" ou "GLOBAL":

GLOBAL._ = require('underscore'); // but you "shouldn't" do this! (see note below)

ou mais útil ...

GLOBAL.window = GLOBAL;  // like in the browser

Na origem do nó, você pode ver que esses são alias entre si:

node-v0.6.6/src/node.js:
28:     global = this;
128:    global.GLOBAL = global;

No código acima, "this" é o contexto global. Com o sistema de módulo commonJS (que o nó usa), o objeto "this" dentro de um módulo (ou seja, "seu código") NÃO é o contexto global. Para provar isso, veja abaixo onde eu vomito o objeto "this" e o objeto "GLOBAL" gigante.

console.log("\nTHIS:");
console.log(this);
console.log("\nGLOBAL:");
console.log(global);

/* outputs ...

THIS:
{}

GLOBAL:
{ ArrayBuffer: [Function: ArrayBuffer],
  Int8Array: { [Function] BYTES_PER_ELEMENT: 1 },
  Uint8Array: { [Function] BYTES_PER_ELEMENT: 1 },
  Int16Array: { [Function] BYTES_PER_ELEMENT: 2 },
  Uint16Array: { [Function] BYTES_PER_ELEMENT: 2 },
  Int32Array: { [Function] BYTES_PER_ELEMENT: 4 },
  Uint32Array: { [Function] BYTES_PER_ELEMENT: 4 },
  Float32Array: { [Function] BYTES_PER_ELEMENT: 4 },
  Float64Array: { [Function] BYTES_PER_ELEMENT: 8 },
  DataView: [Function: DataView],
  global: [Circular],
  process: 
   { EventEmitter: [Function: EventEmitter],
     title: 'node',
     assert: [Function],
     version: 'v0.6.5',
     _tickCallback: [Function],
     moduleLoadList: 
      [ 'Binding evals',
        'Binding natives',
        'NativeModule events',
        'NativeModule buffer',
        'Binding buffer',
        'NativeModule assert',
        'NativeModule util',
        'NativeModule path',
        'NativeModule module',
        'NativeModule fs',
        'Binding fs',
        'Binding constants',
        'NativeModule stream',
        'NativeModule console',
        'Binding tty_wrap',
        'NativeModule tty',
        'NativeModule net',
        'NativeModule timers',
        'Binding timer_wrap',
        'NativeModule _linklist' ],
     versions: 
      { node: '0.6.5',
        v8: '3.6.6.11',
        ares: '1.7.5-DEV',
        uv: '0.6',
        openssl: '0.9.8n' },
     nextTick: [Function],
     stdout: [Getter],
     arch: 'x64',
     stderr: [Getter],
     platform: 'darwin',
     argv: [ 'node', '/workspace/zd/zgap/darwin-js/index.js' ],
     stdin: [Getter],
     env: 
      { TERM_PROGRAM: 'iTerm.app',
        'COM_GOOGLE_CHROME_FRAMEWORK_SERVICE_PROCESS/USERS/DDOPSON/LIBRARY/APPLICATION_SUPPORT/GOOGLE/CHROME_SOCKET': '/tmp/launch-nNl1vo/ServiceProcessSocket',
        TERM: 'xterm',
        SHELL: '/bin/bash',
        TMPDIR: '/var/folders/2h/2hQmtmXlFT4yVGtr5DBpdl9LAiQ/-Tmp-/',
        Apple_PubSub_Socket_Render: '/tmp/launch-9Ga0PT/Render',
        USER: 'ddopson',
        COMMAND_MODE: 'unix2003',
        SSH_AUTH_SOCK: '/tmp/launch-sD905b/Listeners',
        __CF_USER_TEXT_ENCODING: '0x12D732E7:0:0',
        PATH: '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:~/bin:/usr/X11/bin',
        PWD: '/workspace/zd/zgap/darwin-js',
        LANG: 'en_US.UTF-8',
        ITERM_PROFILE: 'Default',
        SHLVL: '1',
        COLORFGBG: '7;0',
        HOME: '/Users/ddopson',
        ITERM_SESSION_ID: 'w0t0p0',
        LOGNAME: 'ddopson',
        DISPLAY: '/tmp/launch-l9RQXI/org.x:0',
        OLDPWD: '/workspace/zd/zgap/darwin-js/external',
        _: './index.js' },
     openStdin: [Function],
     exit: [Function],
     pid: 10321,
     features: 
      { debug: false,
        uv: true,
        ipv6: true,
        tls_npn: false,
        tls_sni: true,
        tls: true },
     kill: [Function],
     execPath: '/usr/local/bin/node',
     addListener: [Function],
     _needTickCallback: [Function],
     on: [Function],
     removeListener: [Function],
     reallyExit: [Function],
     chdir: [Function],
     debug: [Function],
     error: [Function],
     cwd: [Function],
     watchFile: [Function],
     umask: [Function],
     getuid: [Function],
     unwatchFile: [Function],
     mixin: [Function],
     setuid: [Function],
     setgid: [Function],
     createChildProcess: [Function],
     getgid: [Function],
     inherits: [Function],
     _kill: [Function],
     _byteLength: [Function],
     mainModule: 
      { id: '.',
        exports: {},
        parent: null,
        filename: '/workspace/zd/zgap/darwin-js/index.js',
        loaded: false,
        exited: false,
        children: [],
        paths: [Object] },
     _debugProcess: [Function],
     dlopen: [Function],
     uptime: [Function],
     memoryUsage: [Function],
     uvCounters: [Function],
     binding: [Function] },
  GLOBAL: [Circular],
  root: [Circular],
  Buffer: 
   { [Function: Buffer]
     poolSize: 8192,
     isBuffer: [Function: isBuffer],
     byteLength: [Function],
     _charsWritten: 8 },
  setTimeout: [Function],
  setInterval: [Function],
  clearTimeout: [Function],
  clearInterval: [Function],
  console: [Getter],
  window: [Circular],
  navigator: {} }
*/

** Nota: em relação à configuração "GLOBAL._", em geral você deve fazer var _ = require('underscore');. Sim, você faz isso em todos os arquivos que usam sublinhado, assim como em Java import com.foo.bar;. Isso torna mais fácil descobrir o que seu código está fazendo porque as ligações entre os arquivos são 'explícitas'. Um pouco irritante, mas uma coisa boa. .... Essa é a pregação.

Há uma exceção a todas as regras. Eu tive exatamente exatamente UMA instância em que precisei definir "GLOBAL._". Eu estava criando um sistema para definir arquivos "config" que eram basicamente JSON, mas foram "escritos em JS" para permitir um pouco mais de flexibilidade. Esses arquivos de configuração não tinham instruções 'exigem', mas eu queria que eles tivessem acesso ao sublinhado (o sistema INTIRE era baseado em modelos de sublinhado e sublinhado); portanto, antes de avaliar a "configuração", eu definiria "GLOBAL._". Então, sim, para todas as regras, há uma exceção em algum lugar. Mas é melhor você ter um bom motivo, e não apenas "eu me canso de digitar 'exigir', então quero romper com a convenção".

As outras soluções que usam a palavra-chave GLOBAL são um pesadelo para manter / legibilidade (+ poluição do namespace e bugs) quando o projeto fica maior. Eu já vi esse erro muitas vezes e tive o trabalho de corrigi-lo.

Use um arquivo JS e use as exportações do módulo.

Exemplo:

globals.js

var Globals = {
    'domain':'www.MrGlobal.com';
}

module.exports = Globals;

Então, se você quiser usá-los, use require.

var globals = require('globals'); //<< globals.js path
globals.domain //<< Domain.

Que tal um espaço para nome global como global.MYAPI = {}

global.MYAPI._ = require('underscore')

Editar após o comentário de camilo-martin : Todos os outros pôsteres falam sobre o mau padrão envolvido. Portanto, deixando essa discussão de lado, a melhor maneira de definir uma variável globalmente (a pergunta do OP) é ​​através de espaços para nome.

@ dica: http://thanpol.as/javascript/development-using-namespaces

Você pode apenas usar o objeto global.

var X = ['a', 'b', 'c'];
global.x = X;

console.log(x);
//['a', 'b', 'c']

Concordo que o uso do espaço de nomes global / GLOBAL para definir algo global é uma prática ruim e não o utiliza em teoria ( em teoria, é a palavra operativa). No entanto (sim, o dispositivo) eu o uso para definir classes de erro personalizadas:

// Some global/config file that gets called in initialisation

global.MyError = [Function of MyError];

Sim, tabu aqui, mas se o seu site / projeto usar erros personalizados em todo o local, você basicamente precisará defini-lo em qualquer lugar ou pelo menos em algum lugar para:

1. Defina a classe Error em primeiro lugar
2. No script em que você está jogando
3. No script onde você está pegando

Definir meus erros personalizados no namespace global me poupa o trabalho de exigir a minha biblioteca de erros do cliente. Imagem gerando um erro personalizado em que esse erro personalizado é indefinido.

Também, se isso estiver errado, entre em contato, pois eu comecei a fazer isso recentemente