chapter21. 객체 프로퍼티 설정과 프락시

// setEmail과 getEmail메서드가 있다.
//@가 들어있는 문자열은 모두 유효한 이메일 주소라고 간주
const USER_EMAIL = Symbol();
class User {
  setEmail(value) {
    if (!/@/.test(value)) throw new Error(`invalid email ${value}`);
    this[USER_EMAIL] = value;
  }
  getEmail() {
    return this[USER_EMAIL];
  }
}

//이 클래스는 다음과 같은 방식으로 사용해야함
const u = new User();
u.setEmail("join@dot.com");
console.log(`${u.getEmail()}`);

//그러나 우리는 이 방식을 더 자연스럽게 느낌
const u = new User();
u.email = "join@dot.com";
console.log(`${u.getEmail()}`);

//접근자 프로퍼티를 사용하여 이메일 체크
const USER_EMAIL = Symbol();
class User {
  set email(value) {
    if (!/@/.test(value)) throw new Error(`invalid email ${value}`);
    this[USER_EMAIL] = value;
  }
  get email(value){
    return this[USER_EMAIL];
  }
}

class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }
  get perimeter() {
    return this.width * 2 + this.height * 2;
  }
}

const obj = { foo: "bar" };
Object.getOwnPropertyDescriptor(obj, "foo");
//{value: "bar", writable: true, enumerable: true, configurable: true}

//읽기 전용 프로퍼티에 값을 할당하려고할 때 에러가 발생하는것은 스트릭트 모드에서 뿐이다.
"use strict";
Object.defineProperty(obj, "foo", { writable: false });

//foo에 값을 할당하려고 하면 오류가 난다.
obj.foo = 3;

//VM121:7 Uncaught TypeError: Cannot assign to read only property 'foo' of object '#<Object>'

//obj에 color프로퍼티를 추가해보기
Object.defineProperty(obj, "color", {
  get: function() {
    return this._color;
  },
  set: function(value) {
    this._color = value;
  }
});

obj.color = "red";
console.log(obj);

//{foo: "bar", _color: "red"}

//obj에 name 과 greet 프로퍼티를 추가해보기
Object.defineProperty(obj, "name", {
  value: "cynthia"
});
Object.defineProperty(obj, "greet", {
  value: function() {
    return `hello my name is ${obj.name}`;
  }
});

console.log(obj.name); //cynthia
console.log(obj.greet()); //hello my name is cynthia

//배열에 sum와 avg 메서드를 추가하는 경우
const arr = [3, 1.5, 9, 2, 5.2];
arr.sum = function() {
  return this.reduce((a, x) => a + x);
};
arr.avg = function() {
  return this.sum() / this.length;
};

//  for...in문이나 Object.keys, 확산 연산자에서 객체 프로퍼티를 나열할 때 해당 프로퍼티가 포함될지 아닐지 판단
Object.defineProperty(arr, "sum", { enumerable: false });
Object.defineProperty(arr, "avg", { enumerable: false });

Object.keys(arr);

//Object.defineProperties
const arr = [3, 1.5, 9, 2, 5.2];
Object.defineProperties(arr, {
  sum: {
    value: function() {
      return this.reduce((a, x) => a + x);
    },
    enumerable: false
  },
  avg: {
    function() {
      return this.sum() / this.length;
    },
    enumerable: false
  }
});

//## 21.3 객체 보호 : 동결, 봉인, 확장 금지
"use strict";
const appInfo = {
  company: "white knight software, Inc",
  version: "1.3.5",
  buildId: "padddddddddddddddddd",
  //이 함수는 getter이므로 동결한 상태에서도 계속 동작한다.
  copyright() {
    return `${new Date().getFullYear()},${this.company}`;
  }
};

Object.freeze(appInfo); //동결
Object.isFrozen(appInfo); //true

appInfo.newPro = "test";
//VM3275:16 Uncaught TypeError: Cannot add property newPro, object is not extensible

