10 Ocak 2018 Çarşamba

Node.js Dersleri 9 - Why does Eventemitter not work on immediate emit

26 - Why does Eventemitter not work on immediate emit?HelloNode13

Aşağıda 2 farklı kodda EventEmitter.emit() method'u sırasıyla senkron ve asenkron olarak çalıştırılmıştır. Farkı inceleyelim.
EventEmitter emits synchronously, which means that in your first example, the event being emitted (from the constructor) is emitted before a listener has been attached. Because events aren't queued or "saved", your event listener won't get the message (it simply started listening too late). (Aşağıdaki kod düzgün çalışmaz. Çünkü eventEmitter.emit() method'u senkron olarak çağırılmıştır. Dolayısıyla ilgili event için bir listener kaydedilmeden bu event emit edilmeye çalışılmıştır. )
const EventEmitter = require('events');
const util = require('util');
function MyEmitter() {
 EventEmitter.call(this);
 this.emit('event');
}
util.inherits(MyEmitter, EventEmitter);
const myEmitter = new MyEmitter();
myEmitter.on('event', function() {
 console.log('an event occurred!');
});
// No output!
In your second example, the event is emitted from the constructor in the next cycle of the event loop (asynchronously). At that point, the code that adds the listener to myEmitter has already run, so at the time the event is being emitted the listener will receive it. (Aşağıdaki kod ise düzgün çalışır. Çünkü EventEmitter.emit() method'u asenkron olarak çağırılmıştır. Event loop'un sonraki tick'inde çalışacaktır. O noktada ise myEmitter'a listener'ı kaydeden kod'un olduğu satır zaten çalıştırılmış olacaktır. Dolayısıyla ilgili event emit edilmeden önce listener ile register edilmiş olacaktır. )
const EventEmitter = require('events');
const util = require('util');
function MyEmitter() {
 EventEmitter.call(this);
 process.nextTick(function () {
   this.emit('event');
 }.bind(this));
}
util.inherits(MyEmitter, EventEmitter);
const myEmitter = new MyEmitter();
myEmitter.on('event', function() {
 console.log('an event occurred!');
});
Output :
an event occured!
It's similar to this:
// synchronously: 'A' is logged before 'B'
console.log('A');
console.log('B');
// asynchronously: 'B' is logged before 'A'
process.nextTick(function() { console.log('A') });   // Sonra burası çalışır.
console.log('B'); // Önce burası çalışır.
O yüzden emit method'unu asenkron olarak çalıştırmak veya senkron bir kod yazacaksak önce event'i kaydetmek sonra emit etmek gerekir.
Resource :
http://stackoverflow.com/questions/30724625/node-js-eventemitter-not-working-on-immediate-emit
http://stackoverflow.com/questions/38140113/eventemitter-and-nexttick-in-nodejs/38140793#38140793

27 - fs module

http://ricostacruz.com/cheatsheets/nodejs-fs.html
http://www.tutorialspoint.com/nodejs/nodejs_file_system.htm
Reading
fs.readFile('file.txt', function(err, data) { .. });
fs.readFile('file.txt', {encoding: 'utf-8'}, function(err, data) { .. });
Writing
fs.writeFile('output.txt', function(err) { .. });
fs.appendFile('output.txt', function(err) { .. });
Watch
fs.watch('dir OR file.txt', { persistent: true }, function(event, file) {
 event; /* rename | change */
});
Getting info
fs.exists('file.txt', function(exists /*bool*/) { ... });
fs.stat('file.txt', function(stats) {
 stats.isFile();
 stats.isDirectory();
 stats.isSymbolicLink();
});
File operations
fs.rename('old.txt', 'new.txt', function(){});
fs.chown('file.txt', uid, gid, function(){});
fs.symlink('src', 'dest', function(){});
fs.unlink('path', function(){});
fs.rmdir('path', function(){});
fs.readdir('path', function(err, files) { .. }); /* `files` = array of names */
Path
fs.realpath('/etc/passwd', function(err, path) { /* "/private/etc/passwd" */ });
Sync
data = fs.readFileSync('input.txt');
fs.writeFileSync('output.txt', data);
fs.appendFileSync('output.txt', data);
fs.existsSync('file.txt');
Explanation 2 :
Reading File synchronously vs asynchronously
Every method in fs module have synchronous as well as asynchronous form. Asynchronous methods takes a last parameter as completion function callback and first parameter of the callback function is error. It is preferred to use asynchronous method instead of synchronous method as former never block the program execution where as the second one does. ( fs modülündeki tüm method'ların hem synchronous hem de asnchronous çalışan formları vardır. Asenkron çalışan method'ların aldığı son parametre callback fonksiyonudur. Callback fonksiyonu ne zaman çalışır? İlgili asenkron method'un çalışması bitince. Senkron method'un değil de asenkron method'un çalışması tercih edilmelidir. Çünkü asenkron çalışan method, programın çalışmasını asla durdurmaz, bloke etmez. Senkron çalışan method ise programın akışını durdurur, kodun ilerleyebilmesi için senkron çalışan fonksiyonun tamamlanması beklenir. )
Example
Aşağıdaki içeriğe sahip olan bir input.txt dosyası yaratalım:
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Aşağıdaki içeriğe sahip olan bir main.js dosyası yaratalım:
var fs = require("fs");
// input.txt dosyasını asenkron bir şekilde okur.
fs.readFile('input.txt', function (err, data) {
  if (err) {
      return console.error(err);
  }
  console.log("Asynchronous read: " + data.toString());
});
// input.txt dosyasını senkron bir şekilde okur.
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());
console.log("Program Ended");
main.js dosyasını şu komutla çalıştıralım:
$ node main.js
Output :
Synchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended
Asynchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Output'a dikkat edelim. Kodda önce asenkron sonra senkron readFile method'unu çağırdık ancak, dosyayı önce senkron readFileSync() method'u okudu, sonra asenkron readFile() method'u okudu.
Open a File
Bir dosyayı asenkron modda açmak için fs.open() method'u kullanılır :
fs.open(path, flags[, mode], callback)

Parameters
fs.open method'unun parametreleri :
  • path - Açmak istediğimiz dosyanın path'. Relative veya absolute path olabilir.
  • flags - Açılacak dosyanın behaviour'ını belirler.
  • mode - This sets the file mode (permission and sticky bits), but only if the file was created. It defaults to 0666, readable and writeable. ( Dosyanın readable writable vs. olması gibi permission'ları belirler. Default mode ise dosyanın readable ve writable olmasıdır. )
  • callback - This is the callback function which gets two arguments (err, fd). (Dosya açma işlemi başarılı veya başarısız bir şekilde tamamlandığında callback fonksiyonu çağırılır.)
Flags
Flags for read/write operations are:
Flag
Description
r
Dosyayı asenkron modda, readable olarak açar. An exception occurs if the file does not exist.
r+
Dosyayı asenkron modda, readable ve writable olarak açar. An exception occurs if the file does not exist.
rs
Dosyayı senkron modda, readable olarak açar.
rs+
Dosyayı senkron modda, readable ve writable olarak açar.
w
Open file for writing. The file is created (if it does not exist) or truncated (if it exists). (Dosyayı asenkron modda, writable olarak açar. Eğer böyle bir dosya yoksa yaratılır, varsa truncate edilir yani replace edilir.)
wx
Like 'w' but fails if path exists. ( w moduna benzer ancak sıfırdan bir dosya yaratmak için kullanılır. Varolan bir dosya için kullanılırsa fs.open fail eder. )
w+
Open file for reading and writing. The file is created (if it does not exist) or truncated (if it exists). (Dosyayı asenkron modda, readable ve writable olarak açar. Eğer böyle bir dosya yoksa yaratılır, varsa truncate edilir yani replace edilir.)
wx+
Like 'w+' but fails if path exists. ( w+ moduna benzer ancak sıfırdan bir dosya yaratmak için kullanılır. Varolan bir dosya için kullanılırsa fs.open fail eder. )
a
Open file for appending. The file is created if it does not exist. ( Dosyaya appendable modda asenkron olarak açar. Eğer böyle bir dosya yoksa yaratılır.)
ax
Like 'a' but fails if path exists. (append moda benzer ancak sıfırdan bir dosya yaratmak için kullanılır. Varolan bir dosya için kullanılırsa fs.open fail eder.)
a+
Open file for reading and appending. The file is created if it does not exist.
ax+
Like 'a+' but fails if path exists.

Example
Let us create a js file named main.js having the following code to open a file input.txt for reading and writing.
var fs = require("fs");
// Dosya asenkron modda, readable ve writable olarak açılır(r+)
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
  if (err) {
      return console.error(err);
  }
 console.log("File opened successfully!");     
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to open file!
File opened successfully!

Get File information
Bir dosya ile ilgili bilgi almak için fs.stat() method'u kullanılır :
fs.stat(path, callback)
Parameters
Here is the description of the parameters used:
  • path - Dosyanın relative veya absolute path'i.
  • callback - This is the callback function which gets two arguments (err, stats) where stats is an object of fs.Stats type which is printed below in the example. (fs.stat() method'unu aldığı 2.parametre bir callback fonksiyonudur. Bu callback fonksiyonunun aldığı 2. parametre fs.Stats class'ının bir instance'ıdır.)
Apart from the important attributes which are printed below in the example, there are number of useful methods available in fs.Stats class which can be used to check file type. These methods are given in the following table.
Method
Description
stats.isFile()
Returns true if file is a simple file.
stats.isDirectory()
Returns true if file type of a directory.
stats.isBlockDevice()
Returns true if file type of a block device.
stats.isCharacterDevice()
Returns true if file type of a character device.
stats.isSymbolicLink()
Returns true if file type of a symbolic link.
stats.isFIFO()
Returns true if file type of a FIFO.
stats.isSocket()
Returns true if file type of asocket.

Example
Let us create a js file named main.js having the following code (Bu örnekte input.txt dosyası basit bir file dosyası mı yoksa bir klasör mü diye bakacağız):
var fs = require("fs");
console.log("Going to get file info!");
fs.stat('input.txt', function (err, stats) {
  if (err) {
      return console.error(err);
  }
  console.log(stats);
  console.log("Got file info successfully!");
  
  // Check file type
  console.log("isFile ? " + stats.isFile());
  console.log("isDirectory ? " + stats.isDirectory());    
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to get file info!
{ dev: 1792,
 mode: 33188,
 nlink: 1,
 uid: 48,
 gid: 48,
 rdev: 0,
 blksize: 4096,
 ino: 4318127,
 size: 97,
 blocks: 8,
 atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),
 mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),
 ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT) }
Got file info successfully!
isFile ? true
isDirectory ? false

Writing File
Bir dosyaya yazmak için fs.writeFile() veya fs.writeFileSync() method'unu kullanırız :
fs.writeFile(filename, data[, options], callback)
This method will over-write the file if file already exists. If you want to write into an existing file then you should use another method available. ( Bu method sıfırdan bir dosya yaratıp bu dosyaya yazmak için kullanılır. Yani bu method'u çağırdığımızda hem dosya yaratır hem de dosyaya yazarız. Eğer varolan bir dosyaya bu method'u kullanarak yazmaya çalışırsak, varolan dosyayı overwrite etmiş oluruz. Varolan bir dosyaya bir şeyler yazmak için başka method'lar kullanılmalıdır. )
Parameters
Here is the description of the parameters used:
  • path - Dosyanın path'i.
  • data - Dosyaya yazılacak String veya Buffer.
  • options - The third parameter is an object which will hold {encoding, mode, flag}. By default encoding is utf8, mode is octal value 0666 and flag is 'w' .
  • callback - This is the callback function which gets a single parameter err and used to to return error in case of any writing error. (writeFile() method'unun aldığı callback fonksiyonun sadece bir tane parametre alır o da err'dır. )
Example ( 5-fs.writeFile().js )
Let us create a js file named main.js having the following code: (Bu kodda önce varolan bir dosya olan input.txt dosyasına 'Simply Easy Learning' yazıyoruz. Sonra bu dosyanın içeriğini okuyup ekrana yazıyoruz.)
var fs = require("fs");
console.log("Going to write into existing file");
fs.writeFile('input.txt', 'Simply Easy Learning!',  function(err) {
  if (err) {
      return console.error(err);
  }
  console.log("Data written successfully!");
  console.log("Let's read newly written data");
  fs.readFile('input.txt', function (err, data) {
     if (err) {
        return console.error(err);
     }
     console.log("Asynchronous read: " + data.toString());
  });
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to write into existing file
Data written successfully!
Let's read newly written data
Asynchronous read: Simply Easy Learning!

Reading File
Bir dosyadan veri okuyabilmek için kullanabileceğimiz method'larından biri fs.read() method'udur :
fs.read(fd, buffer, offset, length, position, callback)
This method will use file descriptor to read the file, if you want to read file using file name directly then you should use another method available. ( Bu method, file descriptor'ı kullanarak bir dosya okumak için kullanılır. Dosyayı açmak için kullandığımız fs.open() method'u bir file descriptor return eder. Bu file descriptor'ı ve fs.read() method'unu kullanarak dosya okuruz. Eğer bir dosyayı dosya ismini kullanarak okumak istiyorsak, fs.readFile() method'unu kullanmalıyız. )
Parameters
fs.read() method'unun aldığı parametreleri inceleyelim:
  • fd - This is the file descriptor returned by file fs.open() method. (okumak istediğimiz dosyaya karşılık gelen file descriptor)
  • buffer - This is the buffer that the data will be written to. ( Dosyadan okunan veriler bu buffer'a yazılır  )
  • offset - This is the offset in the buffer to start writing at. ( Buffer'ın kaçıncı index'inden itibaren yazmaya başlanılacağını söyler. )
  • length - This is an integer specifying the number of bytes to read. ( Dosyadan kaç byte okumak istediğimizi belirtiriz. )
  • position - This is an integer specifying where to begin reading from in the file. If position is null, data will be read from the current file position. ( Dosyanın neresinden, kaçıncı byte'ından okumak istediğimizi belirtiriz. Position parametresine null verirsek, dosyadaki  current position'dan yani cursor'ın bulunduğu pozisyondan veri okunmaya başlanır. )
  • callback - This is the callback function which gets the three arguments, (err, bytesRead, buffer). ( Dosyanun okuma işlemi tamamlandığında callback fonksiyonu çalıştırılır, callback fonksiyonunun aldığı 2. parametre dosyadan okunan veri sayısını, 3.parametre ise dosyadan okunan veriyi temsil eder.  )
Example (6-fs.read().js )
Let us create a js file named main.js having the following code:
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
  if (err) {
      return console.error(err);
  }
  console.log("File opened successfully!");
  console.log("Going to read the file");
  fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
     if (err){
        console.log(err);
     }
     console.log(bytes + " bytes read");
     
     // Print only read bytes to avoid junk.
     if(bytes > 0){
        console.log(buf.slice(0, bytes).toString());
     }
  });
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to open an existing file
File opened successfully!
Going to read the file
97 bytes read
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Closing File
Following is the syntax of one of the methods to close an opened file: (fs.open() method'unu kullanarak açtığımız bir dosyayı fs.close() method'unu kullanarak kapatmalıyız)
fs.close(fd, callback)
Parameters
fs.close() method'unun aldığı parametreleri inceleyelim:
  • fd - This is the file descriptor returned by file fs.open() method. (fs.open() method'unun return ettiği file descriptor'dır.)
  • callback - This is the callback function which gets no arguments other than a possible exception are given to the completion callback.(fs.close() method'u başarılı veya başarısız bir şekilde tamamlandıktan sonra callback fonksiyonu çalışır. callback fonksiyonu sadece err isimli bir parametre alır, dosya kapatma işlemi başarılı bir şekilde gerçekleştirilmişse err isimli parametre null olur.)
Example
Let us create a js file named main.js having the following code: ( Bu örnekte, input.txt dosyası önce açılmış, sonra okunmuş, sonra ise kapatılmıştır. fs.open() method'unun callback fonksiyonu içerisinde fs.read() method'unun ve fs.read() method'unun callback fonksiyonunun içerisinde fs.close() method'unu çağırıldığına dikkat edelim. )
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
  if (err) {
      return console.error(err);
  }
  console.log("File opened successfully!");
  console.log("Going to read the file");
  fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
     if (err){
        console.log(err);
     }
     // Print only read bytes to avoid junk.
     if(bytes > 0){
        console.log(buf.slice(0, bytes).toString());
     }
     // Close the opened file.
     fs.close(fd, function(err){
        if (err){
           console.log(err);
        }
        console.log("File closed successfully.");
     });
  });
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to open an existing file
File opened successfully!
Going to read the file
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
File closed successfully.

Truncate File
Following is the syntax of the method to truncate an opened file:
fs.ftruncate(fd, len, callback)
Parameters
Here is the description of the parameters used:
  • fd - This is the file descriptor returned by file fs.open() method.
  • len - This is the length of the file after which file will be truncated. (Dosyanın truncate işleminden sonra kaç karakter(kaç byte) içereceğini gösterir. Bu parametreye 10 dedik diyelim mesela, bu durumda dosyadaki en baştaki 10 karakterlik kısım tutulur, geri kalan kısım silinir.  )
  • callback - This is the callback function which gets no arguments other than a possible exception are given to the completion callback. (Truncate işlemi tamamlandıktan sonra bu callback fonksiyonu çalıştırılır. )
Example(HelloNode16_file_module/8-fs.truncate().js )
Let us create a js file named main.js having the following code:
var fs = require("fs");
var buf = new Buffer(1024);
console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
  if (err) {
      return console.error(err);
  }
  console.log("File opened successfully!");
  console.log("Going to truncate the file after 10 bytes");
  
  // Truncate the opened file.
  fs.ftruncate(fd, 10, function(err){
     if (err){
        console.log(err);
     }
     console.log("File truncated successfully.");
     console.log("Going to read the same file");
     fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
        if (err){
           console.log(err);
        }
        // Print only read bytes to avoid junk.
        if(bytes > 0){
           console.log(buf.slice(0, bytes).toString());
        }
        // Close the opened file.
        fs.close(fd, function(err){
           if (err){
              console.log(err);
           }
           console.log("File closed successfully.");
        });
     });
  });
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to open an existing file
File opened successfully!
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
Tutorials
File closed successfully.

Delete File
Following is the syntax of the method to delete a file. ( Bu method'u bir dosyayı silmek için kullanırız ):
fs.unlink(path, callback)
Parameters
Here is the description of the parameters used:
  • path - This is the file name including path.( Silinecek dosyanın path'i. )
  • callback - This is the callback function which gets no arguments other than a possible exception are given to the completion callback. (Dosya silme işlemi başarılı/başarısız tamamlandıktan sonra bu callback fonksiyonu çalıştırılır. )
Example
Let us create a js file named main.js having the following code: (Aşağıdaki kod, current directory'deki input.txt dosyasını siler. )
var fs = require("fs");
console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
  if (err) {
      return console.error(err);
  }
  console.log("File deleted successfully!");
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to delete an existing file
File deleted successfully!

Create Directory
Bir directory(klasör) yaratmak için fs.mkdir() method'unu kullanırız :
fs.mkdir(path[, mode], callback)
Parameters
fs.mkdir() method'unun parametreleri :
  • path - This is the directory name including path. (Yaratılacak directory'nin path'i. )
  • mode - This is the directory permission to be set. Defaults to 0777. (Directory'ye erişim izinlerini ayarlamak için.)
  • callback - This is the callback function which gets no arguments other than a possible exception are given to the completion callback. (Directory yaratma işlemi başarılı/başarısız tamamlandıktan sonra bu callback fonksiyonu çalıştırılır. )
Example
Let us create a js file named main.js having the following code (Aşağıdaki kod current, absolute path /tmp 'de test isimli bir directory yaratır. Eğer absolute path /tmp diye bir directory yoksa error olur. mkdir() method'una 1.parametre olarak '/test' verirsek, current directory'de test diye bir directory(folder) yaratılır. ) :
var fs = require("fs");
console.log("Going to create directory /tmp/test");
fs.mkdir('/tmp/test',function(err){
  if (err) {
      return console.error(err);
  }
  console.log("Directory created successfully!");
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to create directory /tmp/test
Directory created successfully!

Read Directory
Bir directory'yi read etmek(okumak) için bu method kullanılır :
fs.readdir(path, callback)
Parameters
fs.readdir() method'un aldığı parametreleri inceleyelim :
  • path - This is the directory name including path.(read edilecek directory'nin path'i.)
  • callback - This is the callback function which gets two arguments (err, files) where files is an array of the names of the files in the directory excluding '.' and '..'. ( Directory read edilme işlemi tamamlandıktan sonra bu callback fonksiyonu çağırılır. Callback fonksiyonunun 2.parametresi, directory'deki tüm dosyaların isimlerini içeren bir array'dir. )
Example
Aşağıdaki kod, root directory'deki tüm dosyaların ve klasörlerin isimlerini console'a yazdırır. Bu kodda readdir method'u çağırılır, root directory'deki tüm dosya ve directory'lerin isimlerini içeren bir array, readdir method'unun aldığı callback fonksiyonunun 2.parametresi olan files'a atanır. Bu örnekte foreach'i nasıl kullandığımıza dikkat et. array.foreach(some_function) deyince, array'deki herbir eleman için some_function() fonksiyonu çağırılır, some_function fonksiyonu 3 tane parametre alabilir, sırasıyla : content, index, array'in kendisi. Örnek foreach kullanımı için js tutorial ( js/1-array.foreach(somefunction).html)' ımıza bak.
var fs = require("fs");
console.log("Going to read directory /tmp");
fs.readdir("/",function(err, files){
  if (err) {
      return console.error(err);
  }
  files.forEach( function (file){
      console.log( file );
  });
});
Now run the main.js to see the result:
$ node main.js
Verify the Output
Going to read directory /tmp
$Recycle.Bin
appname
Boot
bootmgr
BOOTSECT.BAK
Documents and Settings
DRIVERS
EFI
HaxLogs.txt
hiberfil.sys
INSTALL.LOG
Intel
jython2.7.0
lai.exe
MinGW
msdia80.dll
MSOCache
notes
Notes_Preferences_Backup
oraclexe
osp.ini
pagefile.sys
PerfLogs
pgpsync.log
PGPWDE00
PGPWDE01
PGPWDE02
pnp
pnp64.xml
Program Files
Program Files (x86)
ProgramData
Programs
Recovery
sdwork
servers.ini
setup.log
setupisam.log
SUService.log
swd
System Volume Information
temp
test2
Users
w764drive
Windows

Remove Directory
Bir directory(klasör)'yi silmek için fs.rmdir() method'u kullanılır.
fs.rmdir(path, callback)
Parameters
fs.rmdir() method'unun aldığı parametreleri inceleyelim:
  • path - This is the directory name including path. ( Silmek istediğimiz directory(klasör)'nin path'i. )
  • callback - This is the callback function which gets no arguments other than a possible exception are given to the completion callback. (Directory'yi silme işlemi başarılı/başarısız tamamlanınca bu callback fonksiyonu çağırılır.)
Example
Aşağıdaki kod, root directory'deki tmp directory(klasör)'sindeki test klasörünü klasör. Sonra root directory'deki tmp directory'si read edilir yani içerdiği tüm dosya ve klasör isimleri ekrana yazdırılır, böylece tmp klasörünün içerisinde artı test diye bir klasör olmadığını görürüz. For foreach reference, refer to : js/1-array.foreach(somefunction).html
var fs = require("fs");
console.log("Going to delete directory /tmp/test");
fs.rmdir("/tmp/test",function(err){
  if (err) {
      return console.error(err);
  }
  console.log("Going to read directory /tmp");
  fs.readdir("/tmp/",function(err, files){
     if (err) {
         return console.error(err);
     }
     files.forEach( function (file){
         console.log( file );
     });
  });
});

28 - fs.watchFile() & fs.watch() (HelloNode9_fs.watchFile())

https://nodejs.org/docs/latest/api/fs.html#fs_fs_watch_filename_options_listener
Explanation 1 :
  • fs.watch() watches(polls) a file or a directory. 
  • fs.watchFile() watches(polls) a file.
fs.watch():
  • is newer API and recommended.
  • uses native watching functions supported by OS, so doesn't waste CPU on waiting.
  • doesn't support all platforms such as AIX and Cygwin.
fs.watchFile():
  • is old API and not recommended.
  • calls stat periodically, so uses CPU even when nothing changes.
  • runs on any platforms.
How to monitor a file for modifications in Node.js
Bir dosyada değişiklik meydana gelip gelmediğini belirli aralıklarla check etmek için fs.watch() veya fs.watchFile() method'larından birini kullanabiliriz.
Bir directory'de değişiklik meydana gelip gelmediğini belirli aralıklarla check etmek için ise sadece fs.watch() method'unu kullanabiliriz.

 fs.watchFile(filename, [options], cfunction) - It watches the changes on file. The callback cfunction will be called each time the file is accessed.  If true, persistent prevents the program from terminating. The final argument is a callback which is triggered when the target file is modified.  The callback passes in the type of event (change, rename, etc.) and the name of the file. It is worth noting that watch() is dependent on the underlying OS, and might not work on every system. If watch() is unavailable, the slower watchFile() can be used as a backup.


Example : (HelloNode17_fs.watch()_fs.watchFile() \ 2-fs.watchFile().js) Current directory'deki 1-todos.txt dosyası monitor edilmektedir. Bu dosyanın içeriğini değiştirip programın output'unu inceleyelim.

var fs = require('fs');
var file = fs.readFileSync('1-todos.txt');
console.log('Initial File content : ' + file);
fs.watchFile('1-todos.txt', function() {
   console.log('File is changed... The new content of the file is : ');
   file = fs.readFileSync('1-todos.txt');
   console.log('File content at : ' + new Date() + ' is \n' + file);
});

Note : fs.watchFile() is deprecated. Use fs.watch() instead.


fs.watch(filename, [options], [cfunction]) - Like fs.watchFile it also watches the change on file. It has a return object which will return an object of fs.FSWatcher. Options are optional where you have two values to set persistent and recursive. Persistent indicates that the process should continue as long as the files are watched and recursive indicates whether only current directory should be watched or all sub-directories to be watched. The default value of persistent is true and recursive is false. The callback cfunction is also optional, if it is there it will take two arguments event and filename. Event is either 'rename' or 'change' whereas filename is the name of the file. ( fs.watchFile() method'unu kullanarak, hem dosya hem de directory 'nin içeriği değişmiş mi diye check edebiliriz. Options parametresi optional'dır, bu parametre ile persistent and recursive'i set edebiliriz. Recursive true ise, directory'nin tüm subdirectory'leri izlenir. Callback fonksiyonu da optional'dır, 2 tane parametre alır, 1.parametre event'dir : change veya rename olabilir. )
Watch for changes on filename, where filename is either a file or a directory. The returned object is a fs.FSWatcher.
The second argument is optional. If options is provided as a string, it specifies the encoding. Otherwise options should be passed as an object.
The listener callback gets two arguments (event, filename). event is either 'rename' or 'change', and filename is the name of the file which triggered the event.

Example : (HelloNode17_fs.watch()_fs.watchFile() \ 1-fs.watch().js )

const fs = require('fs');
fs.watch('1-todos.txt', function(event,filename) {
console.log("File  has just changed");
console.log("event : " + event);
console.log("filename : " + filename);
var file = fs.readFileSync('1-todos.txt');
   console.log('File content at : ' + new Date() + ' is \n' + file);
});
console.log("Now watching todos.txt");
Output:
C:\Users\IBM_ADMIN\Desktop\tutorials rad started on may 2016\Web development\Node.js\HelloNode17_fs.watch()_fs.watchFile()>node "1-fs.watch().js"
Now watching todos.txt
File  has just changed
event : change
filename : 1-todos.txt
File content at : Tue Jul 12 2016 12:07:24 GMT+0300 (GTB Daylight Time) is
Hello Omer !
File  has just changed
event : change
filename : 1-todos.txt
File content at : Tue Jul 12 2016 12:07:24 GMT+0300 (GTB Daylight Time) is
Hello Omer !

29 - Streams, data event, end event etc.

http://www.tutorialspoint.com/nodejs/nodejs_streams.htm
https://www.sitepoint.com/basics-node-js-streams/
https://github.com/substack/stream-handbook
https://millermedeiros.github.io/mdoc/examples/node_api/doc/streams.html
http://maxogden.com/node-streams.html
https://nodejs.org/api/stream.html#stream_event_data
Simply put, a stream is nothing but an EventEmitter and implements some specials methods. Depending on the methods implemented, a stream becomes Readable, Writable, or Duplex (both readable and writable). Readable streams let you read data from a source while writable streams let you write data to a destination. ( Kabaca stream, bir EventEmitter object'dir, event dinler. )
For example, in a Node.js based HTTP server, request is a readable stream and response is a writable stream. You might have used fs module which lets you work with both readable and writable file streams. ( HTTP server tanımlarken kullandığımız örneklerdeki request readable bir stream'dir sadece okunabilir, response ise writable bir stream'dir sadece yazılabilir. )
Streams are objects that let you read data from a source or write data to a destination in continous fashion.(Stream'ler, bir kaynaktan veri okumak için veya  bir destination'a veri yazmak için kullanılan object'lerdir. Veri okuma ve yazma anlık tek seferlik değildir, continuous bir şekilde devam eder, ilgili event'leri dinler, event'ler gerçekleştikçe okuma ve yazma tekrar tekrar gerçekleşir. ) In Node.js, there are four types of streams.
  • Readable - Stream which is used for read operation.
  • Writable - Stream which is used for write operation.
  • Duplex - Stream which can be used for both read and write operation.
  • Transform - A type of duplex stream where the output is computed based on input.
Bir stream ya Readable'dır, ya Writable'dır, ya da hem Readable hem Writable(Duplex)'dır. Readable stream'leri kullanarak bir kaynaktan veri okuruz, Writable stream'leri kullarak bir destination'a veri yazarız. Duplex stream'leri kullanarak bir kaynağı hem okuyabilir hem de bu kaynağa yazabiliriz. Transfor stream ise duplex stream'in bir çeşididir, output input'a göre hesaplanır.  )

Tüm stream çeşitleri EventEmitter object'lerdir ve aşağıdaki event'leri throw ederler :
  • data - This event is fired when there is  data available to read. (Okuyacak veri varsa data event fırlatılır, throw edilir, fire edilir. )
  • end - This event is fired when there is no more data to read.  (Okuyacak veri kalmayınca bu event fire edilir. )
  • error - This event is fired when there is any error receiving or writing data. (Veri alırken veya veri yazarken bir hata olunca bu event fırlatılır.)
  • finish - This event is fired when all data has been flushed to underlying system. (Tüm veri sistem'e commit edileceği zaman bu event çağırılır. )
Readable Stream
A readable stream lets you read data from a source. The source can be anything. It can be a simple file on your file system, a buffer in memory or even another stream. As streams are EventEmitters, they emit several events at various points. We will use these events to work with the streams. ( Readable stream'leri kullanarak bir dosyadan, memory'deki bir buffer'dan veya başka bir stream'den veri okuyabiliriz. Stream'ler EventEmitter oldukları için, çeşitli event'ler emit edebilirler. Stream'lerle çalışırken bu event'leri kullanacağız. )
Ex : Readable stream which reads from a file
The best way to read data from a stream is to listen to data event and attach a callback. When a chunk of data is available, the readable stream emits a data event and your callback executes. The function call fs.createReadStream() gives you a readable stream. Initially, the stream is in a static state. As soon as you listen to data event and attach a callback it starts flowing. After that, chunks of data are read and passed to your callback. ( fs.createReadStream() method'unu çağırarak bir Readable stream yarattıktan sonra bu readeable stream'i okumak için data event'i dinlemeliyiz ve bu event'e bir callback fonksiyonu attach etmeliyiz. Stream'i ilk yarattığımızda stream static state'dedir, ancak data event'i dinlemeye başladığımız andan itibaren ilgili callback fonksiyonu çağırılarak stream okunmaya başlanır. )
The stream implementor decides how often data event is emitted. For example, an HTTP request may emit a data event once a few KB of data are read. When you are reading data from a file you may decide you emit data event once a line is read.
When there is no more data to read (end is reached), the stream emits an end event. In the below code, we listen to this event to get notified when the end is reached. ( Dosyanın sonuna gelindiğinde, artık okunacak veri kalmamıştır dolayısıyla end event emit edilir(fire edilir). )
input.txt isimli bir dosya yaratalım, içeriği şöyle olsun:
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
main.js isimli bir dosya yaratalım, içeriği şöyle olsun :
var fs = require("fs");
var data = '';
// Bir readable stream yaratalım. input.txt dosyasından veri okuyacak bir readable stream yarattık.
var readerStream = fs.createReadStream('input.txt');
// Encoding'i UTF8 olarak set edelim.
readerStream.setEncoding('UTF8');
// Stream event'leri handle edelim --> data, end, and error
// okunacak veri olduğu müddetçe belirtilen callback fonksiyonu çağırılır.
readerStream.on('data', function(chunk) {
  data += chunk;
});
// okunacak veri kalmayınca belirtilen callback fonksiyonu çağırılır.
readerStream.on('end',function(){
  console.log(data);
});
// veri okurken bir hata olursa belirtilen callback fonksiyonu çağırılır.
readerStream.on('error', function(err){
  console.log(err.stack);
});
console.log("Program Ended");
main.js dosyasını çalıştıralım:
$ node main.js
Output :
Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Alternative way of reading from stream
There is also another way to read from stream. readable event is emitted when a chunk of data can be read from the stream. You just need to call read() on the stream instance repeatedly until every chunk of data has been read. ( Readable bir stream'den veri okumanın başka bir yolu daha vardır. createReadStream() method'u çağırılarak bir readable stream yaratılır, data event yerine readable event dinlenir. Stream'den okunacak veri varsa, data event yerine readable event emit edilir. )
The read() function reads some data from the internal buffer and returns it. When there is nothing to read, it returns null. So, in the while loop we check for null and terminate the loop. ( Aşağıdaki kodda while döngüsünde read() method'unu çağırıyoruz, stream'in sonuna gelene kadar stream'deki tüm veriyi okumaya devam ediyoruz bu döngüde. Stream'de okunacak bir şey kalmadığında read() method'u null return eder, dolayısıyla döngüde read() method'unun null return edip etmediğini check ederiz. )
var fs = require('fs');
var readableStream = fs.createReadStream('file.txt');
var data = '';
var chunk;
readableStream.on('readable', function() {
   while ((chunk=readableStream.read()) != null) {
       data += chunk;
   }
});
readableStream.on('end', function() {
   console.log(data)
});
Setting Encoding
By default the data you read from a stream is a Buffer object. If you are reading strings this may not be suitable for you. So, you can set encoding on the stream by calling Readable.setEncoding(). In the below example, we set the encoding to utf8. As a result, the data is interpreted as utf8 and passed to your callback as string. (Stream'den okuduğumuz veri default olarak bir Buffer object'dir. Eğer string olarak okumak istiyorsak, encoding'i Readable.setEncoding() method'unu çağırarak utf8'e set etmeliyiz. Böylece stream'den okunan veri aratık string'dir, yani callback fonksiyona verilen argument string'dir. )
var fs = require('fs');
var readableStream = fs.createReadStream('file.txt');
var data = '';
readableStream.setEncoding('utf8');
readableStream.on('data', function(chunk) {
   data+=chunk;
});
readableStream.on('end', function() {
   console.log(data);
});
Piping
Example:
var fs = require('fs');
var readableStream = fs.createReadStream('file1.txt');
var writableStream = fs.createWriteStream('file2.txt');
readableStream.pipe(writableStream);
You should also note that pipe() returns the destination stream. So, you can easily utilize this to chain multiple streams together. Let’s see how! (Yukarıdaki kod, file1 dosyasını okuyup file2 dosyasına yazar. Pipe() method'u destination stream'i yani yazılan dosyayı yani file2'yi return eder.)
Piping is a mechanism where we provide output of one stream as the input to another stream. It is normally used to get data from one stream and to pass output of that stream to another stream. There is no limit on piping operations. Now we'll show a piping example for reading from one file and writing it to another file.( Bir readable stream'i input olarak alıp writable bir stream'in output'una bağlamaya piping denir. Piping işlemlerinde sınır yoktur, istediğimiz kadar piping yapabiliriz. Aşağıdaki örnekte, readable ve writanle stream yaratılmış, readable stream'in içeriği writable stream'e kopyalanmıştır.)
Example(main.js):
var fs = require("fs");
// Create a readable stream
var readerStream = fs.createReadStream('input.txt');
// Create a writable stream
var writerStream = fs.createWriteStream('output.txt');
// Pipe the read and write operations
// read input.txt and write data to output.txt
readerStream.pipe(writerStream);
console.log("Program Ended");
Now run the main.js to see the result:
$ node main.js
Verify the Output
Program Ended
Bu kodu çalıştırınca output.txt, input.txt'nin içeriğini içercektir.
Tutorials Point is giving self learning content


to teach the world in simple and easy way!!!!!
Gönderen zaman:

Hiç yorum yok:

Yorum Gönder

Kaydol: Kayıt Yorumları (Atom)