JavaScript循环和函数

循环语句
while循环
使用场景：同一个代码块，需要执行多次时，考虑用循环。
书写格式：
while(条件){代码块}
功能：条件为真则执行大括号里面的代码块，知道条件为假结束
注：条件是可以变化的（防止死循环）
从1输到10

let state =1
while(state<=10){
    console.log(state++);
}

do{代码块}whole(条件)
和while的区别： 至少执行一次大妈快，条件为真时执行第二次，直到条件为假，结束循环

let state =1
do{
    console.log(state++);
}while(state<=10);

for循环
书写格式：for(表达式1;表达式2;表达式3){
代码块4
}
执行步骤：1-2-4-3
2-4-3
2-4-3…
直到不满足表达式2停止循环

for(let num = 1;num<=10;num++){
    console.log(num);
}

// 输出2000-3000年的闰年
for(let inputYear =2000;inputYear<=2200;inputYear++){
    if(inputYear%4 == 0&&inputYear%100 != 0||inputYear%400 == 0){
        console.log(inputYear+"年");
    }
}

break终止循环
continue（译：未完待续）终止本次循环

for(let num = 0; num<=100;num++){
    if(num == 5){
        continue;//break
    }
    console.log(num);
}

for和while的区别
确定次数用for 不确定用while
数组
功能：一个标识符，存储多个数据
声明数组的方式
字面量声明
书写格式： 关键字 标识符 赋值符号 中括号 分号

let      F70    =    []    ;
let F70 = [1,"abc",undefined,null,true] ;

使用数组中的值
书写格式：数组名称 [下标（索引）]
输出undefined F70[2]
下标（索引）：数组的第一哥值的下标是0，第二个是1；依次类推
获取一个不存在值的下标，会得到undefined
构造函数声明

let = new Array();

字面量与构造函数的区别：
字面量的解析效率比构造函数高
原因：字面量属于JSON格式，可以直接被JS进行解析
构造函数需要先调用构造函数，在进行JS引擎解析

解构
功能：吧引用数据类型，分解成基本数据类型
注：解构的左右数据类型需要一致
把右侧的值赋给左侧
批量赋值

let i = 1;
let j = 2;
[i,j]=[j,i]
console.log(i,j);//2 1

批量赋值

let [a,b,c]=[1,2,3]
console.log(a,b,c); //1 2 3
let [a,b,c]=[1,,3]
console.log(a,b,c);//1 undefined 3

let[i, j]=123;
console.log(i);//报错  因为数据类型不一致

数组的遍历（把里面的每一个值都拿出来，使用或者输出）
数组.length数组的长度（有几个值）

let f70 = ["a","b",1,2,3,4,5,6,7,8,9,10,"j"]
for(let i = 0;i<f70.length;i++){
    console.log(f70[i]);
}

break 名字 ；终止到名字那层循环

let F70 = [1,2,3,4,5,6]
// for...of遍历出数组中的每个数
for(let item of F70){
    console.log(item);
}
// for...in遍历出数组中每个值的下标
for(let item in F70){
    console.log(item);
}

// 在数组最后一个值后加一个
F70[F70.length] = 7;
console.log(F70);

如果常量赋值的是基本（简单）数据，存的是具体的值
如果常量存的是引用（复杂）数据类型存的是地址，在使用常量前更改数组里面的值也会跟着变（重新覆盖不会改变，因为是重新赋值是一个新的地址，而常量存储的是还是原来的地址）

数组的属性和方法：有点就是属性 有小括号就是方法

数组的方法：
增、删、改、查
在数组中增加内容
名字.push()在数组后面添加，可以批量添加 逗号隔开 并返回添加后的数组长度
名字.unshift()在数组前面添加 可以批量添加 逗号隔开 并返回添加后的数组长度

let F70 = [1, 2, 3]
let i = F70.push(4, 5, 6)
console.log(F70);//1 2 3 4 5 6
let = F70.unshift(0)
console.log(F70);//0 1 2 3 4 5 6
console.log(i, j);//6 7

名字.pop()在数组后删除数字（一次只能删除一个） 并返回删除的数据
名字.shift()在数组前删除数字（一次只能删除一个） 并返回删除的数据

let F70 = [1, 2, 3, 4]
let i = F70.pop()
console.log(F70);//1 2 3
let j = F70.shift()
console.log(F70);//2 3
//打印删除的数据
console.log(i,j);//3 1

判断数组中是否存在查找的值
书写格式：
数组.includes（查找内容）
存在返回true 不存在返回false

let F70 = [1, 2, 3]
let input = 2;
let state = F70.includes(input)
console.log(state);//true

判断数组中是否存在查找的值并输出下标
书写格式：
数组.indexOf（查找内容）从前往后找
存在返回值所在的下标 不存在返回-1

