Object

```javascript:qiita.js
// Object 객체는 서명된 파일이있는 캐비닛으로도 설명할수있다.
let user = new Object(); //"object constructor" syntax
let user = {}; // "object literal" syntax

// 객체리터럴
let user = {         // object
    name : 'john',   // key :name   store value 'john'
    age : 30         // key :age   store value 30
};
```

```javascript:qiita.js 
// 속성값접근
alert(user.name);
alert(user.age)

// 속성값제거
delete user.age;

// bool값 추가
user.isAdmin = true;

// 단어조합의 키값을 사용할때는 따옴표를 사용해야한다
let user = {
    name : 'john',
    age : 30,
    "likes birds" : true
}
// set, get, delete
let user = {};
//set
user["likes birds"] = true;
//get
alert(user["likes birds"]);
//delete
delete user["likes birds"];

// 키값 호출뒤 키값에 대응하는 value 보여줌
let user = {
    name : 'john',
    age : 30
}
let key = prompt("What do you want to know about the user?",name);
alert(user[key]);


// Property value shothand
function makeUser(name, age) {
    return {
        name : name,
        age : age
    }
}
let user = makeUser('john',30);
alert(user.name);

function makeUser(name, age) {
    return {
        name,
        age
    }
}

let user = {
    name, // name : name
    age : 30
}

// Existence check

let user = {};
alert(user.noSuchPropery ===undefined) // true

// 키값 존재여후 확인
"key" in object

let user = {name: 'john', age: 30};
alert("age" in user); //true
alert("blabla" in user); //false

let user = {age: 30};
let key = "age";
alert(key in user); //true


// Existence check

let user = {};
alert(user.noSuchPropery ===undefined) // true

// 키값 존재여후 확인
"key" in object

let user = {name: 'john', age: 30};
alert("age" in user); //true
alert("blabla" in user); //false

let user = {age: 30};
let key = "age";
alert(key in user); //true

// undefined 속성값 사용
let obj = {
    test : undefined
}
alert(obj.test); //undefined
alert("test" in obj); //true
```

```javascript:qiita.js
// The “for…in” loop
for(key in object) {
    //...
}

let user = {
    name : "john",
    age : 30,
    isAdmin : true
}

for(let key in user ) {
    
    alert(key); // name, age, isAdmin
    alert(user[key]) // "john", 30, true
}
```
```javascript:qiita.js
//Ordered like an object
let codes = {
    "49": "Germany",
    "41": "Swizerland",
    "44": "Great Britain",
    // ..,
    "1": "USA"
}

// code 값을 가져오지만 정수로 변환되어 오름차순으로 출력된다.
for(code in codes) {
    alert(code); // 1,41,44,49
}

// Math.trunc() 함수는 주어진 값의 소수부분을 제거하고 숫자의 정수부분을 반환합니다.
// Math.trunc is a built-in function that removes the decimal part
alert(String(Math.trunc(Number("49"))));//"49", same, integer property
alert(String(Math.trunc(Number("+49"))));
alert(String(Math.trunc(Number("1.2"))));

// 정수가 아닌경우 생성된 순서대로 호출한다
let user = {
    name : "John",
    surname : 'Smith'
}
user.age = 25;

for(let prop in user) {
    alert(prop); // name, surname, age
}
// 속임수를 써서 원하는 순서대로 정렬
let codes = {
    "+49": "Germany",
    "+41": "Switzerland",
    "+44": "Great Britain",
    // ..,
    "+1": "USA"
}

for(let code in codes) {
    alert(+code); // 49, 41, 1
}
```
```javascript:qiita.js
// 객체와 프리미티브 복사의 차이
let message = "hello";
let phrase = message;

let user = {
    name: "John"
}
let admin = user; // copy reference
//두 개의 변수를 가지며, 각 변수는 동일한 객체에 대한 참조를가집니다.

let user = {name: "John"};
let admin = user;

admin.name = "Pete";
alert(user.name); // Pete
// 변수를 이용하여 객체에 접근 값을 변경할수 있다.

let a = {};
let b = a;
alert(a == b);// true
alert(a === b);// true

let a = {};
let b = {}; // 독립된 두개의 객체
alert(a == b); //false
```
```javascript:qiita.js
// Const 객체
const user = {
    name: "John"
}
user.age = 25
alert(user.age) // 25
/*라인 (*)이 오류를 일으키는 것처럼 보일 수도 있지만, 
전혀 문제가 없습니다. 
그것은 그 자체 const의 가치를 고정시키기 때문 user입니다. 
그리고 여기 user에는 항상 같은 객체에 대한 참조가 저장됩니다. 
선 (*)은 객체 내부 로 들어가고 재 할당하지 않습니다 */


const user = {
    name: "John"
}
user.name = "Pete";
alert(user.name);


/***************** 이부분 잘 모름 ********************/
const user = {
    name: "John"
}
// user = {
//     name: "Pete"
// }
user.name = "Pete";
user.age = 30;
alert(user.name + user.age)
/***************** 이부분 잘 모름 ********************/

// 복제 및 병합
let user = {
    name: "John",
    age: 30
}

let clone = {};
for(let key in user){
    clole[key] = user[key];
}
// 독립된 clone 이다
clone.name = "Pete";
alert(user.name); // John

let user = {name: "john"};

//Object.assign  병합

let user = {name: "John"};

let permissions1 = {canView: true};
let permissions2 = {canEdit: true};

Object.assign(user, permissions1, permissions2);
for(let key in user) {
    alert(key); // name, canView, canEdit
    alert(user[key]); // John, true,true
}

// 받는 객체가 동일한 속성을 가지고 있을경우에는 덥어쓴다
let user = {name: "John"};
//overwrite name, add admin
Object.assign(user, {name: "Pete", isAdmin:true});

//모든 속성을 user빈 객체에 복사 하여 반환합니다. 사실 루프와 같지만 짧습니다.
let user = {
    name: "John",
    age: 30
}
let clone = Object.assign({}, user);
alert(user.name);
alert(clone.name);

//user 는 원시적이나 어떤객체에 대한 참조일 수 있다.
let user = {
    name: "John",
    size: {
        height: 182,
        width: 50
    }
}

let user = {
    name: "John",
    sizes: {
        height: 182,
        width: 50
    }
}

let clone = Object.assign({}, user);
user.sizes.width++;
alert(clone.sizes.width); // 51 같은객체를 참조하고 있으므로 값은 같다
alert(user.size.height); //182
```
```javascript:qiita.js
//객체에 속성이 없으면 isEmpty(obj) true, 
//그렇지 않으면 반환합니다.false
function isEmpth(obj) {
    for(let key in obj) {
        return false;
    }
    return true;
}

let schedule = {};
alert(isEmpth(schedule)); // true 속성이 존재하지 않는다.
schedule["8:30"] = "get up"; // 속성입력
alert(isEmpth(schedule)); // false  속성이 존재한다
```
```javascript:qiita.js
let salaries = {
    John: 100,
    Ann: 160,
    Pete: 130
}

// 급료의 합을 계산하기 급료가 없으면 0
let sum =0;

for(let key in salaries) {
    sum += salaries[key];
}
alert(sum);
```
```javascript:qiita.js
let menu = {
    width: 200,
    height: 300,
    title: "My menu"
}
multiplyNumeric(menu);

menu = {
    width: 400,
    height: 600,
    title: "My menu"
}

function multiplyNumeric(obj) {
    for(let key in obj ) {
        if(typeof obj[key] == 'number') {
            obj[key] *=2
        }
    }
}
```