【 js基础 Day3】关键字的使用，数组（重点）和函数（重点）

最新推荐文章于 2022-12-20 22:30:03 发布
最新推荐文章于 2022-12-20 22:30:03 发布
阅读量662 收藏 2
点赞数 1
分类专栏： JavaScript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42554191/article/details/104296797
版权

在这里插入图片描述

01 复习

一元运算符: ++ –

如果不参与运算, ++在前面还是在后面结果都是一样的 +1
如果不参与运算, --在前面还是在后面结果都是一样的 -1

var num=10;
num++;   后+
++num;   前+

无论是前+还是后+只要参与运算,结果可能就不太一样
如:

 var num=10;
 var sum= num++ +10;

++在后面的时候,先参与运算,然后自身加1

 var num=10;
 var sum=++num +10;

++在前面的时候,先自身加1,然后再参与运算

流程控制: 代码的执行过程

  1. 顺序结构:代码的执行的顺序,从上到下,从左到右(不严谨)
  2. 分支结构: if,if-else ,if-esle if,switch-case ,三元表达式
  3. 循环结构:while 循环,do-while,for循环 for-in循环

总结分支:如果只有一个分支,就用if
如果有两个分支,就用if-else
如果多个分支,一般是范围的,推荐使用if-else if
如果多个分支,一般是具体的值,推荐使用switch-case

总结循环:
while:先判断后循环,有可能一次循环都不执行
do-while:至少执行一次循环体,再判断
for循环:知道了循环的次数,推荐使用for循环

调试:是为了找代码的错误和问题所在,
断点,不加断点,就不方便调试

//本金10000元存入银行，年利率是千分之三，每过1年，将本金和利息相加作为新的本金。
//计算5年后，获得的本金是多少？

   var money = 10000;//本金
   var rate=0.003;
   for(var i=0;i<5;i++){
     //money=money+money*rate;
     money+=money*rate;
   }
   console.log(money);

var money=10000;
var rate=0.003;
for(var i=0;i<5;i++)
{
  money+=money*rate
}
console.log(money)

有个人想知道，一年之内一对兔子能繁殖多少对？于是就筑了一道围墙把一对兔子关在里面。已知一对兔子每个月可以生一对小兔子，而一对兔子从出生后第3个月起每月生一对小兔子。假如一年内没有发生死亡现象，那么，一对兔子一年内（12个月）能繁殖成多少对？（兔子的规律为数列，1，1，2，3，5，8，13，21）

每个月的值 就是前两个月的和

  var num1=1;//第一个月
  var num2=1;//第二个月
  var sum=num1+num2;//第三个月

  var num1=num2;//第二个月
  var num2=sum;//第三个月
  sum=num1+num2;//第四个月
  
  var num1=num2;//第三个月
  var num2=sum;//第四个月
  var sum=num1+num2;

   var num1=1;//第一个月
    var num2=1;//第二个月
    var sum=0;
    //i=3是从第三个月开始
    for(var i=3;i<=12;i++){
      sum=num1+num2;
      num1=num2;
      num2=sum;
    }
    console.log(sum);

var a=1;
var b=1;
var c=0;
for(var i=3;i<=12;i++){
  c=a+b;
  a=b;
  b=c;
}
console.log(c)

练习: ++ 和 –

    var a = 1;

    var b = ++a + ++a;

    console.log(b);


    var a = 1;

    var b = a++ + ++a;
    console.log(b);


    var a = 1;

    var b = a++ + a++;
    console.log(b);


    var a = 1;

    var b = ++a + a++;
    console.log(b);


   var a=1;
   var b=++a + ++a+a++ + ++a;

  var sum=0;
  for(var i=1;i<=100&&i%2==0;i++){
    sum+=i;
  }
  console.log(sum)

 var num = 10;
 switch (num) {
   case 1:
   case 2:console.log("嘎嘎");break;}


   var i=1;
   j=i++ + i++;
   j=1+ 2++;
   console.log(j);

02 课程介绍

1.关键字的使用: break,continue

2.数组—重点-----
冒泡排序-----重点---------3分钟之内必须全部写完

3.函数–重点

03 break关键字的使用

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

  for(var i=0;i<10;i++){
      while (true){
        console.log("哈哈");
        break;//
      }
    }

    
        console.log("哈哈,我出来了");
     for (var i = 0; i < 10; i++) {
     
       //第四步说明break不能跳出for循环，因为for循环在while循环的外面
       
       while (true) {//第一步，此步为死循环
         console.log("yu");
         break;//第二步，
       }
     }
     console.log("shan");//第三

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

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

