클로저

정진원·2022년 12월 26일

JavaScript 모던 자바스크립트 Deep Dive

모던 자바스크립트 Deep Dive

목록 보기

9/16

Chapter 24

24.1 렉시컬 스코프

상위 스코프에 대한 참조(렉시컬 환경의 외부 렉시컬 환경에 대한 참조에 저장할 참조값)는 함수 정의가 평가되는 시점에 함수가 정의된 환경(위치)에 의해 결정된다.

참고

다이나믹 스코프
https://prl.ccs.neu.edu/blog/2019/09/05/lexical-and-dynamic-scope/

24.2 함수 객체의 내부 슬롯[[Environment]]

함수는 자신이 호출되는 환경과는 상관없이 자신이 정의된 환경인 상위 스코프를 기억해야 한다. 이를 위해 자신의 내부 슬롯[[Environment]]에 자신이 정의된 환경인 상위 스코프의 참조를 저장한다.

const x = 1;

function foo() {
  const x = 10;

  // 상위 스코프는 함수 정의 환경(위치)에 따라 결정된다.
  // 함수 호출 위치와 상위 스코프는 아무런 관계가 없다.
  bar();
}

// 함수 bar는 자신의 상위 스코프, 즉 전역 렉시컬 환경을 [[Environment]]에 저장하여 기억한다.
function bar() {
  console.log(x);
}

foo(); // 1
bar(); // 1

foo함수 내부에서 bar 함수가 호출되어 실행 중인 시점의 실행 컨텍스트는 다음과 같다.

함수 정의가 평가된 시점, 즉 전역 코드 평가 시점에 실행 중인 실행 컨텍스트의 렉시컬 환경인 전역 렉시컬 환경의 참조가 저장된다. (①)
함수가 호출되면 함수 내부로 코드의 제어권이 이동한다. 그리고 아래 순수대로 코드가 평가된다.
1. 함수 실행 컨텍스트 생성
2. 함수 렉시컬 환경 생성 (함수 환경 레코드 생성, this 바인딩, 외부 렉시컬 환경에 대한 참조 결정)
여기서 외부 렉시컬 환경에 대한 참조에는 내부 슬롯 [[Environment]]에 저장된 렉시컬 환경의 참조가 할당된다. (②, ③)

24.3 클로저와 렉시컬 환경

외부 함수보다 중컵 함수가 더 오래 유지되는 경우 중첩 함수는 이미 생명주기가 종료한 외부 함수의 변수를 참조한다. 이러한 중첩 함수를 클로저라고 한다.

const x = 1;

// ①
function outer() {
  const x = 10;
  const inner = function () { console.log(x); }; // ②
  return inner;
}

// outer 함수를 호출하면 중첩 함수 inner를 반환한다.
// 그리고 outer 함수의 실행 컨텍스트는 실행 컨텍스트 스택에서 팝되어 제거된다.
const innerFunc = outer(); // ③
innerFunc(); // ④ 10

outer 함수가 평가되어 함수 객체를 생성할 때(①) 현재 실행 중인 실행 컨텍스트의 렉시컬 환경인 전역 렉시컬 활경을 outer 함수 객체의 [[Environment]] 내부 슬롯에 상위 스코프로 저장한다.
outer 함수를 호출하면 함수 객체의 [[Environment]] 내부 슬롯에 저장된 전역 렉시컬 환경을 outer 함수 렉시컬 환경의 외부 렉시컬 환경에 대한 참조에 할당한다.
그 후, 중첩함수 inner가 평가된다.(②) inner 함수는 [[Environment]] 내부 슬롯에 outer 함수의 렉시컬 환경을 상위 스코프로 저장한다.

outer 함수의 실행이 종료되면 inner 함수를 반환하며 생명 주기가 종료된다.(③) 하지만, outer 함수의 실행 컨텍스트가 실행 컨텍스트 스택에서 제거되지만 해당 함수의 렉시컬 환경은 소멸되지 않는다.
outer가 반환한 inner 함수를 호출하면(④) inner 함수의 실행 컨텍스트가 생성되고 렉시컬 환경의 외부 렉시컬 환경에 대한 참조에는 inner 함수 객체의 [[Environment]] 내부 슬롯에 저장된 참조값이 할당된다.

자바스크립트의 모든 함수는 상위 스코프를 기억하는데 그럼 모든 함수가 클로저인가?

클로저는 중첩 함수가 상위 스코프의 식별자를 참조하고 있고 중첩 함수가 외부 함수보다 더 오래 유지되는 경우에 한정된다.

