6. 함수의 비밀 (클로저)/6.3 클로저 활용 예제

6.3.2 함수 팩토리 만들기 - 똑똑한 함수 제조공장 세우기

thejavascript4kids 2025. 7. 7. 04:50

📘 6.3.2 함수 팩토리 만들기 - 똑똑한 함수 제조공장 세우기

안녕하세요, 여러분. 지난 시간에 클로저로 중요한 데이터를 소중히 보호하는 방법을 함께 배웠습니다. 이번에는 한 단계 더 나아가서 함수 팩토리라는 아름다운 개념을 탐구해보겠습니다.

혹시 도자기 공방에 가보신 적이 있으신가요? 한 명의 장인이 같은 물레와 같은 기법으로도 찻잔, 화분, 접시 등 전혀 다른 작품들을 만들어내는 모습을 보면 경이로움을 느끼게 되죠. 함수 팩토리도 이와 비슷합니다. 하나의 틀로 비슷하지만 서로 다른 역할을 하는 함수들을 정성스럽게 만들어낼 수 있는 놀라운 도구입니다.

실제 세상에서도 공장은 같은 기계로 여러 종류의 제품을 만들어내곤 합니다. 자동차 공장에서는 같은 생산 라인으로 빨간 차, 파른 차, 검은 차를 만들고, 빵집에서는 같은 오븐으로 식빵, 케이크, 쿠키를 구워내죠. 함수 팩토리도 이와 같은 원리로, 설정만 조금씩 바꿔가며 다양한 기능의 함수들을 효율적으로 생산할 수 있습니다. 오늘 여러분과 함께 이 아름다운 여정을 떠나보겠습니다.

🧠 먼저 용어를 알아볼까요?

함수 팩토리를 이해하는 데 필요한 핵심 용어들을 차근차근 살펴보겠습니다.

용어 부드러운 의미
함수 팩토리 비슷한 기능을 가진 여러 함수를 자동으로, 그리고 정성스럽게 만들어내는 함수입니다.
틀 함수 새로운 함수들을 만들 때 기본이 되는 틀 역할을 하는 함수입니다. 마치 도자기를 만들 때의 물레 같은 존재예요.
설정 적용하기 설정값을 받아서 동작 방식을 바꾸는 것입니다. 각 함수가 자신만의 개성을 갖게 하는 과정이죠.
함수 생성 새로운 함수를 프로그램 실행 중에 만드는 것입니다. 마치 손으로 직접 빚어내는 것처럼요.
코드 재사용 같은 코드를 여러 번 활용해서 효율성을 높이는 것입니다. 자원을 아끼는 지혜로운 방법이에요.

✨ 함수 팩토리의 핵심 개념

함수 팩토리는 우리가 일상에서 경험하는 정성스러운 수공업과 비슷한 면이 있습니다.

한 동네에 있는 작은 카페를 생각해보세요. 그곳의 바리스타는 하나의 기본 레시피로 아메리카노, 카페라떼, 카푸치노 등 다양한 커피를 만들어내죠. 기본 원리는 같지만 재료나 방법만 조금씩 바꿔서 완전히 다른 맛의 커피가 탄생하는 것입니다. 함수 팩토리도 이와 같은 마음으로 작동합니다.

함수 팩토리의 가장 큰 매력은 코드 중복을 자연스럽게 줄일 수 있다는 점입니다. 만약 계산기 함수 10개를 각각 따로 만든다면 비슷한 코드를 10번 반복해서 써야 하겠지만, 함수 팩토리를 사용하면 한 번만 정성스럽게 만들어놓고 설정만 조금씩 바꿔가며 필요한 만큼 함수를 생산할 수 있어요.

또한 함수 팩토리로 만들어진 각 함수는 클로저의 섬세한 힘을 빌려 자신만의 고유한 설정을 기억합니다. 마치 각각의 장인이 자신만의 기법을 기억하고 있는 것처럼, 생성된 함수들은 서로 방해하지 않으면서도 각자의 역할을 정확하게 수행해요.

조용한 이야기: 작은 도서관의 사서 선생님