04 continue关键字的使用

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

    var i=0;
    while (i<10){
      console.log("哈哈");
      //continue;
      i++;
    
 var i=0;
 while(i<10){
   console.log("hh")
   continue;
   i++;
 }


//案例:求100-200之间所有的奇数的和（用continue）
  var sum = 0;
  for (var i = 100; i <= 200; i++) {
    if (i % 2 != 0) {
      sum += i;
      continue;
      i++;
    }
  }
  console.log(sum)

//cj的方法

sum = 0;
for (var i = 100; i <= 200; i++) {
if (i % 2 == 0) continue;
else {
  sum += i;
}
}
console.log(sum)


var sum = 0;
var i = 100;
while (i <= 200) {
  //判断是不是偶数
  if (i % 2 == 0) {
    //如果是偶数----->跳过这个数字
    i++;//102
    continue;
  }
  sum += i;
  i++;
}
console.log(sum);

案例:求整数100～200的累加值，但要求跳过所有个位为3的数

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

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

var sum=0;
var i=100;
while(i<=200){
  if(i%10==3){
    //个位数是3,不要
    i++;
    continue;
  }
  sum+=i;
  i++;
}
console.log(sum);


var sum=0;
var i=1;
while(i<=10){
  if(i%10==3){
    //个位数是3,不要
    i++;
    continue;
  }
  sum+=i;
  i++;
}
console.log(sum);

console.log(3%10  ==3);

05 数组

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

 var arr1 = new Array();
 var arr2 = new Array(5);
 alert(array);

数组的名字如果直接输出，那么直接就可以把数组中的数据显示出来，
如果没有数据，就看不到数据
就是一个数组----字面量的方式

 var arr3 = new Array(10,20,1000,40,50);
 console.log(arr3)

数组:一组有序的数据
数组的作用:可以一次性存储多个数据
数组的定义:
1. 通过构造函数创建数组

  语法:
    var 数组名=new Array();
    var array=new Array();//定义了一个数组

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

var 数组名=new Array(长度);
如果数组中没有数据,但是有长度—,数组中的每个值就是undefined
构造函数的方式创建数组的时候,如果在Array(一个数字)—>数组的长度(数组元素的个数)
如果在Array(多个值);这个数组中就有数据了,数组的长度就是这些数据的个数
2. 通过字面量的方式创建数组

var 数组名=[];//空数组
var array=[];

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

数组:一组有序的数据
数组元素:数组中存储的每个数据,都可以叫数组的元素,比如:存储了3个数据,数组中3个元素
数组长度:就是数组的元素的个数,比如有3个元素,就说,这个数组的长度是3
数组索引(下标):用来存储或者访问数组中的数据的,索引从0开始,到长度减1结束
数组的索引和数组的长度的关系:长度减1就是最大的索引值

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

数组名[下标]=值;
arr[3]=100;

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

var result=数组名[下标];
console.log(result);

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

    var array=new Array(5);//没有数据,空数组
    console.log(array);
alert(array);

就是一个数组---->字面量的方式

   var arr=[];
    console.log(arr);

var arr1=new Array();//构造函数的方式---空数组
var arr2=new Array(5);//构造函数的方式定义了一个数组,数组中有5个元素,数组长度是5,每个数据是undefined
        

var arr3=new Array(10,20,1000,40,50,60);
console.log(arr3);
var arr = new Array(10, 20, 30, 40, 50);
// console.log(arr[4])//获取
//设置，也就是修改某个值
arr[3] = 1000;
console.log(arr);

   //联想一下，当初求字符串的方式，length
   var arr=[10,20,30,40];
   console.log(arr.length);

  var arr=new Array(10,20,30,40,100);
  //console.log(arr[4]);//获取
  //设置
  arr[3]=1000;
  console.log(arr);

  //字面量的方式更简单

   var arr=[10,20,30,40,50,60,70,80,10,20,3043,5];//空数组
   console.log(arr.length);

小练习：请输入班级人数,根据班级人数,输入每个学生的数学成绩,求总成绩,求平均成绩,求最高分,求最低分
（可以尝试写一写）

06 数组的注意问题

 var arr=[10,2,3,4,1];
    长度:5
    索引:0-4
    console.log(arr);
    alert(arr);

 var arr=[10,"nnn",true,undefined,new Object()]
 console.log(arr);

数组中存储的数据类型一定是一样的吗? 类型可以不一样

  var arr=[10,"哈哈",true,null,undefined,new Object()];
  console.log(arr);

var arr = [];
arr[0] = 10;
arr[1] = 20;
console.log(arr.length);
console.log(arr[2]);

数组的长度是不是可以改变呢?

 var arr = [];
    //通过索引来设置数组中的元素的值
    arr[0] = 10;
    arr[1] = 20;
    console.log(arr.length);
    //获取元素的值,通过索引的方式
    console.log(arr[2]);

07 总结数组基础知识

数组:存储一组有序的数据
数组的作用:一次性存储多个数据
数组的定义方式:
1.构造函数定义数组: var 数组名=new Array();
2.字面量方式定义数组: var 数组名=[];

var 数组名=new Array();空数组
var 数组名=new Array(值);数组定义了,有长度
var 数组名=new Array(值1,值2,值3…);定义数组并且有多个数据
var 数组名=[];空数组
var 数组名=[值1,值2,值3];有三个数据
数组元素:就是数组中存储的数据
数组长度:就是数组中元素的个数
数组索引(下标):从0开始,到数组的长度减1结束
通过下标设置数组的元素值: 数组名[索引]=值
通过下标访问数组的元素值: 数组名[索引]

var arr1=new Array();
    var arr2=new Array(5);
    var arr3=new Array(1,2,3,4,5);
    var arr4=[];
    var arr5=[1,2,3];
    var arr6=["red","blue","green",1,true];
    var arr7=[];
    arr7[0]=10;
    arr7[1]=20;


    console.log(arr1);
    console.log(arr2);
    console.log(arr3);
    console.log(arr4);
    console.log(arr5);
    console.log(arr6);
    console.log(arr7);

    var arr1=new Array();//空数组
    var arr2=new Array(5);//长度为5的数组,每个数据的值是undefined
    var arr3=new Array(1,2,3,4,5);//长度为5分数组,
    var arr4=[];//空数组
    var arr5=[1,2,3];//长度为3的数组
    var arr6=["red","blue","green",1,true];//数组中元素的值的类型可以不一样

    var arr7=[];
    //设置数组的元素的值
    arr7[0]=10;
    arr7[1]=20;

08 for循环遍历数组

 var arr=[10,20,30,40];
     console.log(arr[0]);
     console.log(arr[1]);
     console.log(arr[2]);
     console.log(arr[3]);
     console.log(arr[4]);

    var arr = [10, 20, 30, 40, 50];
    //显示数组中的每个数据
    console.log(arr[0]);
    console.log(arr[1]);
    console.log(arr[2]);
    console.log(arr[3]);
    console.log(arr[4]);
    console.log(arr[5]);//没有数据

    //通过for循环遍历数组
    var arr = [10, 20, 30, 40, 50];
    for (var i = 0; i < arr.length; i++) {
      console.log(arr[i])
    }

     var arr=[10,20,30,40,50,60,70,80,90,100];
 //小于的是数组的长度--个数
     for(var i=0;i<arr.length;i++){
       console.log(arr[i]);
     }

09 数组案例(1)

//案例1:求数组中所有元素的和

   var arr1=[10,20,30,40,50]
   var sum=0;
   for(var i=0;i<arr1.length;i++){
     sum+=arr1[i];
   }
   console.log(sum)

   var arr1 = [10, 20, 30, 40, 50];
   var sum = 0;
   for (var i = 0; i < arr1.length; i++) {
     sum += arr1[i];
   }
   console.log(sum);

案例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)

  
   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);

