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

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

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

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

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

<script>
    // 这是一个输入框
    prompt('请输入您的年龄');
    // alert 弹出警示框 输出的 展示给用户的
    alert('计算的结果是');
    // console 控制台输出 给程序员测试用的  
    console.log('我是程序员能看到的');
</script>

<script>
    // 1. 声明了一个age 的变量 
    var age;
    // 2. 赋值  把值存入这个变量中
    age = 18;
    // 3. 输出结果 
    console.log(age);
    // 4. 变量的初始化 
    var myname = 'Cyan';
    console.log(myname);
</script>

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

age = 18;   // 给 age 这个变量赋值为 18

var age = 18;      // 声明变量同时赋值为 18
// 例如：
var myname = 'Cyan';
console.log(myname);

<script>
    // 1. 用户输入姓名  存储到一个 myname的变量里面
    var myname = prompt('请输入您的名字');
    // 2. 输出这个用户名
    alert(myname);
</script>

var age = 18;
age = 81;     // 最后的结果就是81，把18覆盖掉 

var age = 10, name = 'zs', sex = 2; 

<script>
    // js 是编程语言有很强的逻辑性在里面： 实现这个要求的思路 先怎么做后怎么做 
    // 1. 我们需要一个临时变量帮我们
    // 2. 把apple1 给我们的临时变量 temp 
    // 3. 把apple2 里面的苹果给 apple1 
    // 4. 把临时变量里面的值 给 apple2 
    var temp; // 声明了一个临时变量为空
    var apple1 = '青苹果';
    var apple2 = '红苹果';
    temp = apple1;     // 把右边给左边
    apple1 = apple2;
    apple2 = temp;
    console.log(apple1);
    console.log(apple2);
</script>

var age = 10;     // 这是一个数字型
var areYouOk = '是的';      // 这是一个字符串

var x = 6;     // x 为数字
var x = "Bill";    // x 为字符串 

var age = 21;    // 整数
var Age = 21.3747;    // 小数 

// 1. 八进制 0 ~ 7 我们程序里面数字前面加0 表示八进制
var num1 = 010;
console.log(num1); // 010 是八进制 转换为 10进制 就是 8
var num2 = 012;
console.log(num2);   //10

// 2. 十六进制 0 ~ 9 a ~ f 数字的前面加 0x 表示十六进制
var num3 = 0x9;
console.log(num3);   //9
var num4 = 0xa;
console.log(num4);   //10

// 3. 数字型的最大值
console.log(Number.MAX_VALUE);   // 1.7976931348623157e+308

// 4. 数字型的最小值
console.log(Number.MIN_VALUE);     // 5e-324

// 5. 无穷大
console.log(Number.MAX_VALUE * 2); // Infinity 无穷大

// 6. 无穷小
console.log(-Number.MAX_VALUE * 2); // -Infinity 无穷大

// 7. 非数字
console.log('pink老师' - 100); // NaN

// isNaN() 这个方法用来判断非数字 并且返回一个值 如果是数字返回的是 false 如果不是数字返回的是true
console.log(isNaN(12));   // false
console.log(isNaN('pink老师'));   // true

var str = '今天"也"在学习';
console.log(str);   //今天"也"在学习

// 字符串转义字符 都是用 \ 开头 但是这些转义字符写道引号里面
var str1 = '今天"也"在\n学习';
console.log(str1);

var strMsg = '今天也在学习';
alert(strMsg.length); // 显示 6

// 2. 字符串的拼接 + 只要有字符串和其他类型相拼接 最终的结果是字符串类型
console.log('沙漠' + '骆驼'); // 字符串的 沙漠骆驼
console.log('今天' + 18); // '今天18'  字符串 + 数值
console.log('pink' + true); // pinktrue
console.log(12 + 12); // 24  数值相加
console.log('12' + 12); // '1212'  数值字符串 + 数值

console.log('pink老师' + 18 + '岁');  //pink老师18岁

// 我们变量不要写到字符串里面，是通过和 字符串相连的方式实现的
var age = 19;
console.log('pink老师' + age + '岁');

// 弹出一个输入框（prompt)，让用户输入年龄（用户输入）:prompt('请输入您的年龄')
// 把用户输入的值用变量保存起来:var age = prompt('请输入您的年龄'),把刚才输入的年龄与所要输出的字符串拼接 （程序内部处理）:var str = '您今年已经' + age + '岁了'
// 使用alert语句弹出警示框（输出结果）:alert(str)

