JS笔记之第三天

break关键字：如果在循环中使用，遇到了break，则立刻跳出当前所在的循环

例子：

找到100到200之间第一个可以被7整除的数字

for(var i=100;i<=200;i++){
      if(i%7==0){
          console.log(i);
          break；
     }
  }

continue关键字：在循环中如果遇到continue关键字，直接开始下一次循环

例子：

求100-200之间奇数的和（用continue）

var sum=0;
var i=100;
while (i<=200){
   //判断是不是偶数
   if (i%2==0){
    i++;//这里的i++不能去掉，否则会变成死循环
  //如果是偶数，则跳过这个数字
   continue;
  }
    sum+=i;
    i++;
 }
console.log(sum);

求个位数为多少：  %10

例子：求整数1-100的累加值，但要求跳过个位数为3的数

var sum=0
var i=1;
while (i<=100){
    if (i%10==3){
    i++;
    continue;
   }
    sum+=i;
    i++;
  }
console.log(sum);

 

数组

数组：一组有序的数据

数组的作用：可以一次性存储多个数据

数组的定义：

1.通过构造函数创建数组

语法：

var  数组名=new Array（）；

（数组名是自定义的，相当于变量名，只是换了个说法）

数组的名字如果直接输出，那么直接就可以把数组中的数据显示出来，如果没有数据，就看不到数据

构造函数的方式创建数组的时候，如果是Array（一个数字），则表示的是数组的长度（数组元素的个数）数组中的每个值是undefined。

如果在Array（多个值）；这个数组中就有数据了，数组的长度就是这些数据的个数

例如：var  array=new Array（）；//定义了一个数组

通过构造函数的方式定义一个数组

var array=new Array（）；//（）里面没有数据，是一个空数组

var 数组名=new  Array（长度）；//有多少个数字，就代表了这个数组的长度有多长

2.通过字面量的方式创建数组

var  数组名=【】；//空数组

无论是构造函数的方式还是字面量的方式定义数组，如果没有长度，那么默认是undefined

数组：一组有序的数据

数组元素：数组中存储的每个数据，都可以叫数组的元素。比如：存储了3个数据，数组中有3个元素

数组长度：就是数组的元素的个数，比如有3个元素，就说这个数组的长度是3

数组索引（下标）：用来存储或者访问数组中的数据的

数组的索引和数组的长度的关系：长度减1就是最大的索引值

如何设置数组中某个位置的值

数组名【下标】=值；

arr【3】=100；

如何获取数组中某个位置的值

var  result=数组名【下标】；

console.log（result）；

例如：

var arr=new  Array（）；//构造函数的方式定义一个数组，里面是空数组

var arr=new  Array（5）；//构造函数的方式定义一个数组，数组中有5个元素，数组成度是5，

每个数据是undefined

数组中存储的数据类型可以不一样（为了方便所以类型是一样的）

var  arr=[10，“哈哈”，ture，null，undefined，new object（）]；

数组的长度是可以改变，通过索引来设置数组中的元素的值，获取元素的值，通过索引的方式

总结：

数组：存储一组有序的数据

数组的作用：一次性存储多个数据

数组的定义方式：

1.构造函数定义数组：var 数组名=newArray（）；

2.字面量方式定义数组：var 数组名=【】；

var  数组名=new Array（）；空数组

var  数组名=new Array（值）；数组定义了，有长度

var  数组名=new Array（值1，值2，值3）；定义数组并且有多个数据

var  数组名=【】；空数组

var  数组名=【3】；有三个数据

数组元素：就是数组中存储的数据

数组长度：就是数组中元素的个数

数组索引（下标）：从0开始。到数组的长度减1结束

通过下标设置数组的元素值：数组名【索引】=值

通过下标访问数组的元素值；数组名【索引】

通过for循环遍布数组

 var arr=[10,20,30,40,50]//定义一个有长度的数组

    for(var i=0,i<arr.length;i++){

//用循环的方式显示每一个数组的数据显示出来

//arr.length数组的长度

//下标是从0开始算起的，所以相当于i=0；

         console.log(i);

    }

 案例：

