Object 방법 총화

1. Object. assign (target, source, source 2...) 은 하나 이상 의 대상 을 복사 하여 새로운 대상 을 만 듭 니 다.
원본 대상 (source) 의 모든 매 거 진 속성 을 대상 (target) 으로 복사 합 니 다.복사 한 속성 은 제한 이 있 습 니 다. 원본 대상 의 자체 속성 만 복사 합 니 다 (복사 하지 않 고 계승 속성). 셀 수 없 는 속성 도 복사 하지 않 습 니 다 (enumerable: false)
동명 속성 은 뒤의 원본 대상 속성 에 덮어 씁 니 다.
깊 은 복사 가 아니 라 얕 은 복사 가 실행 된다.

let obj1 = {
    a:1,
    b:2,
}
let obj2 = {
    a:3,
    b:4,
}
let obj3 = {
    e:1,
    f:2,
}
let newObj = Object.assign(obj1,obj2,obj3)
console.log(newObj)// {a: 3, b: 4, e: 1, f: 2}
console.log(obj1)// {a: 3, b: 4, e: 1, f: 2}

let obj4 = {
    a: {b:1}
}
let obj5 = {
    c:2
}
let newObj2 = Object.assign(obj4,obj5)
console.log(newObj2) // {a: {b: 1},c: 2}
obj4.a.b = 3
console.log(newObj2)// {a: {b: 3},c: 2}

let obj6 = {a: 1}
console.log(Object.assign(obj6, null)) // {a: 1}
console.log(Object.assign(obj6, undefined)) // {a: 1}

console.log(Object.assign(null, obj6)) 
console.log(Object.assign(undefined, obj6)) // {a: 1}
// Uncaught TypeError: Cannot convert undefined or null to object

2 Object. create (proto, propertiesObject) 이 방법 은 새로운 대상 을 만 드 는 데 사 용 됩 니 다.생 성 된 대상 은 다른 대상 (proto) 의 원형 을 계승 합 니 다. 새 대상 을 만 들 때 일부 속성 (propertiesObject) 을 지정 할 수 있 습 니 다. 기본 새 대상 의 속성 은 셀 수 없 으 며 변경 할 수 없습니다.
기 존 대상 을 계승 하지 않 고 새로운 대상 을 만 들 려 면 proto 를 null 로 설정 해 야 합 니 다.

let obj = Object.create({a:1}, {b:3})
// Uncaught TypeError: Property description must be an object: 3
let obj = Object.create({a:1}, {b:{value:2}})
console.log(obj) // {b: 2}
console.log(obj.a) // 1
obj.b = 3
console.log(obj.b) // 2
console.log(Object.keys(obj))// []


let obj2 = Object.create(null,{a:{
    value: 2,       //    
    writable: true,     //         
    enumerable: true,   //     
    configurable: true  //            
}})

console.log(obj2)//{a: 2}
obj2.a=3
console.log(obj2)// {a: 3}
Object.keys(obj2)// ["a"]

3. Object. defineProperty (object, prop, descriptor) 는 대상 (object) 에 속성 (prop) 을 추가 하고 이 속성의 설정 (descriptor) 을 지정 합 니 다.
Object. defineProperties (object, {prop 1: descriptor 1, prop 2: descriptor 2,...) 대상 에 여러 속성 을 추가 하고 속성 을 지정 하 는 설정
          1. 첫 번 째 매개 변 수 는 대상 이 어야 합 니 다.
           2. descriptor 는 (value 또는 writable 특성) (get 또는 set 특성) 을 동시에 가 질 수 없습니다.
          3. configurable 이 false 일 때 장식 기 를 다시 수정 할 수 없습니다.

var obj = {};
Object.defineProperty(obj, "newDataProperty", {
    value: 101,
    writable: true,
    enumerable: true,
    configurable: true
});
 
Object.defineProperty(obj, "newAccessorProperty", {
    set: function (x) {
        this.otherProperty = x;
    },
    get: function () {
        return this.otherProperty;
    },
    enumerable: true,
    configurable: true
});

var obj2 = {};
Object.defineProperties(obj2, {
  'property1': {
    value: true,
    writable: true
  },
  'property2': {
    value: 'Hello',
    writable: false
  }
});

4. Object. values (obj) 는 매 거 진 속성 값 을 옮 겨 다 니 며 대상 자체 가 매 거 진 속성 값 만 포함 하고 원형 체인 이 매 거 진 속성 값 을 포함 하지 않 으 며 속성 값 을 되 돌려 주 는 배열 입 니 다.
5. Object. keys () 는 매 거 진 속성 을 옮 겨 다 니 며 대상 자체 의 매 거 진 속성 만 포함 하고 원형 체인 의 매 거 진 속성 은 포함 되 지 않 습 니 다.

let arr = ["a", "b", "c"];
let obj = { foo: "bar", baz: 42 };
let ArrayLike = { 0 : "a", 1 : "b", 2 : "c"};

Object.keys(arr)        // ['0', '1', '2']
Object.keys(obj)        // ["foo","baz"]
Object.keys(ArrayLike)  // ['0', '1', '2']

Object.values(arr)        // ["a", "b", "c"]
Object.values(obj)       // ["bar",42]
Object.values(ArrayLike) // ["a", "b", "c"]

 
6. Object. getPrototypeOf (obj) 지정 한 대상 (obj) 의 원형 (내부 [Prototype]] 속성의 값) 가 져 오기
7. Object. setPrototypeOf (obj, proto) 지정 한 대상 (obj) 의 원형 (proto) 을 설정 합 니 다.
 
