通过 Object.getOwnPropertyDescriptor(Object（查看的对象）,'prototype'（查看的属性）) 来获取Object 对象上的属性标签prototype描述。toString 是原型链上的属性，是存在的，所以ture

判断对象原型上是否有那个属性：obj.hasOwnProperty("z"),如果返回true，则含有，反之，没有。

in 和 hasOwnProperty
in是判断该对象是否具有所要查找的属性
而hasOwnProperty则是判断该对象的实例是否具有所要查找的属性
因此可以自定义一个查找对象属性所在位置的函数：
function hasProperty(obj,property){
return obj.hasOwnProperty(property) && property in obj;
}//返回true时表示该属性在它的实例上，否则就在原型上

所有函数x都有prototype属性，且这个属性是一个对象。
且x.prototype也有原型即Object.prototype。 注意这个原型里有一些默认的方法。
查找属性是按原型链 自下向上 查找。
所以如果下 和 上 有相同的属性名，那么肯定是下的起作用。
删除属性：delete 对象名.属性名
三种构造对象的方法如下：

方法1：（字面量）

 var a={x:1,y:2}

var b={x:1,y:2,

z:{ n:3,m:4}} 

var obj={z:78,y:"asd",o:{oo:"ooo"}};
obj.x="123";

方法2，（new/原型链）

通过new
function foo(){}//创建一个函数对象
foo.prototype.z=3;//这个函数对象默认带一个prototype的属性；

function wc(){};
var ko=new wc();
ko.t=123;

方法3，（Object.create）

var haha=Object.create({x:12,y:"nini"});

对象的一个特点：属性可以动态的添加或者删除。

prototype 是对象自带的属性对象
对象构造：
除了本身被赋予的值之外，对象还有几个隐藏标签：
proto：对象的对象属性prototype上的赋值
class：对象的种类
extensible：是否允许该对象继续增加新的属性

另外对象的值(如 x=1)，也有对应的属性或方法，提供一些访问权限的控制
writable：是否可写
enumerable：是否能被删除
configurable:是否能够枚举
value：值
get/set：

函数声明：会被预先处理（或者叫函数前置/钳制），so，在声明之前调用该函数不会报错lalala...
函数表达式：
除了这两种方法之外，还可以通过new function构造器的方式，去创建函数对象。

1、左边为“函数声明”，右为这“函数表达式”；
2、“函数声明”可以在声明前执行（称之为“前至声明”），而“函数表达式”即不能；

当将一个定义过的类型像对象一样访问属性，系统会自动将他们转换为对象，但当访问结束后会还原。

“===”大部分用于判断类型和值都相等的情况，但NaN不等于NaN！

当判断字符串==数值类型的时候，系统会尝试把字符串转换为数值类型进行判断。

数组、Date、函数等等类型的可编辑并具有功能性的单位属于对象！

特殊运算符的种类：
1、条件运算符 c?a:b c为true 则取a,否则取b
2、逗号运算符 a,b 例如 var s = (1,2,3),则s依次赋值，最后输出为3
3、delete运算符 delete obj.x 删除对象obj中的x属性 在IE9下，obj中必须configurable:true 才可以删除，否则无效
4、in运算符 判断obj是否有值或window里是否有变量，返回布尔值 例如 attr in json 或 'document' in window
5、instanceof 判断对象类型 {} instanceof Object // true（返回布尔值）
6、new运算符 创建一个新对象 new obj / new array ...
7、this对象 全局用指向window，函数内指向函数本身，浮动指针
8、typeof 判断对象，返回对象类型 例如 typeof 100 === 'number' // true（判断对应类型字符串）
9、void 一元的，判断所有值，返回均为undefined

一般delete 运算符可以删除对象的属性，而如果使用方法Object.defineProperty(对象,'属性',{configurable:false})处理了对象，该属性就不会被删除，反之ture就是可以被删除。

1. 原始表达式 //常量、直接量、关键字、变量
   常量,直接量  3,14  "test"
   关键字 null  this  true
   变量 i,j,k
