JavaScript 属性特性

JavaScript中对属性的操作很多，但其中有一些是比较常用的，有的时候可能忘记，所有写这篇纯粹是为了方便查找。

查询属性

// 字面量方式创建一个对象
var person1 = {
                username: 'lixiang',
                age: 24,
                salary: 13000,
                addr: '上海',
                sex: '男',
                sayHi: function() {
                        return 'say Hi';
                       },
                info: function() {
                        return '用户名:' + this.username + '\n年龄:' + this.age + '\n地址:' + this.addr;
                       }
            };
// 查询属性
console.log("用户名: " + person1.username + "\n" + "性别: " + person1.sex);
console1.log("薪水: " + person1["salary"] + "\n" + "地址: " + person1["addr"]);

// 不可以:这样是不被允许的
var key = 'username';
console.log(person1.key);
// 可以
console.log(person1[key]);

//构造函数
function PersonInfo(name, age, sex) {
          this.name = name;
          this.age = age;
          this.sex = sex;
          this.info = function() {
                      return this.username + this.addr;
                      };
        };
var person2 = new PersonInfo('lixiang', 24, '男');
// 查询属性
console.log(person2.name + person2['sex']);

添加属性

person1.dream = '合格的程序员';
person1['Interest'] = '游戏';

修改属性

person1.salary = 15000;
person1['Interest'] = '写代码';

删除属性

// delete只能删除自身属性不能删除继承属性
delete person1.dream;
delete person1['Interest'];

遍历属性

for(var p in person1) {
    console.log(p + '\n');
}

对象中的方法

// 调用对象中的方法
console.log(person1.sayHi());
console.log(person1.info());

//添加方法
person2.info1 = function() {
        return 'this is a test1111';
};
console.log(p1.info1());

对象上是否有这个属性

// 通过in来解释某个对象上是否有这个属性：继承下来的也可以.
function fooo() {
};
fooo.prototype.z = 3; //设置了原型属性z为3
var obj = new fooo();
obj.x = 1; //x是对象本身的属性
obj.y = 2; //y是对象本身的属性

console.log('x' in obj); // true x是对象上本身定义的属性
console.log('z' in obj); // true z是从对象原型上继承来的属性
console.log('toString' in obj); // true toString是从顶级对象Object上继承来的属性
console.log("no" in obj); // false  对象本上没有，查找整个原型链都没有这个属性直到null

// 通过hasOwnProperty() 来检测是否是对象本身的属性，而不是继承来的属性
function Foo() {
};
Foo.prototype.z = 5;

var obj = new Foo();

obj.x = 1;
obj.y = 2;
console.log(obj.hasOwnProperty("x")); // true   x是对象本身定义的属性
console.log(obj.hasOwnProperty("z")); // false   z是对象原型上继承的属性
console.log(obj.hasOwnProperty("toString")); // false   toString是顶级对象上继承来的属性

可枚举

// 可枚举:enumerable表示
// 可枚举性决定了这个属性能否被for…in查找遍历到。
// propertyIsEnumerable()方法返回布尔值，该值指示指定属性是否为对象的一部分以及该属性是否可枚举的。
// 该方法属于Object对象
// 如果判断的属性存在于Object对象的原型内，不管它是否可枚举都会返回false。

// 属性是对象自己的并且可枚举的返回true
console.log(obj.propertyIsEnumerable('x')); // true
console.log(obj.propertyIsEnumerable('z')); // false
console.log(Object.prototype.hasOwnProperty('toString')); // true
console.log(Object.prototype.propertyIsEnumerable('toString')); // false

自有属性名称提取

// 以数组的形式返回所有自有属性的名称，包括不可枚举的
console.log(Object.getOwnPropertyNames(obj));
// 以数组的形式返回所有自有属性的名称，可枚举的
console.log(Object.keys(obj));
// 得到的结果也是自身属性，但是不包括函数在内。
console.log(JSON.stringify(obj))

创建不能被修改的对象的属性

var obj = {
};
// defineProperty创建一个不能被修改的对象的属性
Object.defineProperty(obj, 'x', { value: 12 });
console.log(obj.x); //12

// 检测属性是否是对象自有的
console.log(obj.hasOwnProperty('x')); //true

// 不可修改
obj.x = 456;
console.log(obj.x); //12

// 检测属性是否是对象自己的并且可枚举性.
console.log(obj.propertyIsEnumerable('x')); //false

for(var p in obj) {
    console.log('对象中的属性: ' + p + '\n'); //无
}

// 也就是说不是可枚举的

可配置
Object.defineProperty定义新属性或修改原有的属性。

Object.defineProperty(obj, 'y', {
                value: 56,
                writable: true, //代表是否可写,就是 是否可修改
                enumerable: true, //是否可枚举
                configurable: false //是否可配置
            });
console.log(obj.y); // 56
obj.y = 777;
console.log(obj.y); // 777

