JavaScript基础(2)

JavaScript基础(2)

表达式和语句

表达式

一个表达式可以产生一个值,有可能是运算、函数的调用、有可能是字面量。表达式可以放在任何需要值的地方。

语句

语句可以理解为一个行为,循环语句和判断语句就是典型的语句,一个程序中有很多个语句组成,一般情况下;分隔成一个一个的语句。

流程控制

程序的三种基本结构

顺序结构

从上到下执行的代码就是顺序结构,程序默认是由上到下顺序执行的

分支结构

根据不同的情况,执行对应的代码

循环结构

循环结构:重复做一件事

分支结构

if语句

语法结构

if (/* 条件表达式 */) {
  // 执行语句
}

if (/* 条件表达式 */){
  // 成立执行语句
} else {
  // 否则执行语句
}

if (/* 条件1 */){
  // 成立执行语句
} else if (/* 条件2 */){
  // 成立执行语句
} else if (/* 条件3 */){
  // 成立执行语句
} else {
  // 最后默认执行语句
}

案例

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>if语句</title>
    <!-- 引入jquery -->
    <script src="jquery-1.11.3.min.js"></script>
</head>

<body>
    <input type="date" class="times">
    <button class="btn">判断闰年</button>
    <div class="no"></div>
    <script>

        // 判断一个年份是闰年还是平年
        //条件是四年一闰,四百年一闰,一百年不闰
        //    要求点击按钮判断input里面的月份是不是闰年
        // var year = 2020;
        // 声明一个字符串
        var values = '';
        // 给input自定义一个属性获取到每次input的val值
        $(".times").change(function () {
            $(".times").attr("value", $(this).val()); //赋值
            console.log($(this).val())
            values = $(this).val();
            // 截取字符串substring(0,i),从0到第i个
            values = values.substring(0, 4);
            console.log(values)
        });

        // 点击按钮判断
        $(".btn").click(function () {
            // 判断条件
            if ((values % 4 == 0) || (values % 400 == 0) && (values % 100 != 0)) {
                $(".no").text('今年是闰年!');
            } else {
                $(".no").text('今年不是闰年!');
            }
        })

        //   求两个数的最大数
        var a = 10, b = 20;
        if (a > b) {
            console.log('a比b大');
        } else {
            console.log('b比a大');
        }
        // 判断一个数是偶数还是奇数
        var c = 8;
        if (c % 2 == 0) {
            console.log('c是偶数');
        } else {
            console.log('c是奇数');
        }
        // 分数转换,把  <60  E  60-70 D  70-80 C  80-90 B  90 - 100 A
        var score = 58;
        // 或者大于等于90 ...
        if (score < 60) {
            console.log("E");
        } else if (60 < score < 70) {
            console.log("D");
        } else if (70 < score < 80) {
            console.log("C");
        } else if (80 < score < 90) {
            console.log("B");
        } else {
            console.log("A");
        }

    </script>
</body>

</html>
在这里插入图片描述

三元运算符

表达式1?表达式2:表达式3
是if…else语句的一种简化写法
案例

<script>
        //    是否年满十八岁
        var age = 19;
        var msg = age >= 18 ? '满十八岁' : '不满十八岁';
        console.log(msg);
        // 两个数找最大
        var a = 10; b = 20;
        var msgs = a > b ? a + '大于' + b : b + '大于' + a;
        console.log(msgs);
    </script>
在这里插入图片描述

switch语句

语法格式

switch (expression) {
  case 常量1:
    语句;
    break;
  case 常量2:
    语句;
    break;
  case 常量3:
    语句;
    break;
  …
  case 常量n:
    语句;
    break;
  default:
    语句;
    break;
}

案例:

<script>
        // 显示星期几
        var day = 5;
        switch (day) {
            case 1:
                console.log('星期一');
                break;
            case 2:
                console.log('星期二');
                break;
            case 3:
                console.log('星期三');
                break;
            case 4:
                console.log('星期四');
                break;
            case 5:
                console.log('星期五');
                break;
            case 6:
                console.log('星期六');
                break;
            case 7:
                console.log('星期天');
                break;

        }
    </script>