함수 팩토리를 좀 더 친근하게 이해하기 위해서 한 작은 도서관의 이야기를 들려드리겠습니다.

어느 동네에 정말 작은 도서관이 있었습니다. 그곳의 사서 선생님은 방문하는 사람마다 딱 맞는 책을 추천해주는 능력이 있었어요.

어린이가 오면 "재미있는 모험 이야기는 어떨까요?"라고 말하며 적절한 책을 건네주고, 요리에 관심 있는 분이 오면 "오늘은 이 레시피북이 좋을 것 같아요"라고 다정하게 안내해주었죠. 학생이 와서 공부 도움을 요청하면 "이 참고서로 시작해보세요"라고 따뜻하게 도와주었습니다.

선생님의 기본 원칙은 항상 같았어요. "방문자의 필요를 파악하고, 적절한 자료를 찾아서, 정중하게 안내한다." 하지만 방문자의 특성에 따라 추천하는 책의 종류와 말투가 자연스럽게 달라졌죠.

함수 팩토리도 이와 같습니다. 하나의 기본 틀로 다양한 맞춤형 함수들을 만들어내는 것이 바로 함수 팩토리의 핵심 아이디어입니다.

🎯 함수 팩토리를 배우는 이유

그렇다면 왜 함수 팩토리를 배워야 할까요? 실제 프로그래밍에서 얻을 수 있는 소중한 이점들이 있습니다.

첫 번째로 개발 속도가 자연스럽게 빨라집니다. 비슷한 기능의 함수를 여러 개 만들어야 할 때, 하나하나 손으로 만드는 대신 팩토리 한 번만 정성스럽게 만들어놓으면 나머지는 설정만 바꿔가며 자동으로 생산할 수 있어요.

두 번째로 유지보수가 훨씬 편해집니다. 만약 100개의 비슷한 함수를 각각 따로 만들었다가 수정이 필요하면 100개를 모두 바꿔야 하겠지만, 함수 팩토리로 만들었다면 팩토리 하나만 수정하면 모든 함수에 변경사항이 자연스럽게 적용되거든요.

세 번째로 코드의 일관성이 보장됩니다. 같은 팩토리에서 나온 함수들은 모두 동일한 패턴으로 동작하기 때문에, 팀 프로젝트에서 여러 사람이 작업해도 일관된 결과를 얻을 수 있어요.

마지막으로 확장성이 뛰어납니다. 새로운 종류의 함수가 필요하면 새로운 설정만 추가하면 되므로, 프로그램이 커져도 유연하게 대응할 수 있습니다.

⚙️ 기본 문법 살펴보기

함수 팩토리의 기본 구조는 다음과 같습니다.

function 팩토리이름(설정값) {
    // 설정값을 클로저로 기억
    let 기억할설정 = 설정값;

    // 실제 작업을 수행할 함수 생성
    function 생성될함수(입력값) {
        // 기억된 설정을 사용해서 작업 수행
        return 기억할설정 + 입력값; // 예시
    }

    // 완성된 함수 반환
    return 생성될함수;
}

// 사용 방법
let 함수1 = 팩토리이름("설정A");
let 함수2 = 팩토리이름("설정B");

핵심 구성 요소:

  • 팩토리 함수: 새로운 함수들을 만들어내는 공장 역할
  • 설정값 매개변수: 생성될 함수의 특성을 결정하는 값
  • 클로저: 설정값을 안전하게 기억하는 메커니즘
  • 내부 함수: 실제 작업을 수행하는 생성될 함수
  • 반환: 완성된 함수를 외부로 내보내는 과정

🧪 예제로 익혀보기

이제 실제 예제를 통해 함수 팩토리의 다양한 활용법을 차근차근 알아보겠습니다.

🔹 예제 1: 언어별 인사말 제조공장

첫 번째 예제에서는 가장 기본적인 함수 팩토리를 만들어보겠습니다. 언어 설정만 바꿔가며 다양한 언어의 인사말 함수를 만들어내는 공장을 함께 건설해보겠습니다.

