TILJavascript-Preview

javascript 17강 함수와 일급객체

Web, coding, develop, first-class Object, function, javascript

JavaScript 17강 예습

  • 17강 : 함수와 일급 객체

    1. 일급 객체
    2. 함수 객체의 프로퍼티
    • arguments 프로퍼티
      • caller 프로퍼티
      • length 프로퍼티
      • name 프로퍼티
      • __ proto __ 프로퍼티
      • prototype 프로퍼티

17강

함수와 일급 객체


일급 객체란?

  1. 무명의 리터럴로 생성할 수 있다. (즉, 런타임에 생성이 가능해야한다.)
  2. 변수나 자료 구조에 저장할 수 있다.
  3. 함수의 매개 변수에게 전달할 수 있다.
  4. 함수의 결과값으로 반환할 수 있다.

위 조건을 만족하는 객체를 일급 객체(first-class object)라 칭한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 1. 함수는 무명의 리터럴로 생성할 수 있다.
// 2. 함수는 변수에 저장할 수 있다.
// 런타임(할당 단계)에 함수 리터럴이 평가되어 함수 객체가 생성되고 변수에 할당된다.
const increase = function (num) {
  return ++num;
};

const decrease = function (num) {
  return --num;
};

// 2. 함수는 객체에 저장할 수 있다.
const predicates = { increase, decrease };

// 3. 함수의 매개 변수에게 전달할 수 있다.
// 4. 함수의 반환값으로 사용할 수 있다.
function makeCounter(predicate) {
  let num = 0;

  return function () {
    num = predicate(num);
    return num;
  };
}

// 3. 함수는 매개 변수에게 함수를 전달할 수 있다.
const increaser = makeCounter(predicates.increase);
console.log(increaser()); // 1
console.log(increaser()); // 2

// 3. 함수는 매개 변수에게 함수를 전달할 수 있다.
const decreaser = makeCounter(predicates.decrease);
console.log(decreaser()); // -1
console.log(decreaser()); // -2
  • 함수 일급 객체 = 객체와 동일하게 이용가능
  • 객체는 값이므로 함수는 값과 동일하게 취급가능( 변수 할당문, 객체의 프로퍼티, 배열의 요소, 함수 호출의 인수, 반환문)
  • 리터럴로 어디서든 정의할 수 있고 런타임에 함수 객체로 평가된다.
  • 매개 변수에 전달할 수 있고 결과값으로도 반환할 수 있다.

함수 객체의 프로퍼티

1
2
3
4
5
function square(number) {
  return number * number;
}

console.dir(square);
poiema

일반 객체에는 없는 arguments, caller, length, name, prototype 프로퍼티가 함수 객체에는 존재한다.

이 프로퍼티 들의 프로퍼티 어트리뷰트를 Object.getOwnPropertyDescriptor 메소드로 확인해 보면 아래와 같다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
function square(number) {
  return number * number;
}

// arguments는 square 함수 객체의 데이터 프로퍼티이다.
Object.getOwnPropertyDescriptor(square, 'arguments');
// {value: null, writable: false, enumerable: false, configurable: false}

// caller는 square 함수 객체의 데이터 프로퍼티이다.
Object.getOwnPropertyDescriptor(square, 'caller');
// {value: null, writable: false, enumerable: false, configurable: false}

// length는 square 함수 객체의 데이터 프로퍼티이다.
Object.getOwnPropertyDescriptor(square, 'length');
// {value: 1, writable: false, enumerable: false, configurable: true}

// name은 square 함수 객체의 데이터 프로퍼티이다.
Object.getOwnPropertyDescriptor(square, 'name');
// {value: "square", writable: false, enumerable: false, configurable: true}

// prototype은 square 함수 객체의 데이터 프로퍼티이다.
Object.getOwnPropertyDescriptor(square, 'prototype');
// {value: {…}, writable: true, enumerable: false, configurable: false}

// __proto__는 square 함수 객체의 프로퍼티가 아니다.
Object.getOwnPropertyDescriptor(square, '__proto__');
// undefined

// __proto__는 Object.prototype 객체의 접근자 프로퍼티이다.
// square 함수 객체는 Object.prototype 객체로부터 __proto__ 접근자 프로퍼티를 상속받는다.
Object.getOwnPropertyDescriptor(Object.prototype, '__proto__');
// {get: ƒ, set: ƒ, enumerable: false, configurable: true}
  • 데이터 프로퍼티 : 키와 값으로 구성된 일반적인 프로퍼티다.
  • 접근자 프로퍼티 : 자체적으로는 값을 갖지 않고 다른 데이터 프로퍼티의 값을 읽거나 저장할 때 사용하는 접근자 함수로 구성된 프로퍼티. 접근자 함수는 getter/setter 함수라고도 부른다.

arguments, caller, length, name, prototype 프로퍼티는 모두 함수 객체의 데이터 프로퍼티.

_ proto _는 접근자 프로퍼티이며 함수 객체의 프로퍼티가 아닌 Object.prototype 객체의 프로퍼티를 상속받은 것임.


arguments 프로퍼티

arguments 객체는 함수 호출 시 전달된 인수(argument)들의 정보를 담고 있는 순회 가능한(iterable) 유사 배열 객체(array-like object) 함수 내부에서 지역 변수처럼 사용된다. 즉, 함수 외부에서는 사용할 수 없다.

1
2
3
4
5
6
7
8
9
function multiply(x, y) {
  console.log(arguments);
  return x * y;
}