2. 初始化表达式
   [1,2]   new Array(1,2)
   [1,,,4] [1,undefined,undefined,4]
   {x:1,y:2} var o=new Object();o.x=1;o.y=2;
3. 函数表达式
   var fe = function(){}
   (function(){})()
4. 属性访问表达式
   var o = {x:1}、o.x、o['x']
5. 调用表达式 //func()
6. 对象创建表达式
   var temp=new Func(1,2)//有参数,没有参数时也可以把括号直接去掉
   var temp=new Object;//没有参数
   { x : 1, y : 2} 等价于 var o = new Object();o.x = 1; o.y = 2;

1. 类型检测
   1）typeof（基本类型检测）
   对所有基本类型的返回值
   typeof Number  //“Number”
   typeof String  //"string"        typeof "123"返回“string”

   typeof Boolean //"boolean"
   typeof null    //"object"            typeof null是个例外，为了解决兼容性的问题，不是返回“null”，而是返回“object”
   typeof undefined   //"undefined"
   typeof object  //"object"  
   对函数类型的返回值
   typeof function    //"function"    typepeof Student（Student是已定义的函数）返回“function”
   
   2）instanceof适合自定义对象，用来检测原生对象，返回值是true或者false。

   由于typeof只适用于判断基本类型，对object,Date,Array进行检测时只会统一返回“object”（很显然这不是我们想要的，我们想知道它的具体类型），这时就要用到instanceof了，instanceof在检测对象时会返回具体类型，如：
   new array() instanceof Array //true     [1,2,3,] instanceof Array返回true
   new Date() instanceof Date   //true
   ...
   如果想用instanceof去检测基本类型只会统一返回false，另外由于instanceof是基于原型链的，所以有下列结果：
   

    //定义父类
    function Parent(){}
     //定义子类

    function Child(){}
    //让子类继承父类
    Child.prototype = new Parent();
    //此时再new一个子类实例，使用instanceof
      new Child() instanceof Child;    //true
    new Child() instanceof Parent    //true
    通过原型链索引，new的是子类实例，子类继承父类，所以子类实例既是子类类型又属于父类类型
    PS：instanceof在跨iframe或者window时由于存在多个window对象，所以在使用instanceof检测时会返回false

    3）Object.prototype.toString().apply[[Class]],适用于内置对象
      和基本类型，遇到Undefined和null失效(IE678返回"[object Object]")
      ,如Object.prototype.toString().apply([1,2,3])返回
      "[object Array]"

一、隐式转换：巧妙用“+”和“-”规则转换类型

1、num-0：变为数值       2、num+"":变为字符串

当想要把字符串变为数值时：
字符串与数字之间的加号理解为字符串拼接“123”+65=“12365”

减号理解为运算 “123”-65=58

二、a==b 与 a===b 的区别：
1、类型相同时比较具体数值
2、类型不同时：
    1）==：尝试类型转换：
            string => number 把字符串变为数值再进行比较
            ture   => 1            把布尔值变为数值再进行比较
            false  => 0
            object => 基本类型（涉及包装类）
    2）===： 直接返回false

=:表示赋值，比如a=3;就是把3放到a里面
= =：表示等于，3= ="3";会返回true，因为浏览器内部会把字符串3变成数字3
= = =：表示严格等于，不会转换数据类型3= = ="3"，会返回false，因为不会转换他们的数据类型，数字和字符串当然就不相等了
对象和对象比较，是比较的引用，两个对象都是new出来的（新创建出来的），所以是不同的对象，不同的对象的引用是不同的，所以输出是false
只有对象和基本类型进行比较的时候，才会将对象转变成基本类型，再作比较。两个对象比较的时候是不会转成基本类型的，如：
var a = new String('hi');
var b = new String('hi');
a == 'hi';//true （先转换成基本类型再比较）
b == 'hi';//true（先转换成基本类型再比较）
但是 a == b;// false  （比较的是引用）