JavaScript-ECMAScript5-JS基础语法「建议收藏」

例如：
0=00000000 1=00000001 2=00000010 3=00000011 4=00000100 
5=00000101 6=00000110 7=00000111 8=00001000 9=00001001 
10=00001010

C语言：puts("你好");
PHP：echo "你好";
Java：System.out.println("你好");
JavaScript： alert("你好"）;

<input type="button" value="点我试试" onclick="alert('Hello World')" />

 <script>
 alert('Hello World~!');
 </script>

<script src="my.js"></script>

// 我是一行文字，不想被 JS引擎 执行，所以 注释起来

/*
  获取用户年龄和姓名
 并通过提示框显示出来
*/

// 声明变量
 var age; // 声明一个 名称为age 的变量

var age = 18; // 声明变量同时赋值为 18

<script>
     //弹出输入框 propmt()
    var myName = prompt("请输入你的姓名");
    //弹出输入的内容 alert()
    alert(myName)
</script>

<script>
    var age = 18;
    age = 81; // 最后的结果就是81因为18 被覆盖掉了
    console.log(age)//81
</script>

<script>
    var age = 10,
     name = 'zs',
     sex = 2;
     console.log(age,name,sex)//10 zs 2
</script>

    <script>
        var num1 = 10,
            num2 = 20,
            num3 = num2,//将num2的值存在num3中
            num2 = num1,//将num1的值赋给num2
            num1 = num3;//将num3的值赋给num1
        console.log(num1) //20
        console.log(num2) //10
    </script>

<script>
    var nun = 10; //整数
    var num = 3.14; //小数
</script>

<script>
    //进制
    // 1.生活中常用的是十进制数字，也就是逢10进一
    var num4 = 20;
    console.log(num4)

    // 2.八进制数字序列范围：0~7
    var num1 = 07; // 对应十进制的7
    var num2 = 012; // 对应十进制的12
    var num3 = 08; // 对应十进制的8

    // 3.十六进制数字序列范围：0~9以及A~F
    var num = 0xA;
</script>

<script>
    //数字的范围 javascript中数字的最大值和最小值
    // 1.最大值
    var num5 = Number.MAX_VALUE
    console.log(num5) //1.7976931348623157e+308

    // 2.最小值
    var num6 = Number.MIN_VALUE
    console.log(num6) //5e-324
</script>

<script>
    //数字型的三个特殊值 
    // 1.无穷大 Infinity
    var num7 = Number.MAX_VALUE * 2
    console.log(num7) //Infinity

    // 2.无穷小 -Infinity
    var num8 = -Number.MAX_VALUE * 2
    console.log(num8) //-Infinity

    // 3.非数字 NaN
    var num9 = 5 - "你好"
    console.log(num9) //NaN
</script>

<script>
    //判断是不是非数字型
    // isNaN()这个方法用来判断非数字，返回值为Boolean类型
    var num1 = 12
    console.log(isNaN(num1)) //false 数字型

    var num2 = 'aaa'
    console.log(isNaN(num2)) //true 非数字型
</script>

<script>
    var strMsg = "我爱北京天安门~"; //使用双引号表示字符串
    var strMsg = '我爱北京'; //使用单引号表示字符串
</script>

<script>
    // 1.外双内单 用" " 包含 ''
    var strMsg2 = "我是'高富帅'"
    // 2.内双外单 ' ' 包含 " "
    var strMsg = '我是一个"高富帅"'
</script>

<script>
    //字符串转义符案例
    var s = '酷热难耐，火辣的太阳底下，我挺拔的身姿，\n 成为了最为独特的风景。我审视四周，\n这里，是我的舞台，\n我就是天地间的王者。这一刻，\n我豪气冲天，终于大喊一声："收破烂啦"'
    alert(s)
</script>

<script>
    //字符串长度 length
    // 1.检测获取字符串的长度
    var str = 'my name is andy'
    console.log(str.length) //15
</script>

<script>
    //字符串的拼接 +
    // 1.字符串型+字符串
    var str1 = '沙漠';
    var str2 = '骆驼'
    console.log(str1 + str2) //沙漠骆驼
    console.log('我是' + '孙悟空') //我是孙悟空
    console.log('12' + '12') //1212

    // 2.字符串型+数字型
    console.log('我今年' + 18 + '岁啦') //我今年18岁啦

    // 3.字符串型+Boolean型
    console.log('我是' + true) //我是true

    // 4.数字型+数字型
    console.log(12 + 12) //24
</script>

<script>
    //字符串拼接的加强
    var age1 = 18;
    var age2 = age1 + 1;
    console.log('我今年' + age1 + '岁啦')//我今年18岁啦
    console.log('我明年' + age2 + '岁啦')//我今年19岁啦
</script>

<script>
    //显示年龄案例
    // 弹出一个输入框，需要用户输入年龄，之后弹出一个警示框显示“您今年 xx 岁啦”（xx 表示刚才输入的年龄）
    var age = prompt('请输入你的你年龄');
    var str = '你今年' + age + '岁啦'; //引引加加
    alert(str)
</script>

<script>
    // true做加法时当1来看
    var flag1 = true;
    console.log(flag1 + 1) // 2
    var flag2 = false;

    // false做加法时当0来看
    console.log(flag2 + 1) // 1
</script>

<script>
    // 如果一个变量声明未赋值，就是undefined 未定义数据类型
    var num;
    console.log(num) //undefined

    // 0.undefined拼接
    // 1.undefined+undefined
    var num1;
    var num2;
    console.log(num1 + num2) //NaN

    // 2.undefined+string
    var num3;
    console.log(num + '你好啊') //undefined你好啊

    // 3.undefined+boolean
    var num4;
    console.log(num4 + true) //NaN
    console.log(num4 + false) //NaN

    // 4.undefined+number
    var num5;
    console.log(num5 + 44) //NaN
</script>

<script>
    //一个声明变量给 null 值，里面存的值为空
    var space = null
    console.log(space) //null

    // null+null
    console.log(space + space) //0

    // 1.null+string
    console.log(space + '你好呀') //null你好呀

    // 2.null+number
    console.log(space + 3) //3

    // 3.null+boolean
    console.log(space + false) //0
    console.log(space + true) //1

    // 4.null+undefined
    var num;
    console.log(space + num) //NaN
</script>

<script>
    var num = 3;
    console.log(typeof num) //number
    var str = '你哈'
    console.log(typeof str) //string
    var flag = true
    console.log(typeof flag) //boolean
    var undefined;
    console.log(typeof undefined) //undefined
    var num22 = null;
    console.log(typeof num22) //object 
</script>

<script>
    //String 黑色
    console.log('贝克汉姆') //黑色

    //Number 蓝色
    console.log(12) //蓝色

    //Boolean 深蓝色
    console.log(true); //深蓝色

    //Null和Undefined 浅灰色
    var num = null;
    console.log(num) //浅灰色
    var nu2;
    console.log(nu2) //浅灰色
</script>

<script>
    //转换为字符串型
    // 1. 字型转换为字符型
    // 1.1 toString
    var num = 10;
    var str = toString(num)
    console.log(typeof str) //string

    // 1.2 String
    var num2 = 10;
    var str2 = String(num2)
    console.log(typeof str2) //string

    // 1.3 加号拼接字符串
    var num3 = 10;
    var str3 = num3 + '';
    console.log(typeof str3) //string
</script>

<script>
    // 1. 转换成数字型
    // 1.1 转换成整数型 parseInt(变量) 向下取整
    console.log(parseInt('18.9'), typeof parseInt('18.9')) //18 number
    console.log(parseInt('18.1')) //18
    console.log(parseInt('120px')) //120
    console.log(parseInt('rem120px')) //NaN非数字型

    // 1.2 转换成小数型 parseFloat(变量) 得到小数(浮点数)
    console.log(parseFloat('18.99'), typeof parseFloat('18.99')) //18.99 number

    // 1.3 Number强制转换
    console.log(Number('30.22'), typeof Number('30.22')) //30.22 'number'
    console.log(Number('30'), typeof Number('30')) // 30 'number'

    // 1.4 利用算数运算 -*/隐式转换
    console.log('12' - 0, typeof('12' - 0)); //12 'number'
    console.log('12' * 2, typeof('12' * 2)); //24 'number'
    console.log('12' / 2, typeof('12' / 2)); // 'number'
</script>

<script>
    //转换成布尔型
    // 1.1 代表空，否定的值会被转换为false，如 ’ ’ , 0, NaN , null , undefined
    console.log(Boolean(0)) //false
    console.log(Boolean('')) //false
    console.log(Boolean(null)) //false
    console.log(Boolean(undefined)) //false
    console.log(Boolean(NaN)) //false

    // 1.2 其余的值都会被被转换为true
    console.log(Boolean(3.14)) //true
    console.log(Boolean('你好啊')) //true
</script>

<script>
    //算数运算符 先*/，后+-，有括号就先算括号里面的
    // 1. + - * /
    console.log(10 + 10) //20
    console.log(10 - 10) //0
    console.log(10 * 10) //100
    console.log(10 / 10) //1

    // 2. % 取余数
    console.log(9 % 3) //0
    console.log(9 % 2) //1
    console.log(2 % 9) //2

    // 3. 浮点数 
    // 3.1 所参与的式子都是浮点数的时候算数运算里面会有问题
    // 3.2 不要直接判断两个浮点数是否相等 !
    var num1 = 0.1 + 0.2;
    console.log(num1) //0.30000000000000004
    console.log(num1 == 0.3) //false 判断是否相等
    var num2 = 0.1 * 0.2
    console.log(num2) //0.020000000000000004
    console.log(num2 == 0.02) //false

    // 4. 当浮点数和整数相加的时候，就不会有问题 乘法不适用
    var num3 = 1 + 0.2 + 0.3
    console.log(num3) //1.5
    console.log(num3 == 1.5) //true
    var num4 = 3 * 0.3
    console.log(num4) //0.8999999999999999
    console.log(num4 == 0.9) //false
</script>

<script>
    // 是由数字、运算符、变量等组成的式子，我们称为表达式 1+1
    console.log(1 + 1); //2 就是返回值

    // 正常情况下计算方式 1 + 1= 2
    // 在程序里面 2 = 1+ 1 把右边的表达式计算完毕之后返回值给左边（赋值）
    var num = 1 + 1;
</script>

<script>
    // 1.想要变量自己加1 num=num+1 比较麻烦
    var num1 = 10;
    num1 = num1 + 1; //++num1
    console.log(num1) //11

    // 2.前置递增运算符 ++num ++写在变量的前面
    var num2 = 10;
    ++num2; //类似于 num2=num2+1
    console.log(num2) //11

    // 3.++前置使用口诀：先自加，后返回值
    var p = 10;
    console.log(++p + 10) //21 p+1+10

    // 4.前置--同理
    var num3 = 10;
    --num3;
    console.log(num3) //9
</script>

<script>
    // 1.num++ 后置递增，就是自加1，类似于 num = num + 1 ，但是 num++ 写起来更简单
    var num = 10;
    num++;
    console.log(num) //11

    // 2. 使用口诀：先返回原值，后自加
    var p = 20;
    console.log(p++ + 10) //30

    // 3.后置递减同理
     var num2 = 20;
    num2--;
    console.log(num2) //19
</script>

<script>
    // 1.前置自增和后置自增单独写的时候，执行程序和结果是一样的
    var num1 = 10,
        num2 = 10;
    ++num1
    num2++
    console.log(num1, num2) //11 11

    // 2.前置口诀 先自加，后返回值
    var num3 = 20,
        num4 = ++num3 + 10; //num3=num3+1(先自加) num4=21+10
    console.log(num3, num4) //21 31

    // 3.后置口诀 先返回原值，后自加
    var num5 = 20,
        num6 = num5++ + 10 //num6=20+10(先返回值) num5++(后自增)
    console.log(num5, num6) //21 30
</script>

<script>
    // 比较运算符是两个数据进行比较时所使用的运算符，比较运算后，会返回一个布尔值(true / false)作为比较运算的结果
    // 1. > < >= <=
    console.log(5 > 3) //true
    console.log(5 < 3) //false
    console.log(5 >= 3) //true
    console.log(5 <= 3) //false

    // 2.等于符号 == 默认转换数据类型(内容相等即可) 会把字符串型的转换成数字型
    console.log(3 == '3') //true
    console.log('pink' == '刘德华') //false
    console.log(18 == 18) //true

    // 3.不等于号 ！= 内容相等即可
    console.log(18 != 18) //false
    console.log(3 != '3') //false
    console.log('pink' != '刘德华') //true

    // 4.全等于 === 不全等！== (内容和字符类型全等或者不全等)
    console.log(3 === '3') //false
    console.log(3 !== '3') //true
    console.log('3' === '3') //true
    console.log('3' !== '3') //false
</script>

<script>
    console.log(18 == '18');		//true
    console.log(18 === '18');		//false
</script>

<script>
    //逻辑运算符
    // 1. && (“逻辑与”，简称"与" and) 返回值true/false
    console.log(3 > 2 && 8 > 5) //true 全部为真才true
    console.log(3 > 5 && 5 < 8) //false 一个为假则false

    // 2. || (“逻辑或”，简称"或" or) 返回值true/false
    console.log(5 == '5' || 5 > 7) //true 一个为真则true
    console.log(5 === '5' || 3 < 1) //false 全部为假则false

    // 3. !(“逻辑非”，简称"非" not) 返回值 true/false
    console.log(!(3 > 5)) //true
    console.log(!(5 > 3)) //false
    console.log(!true) //false
    console.log(!false) //true
</script>

<script>
    // 短路运算的原理：当有多个表达式（值）时,左边的表达式值可以确定结果时,就不再继续运算右边的表达式的值
    // 1.逻辑与 表达式1 && 表达式2
    // 1.1如果第一个表达式的值为真，则返回表达式2(多个表达式都为真的时候，则返回最后一个)
    console.log(123 && 456) //456
    console.log(123 && 456 && 789) //456 先比较前两个，返回456，在比较456和789
    console.log(123 && 0 && 789) //0

    // 1.2如果第一个表达式的值为假，则返回表达式1 0、null、undefined、""、NaN为false，其余为 true
    console.log(0 && 456 && 789456) //0
    console.log(null && 456) //null
    console.log(undefined && 456 && 789) //undefined
    console.log('' && 456) //''
    console.log(NaN && 456) //NaN
</script>

<script>
    // 短路运算的原理：当有多个表达式（值）时,左边的表达式值可以确定结果时,就不再继续运算右边的表达式的值
    // 2.逻辑或
    // 2.1如果第一个表达式的值为真，则返回表达式1
    console.log(123 || 456 || 789) //123

    // 2.2如果第一个表达式的值为假，则返回表达式2
    console.log(0 || 456 || 789) //456

    // 2.3案例 逻辑或会影响程序的运行结果
    var num = 0;
    console.log(123 || num++);//表达式1为真，直接返回表达式1 123
    console.log(num); // 0
</script>

<script>
    // 1. + -
    var s = 2;
    s++ //相当于 s=s+1
    console.log(s) //3

    // 2. += -=
    var num = 10;
    num += 20 //相当于 num=num+20
    console.log(num) //30
    var p = 30;
    p -= 20 //相当于 p=p-20
    console.log(p) //10

    // 3.*= /= %=
    var age = 3;
    age *= 10 //相当于 age=age*10
    console.log(age) //30
</script>

<script>
    // 1.案例解释 注意权重
    console.log(4 >= 6 || '人' != '阿凡达' && !(12 * 2 == 144) && true) // true
        /* 执行步骤 1. !(12 * 2 == 144) => !false => true 2. '人' != '阿凡达' && true && true)=>true && true && true => true 3. 4 >= 6 || true =>false || true => true */
    var num = 10;
    console.log(5 == num / 2 && (2 + 2 * num).toString() === '22'); //true
    // true && true => true

    // 2.其他案例
    var a = 3 > 5 && 2 < 7 && 3 == 4;
    // false && true && false => false
    console.log(a) // false
    var b = 3 <= 4 || 3 > 1 || 3 != 2;
    // true || true || true => true
    console.log(b) // true
    var c = 2 === "2";
    console.log(c) //false
    var d = !c || b && a;
    // true || true && false =>true || false =>true
    console.log(d); // true
</script>

// 条件成立执行代码，否则什么也不做
if (条件表达式) {
 // 条件成立执行的代码语句
}

<script>
    // 满足判断的条件，则在执行，否则不执行
    // 案例 弹出一个输入框，要求用户输入年龄，如果年龄大于等于 18 岁，允许进网吧
    var age = prompt('请输入你的年龄');
    if (age >= 18) { 
   
        alert('你已经年满18岁了，可以进入')
    }
</script>

// 条件成立 执行 if 里面代码，否则执行else 里面的代码
if (条件表达式) {
 // [如果] 条件成立执行的代码
} else {
 // [否则] 执行的代码
}

<script>
    //if else 双分支语句 非循环语句
    //案例一：去网吧根据年龄判定是否能上网
    var age = prompt("请输入你的年龄");
    if (age >= 18) { 
   
        alert("欢迎光临！");
    } else { 
   
        console.log("未满18岁禁止上网！");
    }

    //案例二：判断平年和闰年
    var year = prompt("请输入年份");
    if (year % 4 == 0 && year % 100 == 0 || year % 400 == 0) { 
   
        alert("此年份是闰年" + year);
    } else { 
   
        alert("此年份是平年" + year);
    }

    //练习：输入姓名查看是否中奖
    var name = prompt("请输入你的名字");
    if (name == "刘德华") { 
   
        alert(name + "恭喜你中奖了");
    } else { 
   
        alert(name + "不好意思,您未中奖");
    }
</script>

// 适合于检查多重条件。
if (条件表达式1) {
 语句1；
} else if (条件表达式2) {
 语句2；
} else if (条件表达式3) {
 语句3；
 ....
} else {
 // 上述条件都不成立执行此处代码
}

<script>
    //案例 接收用户输入的分数，根据分数输出对应等级字母ABCDE
    var grade = prompt("请输入您的分数");
    if (grade >= 90) { 
   
        alert("A");
    } else if (grade >= 80) { 
   
        alert("B");
    } else if (grade >= 70) { 
   
        alert("c");
    } else if (grade >= 60) { 
   
        alert("D");
    } else { 
   
        alert("E");
    }
</script>

表达式1 ? 表达式2 : 表达式3;

<script>
    //方式1
    var num = 3;
    var result = num > 5 ? '是的' : '不是';
    console.log(result);//'不是'
    //方式2 直接输出（简写）
    console.log(6 > 5 ? 9 : 10);//9
    //方式3：转化成if else
    var n = prompt("请输入你的数字");
    if (n > 10) { 
   
        console.log("是的");
    } else { 
   
        console.log("不是");
    }
    //案例 数字补0：用户输入数字，如果数字小于10，则在前面补 0 ，比如01，09 ，如果数字大于10，则不需要补，比如 20。
    //方法1 if 条件语句
    var s = prompt("请输入你的数字0~59");
    if (s > 10) { 
   
        console.log(s);
    } else { 
   
        console.log("0" + s);
    }
    //方法2 三元表达式简写
    var s = prompt("请输入你的数字0~59");
    n = s > 10 ? console.log(s) : console.log("0" + s);
</script>

switch( 表达式 ){ 
 case value1:
 // 表达式 等于 value1 时要执行的代码
 break;
 case value2:
 // 表达式 等于 value2 时要执行的代码
 break;
 .......
 default:
 // 表达式 不等于任何一个 value 时要执行的代码
}

<script>
// 1.swich语句
    switch (8) { 
   
        case 1:
            console.log("这是" + 1);
            break;
        case 2:
            console.log("这是" + 2);
            break;
        case 3:
            console.log("这是" + 3);
            break;
        default:
            console.log("输入有误");
    }

    //案例：查询水果
    var friut = prompt("请输入你的水果");
    switch (friut) { 
   
        case "苹果":
            alert(friut + "价格为3.9");
            break;
        case "橘子":
            alert(friut + "价格为4.9");
            break;
        case "香蕉":
            alert(friut + "价格为5");
            break;
        default:
            alert("对不起，没有此类水果");
    }
</script>

<script>
    //在开发里面表达式通常使用变量
    //n和case里面的值相匹配的时候是全等的，必须是值和数据类型一致才可以：num===2
    //break如果当前的case里面没有break,则不会退出switch是继续执行下一个case(往后执行，不影响前面的)
    // 1.不存在break
    var num = prompt("请输入你的水果");
    switch (num) { 
   
        case "1":
            console.log("这是" + 1);
        case "2":
            console.log("这是" + 2);    
        case "3":
            console.log("这是" + 3);
        default:
            console.log("输入有误");
    } //输入1 打印 1 2 3 输入有误
    
    // 2.存在break
    var num2 = prompt("请输入你的水果");
    switch (num2) { 
   
        case "1":
            console.log("这是" + 1);
            break;
        case "2":
            console.log("这是" + 2);
            break;
        case "3":
            console.log("这是" + 3);
            break;
        default:
            console.log("输入有误");
    }//输入1 打印 1
</script>

for( 初始化变量; 条件表达式; 操作表达式 ){
 //循环体语句
}

<script>
    // 1.for循环执行的过程
    for (var i = 1; i < 10; i++) { 
   
        console.log(i); //123456789
    }
    //1.首先执行里面的计数器变量 var i=1,但是这句话在for里面只执行一次index
    //2.去i<10来判断是否满足条件，若果满足条件就去执行循环体，不满足条件就退出循环
    //3.最后执行i++，并且i++是单独写的代码，递增，第一轮结束
    //4.接着执行i<10判断是否满足条件，如果满足条件，就继续执行循环体
    //5.当i>=10的时候，退出循环体
</script>

<script>
    // 2.for循环可以执行相同的代码
    for (var i = 1; i < 10; i++) { 
   
        console.log('我爱你');//打印9次'我爱你'
    }
</script>

<script>
    // 3.for循环可以控制用户输入的次数
    var num = prompt("请你输入需要执行的次数");
    for (var i = 1; i <= num; i++) { 
   
        console.log("小君君我爱你");
    }
</script>

<script>
    // 4.for循环执行不相同的代码
  var name = prompt('请输入你喜欢的人名字');
    for (var i = 1; i <= 100; i++) { 
   
        console.log(name + '*' + i);
    }
</script>

<script>
    // 5.for if else 嵌套
  var n = prompt("请输入执行次数");
    for (i = 1; i <= n; i++) { 
   
        if (i == 1) { 
   
            console.log("这个小伙子出生啦");
        } else if (i == 60) { 
   
            console.log("这个人老了");
        } else { 
   
            console.log("这个人" + i + "岁啦");
        }
    }
</script>

<script>
  // 6.案例1 求1-100所有整数的和 重复执行某些操作
  var sum1 = 0
    for (var i = 1; i <= 100; i++) { 
   
        sum1 += i;
    }
    console.log(sum1); //5050
</script>

<script>
 // 7.案例2 求两个数之间的和
    var sum = 0
    var n = parseInt(prompt("请输入你的数字1")); //数据类型先转换
    var m = parseInt(prompt("请输入你的数字2")); //数据类型先转换
    if (m > n) { 
   
        for (var i = n; i <= m; i++) { 
   
            sum += i;
        }
        console.log(sum);
    } else { 
   
        for (var i = m; i <= n; i++) { 
   
            sum += i;
        }
        console.log(sum);
    }
</script>

<script>
// 8.案例3 要求用户输入班级人数，之后依次输入每个学生的成绩，最后打印出该班级总的成绩以及平均成绩
var n = prompt("请输入班级人数:");
    var sum = 0;
    var ave = 0;
    for (var i = 1; i <= n; i++) { 
   
        var grade = parseInt(prompt('请输入第' + i + '个学生的成绩'));
        sum += grade;
    }
    ave = sum / n;//循环结束之后在取平均值
    alert('该班级总成绩为:' + sum + "\n" + '该班级平均成绩为:' + ave);
</script>

<script>
    // 9.案例3 求两个数之间所有数和的平均值
    var sum = 0
    var n = parseInt(prompt("请输入你的数字1")); //数据类型先转换
    var m = parseInt(prompt("请输入你的数字2")); //数据类型先转换
    if (m > n) { 
   
        for (var i = n; i <= m; i++) { 
   
            sum += i;
            var ave = sum / (m - n + 1);
        }
        console.log(sum);
        console.log(ave);
    } else { 
   
        for (var i = m; i <= n; i++) { 
   
            sum += i;
            var ave = sum / (n - m + 1);
        }
        console.log(sum);
        console.log(ave);
    }
</script>

<script>
// 10.案例4 求1-100之间所有偶数和奇数的和
    //方法1
    var sum1 = 0;
    var sum2 = 0;
    for (var i = 1, j = 2; i < 100, j <= 100; i += 2, j += 2) { 
   
        sum1 += i; //奇数和
        sum2 += j; //偶数和
        var sum = sum1 + sum2; //总和
    }
    console.log(sum1); //2500
    console.log(sum2); //2550
    console.log(sum); //5050
    //方法2
    var sum1 = 0;
    var sum2 = 0;
    for (i = 1; i <= 100; i++) { 
   
        if (i % 2 == 0) { 
    //能被2整除的为偶数
            sum1 = sum1 + i; //偶数和 

        } else { 
   
            sum2 = sum2 + i; //奇数和
        }
    }
    console.log(sum1);//2550
    console.log(sum2);//2500
</script>

<script>
 // 11.案例5 1-100之间能被3整除的数字和
    var sum4 = 0;
    for (i = 0; i <= 100; i++) { 
   
        if (i % 3 == 0) { 
   
            sum4 += i;
        }
    }
    console.log(sum4); //1683
</script>

for (外层初始化变量; 外层条件表达式; 外层操作表达式) {
        for (里层初始化变量; 里层条件表达式; 里层操作表达式) {
            //执行语句；
        }
    }

<script>
    // 1.双重for循环 外层循环执行一次，内层循环要执行全部次数
    for (var i = 1; i <= 3; i++) { 
   
        console.log("这是外层循环的第" + i + "次");
        for (var j = 1; j <= 5; j++) { 
   
            console.log("这是里层循环的第" + j + "次");
        }
    }
</script>

<script>
 // 案例1 打印n行n列
    var str = "";
    var n = prompt('请输入你要打印的行：');
    var m = prompt('请输入你要打印的列：');
    for (var i = 1; i <= n; i++) { 
   
        for (var j = 1; j <= m; j++) { 
   
            str = str + "☆";
        }
        str = str + '\n'; //每一行打印完之后换行
    }
    console.log(str);
</script>

<script>
    // 案例2 打印倒三角形案例
    var str = "";
    for (var i = 5; i > 0; i--) { 
    //控制行
        for (var j = 1; j <= i; j++) { 
    //控制列v
            str = str + "☆";
        }
        str = str + '\n'; //每一行打印完之后换行
    }
    console.log(str);
</script>

<script>
    // 案例3 九九乘法表
    var str = " ";
    for (var i = 1; i <= 9; i++) { 
   
        for (var j = 1; j <= i; j++) { 
   
            //1x2=2
            str += '\t' + j + "x" + i + "=" + i * j; //注意字符串和number的转换 通过字符串拼接
        }
        str = str + '\n';
    }
    console.log(str);
</script>

while (条件表达式) {
 // 循环体代码
}
//退出

<script>
    //1.while循环语法结构 当....的时候
    //2.执行思路 当条件表达式为true则执行循环体，否则退出循环
    var num = 1;
    while (num <= 10) { 
   
        console.log("你好");
        num++;
    }
    //4.里面应该也有计数器，初始化变量
    //5.里面应该也有操作表达式完成计数器的更新，防止死循环
</script>

<script>
    // 案例1 打印人的一生，从1岁到100岁
    var i = 1;
    while (i <= 100) { 
   
        console.log("这个人今年" + i + "岁啦");
        i++; //一定要记得更新计数器，防止进入死循环
    }
</script>

<script>
    //案例2计算1-100整数和
    var i = 1;
    var sum = 0;
    while (i <= 100) { 
   
        sum += i;
        i++;
    }
    console.log(sum);//5050
</script>

<script>
    //案例4 弹出一个提示框，你爱我吗，如果输入我爱你，就提示结束，否则一直询问
    var i = prompt("你爱我吗？");
    while (i !== '我爱你') { 
   
        var i = prompt("你爱我吗？");
    }
    alert('我也爱你！');
</script>

do {
 // 循环体代码 - 条件表达式为 true 时重复执行循环体代码
} while(条件表达式);

<script>
   //案例1 打印人的一生
    var i = 1;
    do { 
   
        console.log("你今年" + i + "岁啦");
        i++;
    } while (i <= 100);
</script>

<script>
    //案例2 计算1-100整数和
    var sum = 0;
    var i = 1;
    do { 
   
        sum += i;
        i++;
    } while (i <= 100);
    console.log(sum);//5500
</script>

<script>
    //案例3 弹出一个提示框，你爱我吗，如果输入我爱你，就提示结束，否则一直询问
    do { 
   
        var i = prompt("你爱我吗？");
    } while (i !== "我爱你");
    alert("我也啊你！");
</script>

<script>
    //continue退出当前次的循环,直接执行下一次的循环
    for (var i = 1; i <= 5; i++) { 
   
        if (i == 3) { 
   
            continue; //只要遇见continue就退出本次循环，直接跳到i++
        }
        console.log('我正在吃第' + i + '个包子'); //1.2.4.5
    }

    //案例：求出1-100之间除了能被7整除之外的整数和
    var sum = 0;
    for (var i = 1; i <= 100; i++) { 
   
        if (i % 7 == 0) { 
   
            continue;//i是7的倍数的时候退出本次循环
        }
        sum += i;
    }
    console.log(sum); //4315
</script>

<script>
    //break 跳出整个循环
    for (var i = 1; i <= 5; i++) { 
   
        if (i == 3) { 
   
            break; //退出整个循环 在3以及后面的不再打印
        }
        console.log(i);//1 2
    }
</script>

<script>
    // 作业1 求100以内所有能被3和7整除的数的和
    var sum = 0;
    for (var i = 0; i <= 100; i++) { 
   
        if (i % 3 == 0 && i % 7 == 0) { 
   
            console.log(i) // 0 21 42 63 84 
            sum = sum + i
        }
    }
    console.log(sum) //210
</script>

<script>
    // 作业2 打印出正金字塔（1357）
    for (var i = 1; i <= 4; ++i) { 
   
        // 根据规律知道需要用for输出多余的空格，只需要左边的空格
        for (var k = 1; k <= 4 - i; ++k) { 
   
            document.write("&ensp; ");
        }
        // 结合2n-1的公式求出每一行的星星数
        for (var j = 1; j <= 2 * i - 1; ++j) { 
   
            document.write("☆");
        }
         // 每打完一行就执行换行
        document.write("<br />");
    }
</script>

<script>
    // 作业2 打印出倒金字塔（7351）
    for (var i = 1; i <= 4; i++) { 
   
        for (k = 0; k <= i - 1; k++) { 
   
            document.write(" &ensp;");
        }
        for (j = 1; j <= 9 - 2 * i; j++) { 
   
            document.write("☆");
        }
        document.write("<br />");
    }
</script>

    // 作业4 用户登录验证
    //方法一：while
    var msg = prompt('名字');
    var pwd = prompt('密码');
    while (msg != 'admin' || pwd != '123') { 
   
        alert('请你先登录');
        msg = prompt('名字');
        pwd = prompt('密码');
    }
    alert('登录成功');

    //方法二：do while
    do { 
   
        var msg2 = prompt('名字');
        var pwd2 = prompt('密码');
    } while (msg2 != 'admin' || pwd2 != '123');
    alert('登录成功');
</script>

<script>
    // 利用 new 关键字创建数组
    //创建了一个空数组
    var 数组名 = new Array();
    //创建了一个长度为2的空数组
    var arr = new Array(2);
    //创建了一个数组，并且添加了两个数组元素
    var arr = new Array(1, 2);
</script>

<script>
    //利用数组字面量创建数组
    // 1.利用数组字面量方式创建空的数组 
    var 数组名 = [];
    // 2.使用数组字面量方式创建带初始值的数组
    var 数组名 = ['小白', '小黑', '小黄', '瑞奇'];
    // 3.数组中可以存放任意类型的数据，例如字符串，数字，布尔值等
    var arr = ['小白', 12, true, 28.9];
</script>

<script>
    var arr = [5, true, "你好", 2];
     //访问数组索引号为0的元素
    console.log(arr[0]); //5
    //访问数组索引号为1的元素
    console.log(arr[1]); //true
    console.log(arr[4]); //undefined,因为没有这个数组元素
</script>

<script>
    //练习 定义一个数组，里面存放星期一、.....星期日
    var arr = [];
    for (i = 1; i <= 7; i++) { 
   
        arr[arr.length] = i;
    }
    console.log(arr); //(7) [1, 2, 3, 4, 5, 6, 7]
</script>

<script>
    //遍历数组方式一 for循环
    var arr = [1, 2, 3, 4]
    for (i = 0; i < arr.length; i++) { 
    //i要从0开始，因为索引号从零开始
        console.log(arr[i]); //1 2 3 4 逐个打印数组中的元素
    }
    console.log(arr.length); //4 获取数组长度：有几个数组元素，长度就是多少
</script>

<script>
    // 遍历数组方式二 forEach
    // 1.原函数遍历
    var arr2 = [1, 2, 3, 4]
    arr2.forEach(function(element) { 
   
        console.log(element) //1 2 3 4 逐个打印数组中的元素
    });
    
    // 2.箭头函数
    var arr3 = [5, true, "你好", 2];
    arr3.forEach(value => { 
   
        console.log(value) //5 true 你好 2
    })
</script>

<script>
    //1.arr.length动态监测数组元素的个数
    var arr = [1, 2, 3, 4, 5, 6];
    //i要从0开始，因为索引号从零开始
    for (i = 0; i < arr.length; i++) { 
    
        console.log(arr[i]);
    }
    //获取数组长度：有几个数组元素，长度就是多少
    console.log(arr.length); // 6
</script>

<script>
    //3.修改数组的长度
    //3.1查看数组长度
    var arr = [2, 3, 5, 6];
    console.log(arr.length); //4

    //3.2通过增加素组元素（数组索引号）来增加数组长度
    arr[4] = 7; //为数组索引号为4的下标增加一个数组元素
    console.log(arr.length); //5

    //3.3直接通过修改数组长度来增加数组长度
    arr.length = 6; //修改增加数组长度
    console.log(arr.length); //6
    console.log(arr); //[2, 3, 5, 6, 7, 空]
    console.log(arr[5]); //空undefined

    //3.4直接通过修改数组长度来减少数组长度
    arr.length = 1; //减少数组长度
    console.log(arr) //2 从后面开始删除数组元素
</script>

<script>
    //2.案例：求数组元素的和以及平均值
    var arr = [2, 6, 1, 7, 4];
    var sum = 0;
    for (i = 0; i < arr.length; i++) { 
   
        sum += arr[i]; //求和
    }
    var ave = sum / arr.length; //求平均值
    //总和
    console.log(sum);//20
    //平均值
    console.log(ave);//4
</script>

<script>
    // 案例1 请将 ['关羽', '张飞', '马超', '赵云', '黄忠', '刘备', '姜维'] 数组里的元素依次打印到控制台
    var arr = ['关羽', '张飞', '马超', '赵云', '黄忠', '刘备', '姜维'];
    // 方法1 for 循环遍历
    for (let i = 0; i < arr.length; i++) { 
   
        console.log(arr[i])
    }
    //方法2 forEach遍历 箭头函数
    arr.forEach(element => { 
   
        console.log(element)
    });
</script>

<script>
    //案例2 计算数组的和以及平均值
    var sum = 0;
    var arr2 = [50, 42, 58, 95, 32, 20];
    for (let i = 0; i < arr2.length; i++) { 
   
        sum += arr2[i] //求和
    }
    var ave = sum / arr2.length //求平均值
    console.log(sum, ave) // 297 49.5
</script>

<script>
    //案例3 求数组中的最大值
    var arr3 = [50, 42, 58, 95, 32, 20];
    var max = arr3[0]
    for (let i = 1; i < arr3.length; i++) { 
   
        if (arr3[i] > max) { 
   
            max = arr3[i];
        }
    }
    console.log(max) //95
</script>

<script>
    //案例4 将数组 ['red', 'green', 'blue', 'pink']里面的元素转换为字符串,并用"|"分隔
    var arr4 = ['red', 'green', 'blue', 'pink']
    var str = '';
    for (let i = 0; i < arr4.length; i++) { 
   
        str += arr4[i] + "|"
    }
    console.log(str) //red|green|blue|pink|
</script>

<script>
    // 修改数组长度（通过修改 length 长度新增数组元素）
    var arr = [1, 2, 3, 4];
    arr.length = 5;
    //增加了数组长度，其新增的索引号的元素用空值undefined 表示
    console.log(arr[5])//undefined 
    console.log(arr); //(5) [1, 2, 3, 4, 空白]
</script>

<script>
    //通过索引号增加数组元素
    var arr = [1, 2, 3, 4];
    //arr[]里面的内容代表数组的索引号位置，5代表相对索引号位置所代表的元素
    arr[4] = 5;
    console.log(arr);
</script>

<script>
    //通过循环往空数组里面插入数据
    var arr = [];
    for (var i = 0; i < 10; i++) { 
   
        arr[i] = i + 1;
    }
    console.log(arr);
</script>

<script>
    //1.删除重复的数组元素
    var arr4 = [0, 1, 0, 2, 0, 5, 0, 6, 0, 3, 0, 0, ];
    var arr5 = []; //定义一个空数组
    for (i = 0; i < arr4.length; i++) { 
   
        if (arr4[i] != 0) { 
   
            arr5[arr5.length] = arr4[i];
        }
    }
    console.log(arr5); //[1, 2, 5, 6, 3]
</script>

<script>
    var arr6 = ['张三', 'true', 98, 'andy', 666];
    var arr7 = []
    for (let i = 0; i < arr6.length; i++) { 
    // 循环
        //删除索引号为2和4的数组元素（判断）
        if (i != 2 && i != 4) { 
   
            arr7.push(arr6[i])
        }
    }
    console.log(arr7) //['张三', 'true', 'andy']
</script>

<script>
    //3.利用条件筛选数组从而删除元素
    // 选出大于10的数组元素并组成一个新数组
    var arr8 = [1, 5, 6, 8, 75, 24, 96, 02, 45]
    var arr9 = []
    for (let i = 0; i <= arr8.length; i++) { 
   
        if (arr8[i] > 10) { 
   
            arr9.push(arr8[i])
        }
    }
    console.log(arr9) //[75, 24, 96, 45] 
</script>

<script>
    //修改数组元素
    var arr10 = [1, 2, 3];
    arr10[1] = 4;
    console.log(arr10); //[1, 4, 3]
</script>

<script>
    //筛选数组元素：选择取出条件表达式限制的值
    //方法一
    var arr12 = [1, 2, 3, 10, 2, 50, 92, 75, 60];
    var newArr1 = [];
    var j = 0;
    for (var i = 0; i < arr12.length; i++) { 
   
        if (arr12[i] > 10) { 
   
            newArr1[j] = arr12[i];//符合条件的数组元素添加到新数组中
            j++;
        }
    }
    console.log(newArr1);//[50, 92, 75, 60]
    //方法二
    var arr13 = [1, 2, 3, 10, 2, 50, 92, 75, 60];
    var newArr2 = [];
    for (var i = 0; i < arr13.length; i++) { 
   
        if (arr13[i] > 10) { 
   
            newArr2[newArr2.length] = arr13[i];//符合条件的数组元素添加到新数组中
        }
    }
    console.log(newArr2);//[50, 92, 75, 60]
</script>

<script>
    //翻转数组
    //1.方法一
    var arr14 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    var arr15 = []
    for (var i = arr14.length - 1; i >= 0; i--) { 
   
        arr15[arr15.length] = arr14[i]
    }
    console.log(arr15) //[9, 8, 7, 6, 5, 4, 3, 2, 1]
</script>

<script>
    //2.方法二 数组方法 数组名.push() 后面会学
    var arr16 = ['账单', '李四', '王五', 555, true]
    var arr17 = new Array() //new一个空数组
    for (let i = arr16.length - 1; i >= 0; i--) { 
   
        arr17.push(arr16[i])
    }
    console.log(arr17) / [true, 555, '王五', '李四', '账单']
</script>

<script>
    //案例 数据从小到大排序
    var arr = [23, 14, 65, 10, 52, 18, 85, 63, 24, 59];
    for (i = 0; i < arr.length - 1; i++) { 
   
        for (var j = 0; j < arr.length - i - 1; j++) { 
   
            if (arr[j] > arr[j + 1]) { 
   
            //内部交换变量
                var arr1 = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = arr1;
            }
        }
    }
    console.log(arr);
</script>

<script>
    // 数组嵌套
    var arr = [2, 5, 6, 3],
        arr2 = [5, 9, 8, 5],
        obj = { 
   
            name: '张三',
            age: 20,
            sex: '男',
        }
    arr3 = [];
    arr3[0] = arr;
    arr3[1] = arr2;
    arr3[2] = obj
    arr3[3] = true
    console.log(arr3);
</script>

<script>
    //求两个数以及之间数字的累加和和平均值
    function fn(num1, num2) { 
    //声明函数
        var sum = 0;
        if (num1 > num2) { 
   
            for (let i = num2; i <= num1; i++) { 
   
                sum += i;
            }
            var ave = sum / (num1 - num2 + 1)
        } else { 
   
            for (let i = num1; i <= num2; i++) { 
   
                sum += i;
            }
            var ave = sum / (num2 - num1 + 1)
        }
        console.log(sum, ave)
    }
    //调用函数并传参
    fn(2, 10) //54 6
    fn(30, 1) //465 15.5
</script>

// 声明函数
function 函数名() {
 //函数体代码
}

// 调用函数
函数名(); // 通过调用函数名来执行函数体代码

<script>
    //求两个数以及之间数字的累加和和平均值
    function fn(num1, num2) { 
    //声明函数
        var sum = 0;
        if (num1 > num2) { 
   
            for (let i = num2; i <= num1; i++) { 
   
                sum += i;
            }
            var ave = sum / (num1 - num2 + 1)
        } else { 
   
            for (let i = num1; i <= num2; i++) { 
   
                sum += i;
            }
            var ave = sum / (num2 - num1 + 1)
        }
        console.log(sum, ave)
    }
    //调用函数并传参
    fn(2, 10) //54 6
    fn(30, 1) //465 15.5
</script>

// 带参数的函数声明
function 函数名(形参1, 形参2 , 形参3...) { // 可以定义任意多的参数，用逗号分隔
 // 函数体
}
// 带参数的函数调用
函数名(实参1, 实参2, 实参3...)；

<script>
    //案例 利用函数求任意两个数字的和
    //声明函数传形参
    function fn(num1, num2) { 
   
        var add = num1 + num2
        console.log(add) //50
    }
    //调用函数传实参
    fn(20, 30)
</script>

<script>
    //实参个数=形参个数 一一匹配 正常输出结果
    function fn1(name, age) { 
   
        console.log(name, age)
    }
    fn1('张三', 20) //张三 20
</script>

<script>
    //实参个数>形参个数 
    //形参从前往后依次取实参，直到形参取完，剩下的实参就不再取出
    function fn2(num1, num2) { 
   
        console.log(num1 + num2) //3
    }
    fn2(1, 2, 3) //3
</script>

<script>
    //实参个数<形参个数
    //从前往后一一对应，多出来的形参就相当于一个没有声明值的变量，所以是undefined
    function fn3(a, b, c, d) { 
   
        console.log(a) //1
        console.log(b) //2
        console.log(c) //3
        console.log(d) //undefined
    }
    fn3(1, 2, 3) //1 2 3 undefined
</script>

   //2.返回值的格式
    function 函数名() {
            return 需要的返回结果;
        }
        函数名(); //调用者

<script>
    //代码验证
    function getReturn() { 
   
        return 666;
    }
    getReturn(); //getReturn=666
    console.log(getReturn());
</script>

<script>
    //案例：求任意两个数的和
    function sum(num1, num2) { 
   
        return num1 + num2;
    }
    console.log(sum(1, 2));
</script>

<script>
    //案例：返回两个数的最大值
    //方法一 return
    function max1(num3, num4) { 
   
        if (num3 > num4) { 
   
            return num3;
        } else { 
   
            return num4
        }
    }
    console.log(max1(80, 330)); //330

    //方法二 三元运算符
    function max2(num5, num6) { 
   
        return (num5 > num6 ? num5 : num6)
    }
    console.log(max2(110, 120)); //120
</script>

<script>
    //返回组中的最大值
    function max3(arr) { 
   
        var max4 = arr[0];
        for (var i = 1; i < arr.length; i++) { 
   
            if (arr[i] > max4) { 
   
                max4 = arr[i];
            }
        }
        return max4;
    }
    //max([5, 8, 5, 62, 35, 69, 84]);//函数的调用者：实参是一个数组送过去
    //在实际开发中，我们经常用一个变量来接受函数返回的结果，使用更简单
    var re = max3([5, 8, 5, 62, 35, 69, 84]);
    console.log(re);
</script>

<script>
    //1.return 终止函数
    function getSum(num1, num2) { 
   
        return num1 + num2; //return后面的代码不会被执行
        console.log("你好"); //不会被执行
    }
    var s = getSum(1, 2);
    console.log(s); //3
</script>

<script>
    //2.return只能返回一个值 返回最后一个值
    function getSum2(num11, num21) { 
   
        return num11, num21;
    }
    var s2 = getSum2(1, 2);
    console.log(s2); // 2

    //若要数组返回多个值，那么可以用数组的形式返回
    function getSum(num12, num22) { 
   
        return [num12, num22, num12 + num22, num12 * num22, num12 - num22];
    }
    var s = getSum(1, 2);
    for (i = 0; i < s.length; i++) { 
   
        //利用数组的遍历打印出来每一个数组元素
        console.log(s[i]); 
    }
</script>

<script>
    //有return，则返回return后面的值
    function fun1() { 
   
        return 666; //return存在
    }
    var fun1 = fun1();
    console.log(fun1);//666

    //没有return时返回的值
    function fun2() { 
   

    }
    var fun2 = fun2();
    console.log(fun2); //undefined
</script>

<script>
    //方法1 if else条件判断
    function fn1(num1, num2) { 
   
        if (num1 > num2) { 
   
            return num1
        } else { 
   
            return num2
        }
    }
    console.log(fn1(10, 20)) //20

    //方法2 三元运算符
    function fn1(num3, num4) { 
   
        return num3 > num4 ? num3 : num4
    }
    console.log(fn1(10, 20)) //20
</script>

<script>
    // 求数组 [5,2,99,101,67,77] 中的最大数值
    function fn2(arr1) { 
   
        var max = arr1[0];
        for (let i = 1; i < arr1.length; i++) { 
   
            arr1[i] > max ? max = arr1[i] : max
        }
        return max; //注意，返回的时候值是给函数的调用者
    }
    //若要使用返回值，那么就需要定义一个变量来接收这个返回值
    var Max = fn2([5, 2, 99, 101, 67, 77])
    console.log('最大值为:' + Max) //最大值为:101
</script>

<script>
    function fn3(a, b) { 
   
        //返回对象
        return { 
   
            乘法运算结果: a * b,
            加法运算结果: a + b,
            减法运算结果: a - b,
            除法运算结果: a / b,
            取余运算结果: a % b
        }
    }
    var result = fn3(60, 12)
    console.log(result)
</script>

<script>
    function fn() { 
   
        console.log(arguments); //里面存储了所有传过来的实参
        console.log(arguments[2]); //索引号2下表的数组元素
        console.log(arguments.length); //长度
        //取出arguments下的数组元素
        for (var i = 0; i < arguments.length; i++) { 
   
            console.log(arguments[i])
        }
    }
    fn(1, 2, 3)
</script>

<script>
    //利用 arguments 函数求任意个数的最大值
    function fn2() { 
   
        var max = arguments[0];
        for (i = 1; i < arguments.length; i++) { 
   
            if (arguments[i] > max) { 
   
                max = arguments[i];
            }
        }
        return max; //记得return返回值给函数的调用者 
    }
    // 定义一个变量用来接收返回值
    var s = fn2(1, 2, 3, 5, 48, 5, 2, 522, 3);
    console.log(s); //522
</script>

<script>
    //方法1 不定义形参+arguments+for循环
    function fn() { 
   
        for (i = 0, j = arguments.length - 1; j > i; i++, j--) { 
   
            var temp = arguments[i];
            arguments[i] = arguments[j];
            arguments[j] = temp;
        }
        return arguments;
    }
    console.log(fn(5, 8, 9, 4, 2, 3, 5, 4, 2, 3));
    //方法2 定义形参+数组的方法push()
    function fn2(arr) { 
   
        var arr2 = []
        for (let i = arr.length - 1; i >= 0; i--) { 
   
            //利用数组方法
            arr2.push(arr[i])
        }
        return arr2;
    }
    var arr3 = fn2([5, 8, 9, 4, 2, 3, 5, 4, 2, 3])
    console.log(arr3);
    //方法3 数组的属性length+for循环
    function fn3(arr) { 
   
        var newArray = [];
        for (i = arr.length - 1; i >= 0; i--) { 
   
            // 利用数组长度
            newArray[newArray.length] = arr[i];
        }
        return newArray;
    }
    var arr4 = fn3([5, 8, 9, 4, 2, 3, 5, 4, 2, 3])
    console.log(arr4);
</script>

<script>
    function sort(arr) { 
   
        for (i = 0; i < arr.length - 1; i++) { 
   
            for (var j = 0; j < arr.length - i - 1; j++) { 
   
                if (arr[j] > arr[j + 1]) { 
   
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }
    var arr1 = sort([5, 2, 4, 8, 6, 3, 0, 59, 62, 25, 35]);
    console.log(arr1);
    var arr2 = sort([24, 52, 69, 53, 42, 51]);
    console.log(arr2);
</script>

<script>
    //方法一 
    function year(num) { 
   
        if (num % 4 == 0 || num % 100 == 0 || num % 400 == 0) { 
   
            return "该年份为闰年";
        }
        return "该年份为平年";

    }
    console.log(year(2021)); //该年份为平年
    console.log(year(2020)); //该年份为闰年
    //方法2 
    function isRunYear(num) { 
   
        var flag = false;
        if (num % 4 == 0 && num % 100 != 0 || num % 400 == 0) { 
   
            return !flag;
        }
        return flag;
    }
    console.log(isRunYear(2000)); //true
    console.log(isRunYear(2001)); //false
</script>

<script>
    function fn1() { 
   
        console.log(111)
        fn2();
    }

    function fn2() { 
   
        console.log(222);
    }
    fn1();
</script>

<script>
    fn1();

    function fn1() { 
   
        console.log(111);
        fn2(); //在fn1函数里面调用了fn2函数
        console.log(333);
    }

    function fn2() { 
   
        console.log(222);
        console.log(444)
    }
</script>

<script>
    //判断2月份天数
    function month(year) { 
   
        if (isRunYear(year)) { 
   
            console.log(year + "年是平年, 2月份有28天");

        } else { 
   
            console.log(year + "年是闰年, 2月份有29天");
        }
    }
    month(prompt("请输入你的年份"));
    //判断平年闰年
    function isRunYear(num) { 
   
        var flag = false;
        if (num % 4 == 0 && num % 100 != 0 || num % 400 == 0) { 
   
            return !flag;
        }
        return flag;
    }
</script>

<script>
    //声明函数方式
    function fn() { 
   
        console.log(111) //函数体
    }
    //调用函数 不限位置
    fn();
</script>

<script>
    //函数表达式
    var fun = function() { 
    //fun是变量
            console.log('我是函数表达式'); //函数体
        }
        //调用者，函数调用的代码必须写到函数体后面
    fun();
</script>

<script>
    //构造函数
    function Fun() { 
   
        console.log("我是构造函数");

    }
    var fun2 = new Fun();
</script>

<script>
<script>
    var star = { 
   
        //对象的属性
        name: 'pink',
        age: 18,
        sex: '男',
        //对象的方法
        sayHi: function() { 
   
            console.log('大家好啊~');
        }
    }
    console.log(star.name) //pink 调用对象的属性
    star.sayHi(); //调用对象的方法
</script>

<script>
    var obj = { 
   
        uname: '张三丰',
        age: 18,
        sex: '男',
        sayHi: function() { 
   
            console.log('hai~~');
        }
    }

    //调用属性方式一
    console.log(obj.uname); //张三丰
    //调用属性方式二
    console.log(obj['age']); //18
    //调用方法（函数的调用者）
    obj.sayHi(); //hai~~
</script>

<script>
    //变量
    var num = 20;
    var obj2 = { 
   
            //属性
            age: 18,
            name: '滕杰'
        }
        //变量的使用
    console.log(num)
        //属性的使用
    console.log(obj2.name)

    //函数（匿名函数）
    fn1 = function() { 
   
        console.log('我是匿名函数')
    }
    fn1(); //我是匿名函数
    //方法
    var obj2 = { 
   
        fn2: function() { 
   
            console.log('我是方法，也是匿名函数')
        },
        fn3() { 
   
            console.log('我是方法，这是我的简写形式')
        }
    }
    obj2.fn2(); //我是方法，也是匿名函数
    obj2.fn3(); //我是方法，这是我的简写形式
</script>

<script>
    var obj = new Object(); //创建了一个空对象
    obj.uname = '张三丰';
    obj.age = 18;
    obj.sayHi = function() { 
   
        console.log('hi~');
    }

    //调用属性
    console.log(obj.uname)
    console.log(obj['age']);
    //调用方法
    obj.sayHi();
</script>

  function 构造函数名() {
        this.属性 = 值;
        this.方法 = function() {}
    }
    new 构造函数名(); //创建实例对象

<script>
    function Star(uname, age, sex) { 
   
        this.姓名 = uname;
        this.age = age;
        this.sex = sex;
        this.sing = function(sang) { 
   
            console.log(sang);
        }
    }
    var s = new Star('刘德华', 18, '男'); //new实例对象
    //调用属性
    console.log(s.姓名);
    console.log(s['age']);
    //调用方法 传参
    s.sing('冰雨');
</script>

<script>
    function Star(uname, age, sex) { 
   
        this.姓名 = uname;
        this.age = age;
        this.sex = sex;
        this.sing = function(sang) { 
    //函数的方法（匿名函数）
            console.log(sang);
        }
    }
    var s = new Star('刘德华', 18, '男'); //new 对象的实例化
    console.log(typeof s); //object对象
    console.log(s);
</script>

for(变量 in 对象名字){
    // 在此执行代码
}

for(var k in obj) {
    console.log(k);		//这里的 k 是属性名
    console.log(obj[k]);//这里的 obj[k] 是属性值
}

<script>
    //遍历对象 for(变量)in(对象名)
    var obj = { 
   
            name: '滕杰',
            age: 18,
            sex: '男',
            fn: function() { 
    //匿名函数，因为对象里面是key:value 所以=号转换了
                console.log('你好')
            }
        }
        //遍历
    for (const i in obj) { 
   
        console.log(i) //属性名
        console.log(obj[i]) //属性值
    }
</script>