24.4 클로저의 활용

클로저는 상태를 안전하게 변경하고 유지하기 위해 사용한다. 즉, 상태를 안전하게 은닉하고 특정 함수에게만 상태 변경을 허용하기 위해 사용한다.

카운트 상태를 나타내는 num 변수 값이 increase, decrease 함수가 호출되기 전까지 변경되지 않고, increase, decrease 함수만이 해당 변수를 변경할 수 있도록 하려면 다음과 같이 코드를 작성할 수 있다.

const counter = (function () {
  // 카운트 상태 변수
  let num = 0;

  // 클로저인 메서드를 갖는 객체를 반환한다.
  // 객체 리터럴은 스코프를 만들지 않는다.
  // 따라서 아래 메서드들의 상위 스코프는 즉시 실행 함수의 렉시컬 환경이다.
  return {
    // num: 0, // 프로퍼티는 public하므로 은닉되지 않는다.
    increase() {
      return ++num;
    },
    decrease() {
      return num > 0 ? --num : 0;
    }
  };
}());

console.log(counter.increase()); // 1
console.log(counter.increase()); // 2

console.log(counter.decrease()); // 1
console.log(counter.decrease()); // 0

이를 생성자 함수로 표현할수도 있다. 즉시 실행 함수 내에서 변수를 선언해서 정보를 은닉할 수 있다.

const Counter = (function () {
  // ① 카운트 상태 변수
  let num = 0;

  function Counter() {
    // this.num = 0; // ② 프로퍼티는 public하므로 은닉되지 않는다.
  }

  Counter.prototype.increase = function () {
    return ++num;
  };

  Counter.prototype.decrease = function () {
    return num > 0 ? --num : 0;
  };

  return Counter;
}());

const counter = new Counter();

console.log(counter.increase()); // 1
console.log(counter.increase()); // 2

console.log(counter.decrease()); // 1
console.log(counter.decrease()); // 0

이런 패턴은 외부 상태 변경이나 가변 데이터를 피하고 불변성을 지향하는 함수형 프로그래밍에서 부수 효과를 억제하고 프로그램의 안정성을 높이기 위해 사용된다.
함수형 프로그래밍에서 클로저의 예시는 아래와 같다.

// 함수를 인수로 전달받고 함수를 반환하는 고차 함수
// 이 함수는 카운트 상태를 유지하기 위한 자유 변수 counter를 기억하는 클로저를 반환한다.
function makeCounter(aux) {
  // 카운트 상태를 유지하기 위한 자유 변수
  let counter = 0;

  // 클로저를 반환
  return function () {
    // 인수로 전달 받은 보조 함수에 상태 변경을 위임한다.
    counter = aux(counter);
    return counter;
  };
}

// 보조 함수
function increase(n) {
  return ++n;
}

// 보조 함수
function decrease(n) {
  return --n;
}

// 함수로 함수를 생성한다.
// makeCounter 함수는 보조 함수를 인수로 전달받아 함수를 반환한다
const increaser = makeCounter(increase); // ①
console.log(increaser()); // 1
console.log(increaser()); // 2

// increaser 함수와는 별개의 독립된 렉시컬 환경을 갖기 때문에 카운터 상태가 연동하지 않는다.
const decreaser = makeCounter(decrease); // ②
console.log(decreaser()); // -1
console.log(decreaser()); // -2

하지만 위 예시에서 makeCounter 함수를 호출해 함수를 반환할 때 마다 반환된 함수는 독립적인 렉시컬 환경을 갖는다. 즉, 같은 변수를 공유하지 않는다.

이를 해결하기 위해선 렉시컬 환경을 공유해야 한다. 즉, makeCounter 함수를 한 번만 호출해야 한다.

// 함수를 반환하는 고차 함수
// 이 함수는 카운트 상태를 유지하기 위한 자유 변수 counter를 기억하는 클로저를 반환한다.
const counter = (function () {
  // 카운트 상태를 유지하기 위한 자유 변수
  let counter = 0;

  // 함수를 인수로 전달받는 클로저를 반환
  return function (aux) {
    // 인수로 전달 받은 보조 함수에 상태 변경을 위임한다.
    counter = aux(counter);
    return counter;
  };
}());

// 보조 함수
function increase(n) {
  return ++n;
}

// 보조 함수
function decrease(n) {
  return --n;
}