var age = prompt('请输入您的年龄');
var str = '您今年已经' + age + '岁了';
alert(str);

var flag = true; // flag 布尔型
var flag1 = false; // flag1 布尔型
console.log(flag + 1); // true 参与加法运算当1来看
console.log(flag1 + 1); // false 参与加法运算当 0来看

var str;
console.log(str); // undefined
var variable = undefined;
console.log(variable + 'pink'); // undefinedpink
console.log(variable + 1); // NaN       undefined和数字相加最后的结果是 NaN

// null 空值
var space = null;
console.log(space + 'pink'); // nullpink
console.log(space + 1); // 1

var num = 10;
console.log(typeof num); // number
var str = 'pink';
console.log(typeof str); // string
var flag = true;
console.log(typeof flag); // boolean
var vari = undefined;
console.log(typeof vari); // undefined
var timer = null;
console.log(typeof timer); // object(对象)

// prompt 取过来的值是 字符型的
var age = prompt('请输入您的年龄');
console.log(age);
console.log(typeof age);  // string

console.log(18);  //number
console.log('18');  //string
console.log(true);  //boolean
console.log(undefined);  //undefined
console.log(null);  //null

// 1. 把数字型转换为字符串型 变量.toString()
var num = 10;
var str = num.toString();
console.log(str);  // 10
console.log(typeof str);  // string
// 2. 我们利用 String(变量)
console.log(String(num));   // 10
// 3. 利用 + 拼接字符串的方法实现转换效果 隐式转换
console.log(num + '');  // 10

var age = prompt('请输入您的年龄');
// 1. parseInt(变量) 可以把 字符型的转换为数字型 得到是整数
console.log(parseInt(age)); 
console.log(parseInt('3.14')); // 3 取整
console.log(parseInt('3.94')); // 3 取整
console.log(parseInt('120px')); // 120 会去掉这个px单位
console.log(parseInt('rem120px')); // NaN

// 2. parseFloat(变量) 可以把 字符型的转换为数字型 得到是小数 浮点数
console.log(parseFloat('3.14')); // 3.14
console.log(parseFloat('120px')); // 120 会去掉这个px单位
console.log(parseFloat('rem120px')); // NaN

// 3. 利用 Number(变量)
var str = '123';
console.log(Number(str)); // 123
console.log(Number('12'));  // 12

// 4. 利用了算数运算 - * / 隐式转换
console.log('12' - 0);   // 12
console.log('123' - '120');  // 3
console.log('123' * 1);  // 123

var year = prompt('请输入你的出生年份');
var age = '2023' - year;
alert('你的年龄是：' + age + '岁');

var dyz = prompt('请输入第一个值：');
var dez = prompt('请输入第二个值：');
var jsz = parseFloat(dyz) + parseFloat(dez);  // 转换为数字型再相加
alert('结果是：' + jsz);

console.log(Boolean('')); // false
console.log(Boolean(0)); // false
console.log(Boolean(NaN)); // false
console.log(Boolean(null)); // false
console.log(Boolean(undefined)); // false
console.log(Boolean('小白')); // true
console.log(Boolean(12)); // true

var dys = prompt('请输入您的姓名：');
var dyz = prompt('请输入您的年龄：');
var dez = prompt('请输入您的性别：');
alert('您的姓名是：' + dys + '\n' + '您的年龄是：' + dyz + '\n' + '您的性别是：' + dez);

console.log(1 + 1); // 2
console.log(1 - 1); // 0
console.log(1 * 1); // 1
console.log(1 / 1); // 1
// 1. % 取余 （取模）
console.log(4 % 2); // 0
console.log(5 % 3); // 2
console.log(3 % 5); // 3

// 2. 浮点数 算数运算里面会有问题（转换成二进制计算后会有误差）
console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.07 * 100); // 7.000000000000001

// 3. 我们不能直接拿着浮点数来进行相比较 是否相等
var num = 0.1 + 0.2;
console.log(num == 0.3); // false

// 想要一个变量自己加1 num = num + 1 比较麻烦
var num = 1;
num = num + 1; // ++num
num = num + 1;
console.log(num); // 3

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

// 先加1 后返回值
var p = 10;
console.log(++p + 10); // 21    11 + 10 = 21

