作业---JavaScript 函数

作业一  ：用递归函数实现1-100的累加
 

   <script>
        //递归函数实现1-100的累加
        //第一步 创建一个函数
        function sum(num) {
            //第三步 结束条件
            if (num === 1) {
                return 1;
            }
            //第二部 写出需要出结果的代码
            return num + sum(num - 1);

        }
        var res = sum(100);
        console.log(res);
    </script>

作业二： 写一个函数能输出任意两位个位数之间能组成的奇数的个数

方法 一 ：组建数组方式 

 <script>
        //编写一个函数，计算任意两个数字之间所能组成的奇数个数，数字必须是个位数
        function odd_number(a, b) {
            //第一步 首先判断传入的数字 是否会数字类型
            a = +a;
            b = +b;
            //如果不能转化为数字类型 boolean值则会为false
            if (!String(a) || !String(b)) {
                alert("请输入正确的数字");
            }
            //第二步 把传入的两个数字中的所有数字 找出来组成一个数组
            //先比较选出小的数字
            if (a > b) {
                var tem = a;
                a = b;
                b = tem;
            }
            //用循环 从a和b中找出中间的所有值,并组成一个数组
            var arr = [];
            //创建一个可以存放奇数的数组
            var odd_arr = [];
            for (var i = a; i <= b; i++) {
                arr.push(i);
            }
            // 第三步 遍历arr数组  拼接两个数字 并判断是否为奇数
            for (var k = 0; k < arr.length; k++) { //第一层  找十位数
                for (var j = 0; j < arr.length; j++) {
                    //如果遍历后 两个数字相等 则不输出继续循环
                    if (k == j) {
                        continue;
                    }
                    //判断是否为奇数 是奇数就添加在数组里面
                    if ((arr[k] * 10 + arr[j]) % 2 != 0) {
                        odd_arr.push(arr[k] * 10 + arr[j]);
                    }

                }

            }
            console.log(a, b);
            console.log(arr);
            console.log(odd_arr);
        }
        odd_number(6, 0);


    </script>

方法二：利用两个数字的最大最小值进行循环实现数字组合 （推荐）

    <script>
        function fn(n, m){ 
        	// 比较n，m大小，令n<m
            if(n > m){
                var t = n;//必须比较一下，为后面的循环边界做准备
                n = m;
                m = t;
            }
        
        for( var i = n; i <= m; i++){ //十位数 从最小的开始 
            for(var j = n; j <= m; j++){ // 个位数 从最小开始  
                if(j % 2 == 1 && i != j){ // 个位数不能被2整除 并且两个数字不能相同
                    console.log(''+ i + j);
                }
            }
        }
    }
	fn(4,7)
    </script>

作业三：创建一个加密和解密四位整数的函数。

<script>
    /* 加密函数
    创建一个加密和解密四位整数的函数。
  加密函数规则:
  - 只能加密4位整数(如:1267)
  - 判断每一位数字，如果小于5，该数字加5，否则该数字减5
  - 第一位数字和第三位数字交换位置，第二位和第四位交换位置
      解密函数:
  拿到加密后的数字可以调用解密函数显示原始数字。 */
  //把比较独立的逻辑（重复的逻辑）写在一个函数里面，通过调用对应的函数拿到想要的结果
/* ---------------------------------------------------------- */
    //加密函数  / 解密函数 
    function addCode (key){
        //判断每一位数字，如果小于5，该数字加5，否则该数字减5
        if (key < 5 ){
            return key + 5;
        }
        else {
           return key -5 ;
        }
    }
/* ---------------------------------------------------------- */
  //创建一个函数  一个参数为四位整数的函数 
  function code (num){
    //判断传入的参数是否为整数
    num = +num ;
    //判断是否是NaN值  isNaN(num) 如果是则提示用户重新输入
    if (isNaN(num)){
        alert ("请重新输入4位数字");
    }
    //如果不是NaN值 则拆分4位数
    var a,b,c,d ; //设置四个变量 放四个位数
   a = parseInt(num / 1000)  //千位 取整
   b = parseInt((num -a*1000 )/ 100) //百位数 =（num - 千位数 ） / 100
   c = parseInt((num - a*1000 - b*100 ) / 10 )//十位数 = （num -千位数 - 百位数） / 10
   d = parseInt (num - a*1000 - b*100  - c*10 ) //个位数 （num - 千位数 -百位数 -个位数）
   
/* ---------------------------------------------------------- */    
   //调用加密函数  (输出的时候调换位置 第一位数字和第三位数字交换位置，第二位和第四位交换位置)
   console.log(addCode(c)*1000 + addCode(d)*100 + addCode(a)*10 + addCode(b));
  }
   code(1308);
 </script>

作业四： 二维数组输出

    <script>
        /* 
            二维数组输出
            [[1,2,3],[4,5,6],[7,8,9]]  
                用代码将原数组改为以下数组
            [[1,4,7],[2,5,8],[3,6,9]] 
        */
            var arr =[[1,2,3],[4,5,6],[7,8,9]];
            //创建一个新数组
            var arrNew = []
            for (var i = 0 ; i < arr.length ; i++ ){ // 遍历外层数组 
                for (var j = 0 ; j < arr.length  ; j++){ //遍历内部的数组
                    //需要判断一下新数组里面有没有元素 ,没有元素需要添加一个空数组
                    if (!arrNew[i]){ //空的Boolean值就是false  取反就是true
                        arrNew[i] = [];
                    }
                    //arrNew[0][0] = arr[0][0] ;arrNew[0][1] = arr[1][0];arrNew[0][2] = arr[2][0] 
                    arrNew[i][j] = arr[j][i];
                }              
            }
            console.log (arrNew);
    </script>
</body>

作业五：深拷贝对象

 <script>
        //对象的深拷贝 
        //创建对象person1 
        var person1 = {
            name: "lisi",
            age: 10,
        // frend属性数组是一个引用数据类型，对应的是一个内存地址
            frend: ["a1", "a2", "a3", { name: "lisi", age: 10 }], 
           family: {  // family属性是引用数据类型，也是一个内存地址。
                number: 123,
                address: "四川成都",
                o1: { // 思考，如果是多层次的引用数据类型嵌套，怎样拷贝?
                    o2: {
                        name: "a1"
                    }
                }
            }
        }
        //创建一个函数
        function deepCopy(copyObj) {
            //创建一个空的内存地址 把copy过来的对象存放进来
            var obj = " ";
            //1.判断传入的对象属性是否是数组 如果是数组则遍历数组 然后赋值拷贝obj
            if (Array.isArray(copyObj)) {
                obj = [];
                for (var i = 0; i < copyObj.length; i++) {
       //因为数组的每个元素也有可能是对象数据，所需要调用递归去判断类型在返回对应的数据
                    obj.push(deepCopy(copyObj[i]));
                }
                //返回 obj数组
                return obj;
            }
            //2.判断传入的对象属性是否时对象 如果是对象 则遍历对象赋值拷贝obj
            else if (typeof copyObj === "object") {
                obj = {};
                // 遍历对象赋值拷贝obj
                for (var key in copyObj) {
      //因为object中也有可能有数组属性，所以需要用递归函数去判断类型
                    obj[key] = deepCopy(copyObj[key]);

                }
                //返回对象
                return obj;
            }
            //返回copyObj 
            return copyObj;
        }
        var peo1 = deepCopy(person1);
        console.log(peo1);
    </script>