{
"name": "nodejs",
"version": "1.0.0",
"description": "",
"main": "app.js",
"type": "module", //자바스크립트 자체적으로 쓰는 모듈을 쓸 것이다.
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1",
"start": "nodemon app"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"express": "^4.18.1"
},
"devDependencies": {
"nodemon": "^2.0.16"
}
}
1초 기본 타이머
let num = 1;
setInterval(() => {
console.log(num++);
}, 1000);
setInterval은 따로 중지하지 않는 이상, 계속 실행된다.
/**
* The `timer` module exposes a global API for scheduling functions to
* be called at some future period of time. Because the timer functions are
* globals, there is no need to call `require('timers')` to use the API.
*
* The timer functions within Node.js implement a similar API as the timers API
* provided by Web Browsers but use a different internal implementation that is
* built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
* @see [source](https://github.com/nodejs/node/blob/v17.0.0/lib/timers.js)
*/
declare module 'timers' {
import { Abortable } from 'node:events';
import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
interface TimerOptions extends Abortable {
/**
* Set to `false` to indicate that the scheduled `Timeout`
* should not require the Node.js event loop to remain active.
* @default true
*/
ref?: boolean | undefined;
}
let setTimeout: typeof global.setTimeout;
let clearTimeout: typeof global.clearTimeout;
let setInterval: typeof global.setInterval;
let clearInterval: typeof global.clearInterval;
let setImmediate: typeof global.setImmediate;
let clearImmediate: typeof global.clearImmediate;
global {
namespace NodeJS {
// compatibility with older typings
interface Timer extends RefCounted {
hasRef(): boolean;
refresh(): this;
[Symbol.toPrimitive](): number;
}
interface Immediate extends RefCounted {
/**
* If true, the `Immediate` object will keep the Node.js event loop active.
* @since v11.0.0
*/
hasRef(): boolean;
_onImmediate: Function; // to distinguish it from the Timeout class
}
interface Timeout extends Timer {
/**
* If true, the `Timeout` object will keep the Node.js event loop active.
* @since v11.0.0
*/
hasRef(): boolean;
/**
* Sets the timer's start time to the current time, and reschedules the timer to
* call its callback at the previously specified duration adjusted to the current
* time. This is useful for refreshing a timer without allocating a new
* JavaScript object.
*
* Using this on a timer that has already called its callback will reactivate the
* timer.
* @since v10.2.0
* @return a reference to `timeout`
*/
refresh(): this;
[Symbol.toPrimitive](): number;
}
}
function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
function setTimeout(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
namespace setTimeout {
const __promisify__: typeof setTimeoutPromise;
}
function clearTimeout(timeoutId: NodeJS.Timeout | undefined): void;
function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
namespace setInterval {
const __promisify__: typeof setIntervalPromise;
}
function clearInterval(intervalId: NodeJS.Timeout | undefined): void;
function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
// util.promisify no rest args compability
// tslint:disable-next-line void-return
function setImmediate(callback: (args: void) => void): NodeJS.Immediate;
namespace setImmediate {
const __promisify__: typeof setImmediatePromise;
}
function clearImmediate(immediateId: NodeJS.Immediate | undefined): void;
function queueMicrotask(callback: () => void): void;
}
}
declare module 'node:timers' {
export * from 'timers';
}
타이머 취소하기
let num = 1;
const interval = setInterval(() => {
console.log(num++);
}, 1000);
setTimeout(() => {
console.log("TimeOut!");
clearInterval(interval);
}, 6000);
다만 타이머 계열 api들 보다
process.nextTick(()=>{}) 이 콜스택에 들어가는 최우선 순위를 가장 먼저 가져간다.
코드 실행시간 측정
* setTimeout과 setImmediate는 거의 동일하게 작용
console.time()~console.timeEnd()로 실행~완료 시간을 측정할 수 있다.
console.time("");
setTimeout(() => {
console.timeEnd("");
}, 0); // 1.959ms 등 다양한 숫자가 나오면서 완벽히 0초를 보장하지는 않는다.
console.time("");
setImmediate(() => {
console.timeEnd("");
}, 0); //역시나 2.391ms 등 다양한 숫자가 나오면서 완벽히 0초를 보장하지는 않는다.
완벽한 0초를 보장할 수 없는 이유 : 콜스택이 텅텅 비었다고 보장 받을 때까지 기다리는 시간이 있기 때문이다.
clang -std=c89 -W -Wall -pedantic-errors main.c
//컴파일러, c89표준으로 컴파일하라, Warning 다 켜라, 문제들이 있으면 에러 많이 내뱉어라, 마지막에 main.c 빌드해라
//clang 실제 문서에서 각 컴파일 flag들이 무슨 역할 하는지 적혀있음
//컴파일할 때 어떤 옵션으로 할 것인지 써주는 것들
//main.c 대신에 *.c 하면 모든 C파일 컴파일해서 실행파일 만들어달라고 할 수 있다
//실행파일은 특별히 지정 안 하는 이상 다 a로 나온다.
//윈도우에서는 a.exe, 리눅스에서는 a.out
./a.out
echo $?
요약: c에서 컴파일 화는 과정, 어떤 라이브러리를 가져오겠다고 #include하는 과정은 <> 안에 있는 해당 텍스트 파일을 열어서 코드를 전부 복붙해오는 과정이라고 생각하면 된다.
헤더 파일을 include할 때 실제로 일어나는 일
전처리기는 컴파일을 시작하기 전에 include를 찾는다.
C의 Hello World (.c) (.h)
#include<stdio.h> //헤더 파일 발견
//C의 #include는 헤더 파일(*.h)을 열어서 그 내용을 복사해서
//아예 이 위치에 붙여버린다.
int main()
{
printf("Hello World!");
return 0;
}
즉, 위와 같은 상태로 컴파일을 돌리면
include로 가져온 파일 속에 있는 모든 코드들도 먼저 같이 포함된 상태로
컴파일이 되는 것이다.
C#의 Hello World (.cs)
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Hello_World
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//Console.WriteLine()같은 함수는
//C#언어를 사용하면 가져다 쓰라고 만든 함수, 변수들을 모아놓은 것들 중 하나
}
}
}