let F70 = [1, 2, 3,1]
inputName = 1;
state1 = F70.indexOf(inputName)//从前往后找的第一个
state2 = F70.lastIndexOf(inputName)//从后往前找的第一个
console.log(state1,state2); //0 3
//判断是否重复
state1 == state2;//false

数组.slice（参数1，参数2）批量获取数组内容
参数1是起始值的下标，参数2是结束下标
获取值是从参数1开始到参数2结束（ 不包含参数2）的所有内容
注：返回获取的内容，赋值给接受的变量，不会改变原参数
若参数为负数，则用数组长度与其相加。若没有满足范围的值，返回空数组
若参数只有一个，则从这参数一直获取到最后一个值，为负数，则用数组长度与其相加在获取，
加上长度后还为负数 就取全部值

let F70 = ["a","b","c","d","e"];
let F71 = F70.slice(1,3);
console.log(F70);//[ 'a', 'b', 'c', 'd' ,'e']
console.log(F71);//[ 'b', 'c' ]
//给负值
F71 = F70.slice(1,-2)
console.log(F71);//[ 'b', 'c' ]]
//给一个值
F71 = F70.slice(2)
console.log(F71);//[ 'c', 'd', 'e' ]

修改、插入
数组.splice（参数1，参数2，参数3）
会改变原数组
1个参数
会从这个参数的下标截取到最后一个下标，存储一个新数组并返回

// 一个参数
let F70 = ["a","b","c","d","e","f"];
let F71 = F70.splice(3)
console.log(F71);//[ 'd', 'e', 'f' ]
console.log(F70);//[ 'a', 'b', 'c' ]

2个参数
第1个参数：起始下标
第2个参数：截取个数

//两个参数
let F70 = ["a","b","c","d","e","f"];
let F71 = F70.splice(2,4)
console.log(F71);//[ 'c', 'd', 'e', 'f' ]
console.log(F70);//[ 'a', 'b' ]

3个参数
第1个参数：起始下标
第2个参数：截取个数（0代表插入，非0表示修改）
第3个参数及3个以后的参数：都是插入修改的值

//三个参数
let F70 = ["a","b","c","d","e","f"];
let F71 = F70.splice(2,1,3)
console.log(F71);//[ 'c' ]
console.log(F70);//[ 'a', 'b', 3, 'd', 'e', 'f' ]

let F70 = ["a","b","c","d","e","f"];
let F71 = F70.splice(2,0,3)
console.log(F71);//[]
console.log(F70);//[ 'a', 'b', 3, 'c', 'd', 'e', 'f' ]

运算符（扩展运算符）可以把每个值拿出来 …变量名
字符串快速分别转出数组

let str = "123"
let F70 = []
F70 = [...str]
console.log(F70);//[ '1', '2', '3' ]

快速拿出用户输入的年月日 变量名.split(“分隔符”)

let date = '2020-9-9'
let arr = date.split("-")
console.log(arr);//[ '2020', '9', '9' ]
arr = date.split("")
console.log(arr);//[ '2', '0', '2', '0', '-', '9', '-', '9' ]

数组转字符串
变量.join(“分隔符（为空直接转出）”)

let arr = [1, 2, 3]
let str = arr.join("")
console.log(str);//123
str = arr.join(".")
console.log(str);//1.2.3

let arr = [1, 2, 3]
let arr1 = ["A", "b", "c"]
arr1 = [ ...arr,...arr1]
console.log(arr1);//[ 1, 2, 3, 'A', 'b', 'c' ]

求数组的最大值Math.max（）

// 最大值
let arr = [1,2,3]
let maxNum = Math.max(...arr)
 console.log(maxNum);

用户输入5个数 判断最大值

// 用户输入5个数 判断最大值
const sc = require("readline-sync");
let input = sc.question();
let arr = input.split(",");
let lamp = arr.join;
if (lamp == lamp - 0) {//判断纯数字
    if (arr.length == 5) {
        console.log(Math.max(...arr));
    } else {
        console.log(`请输入5个数`);
    }
}else{
    console.log(`请输入纯数字`);
}

扩展
多维数组
取值就 名[][]

let user = [
    ["111", "123", 1000],
    ["222", "223", 2000],
    ["333", "323", 3000]
]
console.log(user[0][0]);//111
console.log(user[0][1]);//123

数组的排序
1.选择排序
1.选择排序

let num = [1, 6, 5, 2, 3]
for(let i = 0;i<num.length;i++){
    for(let j = i+1;j<num.length;j++){
        if(num[i]>num[j]){
            [num[i],num[j]] = [num[j],num[i]]
        }
    }
}
console.log(num);

2.冒泡排序