var num = 10;
num++; // num = num + 1 ;
console.log(num);
// 1. 前置自增和后置自增如果单独使用 效果是一样的
// 2. 后置自增 口诀：先返回原值 后自加1
var age = 10;
console.log(age++ + 10);  //20  先返回原值10 然后再+10（参与运算） 所以等于20
console.log(age);  //  11  后自加1

var a = 10;
++a;  // 11
var b = ++a + 2; // 12 + 2 = 14
console.log(b); // 14

var c = 10;
c++;  // 11
var d = c++ + 2; // 10 + 2 = 12
console.log(d); // 12 +1 = 13（运算后再加1）

var e = 10;
var f = e++ + ++e; // e++ = 10   代码从左往右算，e++已经返回原值，再+1，所以现在e=11，所以 ++e = 12
console.log(f); // 22
// 后置自增 先表达式返回原值 后面变量再自加1

console.log(3 >= 5); // false
console.log(2 <= 4); // true 

// 1. 我们程序里面的等于符号 是 == 
console.log(3 == 5); // false
console.log('pink老师' == '刘德华' ); // flase
// 默认转换数据类型 会把字符串型的数据转换为数字型 只要求值相等就可以 
console.log(18 == 18); // true
console.log(18 == '18' ); // true    '18'是字符串，会自动转换为数字型
console.log(18 != 18); // false

// 2. 我们程序里面有全等 一模一样 要求 两侧的值 还有 数据类型完全一致才可以 true 
console.log(18 === 18); 
console.log(18 === '18' ); // false

// 1. 逻辑与 && and 两侧都为true 结果才是 true 只要有一侧为false 结果就为false
console.log(3 > 5 && 3 > 2); // false 一真一假
console.log(3 < 5 && 3> 2); // true 都为真
// 2. 逻辑或 || or 两侧都为false 结果才是假 false 只要有一侧为true 结果就是true
console.log(3 > 5 || 3 > 2); // true
console.log(3 > 5 || 3 < 2); // false 
// 3. 逻辑非 not ！ 
console.log(!true); // false
console.log(!false); // true

// 1. 用我们的布尔值参与的逻辑运算 true && false == false
// 2. 123 && 456 是值 或者是 表达式 参与逻辑运算？
// 3. 逻辑与短路运算 如果表达式1 结果为真 则返回表达式2 如果表达式1为假 那么返回表达式1
console.log(123 && 456); // 456  123是数字，所以为真，返回表达式2，除了0之外所有数字都是真的
console.log(0 && 456); // 0 0是假的，所以返回表达式1
console.log(0 && 1 + 2 && 456 * 56789); // 0
console.log('' && 1 + 2 && 456 * 56789); // ''
// 如果有空的或者否定的为假 其余是真的    0   ''  null  undefined  NaN

// 4. 逻辑或短路运算 如果表达式1 结果为真 则返回的是表达式1 如果表达式1 结果为假 则返回表达式2
console.log(123 || 456); // 123
console.log(123 || 456 || 456 + 123); // 123
console.log(0 || 456 || 456 + 123); // 456
// 逻辑中断很重要 它会影响我们程序运行结果
var num = 0;
console.log(123 || num++); // 123
console.log(num); // 0

var age = 10;
age += 5; // 相当于 age = age + 5;
age -= 5; // 相当于 age = age - 5;
age *= 10; // 相当于 age = age * 10;

console.log(4 >= 6 || '人' != '阿凡达' && !(12 * 2 == 144) && true)
// 4>=6 false , '人' != '阿凡达' true , !(12 * 2 == 144) true , true true
//先&&后||，后面三个都为true，所以true，false||true，（||有一个为true结果就为true），最终结果为true

// 1. if 的语法结构 如果if
if (条件表达式) {
    // 执行语句
}

// 例如1：
if (3 < 5) { 
    alert('沙漠骆驼');  
} // 弹出“沙漠骆驼”警示框

// 例如2：
if (3 > 5) { 
    alert('沙漠骆驼');  
} // 什么都没有

// 弹出 prompt 输入框，用户输入年龄， 程序把这个值取过来保存到变量中
// 使用 if 语句来判断年龄，如果年龄大于18，就执行 if 大括号里面的输出语句

var age = prompt("请输入您的年龄");
if (age >= 18) {
    alert("允许")
}