1：求数组中所有元素的和
2：求数组中所有元素的平均值
3：求数组中所有元素中的最大值
4：求数组中所有元素中的最小值
5：倒序遍历数组
6：把数组中每个元素用"|"拼接到一起产生一个字符串并输出
7：去掉数组中重复的0
8：提示用户输入班级人数，求总成绩，平均值，最高分，最低分
9：反转数组
10：冒泡排序

1：求数组中所有元素的和

var arr1=[1,2,3,4,5];//用字面量的方式创建数组
var sum1=0;//定义变量并初始化，里面用来存储arr这个数组相加的和
for (var i=0;i<arr1.length;i++){
    //用for创建循环，i从0开始算起。
    /* i要小于arr1的长度（计算长度.length），索引是从0开始算起的，所以这里的i<0,
        可以写成i<arr1.length。*/
    // i++循环
    sum1+=arr1[i];//arr1[i]访问数组元素值，将里面所有的数字都相加
}
console.log(sum1);//显示sum1最终的结果

2：求数组中所有元素的平均值

var arr2=[1,2,3,4,5];
var sum2=0;
for (var i=0;i<arr2.length;i++){
    sum2+=arr2[i];
}
console.log(sum2/arr2.length);//arr2.length数组的长度
/*循环完之后，sum2是总和，arr2.length是这个arr2数组的长度，用总和除以arr2这个
数组一个有多少个数字，得出平均值。相当于数学的求平均值公式，只是方法不一样*/

3：求数组中所有元素中的最大值

var arr3=[1,2,3,4,5];
//假设，max是最大值，那么max就要与arr3里面的数字做对比，如果max比arr3大，
//那么就不存储，小的话就存储最大值
var max=arr3[0];
for (var i=0;i<arr3.length;i++){
    if (max<arr3[i]){//判断这个变量的值和数组中每个元素的值是不是最大值
        /*给定条件，如果max小于arr3【i】，证明max比arr3【i】小，所以执行
             max=arr3【i】，如果max比arr3【i】大，就不执行*/
        max=arr3[i];
    }
}
console.log(max);//输出最大值
//不要写成max=0；这样会有bug的，因为 var arr1=[-1，-2，-3，-4];那么最大的值是0，数字里面没有0，所以这就是一个bug

4：求数组中所有元素中的最小值

var arr4=[1,2,3,4,5];
//假设，max是最小值，那么max就要与arr4里面的数字做对比，如果max比arr4小，那么就存储，存储最小值
var min=arr4[0];
for (var i=0;i<arr4.length;i++){
    if (min>arr4[i]){//这里要小于，如果是大于的话就变成了最大值了
        min=arr4[i]
    }
}
console.log(min);

5：倒序遍历数组

var arr5=[1,2,3,4,5];
//正序
for (var i=0;i<arr5.length;i++){
    console.log(arr5[i]);
}
//倒序
var arr5=[1,2,3,4,5];
for (var i=arr5.length-1;i>=0;i--){
    console.log(arr5[i]);
}//原来的位置没有改变，只是倒着从后面开始数起输出，不是真正的反转。

6：把数组中每个元素用"|"拼接到一起产生一个字符串并输出

var names=["小明","小红","小苏","小天","小田","小苏","小白","小黑",];
var splicing="";//空的字符串
for (var i=0;i<names.length-1;i++){
    console.log(names[i]);//用索引的方式显示出来，由于names.length-1；所以会少一个
    splicing+=names[i]+"|";
}
/*console.log(splicing+names[names.length-1]);
names[]表示索引；names.length表示数组的长度，[names.length]索引里面是数组的长度，
[names.length-1]数组的长度减1等于索引的长度，
索引是从0开始的，到数组的长度减1结束，所以这就是为什么【names1.length-1】会等于小黑
* */
console.log(splicing+names[names.length-1]);

7：去掉数组中重复的0