// 언어별 인사말 제조공장 - 언어 설정에 따라 다른 인사 함수를 정성스럽게 생산
function createGreetingMachine(language) {
    // 언어에 맞는 인사말을 클로저로 소중히 기억
    let greetingWord = "";

    // 언어별 인사말을 정성스럽게 설정
    if(language === "korean") {
        greetingWord = "안녕하세요";
    } else if(language === "english") {
        greetingWord = "Hello";
    } else if(language === "japanese") {
        greetingWord = "こんにちは";
    } else {
        greetingWord = "Hi"; // 기본값
    }

    console.log(language + " 인사말 기계가 정성스럽게 만들어졌습니다!");

    // 실제 인사 기능을 수행하는 함수를 생성
    function greetPerson(name) {
        let fullGreeting = greetingWord + ", " + name + "!";
        console.log(fullGreeting);
        return fullGreeting;
    }

    // 완성된 인사 함수를 반환
    return greetPerson;
}

// 다양한 언어의 인사 기계들을 생산
console.log("=== 인사말 기계 공장 가동 ===");
let koreanGreeter = createGreetingMachine("korean");    // 한국어 인사 기계
let englishGreeter = createGreetingMachine("english");  // 영어 인사 기계  
let japaneseGreeter = createGreetingMachine("japanese"); // 일본어 인사 기계

// 각 기계들이 각자의 언어로 따뜻하게 인사하기
console.log("\n=== 인사 기계들 작동 테스트 ===");
koreanGreeter("철수");     // "안녕하세요, 철수!"
englishGreeter("John");    // "Hello, John!"
japaneseGreeter("田中");   // "こんにちは, 田中!"

이 예제를 차근차근 살펴보면, 하나의 팩토리 함수가 언어 설정에 따라 완전히 다른 동작을 하는 함수들을 만들어내는 모습을 확인할 수 있습니다. 각 함수는 자신만의 언어를 클로저로 기억하고 있어서, 나중에 호출될 때마다 정확한 언어로 인사를 하게 됩니다.

🔹 예제 2: 똑똑한 계산기 공장

두 번째 예제에서는 조금 더 실용적인 계산기 함수들을 만들어내는 팩토리를 구축해보겠습니다. 설정에 따라 덧셈, 곱셈, 나눗셈 등 다양한 계산기를 자동으로 생산해보겠습니다.

// 똑똑한 계산기 공장 - 계산 종류에 따라 다른 계산기 함수를 정성스럽게 생산
function createCalculatorMachine(operation) {
    // 계산 종류를 클로저로 소중히 기억
    let calcType = operation;

    console.log(calcType + " 계산기가 정성스럽게 제조되었습니다!");

    // 실제 계산을 수행하는 함수를 생성
    function calculate(firstNumber, secondNumber) {
        let result = 0;
        let operationSymbol = "";

        // 계산 종류에 따라 다른 계산을 수행
        if(calcType === "add") {
            result = firstNumber + secondNumber;
            operationSymbol = " + ";
        } else if(calcType === "multiply") {
            result = firstNumber * secondNumber;
            operationSymbol = " × ";
        } else if(calcType === "subtract") {
            result = firstNumber - secondNumber;
            operationSymbol = " - ";
        } else if(calcType === "divide") {
            if(secondNumber !== 0) {
                result = firstNumber / secondNumber;
                operationSymbol = " ÷ ";
            } else {
                console.log("0으로 나눌 수 없습니다!");
                return "오류";
            }
        } else {
            console.log("알 수 없는 계산 방식입니다.");
            return "오류";
        }

        // 계산 과정과 결과를 친근하게 출력
        let equation = firstNumber + operationSymbol + secondNumber + " = " + result;
        console.log(equation);
        return result;
    }

    // 완성된 계산기 함수를 반환
    return calculate;
}

// 여러 종류의 계산기들을 대량 생산
console.log("=== 계산기 공장 가동 시작 ===");
let adder = createCalculatorMachine("add");        // 덧셈 전용 계산기
let multiplier = createCalculatorMachine("multiply"); // 곱셈 전용 계산기
let subtractor = createCalculatorMachine("subtract");  // 뺄셈 전용 계산기
let divider = createCalculatorMachine("divide");       // 나눗셈 전용 계산기

