原型链上有z get，如果要在obj上新增一个z，用

Object.defineProperty(obj,'z',{value:100});

对象标签：[[proto]]

                [[class]]

                [[extensible]] 表示对象是否可扩展，是否可继续添加

slice(8,-1)截取从第8个字符开始一直到最后并去掉最后一个字符

var toString = Object.prototype.toString;
function getType(o){return toString.call(o).slice(8,-1);};

toString.call(null);// "[object Null]"
getType(null);//"Null"
getType(undefined);//"Undefined"
getType(1);"Number"
getType(new Number(1));//"Number"
typeof new Number(1);//"object"

extensible

var obj = {x:1,y:2};
Object.isExtensible(obj);//true
Object.preventExtensions(obj);//阻止扩展，但是不会修改属性标签的状态

Object.seal(obj);//阻止扩展，但是会把属性标签configurable改成false
Object.isSealed(obj);//该方法判断对象是否被seal隐藏

Object.freeze(obj);//阻止扩展，但是会把属性标签configurable和writable改成false
Object.isFrozen(obj);
!!!以上操作均不会影响原型链

序列化：JSON.stringify(obj);

        !!!如果对象的属性值为undefined时，不会出现在序列化结果中

            如果对象的属性值为NaN时,序列化结果会转化为null  

            如果对象的属性值为new Date()时, 序列化结果会转化为UTC的格式     

后端返回数据变成javascript对象JSON.parse

toString

valueOf

Object.keys(person);//返回所有可枚举的属性

Object.defineProperies(person,{
    title:{value:'fe',enumerable:true},
    corp:{value:'baba',enumerable:true},
    salary:{value:'50000',enumerable:true,writable: true},
});
Object.getOwnpropertyDescriptor(person,'salary');
//Object{value:50000,writable:true,enumerbale:true,configurable:false} 未定义的属性标签默认都是false

val = +val;//把它变成数字

get/set与原型链

function foo(){}
Object.defineProperty(foo.prototype,'z',{
    get: function(){return:1;}
});
var obj = new foo();

obj.z;// 1
obj.z = 10;
obj.z;// still 1
// 当obj中没有z属性，并向原型链上查找的时候有对应的get／set方法时，再赋值的时候会走原型上的相应的get/set方法，而不会直接赋值给obj

// 想要赋值给obj.z
Object.defineProperty(obj,'z',{
    value: 100,
    configurable: true;
});
obj.z;// 100
delete obj.z;
obj.z;// back to 1

属性读写

属性删除：

        Object.prototype属性不能被删除

delete Object.prototype;//false
var descriptor =  Object.getOwnPropertyDrscriptor(Object,'prototype');//获取一个属性中的所有标签
descriptor.configurable;//false。是否可配置

        var 定义的全局变量活着局部变量不会被删除

        全局函数或者局部函数也不可以被删除

cat.propertyIsEnumerable('legs');//true可枚举的
cat.propertyIsEnumerable('toString');// false 
// 原型链上的属性不可枚举

自定义一个属性，让他的枚举标签是false

Object.defineProperty(cat,'price'{
    enumerable;false,
    value:10000
});
cat.propertyIsEnumerable('price');//false
cat.hasOwnProperty('price');//true

  操作

cat.legs *= 2; //乘2
cat.legs != undefined;//!==undefined or !== null
cat.legs !== undefined; // !==undefined

不是所有的对象都有原型链或是都有Object.prototype,有toString方法

对象的创建：

        1.字面量：var obj1 = {x:1,y:2};可嵌套

        2.new构造器的方式： prototype是原型是对象属性

function foo(){}
foo.prototype.z = 3;

var obj = new foo();// obj的prototype指向foo.prototype
obj.y = 2;
obj.x = =1;
obj.z = 3;// obj中没有z这个值，会向上找原型，原型中有就返回
// 最上层的原型是Object.prototype --->null 找到null还没有就会返回undefined
typeof obj.toString;// 'function'
'z' in obj; //true
obj.hasOwnProperty('z');// false 说明z不再obj上，而在原型上
// 会继承原型链上的属性，但是不会去修改他们

        3.Object.create创建对象，create时系统内置函数

