[ Node.js in Action ] 3장 요약

3장에서는 아래와 같은 내용을 다룹니다.

 Organizing your code into modules
 Coding conventions
 Handling one-off events with callbacks
 Handling repeating events with event emitters
 Implementing serial and parallel flow control
 Leveraging flow-control tools

3.1 모듈을 이용한 코드 재사용 및 정리

PHP나 Ruby같은 언어에서 import하면 global scope에 영향을 미친다.

이런 것을 피하기 위해서 PHP는 namespaces를 사용하고, Ruby는 modules를 사용한다.

하지만 namespaces를 사용한다고 해도 overwrite의 가능성을 완전히 배제할 수는 없다.

Node에서는 이런 위험을 완전히 배제한다.

우선 Node의 module은 gloabl scope를 변경하지 않는다. 또한, module을 만들 때 개발자가 어떤 기능, 변수를 외부에서 사용가능 하게 할지 선택 할 수 있다. ( 이건 자바에서 접근제한자, public 또는 private,를 생각하면 된다. )

Node에서는 외부에 노출시키는 것을 export한다고 한다. ( public으로 만든다는 것을 의미함 )

export의 방법은 첫째, 둘 이상의 기능 및 변수를 export할 때에는 exports객체의 속성을 세팅해주면 된다. 둘째, 하나의 기능이나 변수만 export할 때에는 module.exports 속성을 이용한다.

3.1.1 모듈 생성하기

모듈은 a.하나의 파일이거나, b.디렉토리내에 하나 이상의 파일로 구성될 수 있다.

디렉토리 구조일 경우에는 디렉토리 내부에 index.js파일을 main파일로 사용한다. ( 이 파일 명은 overridden 가능하다. )

하나의 파일을 모듈로 만들 때에는 아래처럼 정의한다.

--------------- convert.js -------------

var num = 0.5;

exports.convertNum = function(myNum) {
     return Math.round(myNum / num);
}

----------------------------------------

위 코드를 보면 exports의 속성으로 convertNum 함수를 정의했다. 이는 외부에서 접근이 가능한 public 함수이다. 하지만 num 변수는 exports속성으로 정의하지 않았으므로 convert.js파일 내에서만 접근 가능한 private 변수이다.

이렇게 만들어진 모듈을 test-convert.js 파일에서 사용하려면 아래처럼 할 수 있다.

--------------- test-convert.js -------------

var convert = require('./convert');

console.log(convert.convertNum(5));

-----------------------------------------

여기서 require()에 명시한 "./convert"는 현재 디렉토리의 convert.js파일을 import한다는 의미이다. "./"를 붙이지 않으면 오류가 난다. require할 때 core module에 대해서는 상대경로를 사용하지 않고 바로 모듈명만 명시하도록 되어있는데 convert.js는 core module이 아니라 방금 우리가 만든 module이기 때문이다.

require()는 convert.js에 명시한 exports의 속성을 return한다. 따라서 var convert에는 convert.js(모듈)에서 정의한 exports 객체의 내용,즉, convertNum 함수가 할당되었다고 할 수 있다. 

3.1.2 module.exports 사용하기 ( single 변수, 함수, 객체 export 시 사용 ) 

module을 객체지향 관점에서 사용하고자 할 때에는 생성자 함수를 return하도록 한 뒤 아래처럼 사용할 수도 있을 것이다.

---------------- convert.js --------------

var Convert = function (num){

     this.num = num;

}

Convert.prototype.convertNum = function(myNum) {
     return Math.round(myNum / num);
}

// exports = Convert; ( 이렇게 사용 금지 )

module.exports = Convert; 

---------------------------------------

------------- test-convert2.js ------------

var Convert = require('./convert');

var num = 0.5

var convert = new Convert(num);

console.log(convert.convertNum(5));

---------------------------------------

위 코드에서 중요한 부분은 module.exports = Convert; 라인이다.

