"함수는 객체다"

1. 프로퍼티와 메서드를 가질 수 있습니다.
   • 설명: 일반 객체처럼 함수에도 키-값 쌍의 프로퍼티를 추가하거나 내장된 프로퍼티를 사용할 수 있습니다.
   • 핵심 패턴: 함수.프로퍼티명 = 값; 또는 함수.메서드명();
   • 예시:

     function sayHello() {
       console.log("Hello!");
     }
     sayHello.description = "인사를 하는 함수입니다."; // 커스텀 프로퍼티 추가
     console.log(sayHello.description); // "인사를 하는 함수입니다."
     console.log(sayHello.name); // "sayHello" (내장 프로퍼티: 함수 이름)
     console.log(sayHello.length); // 0 (내장 프로퍼티: 기대하는 인자의 수)
     
     const numbers = [1, 2, 3];
     // forEach는 Array.prototype의 메서드지만, 함수 형태로 존재
     numbers.forEach(function printNum(num) { // 익명 함수지만, 엔진은 이름을 붙일 수 있음
       console.log(num, printNum.name); // num, "printNum" (콜백 함수의 이름)
     });
     

2. 변수에 할당될 수 있습니다 (일급 객체, First-class citizen).
   • 설명: 함수는 값(value)으로 취급되어 변수에 저장될 수 있습니다. 이는 함수를 다른 곳으로 쉽게 전달하거나 재사용할 수 있게 합니다.
   • 핵심 패턴: const 변수명 = 함수;
   • 예시:

     const greet = function(name) {
       return `Hello, ${name}!`;
     };
     console.log(greet("World")); // "Hello, World!"
     
     const anotherGreet = greet; // 다른 변수에 할당
     console.log(anotherGreet("JavaScript")); // "Hello, JavaScript!"
     

3. 다른 함수의 인자로 전달될 수 있습니다 (콜백 함수).
   • 설명: 함수를 다른 함수의 매개변수로 넘겨, 특정 작업이 완료된 후 또는 특정 조건에서 호출되도록 할 수 있습니다. 이게 바로 콜백 함수의 원리입니다.
   • 핵심 패턴: 다른함수(function() { /* 콜백 로직 */ });
   • 예시:

     function processUserInput(callback) {
       const name = "Lando Norris"; // 사용자 입력이라고 가정
       callback(name);
     }
     
     processUserInput(function(name) { // 함수를 인자로 전달
       console.log(`안녕하세요, ${name}님!`); // "안녕하세요, Lando Norris님!"
     });
     
     const numbers = [1, 2, 3, 4];
     const evenNumbers = numbers.filter(function(num) { // filter 메서드에 함수 전달
       return num % 2 === 0;
     });
     console.log(evenNumbers); // [2, 4]
     

4. 다른 함수에서 반환될 수 있습니다 (고차 함수, 클로저).
   • 설명: 함수가 다른 함수를 생성하고 그 함수를 결과값으로 반환할 수 있습니다. 이는 클로저(closure)와 같은 강력한 패턴을 가능하게 합니다.
   • 핵심 패턴: function 외부함수() { return function 내부함수() { /* 로직 */ }; }
   • 예시:

     function createGreeter(greeting) {
       return function(name) { // 함수를 반환
         return `${greeting}, ${name}!`;
       };
     }
     
     const sayHelloTo = createGreeter("Hello");
     const sayHiTo = createGreeter("Hi");
     
     console.log(sayHelloTo("Max")); // "Hello, Max!"
     console.log(sayHiTo("Charles")); // "Hi, Charles!"
     

5. 배열이나 객체와 같은 자료구조에 저장될 수 있습니다.
   • 설명: 함수도 값이기 때문에, 배열의 요소나 객체의 속성 값으로 함수를 저장할 수 있습니다.
   • 핵심 패턴: const arr = [함수1, 함수2]; 또는 const obj = { doSomething: 함수 };
   • 예시:

     function add(a, b) { return a + b; }
     function subtract(a, b) { return a - b; }
     
     const operations = [add, subtract];
     console.log(operations[0](10, 5)); // 15 (add 함수 호출)
     console.log(operations[1](10, 5)); // 5  (subtract 함수 호출)
     
     const calculator = {
       plus: add,
       minus: subtract
     };
     console.log(calculator.plus(20, 7)); // 27
     