// 1. 语法结构 if 如果 else 否则
if (条件表达式) {
    // 执行语句1
} else {
    // 执行语句2
}

// 例如：
var age = prompt("请输入您的年龄");
if (age >= 18) {
    alert("允许")
} else{
    alert("拒绝")
}

// 弹出prompt 输入框，让用户输入年份，把这个值取过来保存到变量中
// 使用 if 语句来判断是否是闰年，如果是闰年，就执行 if 大括号里面的输出语句，否则就执行 else里面的输出语句
// 一定要注意里面的且 &&  还有或者 || 的写法，同时注意判断整除的方法是取余为 0

var year = prompt("请您输入要检测的年份：");
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
    alert("您输入的年份是闰年")
} else{
    alert("您输入的年份是平年")
}

var name = prompt("请输入您的姓名：");
if (name == '刘德华') {
    alert("恭喜您中了5块钱")
} else{
    alert("谢谢参与")
}

// 1. 多分支语句   就是利用多个条件来选择不同的语句执行 得到不同的结果  多选1 的过程
// 2. if else if语句是多分支语句
if (条件表达式1) {
    // 语句1;
} else if (条件表达式2) {
    // 语句2;
} else if (条件表达式3) {
    // 语句3;
} else {
    // 最后的语句;
}

var fs = prompt("请输入您的分数：");
if (fs >= 90) {
    alert("A")
} else if (fs >= 80 && fs < 90) {
    alert("B") 
} else if (fs >= 70 && fs < 80) { 
    alert("C") 
} else if (fs >= 60 && fs < 70) { 
    alert("D") 
} else { 
    alert("E") 
}

条件表达式 ？ 表达式1 ： 表达式2

var num = 10;
var result = num > 5 ? '是的' : '不是的'  // 我们知道表达式是有返回值的
console.log(result);  // 是的

// 用户输入0~59之间的一个数字
// 如果数字小于10，则在这个数字前面补0,（加0 拼接） 否则  不做操作
// 用一个变量接受这个返回值，输出

var num = prompt("请您输入0~59之间的一个数字");
var result = num < 10 ? '0' + num : num;
alert(result);

// 1. switch 语句也是多分支语句 也可以实现多选1
// 2. 语法结构 switch 转换、开关
switch(表达式) {
    case value1:
        执行语句1;
        break;
    case value2:
        执行语句2;
        break;
    ...
    default:
        执行最后的语句;
}

// 例如：
switch (2) {
    case 1:
        console.log('这是1');
        break;
    case 2:
        console.log('这是2');
        break;
    case 3:
        console.log('这是3');
        break;
    default:
        console.log('没有匹配结果');
} // 这是2

// 弹出 prompt 输入框，让用户输入水果名称，把这个值取过来保存到变量中。
// 将这个变量作为 switch 括号里面的表达式。
// case 后面的值写几个不同的水果名称，注意一定要加引号 ，因为必须是全等匹配。
// 弹出不同价格即可。同样注意每个 case 之后加上 break ，以便退出 switch 语句。
// 将 default 设置为没有此水果。

var fruit = prompt('请您输入查询的水果:');
switch (fruit) {
    case '苹果':
        alert('苹果的价格是 3.5/斤');
        break;
    case '榴莲':
        alert('榴莲的价格是 35/斤');
        break;
    default:
        alert('没有此水果');
}

var time = prompt('请输入时间点：');
if (time >= 6 && time <= 12) {
    alert("上午好");
} else if (time >= 13 && time <= 18) {
    alert("下午好");
} else if (time >= 19 && time <= 23) {
    alert("晚上好");
} else if (time >= 0 && time <= 5) {
    alert("这是休息时间，不要说话！");
} else{
    alert("请输入0-24之间的数字表示时间点")
}

//  var num=Number(prompt('请输入一个数')):使用Number()转换数据类型。因为prompt输入的数据默认是字符串类型，要变成数字类型，就要转换数据类型；而不知道是转换成什么数据类型，就用Number().
var num1 = Number(prompt('请输入第一个数'));
var num2 = Number(prompt('请输入第二个数'));
if (num1 > num2) {
    alert("最大值：" + num1);
} else {
    alert("最大值：" + num2);
}

// parseInt()是转换成整数型
// parseFloat()是转换成浮点数
// Number()是转换成数字型。

