二维数组 函数

二维数组

通过两个下标（索引）来锁定一个元素，是一维数组的叠加

创建方法：

  var info = new Array(
           new Array('刘备','男',23),
        //    第一行
           new Array('张飞','男',24),
        //    第二行
           new Array('关羽','男',25),
        //    第三行
       )

数组名[下标1][下标2]

默认：按照行优先，第一个下标是行下标，第二个下标是列下标

   var str = ''
       for(var i=0;i

练习:求一个3*4的二维数组的每行元素之和

 var arr =[
           [10,20,30,40],
           [1,2,3,4],
           [5,6,7,8]
        ]
       console.log(arr)
       for(var i=0;i

求1！+2！+3！+...10!

  var res=0;
    var equ=1;
    for(i=1;i<=10;i++){
        for(j=1;j<=i-1;j++){
        equ=j*i;
        }
        res+=equ;
    }
    console.log('1!+2!+3!+...+10!=',res);

插入一个数并按照大小排序

计算a+aa+aaa+aaaa+aaaaa

   var a=prompt('请输入一个整数：')
    var n=prompt('请输入位数：')
    var t=a;
    var sum=0;
    var str=''; 
    while(n>0){
        str+=t+'+'
        sum+=t;
        t=t*10+a;
        n--;
    }
    str+='='+sum
    console.log(str)

函数

可以实现某种功能的代码块，可以重复使用

声明函数：

function 函数名（[参数]）

{

函数体语句

}

1.function是关键字

2.’函数名‘是标识符

3.函数可以有参数，也可以没有参数(无参函数)，也可以有多个参数，（）不能能省略

4.{}表示函数的作用范围，不能省略

函数调用

function getSum()     //无参函数

{

  var sum = 0;

for(i=1;i<100;i++){

   sum+=i;

}

return sum;

}

var s=getSum(); //函数调用：从调用开始执行函数

console.log('1+2+3+...+100=',getSum())

函数分类

1.有返回值函数

function 函数名（）{

return 需要返回的结果；}

函数名（）；

函数名（）= return后面需要返回的结果

终止函数，后面的内容不会被执行

返回的结果是最后一个值，如果要返回多个值，可以用return返回一个数组

2.无返回值函数

通常只实现某种功能

function 函数名（形参1，形参2..）{

}

函数名（实参1，实参2..）

实参把值传递给形参，单向传递

函数的参数可以有，也可以没有，个数不限，可以是数字、字符、数组

用变量接受函数的返回结果

函数声明方式

1.命名函数

function 函数名 （[参数]）{}

函数名（）

2.函数表达式（匿名函数）

var 变量名 = function （）{}

变量名（）

var fn=function(aru){
  console,log('我是函数表达式');
  console.log(aru);
}
fn('pink');
//函数表达式也可以传递参数

//用函数反转数组  reverse反转
function reverse(arr){
  var newArr=[]
  for(var i=arr.length;i>0;i++){
  newArr[newArr.length]=arr[i];
  }

return newArr
}
var arr1=reverse([1,2,3,4,5])
console.log(arr1)
var arr2=reverse(['pink','yellow','blue'])
console.log(arr2)

//函数封装冒泡排序   sort排序
function sort(arr){
  for(var i=0;iarr[j+1]){
           var temp=arr[j];
           arr[j]=arr[j+1];
           arr[j+1]=temp;
      }
    }
   return arr;
  }
var arr1=sort([1,2,4,9]);
coonsole.log(arr1)

//函数判断闰年
function isRunYear(year){
//如果是闰年返回true，否则返回false
var flag=false;
if(year%4==0&&year%100!=0||year%400==0){
  flag=true;
}
return flag;
}
console.log(isRunYear(2008));
console.log(isRunYear(2007));

//函数可以调用另一个函数
function fn1(){
console.log(11);
fn2();
//在函数fn1里调用了fn2
}
fn1();
function fn2(){
   console.log(22);
}

//输出二月份的天数
function backDay(){
   var year = prompt('请输入年份：'); 
   if(isRunYear()){
   alert('当前年份是闰年2月有29天');
   }
   else{
   alert('当前年份是平年2月28天');
}
backDay; 
//函数判断闰年
function isRunYear(year){
//如果是闰年返回true，否则返回false
var flag=false;
if(year%4==0&&year%100!=0||year%400==0){
  flag=true;
}
return flag;
} 

 // 把二维数组用字符串显示
         function showArray(arr){
            //  arr为形式参数,占位符
            var str='';
             for(i=1;i

练习：判断一个数是否是素数，输出1-100以内的素数

  //定义判断素数的函数：形参的设置和函数返回值的使用
function getSushu(num){
            var flag=true;
            for(i=2;i<=num;i++){
                 if(n % i==0){
                    flag=false;
                    break;
                 }
                 return flag;
                }
        }
      
    //函数调用：输出一百以内的素数
        for(k=1;k<=100;k++){
                if(getSushu(k)){
                  console.log(k);
                }
               
            }

定义一个函数，判断是否是水仙花数，输出一千以内的所有水仙花数

  function shuiXh(num){
            var flag=true
            if(1000>num>100){
               a=parseInt(num/100)
               b=parseInt(num/10%10)
               c=parseInt(num%10)
            }
                
            if(num!=a*a*a+b*b*b+c*c*c){
                flag=false;
            }
            return flag
        }
        for(i=100;i<=1000;i++){
            if(shuiXh(i)){
                console.log(i)
            }
        }

内聚：模块内部结合的紧密程度

耦合：模块之间结合的紧密程度

高内聚，低耦合

关于函数参数：形参和实参的个数可以不同

实参个数大于形参个数  多余实参会被忽略

实参数量小于形参，多于形参没有值，undefined，NaN

arguments的使用：定义函数时，函数有一个隐含的内置对象arguement，保留了函数调用时传递的所有实参

具有数组的length属性，按照索引的方式存储的，可以实现遍历，伪数组

    function fn(){
            //    定义函数,没有参数
                 console.log(arguments)
                //  输出调用函数时传递的所有形参
                 console.log(arguments.length)
                //  arguments是一个数组
                 console.log(arguments[2])
                //  输出第三个实参
           }
          fn(11,22,33)

DOS指令

磁盘操作系统    

目录：对应windows下面的文件夹

简单的dos指令

1.目录转换：cd 目录名

        cd\：退回根目录     cd..:返回上一级目录  

2.查看当前目录下的文件将或文件夹：dir

         dir/p:分屏显示文件和子目录    dir/w:宽屏形式文件和子目录  []里面是文件夹   

        .:表示当前文件夹   ..:表示当前文件夹的上一级文件夹

3.创建目录（新建文件夹）：md 目录名

4.删除目录（删除文件夹）：rd 目录名 //被删除的文件夹不能有子目录，为空

nodeJS

语法和js基本一致，搭建了js的运行平台，js不依赖浏览器，直接通过nide编译运行

函数

利用函数找数组中的最大值

function getMax(){
    var max = arr[0]
    for(i=1;inum2?num1:num2
}
var n=getMax(22,'23')
console.log('Max=',n)

利用函数输出数组

function getResult(num1,num2){
    return[num1+num2,num1-num2,num1*num2,num1/num2]
}
var a=getResult(5,7)
console.log(a)

利用函数反转数组元素

function reverse(arr){
    var i=0;
    var j=arr.length-1;
    while(i

函数表达式

把函数的值赋给一个变量，通过变量完成对函数的定义、调用、参数传递

var 变量名=function[(参数)]{

函数体语句

}

var sum=function(n,m){
    //将匿名函数赋值给变量，通过变量调用该函数
    var s=0;
    for(var i=m;i<=n;i++){
        s+=i
    }
    return s
}
console.log('函数表达式:',sum(1,100))

回调函数

把一个函数a作为参数传递给一个函数b，在函数b的函数体内调用函数a，把a叫回调函数

function a(num1,num2,fn){
    //fn表示函数
    return fn(num1,num2)
    //调用函数，num1和num2作为参数
}

var t=a(12,23,function(a,b)
//function为回调函数
     {
         return a+b
     }
);
var k=a(23,34,function(a,b){
    return a*b
}
);
console.log(t)
console.log(k)

递归函数（调用）

函数自己调用自己

用递归解决问题的前提条件a.问题可以分解：将复杂问题分解成简单问题b.分解后新问题的解决办法和老问题一样c.分解过程有明确的结束条件，不是无限循环

1.自上而下分解问题

2.自下而上回溯得到问题的解

入栈 出栈

//求阶乘的函数
function fun(n){
    //计算n！
    if(n==1||n==0){
        //递归地结束条件
        return 1
    }
    else{
        return n=n*fun(n-1)
        //递归调用：函数自己调用自己
    }
}

用递归函数实现斐波拉契数列

function fib(n){
    if(n===1||n===2){
        return 1
    }
    //第一二项返回1
    else{
        return fib(n-1)+fib(n-2)
    }
     //从第三项开始，每一项等于前两项之和
}
  var str=''
     for(var i=1;i<10;i++){
         str +=fib(i)+'\t'
     }
console.log(str)

用函数递归计算1+2+3+...+100

function sum(n){
    if(n===1){
        return 1
    }
    else {
        return n+=sum(n-1)
    }
}
console.log('1+2+3+...+100=',sum(100))

用递归打印一个整数的每一个数字

function res(n){
    if(n>10){
       res(parseInt(n/10))
    }
     
      console.log(parseInt(res(n%10)))
     }
res(1024)

汉诺塔挪盘子

猴子吃桃子 每天吃一半多一个，第十天剩一个

函数作用域分配

作用域：作用范围

代码名字在某个范围内起作用和效果，为提高程序可靠性，减少命名冲突，可以分为全局作用域和局部作用域

全局变量：在函数外部定义的变量、在函数内部省略var定义的变量，作用范围整个作用域

局部变量：在函数内部使用var关键字声明的变量，之在函数内部有效

区别：全局变量比较占用内存资源，局部变量比较节约内存资源

块级变量：在ES6(ECMASCRIPT6)标准中，用户用let声明的变量，只在语句块中生效

var arr=[1,2,3,4,5,6]
var str=''
for(let i=0;i

闭包的优缺点

闭包在作用域链中的体现

立即调用的函数表达式

立即调用匿名函数

格式：

(function([参数])

{

函数体语句

})()

(
    function(){
        var sum=0
        for(let i=1;i<=100;i++){
            sum+=i
        }
        console.log('1+2+3+...+100=',sum)
    }
)()

定义函数，计算表达式的值

2/1  3/2  5/3   8/5   13/8  21/13...数列前二十项的值

(
    function(num){
        var sum=0;
       var f1=1,f2=1;
       var fn;
       for(var i=1;i<=18;i++){
           fn=f1+f2;
           f1=f2;
           f2=fn;
         
           num=(f2)/(f1);
           sum+=num;
       }
       console.log('此数列前二十项之和为',sum)
        })()

(
            function(){
                var a=2,b=1,c
                var sum=0;
                var str=''
                for(let i=1;i<=20;i++){
                    str+=(a+"/"+b+"+")
                    sum+=a/b
                    c=a+b
                    b=a
                    a=c
                }
                str+='='+sum 
                console.log(str)
            })()