案例3:求数组中所有元素中的最大值

  var arr3 = [1, 2, 3, 4, 10, 2, 3, 6, 9, 11, 78, 55];
  var max = arr3[0];
  for (var i = 0; i < arr3.length; i++) {
    if (max < arr3[i]) {
      max = arr3[i];
    }
  }
  console.log("最大值：" + max)

   var arr3 = [1, 3, 2, 5, 10, 100, 50];
   //假设max变量中存储的是最大值
   var max = arr3[0];
   for (var i = 0; i < arr3.length; i++) {
     //判断这个变量的值和数组中每个元素的值是不是最大值
     if (max < arr3[i]) {
       max = arr3[i];
     }
   }
   console.log("最大值:" + max);
   //一个不好的地方----会出现bug的
    var arr3=[-1,-2,-3];
    //假设max变量中存储的是最大值
    var max=0;
    for(var i=0;i<arr3.length;i++){
      //判断这个变量的值和数组中每个元素的值是不是最大值
      if(max<arr3[i]){
        max=arr3[i];
      }
    }
    console.log("最大值:"+max);

   var arr3=[1,3,2,5,10,100,50];
   //假设max变量中存储的是最大值
   var max=Number.MIN_VALUE;//假设变量是最大的,但是实际上存储的是最小的值
   for(var i=0;i<arr3.length;i++){
     //判断这个变量的值和数组中每个元素的值是不是最大值
     if(max<arr3[i]){
       max=arr3[i];
     }
   }
   console.log("最大值:"+max);

案例4:求数组中所有元素的最小值

    var arr4 = [1, 2, -3, 4, 10, 2, 3, 6, 9, 11, 78, 55];
     var min = arr4[0];
     for (var i = 0; i < arr4.length; i++) {
       if (min > arr4[i]) {
         min = arr4[i];
       }
     }
     console.log("最小值：" + min)


    var arr4 = [100, 10, 20, 30, 40, 50];
    var min = arr4[0];//假设min里存储的就是最小值
    for (var i = 0; i < arr4.length; i++) {
      if (min > arr4[i]) {
        min = arr4[i];
      }
    }
    console.log("最小值:" + min);

09 数组案例(2)

案例5:倒序遍历数组

    var arr5 = [10, 20, 30, 40, 50];
    //正序
    for (var i = 0; i < arr5.length; i++)
      console.log(arr5[i]);
    //那么倒序呢
    for(var i=arr5.length-1;i>=0;i--){
      console.log(arr5[i])
    }

    var arr5 = [10, 20, 30, 40, 50, 100];
    //正序
    //    for (var i = 0; i < arr5.length; i++) {
    //      console.log(arr5[i]);
    //    }
    //倒序
    for (var i = arr5.length - 1; i >= 0; i--) {
      console.log(arr5[i]);
    }

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