var num = Number(prompt('请输入一个数'));
if (num % 2 == 0) {
    alert(num + '为偶数!');
} else {
    alert(num + '为奇数。');
}

var date = prompt('请输入日期数');
if (date == 1 || date % 7 == 1) {
    alert("今天是星期一");
} else if (date == 2 || date % 7 == 2) {
    alert("今天是星期二");
} else if (date == 3 || date % 7 == 3) {
    alert("今天是星期三");
} else if (date == 4 || date % 7 == 4) {
    alert("今天是星期四");
} else if (date == 5 || date % 7 == 5) {
    alert("今天是星期五");
} else if (date == 6 || date % 7 == 6) {
    alert("今天是星期六");
} else if (date == 7 || date % 7 == 0) {
    alert("今天是星期天");
}

var money = Number(prompt('请输入一个数'));        
if (money >= 2000) {        
    alert("请大家吃西餐");     
} else if (money >= 1500 && money < 2000) {      
    alert("请大家吃快餐");      
} else if (money >= 1000 && money < 1500) {
    alert("请大家喝饮料");
} else if (money >= 500 && money < 1000) {
    alert("请大家吃棒棒糖");
} else {
    alert("班长下次把钱带够");
} 

var fs = prompt("请输入您的分数：");
if (fs >= 90) {
    alert("A")
} else if (fs >= 80 && fs < 90) {
    alert("B") 
} else if (fs >= 70 && fs < 80) { 
    alert("C") 
} else if (fs >= 60 && fs < 70) { 
    alert("D") 
} else { 
    alert("E") 
}

for (初始化变量; 条件表达式; 操作表达式) {
    //循环体
}
// 初始化变量 就是用var 声明的一个普通变量， 通常用于作为计数器使用
// 条件表达式 就是用来决定每一次循环是否继续执行 就是终止的条件
// 操作表达式 是每次循环最后执行的代码 经常用于我们计数器变量进行更新（递增或者递减）

// 代码体验 我们重复打印100局 你好
for (var i = 1; i <= 100; i++) {
    console.log('你好吗');
}
// 1. 首先执行里面的计数器变量  var i = 1 .但是这句话在for 里面只执行一次
// 2. 去 i <= 100 来判断是否满足条件， 如果满足条件  就去执行 循环体（console.log('你好吗');）  不满足条件退出循环 
// 3. 最后去执行 i++   i++是单独写的代码 递增  第一轮结束 
// 4. 接着去执行 i <= 100 如果满足条件  就去执行 循环体  不满足条件退出循环   第二轮

//  基本写法
for(var i = 1; i <= 10; i++){
    console.log('学习！');
}

// 用户输入次数
var num = prompt('请输入次数:')；
for ( var i = 1 ; i <= num; i++) {
    console.log('学习！');
} 

for (var i = 1; i <= 100; i++) {
      console.log('这个人今年' + i + '岁了');
}

// 多分支
for (var i = 1; i <= 100; i++) {
    if (i == 1) {
        console.log('这个人今年1岁了，他出生了');
    } else if (i == 100) {
        console.log('这个人今年100岁了，他');
    } else {
        console.log('这个人今年' + i + '岁了');            
    }
}

var sum = 0; // 求和 的变量
for (var i = 1; i <= 100; i++) {
    // sum = sum + i;
    sum += i;
}
console.log(sum); // 5050

var sum = 0; // 求和 的变量
var average = 0;
for (var i = 1; i <= 100; i++) {
    // sum = sum + i;
    sum += i;
}
average = sum / 100;
console.log(average);

// 我们需要一个偶数的和变量 even  还需要一个奇数 odd
var even = 0;
var odd = 0;
for (var i = 1; i <= 100; i++) {
    if (i % 2 == 0) {
        even = even + i;
    } else {
        odd = odd + i;
    }
}
console.log('1~100 之间所有的偶数和是' + even);
console.log('1~100 之间所有的奇数和是' + odd);

var result = 0;
for (var i = 1; i <= 100; i++) {
    if (i % 3 == 0) {
        // result = result + i;
        result += i;
    }
}
console.log('1~100之间能够被3整数的数字的和是：' + result);