var obj = Object.create({x:1});// 会让对象的原型指向创建的x
obj.x//1
typeof obj.toString;// 'function'
obj.hasOwnProperty('x');// false

var obj = Object.create(null);
obj.toString //undeined

对象包含一系列无序的属性，每个属性都有一个字符串key和对应的value

严格模式：'use strict';提高错误检查，增强安全性

    不允许适应with

    不允许未声明的变量被赋值

    arguments变为参数的静态副本

    delete参数，函数名报错

    delete不可配置属性报错

    对象字面量重复属性报错

    禁止八进制的字面量

    eval arguments变为关键字，不能作为变量，函数名   

    eval独立作用域 

fd();//true 函数可以在声明前执行
function fd(){
    // do sth
    return true;
}
fd();//TypeError。函数表达式不可以
var fe = function () {
    // do sth
};

for...in    顺序不确定

            enumberable为false时不会出现

            for  in 对象属性时受原型链影响

width语句可以修改当前的作用域

with({x:1}){
    console.log(x);
}
// 可以直接输出，不用对象.属性调用
with(document.forms[0]){
    console.log(name.value)
}

var form = document.forms[0];
console.log(form.name.value);
/*
使用with让JS引擎优化更难
可读性变差。 可被变量定义代替
严格模式下被禁用
*/

，逗号运算符表达式的每一个元素都会被计算，但是最后取的值是逗号最右边的值

var obj ={};
Object.defineProperty(obj,'x',{
    configurable: false,//只有这个标签的值是true时才可以被delete掉
    value:1
});
delete obj.x;//false
obj.x; //1

in运算符：

        window.x = 1;

        'x' in window;//true

function Foo(){};
Foo.prototype.x = 1;
var obj = new Foo();
obj.x; //1
obj.hasOwnProperty('x');//false
obj._proto_.hasOwnProperty('x'); //true

this运算符

this;// window
var obj = {
    func:function(){return this;}
};
obj.func();//obj

一元运算符void

        void 0 //undefined

        void(0) //undefined

表达式：原始表达式

                初始化

                函数

                属性访问

                 调用

                  对象创建

类型检测的方法：

    typeof:   适合基本类型以及function的检测，遇到null失效

                    100 -->"number"

                    true -->"boolean"

                    function --> "function"

                    undefined --> "undefined"

                    new Object() --> "object"

                    [1,2] --> "object"

                    NaN --> "number"

                    null -->"object"

    instanceof:基于原型链判断对象类型，适合自定义对象，检测原生对象

        obj instanceof Object  左面是对象

            [1,2] instanceof Array === true

           new Object() instanceof Array === false

        若Student.prototype = new Person()

            原型会指向构造器，会向上找原型的原型这样也是true

    ！！！不同window或iframe间的对象类型检测不能使用instanceof

    Object.prototype.toString适合内置对象和基元类型，null，undefined失效

                 Object.prototype.toString.apply([]) === "[object Array]"

                Object.prototype.toString.apply(function(){}) === "[object Function]"

                Object.prototype.toString.apply(null) === "[object Null]"

                Object.prototype.toString.apply(undefined) === "[object Undefined]"

    constructor（会被改写）指向构造这个对象的构造器或是构造函数

    duck type判断是否有join，push，length这样的方法来判断是什么类型

var str = "string"; //string对象

var strObj = new String("string");// 包装对象

“1.23”== 1.23

0 == false

null == undefined  相等

new Object() == new Object()

[1,2] ==[1,2]

1 == true 布尔转number

object == number | string  尝试将对象转为基本类型

        new String("hi") == "hi"//true

===严格等于

类型不同，返回false

类型相同，null===null

                undefined===undefined

                NaN != NaN 自己和自己比较也不相等

                newObject ！= newObject  因为对象比较的不是值是引用