// 각 계산기들의 성능을 테스트
console.log("\n=== 계산기 성능 테스트 ===");
adder(10, 5);        // 10 + 5 = 15
multiplier(7, 8);    // 7 × 8 = 56
subtractor(20, 3);   // 20 - 3 = 17
divider(15, 3);      // 15 ÷ 3 = 5

이 예제에서는 하나의 팩토리로 네 가지 서로 다른 계산기를 만들어내는 모습을 볼 수 있습니다. 각 계산기는 자신만의 계산 방식을 클로저로 기억하고 있어서, 호출될 때마다 정확한 계산을 수행합니다.

🔹 예제 3: 개인 맞춤 메시지 공장

세 번째 예제에서는 더욱 섬세한 함수 팩토리를 만들어보겠습니다. 메시지 타입과 추가 설정을 조합해서 다양한 개인 맞춤 메시지 함수들을 생산해보겠습니다.

// 개인 맞춤 메시지 공장 - 메시지 타입과 스타일에 따라 다른 메시지 함수를 정성스럽게 생산
function createMessageMachine(messageType, style) {
    // 메시지 설정들을 클로저로 소중히 기억
    let msgType = messageType;
    let msgStyle = style || "normal"; // 기본 스타일

    console.log(msgType + " 메시지 기계(" + msgStyle + " 스타일)가 정성스럽게 제조되었습니다!");

    // 실제 메시지를 만드는 함수를 생성
    function createMessage(name, extraInfo) {
        let baseMessage = "";
        let styledMessage = "";

        // 메시지 타입에 따른 기본 메시지 생성
        if(msgType === "welcome") {
            baseMessage = "환영합니다, " + name + "님!";
        } else if(msgType === "goodbye") {
            baseMessage = "안녕히 가세요, " + name + "님!";
        } else if(msgType === "birthday") {
            baseMessage = "생일 축하합니다, " + name + "님!";
        } else if(msgType === "congratulation") {
            baseMessage = "축하합니다, " + name + "님!";
        } else {
            baseMessage = "안녕하세요, " + name + "님!";
        }

        // 추가 정보가 있으면 자연스럽게 포함
        if(extraInfo) {
            baseMessage = baseMessage + " " + extraInfo;
        }

        // 스타일에 따른 메시지 꾸미기
        if(msgStyle === "formal") {
            styledMessage = "【 " + baseMessage + " 】";
        } else if(msgStyle === "cute") {
            styledMessage = "♡ " + baseMessage + " ♡";
        } else if(msgStyle === "exciting") {
            styledMessage = "★ " + baseMessage + " ★";
        } else {
            styledMessage = baseMessage; // 일반 스타일
        }

        console.log(styledMessage);
        return styledMessage;
    }

    // 완성된 메시지 제작 함수를 반환
    return createMessage;
}

// 다양한 메시지 기계들을 대량 생산
console.log("=== 메시지 기계 공장 가동 ===");
let welcomeBot = createMessageMachine("welcome", "formal");      // 정중한 환영 메시지
let birthdayBot = createMessageMachine("birthday", "cute");      // 귀여운 생일 메시지
let congratsBot = createMessageMachine("congratulation", "exciting"); // 신나는 축하 메시지
let simpleBot = createMessageMachine("goodbye");                 // 일반 작별 메시지

// 각 메시지 기계들의 개성 있는 메시지 생산
console.log("\n=== 메시지 기계들 작동 테스트 ===");
welcomeBot("김철수", "저희 회사에 입사하신 것을");
birthdayBot("박영희", "즐거운 하루 되세요!");
congratsBot("이민수", "대학 합격을 진심으로");
simpleBot("정지은", "좋은 하루 되세요!");

이 예제는 함수 팩토리의 진정한 아름다움을 보여줍니다. 메시지 타입과 스타일이라는 두 가지 설정을 조합해서 무려 수십 가지의 서로 다른 메시지 함수를 만들어낼 수 있어요. 각 함수는 자신만의 고유한 설정을 완벽하게 기억하고 있습니다.

