对象的枚举遍历及this环境

对象的枚举

for in
1.hasOwnProperty
2.in
3.instanceof

var arr = [1,3,3,4,5,6,7,8,9];
/遍历  枚举 enumeration
for(var  i  =  0;  i  <  arr.length;  i++)  {
      console.log(arr[ i ]);
}
var  obj = {
      name : '13',
      age  :  123,
      sex  :  'male',
      height  :  180,
      weight  :  75
}
for(var  prop  in  obj)  {
    console.log(prop  +  " "  +  typeof(prop));
}会把所有obj的属性名显示出来  类型是string
如果是打印属性值 就console.log(obj[prop]);
但是如果是console.log(obj.prop);/obj['prop']就是
五个underfined
var obj1  =  {
    a  :  123,
    b  :  234,
    c  :  345
}
for (var key  in  obj1)  {
        obj1[key]  ++;
}

var  obj = {
      name : '13',
      age  :  123,
      sex  :  'male',
      height  :  180,
      weight  :  75,
     __proto__  : {
          lastName  :  "deng"
     }
}
Object.prototype.abc  =  '123';
for(var  prop  in  obj)  {
      if(obj.hasOwnProperty(prop)){
              console.log(obj.[prop]);
      }
}
如果是自己的属性方法，就会打印，如果不是，是
原型链的方法，就会排除  所以deng 123 被排除
hasOwnProperty是用来甄别是不是自带的属性方法

A instanceof B
看A对象的原型链上 有没有B的原型 返回true/false

区别数组和对象的三种方法
1.用 .constructor

2. instanceof
   [ ] instanceof Array -->true
   var obj = {} obj instanceof Array -->false

3.用toString
Object.prototype.toString = function (){
识别this
返回相应的结果
}
obj.toString();
object.prototype.toString.call([ ]);
return "[object Array]"
object.prototype.toString.call({ });
return "[object object]"

this

1.函数预编译过程 this-->window
2.全局作用域里 this--> window
3.call/apply 可以改变函数运行时this指向

4. obj.fun(); fun()里面的this指向obj

var name  =  'window1';
var obj  =  {
    name  :  'obj'
    say  :  function(){
        console.log(this.name);
    }
}
obj.say ();    -> obj
obj.say.call(window)  ->window1(相当于打印了
window.name,也就是归全局变量的那个var)
var fun  =  obj,say;
 //相当于  = function(){
//        console.log(this.name);
//    }
fun();没有人调用，只能走预编译环节 this指代
window 所以结果是 window1；

arguments

arguments.callee 本身的意思 打印就是返回自己

function test () {
   console.log(arguments.callee  ==  test);
}
test();        return  -->  true

var  num  = (function (n)  {
      if(n  ==  1){
            return  1;
       }
      return  n*arguments.callee(n-1);
 }(20))计算20阶乘

func.caller

function test () {
demo();
}

function  demo () {
      console.log(demo.caller);
}
test();
demo被调用的哪个环境  caller就指代谁

 var foo = 123;
function print() {
   this.foo = 234;
   console.log(foo);
}
print();     return 234; 
这里的foo指代的是全局里的  而this就是指向全局
把外面的123覆盖了 所以成了234

 var foo = 123;
function print() {
    /var  this =  Object.create(print.prototype)
   this.foo = 234;
   console.log(foo);
}
  new print();   return 123；
在new执行时生成了~  this有对象可指了 所以不指代window了