6. prototype 프로퍼티를 가집니다.
   • 설명: 함수가 정의될 때, 해당 함수는 prototype이라는 특별한 객체 프로퍼티를 갖게 됩니다 (화살표 함수 제외). 이 prototype 객체는 해당 함수를 생성자(constructor)로 사용했을 때 생성되는 인스턴스 객체들의 부모 역할을 하며, 프로토타입 기반 상속의 핵심입니다.
   • 핵심 패턴: 함수명.prototype.메서드명 = function() { /* 로직 */ };
   • 예시:

     function Car(brand) {
       this.brand = brand;
     }
     
     // Car 함수의 prototype 객체에 메서드 추가
     Car.prototype.getBrand = function() {
       return this.brand;
     };
     
     const myCar = new Car("McLaren"); // Car를 생성자로 사용
     console.log(myCar.getBrand()); // "McLaren"
     // myCar는 Car.prototype에 정의된 메서드를 상속받아 사용 가능
     

7. 생성자 함수(Constructor Function)로 사용될 수 있습니다 (new 키워드와 함께).
   • 설명: new 연산자와 함께 함수를 호출하면, 그 함수는 객체를 생성하는 생성자 역할을 합니다. 이때 함수 내부의 this는 새로 생성된 객체를 가리킵니다.
   • 핵심 패턴: const 인스턴스 = new 함수명(인자);
   • 예시: (위 6번 Car 예시 참고)
8. call(), apply(), bind() 메서드를 사용할 수 있습니다.
   • 설명: 모든 함수는 Function.prototype으로부터 이 메서드들을 상속받습니다. 이 메서드들은 함수를 호출하면서 this 값을 명시적으로 설정하거나, 인자를 특정 방식으로 전달할 때 유용합니다.
   • 핵심 패턴:
     • 함수.call(thisArg, arg1, arg2, ...)
     • 함수.apply(thisArg, [arg1, arg2, ...])
     • const 바인딩된함수 = 함수.bind(thisArg, arg1, ...);
   • 예시:

     function introduce(greeting, punctuation) {
       console.log(`${greeting}, my name is <span class="math-inline">\{this\.name\}</span>{punctuation}`);
     }
     
     const person1 = { name: "Lando" };
     const person2 = { name: "Oscar" };
     
     introduce.call(person1, "Hello", "!"); // Hello, my name is Lando!
     introduce.apply(person2, ["Hi", "."]);   // Hi, my name is Oscar.
     
     const introduceLando = introduce.bind(person1, "Hey there");
     introduceLando("!!"); // Hey there, my name is Lando!!
     

9. Function 생성자를 통해 동적으로 함수를 생성할 수 있습니다 (권장되진 않음).
   • 설명: new Function(...) 문법을 사용하면 문자열로부터 함수를 만들 수 있습니다. 이는 함수가 객체처럼 '생성'될 수 있음을 보여주지만, 보안 및 성능 문제로 잘 사용되지 않습니다.
   • 핵심 패턴: const 함수명 = new Function('인자1', '인자2', '함수 본문');
   • 예시:

     const sum = new Function('a', 'b', 'return a + b;');
     console.log(sum(5, 10)); // 15
     

10. 호출 가능하다(Callable)!
    • 설명: 객체이긴 하지만, 특별히 () 연산자를 통해 실행될 수 있는 고유한 특징을 가집니다. 이것이 함수 객체를 다른 일반 객체와 구분 짓는 가장 큰 차이점입니다.
    • 핵심 패턴: 함수명();
    • 예시:

      function uniqueAction() {
        console.log("I am callable!");
      }
      uniqueAction.isObject = true;
      
      console.log(typeof uniqueAction); // "function" (특별한 종류의 객체)
      console.log(uniqueAction.isObject); // true
      uniqueAction(); // "I am callable!"