이제 여러분께 연습문제를 드리려고 합니다. 잠시 마음을 차분히 하시고 지금까지 배운 내용들을 떠올려보세요. 함수 팩토리라는 개념이 처음에는 조금 복잡하게 느껴지실 수도 있지만, 사실 우리 일상에서 늘 경험하는 자연스러운 과정과 다르지 않습니다. 하나의 방법으로 여러 가지 결과를 만들어내는 것, 그것이 바로 함수 팩토리의 본질입니다. 연습문제를 통해 이 아름다운 개념을 조금 더 친근하게 느껴보시길 바랍니다.

✏️ 연습문제로 개념 다지기

이제 배운 내용을 연습문제를 통해 차근차근 익혀보겠습니다.

Ex1) 인사 스타일에 따라 다른 인사 함수를 만들어보자

// 인사 스타일별로 다른 인사 함수를 만드는 팩토리
function createGreeter(style) {
    function greet(name) {
        // 스타일에 따라 다른 인사말을 생성
        if(style === "formal") {
            return "안녕하십니까, " + name + "님";
        } else if(style === "casual") {
            return "안녕, " + name + "!";
        } else {
            return "안녕하세요, " + name + "님";
        }
    }
    return greet; // 완성된 함수를 반환
}

// 다양한 스타일의 인사 함수들을 생성
let formalGreeter = createGreeter("formal");   // 정중한 인사 함수
let casualGreeter = createGreeter("casual");   // 친근한 인사 함수

// 각 함수가 자신만의 스타일로 인사하는지 확인
console.log(formalGreeter("김철수")); // "안녕하십니까, 김철수님"
console.log(casualGreeter("박영희"));  // "안녕, 박영희!"

Ex2) 단위 변환기 팩토리를 만들어서 다양한 변환 함수를 생산해보자

// 단위 변환을 위한 함수 팩토리
function createUnitConverter(fromUnit, toUnit, conversionRate) {
    function convert(value) {
        // 변환 계산을 수행
        let result = value * conversionRate;
        let message = value + fromUnit + " = " + result + toUnit;
        console.log(message);
        return result;
    }
    return convert; // 변환 함수를 반환
}

// 다양한 단위 변환 함수들을 생성
let cmToInch = createUnitConverter("cm", "inch", 0.393701); // 센티미터를 인치로
let kgToLb = createUnitConverter("kg", "lb", 2.20462);     // 킬로그램을 파운드로

// 각 변환기가 제대로 작동하는지 테스트
cmToInch(100);  // "100cm = 39.3701inch"
kgToLb(10);     // "10kg = 22.0462lb"

Ex3) 할인 계산기 팩토리를 만들어서 "10% 할인"과 "5000원 할인" 함수를 만들어보자

// 할인 방식에 따른 계산기 팩토리
function createDiscountCalculator(discountType, amount) {
    function calculateDiscount(originalPrice) {
        let discountAmount = 0;

        // 할인 방식에 따라 다른 계산을 수행
        if(discountType === "percent") {
            discountAmount = originalPrice * (amount / 100); // 퍼센트 할인
        } else if(discountType === "fixed") {
            discountAmount = amount; // 고정 금액 할인
        }

        let finalPrice = originalPrice - discountAmount;
        if(finalPrice < 0) finalPrice = 0; // 음수 방지

        let result = {
            원가: originalPrice,
            할인금액: discountAmount,
            최종가격: finalPrice
        };

        console.log("원가: " + originalPrice + "원, 할인: " + discountAmount + "원, 최종: " + finalPrice + "원");
        return result;
    }

    return calculateDiscount; // 할인 계산 함수를 반환
}

// 서로 다른 할인 방식의 계산기들을 생성
let percentDiscount = createDiscountCalculator("percent", 20);  // 20% 할인
let fixedDiscount = createDiscountCalculator("fixed", 5000);    // 5000원 할인

// 각 계산기로 할인 계산을 테스트
percentDiscount(30000);  // 30000원에서 20% 할인 = 24000원
fixedDiscount(15000);    // 15000원에서 5000원 할인 = 10000원