var num = prompt('请输入班级的总人数:'); // num 总的班级人数
var sum = 0; // 求和的变量
var average = 0; // 求平均值的变量
for (var i = 1; i <= num; i++) { 
    var score=prompt('请您输入第' + i + '个学生成绩' ); 
    // 因为从prompt取过来的数据是 字符串型的需要转换为数字型 sum=sum +
    parseFloat(score); 
} 
average=sum / num; 
alert('班级总的成绩是' + sum); 
alert('班级平均分是：' + average);

// 一行5个星星
var str = '';
for (var i = 1; i <= 5; i++) {
    str = str + '★'
}
console.log(str);


// 自己设定多少个星星
var num = prompt('请输入星星的个数');
var str = '';
for (var i = 1; i <= num; i++) {
    str = str + '★'
}
console.log(str);

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

// 我们可以把里面的循环看做是外层循环的语句
// 外层循环循环一次， 里面的循环执行全部

// 代码验证
for (var i = 1; i <= 3; i++) {
    console.log('这是外层循环第' + i + '次');
    for (var j = 1; j <= 3; j++) {
        console.log('这是里层的循环第' + j + '次');

    }
}

// 打印五行五列星星
var str = '';
for (var i = 1; i <= 5; i++) { // 外层循环负责打印五行
    for (var j = 1; j <= 5; j++) { // 里层循环负责一行打印五个星星
        str = str + '★';
    }
    // 如果一行打印完毕5个星星就要另起一行 加 \n
    str = str + '\n';
}
console.log(str);

var hang = prompt('请输入您打印几行星星：');
var lie = prompt('请输入您打印几列星星：');
var str = '';
for (var i = 1; i <= hang; i++) {
    for (var j = 1; j <= lie; j++) {
        str = str + '⭐';
    }
    str = str + '\n';
}
console.log(str);

var str = '';
for (var i = 1; i <= 10; i++) { // 外层循环控制行数
    for (var j = i; j <= 10; j++) { // 里层循环打印的个数不一样  j = i
        str = str + '⭐';
    }
    str = str + '\n';
}
console.log(str);

// i=1表示第一行，外循环，然后j=i即j=1，但后面有j小于等于10，因为有外层循环循环一次， 里面的循环执行全部，所以内循环要全部执行，然后j是从1开始的，即执行10次，所以有10颗星星。
// 

var str = '';
for (var i = 1; i <= 10; i++) { // 外层循环控制行数
    for (var j = 1; j <= i; j++) {
        str = str + '⭐';
    }
    str = str + '\n';
}
console.log(str);

var str = '';
for (var i = 1; i <= 9; i++) { // 外层循环控制行数
    for (var j = 1; j <= i; j++) {
        str += j + '×' + i + '=' + i * j + '\t';
    }
    str = str + '\n';
}
console.log(str);

// while 当... 的时候
while (条件表达式) {
    // 循环体代码
}

// 执行思路：当条件表达式结果为true 则执行循环体 否则 退出循环

// 代码验证
var num = 1;
while (num <= 100) {
    console.log('学习');
    num++;
}

// 里面应该也有计数器 初始化变量
// 里面应该也有操作表达式  完成计数器的更新 防止死循环

var i = 1;
while (i <= 100) {
    console.log('这个人今年' + i + '岁了');
    i++;
}

var sum = 0;
var j = 1;
while (j <= 100) {
    sum += j;
    j++
}
console.log(sum);

var message = prompt('你爱我吗?');
while (message !== '我爱你') {
    message = prompt('你爱我吗?');
}
alert('我也爱你啊！');

do {
    // 循环体
} while (条件表达式)
    
// 执行思路 跟while不同的地方在于 do while 先执行一次循环体 在判断条件 如果条件表达式结果为真，则继续执行循环体，否则退出循环

// 代码验证
var i = 1;
do {
    console.log('how are you?');
    i++;
} while (i <= 100)
// 我们的do while 循环体至少执行一次

var i = 1;
do {
    console.log('这个人今年' + i + '岁了');
    i++;
} while (i <= 100)

var sum = 0;
var j = 1;
do {
    sum += j;
    j++;
} while (j <= 100)
console.log(sum);

do {
    message = prompt('你爱我吗?');
} while (message !== '我爱你')
alert('我也爱你啊！');

// continue 关键字   退出本次（当前次的循环）  继续执行剩余次数循环

for (var i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;  // 当i=3时，退出本次循环，不跳到下面的代码，回到i++上，然后进行其他的循环。
    }
    console.log('我正在吃第' + i + '个包子');
}