var zero=[10,0,20,0,30,0,50];
var array1=[];//新数组，用来存储第一个数组里面所有非0的数字
for (var i=0;i<zero.length-1;i++){
    if (zero[i]!=0){
        /*zero[i]!=0当zero里面的数字不等于0则执行下面代码
            array1[array1.length]=zero[i]；当数字不等于0时，新数组array1用来存储数据
            array1[array1.length]  array1是数组，array1[]变成了索引，array1.length数组的长度
            array1[array1.length]当for循环执行第一次时，数组的索引是0，数组的长度的第一个数字不是0，所以将10放到array1里面
            当for循环执行第二次时，数组的索引是1，数组的长度的第二个数字是0；此时将跳过zero[i]!=0这个条件直接执行下一次循环
             */
        array1[array1.length]=zero[i];
    }
}
//把新数组的长度作为下标使用，数组的长度是可以改变的
console.log(array1);

8：提示用户输入班级人数，求总成绩，平均值，最高分，最低分

var perCount=parseInt(prompt("请您输入班级的人数"));//创建一个数据组，用于提示用户输入班级人数
var perScores=[];//定义一个新的空数组，用于存储班级每个人的成绩
//用循环的方式录入每个人的成绩
for(var i=0;i<perCount;i++){
    //perScores=[]这个空数组用来存储用户输入每个人的成绩
    perScores[perScores.length]=parseInt(prompt("请输入第"+(i+1)+"个人的成绩"));
}
console.log(perScores);//显示用户输入的每个人的成绩
var sum5=0;//总成绩
var max=perScores[0];//最大值
var min=perScores[0];//最小值
for (var i=0;i<perScores.length;i++){
    sum5+=perScores[i];
    var avg=sum5/perScores.length;//平均值(代码是从上到下执行的，所有不能写着上面，否则不执行)
    if (max<perScores[i]){
        max=perScores[i];
    }
    if (min>perScores[i]){
        min=perScores[i];
    }
}
console.log("总成绩"+sum5);
console.log("平均值："+avg);
console.log("最大值："+max);
console.log("最小值："+min);
/*
* 不要把总成绩、平均值、最小值和最大值写到for(var i=0;i<perCount;i++)这里面，perCount是用户输入的人数，
* perScore这个新定义的数组才是用来存储用户输入每个人的分数，要计算的是perScore这个数组里面所有数值的和、平均值
* 最大值和最小值。i<perScore.length这个才是用来计算所需要的总和、平均值、最大值和最小值。
* */

9：反转数组

var array=[10,20,30,40,50];
//循环的目的是控制交换的次数
for (var i=0;i<array.length/2;i++){
    //先把第一个元素的值放在第三方变量中
    var temp=array[i];
    /*array.length-1-i这里的要减i；如果不减i只单单减1，那么最后一个
       值跑到了第一个代替了第一个值，再次循环的话倒数第二个就不会跑到前面去
       ，所以这里要减i；循环第一次是0，循环第二次是1*/
    array[i]=array[array.length-1-i];
    //把第三方变量的值拿出来，这样第一个数字就变成了最后一个数字
    array[array.length-1-i]=temp;
}
console.log(array);
这里的反转才是位置发生改变的反转。原来的位置也发生了改变。

10：冒泡排序

按照一定的顺序排序这些数字。（从大到小或者从小到大）

依次比较相邻的两个值，如果后面的比前面的小（大），这将小（大）的元素排到前面，依照这个规则进行多次递减的迭代，直到顺序正确。

需要有两个循环来控制

图解：

 

实现代码：

var arr=[5,4,3,2,1];
for(var i=0;i<arr.length-1;i++) {//循环控制轮数。
    for (var j=0;j<arr.length-1-i;j++) {//循环控制轮数的次数。j<arr.length-1-i,-i是比较的次数越来越少
        if (arr[j]>arr[j+1]) {
            /*判断，第一个元素和二个元素做判断，第二个元素和第三个元素做判断，依次类推
               * 当j=0的时候，此时需要与j+1作比较
               * 如果要从最小值排到最大值，那么 arr[j]>arr[j+1]需要写成大于号*/
            var temp5 = arr[j];
            //定义第三方变量用于交换位置。前面的比后面的数字大，那么前面的数字就和后面的数字调换位置
            arr[j] = arr[j + 1];
            arr[j + 1] = temp5;
        }
    }
}
console.log(arr);
/*for(var i=0;i<arr.length-1;i++) {}
   *循环控制比较的轮数
   *第一轮是从5开始与后面的数字做比较，如果5比后面的4、3、2、1大，那么5要依次于4、3、2、1对调位置，
     最后变成4、3、2、1、5,比较了4次
   *第二轮是从4开始与前面后面的数字做比较，如果4比后面的3、2、1大，那么4要依次于3、2、1对调位置，
     最后变成3、2、1、3、4、5,比较了3次.5比4大，所以不用对调位置
   *第三轮是从3开始与前面后面的数字做比较，如果3比后面的2、1大，那么3要依次于2、1对调位置，
     最后变成2、1、3、4、5,比较了2次.
   *第四轮是从2开始与前面后面的数字做比较，如果2比后面的31大，那么2要依次于1对调位置，
     最后变成1、2、3、4、5,比较了1次.
     */
