JS笔记（五）关键字、数组、函数
1、关键字：
（1）break; 在循环中使用，break则立刻跳出循环。
（2）continue; 在循环中使用，直接开始下一次循环。
var sum = 0;
var i = 100;
while(i <= 200){
//判断是不是偶数
if( i% 2 == 0){
//如果是偶数就跳过,即后面的sum不加
i++;
continue；
}
sum+=i;
i++;
}
2、数组：一组有序的数据
定义：（1）通过构造函数创建数组：var 数组名 = new Array(); Array()是构造函数。
创建数组：
（1）var arr = new Array();空数组
arr[0] = 'Audi';
arr[1] = 'Bmw';
arr[2] = 'Volvo';
（2） var arr = new Array(5);5是长度
（3） var arry = new Array(10,20,30,40,50,60); 直接放数据，实例化。
（直接输出“数组名”，可直接把数组中的数据显示出来）
（4）var arr = [10];一个元素，值是10
（5）var arr = [];空数组
（6）通过字面量的方式创建数组：var 数组名 = [];
var arr = ['Audi','Bmw','Volvo'];
--->注意：用new Array的时候后面不可加 [ ] ；
数组的项：（1）数组元素：存放的每个数据
（2）数组长度：数组元素的个数
（3）数组索引（下标）：用来存储或访问数中的数据的，从0开始
--->注意：js中数组存储的数据类型可以不同；数组的长度也是可以改变的。
--->而在JAVA中，声明数组
（1）声明并赋值：int[] arr = {1,2,3,4...};
（2）int[] arr; arr = new int[]{1,2,3...};
（3）int[] arr = new int[3];
（4）多维数组：int[][] arr = {{1,2,3},{4,5,6}};
例1：求数组中最大值
var arr = [1,2,3,4,5,6];
var max = arr[0];
for(var i=0; i<arr.length; i++){
if(max < arr[i]){
max = arr[i];
}
}
例2：去掉数组中重复的0，剩下的归于一个新的数组
var arr = [10,0,22,0,12,0,0];
var newArr = [];
for(var i=0; i<arr.length; i++){
if(arr[i] != 0){
newArr[newArr.length] = arr[i]; //新数组的长度作为下标使用
}
}
例3：反转数组：第一个和最后一个交换位置，第二个和倒数第二个交换
var arr = [10,20,30,40,50];
for(var i =0; i<array.length/2;i++){
var temp = array[i];
array[i] = array[array.length-1-i];
array[array.length-1-i] = temp;
}
例4：提示输入班级人数，求总成绩，平均值，最高分，最低分
var perCount = parseInt(prompt("请输入班级人数"));
var perScores = [];
for(var i = 0;i < perCount;i++){
perScores= parseInt(prompt("请输入第" + (i+1) + "个人的成绩"));
}
for(var i=0;i<perScores.length; i++){
var sum +=perScores[i];
}
var avg = sum/perScores.length;
var max = perScores[0];
var min = perScores[0];
for(var i=0;i<perScores.length; i++){
if(max < perScores[i]){
max = perScores[i];
}
if(min< perScores[i]){
mini = perScores[i];
}
}
例5：冒泡排序：把所有的数据按照一定的顺序排列，从小到大、从大到小
var arr = [10,0,100,20,60,30];
//控制比较的次数
for( var i = 0; a<arr.length-1; i++）{
//控制每一轮的比较的次数
for(var j = 0; j<arr.length-1-i; j++){
if(arr[j] <arr[j+1] ){ //从小到大
var temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
3、函数：把重复的代码进行封装，在需要的时候再调用
语法：
定义：
function 函数名（）{
函数体
}
调用：函数名（）；
（1）函数的参数：
在函数定义时，函数名字后面的括号内的数据就是参数，用于用户调用函数时候传参
function consoleSum（x,y）{
var sum = x+y;
console.log(sum);
}
consoleSum（10,20）；
---->形参：函数在定义时小括号里面的变量叫形参
---->实参：函数在调用时小括号里面传入的值叫实参，可以是变量也可以是值
（2）函数的返回值：
//get：获取
//set：设置
//函数的返回值：函数内部有return字样，返回后面的内容
function consoleSum（x,y）{
var sum = x+y;
return sum;
}
console.log(getSum(10,20));
注意问题：形参和实参的个数可以不一致，但是只会接收形参的个数的。
形参和实参也不是同一个变量，值一样，或者名字一样。
函数没有返回值，接受的话是undefined。
一个函数只能有一个返回值。
（3）函数练习：
例6：判断一个数是否是质数，只能被1和本身整除的。
（用这个数字和它前面的所以数字整除一次）
function isPrimeNumber(num){
for(var i =2; i<=num/2; i++){ //在一半的时候有酒已经证明
if(num%i == 0){
return false; //说明有一个数字被整除了，已经不是质数了
}
}
return true; //是质数
}
isPrimeNumber(7)?"是质数" : "不是质数";
例7： 求数组中最大
function zuiDa(arr){
max = arr[0];
for(i=0;i<arr.length;i++){
if(max<arr[i]){
max = arr[i];
}
}
return max;
}
console.log(zuiDa([10,2,3,4]));
例8：求一个数组中最大值和最小值还有和
/**
*
*@param array参数是一个数组
*@returns {*[]}返回值是一个数组，第一个元素是最大值，第二个元素是最小值，第三个是和
*/
function getMaxMinSum(array){
var max = array[0];
var min = array[0];
var sum= 0;
for(var i=0; i<array.length;i++){
sum += array[i];
if(max < array[i]){ max = array[i]; }
if(min > array[i]){ min = array[i]; }
}
var arr = [max,min,sum];
return arr;
}
var array = [10,2,3,4];
console.log(getMaxMinSum(array));
例9：函数实现数组反转：
function reverseArray(arr){
for(var i=0; i<arr.length/2;i++){
var temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
return arr;
}
console.log (reverseArray([1,2,3,4,5]));
例10：冒泡排序：
function sortArray(arr){
for(var i = 0;i <arr.length -1; i++){ //轮数
for(var j = 0;j <arr.length -1-i; j++){ //每轮的次数
if(arr[j] > arr[j +1]){
var temp = arr[j];
arr[j] = arr[j +1];
arr[j +1] = temp;
}
}
}
return arr;
}
console.log (sortArray([11,22,13,64,15]));
例11：求一个数字的阶乘
function getJieCheng(num){
var result = 1;
for(var i=1; i<=num;i++){
result *=i;
}
return result;
}
console.log(getJieCheng(5)); //1*2*3*4*5
（4）使用arguments对象可以获取传入的每个参数的值
arguments是个伪数组
（5）函数的其他定义方式
命名函数/匿名函数
函数定义方式：
A、函数声明--函数定义
function 函数名（）{
函数体；
}
B、函数表达式：把一个函数给一个变量，此时形成了函数表达式，函数名省略
var arr = function() { }; //arr就是一个函数，可直接加小括号调用来了
函数表达式自调用：(function(){ console.log("输出值"); })();
注意：函数的数据类型是function；
（6）函数作为参数使用：
function sayHi(){
console.log("您好呀");
fn();
}
function suSay(){
console.log("你也好呀");
}
sayHi(suSay);
注意：如果一个函数可以作为参数使用，那么这个函数就是回调函数。
（7）函数作为返回值使用：
function f1(){
console.log("f1被调用了");
return function(){
console.log("这是一个函数");
}
}
var ff = f1();
ff(); //ff就是一个函数了
（8）函数的作用域：
全局变量：var声明的变量就是全局变量。目前除了函数内声明的变量，其他任意位置的都是全局变量。var num=100;
（页面不关闭，就不会释放，消耗空间。全局变量不能被删除）
局部变量：在函数内部定义的是局部变量
（函数调用完就释放内存）
隐式全局变量：声明的变量没有var，就是隐式全局变量，外部可以使用，包括函数内声明的。num = 100;
（隐式全局变量能够被删除）
全局作用域：全局变量的使用范围
局部作用域：局部变量的使用范围
块级作用域：一对大括号就是一块，js中在块级作用域中定义的变量在外面也能使用。
（9）作用域链：在一个函数中使用一个变量，先在该函数中索搜这个变量，找到则使用，找不到则继续向外面找这个变量，一直找到全局作用域，找不到则是undefined。
（10）预解析：
（提前解析代码）
A、变量的声明提前了，提前到当前所在的作用域的最上面，但是赋值的过程不会提前；
B、函数的声明也提前，提前到当前所在的作用域的最上面；
（预解析变量的提升，只会提升到当前作用域的最上面，比如函数的只会在函数的最前面）
C. 预解析分段的问题的局部作用域问题
不同的<script></script>中，互不影响
例12：
f1();
var num=20;
function f1(){
console.log(num);
}
//结果为undefined，因为变量num声明提前，函数声明也提前，但是赋值没有提前。
例13：
var a = 18;
function f1(){
var b = 9;
console.log(a); //undefined
console.log(9); //9
var a = '123';
}
f1();
例14：
f1();
console.log(c);//9
console.log(b);//9
console.log(a);//报错
function f1(){
var a = b= c =9;
console.log(c);//9
console.log(b);//9
console.log(a);//9
}
//为什么第一个a会报错，是因为，函数提前的时候，var a; a=9; b =9; c =9; b和c是隐式全局变量，a仅在函数内有效。
例15：
f1(); //f1 is not a function
var f1 = function(){
console.log(a);
var a = 10;
}
//预解析的时候，var f1;提前，其他事赋值不能提前，所以