📚 이전 단원 복습 문제

6단원까지 왔으니, 이전에 배운 중요한 내용들을 복습해볼까요?

복습 1) 함수 선언과 호출 (5단원 복습)

// 다음 코드의 출력 결과를 예상해보세요
function createAdder(number) {
    function add(x) {
        return x + number;
    }
    return add;
}

let addFive = createAdder(5);
let addTen = createAdder(10);

console.log(addFive(3));  // 이 출력 결과는?
console.log(addTen(3));   // 이 출력 결과는?

정답:

  • 첫 번째 console.log는 8을 출력합니다 (3 + 5)
  • 두 번째 console.log는 13을 출력합니다 (3 + 10)
  • 각 함수는 자신만의 number 값을 클로저로 기억하고 있습니다

복습 2) 변수와 스코프 (1-2단원 복습)

// 다음 코드가 왜 다르게 동작하는지 설명해보세요
let globalVar = "전역 변수";

function testScope() {
    let localVar = "지역 변수";
    console.log(globalVar);  // 접근 가능
    console.log(localVar);   // 접근 가능
}

testScope();
console.log(globalVar);      // 접근 가능
// console.log(localVar);    // 오류 발생!

정답:

  • 전역 변수는 어디서든 접근 가능합니다
  • 지역 변수는 선언된 함수 안에서만 접근 가능합니다
  • 함수 밖에서는 함수 안의 지역 변수에 접근할 수 없습니다

지금까지 함수 팩토리를 만들고 활용하는 방법을 차근차근 알아보았습니다. 이제 여러분은 하나의 틀로 수많은 함수들을 효율적으로 생산할 수 있는 진정한 함수 제조 전문가가 되셨습니다. 마치 숙련된 장인이 된 것처럼, 필요에 따라 다양한 종류의 함수들을 손쉽게 만들어낼 수 있는 능력을 갖추게 된 것입니다.

✅ 학습 완료 체크리스트

이번 시간에 배운 내용들을 모두 이해했는지 확인해보세요!

학습 내용 이해했나요?
함수 팩토리의 기본 개념 ✅
기본 사용법과 문법 ✅
주요 특징과 차이점 ✅
자주 하는 실수들 ✅
실전 예제 이해 ✅

🎯 추가 연습 문제들

조금 더 연습하고 싶은 분들을 위한 추가 문제들입니다!

추가 문제 1. 간단한 메시지 생성 팩토리를 만들어보세요.

function createMessageMaker(messageType) {
    function makeMessage(name) {
        if(messageType === "welcome") {
            return "환영합니다, " + name + "님!";
        } else if(messageType === "goodbye") {
            return "안녕히 가세요, " + name + "님!";
        } else {
            return "안녕하세요, " + name + "님!";
        }
    }
    return makeMessage;
}

let welcomer = createMessageMaker("welcome");
let goodbyer = createMessageMaker("goodbye");

console.log(welcomer("철수"));  // "환영합니다, 철수님!"
console.log(goodbyer("영희"));  // "안녕히 가세요, 영희님!"

추가 문제 2. 단위 변환 팩토리를 만들어보세요.

function createConverter(fromUnit, toUnit) {
    function convert(value) {
        if(fromUnit === "cm" && toUnit === "m") {
            return value / 100;
        } else if(fromUnit === "m" && toUnit === "cm") {
            return value * 100;
        } else {
            return value;  // 같은 단위
        }
    }
    return convert;
}

let cmToM = createConverter("cm", "m");
let mToCm = createConverter("m", "cm");

console.log(cmToM(150));  // 1.5
console.log(mToCm(2));    // 200

추가 문제 3. 다음 팩토리 함수에서 문제점을 찾아보세요.

function createAdder(number) {
    function add(x) {
        return x + number;
    }

    return add(5);  // 여기가 문제입니다!
}

let addTen = createAdder(10);
console.log(addTen);  // 15 (함수가 아님)

답: return add(5)에서 함수를 실행한 결과를 반환하고 있습니다. return add로 함수 자체를 반환해야 합니다.