/*for(var i=0;i<arr.length-1;i++) {//循环控制轮数。for (var j=0;j<arr.length-1-i;j++) {} }
for (var j=0;j<arr.length-1-i;j++) {循环控制轮数的次数。j<arr.length-1-i,-i是比较的次数越来越少}
* 第一轮比较了4次。5和4比较、5和3比较、5和2比较、5和1比较，共4次比较
* 第二轮比较了3次。4和3比较、4和2比较、4和1比较，共3次比较
* 第三轮比较了2次。3和2比较、3和1比较，共2次比较
* 第四轮比较了1次。2和1比较，共1次比较
* */

函数

函数：把一堆重复的代码封装，在有需要的时候调用即可

函数的作用：代码的重用（重复使用）

函数的定义：

function  函数名字（）{

    函数体--->用于放置一堆重复的代码

}

函数的调用：函数名（）；括号不能漏掉。

例如：

function cool() {//函数定义

   console.log("切菜");

   console.log("放油");

   console.log("炒菜");

   console.log("下盐");

   console.log("装盘");

  }//打开浏览器是看不了的，要调用才能看到

 

//函数调用

  console.log("早饭————————");

  cool();

  console.log("午饭————————");

  cool();

  console.log("晚饭————————");

  cool();

总结：

1.函数需要先定义，然后才能使用

2.函数名字：要遵循驼峰命名法

3.函数一旦重名，后面的会把前面的函数覆盖

4.一个函数最好就是一个功能

函数的参数：

在函数定义的时候，函数名字后面的小括号里的变量就是参数，目的是函数在调用的时候，对用户传过来的值操作。

此时函数定义的时候后面的小括号里的变量叫参数；写了两个变量，就有两个参数。

在函数调用的时候，按照提示的方式，给变量赋值----->就叫传值，把这个值传到了变量（参数）中。

形参：函数在定义的时候小括号里的变量叫形参；

实参：函数在调用的时候小括号里传入的值叫实参。实参可以是变量也可以是值。

（function  consoleSun（x，y））{ }这个是函数的定义，括号里面的变量x和y就是参数，x和y是两个参数。如果在再括号里面再加一个变量z，那么就是三个参数。括号里面的变量不用写var，否则就会出现报错。

function  consoleSun（x，y）小括号里面的变量x和y叫形参。

调用consoleSun（x，y）小括号里传入的值叫实参     可以选择不写进去）

//函数定义
function  consoleSun(x,y){
/*这个是函数的定义，括号里面的变量x和y就是参数，x和y是两个参数。
 如果在再括号里面再加一个变量z，那么就是三个参数。括号里面的变量不用写var，否则就会出现报错。 */
      var sum=x+y;//计算和。第一个功能
      console.log(sum);//输出和。第二个功能
 }

//函数调用
 consoleSun(10,20);//小括号里面的变量x和y叫形参。调用consoleSun（x，y）小括号里传入的值叫实参

也可用下面的写法：

//函数定义
function  consoleSun(x,y){
/*这个是函数的定义，括号里面的变量x和y就是参数，x和y是两个参数。
如果在再括号里面再加一个变量z，那么就是三个参数。括号里面的变量不用写var，否则就会出现报错。 */
    var sum=x+y;//计算和。第一个功能
    console.log(sum);//输出和。第二个功能
}

