Object

Syntax

オブジェクトの2つの形式.
構造がpropertyを追加できる以外は同じです.

//literal
var obj = {
	key: value,
};
// constructed form
var myObj = new Object();
myObj.key = value;

Type

language types

string

number

boolean

null

undefined

object

Built-in Objects

object sub-types

String

Number

Boolean

Object

Function

Array

Date

RegExp

Error

実はbuild-in関数です.コンストラクション関数として使用できます.(newを使用して新しい構造のオブジェクトを作成)

var strPrimitive = "I am a string";
typeof strPrimitive;	// "string"
strPrimitive instanceof String;	// false

var strObject = new String( "I am a string" );
typeof strObject; 	  // "object"
strObject instanceof String;		// true

// inspect the object sub-type
Object.prototype.toString.call( strObject );	// [object String]

「hi」はオブジェクトではありませんが、ここで作業するにはStringオブジェクト(長さ、コンテンツアクセス)が必要な場合があります.幸いなことに、必要に応じて自動的に接続されます.
number,booleanなども,null,undefinedにwrapper formがない場合,Dateなどの場合は構造のobject formでしか生成できない.
もっと解釈形式の選択肢がありますが、必要でない場合は使用しないでください.
エラーは通常自動的に生成されます.

Contents

オブジェクトのpropertyはvalueを格納するポインタを指すようになります.(所属ではなく).[""]を利用して近づくことができます.
property名は常にstringです.他のタイプを使用しても自動的に変更されます.

Computed Property Names

literal宣言では、key-name位置に[]で囲まれ、式を使用して名前を付けることができます.
さらに、より一般的な使用はSymbolです.簡単に言えば、推測できないstringタイプに名前を付けます.

var myObject = {
	[Symbol.Something]: "hello world"
};

Property vs. Method

オブジェクト内の関数をメソッドと呼びます.

Arrays

arrayをobjectに書くのに何の役に立つの?

var myArray = [ "foo", 42, "bar" ];

myArray.baz = "baz";

myArray.length;	// 3

myArray.baz;	// "baz"
//["foo", 42, "bar", baz: "baz"]
var myArray = [ "foo", 42, "bar" ];

myArray["3"] = "baz";

myArray.length;	// 4

myArray[3];		// "baz"
//["foo", 42, "bar", "baz"]

Duplicating Objects

function anotherFunction() { /*..*/ }

var anotherObject = {
	c: true
};

var anotherArray = [];

var myObject = {
	a: 2,
	b: anotherObject,	// reference, not a copy!
	c: anotherArray,	// another reference!
	d: anotherFunction
};

anotherArray.push( anotherObject, myObject );

浅いコピーの場合、aは2にコピーされますが、残りは既存のオブジェクトの参照に直接インポートされます.
deepcopyの場合、myObjectだけでなく、他のObject、他のArrayもコピーされ、参照がループされます.deep copy..
JSONメソッド

var newObj = JSON.parse( JSON.stringify( someObj ) );

Object.assign()は浅いコピーができます.

var newObj = Object.assign( {}, myObject );

newObj.a;						// 2
newObj.b === anotherObject;		// true
newObj.c === anotherArray;		// true
newObj.d === anotherFunction;	// true

Property Descriptors

var myObject = {
	a: 2
};

Object.getOwnPropertyDescriptor( myObject, "a" );
// {
//    value: 2,
//    writable: true,
//    enumerable: true,
//    configurable: true
// }
var myObject = {};
//보통 사용하지 않음
Object.defineProperty( myObject, "a", {
	value: 2,
	writable: true,
	configurable: true,
	enumerable: true
} );

myObject.a; // 2

Writable

var myObject = {};

Object.defineProperty( myObject, "a", {
	value: 2,
	writable: false, // not writable!
	configurable: true,
	enumerable: true
} );

myObject.a = 3;
//"use strict"; TypeError// setter와 비슷.

myObject.a; // 2

Configurable

このセクションがfalse(strict modeに関係なく)の場合、definedPropertyを使用するとタイプエラーが発生します.キャンセル不可.
でも.falseであっても、書き込み可能性をtrueからfalseに変換できます.反対はあり得ない.deleteを止めることができますdeleteは他の言語のようにメモリを解放するのではなく、消去可能なオブジェクト属性をクリアします.

myObject.a;				// 2
delete myObject.a;
myObject.a;				// 2

Enumerable

リストできますか...

Immutability

propertyに他の参照が含まれている場合は、propertyが変更できない場合でも値を変更できます.

Object Constant

writable:false && configurable:false

Prevent Extensions

オブジェクトの内部に変化がないようにするには、「Object.preventExtensions(객체)」を選択します.strictモードで試した場合、タイプエラー