let num = [1, 6, 5, 2, 3]
for (let i = 1;i<num.length;i++){//比较次数
    for(let j = 0;j<num.length;j++){
        if(num[j]>num[j+1]){//冒泡排序是前一个和后一个比较
            [num[j],num[j+1]] = [num[j+1],num[j]]
        }
    }
}
console.log(num);

一个标识符（集合Set）可以存储多个数据，数据不能重复
集合与数组的区别
集合的内容具有唯一性（内容不能相同，是全等，相同类型一样的值只能出现一次）
声明集合 构造函数
let 名字 = new Set() 小括号里面不能是具体的单个的值 ，可以是数组
// 声明集合
let f70 = new Set();//集合声明，小括号里不能是具体的值
f70.add(1)//在几乎后面加值
f70.add(2)
f70.add(1)//相同的值存不进去
f70.add(“1”)//不同的类型可以存储
console.log(f70);

数组去重

let f71 = [1,2,1,3,45,3]
let f70 = new Set(f71);//先转集合
f71 = [...f70]//在吧集合转数组
console.log(f71);

集合的方法和属性
集合名.size
输出集合的存储数据的个数

集合的方法
在集合后面添加
集合名字.add(添加值)
链式调用：（一行代码连续书写多个书写方法）
集合名.add(添加值).add(添加值)…（
由于add方法返回值就是集合，因此可以在.add后面继续添加add）

清空集合：
集合名.clear()

查找集合里面的值
集合名.has(查找的值)

let f70 = new Set([1,2,3,4,5])
console.log( f70.has(2));


let f70 = new Set([1,2,3,4,5])
console.log( f70.has(2));
for(let item of f70.keys()){
    console.log(item);//1 2 3 4 5  键名
    
}
for(let item of f70.values()){
    console.log(item);1 2 3 4 5  键值
}
for(let item of f70.entries()){
    console.log(item);  // 键值和键名一起输出
}

集合的键值对：他的值就是键

函数
可以实现一定功能
即把可以实现一定功能的代码，封装成一个函数
声明函数（不会直接执行，什么时候执行取决于什么时候调用）

字面量声明
书写格式： 关键字 标识符（函数名） 小括号 {代码块/函数体}
function f70 () {代码块}

function serach() {//创建函数
    console.log("ddddd");
}

调用函数
书写格式 函数名（）
function serach() {//创建函数
console.log(“ddddd”);
}
serach()//执行函数

构造函数声明
书写格式 ：关键字 标识符 赋值符号 new Fution();
let f70 = new Function();

匿名函数表达式(函数表达式（匿名函数表达式）声明函数)
书写格式： 标识符 赋值符号 function() {函数体 }

let f70 = function() {
    console.log(`1234569`);
}

函数三要素：
1.函数名
2.参数
形参（形式参数）
在函数声明的时候
实参（实际参数）
在函数调用的时候
形参和实参可以重名，但是不影响
形参比实参多，多的形参会是undefined
实参的个数比形参多，多的实参不会使用

function f70(name,name1,name2,name3){
    console.log(`1号${name},2号${name1},3号${name2},4号${name3}`);
}
let name = "aaa";
let name1 = "bbb"
let name2 = "ccc"
let name3 = "ddd"
f70(name,name2,name1,name3)//1号aaa,2号ccc,3号bbb,4号ddd

类数组
函数名.arguments
arguments是函数的属性，返回所有实参的内容;
可以类似于数组的使用方法进行值的获取
函数名.arguments[下标]可以获取到第几个值
函数名.arguments[.arguments.length-1] 获取最后一个实参的值

function f70(name,name1,name2,name3){
    console.log(`1号${name},2号${name1},3号${name2},4号${name3}`);
console.log(f70.name);//f70
console.log(f70.arguments)//[Arguments] { '0': 'aaa', '1': 'ccc', '2': 'bbb', '3': 'ddd' }
console.log(f70.arguments[1])//ccc
console.log(f70.arguments.length)//4
}
let name = "aaa";
let name1 = "bbb"
let name2 = "ccc"
let name3 = "ddd"
f70(name,name2,name1,name3)//1号aaa,2号ccc,3号bbb,4号ddd

3.返回值
返回值 return （只能返回一个值 但是可以用引用数据类型返回多个值）
写了return，只返回后面的return后面的内容
如果没有，就返回undefined
注：具备终止函数的功能

function f70 (){
    console.log("aaa");
}
console.log(f70());//先执行console.log("aaa");然后没有返回值在输出undefined

随机生成相同的数

随机生成0-1之间的数，不包含1

Math.random()

//生成1-9之间的整数
function num(min = 1, max = 9) {
    if (min > max) {
        [min, max] = [max, min];
    }
    return parseInt((max - min + 1) * Math.random() + min);
}