var names = ["卡卡西", "佐助", "鸣人", "大蛇丸", "雏田", "小苏", "凤姐", "黑崎一护"];
   var str = "";
   for (var i = 0; i < names.length - 1; i++) {
     str += "|" + names[i];
   }
   console.log(str + names[names.length - 1]);

   var names = ["卡卡西", "佐助", "鸣人", "大蛇丸", "雏田", "小苏", "凤姐", "黑崎一护"];
   var str = "";//空的字符串
   for (var i = 0; i < names.length - 1; i++) {
     str += "|" + names[i];
   }
   console.log(str + names[names.length - 1]);

  var names = ["卡卡西", "佐助", "鸣人", "大蛇丸", "雏田", "小苏", "凤姐", "黑崎一护"];
  var str = "";//空的字符串
  for (var i = 1; i < names.length; i++) {
    str += "|" + names[i];
  }
  console.log(names[0] + str);

案例7:去掉数组中重复的0，把其他的数据放在一个新的数组中

var arr = [10, 0, 20, 0, 30, 0, 50];
 var newArr = [];//新数组，用来存放第一个数组中所有非0的数字
 for (var i = 0; i <= arr.length; i++) {
   if (arr[i] != 0) {
     newArr[newArr.length] = arr[i];
   }
 }
 console.log(newArr);


 var arr = [10, 0, 20, 0, 30, 0, 50];
 var newArr = [];//新数组,用来存放第一个数组中所有非0的数字
 for (var i = 0; i <=arr.length; i++) {
   if (arr[i] != 0) {
     newArr[newArr.length] = arr[i];
   }
 }
 //把新数组的长度作为下标使用,数组的长度是可以改变的
 console.log(newArr);

案例8:反转数组—把数组中的数据的位置调换

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

    var array = [10, 20, 30, 40, 50];
    //循环的目的是控制交换的次数
    for (var i = 0; i < array.length / 2; i++) {
      //先把第一个元素的值放在第三方变量中
      var temp = array[i];
      array[i] = array[array.length - 1 - i];
      array[array.length - 1 - i] = temp;
    }
    console.log(array);


   for(var i=array.length-1;i>=0;i--){
     console.log(array[i]);
   }
   console.log(array);//50 40 30 20 10

案例9:提示用户输入班级人数,求总成绩,平均值,最高分,最低分—扩展

//提示用户输入人数,并转成数字类型
 var perCount = parseInt(prompt("请输入班级人数"));
 //定义数组存储班级的每个人的成绩
 var perScores = [];
 //循环的方式录入每个人的成绩
 for (var i = 0; i < perCount; i++) {
   //把每个人的成绩存储到数组中
   perScores[perScores.length] = parseInt(prompt("请输入第" + (i + 1) + "个人的成绩:"));
 }
 console.log(perScores);
 //求总成绩
 var sum = 0;
 var avg = 0;//平均值
 var max = perScores[0];//最大值
 var min = perScores[0];//最小值
 for (var i = 0; i < perScores.length; i++) {
   sum += perScores[i];//求和
   //求最大值
   if (max < perScores[i]) {
     max = perScores[i];
   }
   //求最小值
   if (min > perScores[i]) {
     min = perScores[i];
   }
 }
 //平均值
 avg = sum / perScores.length;
 console.log("和为:" + sum);
 console.log("平均值:" + avg);
 console.log("最大值:" + max);
 console.log("最小值:" + min);

案例10: 冒泡排序

11 冒泡排序

案例8:反转数组—把数组中的数据的位置调换

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

  var perCount=parseInt(prompt("请输入班级人数"));
  var perScores=[];
  for(var i=0;i<perCount;i++){
    perScores[perScores.length]=parseInt(prompt("请输入第"+(i+1)+"个人的成绩："));
  }
  console.log(perScores);
  var sum=0;
  var avg=0;
  var max=perScores[0];
  var min=perScores[0];
  for(var i=0;i<perScores.length;i++){
    sum+=perScores[i];
    if(max<perScores[i]){
      max=perScores[i];
    }
    if(min>perScores){
      min=perScores[i];
    }
  }
  avg=sum/perScores.length;
  console.log("和为："+sum);
  console.log("平均值为："+avg);
  console.log("最大值为："+max);
  console.log("最小值为："+min);


  var arr=[10,20,30];
  var sum=0;
  for(var i=0;i<arr.length;i++){
    sum+=arr[i];
  }

冒泡排序:把所有的数据按照一定的顺序进行排列(从小到大,从大到下)

  var arr = [10, 0, 100, 20, 60, 30]
    for (var i = 0; i < arr.length - 1; i++) {
      for (var j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
          var temp = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = temp;
        }
      }
    }
    console.log(arr);
    //从小到大：大于号
    //从大到小：小于号

    var arr = [10, 0, 100, 20, 60, 30];
    //循环控制比较的轮数
    for (var i = 0; i < arr.length - 1; i++) {
      //控制每一轮的比较的次数
      for (var j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] < arr[j + 1]) {
          var temp = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = temp;
        }
      }
    }
    console.log(arr);