在这里插入图片描述
break可以省略,如果省略,代码会继续执行下一个case
switch语句在比较值时使用的是全等操作符,因此不会发生类型转换(例如字符串‘10’不会等于数字10)

布尔类型的隐式转换

流程控制语句会把后面的值隐式转换成布尔类型
转换为true 非空字符串 非0数字 true 任何对象
转换为false 空字符串0 false null undefined

  // var num = 0;
    // console.log(Boolean(num));

    // 转换成false的情况   0   ''空字符串  NaN  null undefined 
    // 隐式类型转换
    // if (num) {
    //   console.log('hello');
    // }
    // 
    // 
    // var msg;
    // if (msg) {
    //   console.log('hello');
    // }
    // 
    // 
    var str = '123';

    var isOK = !!str;  // Boolean(str);
    console.log(isOK);

循环结构

在JavaScript中,循环语句有三种,while、do…while、for循环

while语句

基本语法

// 当循环条件为true时,执行循环体,
// 当循环条件为false时,结束循环。
while (循环条件) {
  //循环体
}

代码示例:

// 计算1-100之间所有数的和
// 初始化变量
var i = 1;
var sum = 0;
// 判断条件
while (i <= 100) {
  // 循环体
  sum += i;
  // 自增
  i++;
}
console.log(sum);
 <script>

        var num = 1;
        var sum = 0;
        // 循环的条件100以内
        while (num <= 100) {
            // if判断 打印100以内7的倍数
            // if (num % 7 == 0) {
            //     console.log(num);
            // }
            // 打印100以内的所有偶数
            // if (num % 2 == 0) {
            //     console.log(num);
            // }
            // 打印100以内所有偶数
            if (num % 2 == 0) {
                sum += num;

            }
            num++;
        }
        console.log(sum);
    </script>
do…while语句

do…while语句和while循环非常像,二者经常可以相互替代,但是do…while的特点是不管条件成不成立,都会执行一次。
基础语法:

do {
  // 循环体;
} while (循环条件);

代码示例:

// 初始化变量
var i = 1;
var sum = 0;
do {
  sum += i;//循环体
  i++;//自增
} while (i <= 100);//循环条件

案例:

<script>
        // 求100以内所有3的倍数的和
        // var i = 1;
        // var sum = 0;
        // do {
        //     // 循环体
        //     if (i % 3 == 0) {
        //         sum += i;
        //     }
        //     i++;
        // } while (i <= 100);
        // console.log(sum);
        // do-while循环
        do {
            var msg = prompt('你到底爱不爱我?', '请输入yes/no');
        } while (msg !== 'yes');
        console.log('小样还想点no');
    </script>
for语句

while和do…while 一般用来解决无法确认次数的循环,for循环一般在循环次数确定的时候比较方便
for循环语法:

// for循环的表达式之间用的是;号分隔的,千万不要写成,
for (初始化表达式1; 判断表达式2; 自增表达式3) {
  // 循环体4
}

执行顺序:1243 —- 243 —–243(直到循环条件变成false)

  • 初始化表达式
  • 判断表达式
  • 自增表达式
  • 循环体
    案例:
<script>
        // 打印1-100之间的数
        // for (var i = 1; i <= 100; i++) {
        //     console.log(i);
        // }
        // 打印1-100之间所有数的和
        // var sum = 0;
        // for (var i = 1; i <= 100; i++) {
        //     sum += i;
        // }
        // console.log(sum);
        // 打印1-100之间所有数的平均值
        // var sum = 0;
        // var avg;
        // for (let i = 1; i < 100; i++) {
        //     sum += i;
        // }
        // avg = sum / 100;
        // console.log(avg);
        // 打印1-100之间所有偶数的和
        // var num = 0;
        // for (let i = 1; i <= 100; i++) {
        //     if (i % 2 == 0) {
        //         num += i;
        //     }
        // }
        // console.log(num);
        // 打印九九乘法表
        // 声明一个字符串变量
        var str = '';
        // 外循环,循环九次
        for (let i = 0; i <= 9; i++) {
            // 内循环 j=i
            for (let j = i; j <= 9; j++) {
                str += i + '*' + j + '=' + i * j + '\t';
            }
            // 换行
            str += '\n';
        }
        console.log(str);
    </script>