// 求1~100 之间， 除了能被7整除之外的整数和 
var sum = 0;
for (var i = 1; i <= 100; i++) {
    if (i % 7 == 0) {
        continue; 
    }
    sum += i;
}
console.log(sum);

// break 退出整个循环

for (var i = 1; i <= 5; i++) {
    if (i == 3) {
        break;
    }
    console.log('我正在吃第' + i + '个包子');
}

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

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

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

var str = '';
for (var i = 1; i <= 5; i++) {
    for (var j = 1; j <= 5; j++) {
        str = str + '★'
    }
    str = str + '\n'
}
console.log(str);

var str = '';
for (var i = 1; i <= 5; i++) {
    for (var j = 1; j <= i; j++) {
        str = str + '★'
    }
    str = str + '\n'
}
console.log(str);

var sum = '';
for (var i = 1; i <= 9; i++) {
    for (var j = 1; j <= i; j++) {
        sum = sum + j + 'x' + i + '=' + j * i + '\t';
    }
    sum = sum + '\n'
}
console.log(sum);

var message1 = prompt('请输入用户名');
var message2 = prompt('请输入密码');
while (message1 !== 'admin' && message2 !== '123456') {
    var message1 = prompt('请输入用户名');
    var message2 = prompt('请输入密码');
}
alert('登录成功！');

var sum = 0;
for (var i = 1; i <= 100; i++) {
    if (i % 10 == 3) { // 除以10的余数为3，即个位数为3
        continue;
    }
    sum += i;
}
console.log(sum);

// while(true)就是无限循环语句。因为括号中的条件为true，所以永远不会跳出循环，除非语句块中有break语句才都能跳出循环。
var yue = 100;
while (true) {  
    var message = prompt('请输入您要的操作：\n 1.存钱 \n 2.取钱 \n 3.显示余额 \n 4.退出');
    if (message == '1') {
        var cunqian = parseFloat(prompt('请您输入存的钱数：'));
        yue += cunqian;
        alert('您现在的钱数是：' + yue);
    } else if (message == '2') {
        var quqian = parseFloat(prompt('请您输入取的钱数：'));
        yue -= quqian;
        alert('您现在的钱数是：' + yue);
    } else if (message == '3') {
        alert('您现在的钱数是：' + yue);
    } else if (message == '4') {
        alert('正在退出');
        break
    }
}

// 普通变量一次只能存储一个值
var  num = 10; 
// 数组一次可以存储多个值
var arr = [1,2,3,4,5];

var 数组名 = new Array() ；
var arr = new Array();   // 创建一个新的空数组

// 1. 使用数组字面量方式创建空的数组
var  数组名 = []；
// 2. 使用数组字面量方式创建带初始值的数组
var  数组名 = ['小白','小黑','大黄','瑞奇'];

var arr = []; //创建了一个空的数组
var arr1 = [1,2,'学习',true];
// 我们数组里面的数据一定用逗号分隔
// 数组里面的数据 比如1,2， 我们称为数组元素

var arr1 = [1,2,'学习',true];
console.log(arr1);
console.log(arr1[2]); // 学习
console.log(arr1[3]); // true
console.log(arr1[4]); // 因为没有这个数组元素 所以输出的结果是 undefined

var arr = ['星期一', '星期二', '星期三', '星期四', '星期五', '星期六', '星期日',];
console.log(arr[6]);

var arr = ['red', 'green', 'blue'];
for (var i = 0; i < 3; i++) {
    console.log(arr[i]);
}
// 1. 因为我们的数组索引号从0开始 ，所以 i 必须从 0开始  i < 3
// 2. 输出的时候 arr[i]  i 计数器当索引号来用

var arr = ['关羽', '张飞', '马超', '赵云', '黄忠', '刘备', '姜维'];
console.log(arr.length);

var arr = ['关羽', '张飞', '马超', '赵云', '黄忠', '刘备', '姜维', 'pink'];
// for (var i = 0; i < 7; i++) {
//     console.log(arr[i]);
// }
// console.log(arr.length);

for (var i = 0; i < arr.length; i++) {
    console.log(arr[i]);
}

