JS---函数 （作用域）、递归、对象

作用域：变量起作用的范围称为作用域。

var nm=100
function fn()
{    
    //局部作用域
    var num1=200
}

作用域分为全局作用域和局部作用域

局部作用域：在函数体中作用范围

全局作用域：在整个JS代码起作用

内层可以访问外层作用域变量，外层不可访问内层作用域范围变量！！

 <script>
        var num = 100
        function fun1() {
            var num1 = 200
            console.log('fun1 num ', num)

            function fun2() {
             var num2 = 300
             console.log('fun2 num ', num)//如果上级作用域没有，接着向上找，直到全局作用域，
             console.log('fun2 num ', num1)//如果当前作用域没找到，到上级作用域找
             console.log('fun2 num ', num2)//当前作用域
             console.log(num3)//如果全局作用域也没有，直接报错
                
                }
                fun2()
            }
            fun1()
        
    </script>

 赋值规则：

 var num = 100
        function fun1() {
            var num1 = 200

            function fun2() {
                var num2 = 300
                num1 = 400
                num = 500
                num3 = 600  //当前作用域查找，上级作用域查找，全局作用域查找，都没找到，将创建全局变量，然后赋值

            }
            fun2()
        }

 作用域链：

变量访问或赋值时，先在自己的作用域查找，如果没有找到，再一层一层向上查找，到最外层作用域。这种层层查找关系，叫作作用域！

递归函数：函数自身调用自身，这样的函数被称为递归函数

注意哦，要有递归结束的条件！还要改变递归条件！！

递归可以解决哪些问题：后面结果由前面推导出来的，可以采用递归简化实现。

例如求1+2+3的和：

function f(n){
    if(n==1){
    return 1
    }
returnf(n-1)+n
   }
var sum=f(3)
 console.log(sum)

 例如求1*2*3*4*5的积：

 function f(n) {
            if (n == 1) {
                return 1
            }
            return f(n-1) * n
        }
        var sum = f(5)
        console.log(sum)

对象：

现实生活中对象，具体的一个事物称对象；每个对象有自己的特征行为。

在软件世界上，同样有对象，用object表示，行为：属性 ；特征：方法。

创建对象
（有字面创建和new语句 构造函数创建对象，下面为字面创建）

    var jackObj={ }   / / 创建对象

    var jackObj={ name:'jack',    //姓名属性 name属性名和jack属性值构成
                  age:18         //年龄属性 age属性名和18属性值构成
                }  

 <script>
        //1创建一个姓名为rc,年龄18，姓别女的对象
        //obj称为对象，可以叫引用变量
        //通过对象名访问对象属性，对象名，属性名-->属性值
        var obj={
            name:'rc',
            age:18,
            sex:'女'
        }

        //2访问对象给定的属性值
        console.log('name:', obj.name)
        console.log('age:',obj.age)
        console.log('sex:',obj.sex)

        //3修改属性值
        obj.name='rose'
        console.log('name:',obj.name)

        //4删除属性值
        delete obj.name
        console.log(obj)

        //5添加属性
        obj.score=98
        console.log(obj)

        //6遍历对象 for-in
        for(var key in obj){
            //key='name'   key='age'....
         console.log('key',key)
        }

        //7访问属性值，属性名是变量情况,我们需要写中括号！
        console.log('name ',obj.name);
        var_name='name'
        console.log(obj[_name])


    </script>

基础数据类型有五种，而我们创建的对象属于复杂数据类型里面的对象数据类型！创建键值对的组合！

 <script>
        // 创建一个名为student的学生对象，有属性学号num,性别sex,班级grade, 成绩score, 姓名name
        // 分别用字面量方式和构造函数方式创建.
        // 要求打印显示学生信息到页面


        var student={
            name:'zs',
            num:1910,
            sex:'男',
            grade:'h5',
            score:80
        }
        //访问
        console.log('name',student.name);
        console.log('num',student.num);
        console.log('sex',student.sex);
        console.log('grade',student.grade);
        console.log('score',student.score);

        //添加属性
        student.hoby='play'
        console.log(student)
        

        //遍历
        for(var key in student){
            console.log('key',key,'value',student[key])
            console.log(key)
        }
    </script>

用new语句创建对象（构造函数）

    <script>
        var obj=new Object()
        obj.name='jack'
        obj.age=18
    </script>

数组的基础知识： 

 // 数组 Array 
            // 1：作用存储一系列有序数据的集合

            // 2：创建数组
            // var arr=[ ] 创建一个空数组
            // var arr=[ 1，2，34，true，'jack']

            // 3.索引号

            // 4.访问数组元素
            //     arr[0]

            // 5.数组长度（元素个数）
            // lenght 属性
            // arr.lenght
            
            // 6.遍历数组

            // 7.创建数组方式
            //   构造函数
            //     var arr=new Array()空数组
            //     字面量
            //     var arr=[]空数组




            // 1.创建数组
         var arr=[10,20,30,40]

            //2.访问数组元素
            console.log('arr[0]:', arr[0], 'arr[1]:', arr[1])

            //3.数组长度（元素个数）
            console.log('lenght>>:',arr.length)

            //4.遍历数组，循环变量表示数组索引号从0开始
            for(var i=0;i<=arr.length;i++){
                console.log(arr[i])
            }
            // 5.构造函数创建数组
            var arr1=new Array(100,200,300,400,500)
               for(var i=0;i<arr1.length;i++){
                console.log(arr1[i])
               }

             //6.创建数组只有一个元素，表示创建一个空数组长度是5  lenght=5
               var arr2=new Array
               console.log('arr2.lenght>>>>',arr2.length)
               for(var i=0;i<=arr2.length;i++){
                console.log(arr2[i])
               }

             //7.直接控制台打印
               console.log(arr);

数组例题：

    <script>


        // 创建一个学生成绩数组，存储所有学生的数学成绩，分别是89,78,90,99,67,59
        var scoreArr = [89, 78, 90, 99, 67, 59]

        //求所有学生的最高分并输出在界面
        //假设第一数为最高分
        var max = scoreArr[0]

        //依次与后面的分数相比，如果大于max,就赋值给max
        for (var i = 1; i < scoreArr.length; i++) {
            if (scoreArr[i] > max) {
                max = scoreArr[i]
            }
        }
        console.log('最大值',max)

        // if(scoreArr[1]>max){
        //     max=scoreArr[1]
        // }
        // if(scoreArr[2]>max){
        //     max=scoreArr[2]
        // }
        // if(scoreArr[3]>max){
        //     max=scoreArr[3]
        // }
        // if(scoreArr[4]>max){
        //     max=scoreArr[4]
        // }
        // if(scoreArr[5]>max){
        //     max=scoreArr[5]
        // }
        // console.log('最大值',max)


        //4.求不及格的学生有几个，打印到界面
        //    分析：遍历学生成绩数组，与60比较，小于则不及格，计数器加一
          var count=0
        for(var i=0;i<scoreArr.length;i++){
            if(scoreArr[i]<60){
                count++
            }
        }
        console.log('不及格人数',count)

    </script>

若有不正确的地方，敬请指正！