12 函数介绍及定义

单身生活:

早上饿了
自己做饭-----番茄炒西红柿盖饭-----
切菜
洗菜
放油
炒菜
放盐
装盘
—目的—吃

中午饿了
自己做饭—番茄炒西红柿盖饭
切菜
洗菜
放油
炒菜
放盐
装盘
—目的—吃

晚上饿了
自己做饭—番茄炒西红柿盖饭
切菜
洗菜
放油
炒菜
放盐
装盘
—目的—吃

半夜饿了
自己做饭—番茄炒西红柿盖饭
切菜
洗菜
放油
炒菜
放盐
装盘
—目的—吃

非单身—

早上饿了
找一个会做饭的人—做饭的所有的步骤,都是这个人
吃

中午饿了
一个人
吃

晚上饿了
这个人
吃

函数:把一坨重复的代码封装,在需要的时候直接调用即可
函数的作用:代码的重用

函数的定义
语法:

function 函数名字(){
  函数体-----一坨重复的代码
}

函数的调用:

函数名();

 //单身生活
 //早上
 console.log("切菜");
 console.log("炒菜");
 console.log("放油");
 console.log("炒菜");
 console.log("装盘");

 //中午
 console.log("切菜");
 console.log("炒菜");
 console.log("放油");
 console.log("炒菜");
 console.log("装盘");

 //晚上

 console.log("切菜");
 console.log("炒菜");
 console.log("放油");
 console.log("炒菜");
 console.log("装盘");

 //半夜
 console.log("切菜");
 console.log("炒菜");
 console.log("放油");
 console.log("炒菜");
 console.log("装盘");


 //有函数了,把这些重复使用的代码放在函数中写,在需要的时候直接调用函数就可以

 function cook(){
   console.log("hh");
 }
 console.log("早上====");
 cook();
 console.log("中午====");
 cook();
 console.log("晚上====");
 cook();
 console.log("半夜====");
 cook();

 //函数定义
 function cook() {
   console.log("切菜");
   console.log("放油");
   console.log("炒菜");
   console.log("放盐");
   console.log("装盘");
 }

 //函数调用
 console.log("早上======");
 cook();
 console.log("中午======");
 cook();
 console.log("晚上======");
 cook();
 console.log("半夜======");
 cook();
 console.log("后半夜");
 cook();

13 函数的小练习

函数需要先定义,然后才能使用
函数名字:要遵循驼峰命名法
函数一旦重名,后面的会把前面的函数覆盖
Ctrl +鼠标左键---->转到定义
一个函数最好就是一个功能
下面的所有的函数的代码-----全部作废

alert("jjj");

     function alert() {
       console.log("哇塞,哭了哇函数迪斯噶");
     }
       alert("弹框");

      function f1() {
        console.log("小杨好帅哦");
      }
      function f1() {
        console.log("小苏好猥琐哦");
      }
      f1(); -->

通过函数
求两个数字的和

  function consoleSum() {
    var num1 = 10;
    var num2 = 20;
    var num3 = 30;
    var sum = num1 + num2 + num3;
    console.log(sum)
  }
  consoleSum();
  
  
function consoleSum() {//函数定义
    var num1 = 100;
    var num2 = 200;
    var sum = num1 + num2;
    console.log(sum);
  }
  //调用
  consoleSum();

求三个数字的和

    function consoleSum2() {
      var num1 = 10;
      var num2 = 20;
      var num3 = 30;
      var sum = num1 + num2 + num3;
      console.log(sum);
    }
    consoleSum2();

   function consoleMax1() {
     var x = 1220;
     var y = 2220;
     var z = 1900;
     var max = x>y?(x>z?x:z):(y>z?y:z);//嵌套的三元表达式
     console.log(max);
   }
   consoleMax1();

求两个数字的最大值

  function consoleMax() {
    var x = 10222;
    var y = 220;
    console.log(x > y ? x : y);
  }
  consoleMax();

求三个数字的最大值

  function consoleMax2() {
    var x = 10;
    var y = 20;
    var z = 30;
    var max = x > y ? (x > z ? x : z) : (y > z ? y : z);//嵌套的三元表达式
    console.log(max);
  }

 // consoleMax2()

求1-100之间所有数字的和

  function Sum() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
      sum += i;
    }
    console.log(sum)
  }
  Sum();


  function everySum() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
      sum += i;
    }
    console.log(sum);
  }
  everySum();

求1-100之间所有偶数的和

  function everyEvenSum1() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
      if (i % 2 == 0) {
        sum += i;
      }
    }
    console.log(sum)
  }

 // everyEvenSum1();


  function everyEvenSum() {
    var sum = 0;
    for (var i = 1; i <= 100; i++) {
      if (i % 2 == 0) {
        sum += i;
      }
    }
    console.log(sum);
  }
  everyEvenSum();