// 보조 함수를 전달하여 호출
console.log(counter(increase)); // 1
console.log(counter(increase)); // 2

// 자유 변수를 공유한다.
console.log(counter(decrease)); // 1
console.log(counter(decrease)); // 0

24.5 캡슐화와 정보 은닉

캡슐화는 객체의 상태를 나타내는 프로퍼티와 프로퍼티를 참조하고 조작할 수 있는 동작인 메서드를 하나로 묶는 것이다. 객체의 특정 프로퍼티나 메서드에 대한 정보를 은닉하기 위해 사용한다.

기본적으로 자바스크립트는 접근 제한자를 제공하지 않는다. 따라서 자바스크립트 객체의 모든 프로퍼티와 메서드는 public 하다.

const Person = (function () {
  let _age = 0; // private

  // 생성자 함수
  function Person(name, age) {
    this.name = name; // public
    _age = age;
  }

  // 프로토타입 메서드
  Person.prototype.sayHi = function () {
    console.log(`Hi! My name is ${this.name}. I am ${_age}.`);
  };

  // 생성자 함수를 반환
  return Person;
}());

const me = new Person('Lee', 20);
me.sayHi(); // Hi! My name is Lee. I am 20.
console.log(me.name); // Lee
console.log(me._age); // undefined

const you = new Person('Kim', 30);
you.sayHi(); // Hi! My name is Kim. I am 30.
console.log(you.name); // Kim
console.log(you._age); // undefined

다음과 같이 생성자 함수의 지역 변수로 변수를 선언하면 해당 변수를 private하게 사용할 수 있다. 하지만, 이 코드는 여러 개의 인스턴스 생성시 변수의 상태가 유지되지 않는다는 문제가 있다.

const me = new Person('Lee', 20);
me.sayHi(); // Hi! My name is Lee. I am 20.

const you = new Person('Kim', 30);
you.sayHi(); // Hi! My name is Kim. I am 30.

// _age 변수 값이 변경된다!
me.sayHi(); // Hi! My name is Lee. I am 30.

Person.prototype.sayHi 메서드가 단 한 번만 생성되는 클로저이기 때문에 이런 현상이 발생한다. 해당 함수의 [[Environment]] 내부 슬롯에는 하나의 동일한 상위 스코프의 참조가 저장되기 때문이다.
즉, 자바스크립트에서는 완전하게 정보 은닉을 제공하지 않는다. 하지만, 클래스에는 private 필드를 정의할 수 있는 방법이 제안되어 있다.

24.6 자주 발생하는 실수

var funcs = [];

for (var i = 0; i < 3; i++) {
  funcs[i] = function () { return i; }; // ①
}

for (var j = 0; j < funcs.length; j++) {
  console.log(funcs[j]()); // ②
}

위의 예제를 실행하면 0,1,2가 아닌 3,3,3 이 출력된다.
var가 블록 레벨 스코프가 아닌 함수 레벨 스코프를 갖기 때문에 전역 변수로 선언이 된다.
클로저를 사용해 이를 바르게 동작하도록 할 수 있다.

var funcs = [];

for (var i = 0; i < 3; i++){
  funcs[i] = (function (id) { // ①
    return function () {
      return id;
    };
  }(i));
}

for (var j = 0; j < funcs.length; j++) {
  console.log(funcs[j]());
}

즉시 실행 함수의 매개변수 id는 즉시 실행 함수가 반환한 중첩 함수의 상위 스코프에 존재한다. 즉시 실행 함수가 반환한 중첩 함수는 자신의 상위 스코프를 기억하는 클로저이고, 매개변수 id는 즉시 실행 함수가 반환한 중첩 함수에 묶여있는 자유 변수가 되어 값을 유지한다.

let으로 선언하여 위 코드를 더 깔끔하게 작성할수도 있다.

const funcs = [];

for (let i = 0; i < 3; i++) {
  funcs[i] = function () { return i; };
}

for (let i = 0; i < funcs.length; i++) {
  console.log(funcs[i]()); // 0 1 2
}

고차함수를 사용하는 방법도 있다.

// 요소가 3개인 배열을 생성하고 배열의 인덱스를 반환하는 함수를 요소로 추가한다.
// 배열의 요소로 추가된 함수들은 모두 클로저다.
const funcs = Array.from(new Array(3), (_, i) => () => i); // (3) [ƒ, ƒ, ƒ]

// 배열의 요소로 추가된 함수 들을 순차적으로 호출한다.
funcs.forEach(f => console.log(f())); // 0 1 2