Node.js dersleri 5 - Global Objects, Global Variables

11 - Global Objects

https://nodejs.org/docs/latest/api/globals.html#globals_dirname

http://www.tutorialspoint.com/nodejs/nodejs_global_objects.htm

Node.js global objects are global in nature and they are available in all modules. We do not need to include these objects in our application, rather we can use them directly. These objects are modules, functions, strings and object itself as explained below.

These objects are available in all modules. Some of these objects aren't actually in the global scope but in the module scope - this will be noted. ( Global object'lere tüm module'lerden erişilebilir. Hem de bu object'leri kullanmak için require etmeye yani include etmeye gerek yoktur. Global object'lerin bazıları global scope'da değildir ama gene de tüm module'lerin scope'undadır. )

The objects listed here are specific to Node.js. There are a number of built-in objects that are part of the JavaScript language itself, which are also globally accessible. ( Birazdan inceleyeceğimiz object'ler Node.js'ye specific'dir. Javascript'e özel global object'ler de vardır. )

Class: Buffer

Buffer class is a global class and can be accessed in application without importing buffer module. Buffer class is used to handle binary data. ( Buffer class'ı, global bir class'dır. Buffer module'ünü import etmeye gerek olmadan Buffer class'ını kullanabiliriz. Buffer class'ı, binary data'yı handle etmek için kullanılır.  )

__dirname

The name of the directory that the currently executing script resides in. (Currently çalışan .js dosyasının bulunduğu directory return edilir.)

__dirname ve process.cwd() arasındaki farkı iyi anlamak lazım. process.cwd() -> ./ and process.cwd() refers to the directory on which the node command was called. ( Komut satırında node programımızı hangi directory'den komut vererek çalıştırdıysak bu directory'yi return eder.)

Example: running node example.js from /Users/mjr

console.log(__dirname);

// /Users/mjr

__dirname isn't actually a global but rather local to each module. ( cd /Users/mjr diyerek Users/mjr directory'ye gelelim komut satırından.

Bu directory'de example.js dosyası olsun, bu dosyada şöyle bir satır var diyelim : console.log(__dirname);

Bu dosyayı node example.js komutunu vererek çalıştırınca example.js dosyasının bulunduğu directory output'a yazılır.)

Örneğin 2 tane modül yazdık diyelim :

• a.js bulunduğu yer -> /Users/mjr/app/a.js
• b.js bulunduğu yer -> /Users/mjr/app/node_modules/b/b.js

a.js ve b.js modülünü başka bir modülde include etsek bile, a.js ve b.js dosyasının içerisindeki __dirname, sırayla /Users/mjr/app/a.js ve /Users/mjr/app/node_modules/b/b.js return eder. )

__filename

For a main program this is not necessarily the same filename used in the command line. __filename isn't actually a global but rather local to each module. ( __dirname gibidir. Bulunduğu dosyanın directory'si + file ismi'ni return eder, yani absolute path return eder. )

/Users/mjr directory'sine gelelim komut satırından. Sonra şu komutu verelim : node example.js

example.js dosyasındaki console.log(__filename) satırı çalışınca log'lara şu yazılır : /Users/mjr/example.js

Timer methods

Timer'ları handle etmek için kullandığımız aşağıadaki method'ları, herhangi bir şey include etmeye gerek olmadan kullanabiliriz.

• clearImmediate(immediateObject)
• clearInterval(intervalObject)
• clearTimeout(timeoutObject)
• setImmediate(callback[, arg][, ...])
• setInterval(callback, delay[, arg][, ...])
• setTimeout(callback, delay[, arg][, ...])

<Object> console

console object'ini kullanarak stdout'a ve stderr'a yani log'lara log yazabiliriz.

 

exports

exports isn't actually a global but rather local to each module. ( exports object de aslında global bir object değildir, herbir modül için local bir object'dir. )

<Object> global

The global namespace object.