Seal

Object.seal()密封対象物を製造する.すなわち、Object.preventExtensions(객체)およびconfigurable:falseが適用される.

Freeze

Object.freeze() sealにwritable:falseを追加しますが、最初に説明したように、参照されるオブジェクトは影響を受けません.

[[Get]]

var myObject = {
	a: 2,
	c: undefined
};

myObject.a; // 2
myObject.b; // undefined// No Error
myObject.c; // undefined// 윗줄과 결과가 똑같은데 어떻게 구별?

実は[[Get]]()でやっている動作です.初期リクエスト名のプロパティについてオブジェクトプロパティ調査を行い、見つかった場合はvalueを返します.「undefined」returnが見つからない場合

[[Put]]

既存または新しいプロパティ設定方法を制御します.
propertyが存在する場合、
1. Is the property an accessor descriptor? そうなるとsetter call
2. Is the property a data descriptor with writable of false? 殴られたら失敗する
3.その他の場合、正常に動作します.

Getters & Setters

ES 5から、オブジェクトレベルではなくgetter、setterを使用して属性レベルのデフォルト操作を上書きできます.
getterは関数を呼び出して値を検索し、setterは関数を呼び出して値を設定します.
このようなgetterまたはsetterを属性として定義する場合は「accessor記述子」と呼ばれ、この場合value、writableは無視され、JSはget、setが使用されます.

var myObject = {
	// define a getter for `a`
	get a() {
		return 2;
	}
};

Object.defineProperty(
	myObject,	// target
	"b",		// property name
	{			// descriptor
		// define a getter for `b`
		get: function(){ return this.a * 2 },

		// make sure `b` shows up as an object property
		enumerable: true
	}
);

myObject.a; // 2

myObject.b; // 4

myObject.a = 3;//setter가 유효하다고 하더라도 .... 결과는 아래와 같다.

myObject.a; // 2

getterとsetter

var myObject = {
	// define a getter for `a`
	get a() {
		return this._a_;
	},

	// define a setter for `a`
	set a(val) {
		this._a_ = val * 2;
	}
};

myObject.a = 2;

myObject.a; // 4

Existence

さっき上が本当になかったのか、それとも値が定義されていないのかをどのように区別しますか?
inは、プロパティが[PRODetype]レベルに存在するかどうか、およびオブジェクトに存在するかどうかを示します.(property name)hasOwnProperty()は後者です.これは対象です.Prototypeに接続されているObjectcreate(null)を使用すると失敗します.正確にはObject.prototype.hasOwnProperty.call(myObject,"a")です.

var myObject = {
	a: 2
};

("a" in myObject);				// true
("b" in myObject);				// false

myObject.hasOwnProperty( "a" );	// true
myObject.hasOwnProperty( "b" );	// false

Enumeration

var myObject = { };

Object.defineProperty(
	myObject,
	"a",
	// make `a` enumerable, as normal
	{ enumerable: true, value: 2 }
);

Object.defineProperty(
	myObject,
	"b",
	// make `b` NON-enumerable
	{ enumerable: false, value: 3 }
);

myObject.b; // 3
("b" in myObject); // true
myObject.hasOwnProperty( "b" ); // true

// .......

for (var k in myObject) {
	console.log( k, myObject[k] );
}
// "a" 2
//직접적으로 알려줌
myObject.propertyIsEnumerable( "a" ); // true
myObject.propertyIsEnumerable( "b" ); // false
//key는 가능한 것들만 나옴.
Object.keys( myObject ); // ["a"]
Object.getOwnPropertyNames( myObject ); // ["a", "b"]

Iteration

forEach():コールバック戻り値を無視して配列内のすべての値を繰り返すevery():最後までコールバックがfalse値を返すと停止します.some():コールバックがtrutty値を与えるまで、最後まで行きます.for...of arrayの値を直接入力します.
@@iterator

var myObject = {
	a: 2,
	b: 3
};

Object.defineProperty( myObject, Symbol.iterator, {
	enumerable: false,
	writable: false,
	configurable: true,
	value: function() {
		var o = this;
		var idx = 0;
		var ks = Object.keys( o );
		return {
			next: function() {
				return {
					value: o[ks[idx++]],
					done: (idx > ks.length)
				};
			}
		};
	}
} );

// iterate `myObject` manually
var it = myObject[Symbol.iterator]();
it.next(); // { value:2, done:false }
it.next(); // { value:3, done:false }
it.next(); // { value:undefined, done:true }

// iterate `myObject` with `for..of`
for (var v of myObject) {
	console.log( v );
}
// 2
// 3