function calcArea(r) {
    return r * r * Math.PI;
  }

  let circle = {
    radius: 200,
    backgroundColor: 'blue',
    area: function() {
      return this.radius * this.radius * Math.PI;
    }
  };

  let area1 = calcArea(circle.radius);
  let area2 = circle.area();

  console.log(area1, area2);

let circle = {
  A: 10,
  get a(){
    return this.A;
  }, // 2. 함수 앞에 get 
  set b(x){
    if(typeof x !== number) return;
    this.A = x;
  }, // 4. 함수 앞에 set
  _radius: 200,
  backgroundColor: 'blue',
  get area() {
    return this.radius * this.radius * Math.PI;
  },
  get radius() {
    return this._radius;
  },
  set radius(r) {
    if (typeof r === 'number') {
      this._radius = r;
    }
  }
};

let area = circle.area;

circle.radius = '100';

console.log(circle);

circle.a * 10; // 1. 사용자한테 함순지 변순지 안알려주고싶고.. 그럼 앞에 get 하면댐
circle.b = 10; // 3. 넣을때 set.. 

A = 10; // 복사
B = {}; // 참조 {}은 300의 위치값에 있다. 300값 참조하기

a = {x: 10}; // 500번재의 위치값의 객체 참조
b = a; // 복사

b.x = 50; // console.log(50)
a.x; // 50 나옴 왜냐면 같은 500번째의 객체를 참조하고있기때문에.. 객체의 양은 늘어나지 않음.

// 복사

let x1 = 10;
let y1 = 10;

let x2 = x1;
let y2 = y1;

console.log(x1, x2);

x2 = 100;

console.log(x1, x2);

// x1, x2는 서로 연관이 없고 각각 개별의 값. 복사돼기때문에

// 참조

let x1 = { value: 10 };
let y1 = { value: 10 };

let x2 = x1;
let y2 = y1;

x2.value = 100;

console.log(x1);

function double(v, o) {
  v = v * 2;
  o.value = o.value * 2;
}

let p1 = 100;
let p2 = { value: 100 };

double(p1, p2);

console.log(p1, p2);

// p1은 복사가 일어났고
// p2는 참조가 일어남

function double(v, o) {
  v = v * 2;
  o = {value: 10};
}

let p1 = 100;
let p2 = { value: 100 };

double(p1, p2);

console.log(p1, p2);

// 위치값이 들어가는데 o의 새로 만든 객체는 안바껴용

var title = '전역 스코프';

function displayTitle() {
  var title = '함수 스코프';

  if (title) {
    let title = '블럭 스코프';

    console.log(title);
  } // 조건문안의 블럭 스코프도 유효해졌음
  
  console.log(title);
}

displayTitle();
console.log(title);

var days = ['월','화','수']; // 배열을 순회할 때 위치값이 필요..
// var라는 키워드는 함수스코프 또는 전역스코프에 변수를 만드는 명령어

for(var i=0; i<days.length; i++) {
  console.log(days[i]); // var i 는 전역스코프에 만들게 됌. 
}

console.log(i); // 그래서 i가 전역스코프에 존재하게됌. 자원을 효과적으로 쓸 수 없음.

for(let j=0; j<days.length; j++) {
  console.log(days[j]); 
  // var의 전역스코프에 뿌려지는 매카니즘 방지하고 자원을 효과적으로 관리할 수 있음
}

console.log(j); // let 이라는 명령어는 블록스코프에 유효범위가 존재함

function displayPerson() {
  console.log(`name : ${name}`);
  console.log(`age : ${age}`);
  
  var name = '홍길동'; // undefined 
  // 함수스코프가 만들어진 다음에 함수안에 있는 코드를 스캔한 담에
  // var로 만드는 변수가 있으면 var name; 이렇게 만들어버림 (호이스팅 = 끌어올림)

  let age = 25;
  // 
}

displayPerson();

function makeUnit(unit) { // 생성시 생성시점
  return function(value) {
    return `${value}${unit}`;
  }
} // 참조 가능한 알려진 변수 = 스코프

let px = makeUnit('px');
let em = makeUnit('em');

console.log(px(11));
console.log(px(24));
console.log(em(32));

  this;
  // 전역객체 window

let counter = {
  count: 0,
  increment() {
    this.count++;

    // 이 this는 "소유자 객체가 확인될 때"
    // increment() 메소드를 소유하고 있는 객체는 counter.
    // 소유자 확인은 실행하는 순간에 함.
    // counter의 increment() 메소드를 호출할 때 소유자 확인을 함.
  }
};

counter.increment();

console.log(counter.count); // 일때는 1이 됌
// ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

// 변수를 만들어서담을때
let inc = counter.increment;

counter.increment();
inc(); // 실행하는 시점에 소유자가 등장하지않기때문에, 소유자를 모르니 count++ 안댐
// 즉, 실행 맥락상 this가 달라진다..
// 콜백함수를 실행해야할 때 이런 방법을 사용해서 할수밖에 없다

console.log(counter.count);
// ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
function foo(fn){
  fn();
}

foo(counter.increment);
// 이런식으로하면 this를 잊어버리는 일이 비일비재하다.
// 그래서 this를 원하는대로 조작하거나 보정하는 방법을 배워야한다.

// this를 내가 원하는 형태로 조작하는 방법 함수명.call() / 함수명.apply()
counter.increment();
let inc = counter.increment;
let yourCounter = {count: 10};

inc();
inc.call(counter); // 이렇게 첫번째 인자에
inc.apply(yourCounter); // this를 내가 원하는 객체로 지정할 수 있다.

console.log(counter.count);

// ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ

let counter = {count: 0};
let yourCounter = {count: 10};
let arg = [10, 20];

function increment(){
  this.count++;
}

function increment02(x,y){
  this.count = this.count + 1 + x + y;
}

increment.call(counter);
increment.call(yourCounter);

increment02.call(counter, 10, 20); // 하드코딩
increment02.apply(counter, [10, 20]); // 배열이면 코드가 아니고 외부로부터 데이터를 받을 때.. 

increment02.apply(counter, arg); // 이렇게 외부로부터 배열형태로 받게돼면 전달하는 방식이 apply 

//call 과 apply는 똑같음.
//전달인자의 형태에 따라 다름

counter.increment = counter.increment.bind(counter);
// increment 메소드에 this가 가르치고있는 객체를 counter로 고정하고싶으면 bind로 묶음

counter.increment();
let inc = counter.increment;

inc();
inc();
inc();

console.log(counter.count);