复习第四天
//1.day01 -- 变量、数据类型
// 输入 ：var usrInput = prompt('消息内容'); --> 返回的都是字符串
// var usrChoose = confirm('消息内容'); --> 返回的true/false
// document.write('<script src="1.js"><\/script>')
// 输出 ： console.log('输出内容'); --> 程序员用
// alert('用户消息'); --> 给页面浏览者看的
//2.day02 -- if else 条件判断 switch case --> if(a === 1)
// 显示类型转换：
// 转数值： parseInt() parseFloat() Number() , +('') -> 0 parseInt('') -> NaN
// 转字符串： 变量.toString() String() -- null和 undefined 没有toString() ，会报错！
// 转布尔值： Boolean()
// 转成false : 0 -0 NaN '' false undefined null document.all
// 转成true
//3.day03 -- 循环 ： 凡是 不依赖与 循环次数，都用 while 或 do while
// while 先奏后斩 - 先判断 循环条件是否成立，如果成立，则执行循环体代码，否则，直接退出循环
// do while 先占后奏 - 先执行1次循环体代码，然后再判断循环条件，看要不要执行下一次循环
// for --- 有指定循环次数 时 使用！
// 用来 按照次数循环 for(var i = 1; i<=10;i++){ }
// 用来 生成数字 for(var i = 20; i<= 80;i++){ }
// 用来 生成 数组 的 下标 for(var i = 0; i < arr.length;i++){ }
// continue -- 退出本次循环 --》跳到 i++
// break -- 退出整个循环
//4.day04 -- 数组：
// var arr = [1 , 2 , 3 , 'a' , true];
// 0 1 2 3 4 , length = 5
// 数组三要素： 元素，下标，length
// 追加元素：arr.push('暴雨为何还不来~~！'); // -> [1 , 2 , 3 , 'a' , true, '暴雨为何还不来~~！']
// 删除元素：arr.splice(index,count)
// 修改元素：arr[1] = 'love'; // -> [1 , 'love' , 3 , 'a' , true, '暴雨为何还不来~~！']
// 清空数组：arr.length = 0; // -> [ ]
// 遍历数组
var arr = [1, 2, 3, 'a', true];
// 0 1 2 3 4 , length = 5
// 正序遍历
for (var i = 0; i < arr.length; i++) { // i = 0 1 2 3 4
console.log(arr[i]);
}
// 倒序遍历
for (var i = arr.length - 1; i >= 0; i--) { // i = 4 3 2 1 0
console.log(arr[i]);
}
01函数
// 本质上说，变量 就是 一个 内存空间
// 通俗的说, 变量 就是 一个 盒子，里面只能装一个数据
var a = '苹果';
a = '梨子';
// 数组
// 本质上说，数组 就是 一连串 的空间
// 通俗的说, 数组 就是 一连串 的盒子，可以装好多数据
var arrFruit = ['苹果', '梨子', '葡萄', '香蕉', '芒果'];
// ------------------------------------------函数 ----------------------------------------------
// 本质上说，函数 就时 一个 装了 代码 的 内存空间
// 1.【函数声明】： 创建 装了 代码的 “盒子”，盒子里的代码 此时 不会 执行
// function 函数关键字
// showLove 函数名
// () 形参列表
// { } 函数体
function showLove(){
var num = 10;
num += 100;
console.log('ruiky，我爱你 ~~~~');
console.log('隔壁老周,讨厌~~~' + num);
}
// 2.【函数调用】：执行 函数"盒子" 里的代码！！
// 语法： 函数名();
// 当 函数中的代码 执行 完成后，JS引擎就调到 函数 调用 后面的代码执行
showLove();
console.log('函数调用结束了~~~~');
// 3.【为什么要有函数】：函数 可以用来 将 经常 会被调用 的 一段 代码 封装起来， 重复调用 ！-------------
// 【函数的功能】 ：封装、复用代码
// 3.1【函数的参数】：
// 形参-》声明函数时，小括号中 可以 添加 【形参变量】，用来 接收 函数调用时 传入的 值
// 形参的本质，就是 函数的 局部变量，只能在函数内部访问和使用
// 实参-》调用函数时，小括号中 可以 添加 【实参值】，实参值 会被 “传给” 被调用函数的 【形参变量】
// // ---------------------------------------大宝剑函数 ---------------------------------
// function bigSword(jiShiId){ //var jiShiId;
// console.log('------------欢迎来到快乐岛盲人按摩健康会所------------');
// console.log('交钱：1888~~~');
// console.log('选择盲人技师 '+ jiShiId +' 号 ~~');
// console.log('天黑请闭眼~~正规盲人按摩开始~~');
// console.log('正规按摩结束，先生请喝一杯可乐~~~');
// }
// console.log('坤哥起床了，觉得精神不好，要去 大宝剑~~~~');
// bigSword(999); // 实参 999 ，被传给 形参 jiShiId
// console.log('坤哥中午下班了，觉得有点累，要去 大宝剑~~~');
// bigSword(68);
// console.log('坤哥晚上回家了，老婆说他回来太晚，不让进门，坤哥很郁闷，就去 大宝剑~~~');
// bigSword(69);
//3.2 如果 没有 为 形参 赋值，那么 形参默认值 为 undefined
// bigSword(); //
// ---------------------------------------大宝剑函数 ---------------------------------
//4.【函数的形参】 可以 有多个，中间用 逗号隔开~~~
function bigSword(jiShiId,yinLiao){ //var jiShiId;
console.log('------------欢迎来到快乐岛盲人按摩健康会所------------');
console.log('交钱：1888~~~');
console.log('选择盲人技师 '+ jiShiId +' 号 ~~');
console.log('天黑请闭眼~~正规盲人按摩开始~~');
console.log('正规按摩结束，先生请喝一杯' + yinLiao + '~~~');
}
console.log('坤哥起床了，觉得精神不好，要去 大宝剑~~~~');
//4.2【函数实参】因为 形参 有 两个，所以 实参 也可以传递 2个 给 对应的形参
// 传参规则：按照 实参 和 形参 的 对应顺序 依次赋值
bigSword(999,'牛奶'); // 实参 999 ，被传给 形参 jiShiId
// console.log('坤哥中午下班了，觉得有点累，要去 大宝剑~~~');
// bigSword(68,'咖啡');
// console.log('坤哥晚上回家了，老婆说他回来太晚，不让进门，坤哥很郁闷，就去 大宝剑~~~');
// bigSword(69,'汇源肾宝');
02函数形参的默认值
//【函数形参 的默认值】: 当 调用函数时，没有传入实参时，形参 会有一个 默认的值
//1.方式一：使用 || 运算符 的 短路 操作
function bigSword1(jiShiId, yinLiao) { //var jiShiId;
// 如果 jiShiId 没有实参值，默认 是 undefined，也就是说，调用函数时，没有实参传入
//1.1 通过 if 来 模式 设置 默认值 ------------------------
// if(jiShiId == undefined){
// // 所以 设置 jiShiId 的默认值为 77
// jiShiId = 77;
// }
// if(yinLiao== undefined){
// yinLiao = '可乐';
// }
//1.2 通过 三元运算符 来 模式 设置 默认值 ------------------------
// jiShiId = jiShiId == undefined ? 77: jiShiId;
// yinLiao = yinLiao == undefined ? '可乐': yinLiao;
// if ()中的值 如果 直接是 0 -0 NaN null undefined '' ，相当于 if(false){ }
// if(!jiShiId){
// jiShiId = 77;
// }
//1.3 通过 逻辑或 短路来 模拟 设置默认值 ------------------------
// 形参 = 形参 || 默认值;
// jiShiId = jiShiId || 77;
// yinLiao = yinLiao || '牛奶';
console.log('------------欢迎来到快乐岛盲人按摩健康会所------------');
console.log('交钱：1888~~~');
console.log('选择盲人技师 ' + jiShiId + ' 号 ~~');
console.log('天黑请闭眼~~正规盲人按摩开始~~');
console.log('正规按摩结束，先生请喝一杯' + yinLiao + '~~~');
}
//4.方式四：使用 es6 语法 设置默认值
function bigSword(jiShiId = 77, yinLiao='牛奶') {
console.log('------------欢迎来到快乐岛盲人按摩健康会所------------');
console.log('交钱：1888~~~');
console.log('选择盲人技师 ' + jiShiId + ' 号 ~~');
console.log('天黑请闭眼~~正规盲人按摩开始~~');
console.log('正规按摩结束，先生请喝一杯' + yinLiao + '~~~');
}
//调用函数：没有传实参
bigSword();
//调用函数：传递了实参
bigSword(29,'肾宝');
03函数的返回值
//1. 函数 的作用 ： 封装代码 ， 复用代码
//2. 函数 的参数 : 函数声明时的【形参】，函数调用时的【实参】
//3. 函数 的形参的默认值： es6语法，在小括号中直接为 形参设置 默认值
//4. 函数 的返回值 ：在函数 内部 使用 return 关键字 可以 将一个值 返回 给 函数的调用者
// 调用函数 的目的 ：
// a.执行一段 封装在 函数内部的 代码 ，比如说 bigSword函数，就是单纯的为 了 执行一遍 大宝剑的业务代码
// b.执行一段 封装在 函数内部的 代码，并且 获取 一个 执行的 结果，比如说 求 随机数 Math.random() ，执行后 会返回一个 随机数
function add(x,y){
var res = x + y;
return res; // 在函数内部 将一个 值 返回给 函数的调用者
console.log('我是 retrun后面的代码，永远都不会被执行！！！');
}
var numX = add(1,2); // 相当于 ： var numX = 3;
console.log(numX);
// 如果 函数中 不使用 return ，那 有没有返回值？
//4.1【所有函数中如果 不使用 return 来返回一个值的话，默认 都返回 undefined~~!】
function showLove(){
console.log('cai lan hei ~~~~');
}
var a = showLove();
console.log(a);
//4.2 return 跳出 当前函数！！！
function showLove(){
console.log('我爱你~~');
console.log('i love u ~~');
return; // return undefined;
console.log('cai lan hei ~~');
console.log('a yi xi te nu ~~');
}
showLove();
console.log('showLove 参数执行完毕');
04 js预解析和函数变量提升
// console.log(b); // 报错： b is not defined
//【js引擎 会 先 做 预解析，然后再 由上到下 的执行代码】
// 1. JS预解析
// 1.1 将 所有 声明的变量 提到 所在作用域的 最顶端
// 1.2 将 所有 声明的函数 提到 所在作用域的 最顶端
// 注意：提升后，变量 在 函数 之前
//1.1 将 所有 声明的变量 提到 所在作用域的 最顶端----------
console.log(a); // undefined
var a = 1;
console.log(a); // 1
//1.2 将 所有 声明的函数 提到 所在作用域的 最顶端-------------
b();
function b(){
console.log('我是bbbbbbbbbb');
}
05函数的作用域
// 全局作用域 和 局部作用域 中的 变量，重名 不会 相互影响！！因为 两个变量 在 不同的 作用域中！！！
//1.【作用域】： 变量可以访问的范围
//2.【全局作用域】: 整个页面就是 全局作用域 -- window对象就是 全局作用域
//3.【局部作用域】：函数大括号内部 就是 局部作用域
//4.【全局变量】：在函数外部声明的变量 就是 全局变量 -- 全局作用域里声明的 变量 就是 全局变量
//5.【局部变量】：在函数内部声明的变量 就是 局部变量
var num = 1;
var num2 = 120;
function a() {
var num = 10;
// a.注意：在函数 内部 访问 num时，因为 局部作用域里的 num 和 log 代码 在同一个作用域中，所以 ，打印的就是 局部作用域里的 a
// 在函数内部 访问变量时，优先使用 函数内部的变量
console.log('函数内部的 num =' + num); // 10
// b.注意：在函数 内部 访问num2时，先在 函数内部找 num2，如果没有，就去 全局作用域找 num2
console.log('num2 = ' + num2);
// c. 注意：在函数 内部 访问num3时，先在 函数内部 找 num3,如果没有，就去 全局作用域找 num3，如果还没有，就报错！！！
// console.log('num3 = ' + num3); // 报错
}
a();
console.log('函数外部的 num =' + num); // 1
06计算三个数的乘积
function plus(x, y, z) {
var res = x * y * z;
return res;
}
var num = plus(1,2,3);
console.log(num);
07求x到y之间所有数字的和
function add(x, y) {
// 准备 累加和用的 变量
var sumNum = 0;
// 循环 生成 x 到 y 之间所有的数
for(var i = x; i <= y;i++){
// 将 生成的数 累加到 变量 sumNum 中
sumNum += i;
}
//返回 累加和
return sumNum;
}
var num = add(1, 100);
console.log(num);
08.求一个数组的最大值
// 求一个 数组中的最大值
// 1. 数组 是 调用时 传进来的
// 2. 函数内部要 将 数组中的 最大值 找到，并返回
function getMax(arrNum) {
//定义局部变量 maxNum ，用来当做擂台，保存数组中的 最大值
var maxNum = -Infinity;
//使用 for 循环 生成 数组里的下标，并 找出最大值
for(var i = 0; i< arrNum.length;i++){
//比较 数组里的元素 和 maxNum 谁大，如果 元素大，就将 元素 存入 maxNum
if(arrNum[i] > maxNum){
maxNum = arrNum[i];
}
}
//返回 最大值
return maxNum;
}
//调用函数
var arrAge = [18, 21, 777,25, 99,30, 77,2];
var maxAge = getMax(arrAge);
console.log(maxAge);