delete appInfo.company;

appInfo.company; //"white knight software, Inc"

Object.defineProperty(appInfo, "company", { enumerable: false });
//VM3316:2 Uncaught TypeError: Cannot redefine property: company...

//객체 봉인
class Logger {
  constructor(name) {
    this.name = name;
    this.log = [];
  }
  add(entry) {
    this.log.push({
      log: entry,
      timestamp: Date.now()
    });
  }
}
const log = new Logger("Logs");
Object.seal(log);
Object.isSealed(log); //true

log.name = "capting boring log"; //ok
log.add("another boring day at sea..."); //ok

log.newPro = "test";
//TypeError: Cannot add property newPro, object is not extensible

log.name = "test";

delete log.name; //VM4096:23 Uncaught TypeError: Cannot delete property 'name' of #<Logger>

Object.defineProperty(log, "log", { enumerable: false });
//Uncaught TypeError: Cannot redefine property: log...

"use strict";
class Logger {
  constructor(name) {
    this.name = name;
    this.log = [];
  }
  add(entry) {
    this.log.push({
      log: entry,
      timestamp: Date.now()
    });
  }
}
const log2 = new Logger("First Mate's log");
Object.preventExtensions(log2);
Object.isExtensible(log2); //false

log2.name = "first.."; //true
log2.add("another..."); //true

log2.newPro = "test"; //VM5050:18 Uncaught TypeError: Cannot add property newPro, object is not extensible

log2.name = "test.."; //true
delete log2.name; //true
Object.defineProperty(log, "log", { enumerable: false });
// Uncaught TypeError: Cannot redefine property: log...

const cofficients = {
  a: 1,
  b: 2,
  c: 5
};
//이 객체의 프로퍼티가 수학의 계수라면
function evaluate(x, co) {
  return co.a + co.b + co.c * Math.pow(x, 2);
}

evaluate(4, cofficients); //83

//그런데,
//계수 일부가 빠진 객체를 가지고 계산해야한다면?
const cofficients = {
  a: 1,
  c: 5
};
evaluate(4, cofficients); //NaN

//cofficients.b에 0을 할당하면 문제를 해결할수 있지만 프락시를 쓰는 게 더 낫다.
//프락시는 정의되지 않은 프로퍼티는 항상 0을 반환하게 만들 수 있다.

//cofficients에 객체의 프락시 생성
const betterCofficients = new Proxy(cofficients, {
  get(target, key) {
    return target[key] || 0;
  }
});
evaluate(4, cofficients); //NaN
evaluate(4, betterCofficients); //81

//betterCofficients 객체의 프락시에는 무한한 프로퍼티가 있고,
//직접 정의한 프로퍼티를 제외하면 값이 0인것과 마찬가지이다.
betterCofficients.a; //1
betterCofficients.b; //0
betterCofficients.c; //5
betterCofficients.d; //0

//키로 소문자 한 글자만 받았을때 프락시가 동작하게 할 수도 있다.
const betterCofficients = new Proxy(cofficients, {
  get(target, key) {
    if (!/^[a-z]&/.text(key)) return target[key];
    return target[key] || 0;
  }
});

//객체에 위험한 프로퍼티가 있어서,
//한 단계를 더 거치지 않으면 값을 할당하거나 메서드를 호출할수 없게함
const cook = {
  name: "Wait",
  redPhosphours: 100, //위험하다고
  water: 500 //안전하다고
};
const protectCook = new Proxy(cook, {
  set(target, key, value) {
    if (key === "redPhosphours") {
      if (target.allowDangerousOperations)
        return (target.redPhosphours = value);
      else return console.log("Too dangerous");
    }

    //다른 프로퍼티는 모두 안전함
    target[key] == value;
  }
});
protectCook.water; //500
protectCook.redPhosphours; //100

protectCook.redPhosphours = 150; //Too dangerous
protectCook.allowDangerousOperations = true; // true