JavaScript创建对象和属性的查询和设置

JavaScript 对象

JavaScript 中的所有事物都是对象：字符串、数值、数组、函数...

JavaScript 提供多个内建对象，比如 String、Date、Array 等等。 对象只是带有属性和方法的特殊数据类型。

• 布尔型可以是一个对象。
• 数字型可以是一个对象。
• 字符串也可以是一个对象
• 日期是一个对象
• 数学和正则表达式也是对象
• 数组是一个对象
• 函数也可以是对象

js数据类型

var str = 'str';    #字符串
var num = 123;    #数值   
var bool = true;   #布尔
var n = null;        #null
var unde = undefined;    #undefined
var arr=[1,2,3,4,5];       #数组
var obj = {name:'sonia'};    #对象
var f = function(){};        #函数
console.log(typeof str);    //string
console.log(typeof num);    //nember
console.log(typeof bool);    //boolean
console.log(typeof n);        //object
console.log(typeof unde);    //undefined
console.log(typeof obj);     //object
console.log(typeof f);         //function

object类型对象创建

第一种object构造函数

优点：较直观看到对象的属性和方法

缺点：处理多个类型，需要创建多个实例

var obj = new Object();
obj.name="abc";
obj.action = function() {
    console.log(this.name)
};
console.log(obj.name);    //abc
obj.action();    //abc

第二种字面量

优点：便于封装调用

缺点:只能创建一次对象，复用性较差

1）简单的字面量
      var obj2 = {};
      obj2.name ='jss';
      obj2.age = 21;
      obj2.action = function(){
            return this.age;//this表示当前obj2对象

    }


2)嵌套字面量(推荐使用)
      var obj3 = {
          name:'jack',
          age:18,
          action:function(){
              return this.name;
          }
      }

第三种工厂方式

优点：解决了重复创建相识对象的问题

缺点：工厂模式虽然解决了创建多个相似对象的问题，但却没有解决对象识别的问题（即怎样知道一个对象的类型）。

function createObj(name) {
    var obj4 = new Object();
    obj4.name = name;
    obj4.action = function(){
        console.log(this.name)
     };
     return obj4;
}
var a = createObj('衣服');
var b = createObj('鞋子');

a.name    //衣服

第四种构造函数 首字母大写 驼峰命名

构造函数:构造函数与其他函数的唯一区别，就在于调用它们的方式不同。不过，构造函数毕竟也是函数，不存在定义构造函数的特殊语法。任何函数，只要通过 new 操作符来调用，那它就可以作为构造函数；

按照惯例，构造函数始终都应该以一个大写字母开头，而非构造函数则应该以一个小写字母开头。

优点:明确了实例对象，

缺点:使用构造函数的主要问题，就是每个方法都要在每个实例上重新创建一遍。在下面的例子中，p3和 p4 都有一个名为 action()的方法，但那两个方法不是同一个 Function 的实例.因此，不同实例上的同名函数是不相等的.

 

      function Person(name,age){
        this.name = name; //构造函数中this指向当前实例化对象

        this.age = age;
        this.action = function(){ //this.action = new Function("alert(this.name)"); 与声明函数在逻辑上是等价的
          console.log(this.name);
        }
      };
      var p3 = new Person('abc',20);
      var p4 = new Person('xyz',20);
      console.log(p3 instanceof Person);//true

改进后：

我们把 action()函数的定义转移到了构造函数外部。而在构造函数内部，我们

将 action属性设置成等于全局的 action函数。这样一来，由于 action包含的是一个指向函数

的指针，因此 p3 和 p4对象就共享了在全局作用域中定义的同一个 action()函数。

缺点:

如果对象需要定义很多方法，那么就要定义很多个全局函数，于是我们这个自定义的引用类型就丝毫没有封装性可言了。好在，这些问题可以通过使用原型模式来解决。

      function Person(name,age){
        this.name = name;
        this.age = age;
        this.action = action;
      };
      function action(){
        console.log(this.name);
      };
      var p3 = new Person('abc',20);
      var p4 = new Person('xyz',20);
      console.log(p3 instanceof Person);

原型模式+构造函数

我们创建的每个函数都有一个 prototype（原型）属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。

      function Person(name,age){
        this.name = name;
        this.age = age;
        // this.action = function(){
        //   console.log('大家都要睡觉');
        // }
      };
      Person.prototype.action = function(){
        console.log('大家都要睡觉');
      }
      var p5 = new Person('abc',20);
      var p6 = new Person('xyz',20);
      p5.action();    //大家都要睡觉

 

对象的属性

设置/获取属性 .  /  [ ]

区别：.是取自身的属性 [ ]可以是变量

      var obj = {}
      obj.name = 'abc';
      obj['age']= 18;
      console.log(obj.name);
      console.log(obj['name']);
      //实例
      var o = {
          name:'xyz',
          age:18
      }
      var a = 'name';
      console.log(o[a])  //o[a]===o['name']  o.a则会打印undefined  

删除属性

通过关键字delete 对象.属性  就可以删除

      var o2 = {
          name:'xyz',
          age:18
      }
      //delete o2.name;
      delete o2['name'];
      console.log(o2);    //{age: 18}  name已经没了

属性的检测

属性检测有三种方法

1)用 in 运算符 判断对象中的属性是否存在

var o4 ={a:'1',b:'2',c:'3'};
console.log('a' in o4);  //true
console.log('m' in o4);  //false

2)使用对象的hasOwnProperty()方法

var o4 ={a:'1',b:'2',c:'3'};
console.log(o4.hasOwnProperty('a'));    //true
var type = 'b';
console.log(o4.hasOwnProperty(type));    //true

3)使用 !=undefined 判断

var o4 ={a:'1',b:'2',c:'3'};
console.log(o4.a != undefined)    //true  说明a它存在o4中
var o5 = {a:undefined}
console.log(o5.a != undefined)    //false    这里有点注意的是使用这个方法，字段值就不能是undefined

 属性的遍历

    // for ... in 
    var o5 ={a:'1',b:'2',c:'3'};
    var arr = ['x','y','z','w'];
    //对象   获取到属性的key
    for(var k in o5){   //o5对象    k变量
        //console.log(k)   //a b c
        console.log(o5[k])  //123
    };
    //数组   获取索引
    for(var v in arr){
        console.log(v)  //0123
    };

    for(var i=0;i<arr.length;i++){
        console.log(arr[i]);
    };

    //forEach   没有返回值
    var arr = ['x','y','z','w'];
    arr.forEach(function(item,index,input){  //item 当前元素   index索引   input  ['x','y','z','w']
        console.log(index)
    });

    //map   回调函数中支持return返回值
     var arr = ['x','y','z','w'];
    var a = arr.map(function(item,index,input){  //item 当前元素   index索引   input  ['x','y','z','w']
        return item+'1';
    });
    console.log(a);