// 可枚举检测
for(var p in obj) {
    console.log(p); //y
}
console.log(obj.propertyIsEnumerable('y'));// true// 检测属性是否是对象自己的并且可枚举性.
console.log(Object.keys(obj)); // ["y"]// 返回对象属性包括可枚举的
console.log(Object.getOwnPropertyNames(obj)); // ["x","y"]// 返回对象属性包括不可枚举的


Object.defineProperty(obj, 'z', {
                value: 'this is a test',
                writable: true, // 代表是否可写，就是代表是否可修改
                enumerable: true, // 是否可枚举
                configurable: true // 是否可配置
            });
console.log(obj.z); // this is a test
obj.z = 'hello';
console.log(obj.z); // hello
delete obj.z; // 可配置为true，能对其进行删除操作
console.log(obj.z); // undefined


Object.defineProperty(obj, 'k', {
                value: 1,
                writable: false,// 代表是否可写，就是代表是否可修改
                enumerable: false,// 是否可枚举
                configurable: true // 是否可配置
            });
console.log(obj.k); //1
obj.k = 3;
console.log(obj.k); //1

// 可配置true的情况下才可以重写defineProperty方法或者:
// writable: true
// 特殊情况，如果属性不可配置，但是可以吧writable的true变成false，但不能将false变为true
// 也可以重新写此函数
Object.defineProperty(obj, 'k', {
                writable: true
            });
obj.k = 5;
console.log(obj.k); // 5

// get
var obj = {
};
Object.defineProperty(obj, 'x', {
                get: function() {
                    return 123;
                }
            });
console.log(obj.x);// 123


var obj1 = {
    __proto__: null, // 保证所有属性没有继承而来
    value: 1
};
Object.defineProperty(obj1, 'x', {
                value: 1,
                writable: false,// 代表是否可写,就是代表是否可修改
                enumerable: false,// 是否可枚举
                configurable:true// 是否可配置
});
obj1.x = 2;
console.log(obj1.x);// 1

Object.defineProperty(obj1, 'x', {
        value: 3
});
console.log(obj1.x);// 3
obj1.x = 5;
console.log(obj1.x);// 3

Object.getOwnPropertyDescriptor(object, propertyname)函数
获取指定对象的自身属性描述符。自身属性描述符是指直接在对象上定义（而非从对象的原型继承）的描述符。

console.log(Object.getOwnPropertyDescriptor(obj1, 'x'));

存储器

// 属性不存在
var person = {
        username: 'king',
        sex: '男',
                
          // 访问不存在的值
          get age() {
            return 12;
          },
          set age(val) {
            console.log('不能设置' + val);
          }
    };
console.log(person.username);
console.log(person.age);// 属性不存在，自动调用get方法
person.age = 13;

// 属性存在
var p = {
        name: "xiangli",
        work: function() {
            console.log("wording...");
        },
        _age: 18,
        get age() {
            return this._age;
        },
        set age(val) {
            if(val < 0 || val > 100) { //如果年龄大于100就抛出错误
                throw new Error("invalid value")
            } else {
                this._age = val;
            }
        }
    };
console.log(p.name);// 输出xiangli
console.log(p.age);// 18
p.age = 23
console.log(p.age);// 23

原型对象判断

var obj = { x: 1 };
var obj1 = Object.create(obj); //obj就是obj1 的原型对象
// obj是obj1原型
console.log(obj.isPrototypeOf(obj1));//true
console.log(Object.prototype.isPrototypeOf(obj1));//true

toString()

toString() 函数用于将当前对象以字符串的形式返回。

类型	行为描述
Array	将 Array 的每个元素转换为字符串，并将它们依次连接起来，两个元素之间用英文逗号作为分隔符进行拼接。
Boolean	如果布尔值是true，则返回"true"。否则返回"false"。
Date	返回日期的文本表示。
Error	返回一个包含相关错误信息的字符串。
Function	返回如下格式的字符串，其中 functionname 是一个函数的名称，此函数的 toString 方法被调用： "function functionname() { [native code] }"
Number	返回数值的字符串表示。还可返回以指定进制表示的字符串，请参考Number.toString()。
String	返回 String 对象的值。
Object(默认)	返回"[object ObjectName]"，其中 ObjectName 是对象类型的名称。

var obj = {
    name:'wo'
};
// 小写的是方法返回的值的格式中默认的，大些的是对象的名字Object
console.log(obj.toString()); // 对象[object Object]

var ary = [1, 2, 3];
console.log(ary.toString()); // 1,2,3

var arr = new Array();
console.log(arr.toString()); // 什么也不显示，空数组

Object中的tostring与Array中的tostring的区别

对象类型判断

console.log(Object.prototype.toString.call(arr)); // [object Array]

获取数组指定元素

arrayObject.slice(start,end)
slice() 方法可从已有的数组中返回选定的元素。