추가 문제 4. 다음 팩토리 함수의 동작을 분석하고 사용 예시를 만들어보세요.

function createCounter(step) {
    let count = 0;

    function counter() {
        count = count + step;
        return count;
    }

    return counter;
}

답: 이 팩토리는 지정된 간격으로 증가하는 카운터 함수를 생성합니다.

사용 예시:

let countByOne = createCounter(1);
let countByFive = createCounter(5);

console.log(countByOne());  // 1
console.log(countByOne());  // 2
console.log(countByFive()); // 5
console.log(countByFive()); // 10

설명: 각 카운터는 독립적인 count 변수와 step 값을 가지므로 서로 영향을 주지 않습니다.

추가 문제 5. 함수 팩토리를 활용해서 간단한 형식 변환기를 만들어보세요.

function createFormatter(format) {
    function formatter(value) {
        if(format === "currency") {
            return value + "원";
        } else if(format === "percent") {
            return value + "%";
        } else if(format === "phone") {
            return "010-" + value;
        } else {
            return value;
        }
    }
    return formatter;
}

let currencyFormatter = createFormatter("currency");
let percentFormatter = createFormatter("percent");
let phoneFormatter = createFormatter("phone");

console.log(currencyFormatter(1000));  // "1000원"
console.log(percentFormatter(85));     // "85%"
console.log(phoneFormatter("1234-5678")); // "010-1234-5678"

답: 이 팩토리는 다양한 형식으로 값을 변환하는 함수들을 생성합니다.

설명: 함수 팩토리를 사용하면 형식 변환 로직을 재사용하면서도 각각 다른 형식의 변환기를 쉽게 만들 수 있습니다.

🔄 단계별 진행 과정 정리

지금까지 배운 내용을 단계별로 다시 한번 정리해볼게요.

1단계 과정: 1) 팩토리 함수에 언어 설정 전달 → 2) 언어에 맞는 인사말 설정 → 3) 인사말을 기억하는 클로저 함수 생성 → 4) 생성된 함수 반환 → 5) 각 함수는 자신의 언어로 인사

2단계 과정: 1) 계산 종류를 팩토리에 전달 → 2) 해당 계산 방식을 기억하는 클로저 생성 → 3) 계산 함수 반환 → 4) 생성된 함수는 항상 자신의 방식으로 계산 → 5) 필요한 만큼 계산 실행

3단계 과정: 1) 메시지 종류와 스타일을 팩토리에 전달 → 2) 해당 설정들을 기억하는 클로저 생성 → 3) 메시지 생성 함수 반환 → 4) 입력받은 이름에 맞는 메시지 생성 → 5) 각 함수는 자신의 스타일로 동작

📂 마무리 정보

오늘 배운 6.3.2 내용이 여러분의 자바스크립트 지식에 잘 저장되었나요? 다음 시간에는 더 흥미로운 내용으로 만나요!

기억할 점: 오늘 배운 내용을 꼭 연습해보시고, 궁금한 점이 있으면 언제든 다시 돌아와서 읽어보세요.


🚀 더 체계적인 JavaScript 학습을 원하신다면?
이 포스팅에서 다룬 내용을 실제로 실습해보세요!
무료 JavaScript 학습 플랫폼에서 단계별 학습과 실시간 코드 실행을 통해
더욱 효과적이고 재미있게 학습하실 수 있습니다.
📝 실시간 코드 실행 📊 학습 진도 관리 👥 체계적 커리큘럼
📚 171개 체계적 학습레슨 · 📋 855개 4지선다 연습문제 · 🆓 완전 무료 · ⚡ 즉시 시작

'6. 함수의 비밀 (클로저) > 6.3 클로저 활용 예제' 카테고리의 다른 글

6.3.1 클로저로 중요한 정보 지키기 - 우리만의 비밀 금고 만들기  (0) 2025.07.07

'6. 함수의 비밀 (클로저)/6.3 클로저 활용 예제'의 다른글

  • 현재글6.3.2 함수 팩토리 만들기 - 똑똑한 함수 제조공장 세우기

관련글

티스토리툴바