// 빈 객체의 생성
const person = new Object();

// 프로퍼티 추가
person.name = 'Son';
person.sayHello = function() {
  console.log(`Hi! My name is ${this.name}`);
};

console.log(person);
person.sayHello;

// { name: 'Son', sayHello: [Function (anonymous)] }
// Hi! My name is Son

// String
const strObj = new String('Son');
console.log(typeof strObj);
console.log(strObj); // [String : "Son"]

// Number
const numObj = new Number(123);
console.log(typeof numObj);
console.log(numObj); // [Number : 123]

// Boolean
const boolObj = new Boolean(true);
console.log(typeof boolObj);
console.log(boolObj); // [Boolean: true]

// Function
const func = new Function('x', 'return x * x');
console.log(typeof func); // function
console.dir(func);

// Array
const arr = new Array(1, 2, 3);
console.log(typeof arr);
console.log(arr); // [1, 2, 3]

// RegExp
const regExp = new RegExp(/ab+c/i);
console.log(typeof regExp);
console.log(regExp); // /ab+c/i

// Date
const date = new Date();
console.log(typeof date);
console.log(date); // 2023-08-03T04:11:37.506Z

const circle1 = {
  radius: 5,
  getDiameter() {
    return 2 * this.radius;
  },
};

const circle2 = {
  radius: 10,
  getDiameter() {
    return 2 * this.radius;
  },
};

console.log(circle1.getDiameter()) // 10
console.log(circle2.getDiameter()) // 20

// 생성자 함수
function Circle(radius) {
  // 생성자 함수 내부의 this는 생성자 함수가 생성할 인스턴스를 가리킨다.
  this.radius = radius;
  this.getDiameter = function() {
    return 2 * this.radius;
  }
}

const circle1 = new Circle(5);
const circle2 = new Circle(10);

console.log(circle1.getDiameter()); // 10
console.log(circle2.getDiameter()); // 20

// new 연산자와 함께 호출하지 않으면 생성자 함수로 동작하지 않는다.
// 일반 함수로 호출됨
const circle3 = Circle(15);

console.log(circle3); // undefined

// 일반 함수로소 호출된 Circle 내의 this는 전역 객체를 가리킨다.
console.log(radius); // 15

function Circle(radius) {
  this.radius = radius;
  this.getDiameter = function() {
    return 2 * this.radius;
  }
}

const circle1 = new Circle(5);

// 함수는 객체다.
function foo() {};

// 함수는 객체이므로 프로퍼티를 소유할 수 있다.
foo.prop = 10;

// 함수는 객체이므로 메서드를 소유할 수 있다.
foo.method = function() {
  console.log(this.prop);
}

foo.method(); // 10

function foo() {};

// 일반적인 함수로서 호출: Call 호출
foo();

// 생성자 함수로서 호출: Construct 호출
new foo();

// 일반 함수 정의: 함수 선언문, 함수 표현식
function foo() {};
const bar = function() {};
// 프로퍼티 x의 값으로 할당된 것은 일반 함수로 정의된 함수다. 이는 메서드로 인정하지 않음
const baz = {
  x: function() {},
};

// 일반 함수로 정의된 함수만이 constructor.
new foo(); // foo {}
new bar(); // bar {}
new bar.x(); // x {}

// 화살표 함수 정의
const arrow = () => {};

new arrow(); // TypeError

// 메서드 정의: ES6 의 메서드 축약 표현만 메서드로 인정
const obj = {
  x() {},
};

new obj.x(); // TypeError:

// 생성자 함수로서 정의하지 않은 일반 함수
function add(x, y) {
  return x + y;
}

// 생성자 함수로서 정의하지 않은 일반 함수를 new 연산자와 함께 호출
let inst = new add();

// 함수가 객체를 반환하지 않았으므로 반환문이 무시된다. -> 빈 객체가 생성
console.log(inst); // {}

// 객체를 반환하는 일반 함수
function createUser(name, role) {
  return { name, role };
}

// 일반 함수를 new 연산자와 함께 호출
inst = new createUser('Son', 'admin');
// 함수가 생성된 객체 반환
console.log(inst); // { name: 'Son', role: 'admin' }

function Circle(radius) {
  this.radius = radius
  this.getDiameter = function() {
    return 2 * this.radius
  }
}

const circle1 = Circle(5);

console.log(circle1); // undefined

// 일반 함수 내부의 this는 전역 객체 window를 가리킨다.
console.log(radius); // 5
console.log(getDiameter()); // 10

circle1.getDiameter(); // TypeError

// 생성자 함수
function Circle(radius) {
  // 이 함수가 new 연산자와 함께 호출되지 않았다면 new.target은 undefined다.
  if (!new.target) {
    // new 연산자와 함께 생성자 함수를 재귀 호출하여 생성된 인스턴스를 반환한다.
    return new Circle(radius);
  }
  this.radius = radius;
  this.getDiameter = function() {
    return 2 * this.radius;
  }
}

// new 연산자 없이 생성자 함수를 호출하여도 new.target을 통해 생성자 함수로서 호출된다.
const circle = Circle(5);
console.log(circle.getDiameter()); // 10

let obj = new Object();
console.log(obj); // {}

obj = Object();
console.log(obj); // {}

let f = new Function('x', 'return x ** x');
console.log(f); // [Function: anonymous]

f = Function('x', 'return x ** x');
console.log(f); // [Function: anonymous]

const str = String(123);
console.log(str, typeof str); // 123 string

const num = Number('123');
console.log(num, typeof num); // 123 number

const bool = Boolean(1);
console.log(bool, typeof bool); // true boolean