In browsers, the top-level scope is the global scope. That means that in browsers if you're in the global scope var something will define a global variable. In Node.js this is different. The top-level scope is not the global scope; var something inside an Node.js module will be local to that module. ( Javascript'de top-level scope'da bir variable declare edersek bu variable global scope'dadır. Ancak node.js'de bir dosyada top-level scope'da bir variable declare edersek, bu variable bu module içindeki local bir variable'dır. Node.js'de global variable declare etmeyi sonraki maddede öğreneceğiz. )

 

<Object> module

A reference to the current module. module isn't actually a global but rather local to each module. ( module object'i, current module'e refer eder. )

<Object> process

The process object.

<Function> require()

To require modules. require isn't actually a global but rather local to each module. (Modülleri include etmek için kullancığımız require() method'unu kullanmak için herhangi bir şey include(require) etmeye gerek yoktur.)

<Object>  require.cache

Modules are cached in this object when they are required. By deleting a key value from this object, the next require will reload the module. Note that this does not apply to native addons, for which reloading will result in an Error.

<Object> require.extensions

Stability: 0 - Deprecated

Instruct require on how to handle certain file extensions.

Process files with the extension .sjs as .js:

require.extensions['.sjs'] = require.extensions['.js'];

 

require.resolve()

Use the internal require() machinery to look up the location of a module, but rather than loading the module, just return the resolved filename.

12 - Global Variables in Node.js

http://www.hacksparrow.com/global-variables-in-node-js.html

How do you make variables global in Node.js? 2 farklı şekilde :       

- global.name='omer' veya GLOBAL.name='omer' (add the variable to the global object)

- name = 'omer' diyerek.(declare the variable without the var keyword)

global object'i incelemek için, önce komut satırını açalım ve node komutunu çalıştırarak Node REPL(prompt)'in açılmasını sağlayalım.

$ node
>

Type global at the prompt to see what the object is all about. That's one huge object! Infact, you saw the soul of Node. global and GLOBAL are one and the same thing. Indeed, GLOBAL is an alias for global.

(Node REPL komut satırına global yazınca, global object'in dev içeriğini görürüz.)

> global

Örnek :

> global.name
undefined name isimli bir global variable olmadığı için undefined return oldu.

> global.name = 'El Capitan' name isimli bir global variable tanımladık.
> global.name
'El Capitan'

> GLOBAL.name
'El Capitan'

> delete global.name
true
> GLOBAL.name
undefined

> name = 'El Capitan'
'El Capitan'
> global.name
'El Capitan'
> GLOBAL.name
'El Capitan'

> var name = 'Sparrow'
undefined
> global.name
'Sparrow'

* Globally declared variables in a module can be referenced from any module with just their name, without having to refer them from the global object - name == global.name. But that does not mean you should do that. Why? Look at this:

var company = 'Yahoo';
console.log(global.company); // 'Google'
console.log(company); // 'Yahoo'

When you use global.company, you know you are dealing with a global variable, besides it spares the name company for use as a local variable within the module. ( company isimli bir local variable tanımladık. Sonra sırayla company isimli global variable'ı ve local variable'ı console'a yazdık. Local variable'a erişmek için sadece company dedik. Halbuki company='Yahoo' deseydik de bir global variable tanımlamış olacaktır. Sonra şöyle bir yanılgıya kapılabilirdik : console.log(company) deyince global variable'a erişmeye çalıştığımızı zannedebilirdik. Dolayısıyla global.company='Yahoo' diyerek global bir variable tanımlamak daha iyidir. )

* Gereksiz yere çok sayıda global variable tanımlamaktan kaçınmalıyız. Bunun yerine module.exports kullanmalıyız. main modülünde company isimli bir public variable tanımlandı, bu variable'a diğer modüllerden erişmek için main.js modülünü include etmeliyiz.

File: main.js

exports.company = 'Google';
var m = require('./mod');

File: mod.js

var company = require('./main').company;
console.log(company);

Now to see it in action:

$ node main.js
Google

Note: including a module which was already included in another module just creates a reference to the previous inclusion, so it does not mean a drastic increase in RAM. Also, since the there is no real re-inclusion, all the init functions in the module are not executed again.

So, in conclusion, there are two ways of creating global variables in Node.js, one uses the global object, and the other uses module.exports. What is my recommendation? global method for small apps, module.exports for big apps.