첫 예제에서 exports를 이용해서 property값을 설정함으로써 convert모듈에서 정의한 convertNum() 함수를 사용할 수 있었다. 이는 exports가 module.exports를 참조하는 global변수였기에 가능했다. 따라서 exports = Convert; 라고 해버리면 exports는 더이상 module.exports를 참조하는 변수가 아닌것이 된다. 

3.1.3 node_modules 디렉토리

앞에서 module을 require할 때 core module이 아니면 상대 경로를 적어주고, core module이면 그냥 이름을 써도 된다고 했다.

그러면 내부적으로 어떤 로직을 타길래 core module은 이름만 적어도 되는 걸까? Node가 module을 찾는 로직은 아래와 같다.

 

자, 그럼 내가 만든 모듈을 상대경로 지정을 하지 않고 쓰려면 어떻게 하면 될까?

그냥 node_modules 안에 넣어버리면 된다. 실제로 npm(Node Package Manager)를 이용하여 install을 하면 node_modules 디렉토리에 설치가 된다.

3.1.4 주의사항

첫번째 주의사항은 디렉토리 module 사용상 주의사항이다.

디렉토리 묶음으로 module을 만들었을 때에는 package.json에 명시하지 않는한 index.js파일이 존재해야한다.

아래 그림은 connect module을 설치했을 때 볼 수 있는 패키지 트리이다.

connect 디렉토리 안에 index.js라는 파일이 있는 것을 볼 수 있다. 

이제 이 파일명을 index.js 가 아닌 index_2.js 로 바꿔보자.

그리고 테스트 프로그램을 하나 만들어서 require('connect'); 한 줄만 입력해보고 실행해보자. 

그럼 오류가 날 것이다.

일반적으로 디렉토리 구조의 module에서는 index.js 라는 파일명을 사용하지만, 굳이 바꾸고 싶다면 package.json 파일에 명시해주면 된다.

package.json 파일을 열어서 "main" 을 찾아보자. 아마 없을 것이다. 아래처럼 main속성을 넣어보자.

{  // package.json 1번째 라인

"main":"index_2.js"

--생략--

} // package.json 마지막 라인

이제 다시 실행해보면 에러없이 실행되는 것을 확인할 수 있다. ( core module이니 파일명은 다시 index.js로 바꿔주자. Now~~ )

참고로 아래 그림은 directory 형태의 module을 require했을 때 처리되는 로직이다.

두 번째 주의사항은 "monkey patching"이다. 원숭이 패치? 이름이 참 희한하다.

monkey patching은 module을 객체로 caching하는 Node의 능력 때문에 가능한 것으로, 만약 애플리케이션에서 서로 다른 두 파일이 하나의 module을 require한다고 가정해보자. 이 때 동일한 module을 두 번 require했다고해서 module파일을 두 번 읽어들일 필요가 없도록 Node에서 캐시에 넣어둔다. 하지만, 이 두번 째 require에서 이 캐시에 들어있는 module정보를 변경(alter)할 수 있는 기회를 갖게 된다. 이렇게 변경하는 것을 monkey patching이라고 하는데, 이것을 잘 이용하면 module이 다른 module의 동작(behavior)를 수정할 수 있을 뿐 아니라 개발자가 다른 버전의 module을 만들 필요가 없도록 해준다. ( 이건 동적 BCI라고 이해했다. )

3.2 비동기식 프로그래밍 테크닉

3.2.1 Callback함수를 이용한 one-off 이벤트 핸들링

var fs = require('fs');
fs.readFile('./blah.txt', function(err, data) {
     if (err) { throw err };
     // do something
});

3.2.2 EventEmitter를 이용한 반복 이벤트 핸들링 

var net = require('net');
var server = net.createServer(function(socket) {
     socket.on('data', function(data) {
          socket.write(data);
     });
});
server.listen(8080);

1회성 이벤트 처리시 once 사용.

var net = require('net');
var server = net.createServer(function(socket) {
     socket.once ('data', function(data) {
          socket.write(data);
     });
});
server.listen(8080);

EventEmitter 확장하기

function Watcher(watchDir, processedDir) {
     this.watchDir = watchDir;
     this.processedDir = processedDir;
}