//函数调用
  var num1=parseInt(prompt("请输入第一个数字"));
  var num2=parseInt(prompt("请输入第二个数字"));
  consoleSun(num1,num2);//小括号里面的变量x和y叫形参。调用consoleSun（x，y）小括号里传入的值叫实参

set：可以理解为：设置

get：可以理解为：获取

后面的命名大多数都是以set和get设置的

函数的返回值：

在函数内部有return关键字，并且在关键字后面有内容，这个内容被返回了，当函数调用之后，需要这个返回值，那么就定义变量接收即可。（需要值的话调用就行，不需要的话就不调用，但是函数定义里面的代码是会执行的。 ）（尽可能保证函数只有一个功能）（注意：是return关键字的后面，不是下一行代码）

 例如：

function getSum（x，y）{
   var  sum=x+y；
   return  sum//把和返回
}

//函数调用
var  result=getSum（10,20）；
console.log（result）;

定义的函数可以改为这样：

function getSum（x，y）{
    return x+y；//把和返回
}//不需要在函数里面进行变量了

//函数调用
var  result=getSum（10,20）；
console.log（result）;

函数的参数和返回值的注意问题：

1.如果一个函数中有reture，那么这个函数就有返回值

如果一个函数中没有reture，那么这个函数就没有返回值

2.如果一个函数中没有明确的返回值，那么调用的时候接收了，结果是undefined。

（没有明确明确返回值：函数中有return，但是return后面没有任何内容）

3.函数没有返回值，但是在调用的时候接收了，那么结果就是undefined

4.变量声明了，没有赋值结果也是undefined

5.如果一个函数有参数，就是有参数的函数

如果一个函数没有参数，就是没有参数的函数

6.形参的个数和实参的个数可以不一致

7.return   下面的代码是不会执行的

案例：

1.求两个数中的最大值

function getMax(num1,num2) {
    return num1>num2?num1:num2;
}
console.log(getMax);//显示函数的代码
console.log(getMax(10,20));

另一种写法：

function getMax(num1, num2) {//num1和num2是形参
    return num1 > num2 ? num1 : num2;
}
var x = 10;
var y = 20;
var result = getMax(x, y);//x和y是实参
console.log(result);
/*x的值是10，num1的值是10； x和y不相等； x和num1相等，此时这行代码var result=getMax(x,y)一执行;是把x变量中的值复制一份出来
赋值给了num1，所以num1变量里面存的是10，此时出现了两块空间，一块是x的空间，一块是num1的空间，总共两块空间。y同理*/

2.求三个数中的最大值（可以写三，但是不要写4个，要写是4的话就要用循环）

function getThreeMax(x, y, z) {
    return x > y ? (x > z ? x : z) : (y > z ? y : z);
}
console.log(getThreeMax(10, 20, 40));

3.判断一个数是否是素数(质数)，只能被1和自身整除，质数是从2开始，用这个数字和这个数字前面的所有的数字整除一次（没有1和自身的）

function isPrimeNumber(num) {
    for (var i = 2; i < num; i++) {
        if (num % i == 0) {
            //说明有一个数字整除了，就没有必要向后继续整除了，此时就已经验证出不是质数了
            return false;
        }
    }
    return true;
}
console.log(isPrimeNumber(8) ? "是质数" : "不是质数");
//可以这么写 console.log(isPrimeNumber(prompt("请您输入一个数字"))?"是质数":"不是质数");

4.求两个数字的差

function getSub(x, y) {
   return x - y;
}
console.log(10, 20);

5. 求一组数字中的最大值

方式一：

function getArrarMax(array) {//array这个变量未必存的是一个值，这么写传入的是一个数组
    //定义变量，假设这个变量中存储的是最大值
    var max = array[0];
    for (var i = 0; i < array.length; i++) {
        if (max < array[i]) {
            max = array[i];
        }
    }
    return max;
}

方式二：

var max = getArrarMax([1, 2, 3, 4, 5]);//不用重新定义变量，可以直接把数组输到函数中
console.log(max);

方式三：

console.log(getArrarMax([1, 2, 3, 4, 5]));//也可以这么写，直接把数组输到函数中
//一共三种方式可以选择
后面学JS对象的时候会出现

6.求一组数字中的最小值