console.log(multiply());        // NaN
console.log(multiply(1));       // NaN
console.log(multiply(1, 2));    // 2
console.log(multiply(1, 2, 3)); // 2

multiply(1, 2, 3)으로 초과된 인수는 arguments가 소유하고 있다.

arguments

arguments 객체의 callee 프로퍼티는 호출된 함수, 즉 arguments 객체를 생성한 함수를 가리키고
arguments 객체의 Symbol(Symbol.iterator) 프로퍼티는 arguments 객체를 순회 가능한 자료 구조인 이터러블(iterable)로 만들기 위한 프로퍼티다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function multiply(x, y) {
  // 이터레이터
  const iterator = arguments[Symbol.iterator]();

  // 이터레이터의 next 메소드를 호출하여 이터러블 객체 arguments를 순회
  console.log(iterator.next()); // {value: 1, done: false}
  console.log(iterator.next()); // {value: 2, done: false}
  console.log(iterator.next()); // {value: 3, done: false}
  console.log(iterator.next()); // {value: undefined, done: true}

  return x * y;
}

multiply(1, 2, 3);

arguments 객체는 매개변수 개수를 확정할 수 없는 가변 인자 함수를 구현할 때 유용하게 사용된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function sum() {
  let res = 0;

  // arguments 객체는 length 프로퍼티가 있는 유사 배열 객체이므로 for 문으로 순회할 수 있다.
  for (let i = 0; i < arguments.length; i++) {
    res += arguments[i];
  }

  return res;
}

console.log(sum());        // 0
console.log(sum(1, 2));    // 3
console.log(sum(1, 2, 3)); // 6

caller 프로퍼티

함수 객체의 caller 프로퍼티는 함수 자신을 호출한 함수를 가리킨다.


length 프로퍼티

함수 객체의 length 프로퍼티는 함수 정의 시 선언한 매개변수의 개수를 가리킨다.

1
2
3
4
5
6
7
8
9
10
11
12
function foo() {}
console.log(foo.length); // 0

function bar(x) {
  return x;
}
console.log(bar.length); // 1

function baz(x, y) {
  return x * y;
}
console.log(baz.length); // 2

arguments 객체의 length 프로퍼티는 인자의 개수를 가리키고, 함수 객체의 length 프로퍼티는 매개변수의 개수를 가리킨다.


name 프로퍼티

함수의 이름을 나타내는 프로퍼티. (변수 이름 아니다. 함수 이름임.)

ES6부터 정식 표준이 되었다.

ES5 와 ES6의 동작이 달리하므로 주의.

익명 함수 표현식의 경우 ES5 ➤ 빈 문자열

익명 함수 표현식의 경우 ES6 ➤ 함수 객체를 가리키는 변수 이름

1
2
3
4
5
6
7
8
9
10
11
12
13
// 기명 함수 표현식
var namedFunc = function foo() {};
console.log(namedFunc.name); // foo

// 익명 함수 표현식
var anonymousFunc = function() {};
// ES5: name 프로퍼티는 빈 문자열을 값으로 갖는다.
// ES6: name 프로퍼티는 함수 객체를 가리키는 변수 이름을 값으로 갖는다.
console.log(anonymousFunc.name); // anonymousFunc

// 함수 선언문(Function declaration)
function bar() {}
console.log(bar.name); // bar

__ proto __ 접근자 프로퍼티

모든 객체는 [[Prototype]]이라는 내부 슬롯을 갖는다.

[[Prototype]] 내부 슬롯은 객체 지향 프로그래밍의 상속을 구현하는 프로토타입 객체를 가리킨다.

__ proto __ 프로퍼티는 [[Prototype]] 내부 슬롯이 가리키는 프로토타입 객체에 접근하기 위해 사용하는 접근자 프로퍼티이다.

  • 데이터 프로퍼티** : 키와 값으로 구성된 일반적인 프로퍼티다.
  • 접근자 프로퍼티 : 자체적으로는 값을 갖지 않고 다른 데이터 프로퍼티의 값을 읽거나 저장할 때 사용하는 접근자 함수로 구성된 프로퍼티. 접근자 함수는 getter/setter 함수라고도 부른다.

[[Prototype]] 내부 슬롯에도 직접 접근할 수 없으며 __ proto __ 접근자 프로퍼티를 통해 간접적으로 프로토타입 객체에 접근할 수 있다.

1
2
3
4
5
6
7
8
9
const obj = { a: 1 };

// 객체 리터럴 방식으로 생성한 객체의 프로토타입 객체는 Object.prototype이다.
console.log(obj.__proto__ === Object.prototype); // true

// 객체 리터럴 방식으로 생성한 객체는 프로토타입 객체인 Object.prototype의 프로퍼티를 상속받는다.
// hasOwnProperty 메소드는 Object.prototype의 메소드이다.
console.log(obj.hasOwnProperty('a'));         // true
console.log(obj.hasOwnProperty('__proto__')); // false

prototype 프로퍼티

prototype 프로퍼티는 함수 객체만이 소유하는 프로퍼티이다. 일반 객체에는 prototype 프로퍼티가 없다.

1
2
3
4
5
// 함수 객체는 prototype 프로퍼티를 소유한다.
console.log((function() {}).hasOwnProperty('prototype')); // true

// 일반 객체는 prototype 프로퍼티를 소유하지 않는다.
console.log(({}).hasOwnProperty('prototype')); // false

prototype 프로퍼티는 함수가 객체를 생성하는 생성자 함수로 사용될 때,

생성자 함수가 생성할 인스턴스의 프로토타입 객체를 가리킨다.


Share