chapter14. 비동기적 프로그래밍

// ## 14.2 콜백
console.log("before setTimeout " + new Date());
function f(){
    console.log("After setTimeout "+ new Date());
}
setTimeout(f, 60 *1000); // 1분 
console.log("i happen after setTimeout");
console.log("me too");
/*
before setTimeout Thu Aug 01 2019 21:10:46 GMT+0900 (GMT+09:00)
i happen after setTimeout
me too
After setTimeout Thu Aug 01 2019 21:11:46 GMT+0900 (GMT+09:00)
*/

setTimeout(function(){
    console.log("After TimeOut "+ new Date() ,6000);
});

//분이 넘어거거나 10회째가 될 때까지 5초마다 콜백 실행
const start = new Date();
let i =0;
const intervalId = setInterval(function(){
    let now = new Date();
    if(now.getMinutes() !== start.getMinutes() || ++i >10)
        return clearInterval(intervalId);
        console.log(`${i}:${now}`);
},5000);

/*
 1:Fri Aug 02 2019 13:59:47 GMT+0900 (한국 표준시)
 2:Fri Aug 02 2019 13:59:52 GMT+0900 (한국 표준시)
 3:Fri Aug 02 2019 13:59:57 GMT+0900 (한국 표준시)
*/

//5초 카운트 다운
function countdown(){
    let i; //i를 for 루프 밖에서 실행
    console.log("Countdown");
    for(i=5; i>=0; i--){
        setTimeout(function(){
            console.log(i===0 ? "Go":i)
        },(5-i)*1000);
    }
}
countdown();

//-1이 6번 나옴

//1. 즉시표현식
var count= function(i){
console.log("Countdown");
    for(let i=5; i>=0; i--){
        setTimeout(function(){
            console.log(i===0 ? "Go":i)
        },(5-i)*1000);
    }
}();

//2. for 루프 안에 let i 선언
function countdown(){
    //  let i; i를 for 루프 밖에서 실행
    console.log("Countdown");
    for(let i=5; i>=0; i--){
        setTimeout(function(){
            console.log(i===0 ? "Go":i)
        },(5-i)*1000);
    }
}
countdown();

//노드에서 파일 콘텐츠를 읽을 떄 우선 오류 콜백을 사용할 경우
const fs = require('fs');
const fname = 'may_or_may_not_exist.txt';
fs.readFile(fname, function(err,data){
    if(err) return console.error(`error reading file ${fname}:${err.message}`);
});

// 5초 카운트 다운에 매이지 않고, 카운트가 끝나면 프라미스를 반환
function countdown(seconds){
    return new Promise(function(resolve,reject){
        for(let i =seconds; i>=0; i--){
            setTimeout(function(){
                if(i>0) console.log(i + "...");
                else resolve(console.log("GO"));
            },(seconds-i)*1000);
        }
    });
}

/*
결과
5...
4...
3...
2...
1...
GO

만약 이 함수가 실패하면 "GO"를 반환
*/

//13을 만나면 에러를 내는 함수
function countdown(seconds){
    return new Promise(function(resolve,reject){
        for(let i =seconds; i>=0; i--){
            setTimeout(function(){
                if(i === 13) return reject(new Error("oh my god")); 
                if(i>0) console.log(i + "...");
                else resolve(console.log("GO"));
            },(seconds-i)*1000);
        }
    });
}
/*
15...
14...
Uncaught (in promise) Error: oh my god
12...
11...
10... 
9...

*/

//countdown 함수를 countdown 클래스로 변경
const EventEmitter = require('events').EventEmitter;
class Countdown extends EventEmitter{
    constructor(seconds,superstitious){
        super();
        this.seconds = seconds;
        this.superstitious = !!superstitious;
    }
    go(){
        const countdown = this;
        const timeoutIds = [];
        return new Promise(function(resolve,reject){
            for(let i = countdown.seconds; i>=0; i--){
               timeoutIds.push(setTimeout(function(){
                   if(countdown.superstitious && i ===13){
                        //대기중인 타임아웃을 모두 취소
                        timeoutIds.forEach(clearTimeout);
                        return reject(new Error('oh my god'));
                   }
                   countdown.emit('trick',i);
                   if(i === 0) resolve();
               },(countdown.seconds-i)*1000));
            }
        });
    }
}

//카운트다운 사용
const c = new Countdown(5);
c.on('trick',function(i){
    if(i>0) console.log(i+"...");
});
c.go().then(function(){
    console.log('go');
}).catch(function(err){
    console.log(err.message);
});

function launch(){
    return new Promise(function(resolve,reject){
        console.log("Lift off");
        setTimeout(function(){
            resolve("in orbit");
        },5*1000); //2초만에 궤도도달
    });
}
//이 함수를 카운트다운에 쉽게 묶을 수 있다.
const c = new Countdown(5).on('trick',i => console.log(i + "..."));

c.go().then(launch).then(function(msg){
    console.log(msg);
}).catch(function(err){
    console.error("houston, we have a problem...");
});

//파일 3개를 읽고 1분간 기다린 다음 그 내용을 합쳐서 네 번째 파일에 작성
//1. 노드의 콜백 오류를 프라미스로 바꾸기 
function nfcall(f,...args){
    return new Promise(function(resolve,reject){
        f.call(null,...args,function(err,...args){
            if(err) return reject(err);
            resolve(args.length<2 ? args[0]:args);
        });
    });
}

//2. setTimeout을 써야하는데, 이는 오류 우선 콜백 패턴을 따르지 않으므로 같은 기능을 가진 ptimeout(promise timeout) 함수를 만든다.

function ptimeout(delay){
    return new Promise(function(resolve,reject){
        setTimeout(resolve,delay);
    });
}


//3. 제너레이터 실행기
// 제너레이터는 동기적이지만, 호출자와 통신 가능하므로 제너레이터와의 통신을 관리하고, 비동기적 호출을 처리하는 함수 grun을 만듬 
function grun(g){
    const it = g();
    (function iterate(val){
        const x = it.next(val);
        if(!x.done){
            if(x.value instanceof Promise){
                x.value.then(iterate).catch(err => it.throw(err));
            }else{
                setTimeout(iterate,0,x.value);
            }
        }
    })();
}

//grun은 제너레이터 실행기이고, yield로 값을 넘긴 제너레이터는 이터레이터에서 next를 호출할 때까지 기다린다. 
function* theFutureIsNow(){
    const dataA = yield nfcall(fs,readFile, "a.txt");
    const dataB = yield nfcall(fs,readFile, "b.txt");
    const dataC = yield nfcall(fs,readFile, "c.txt");
    yield ptimeout(60*1000);
    yield nfcall(fs.writeFile,"d.txt",dataA + dataB + dataC);
}

grun(theFutureIsNow);

function* theFutureIsNow(){
    let data;
    try{
    data = yield Promise.all([
        nfcall(fs.readFile, "a.txt"),
        nfcall(fs.readFile, "b.txt"),
        nfcall(fs.readFile, "c.txt"),
    ]);
    }catch(err){
        console.error("unable to read.." + err.message);
        throw err;
    }
    yield ptimeout(60 * 1000);
    try{
       yield nfcall(js.writeFile, "d.txt", data[0] + data[1] + data[2]);
    } catch(err){
        console.err("unable to write output file"+ err.message);
        throw err;
    }
}

grun(theFutureIsNow);