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
};
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
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
}
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
}
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
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
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 속성이 존재한다
qiita.js
let salaries = {
John: 100,
Ann: 160,
Pete: 130
}
// 급료의 합을 계산하기 급료가 없으면 0
let sum =0;
for(let key in salaries) {
sum += salaries[key];
}
alert(sum);
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
}
}
}