求一个数组的和

  function consoleArraySum1(){
    var sum=0;
    var arr=[10,20,30,40,50];
    for(var i=0;i<arr.length;i++){
      sum+=arr[i];
    }
    console.log(sum);
  }
  consoleArraySum1();

  function consoleArraySum() {
    var sum = 0;
    var arr = [10, 20, 30, 40, 50];
    for (var i = 0; i < arr.length; i++) {
      sum += arr[i];
    }
    console.log(sum);
  }
  consoleArraySum();

14 函数的参数

函数参数:
在函数定义的时候,函数名字后面的小括号里的变量就是参数,目的是函数在调用的时候,
用户传进来的值操作
此时函数定义的时候后面的小括号里的变量叫参数;写了两个变量,就有两个参数,
在函数调用的时候,按照提示的方式,给变量赋值—>就叫传值,把这个值就传到了变量(参数)中

形参:函数在定义的时候小括号里的变量叫形参
实参:函数在调用的时候小括号里传入的值叫实参,实参可以是变量也可以是值

 function consoleSum1() {
       var x = 10;
       var y = 20;
       var sum = x + y;
       console.log(sum);
     }
     consoleSum1();

     function consoleSum1(x, y, z) {
       var sum = x* y * z;
       console.log(sum);
     }
     consoleSum1(10, 20, 30)


    //函数定义
    function consoleSum(x, y) {
      var sum = x + y;//计算和----功能
      console.log(sum);//输出和---第二个功能
    }
   //函数调用
   var num1=parseInt(prompt("输入第一个数字"));
   var num2=parseInt(prompt("输入第二个数字"));
   consoleSum(num1, num2);


       function f1(x) {
         console.log(x);
       }
       function f2(x,y) {
        console.log(x,y);
       }
       function f3(x,y,z) {
        console.log(x,y,z);
       }
       function f4(x,y,z,k) {
        console.log(x,y,z,k);
       }


       f1(1)
       f2(2,3)
       f3(7,8,8)
       f4(5,4,0,2)

15 函数的返回值

set:设置
get:获取
函数的返回值:在函数内部有return关键字,并且在关键字后面有内容,这个内容被返回了
当函数调用之后,需要这个返回值,那么就定义变量接收,即可

如果一个函数中有return ,那么这个函数就有返回值
如果一个函数中没有return,那么这个函数就没有返回值
如果一个函数中没有明确的返回值,那么调用的时候接收了,结果就是undefined
(没有明确返回值:函数中没有return,函数中有return,但是return后面没有任何内容)
函数没有返回值,但是在调用的时候接收了,那么结果就是undefined
变量声明了,没有赋值,结果也是undefined
如果一个函数有参数,有参数的函数
如果一个函数没有参数,没有参数的函数
形参的个数和实参的个数可以不一致
return 下面的代码是不会执行的

    function f11(x,y){
      var sum=x+y;
      return sum;
      console.log("hh");
      return 100;
    }
    var aa=f11(11,22)
    console.log(aa)



    function getSum(x, y) {
     return x + y;
    }
    var aa=getSum(10, 20);
    console.log(aa+10);

    function f1(x, y) {
      var sum = x + y;
      return sum;
      console.log("助教才是最帅的");
      return 100;
    }
    var result = f1(10, 20);
    console.log(result);

   function getSum(x, y) {
     var sum = x + y;
     return sum;//把和返回
   }

函数调用

   var result=getSum(10, 20);
   console.log(result+10);

函数定义: 有参数有返回值的函数

function getSum(x, y) {
  return  x + y;//把和返回
}

函数调用

  var result=getSum(10, 20);
  console.log(result+10);

有参数,有返回值的函数

   function f1(x,y) {
     return x+y;
   }

有参数,无返回值的函数

   function f2(x) {
     console.log(x);
   }

无参数,有返回值的函数

   function f3() {
     return 100;
   }

无参数无返回值的函数

function f4() {
  console.log("萨瓦迪卡");
}

var sum=f1(10);
console.log(sum);

16 函数案例

//求两个数字的和:获取任意的两个数字的和
    function getSum(x, y) {
      return x + y;
    }
    console.log(getSum(10, 20));


    //求1-100之间所有的数字的和
    function geteverySum() {
      var sum=0;
      for(var i=1;i<=100;i++){
        sum+=i;
      }
      return sum;
    }
    console.log(geteverySum());


    // //- 求1-n之间所有数的和
   function geteverySum(n) {
     var sum = 0;
     for (var i = 1; i <= n; i++) {
       sum += i;
     }
     return sum;
   }
   console.log(geteverySum(10));


    //    - 求n-m之间所有数的和


   function geteverySum2(n, m) {
     var sum = 0;
     for (var i = n; i <= m; i++) {
       sum += i;
     }
     return sum;
   }
   console.log(geteverySum2(1, 100));

    // //求圆的面积
   function getS(r) {
     return Math.PI * r * r;
   }
   console.log(getS(5));


    - 求2个数中的最大值
    - 求3个数中的最大值
    - 判断一个数是否是素数(质数)


    function f1() {
      console.log("考尼奇瓦");
      return 100;
    }
    //f1函数调用,把函数的返回值输出了
    console.log(f1());
    
    function f1() {
      console.log("考尼奇瓦");
      return 100;
    }
    console.log(f1);//输出的f1函数名字-----是f1函数的代码

