JavaScript笔记（5）

1.return 跳出当前函数 返回一个结果

<script>
    //return可以跳出当前函数  所以return写在函数的最后一行
    function out() {
            return function (){
                console.log("inner-before")
                return "inner-fn";
                console.log("inner-end")
            };
    }

    var inner = out();
    var str = inner();
    console.log(str); 
</script>

输出:
   inner-before
   inner-fn
因为inner-end 写在return的后面，所以代码没有被运行，也就没有输出

<script>
    
    function test() {
        var a = "a";
        console.log(a);
    }
    test();
    console.log(a);
输出结果为：a

还报了一个错误：a is not defined
因为a变量的值是定义在局部作用域中的
所以外面的 console.log(a)全局作用域访问不到里面  取不到定义的a变量的值

<script> /*全局作用域*/

   
    function out() {
           
            return function inner(){
                return "inner-fn";
            };
    }

   var inner =  out() ;

</script>                                           

this指向于谁
        得看函数调用位置上的调用形式
            普通调用        指向  -->                            window
            隐式调用        指向  -->                            调用对象
            显示调用        指向  -->                            指定对象
            构造调用        指向  -->                            构造出来的对象(实例)

this的值必定是引用类型

<script>
    function test(a,b,c,d,f,){

    }
console.log(test.length);

</script>
输出结果为：5

length属性表示形参的个数

    function test(flag,flag1) {
        console.log(this,flag,flag1)
    }
    test("普通调用","普通调用2")
    test.call({a:"a"},"call调用","call调用2");         call函数的第二个参数 是当前函数的第一个参数
    test.apply({b:"b"});

 call() apply()调用（显示调用） 相比于 普通调用 可以改变 函数内部的this指向  
 call() 和 apply() 传参方式不一样

分三步：
1.创建一个新的对象  --->原型
2.将this指向新的对象
3.默认构造函数的最后一步
       return undefined
             因为undefined是基本数据类型
                 return 新的对象

JS中是不存在构造函数的定义语法的，只有函数的构造调用，当一个函数被构造调用时（new），
当前这个函数就可以被认为是一个构造函数。
构造调用：

function Person(name,age) {
　　this.name = name;
　　this.age = age;
}

//无参构造调用 new Person
// 构造调用的时候 函数执行的最后一步: return this 这是一个隐式的操作
// 普通调用的时候 函数执行的最后一步: return undefined 这是一个隐式的操作

数组是一个有序的数据集合（数据可以是原始类型 或 引用数据类型）var arr=[];
相对于变量 ，数组可用于在一个变量中存储多个值。
数组中的每一项都有一个数字附于其上，被称为索引。JavaScript，数组索引 从0开始
JS数组中是可以自动扩容的

静态方法（构造函数身上的方法）：

isArray :判断是否是数组
obj:需要检测的值
返回值：如果对象是Array,则为true；否则为false.
语法：Array.isArray(obj)

实例方法（实例身上的方法）：

输出结果为：[2，3,4,5,6,7,9]
第一步，先用sort()方法对数组进行排序。
第二步，创建一个新的空数组用来存放去重之后的数组
第三步，默认放入排序后数组的第一个元素，然后判断数组中的每一个元素是否等于当前元素的前一个元素，再用push()方法，如果相等就不放进去新的数组，如果不相等就放入新的数组。

var arr =new Array(4) //不会拿undefined来填充默认值 empty *4
var arr[];arr.length=4

具有length属性的对象（属性名是字符串类型的数字）
通常拿到一个伪数组时，都需要将伪数组转为真数组（通过Array.prototype.slice.call/apply）将伪数组转换为真数组

　　var obj ={};
　　　　　　obj.length=3;
　　　　　　obj["0"]="a";
　　　　　　obj["1"]="b";
　　　　　　obj["2"]="c";

//每一个实例对象的实例方法 都是去 它构造函数的原型上找的
　　　　var arr = Array.prototype.slice.call(obj)
　　　　　　　　console.log(arr);
　　　　　　　　　　arr.map(function (item) {
　　　　　　　　　　　　　　console.log(item)
　　　　　　　　})

arguments（函数内部属性）是一个类数组

包含着传入函数中的所有参数。虽然 arguments 的主要用途是保存函数参数，

但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。

从 ES5  规范开始就允许在列表（数组值、属性列表等）末尾多加一个逗号（在实际处理中会被忽略不计）。
所以如果你在代码或者调试控制台中输入 [ , , , ] ，实际得到的是 [ , , ] （包含三个空单元的数组

function factorial2(num) {

// console.log(arguments.callee == factorial)

   if(num<=1){
    return 1;

    }else{

     return num * arguments.callee(num-1);
  }

}
   var res = factorial2(4);
   console.log(res)

//递归的思想  自己调自己

用argument.callee指代函数自己本身

语法： var arr = [[]];

  var arr = [[3,8,2],[2,7],[9,0,1,6]];

     for(var i=0;i<arr.length;i++){
         for(var j=0;j<arr[i].length;j++){
              document.write(arr[i][j]+"&nbsp;&nbsp;");
    }
         document.write("<br/>");
   }