var arr = [2, 6, 1, 7, 4];
var sum = 0;
var average = 0;
for (var i = 0; i < arr.length; i++) {
    sum += arr[i];  // 我们加的是数组元素 arr[i] 不是计数器 i
}
average = sum / arr.length;
console.log(sum, average); // 想要输出多个变量，用逗号分隔即可

var arr = [2, 6, 1, 77, 52, 25, 7];
var max = arr[0];
for (var i = 1; i < arr.length; i++) {
    if (arr[i] > max) {
        max = arr[i];
    }
}
console.log('该数组里面的最大值是：' + max);

// 最小值
var arr = [2, 6, 1, 77, 88, 25, 7];
var min = arr[0];
for (var i = 1; i < arr.length; i++) {
    if (arr[i] < min) {
        min = arr[i];
    }
}
console.log('该数组里面的最小值是：' + min);

// 将数组 ['red', 'green', 'blue', 'pink'] 转换为字符串，并且用 | 或其他符号分割
// 1.需要一个新变量用于存放转换完的字符串 str。
// 2.遍历原来的数组，分别把里面数据取出来，加到字符串里面。
// 3.同时在后面多加一个分隔符
var arr = ['red', 'green', 'blue', 'pink'];
var str = arr[0];
for (var i = 1; i < arr.length; i++) {
    str = str + '|' + arr[i];
}
console.log(str);

var arr = ['red', 'green', 'blue'];
console.log(arr.length); // 3
arr.length = 5;  // 把我们数组的长度修改为了 5  里面应该有5个元素 
console.log(arr);
console.log(arr[3]); // undefined
console.log(arr[4]); // undefined
// 其中索引号是 3，4的空间没有给值，就是声明变量未给值，默认值就是 undefined。

var arr1 = ['red', 'green', 'blue'];
arr1[3] = 'pink';
console.log(arr1);  // ['red', 'green', 'blue', 'pink']
arr1[4] = 'hotpink';
console.log(arr1);  // ['red', 'green', 'blue', 'pink', 'hotpink']
arr1[0] = 'yellow'; // 这里是替换原来的数组元素
console.log(arr1);  // ['yellow', 'green', 'blue', 'pink', 'hotpink']
arr1 = '有点意思';
console.log(arr1);  // 有点意思 之前的数据都没有了
// 不要直接给 数组名赋值 否则里面的数组元素都没有了

var arr = [];
for (var i = 0; i < 10; i++) {
    arr[i] = i + 1;
}
console.log(arr);

// 将数组 [2, 0, 6, 1, 77, 0, 52, 0, 25, 7] 中大于等于 10 的元素选出来，放入新数组。
// 1、声明一个新的数组用于存放新数据newArr。
// 2、遍历原来的旧数组， 找出大于等于 10 的元素。
// 3、依次追加给新数组 newArr。
// 方法1
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
var j = 0;
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
        // 新数组索引号应该从0开始 依次递增
        newArr[j] = arr[i];
        j++;
    }
}
console.log(newArr);

// 方法2 
var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
// 刚开始 newArr.length 就是 0
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 10) {
        // 新数组索引号应该从0开始 依次递增
        newArr[newArr.length] = arr[i];
    }
}
console.log(newArr);

var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
var newArr = [];
for (var i = 0; i < arr.length; i++) {
    if (arr[i] >= 1) {  // 或者 (arr[i] != 0)
        newArr[newArr.length] = arr[i];
    }
}
console.log(newArr);

// 1、声明一个新数组 newArr
// 2、把旧数组索引号第4个取过来（arr.length - 1)，给新数组索引号第0个元素 (newArr.length)
// 3、我们采取 递减的方式  i--
var arr = ['red', 'green', 'blue', 'pink', 'purple'];
var newArr = [];
for (var i = arr.length - 1; i >= 0; i--) {
    newArr[newArr.length] = arr[i];
}
console.log(newArr);

var arr = [5, 4, 3, 2, 1];
// var arr = [4, 1, 2, 3, 5]; 也是可以排序的
for (var i = 0; i <= arr.length - 1; i++) { // 外层循环管趟数 
    for (var j = 0; j <= arr.length - i - 1; j++) { // 里面的循环管 每一趟的交换次数
        // 内部交换2个变量的值 前一个和后面一个数组元素相比较
        if (arr[j] < arr[j + 1]) {   // 降序(arr[j] > arr[j + 1])
            var temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }

    }
}
console.log(arr);