17 习题

求整数1～100的累加值，但要求碰到个位为3的数则停止累加

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

求1-100之间不能被7整除的整数的和（用continue）

var sum = 0;
 for (var i = 1; i <= 6; i++) {
   if (i % 7 != 0) {
     sum += i;
     continue;
   }
 }
 console.log(sum)

求200-300之间所有的奇数的和（用continue）

 var sum = 0;
 for (var i = 200; i <= 300; i++) {
   if (i % 2 != 0) {
     sum += i;
   }
 }
 console.log(sum)

求3个数中的最大值
思路：用函数+三元表达式

     function max() {
       var x = 1;
       var y = 2;
       var z = 3;
       console.log(x > y ? (x > z ? x : z) : (y > z ? y : z));
     }
     max();

求3个数中的最大值
判断一个数是否是素数(质数)

   var aa=parseInt(prompt("请输入一个数字"))

求1-n之间所有数的和

  function geteverysum(n) {
       var sum = 0;
       for (var i = 0; i <= n; i++) {
         sum += i;
       }
       return sum;
     }
     console.log(geteverysum(10))

求n-m之间所有数的和

 function geteverysum(n,m) {
   var sum = 0;
   for (var i = n; i <= m; i++) {
     sum += i;
   }
   return sum;
 }
 console.log(geteverysum(1,10))

求圆的面积 π*r^2

  function circle(r){
     return Math.PI*r*r;

    }
   console.log(circle(8))

求2个数中的最大值
求3个数中的最大值
判断一个数是否是素数(质数):从2开始，只能被自身和1整除

求1-100之间所有的数字的和

 function geteverysum(){
   var sum=0;
   for(var i=0;i<=100;i++){
     sum+=i;
   }
   return sum;
 }
 console.log(geteverysum())
     function f1(){
       console.log("s");
       return 100;
     }
//函数调用，把函数的返回值输出了
     console.log(f1);

如果括号内是f1，那么输出的是定义函数的内容
如果括号内是f1()，那么输出的是结果

其他参考链接

【 js基础 Day1】js的介绍及基本语法变量,运算符

【 js基础 Day2】js的流程控制:分支语句,循环.顺序结构

【 js基础 Day3】关键字的使用，数组（重点）和函数（重点）

【 js基础 Day4】面向过程，面向对象，自定义对象，内置对象

【 js基础 Day5】函数(重点)，作用域，预解析，arguments，对象

【 js基础 Day6】内置对象和基本包装类型等知识

【如果你不是新手】推荐链接

【js高级 Day1】深入理解原型及作用,构造函数和实例对象和原型对象之间的关系

【js高级 Day2】深入理解原型添加方法,私有函数,面向对象的编程思想（案例小贪吃蛇）

【js高级 Day3】深入理解原型的方式继承，借用构造函数继承，组合继承，拷贝继承

【js高级 Day4】深入理解apply和call方法，作用域，闭包，递归

【js高级 Day5】深入理解浅拷贝，深拷贝，遍历DOM树，正则表达式