8. Object. entries (obj) 는 주어진 대상 자체 가 매 거 진 속성 을 가 진 [key, value] 배열 을 되 돌려 줍 니 다.

let obj = {
    a:1,
    b:2,
}
let arr = Object.entries(obj)
console.log(arr)  // [["a", 1],["b", 2]]

9. Object. freeze (obj) 동결 대상: 다른 코드 는 속성 을 삭제 하거나 변경 할 수 없습니다. 새로운 속성 을 추가 할 수 없습니다. 기 존 속성의 값 을 수정 할 수 없습니다. 기 존 속성 을 삭제 할 수 없습니다. 기 존 속성의 매 거 성, 설정 성, 쓰기 성 을 수정 할 수 없습니다. 즉, 이 대상 은 영원히 변 할 수 없습니다.
10. Object. isFrozen () 은 한 대상 이 동결 되 었 는 지 판단 한다.
11. Object. preventExtensions (obj) 는 대상 을 확장 할 수 없 게 만 듭 니 다. 즉, 새로운 속성 을 영원히 추가 할 수 없습니다.
12. Object. isExtensible (obj) 은 대상 이 확장 가능 한 지 여 부 를 판단 합 니 다.

let o = {a: 1}

o.b = 2      //    b  
Object.freeze(o)

Object.isFrozen(o)    //true       

o.a = 2       //    a   
o.c = 5       //    c  
delete o.b   //    b  

//                    configurable: false, writable: false，         
let o2 = {a: 1}
o2.b = 2     //     b  
Object.priventExtensions(o2)
Object.defineProperties(o2, {
    a: {configurable: false, writable: false},
    b: {configurable: false, writable: false}
})

Object.isFrozen(o2)    //true o4      


// freeze()      ，                       freeze()  
let obj = {
    internal :{}
};
Object.freeze(obj);//   
obj.internal.a = "aValue";
console.log(obj.internal.a);//"aValue"
    
    
function deepFreeze(o){
   var prop,propKey;
    Object.freeze(o);//         
    for(propKey in o){
        prop = o[propKey];
        if(!o.hasOwnProperty(propKey) || !(typeof prop === "object") || Object.isFrozen(prop)){
            continue;
        }
        deepFreeze(prop);//  
    }
}
    
deepFreeze(obj);
obj.internal.b = "bValue";//    
console.log(obj.internal.b);//undefined

13. Object. seal (obj) 은 대상 을 밀봉 하여 새로운 속성 을 추가 할 수 없고 기 존 속성 을 삭제 할 수 없 으 며 기 존 속성의 매 거 성, 설정 성, 쓰기 성 을 수정 할 수 없 지만 기 존 속성의 값 을 수정 할 수 있 습 니 다.
14. Object. is Sealed 는 한 대상 이 밀봉 되 었 는 지 판단 한다.

var o = {b: 1}
o.d = 2    //    
var obj = Object.seal(o);
obj === o         //true         ，          
Object.isSealed(o)   // true
o.b = 111       //  b     
o.f = 222       //    ,  f      
delete o.b      //    ,  b      

//      Object.preventExtensions         。        
let o1 = {};
Object.isSealed(o1)    //false
Object.preventExtensions(o1);
Object.isSealed(o1)    // true

//       Object.preventExtensions         ,
//         configurable: false。        
let o2 = {a: 1}
Object.preventExtensions(o2);
Object.isSealed(o2)    //false
Object.defineProperty(o2, "a", { configurable: false });
Object.isSealed(o2)    //true

 
15. Object. is () 는 두 값 이 같은 지 비교 합 니 다. 모든 NaN 값 이 같 습 니 다 (이것 은 = = 과 = = 이 다 릅 니 다)

Object.is('foo', 'foo')     // true
Object.is({}, {})           // false

//     ===   
+0 === -0                   //true
NaN === NaN                 //false

Object.is(+0, -0)           // false
Object.is(NaN, NaN)         // true

16. obj. hasOwnProperty (prop) 방법 은 불 값 을 되 돌려 주 고 대상 자체 속성 에 지정 한 속성 이 있 는 지 여 부 를 표시 합 니 다.

let o = {a: 1 }
o.hasOwnProperty('a')   //true
o.hasOwnProperty('b')   //false           b
o.hasOwnProperty('toString');  //false               


//                ，  ：
var buz = {
    fog: 'stack'
};

let ownProp = []
for (var name in buz) {
    if (buz.hasOwnProperty(name)) {
       ownProp[name]
    }
}