function getArrarMin(array) {//array这个变量未必存的是一个值，这么写传入的是一个数组
    //定义变量，假设这个变量中存储的是最小值
    var min = array[0];
    for (var i = 0; i < array.length; i++) {
        if (min > array[i]) {
            min = array[i];
        }
    }
    return min;
}

console.log(getArrarMin([1, 2, 3, 4, 5]));

7.求一组数字的和

function getArraySum(array) {
    var sum = 0;
    for (var i = 0; i < array.length; i++) {
        sum += array[i];
    }
    return sum;
}
console.log(getArraySum([1, 2, 3, 4, 5, 6]));

8.求一个数组中的最大值和最小值还有和

     var max = array[0];//最大值
var min = array[0];//最小值
var sum = 0;//和
for (var i = 0; i < array.length; i++) {
    sum += array[i];//求和
    //求最大值
    if (max < array[i]) {
        max = array[i];
    }//end if
    //求最小值
    if (min > array[i]) {
        min = array[i];
    }//end if
}//end for
var arr = [max, min, sum];
return arr;
}
var resultArray = getArrayMaxAndMinAndSum([1, 2, 3, 4, 5, 6, 7]);//不加括号console.log打印直接报错，注意细节
console.log("最大值"+resultArray[0]);
console.log("最小值" + resultArray[1]);
console.log("和" + resultArray[2]);

9.通过函数实现数组反转

function getReversal(arr) {
    for (var i = 0; i < arr.length / 2; i++) {
        var temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
    return arr;
}
console.log(getReversal([1,2,3,4,5]));

10.通过函数实现冒泡排序

function getBubbling(arr2) {
    for (var i = 0; i < arr2.length - 1; i++) {
        for (var j = 0; j < arr2.length - 1 - i; j++) {
            if (arr2[j] > arr2[j + 1]) {
                var temp = arr2[j];
                arr2[j] = arr2[j + 1];
                arr2[j + 1] = temp;
            }
        }
    }
    return arr2;
}
console.log(getBubbling([1,3,4,6,5,2]));

11.求一个数字的阶乘

function getJieCheng(num) {
    var result=1;
    for (var i=1;i<=num;i++){
        result*=i;
    }
    return result;
}
console.log(getJieCheng([5]));

12.求斐波那契数列

function getFbi(num) {
    var num1=1;
    var num2=1;
    var sum=0;
    for (var i=3;i<=num;i++){
        sum=num1+num2;
        num1=num2;
        num2=sum;
    }
    return sum;
}
console.log(getFbi([12]));

13.输入： 年月日，获取这个日期是这一年的第几天

function isLeapYear(year) {
    return year%4==0&&year%100!==0||year%400==0;
}//这个函数放在前面这里或者后面都行
function getDays(year,month,day) {
    //定义变量存储对应得天数
    var days=day;
    //如果用户输入的是1月份，就没有必要向后算天数，直接返回天数
    if (month==1){
        return days;
    }
    //代码执行到这里--->说明用户输入的不是1月份
    //用户输入的如果是4月份23日--->那么前面的1，2,3月份都要相加再加上4月份的23天
    //定义一个数组，存储每个月份的天数
    var months=[31,28,31,30,31,30,31,31,30,31,30,31];
    //小于的数输入的月份-1
    for (var i=0;i<month-1;i++){//当i=4月份的时候，4<4-1,很明显，4比三大，所以不循第4
        days+=months[i];
    }
    //判断这个年份是不是闰年
    if (isLeapYear(year)&&month>2){
        days++;
    }
    return days;
}
console.log(getDays(2020,2,13));

14.求一个数字的阶乘和 （如果输入的是5这个数字，要算：5的阶乘+4的阶乘+3的阶乘+2的阶乘+1的阶乘）

function getJieChengSum(num) {
    var sum=0;//求和
    for (var i=1;i<=num;i++){
        sum+=getJieCheng(i);//函数调用，调用 12.求一个数字的阶乘
    }
    return sum;//最后要的是阶乘的和
}
console.log(getJieChengSum(5));
//1*2*3*4*5=120
//1+2+6+24+120=153      1+(1*2)+(2*3)*(6*4)+(24*5)   阶乘和