阿珊和她的猫
关注
专栏目录
javaScript基础关键字介绍.docx
06-26
### JavaScript基础关键字详解 #### 一、概述 在JavaScript编程语言中，关键字（也称作保留字）扮演着至关重要的角色。这些关键字拥有特殊的含义，主要用于定义语言的基本结构或者执行特定的操作。根据JavaScript...
JavaScript基础练习_day3
08-24
### JavaScript基础练习_day3知识点详解 #### 一、变量赋值与条件判断 **知识点**： 1. **变量声明与赋值**：在JavaScript中，`var`关键字用于声明变量，可以用来存储各种数据类型（如布尔型、字符串、数字等）。 ...
JavaScript (三) js的基本语法 - - 数组 与函数 、关键字
喜欢历史的码农
07-30 470
一、关键字 1、break 关键字使用 break关键字:如果在循环中使用,遇到了break,则立刻跳出当前所在的循环 示例： for(var i=0;i<10;i++){ while (true){ console.log("哈哈"); break;// ...
js学习day3，数组与函数（上）
qq_40281275的博客
09-03 138
1. 通过创建对象创建数组 var array=new Array(); console.log(array); 如果数组()里面有一个数，那么这个数就是这个数组长度，多个数就为这个数组的值，而且里面的数为undefined arr[10]这个数只是值而不是长度 2.通过字面量创建数组 var arr=[];//空数组 ...
关键字arguments、数组
weixin_30673715的博客
01-05 116
一、关键字arguments function 函数名（）{} 函数声明没有形参 函数名（实参，实参） 调用的时候有传递实参 利用arguments可以在函数里边接收实参信息 例如 1 function f2(){ 2 var len=arguments.length; 3 if(len==0){ 4 console.log("个人...
[js点滴]JavaScript关于数组的方法总结
图解AI
10-26 4450
// 1.数组的写法 // 1.1字面量写法 var arr = [1,2,3,4,5]; // 1.2 构造函数写法 var arr1 = new Array(2);//创建一个长度为2的一个数组对象 // 1.3 不加new关键字写法 var arr2 = Array(2);//创建一个长度为2的一个数组对象 var arr3 = new Array();/
js shift() push()用法
LANGZI7758521的专栏
06-22 1004
shift()方法：移除数组中的第一项并返回该项 push()方法：从数组末端添加项 若是想实现相反的操作的话，可以使用 unshift()方法：在数组的前端添加项 pop()方法：从数组末端移除项 ...
JavaScript基础练习_day11
10-26
### JavaScript基础练习_day11知识点解析 #### 一、变量声明与作用域 **知识点概述：** 本部分内容涉及JavaScript中的变量声明方式以及不同声明方式之间的区别。JavaScript中有多种声明变量的方式，每种方式都有其...
JavaScript【数组】-【函数】-【重点】
Coding
03-20 424
JavaScript【数组】-【函数】-【重点】
JavaScript基础练习_day13
02-28
### JavaScript基础练习_day13知识点总结 #### 一、JavaScript数据类型 1. **基本数据类型**：在JavaScript中，基本数据类型包括`number`、`string`、`boolean`、`null`、`undefined`、`bigint`、`symbol`。 - `...
JavaScript 使用关键字 function 定义函数
热门推荐
菜菜鱼的博客
08-21 1万+
JavaScript 使用关键字 function 定义函数 函数可以通过声明定义，也可以是一个表达式。 函数声明 在之前的教程中，你已经了解了函数声明的语法 : ? 1 2 3 function functionName(parameters) { 执行的代码 }
C语言——数组&常用关键字
最新发布
qq_58969626的博客
12-20 1971
C语言数组的相关知识：初始化&元素访问&参数传递。关键字：typedef&#define的用法和区别。static修饰局部变量、全局变量和函数时的用法以及注意事项。
js数组的操作和this关键字
代码写到地老天荒
11-09 641
js数组的操作;   一:数组的创建: 1、数组的创建 var array = new Array();　//创建一个数组 var array = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]]);　...
js数组字符串关键字查找的方法 includes() indexOf() lastIndexOf() - Kaiqisan
Kaiqisan的博客
08-04 5110
js数组字符串关键字查找的方法 includes indexOf lastIndexOf ヤッハロー、Kaiqisanすうう、一つふつうの学生プログラマである，之前通过打印一个空字符串，通过查看其__proto__原型方法，找到了数组的所有的方法，里面绝大部分我是知道的，但是还有极少的几个方法我从来没见到，我会在以后的文章里详细地记下这些数组的操作方法。 includes(val, startIndex): 判断字符串内是否包含了相应的内容（顺序也不可以乱）,第一个参数填写需要判定的关键字，第二个参数可
Javascript知识【JS数组】重点
日常学习总结
08-07 362
本篇主要讲述：JavaScript中的数组知识，具体为定义方式和遍历方式
C语言数组详解
sjp151的博客
07-30 619
数组分类一维数组数组的创建数组的初始化数组的存储二维数组二维数组的创建和初始化二维数组的存储数组越界数组作为函数参数 一维数组 数组的创建 数组就是一类相同元素的集合。数组的创建要有元素类型，数组名，数组的大小，数组初始化。数组创建时可以不初始化，但是要指定大小。也可以不指定大小，但是要初始化。数组名可以随意指定，但是不要与关键字相同。 数组的大小一定是常量 下面就是几个创建数组的实例 int arr1[10]; char arr2[10]; float arr3[10]; double arr4[10]
1331. 数组序号转换 : 简单模拟题
宫水三叶的刷题日记
07-28 160
题目描述 这是 LeetCode 上的 1331. 数组序号转换 ，难度为 简单。 Tag : 「模拟」、「哈希表」、「排序」 给你一个整数数组 arr，请你将数组中的每个元素替换为它们排序后的序号。 序号代表了一个元素有多大。序号编号的规则如下： 序号从 开始编号。一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。每个数字的序号都应该尽可能地小。 示例 1： 输入：arr = [40,10,20,30]输出：[4,1,2,3]解释：40 是最大的
数组的基础及案例
weixin_34113237的博客
11-29 94
var arr1=new Array();//空数组var arr2=new Array(5);//长度为5的数组，每个数据的值为undefinedvar arr3=new Array(1,2,3,4,5);//长度为5的数组var arr4=new Array[];//空数组var arr5=new Array[1,2,3];//长度为3var arr6=new Array["red","gre...
js模糊查询数组中的某个值
Create_Time_NET的博客
01-09 6409
一次在写代码时需要将一些值以json的格式写入数组，然后可能会需要找到一些值，但是要找的值不足以直接拼接成一个完整json去查询，所以需要用到模糊查询，所以就想了一个办法来查询。 虽然这只是一个取巧的办法，但是简单 思路如下： 获取到要查询的值。 循环得到Array里的值。 用indexOf查询是否能在这个值里面找到。 如果能找到这个值，就把这个值放入新的数组中。 然后你就找到你要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿珊和她的猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值