함수의 구분

var foo = function () {
  return 1;
};
 
 
// 일반적인 함수로서 호출
foo(); // -> 1
 
// 생성자 함수로서 호출
new foo();
 
// 메서드로서 호출
var obj = {foo: foo};
obj.foo(); // -> 1

var foo = function () {};
 
// ES6 이전의 모든 함수는 callable 이면서 constructor다.
foo(); // undefined
new foo(); // -> foo {}

// 프로퍼티 f에 바인딩된 함수는 callable이며 constructor다.
var obj = {
  x:10,
  f: function () {return this.x;}
};
 
// 프로터피 f에 바인딩된 함수를 메서드로서 호출
console.log(obj.f()); //10
 
// 프로퍼티 f에 바인딩된 함수를 일반 함수로서 호출
var bar =obj.f;
console.log(bar());
 
//프로퍼티 f에 바인딩된 함수를 생성자 함수로서 호출
console.log(new obj.f()); // f {}

const obj = {
  x:1,
  // foo는 메서드다.
  foo() {return this.x;}
  // bar에 바인딩된 함수는 메서드가 아닌 일반 함수다.
  bar: function() {return this.x;}
};
 
console.log(obj.foo()); //1
console.log(obj.bar()); //1

const base = {
 name: 'Lee',
 sayHi() {
   return `Hi ${this.name}`;
 }
};
 
const derived = {
 __proto__: base,
 // sayHi는 ES6의 메서드다. ES6 메서드는 [[HomeObject]]를 갖는다.
 // sayHi의 [[HomeObject]]는 sayHi가 바인딩된 객체인 derived를 가리키고
 // super는 sayHi의 [[HomeObject]]의 프로토타입인 base를 가리킨다.
 sayHi() {
   return `${super.sayHi()}. how are you doing?`;
 }
}
 
console.log(derived.sayHi()); // Hi! Lee. how are you doing?

const derived = {
 __proto__:base,
 // sayHi는 ES6 메서드가 아니다.
 // 따라서 sayHi는 [[HomeObject]]를 갖지 않으므로 super 키워드를 사용할 수 없다.
 sayHi: function () {
   return `${super.sayHi()}. how are you doing?`;
 }
};

const create = (id,content) => ({id,content});
create(1,'JavaScript'); // -> {id: 1, content: "JavaScript"}
 
// 위 표현은 다음과 동일하다.
const create = (id,content) => {return {id,content};};

// {id,content}를 함수 몸체 내의 쉼표 연산자문으로 해석합니다.
const create = (id,content) => {id,content};
create(1,'JavaScript'); // -> undefined

//ES5
[1,2,3].map(function (v) {
 return v*2;
});
 
//ES6
[1,2,3].map(v => v*2); // -> [2,4,6]