javascript中的对象

也许你经常听别人说"javascript中万物皆对象",这句话是错的

　　在讲这个问题前,我们来了解下对象的声明方式

1.文字语法                                                                                                                      

var myObj = {
key: value
// ...
};

2.构造形式                                                                                                                      

var myObj = new Object();
myObj.key = value;

 唯一的区别是，在文字声明中你可以添加多个键 / 值对，但是在构造形式中你必须逐个添加属性。

对象是 JavaScript 的基础。在 JavaScript 中一共有六种主要类型（术语是“语言类型”）：
　　string •       
　　number •    
　　boolean •     
　　null •          
　　undefined •
　　object •      

在这里面,我们可以看到null也是简单基本类型的一种,但有时null也被当作对象类型,typeof null//"Object"

为什么我们可以使用简单基本类型的"属性?"                                                                              

"abc".length//3

类似上面的代码,我们知道了在调用字面量的时候,引擎把字面量转换成了相应的对象

内容                                                                                                                                

　　从上面我们知道了一个对象可以通过文字语法和构造语法来生成,那么它的属性该怎么办?

var d={
  a:1,
  b:function(){
     console.log(this.a);  
    }  
}

　　需要说明的是,属性只是对值的一个引用,真正的值是放在内存中,存放的位置由编译器决定

我们都知道访问对象的属性有两种方法

1.通过.访问属性                                                                                                

a.b
c.d

2.通过属性名称                                                                                                  

a["b"]
c["d1"]

　　这两个的区别在于,一个可以输入非法字符-=-,请看下面的代码

        var d={
            "fd-!":2
        };
        console.log(d["fd-!"]);//2
        console.log(d.fd-!);//错误

有可能你需要在某个对象上加一个固定的前缀,那么你这里这样                                             

var prefix = "foo";
var myObject = {
[prefix + "bar"]:"hello",
[prefix + "baz"]: "world"
};
myObject["foobar"]; // hello
myObject["foobaz"]; // world

讲到这里,你可能会觉得javascript和其他的语言比会有所不足,其实不是不足,而是我们了解的不够深,

　　比如你有可能会问,在C#中属性有Get/Set你的在哪里呢?!!别急,接着往下看

属性与方法                                                                                                         

 　　　属性描述符                              

        var d={a:100000};
        console.log(Object.getOwnPropertyDescriptor(d,"a"));

在这里我们就知道了,一个属性默认有3个描述符

　　　　1.可写(writable)

　　　　2.可枚举(enumerable)

　　　　3.可配置(configurable)

　　在这里就详细的介绍这些了,你还可以用下面的方法做一些有趣的事情

1 禁止扩展                                                                                  
　　如果你想禁止一个对象添加新属性并且保留已有属性，可以使用 Object.prevent
　　Extensions(..) ：
　　var myObject = {
　　a:2
　　};
　　Object.preventExtensions( myObject );
　　myObject.b = 3;
　　myObject.b; // undefined

2. 密封                                                                                       
　　Object.seal(..) 会创建一个“密封”的对象，这个方法实际上会在一个现有对象上调用
　　Object.preventExtensions(..) 并把所有现有属性标记为 configurable:false 。
　　所以，密封之后不仅不能添加新属性，也不能重新配置或者删除任何现有属性（虽然可以
　　修改属性的值）


3. 冻结                                                                                        
　　Object.freeze(..) 会创建一个冻结对象，这个方法实际上会在一个现有对象上调用
　　Object.seal(..) 并把所有“数据访问”属性标记为 writable:false ，这样就无法修改它们
　　的值。

 Getter和Setter                                                                                                        

var myObject = {
// 给 a 定义一个 getter
get a() {
return 2;
}
};
Object.defineProperty(
myObject, // 目标对象
"b", // 属性名
{ // 描述符
// 给 b 设置一个 getter
get: function(){ return this.a * 2 },
// 确保 b 会出现在对象的属性列表中
enumerable: true
}
);
myObject.a; // 2
myObject.b; // 4

遍历                                                                                              

常用的遍历方法有 

　　1.for(var t in ddd)

    var arra1=[1,2,3,4];
    for(var t in arra1){
        console.log(arra1[t]);//1,2,3,4
    }

　　2.forEach(function(){})

    arra1.forEach(function(i){
        console.log(i);//1,2,3,4
    });

　　3.some()  运行到程序返回true

    arra1.some(function(i){
        console.log(i);//1,2,3,4
        if(i==4){
        return true;
        }
    });

　　4.every()  运行到程序返回false 

    var arra1=[1,2,3,4];
    arra1.every(function(i){
            console.log(i);//1,2,3,4
            return i<5;
    });

　　5.for(var t of ddd)

    var arra1=[1,2,3,4];
    for(var t of arra1){
        console.log(t);//1,2,3,4
    }

上面的数组可以枚举是因为他默认有@@iterator,下面我们来看看他的实现　　

    var array1=[1,2,3,4];
    var it=array1[Symbol.iterator]();
    var zi=it.next();
        while(!zi.done){
            console.log(zi);
            zi=it.next();
        }

当然我们也可以创建自己的迭代器,请看代码

        var temp={
            a:1,
            b:2,
            c:3
        };
        Object.defineProperty(temp,Symbol.iterator,{
            value:function(){
                var o=this;
                var id=0;
                var ks=Object.keys(o);
                return{
                    next:function(){
                        return{
                            value:o[ks[id++]],
                            done:id>ks.length
                        }
                    }
                }
            }
        }
        );
        for(var t of temp){
            console.log(t);//1,2,3
        }