var events = require('events'), util = require('util');
util.inherits(Watcher, events.EventEmitter);     // == Watcher.prototype = new events.EventEmitter();

var fs = require('fs'), watchDir = './watch', processedDir = './done';
Watcher.prototype.watch = function() {
     var watcher = this;
     fs.readdir(this.watchDir, function(err, files) {
          if (err) throw err;
          for(var index in files) {
               watcher.emit('process', files[index]);
          }
     })
}
Watcher.prototype.start = function() {
     var watcher = this;
     fs.watchFile(watchDir, function() {
          watcher.watch();
     });
}

var watcher = new Watcher(watchDir, processedDir);

watcher.on('process', function process(file) {
     var watchFile = this.watchDir + '/' + file;
     var processedFile = this.processedDir + '/' + file.toLowerCase();
     fs.rename(watchFile, processedFile, function(err) {
          if (err) throw err;
     });
});

watcher.start();

3.2.3 비동기식 어플 개발시 주의할 점

동기식에서는 프로그램의 실행 순서가 명확하지만 비동기식에서는 실행 순서가 명확하지 않다. 

Node의 event loop는 비동기 로직이 완전히 완료되었는지 추적을 합니다. 아무리 비동기 로직이라도 완전히 끝나지 않았다면 프로세스는 종료되지 않습니다.

[ Javascript 의 Closure에 대한 개념 링크 ]

3.3 비동기식 로직을 순서대로 처리하기

Nimble 을 이용한 sequencing 처리

Nimble 이외에도 Step, Seq와 같은 module이 이미 존재함. 가져다 쓰면 됨.

[[궁금증 들.....]]

1. 의존성모듈 package.json 파일명을 다른걸로 바꿀 수 있나??

npmjs.com에서 말하는 npm에서 말하는 package라 함은 아래와 같습니다.

A package is any of:

• a) a folder containing a program described by a package.json file
• b) a gzipped tarball containing (a)
• c) a url that resolves to (b)
• d) a <name>@<version> that is published on the registry with (c)
• e) a <name>@<tag> that points to (d)
• f) a <name> that has a latest tag satisfying (e)
• g) a git url that, when cloned, results in (a).

또한 module이라 함은

• A folder with a package.json file containing a main field.
• A folder with an index.js file in it.
• A JavaScript file.

로 정의를 하고 있습니다. 

따라서, package.json 파일을 다른 파일명으로 사용한 다는 것은 불가능합니다.

출처 : https://docs.npmjs.com/how-npm-works/packages

2. 이벤트 루프 = 멀티쓰레드????, 비동기와 멀티쓰레드의 차이점??

이벤트 루프는 결국 멀티쓰레드, 폴링과 같은 기술을 사용하는 것이라는 결론입니다. 

아래는 참조할 만한 링크들입니다.

http://jeremyko.blogspot.kr/2012/12/nodejs-thread-poollibuv.html    ( 한글 블로그 )

http://nikhilm.github.io/uvbook/basics.html#event-loops

http://stackoverflow.com/questions/21485920/single-threaded-event-loop-vs-multi-threaded-non-blocking-worker-in-node-js

3. monkey patching - 왜 첫 번째 require할 때 수정가능X ?

이건 사실 질문 자체가 잘못되었던 것 같다. monkey patching에 대해서는 아래 링크에 설명이 나와있다.

http://fredkschott.com/post/2014/09/nodejs-dangerous-module-design-patterns/

결국 monkey patching 이라는 것은 기존에 있던 것을 overwrite한다는 것인데 require를 처음 할 때에는 overwrite할 게 없으니까 동일한 모듈을 다른 파일에서 또 require 할 때에 수정할 수 있는 기회를 준다고 책에서 설명을 한 것 같다. 이 "원숭이 패치"에 대해서는 책에서 자세하게 설명을 안하고 있는데 위 링크에서 설명하는 것을 보면 그 위험성 때문에 그런게 아닌가 싶다. 가독성도 떨어질 것 같고..