바쁜 분은 이것만
- 함수가 끝나지 않고 계속 함수를 부르면 나는 에러. 트레이스에 같은 줄이 반복되면 그 함수가 범인
- 재귀는 종료 조건부터 확인, setter 안에서
this.name =쓰면 자기 자신을 다시 부름 →#name이나_name에 저장 - 재귀가 없는데 나면
Math.max(...arr),push(...arr)같은 큰 배열 스프레드 의심 →reduce나 for문으로
RangeError: Maximum call stack size exceeded는 "함수 호출이 너무 깊게 쌓여 콜 스택(호출 기록 공간)이 꽉 찼다"는 뜻입니다. 함수를 부를 때마다 스택에 한 칸씩 쌓이고 함수가 끝나면 빠지는데, 끝나지 않고 계속 부르기만 하면 한계에 닿아요. Node.js v26에서 원인별로 직접 재현해 정리했습니다.
1. 재귀에 종료 조건이 없을 때
function countdown(n) {
console.log(n);
countdown(n - 1);
}
countdown(3);
3
2
1
0
-1
-2
... (중략: 1만 줄 넘게 출력)
-10281
node:internal/console/constructor:315
if (isStackOverflowError(e))
^
RangeError: Maximum call stack size exceeded
at [kWriteToConsole] (node:internal/console/constructor:315:13)
at console.log (node:internal/console/constructor:414:26)
at countdown (~/work/c1.js:2:11)
at countdown (~/work/c1.js:3:3)
at countdown (~/work/c1.js:3:3)
at countdown (~/work/c1.js:3:3)
at countdown (~/work/c1.js:3:3)
at countdown (~/work/c1.js:3:3)
at countdown (~/work/c1.js:3:3)
at countdown (~/work/c1.js:3:3)
Node.js v26.10.0
0에서 멈출 거라 생각했지만 멈추라는 코드가 없어서 음수로 계속 내려갔어요. 트레이스 맨 위는 Node 내부(console.log)지만 그 아래 countdown (c1.js:3:3)이 똑같이 반복되는 게 핵심입니다. 반복되는 줄의 함수가 원인이에요.
얼마나 깊이 들어가야 터지는지 세어 보면:
let depth = 0;
function dive() {
depth++;
dive();
}
try {
dive();
} catch (e) {
console.log(e.name + ": " + e.message);
console.log("멈춘 깊이:", depth);
}
RangeError: Maximum call stack size exceeded
멈춘 깊이: 10395
이 맥의 Node v26에서는 약 1만 번이었어요. 숫자는 함수 안의 변수 개수, Node 버전, 브라우저에 따라 달라집니다. node --stack-size=2000처럼 늘리는 옵션도 있지만(같은 코드가 21233까지 감) 원인을 고치는 게 먼저예요.
2. 종료 조건은 있는데 그 값에 못 닿을 때
function countdown(n) {
if (n < 0) return; // 종료 조건
console.log(n);
countdown(n - 1);
}
countdown(3);
function factorial(n) {
if (n === 1) return 1; // 1에서 멈추길 기대
return n * factorial(n - 1);
}
console.log(factorial(5));
try {
console.log(factorial(0)); // 0 → -1 → -2 ... 1을 영영 못 만남
} catch (e) {
console.log(e.name + ": " + e.message);
}
try {
console.log(factorial(2.5)); // 2.5 → 1.5 → 0.5 → -0.5 ...
} catch (e) {
console.log(e.name + ": " + e.message);
}
3
2
1
0
120
RangeError: Maximum call stack size exceeded
RangeError: Maximum call stack size exceeded
factorial(5)는 잘 되지만 0이나 2.5를 넣으면 n === 1을 건너뛰어 버려요. 종료 조건은 ===보다 n <= 1처럼 범위로 쓰는 게 안전하고, 정수만 받아야 한다면 처음에 Number.isInteger(n)로 걸러 주세요.
3. setter 안에서 같은 이름에 값을 넣을 때
재귀를 쓴 적이 없는데 이 에러가 났다면 class의 getter·setter를 먼저 의심해 보세요.
class User {
constructor(name) {
this.name = name;
}
get name() {
return this.name;
}
set name(value) {
this.name = value.trim();
}
}
const u = new User(" 백조 ");
console.log(u.name);
~/work/c4.js:9
this.name = value.trim();
^
RangeError: Maximum call stack size exceeded
at String.trim (<anonymous>)
at set name (~/work/c4.js:9:23)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
at set name (~/work/c4.js:9:15)
Node.js v26.10.0
setter 안의 this.name = ...도 다시 set name을 부릅니다. 그래서 set name이 끝없이 반복돼요. getter의 return this.name도 같은 이유로 자기 자신을 부릅니다. 실제 값은 다른 이름에 저장하면 돼요.
class User {
#name;
constructor(name) {
this.name = name;
}
get name() {
return this.#name;
}
set name(value) {
this.#name = value.trim();
}
}
const u = new User(" 백조 ");
console.log(`[${u.name}]`);
class User2 {
constructor(name) {
this.name = name;
}
get name() {
return this._name;
}
set name(value) {
this._name = value.trim();
}
}
console.log(`[${new User2(" 백조 ").name}]`);
[백조]
[백조]
#name은 클래스 밖에서 못 건드리는 private 필드, _name은 예전부터 쓰던 관례예요. 어느 쪽이든 setter 이름과 겹치지만 않으면 됩니다.
4. 큰 배열을 스프레드로 넘길 때: Math.max(...arr)
재귀도 setter도 없는데 나는 경우예요. 스프레드 ...arr는 배열 원소를 함수 인자 하나하나로 펼쳐 넘기는데, 인자도 스택에 올라가서 원소가 많으면 넘칩니다.
for (const n of [100_000, 1_000_000]) {
const arr = Array.from({ length: n }, (_, i) => i);
try {
console.log(n, "개 → Math.max(...arr) =", Math.max(...arr));
} catch (e) {
console.log(n, "개 →", e.name + ": " + e.message);
}
}
100000 개 → Math.max(...arr) = 99999
1000000 개 → RangeError: Maximum call stack size exceeded
이 환경에서는 12만 개는 되고 12만5천 개부터 에러가 났어요. 데이터가 적을 땐 잘 되다가 쌓이면 갑자기 터지니 찾기 어렵습니다. apply도 같은 방식이라 똑같고, push(...arr)도 마찬가지예요. 큰 배열은 reduce나 for문을 쓰세요.
const arr = Array.from({ length: 1_000_000 }, (_, i) => i);
console.log("reduce:", arr.reduce((a, b) => (a > b ? a : b), -Infinity));
let max = -Infinity;
for (const v of arr) if (v > max) max = v;
console.log("for...of:", max);
try {
console.log("apply:", Math.max.apply(null, arr));
} catch (e) {
console.log("apply:", e.name + ": " + e.message);
}
const target = [];
try {
target.push(...arr);
console.log("push(...arr) 길이:", target.length);
} catch (e) {
console.log("push(...arr):", e.name + ": " + e.message);
}
console.log("concat 길이:", target.concat(arr).length);
reduce: 999999
for...of: 999999
apply: RangeError: Maximum call stack size exceeded
push(...arr): RangeError: Maximum call stack size exceeded
concat 길이: 1000000
배열을 이어 붙일 땐 concat을 쓰면 됩니다. 스프레드로 배열을 복사하는 [...arr]는 함수 인자가 아니라서 이 문제가 없어요(자바스크립트 배열 복사 (스프레드) 글 참고).
5. 두 함수가 서로를 부를 때
function isEven(n) {
if (n === 0) return true;
return isOdd(n - 1);
}
function isOdd(n) {
if (n === 0) return false;
return isEven(n - 1);
}
console.log(isEven(10));
console.log(isEven(-1));
true
~/work/c8.js:6
if (n === 0) return false;
^
RangeError: Maximum call stack size exceeded
at isOdd (~/work/c8.js:6:3)
at isEven (~/work/c8.js:3:10)
at isOdd (~/work/c8.js:7:10)
at isEven (~/work/c8.js:3:10)
at isOdd (~/work/c8.js:7:10)
at isEven (~/work/c8.js:3:10)
at isOdd (~/work/c8.js:7:10)
at isEven (~/work/c8.js:3:10)
at isOdd (~/work/c8.js:7:10)
at isEven (~/work/c8.js:3:10)
Node.js v26.10.0
함수 하나만 보면 재귀가 아닌데 A → B → A → B로 돌고 있어요. 트레이스에 두 함수가 번갈아 나오면 이 경우입니다. 여기서는 -1이 0을 지나쳐 계속 내려간 게 원인이라 Math.abs()로 막을 수 있지만, 입력이 크면 종료 조건이 맞아도 깊이 때문에 터져요.
function isEven(n) {
n = Math.abs(n);
if (n === 0) return true;
return isOdd(n - 1);
}
function isOdd(n) {
n = Math.abs(n);
if (n === 0) return false;
return isEven(n - 1);
}
console.log(isEven(10), isEven(-1));
try {
console.log(isEven(100_000));
} catch (e) {
console.log("100000:", e.name + ": " + e.message);
}
console.log("반복문:", ((n) => Math.abs(n) % 2 === 0)(100_000));
true false
100000: RangeError: Maximum call stack size exceeded
반복문: true
깊이가 수만 단위로 갈 수 있는 계산은 재귀 대신 반복문이나 계산식으로 바꾸는 게 맞아요. 파이썬에서도 같은 상황이 RecursionError로 나는데, 고치는 방향은 같습니다(파이썬 RecursionError: maximum recursion depth exceeded 고치는 법).
6. 덤: 자기 자신을 가리키는 객체를 직접 복사할 때
const a = { name: "a" };
a.self = a;
try {
JSON.stringify(a);
} catch (e) {
console.log(e.name + ": " + e.message.split("\n")[0]);
}
function deepCopy(obj) {
const out = {};
for (const k in obj) {
out[k] = typeof obj[k] === "object" ? deepCopy(obj[k]) : obj[k];
}
return out;
}
try {
deepCopy(a);
} catch (e) {
console.log(e.name + ": " + e.message);
}
console.log(structuredClone(a).self.self.name);
TypeError: Converting circular structure to JSON
RangeError: Maximum call stack size exceeded
a
JSON.stringify는 순환을 알아채고 다른 에러를 내지만, 직접 만든 깊은 복사 함수는 a.self.self.self...를 끝없이 따라가다 스택이 넘쳐요. 순환이 있을 수 있는 객체는 structuredClone()을 쓰면 됩니다.
정리
| 트레이스 모양 / 상황 | 원인과 고치는 법 |
|---|---|
| 같은 함수 한 줄 반복 | 재귀 종료 조건 없음 → if (n <= 0) return |
| 어떤 입력에서만 남 | === 1을 지나침 → <= 1, Number.isInteger |
at set name 반복 |
setter가 자기 자신 호출 → #name / _name에 저장 |
| 재귀 없음, 데이터 많을 때만 | Math.max(...arr)·push(...arr) → reduce, for문, concat |
| 두 함수가 번갈아 반복 | 서로 부르는 함수 → 종료 조건 확인, 깊으면 반복문으로 |
| 순환 객체 복사 | structuredClone() |
참고: MDN — RangeError, Too much recursion, Spread syntax, Function.prototype.apply, getter / setter, Private properties, structuredClone() / Node.js 문서 — Command-line options (--stack-size는 V8 옵션)