continue和break

break:立即跳出整个循环,即循环结束,开始执行循环后面的内容(直接跳到大括号)
continue:立即跳出循环,继续下一次循环(跳到++的地方)
案例:

 <script>
        // 求整数1-100的累加值,但要求碰到个位为3的数着暂停累加
        // var sum = 0;
        // for (let i = 1; i <= 100; i++) {
        //     if (i % 10 == 3) {
        //      console.log(i)
        //         
        //     }else{
        //    sum + = i;
        // }

        // }
        // console.log(sum);
        // 求整数1-100的累加值,但要求碰到个位为3的数就跳过
        var sum = 0;
        for (let i = 1; i <= 100; i++) {
            if (i % 10 == 3) {
                continue;
            }
            sum += i;
        }
        console.log(sum);
    </script>

调试

  • 过去调试JavaScript的方式
    • alert()
    • console.log()
  • 断点调试
    断点调试是指自己在程序的某一行设置一个断点,调试时,程序运行到这一行就会停住,然后你可以一步一步往下调试,调试过程中可以看各个变量的当前的值,出错的话,调试到出错的代码行即显示错误,停下。
  • 调试步骤
    浏览器中按F12—–>sources—->找到需要调试的文件—>在程序的某一点设置断点
  • 调试中的相关操作
    watch:监视,可以通过watch可以监视变量的值的变化,非常的常用。
    F10:程序单步执行,让程序一行一行的执行,这个时候,观察watch中的变量的值的变化
    F8:跳到下一个断点处,如果后面没有断点了,则程序执行结束
    tips:监视变量,不要监视表达式,因为监视了表达式,那么这个表达式也会执行。
    • 代码调试的能力非常重要,只有学会了代码提调试,才能学会自己解决bug的能力。

数组

数组是一个有序的列表,可以在数组中存放任意的数据,并且数组的长度可以动态的调整

  • 字面量
// 创建一个空数组
var arr1 = []; 
// 创建一个包含3个数值的数组,多个数组项以逗号隔开
var arr2 = [1, 3, 4]; 
// 创建一个包含2个字符串的数组
var arr3 = ['a', 'c']; 

// 可以通过数组的length属性获取数组的长度
console.log(arr3.length);
// 可以设置length属性改变数组中元素的个数
arr3.length = 0;
获取数组元素

数组的取值

// 格式:数组名[下标]	下标又称索引
// 功能:获取数组对应下标的那个值,如果下标不存在,则返回undefined。
var arr = ['red',, 'green', 'blue'];
arr[0];	// red
arr[2]; // blue
arr[3]; // 这个数组的最大下标为2,因此返回undefined
遍历数组

遍历:遍及所有,对数组的每一个元素都访问一次就叫遍历。
数组遍历的基本语法:

for(var i = 0; i < arr.length; i++) {
	// 数组遍历的固定结构
}

for(var n in arr){console.log(arr(n))}
数组中新增元素

数组的赋值:

// 格式:数组名[下标/索引] = 值;
// 如果下标有对应的值,会把原来的值覆盖,如果下标不存在,会给数组新增一个元素。
var arr = ["red", "green", "blue"];
// 把red替换成了yellow
arr[0] = "yellow";
// 给数组新增加了一个pink的值
arr[3] = "pink";
  <script>
    // // 数组 是一种数据类型
    // // Number String
    // var n1 = 6;
    // var name = 'zs';

    // // 数组 可以存储很多项,有顺序,很多项形成一个集合,这个集合就是数组 Array
    // // 数组的字面量 [] 
    // var names = ['zs', 'ls', 'ww', 'zl'];

    // // 如何获取数组中的数据
    // // 索引/下标  数组中的第一项的索引是从0开始
    // console.log(names[0]);
    // console.log(names[1]);
    // // 获取数组中最后一项的值
    // console.log(names[3]);
    // // undefined
    // console.log(names[4]);
    // 
    // 
    // 数组中存储的数据类型可以不一致
    // 但是不推荐这么用
    // var names = ['zs', 'ls', 18, 19, true];
    // console.log(names);
    // 
    // 数组的长度: 数组中元素的个数
    // var names = ['zs', 'ls', 'ww', 'zl', '', 'abc', '123'];
    // // 获取数组的长度
    // // console.log(names.length);
    // // 
    // // console.log(names[0]);
    // // 获取数组中的最后一个元素
    // // 如果数组中有29项,最后一项的索引是多少?  数组的长度 - 1
    // console.log(names.length);
    // console.log(names[names.length - 1]);
    

    // 数组 的长度 可以动态改变
     // var names = ['zs', 'ls', 'ww', 'zl'];
     // // 如何修改数组中的元素
     // // names[0] = 'xxx';
     // // console.log(names);
     // // 
     // // 给数组增加一项
     // // names[4] = 'abc';
     // names[6] = 'xxx';
     // console.log(names);
     // console.log(names.length);


     // 获取数组中的每一项,并打印(遍历数组)
    // var names = ['zs', 'ls', 'ww', 'zl'];
    // for (var i = 0; i < names.length; i++) {
    //   console.log(names[i]);
    // }

    // 遍历数组  先打印最后一项    长度 - 1    长度 - 2
    // var names = ['zs', 'ls', 'ww', 'zl'];
    // for (var i = names.length - 1; i >= 0; i--) {
    //   console.log(names[i]);
    // }
    // 
    // 
    // 补充 
    var scores = [];  // 空数组
    console.log(scores.length);
    for (var i = 0; i < 10; i++) {
      scores[i] = i;
    }
    console.log(scores);

    // 清空数组
    scores.length = 0;
    console.log(scores);

    // var array = [57, 90, 100];
    
  </script>

案例:

<script>
        // 求一组数中所有数的和和平均值
        var arr = [20, 10, 40, 0, 30, 50, 60, 0];
        // 假设最大值在第一位
        // var max = arr[0];
        // var min = arr[0];
        // var maxIndex = 0;
        // var minIndex = 0;
        // var sum = 0;
        // var avg;
        // for (let i = 0; i < arr.length; i++) {
        //     var a = arr[i];
        //     sum += a;
        // }
        // avg = sum / arr.length;
        // console.log(sum);
        // console.log(avg);

        // 求一个数组中的最大值和最小值以及所在的位置
        // for (let i = 0; i < arr.length; i++) {
        //     if (max < arr[i]) {
        //         max = arr[i];
        //         maxIndex = i;
        //     }
        //     if (min > arr[i]) {
        //         min = arr[i];
        //         minIndex = i;
        //     }
        // }
        // console.log('最大值:' + max);
        // console.log('最大值所在的位置:' + maxIndex);

        // console.log('最小值:' + min);
        // console.log('最小值所在的位置:' + minIndex);

        // 将字符串数组用|分隔
        // var a = ['a', 'b', 'c'];
        // var str = '';
        // var fgf = '|';
        // for (let i = 0; i < a.length; i++) {
        //     //在a后面加分隔符
        //     // str += a[i] + fgf;
        //     // 在a前面加分隔符
        //     str += fgf + a[i];
        // }
        // console.log(str);

        //将数组中的第0项去掉,将不为0的值存入一个新数组
        // var newArry = [];
        // for (let i = 0; i < arr.length; i++) {
        //     //    判断不为0
        //     if (arr[i] !== 0) {
        //         // 将数据存入新数组
        //         newArry[newArry.length] = arr[i];
        //     }
        // }
        // console.log(newArry);

        // 翻转数组
        // 创建新数组
        // var array = [];
        // // 倒着遍历
        // for (var i = arr.length - 1; i >= 0; i--) {
        //     array[array.length] = arr[i];
        // }
        // console.log(array);

        // 冒泡排序 从小到大 外层循环:控制趟数,每一趟一个最大值  内层循环:控制比较次数,并且判断两个数的大小
        // var count = 0;  //记录趟数
        // for (let i = 0; i < arr.length - 1; i++) {
        //     count++;
        //     for (let 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);
        // console.log(count);


        // 优化
        var count = 0;  //记录趟数
        for (let i = 0; i < arr.length - 1; i++) {
            // 假设数据排好了顺序
            var isSort = true;
            count++;
            for (let j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 没有排好
                    isSort = false;
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            // 某一趟结束,判断一下排序是否结束
            // 如何判断排序是否排好,根据是否发生了数据交换,如果发生了数据交换说明没有排好
            if (isSort) {
                // 如果排序完成
                break;
            }
        }
        console.log(arr);
        console.log(count);
    </script>

函数

函数就是把一段相对独立的具有特定功能的代码块封装起来,形成一个独立实体,就是函数,在后续开发中可以反复调用,函数的作用就是封装一段代码,将来可以重复使用

函数的定义
  • 函数声明
function 函数名(){
  // 函数体
}
  • 函數表式
 var fn = function() {
  // 函数体
}

特点:
函数体只有在调用的时候才会执行,调用需要()进行调用
可以调用多次(重复使用)
代码示例:

// 声明函数
function sayHi() {
  console.log("吃了没?");
}
// 调用函数
sayHi();

// 求1-100之间所有数的和
function getSum() {
  var sum = 0;
  for (var  i = 0; i < 100; i++) {
    sum += i;
  }
  console.log(sum);
}
// 调用
getSum();
函数的参数
  • 为什么要有参数
function getSum() {
  var sum = 0;
  for (var i = 1; i <= 100; i++) {
    sum += i;
  }
  console.log();
}

// 虽然上面代码可以重复调用,但是只能计算1-100之间的值
// 如果想要计算n-m之间所有数的和,应该怎么办呢?
  • 语法
    // 函数内部是一个封闭的环境,可以通过参数的方式,把外部的值传递给函数内部
    // 带参数的函数声明
    function 函数名(形参1, 形参2, 形参…){
    // 函数体
    }

// 带参数的函数调用
函数名(实参1, 实参2, 实参3);

  • 形参和实参
  1. 形式参数:在声明一个函数的时候,为了函数的功能更加灵活,有些值是固定不了的值。我们可以给函数设置参数,这个参数没有具体的值,仅仅起到一个占位置的作用,我们通常称之为形式参数,也叫形参。
  2. 实际参数:如果函数在声明时,设置了形参,那么在函数调用的时候就需要传入对应的参数,我们把传入的参数叫做实际参数,也叫实参。
  var x = 5, y = 6;
fn(x,y); 
function fn(a, b) {
  console.log(a + b);
}
//x,y实参,有具体的值。函数执行的时候会把x,y复制一份给函数内部的a和b,
函数内部的值是复制的新值,无法修改外部的x,y
函数的返回值

当函数执行完的时候,并不是所有时候都要把结果打印。我们期望函数给我一些反馈,这个时候可以让函数返回一些东西,也就是返回值。函数通过return 返回一个值。
返回值语法:

//声明一个带返回值的函数
function 函数名(形参1, 形参2, 形参...){
  //函数体
  return 返回值;
}

//可以通过变量来接收这个返回值
var 变量 = 函数名(实参1, 实参2, 实参3);

函数的调用结果就是返回值,因此我们可以直接对函数调用结果进行操作。
返回值详解:

  1. 如果函数没有显示的使用return语句,你们函数有默认的返回值:undefined
  2. 如果函数使用return语句,那么跟在return后面的值,就成了函数的返回值
  3. 如果函数使用return语句,但是return后面没有任何值,那么函数的返回值也是:undefined
  4. 函数使用return后,这个函数会在执行完return语句之后停止并立即退出,也就是说return后面的所有其他代码都不会执行
    推荐:要么始终都返回一个值,要么永远都不要返回值。

案例:

 <script>
        // 写一个函数,计算两个数的和
        function getSum(x, y) {
            var sum = x + y;
            console.log(sum);   //300  3
        }
        // 调用函数
        getSum(100, 200);
        // 实参和形参
        var a = 1;
        var b = 2;
        getSum(a, b);

        // 圆的面积 
        function clice(r) {
            var pi = 3.1415926;
            console.log(pi * r * r);

        }
        clice(6);

        // 求两个数中最大值,求三个数就用&&
        function maxNumber(a, b) {
            if (a > b) {
                console.log(a);
            } else {
                console.log(b);
            }
        }

        maxNumber(10, 20);
        var c = 30;
        var d = 40;
        maxNumber(c, d);


        // - 判断一个数是否是素数(又叫质数,只能被1和自身整数的数)
        function jdugePrimeNumber(number) {
            // 假设number是质数
            var isPrime = true;
            for (var i = 2; i < number; i++) {
                // 判断是否有能被number整数的数
                if (number % i === 0) {
                    // 如果此处执行了。说明不是质数
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                console.log('质数');
            } else {
                console.log('不是质数');
            }
        }
        jdugePrimeNumber(13);

返回值

<script>
        // 求一组数组中的最大值
        function arrayMax(array) {
            var max = array[0];
            for (let i = 0; i < array.length; i++) {
                if (max < array[i]) {
                    max = array[i];
                }
            }
            // 函数返回值
            return max;
        }
        // 调用函数
        var arr = [1, 3, 55, 8, 0, 48];
        var max = arrayMax(arr);
        console.log(max);

        // 求阶乘 5*4*3*2*1
        function getJieChen(n) {
            var result = 1;
            for (let i = 1; i <= n; i++) {
                result = result * i;
            }
            return result;
        }
        var num = getJieChen(5);
        console.log(num);

        // 求1!+2!+3!+n!
        function getSum(n) {
            var sum = 0;
            for (let i = 1; i <= n; i++) {
                // 累加阶乘
                sum += getJieChen(n);
            }
            return sum;
        }
        var sums = getSum(5);
        console.log(sums);
    </script>
arguments的使用

JavaScript中,arguments对象是比较特别的一个对象,实际上是当前函数的一个内置属性。也就是说所有函数都内置了一个arguments对象,arguments对象中存储了传递的所有的实参。arguments是一个伪数组,因此可以进行遍历。

案例:

 <script>
        function test(a, b, c) {
            // 我们可以通过arguments 获取函数调用的时候的实参
            // arguments非常像数组,但不是数组
            console.log(arguments);
        }
        test(4, 5, 6);

        // 求任意个数的最大值
        function getMax() {
            var num = arguments[0];
            for (let i = 0; i < arguments.length; i++) {
                if (num < arguments[i]) {
                    num = arguments[i];
                }
            }
            return num;
        }
        var max = getMax(5, 0, 50, 20, 88);
        console.log(max);

        // 求斐波那契数列中第n个数是多少
        function fibonacci(n) {
            //    函数体
            var n1 = 1;
            var n2 = 1;
            var n3;
            for (let i = 3; i <= n; i++) {
                n3 = n1 + n2;
                n1 = n2;
                n2 = n3;
            }
            return n3;
        }
        var r = fibonacci(6);
        console.log(r);

        // 翻转数组
        // var a = [1, 2, 5, 8, 5, 4];
        // var b = [];
        // for (let i = a.length - 1; i >= 0; i--) {
        //     b[b.length] = a[i];
        // }
        // console.log(b);

        // 翻转数组,返回一个新数组   [5, 4, 3, 2, 1] -> [1, 2, 3, 4, 5]
        // function reverse(array) {
        //   var newArray = [];
        //   for (var i = array.length - 1; i >= 0; i--) {
        //     newArray[newArray.length] = array[i];
        //   }
        //   return newArray;
        // }

        // // var arr = [5, 3, 2, 1];
        // // console.log(reverse(arr));

        // var arr = ['abc', 'xyz', '123'];
        // console.log(reverse(arr));


        // 对数组排序,从小到大  -- 冒泡排序
        // function sort(array) {
        //   // 外层循环 控制趟数
        //   for (var i = 0; i < array.length - 1; i++) {
        //     // 假设排好序了
        //     var isSort = true;
        //     // 内层循环 控制比较的次数
        //     for (var j = 0; j < array.length - 1 - i; j++) {
        //       if (array[j] > array[j + 1]) {
        //         isSort = false;
        //         // 交换位置
        //         var tmp = array[j];
        //         array[j] = array[j + 1];
        //         array[j + 1] = tmp;
        //       }
        //     }
        //     // 判断是否排好了
        //     if (isSort) {
        //       break;
        //     }
        //   }
        //   return array;
        // } 

        // var array = [34, 12, 88, 20, 30];

        // console.log(sort(array));
        // }

        // 输入一个年份,判断是否是闰年[闰年:能被4整数并且不能被100整数,或者能被400整数]
        // function isRun(year) {
        //   var result = false;
        //   if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) {
        //     result = true;
        //   } 
        //   return result;
        // }

        // console.log(isRun(2016));


        // 输入某年某月某日,判断这一天是这一年的第几天?
        // 1998 5 18 
        // 5月份 18
        // 4月份 30
        // 3月份 31
        // 2月份 闰年的时候29天  平年的时候28天
        // 1月份 31
        // 
        // 判断年份是否是闰年
        function isRun(year) {
            var result = false;
            if ((year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0)) {
                result = true;
            }
            return result;
        }
        // 获取年月日 是当前年的多少天
        function getDays(year, month, day) {
            // 计算总共有多少天
            var days = day;   // 当前月份的天数
            for (var i = 1; i < month; i++) {
                switch (i) {
                    case 1:
                    case 3:
                    case 5:
                    case 7:
                    case 8:
                    case 10:
                    case 12:
                        days += 31;
                        break;
                    case 4:
                    case 6:
                    case 9:
                    case 11:
                        days += 30;
                        break;
                    case 2:
                        // 判断是平年28还是闰年29
                        if (isRun(year)) {
                            days += 29;
                        } else {
                            days += 28;
                        }
                        break;
                }
            }
            return days;
        }

        console.log(getDays(1998, 5, 2));
    </script>

函数其它

匿名函数

匿名函数:没有名字的函数
匿名函数如何使用:
将匿名函数赋值给一个变量,这样可以通过变量进行调用 匿名函数自调用
关于自执行函数(匿名函数自调用)的作用:防止全局变量污染

自调用函数

匿名函数不能通过直接调用来执行,因此可以通过匿名函数的自调用的方式来执行

(function () {
  alert(123);
})();
函數是一种数据类型
function fn() {}
console.log(typeof fn);
  • 函数作为参数
    因为函数也是一种类型,可以把函数作为一个函数的参数,在一个函数中调用
  • 函数作为返回值
    因为函数是一种类型,所以可以把函数作为返回值从内部返回,这种用法在后面很常见。
function fn(b) {
  var a = 10;
  return function () {
    alert(a+b);
  }
}
fn(15)();

案例:

 <script>
        // //1 函数声明 - 命名函数
        // function fn() {
        // }

        // //2 函数表达式  -- 后半部分  匿名函数
        // var fn = function () {
        // }
        // 

        // 3 自调用函数  -- 当函数书写完成之后立即调用
        // (function () {
        //   console.log('我是自调用函数');
        // })()
        // 
        // 
        // 4 函数也是一种数据类型  function 也是一种数据类型
        var n = 5;
        var str = '123';
        var fn = function () {
            console.log('我是传过来的函数');
        }
        // console.log(typeof fn);
        // 4.1 因为函数是一种数据类型,所以函数可以作为另一个函数的参数
        // function test(fun) {
        //   // 当我们调用函数的时候。如果没有传递参数,此时形参的值是什么?
        //   // 此时fun的值是undefined
        //   // console.log(fun);
        //   fun();
        // }

        // test(fn);
        // 
        // 4.2 因为函数是一种数据类型,所以函数可以作为另一个函数的返回值

        function test(a) {
            var b = 5;

            return function () {
                console.log(a + b);
            }
        }

        var fn = test(2);  // 此函数返回的结果是一个函数
        fn();
    </script>
代码规范
  1. 命名规范
  2. 变量规范
    var name = ‘zs’;
  3. 注释规范
    // 这里是注释
  4. 空格规范
  5. 换行规范
	var arr = [1, 2, 3, 4];
	if (a > b) {
      
	}
	for(var i = 0; i < 10; i++) {
      
	}
	function fn() {
      
	}

这篇文章有一个评论

发表评论