zoukankan      html  css  js  c++  java
  • JS 对象属性相关--检查属性、枚举属性等

    1.删除属性

    delete运算符可以删除对象的属性

     delete person.age //即person不再有属性age
     delete person['age'] //或者这样

    delete只是断开属性和宿主对象的联系,而不会去操作属性中的属性  看到delete a.p之后b.x仍然为1

    复制代码
    var a = {p:{x:1}};
    var b = a.p;
    console.log(a.p.x); //1
    delete a.p;
    console.log(a.p.x); //TypeError a.p is undefined
    console.log(a.p); //undefined
    console.log(b.x); //1
    复制代码

    delete只能删除自有属性,不能删除继承属性(要删除继承属性必须从定义这个属性的原型对象上删除它,当然,这会影响到所有继承来自这个原型的对象)

    复制代码
    function inherit(p){ 
        if(p == null){   // 不能从null中继承
            throw TypeError();
        }
        if(Object.create){   //如果有这个方法就直接使用
            return Object.create(p);
        }
        var t = typeof p;
        if(t !== "object" || t !== "function"){   //要继承的对象  类型要符合
            throw TypeError();
        }
        function f(){ };  //定义一个空的构造函数
        f.prototype = p;  //原型指向要继承的对象p
        return new f();   //创建f对象,此对象继承自p
    }
    
    var obj = {x:1};
    var obj1 = inherit(obj);
    obj1.y = 2;
    console.log("x = "+obj1.x+" y = "+obj1.y); //x = 1 y = 2
    delete obj1.x;
    delete obj1.y;
    console.log("x = "+obj1.x+" y = "+obj1.y); //x = 1 y = undefined
    复制代码

    当然了,可配置的属性才能用到delete
    比如

    复制代码
    delete Object.prototype; // 不能删除  不可配置
    
    var x = 1;
    delete this.x; //不能删除
    this.y = 1;
    delete y; //这样可以删除
    
    function f(){ }
    delete this.f; //不能删除
    复制代码

    2.检测属性

    使用 “in"

    in 运算符希望它的左操作数是一个字符串或者可以转换为字符串,希望它的右操作数是一个对象

    复制代码
    var data = [5,6,7];
    console.log("0" in data);  //有下标0
    console.log(1 in data);    //1可以转换成"1"
    console.log("4" in data);  //下标只有 1  2  3
     
    var obj = {x:1};
    console.log("x" in obj); //true
    console.log("y" in obj); //false
    console.log("toString" in obj); //true  因为obj继承了这个方法
    复制代码

    使用hasOwnProperty()或者propertyIsEnumerable() --- 后者是前者的增强
    顾明思议

    var obj = {x:1};
    console.log(obj.hasOwnProperty("x")); //true
    console.log(obj.hasOwnProperty("y")); //false
    console.log(obj.hasOwnProperty("toString")); //false  因为obj继承了这个方法,但不是它自己的

    只有检测到是自由属性并是可枚举的属性时,后者才返回true

    var obj = {x:1};
    console.log(obj.propertyIsEnumerable("x")); //true
    console.log(obj.propertyIsEnumerable("y")); //false
    console.log(obj.propertyIsEnumerable("toString")); //false  因为obj继承了这个方法,但不是它自己的
    console.log(Object.prototype.propertyIsEnumerable("toString")); //false  因为最原始的的 toString就是不可枚举的


    当然,也可以直接用 ”!=="运算符判断

    var obj = {x:1};
    console.log(obj.x !== undefined);//true
    console.log(obj.y !== undefined);//false
    console.log(obj.toString !== undefined); //true

    3.枚举属性

    var obj = {x:1,y:2};
    for(p in obj){
      console.log(p);//x y
      console.log(obj.p);// undefined undefined
      console.log(obj[p]);//1 2
    }

    拓展1:

    每个对象都有与之相关的原型(prototype)、类(class)、可扩展性(extensible)

    要检测一个对象是否是另一个对象的原型(或处于原型链中),可以使用isPrototypeOf()方法

    var p = {x:1}; //p原型对象继承自Object.prototype
    var o = Object.create(p); //o对象继承自p
    
    console.log(p.isPrototypeOf(o));//true
    console.log(Object.prototype.isPrototypeOf(o));//true
    console.log(Object.prototype.isPrototypeOf(p));//true

    当然,isPrototypeOf()方法和instanceof运算符非常类似
    instanceof运算符希望它的左操作数是一个对象,右操作数标识对象的类。如果左侧的对象是右侧类的实例,则表达式返回true,否则返回false

    复制代码
    var p = {x:1}; 
    console.log(p instanceof Object);//true
    
    var d = new Date();
    console.log(d instanceof Date);//true
    console.log(d instanceof Object);//true
    console.log(d instanceof Number);//false
    复制代码


    拓展2:

    对象的类属性是一个字符串,用以表示对象的类型信息

    一般调用toString()方法后返回形如 [object class]的形式

    比如

    var obj = {x:1,y:2};
    console.log(obj.toString());//[object Object]

    所以要想获取对象的类,就可以通过返回的字符串中找出 “class"字段  使用 slice(8,-1)
    比如

    复制代码
    function classOf(obj){  // 找出类名
      if(obj === null){
        return "Null";
      }
      if(obj === undefined){
        return "Undefined";
      }
      return Object.prototype.toString.call(obj).slice(8,-1);
    }
    
    console.log(classOf(1)); //Number
    //注意,实际上是这些类型的变量调用toString()方法,而不是通过他们自身直接调用
    //console.log(1.toString()); //会报错
    var a = 1;
    console.log(Number(1).toString()); //1
    console.log(a.toString()); //1
    console.log({x:1}.toString()); //[object Object]
    
    console.log(classOf(1)); //Number
    console.log(classOf("")); //String
    console.log(classOf("str")); //String
    console.log(classOf(null)); //Null
    console.log(classOf(false)); //Boolean
    console.log(classOf({})); //Object
    console.log(classOf([])); //Array
    console.log(classOf(new Date())); //Date
    function f(){}
    console.log(classOf(new f())); //Object
    复制代码
  • 相关阅读:
    108. Convert Sorted Array to Binary Search Tree
    How to check if one path is a child of another path?
    Why there is two completely different version of Reverse for List and IEnumerable?
    在Jenkins中集成Sonarqube
    如何查看sonarqube的版本 how to check the version of sonarqube
    Queue
    BFS广度优先 vs DFS深度优先 for Binary Tree
    Depth-first search and Breadth-first search 深度优先搜索和广度优先搜索
    102. Binary Tree Level Order Traversal 广度优先遍历
    How do I check if a type is a subtype OR the type of an object?
  • 原文地址:https://www.cnblogs.com/double405/p/5163818.html
Copyright © 2011-2022 走看看