這篇文章為大家帶來了JavaScript中關於物件的相關知識，JavaScript中的物件也是變量，但是物件包含很多值，希望看完這篇文章後對大家有幫助。
JavaScript有六種主要語言型別：
string , number , boolean ,undefined , null , object
基本型別：string，number，boolean，undefined，null；基本型別本身不是物件。
但是 null有時會被當成對象，typeof null 會傳回object，實際上null是基本型別。原因是不同物件在底層都是表示為二進位，在JavaScript中二進位前三位都為0會被判斷為object類型，null表示全 0，所以typeof時會傳回object。
陣列也是物件的一種類型，具備一些額外的行為。數組的組織方式比一般的物件要複雜。
函數本質上和普通函數一樣，只是可以調用，所以可以操作物件一樣操作函數。
String
Number
Date
Boolean
Object
Function
Array
.a 稱之為屬性訪問，['a']稱之為操作符訪問。
//对象中的属性名始终是字符串
myobj={}
myobj[myobj]='bar'//赋值
myobj['[object object]'] //'bar'es6 增加可計算屬性名，可以在文字形式中使用[] 包覆一個表達式來當作屬性名
var perfix = 'foo'
var myobj={
[perfix + 'bar'] :'hello'
}
myobj['foobar']//helloes5開始，所有屬性具備了屬性描述符，例如可以直接判斷屬性是否可讀可寫等。
/* * 重要函数： * Object.getOwnPropertyDescriptor(..) //获取属性描述符 * Object.defineProperty(..) //设置属性描述符 */ writeble（可读性） configurable（可配置性） enumerable （可枚举性）
for in可用來遍歷物件的可枚舉屬性清單（包括[[Prototype]]鏈），需要手動取得屬性值。可以遍歷數組及普通的對象
es6新增，可以用來遍歷數組的屬性值，for of循環首先會向被訪問對象請求一個迭代器對象，然後透過呼叫迭代器物件的next()方法來遍歷所有的回傳值。
陣列有內建的@@iterator，
var arr = [1, 2, 3]
var it = arr[Symbol.iterator]()//迭代器对象
console.log(it.next());//{value: 1, done: false}
console.log(it.next());//{value: 2, done: false}
console.log(it.next());//{value: 3, done: false}
console.log(it.next());//{value: undefined, done: true}
/*
* 用es6 的Symbol.iterator 来获取对象的迭代器内部属性。
* @@iterator本身并不是一个迭代器对象，而是一个返回迭代器对象的函数。
*/因為物件沒有內建一個@@iterator，無法自動完成for…of遍歷。但是，可以給你任何想遍歷的物件定義@@iterator，舉例來說：
var obj={
a:1,b:2
}
Object.defineProperty(obj, Symbol.iterator, {
enumerable: false,
writable: false,
configurable: true,
value: function () {
var self = this
var idx = 0
var ks = Object.keys(self)
return {
next: function () {
return {
value: self[ks[idx++]],
done: (idx > ks.length)
}
}
}
}
})
//手动遍历
var it = obj[Symbol.iterator]()//迭代器对象
console.log(it.next());//{value: 1, done: false}
console.log(it.next());//{value: 2, done: false}
console.log(it.next());//{value: undefined, done: true}
//for of 遍历
for (const v of obj) {
console.log(v);
}
//2
//3/* forEach：会遍历所有并忽略返回值 some：会一直运行到回调函数返回 true（或者"真"值） every：会一直运行到回调函数返回 false（或者"假"值） map： filter：返回满足条件的值 reduce： some和every 和for的break语句类似，会提前终止遍历 */
上面提過，JavaScript的主要的語言類型有六種：string、number、boolean、null、undefined、object；其中前5種屬於基本型，最後的object屬於引用型別。
#堆疊：自動分配記憶體空間，系統自動釋放，裡面存放的是基本類型的值和參考類型的位址
堆：動態分配的內存，大小不定，也不會自動釋放。裡面存放引用類型的值
基本型別採用值傳遞；引用型別所採用的位址（指標）傳遞，將存放在堆疊記憶體中的位址賦值給接收的變數。
淺拷貝：物件的淺拷貝，會對『主』物件進行拷貝，但不會複製物件裡面的物件。 ‘裡面的物件’會在原來的物件和它的副本之間共用。
深拷貝：對物件的深拷貝，不僅將原始物件的各個屬性逐一複製出去，而且將原始物件各個屬性所包含的物件也依次採用深複製的方法遞歸複製到新物件上，所以對一個物件的修改並不會影響另一個物件。
範例來說:
var anotherObject={
b:"b"
}
var anotherArray=[]
var myObject={
a:'a',
b:anotherObject, //引用，不是副本
c:anotherArray //另外一个引用
}
anotherArray.push(anotherObject,myObject)
/*
如何准确的复制 myObject?
浅复制 myObject，就是复制出 新对象中的 a 的值会复制出对象中a 的值，也就是 'a'，
但是对象中的 b、c两个属性其实只是三个引用，新对象的b、c属性和旧对象的是一样的。
深复制 myObject，除了复制 myObject 以外还会复制 anotherObject 和 anotherArray。
但是这里深复制 myObject会出现一个问题，anotherArray 引用 anotherObject 和 myObject，
所以又需要复制 myObject，这样就会由于循环引用导致死循环。
后面会介绍如何处理这种情况。
*/object.assign()、擴充運算子（…）
var obj1 = {x: 1, y: 2}
var obj2 = Object.assign({}, obj1);
console.log(obj1) //{x: 1, y: 2}
console.log(obj2) //{x: 1, y: 2}
obj2.x = 2; //修改obj2.x
console.log(obj1) //{x: 1, y: 2}
console.log(obj2) //{x: 2, y: 2}
var obj1 = {
x: 1,
y: {
m: 1
}
};
var obj2 = Object.assign({}, obj1);
console.log(obj1) //{x: 1, y: {m: 1}}
console.log(obj2) //{x: 1, y: {m: 1}}
obj2.y.m = 2; //修改obj2.y.m
console.log(obj1) //{x: 1, y: {m: 2}}
console.log(obj2) //{x: 2, y: {m: 2}}slice()、concat、Array.from()、擴充運算子（…）、concat、for迴圈
var arr1 = [1, 2, [3, 4]], arr2 = arr1.slice(); console.log(arr1); //[1, 2, [3, 4]] console.log(arr2); //[1, 2, [3, 4]] arr2[0] = 2 arr2[2][1] = 5; console.log(arr1); //[1, 2, [3, 5]] console.log(arr2); //[2, 2, [3, 5]]
進行JSON.stringify()序列化的過程中，undefined、任意的函數以及symbol 值，在序列化過程中會被忽略（出現在非數組物件的屬性值中時）或被轉換成null（出現在數組中時）。
var obj1 = {
x: 1,
y: {
m: 1
},
a:undefined,
b:function(a,b){
return a+b
},
c:Symbol("foo")
};
var obj2 = JSON.parse(JSON.stringify(obj1));
console.log(obj1) //{x: 1, y: {m: 1}, a: undefined, b: ƒ, c: Symbol(foo)}
console.log(obj2) //{x: 1, y: {m: 1}}
obj2.y.m = 2; //修改obj2.y.m
console.log(obj1) //{x: 1, y: {m: 1}, a: undefined, b: ƒ, c: Symbol(foo)}
console.log(obj2) //{x: 2, y: {m: 2}}function deepClone(obj){
let result = Array.isArray(obj)?[]:{};
if(obj && typeof obj === "object"){
for(let key in obj){
if(obj.hasOwnProperty(key)){
if(obj[key] && typeof obj[key] === "object"){
result[key] = deepClone(obj[key]);
}else{
result[key] = obj[key];
}
}
}
}
return result;
}
var obj1 = {
x: {
m: 1
},
y: undefined,
z: function add(z1, z2) {
return z1 + z2
},
a: Symbol("foo"),
b: [1,2,3,4,5],
c: null
};
var obj2 = deepClone(obj1);
obj2.x.m = 2;
obj2.b[0] = 2;
console.log(obj1);
console.log(obj2);
//obj1
{
a: Symbol(foo)
b: (5) [1, 2, 3, 4, 5]
c: null
x: {m: 1}
y: undefined
z: ƒ add(z1, z2)
}
//obj2
{
a: Symbol(foo)
b: (5) [2, 2, 3, 4, 5]
c: null
x: {m: 2}
y: undefined
z: ƒ add(z1, z2)
}上面的深拷貝方法遇到循環引用，會陷入一個循環的遞歸的過程，從而導致爆棧。因此需要改進。
解決因循環遞歸而暴棧的問題，只需要判斷一個物件的欄位是否引用了這個物件或這個物件的任意父級即可。
function deepClone(obj, parent = null){ // 改进（1）
let result = Array.isArray(obj)?[]:{};
let _parent = parent; // 改进（2）
while(_parent){ // 改进（3）
if(_parent.originalParent === obj){
return _parent.currentParent;
}
_parent = _parent.parent;
}
if(obj && typeof obj === "object"){
for(let key in obj){
if(obj.hasOwnProperty(key)){
if(obj[key] && typeof obj[key] === "object"){
result[key] = deepClone(obj[key],{ // 改进（4）
originalParent: obj,
currentParent: result,
parent: parent
});
}else{
result[key] = obj[key];
}
}
}
}
return result;
}
// 调试用
var obj1 = {
x: 1,
y: 2
};
obj1.z = obj1;
var obj2 = deepClone(obj1);
console.log(obj1);
console.log(obj2);function deepClone(obj, parent = null){
let result; // 最后的返回结果
let _parent = parent; // 防止循环引用
while(_parent){
if(_parent.originalParent === obj){
return _parent.currentParent;
}
_parent = _parent.parent;
}
if(obj && typeof obj === "object"){ // 返回引用数据类型(null已被判断条件排除))
if(obj instanceof RegExp){ // RegExp类型
result = new RegExp(obj.source, obj.flags)
}else if(obj instanceof Date){ // Date类型
result = new Date(obj.getTime());
}else{
if(obj instanceof Array){ // Array类型
result = []
}else{ // Object类型，继承原型链
let proto = Object.getPrototypeOf(obj);
result = Object.create(proto);
}
for(let key in obj){ // Array类型 与 Object类型 的深拷贝
if(obj.hasOwnProperty(key)){
if(obj[key] && typeof obj[key] === "object"){
result[key] = deepClone(obj[key],{
originalParent: obj,
currentParent: result,
parent: parent
});
}else{
result[key] = obj[key];
}
}
}
}
}else{ // 返回基本数据类型与Function类型,因为Function不需要深拷贝
return obj
}
return result;
}
// 调试用
function construct(){
this.a = 1,
this.b = {
x:2,
y:3,
z:[4,5,[6]]
},
this.c = [7,8,[9,10]],
this.d = new Date(),
this.e = /abc/ig,
this.f = function(a,b){
return a+b
},
this.g = null,
this.h = undefined,
this.i = "hello",
this.j = Symbol("foo")
}
construct.prototype.str = "I'm prototype"
var obj1 = new construct()
obj1.k = obj1
obj2 = deepClone(obj1)
obj2.b.x = 999
obj2.c[0] = 666
console.log(obj1)
console.log(obj2)
console.log(obj1.str)
console.log(obj2.str)附註：Function類型的深拷貝：
bind()：使用fn.bind()可將函數進行深拷貝，但因為this指標指向問題而不能使用；
eval(fn.toString())：只支援箭頭函數，普通函數function fn(){}則不適用；
new Function(arg1,arg2,…,function_body)：需要將參數與函數體提取出來；
#PS：一般也不需要深拷貝Function。
【相關推薦：javascript學習教學】
#以上是詳解JavaScript基礎之對象（整理分享）的詳細內容。更多資訊請關注PHP中文網其他相關文章！
