# |注意:本篇笔记存在大量的自定义格式,请详细阅读下面的说明, 避免可能会产生的语法上的理解错误和歧义。
# |说明:"本页面笔记代码所使用格式:" #+[中文名称+代码本体]+代码举例+//备注
# |说明:本笔记临时使用"t"作为"数值,属性"的通用命名
# |说明:本笔记临时使用"h"作为"函数(function)"的通用命名
# |说明:本笔记临时使用"I"作为"脚本,数值,属性"的通用格式,(I)可以是您的任意脚本

—————————————————————————————————————————————————————————————————————————————————————————————————————————————
# |前置知识点：
# |JS中的六种数值类型：1.string(字符串) 2.Number(数值) 3.Boolean(布尔值) 4.Nu11(空值) 5.Undefined(未定义) 6.Object(对象)
# |JS中的引号规范：1.在JS中字符串需要使用引号引起来 2.使用双引号或单引号都可以，但是不要混着用 3.引号不能嵌套，双引号不能放双引号，单引号不能放单引号 4.在字符串中我们可以使用\作为转义字符来输入特殊字符等 如:(\"表示" |\'表示' |\n表示换行 |\t表示制表符 |\\表示\)
# |JS中所有的数值都是Number类型:包括整数和浮点数(小数)
# |JS中可以表示的数字的最大值:Number.MAX VALUE = Infinity 表示正无穷
# |JS中可以表示的数字的最小值:-Number.MAX VALUE = -Infinity 表示负无穷
# |非数字变量前加"+"可以转为数字型 //列举：t=+"123"等同于t=123
# [赋值-计算] var t = 00 //为t赋值00 

# |[数据-常规] var t = 00 或 "00" 或 true  //定义数据的可以是数值型或字符串型或布尔类型...
# |[数据-合成] var t = {t1:00 t2:"00" t3:true} //定义不同数据可以组合,数值型+字符串+布尔类型等...
# |[数据-空值] var t = null 或 undefined //定义数据的两种状态："null"代表对象为"没有","undefind"代表数值为"没有"

—————————————————————————————————————————————————————————————————————————————————————————————————————————————
# |JS引入:[内联式引入] <script var t = 0: ></script> //在html文档的script标签里直接写入js 
# |JS引入:[外部引入] <script src="./xx.js"></script> //在html文档的script标签内引入外部js表 
变量———————————————————————————————————————————
# [全局变量: var] var t = 1
# [局部变量: let] let t = 1 
# [局部常量: const] const t = 1

# [变量提升: console.log] console.log(t); var t =1  //先打印后声明:浏览器执行顺序:先定义"t"为null(空值),再打印"t",重新定义"t"为"1" 
# [输出后台: console.log] console.log(t)
# [输出弹窗: alert] alert(t)
# [输出页面: document.write] document.write(t)
# [输入弹窗: prompt] t =prompt('T') //弹窗输入框的数据T赋值给t

数值———————————————————————————————————————————
# [数据-检查: typeof] typeof t; //判断t:如果为数字返回number,如果为字符串返回string,如果为布尔类型返回boolean;如果为对象返回object 
# [数据-查询: length] t.length //获取t的数值长度或子集个数  

# [计算-常规] t1 + t2 //直接计算 
# [计算-自增] ++t //自增计算 | "++"为自增数值加1;"--"为自减数值减1* 
# [计算-变体] t1 += t2 //等同于"t1=t1+t2"
# [计算-比较] t1 > t2 //t1与t2进行比较,返回结果true或false    
# [计算-取反] !t //对t进行取反 | 注意:t="undefined,null,false,0,NaN"等值时返回结果为flase,其他为true 
# [条件-且] t1 < t2 && t1 = t2 //t1与t2进行条件判断,同时满足所有条件时返回true,否则返回flase 
# [条件-或] t1 < t2 || t1 = t2 //t1与t2进行条件判断,满足其中一个条件时返回true,都没有则返回flase  

判断———————————————————————————————————————————
# [判断-单条件: if] if(t1 == t2){I} //单条件判断: 如果t1等于t2判断为true,执行I,否则不执行 
# [判断-多条件: if/else] if(t1 == t2){I1}else{I2} //多条件判断: 如果t1等于t2判断为true,执行I1,否则执行I2 
# [判断-三元运算] t1 == t2 ? I1:I2 //三元运算：if嵌套的超简化版语句格式：如果t1等于t2,则执行I1,否则执行I2 
# [判断-多条件: switch/case;break]  switch(t){case a:I1;break;case b:I2;break;case c:I3;break;default:I4} //多条件判断: 如果t为a执行I1,为b执行I2,为c执行I3,都不满足执行I4
# [循环-单条件: for] for(初始值;条件;迭代因子){I} //单条件循环判断:"迭代因子"为每轮循环所要执行的操作,直到初始值达到"条件"设定的目标为止,I为要循环的公式 
# [循环-单条件: while] while(条件){I} //单条件循环判断:"条件"为循环要达到的目标,I为要循环的公式,初始值可以写在while前面
# [循环-跳过本轮: break] for(初始值;条件;迭代因子){I;break} //循环判断: 在原有循环语句I后添加"break"来跳出整个循环 
# [循环-终止本轮: continue] for(初始值;条件;迭代因子){I;continue} //循环判断: 在原有循环语句I后添加"continue"来终止本轮循环,并返回头部进行下一轮循环 

# [获取指定位置数值: charAt] t.charAt(I) //从数值左边第0个开始数,获取t的第I个数值 
# [数值合并-不运算: concat] t1.concat(t2,I) //连接t1和t2并和I合并, 
# [数值截取: substring] t.substring(I1,I2) //从数值左边第0个开始数|获取t的第I1个数值和I2数值之间的所有数值并进行合并,,获取不包含I1和I2数值本身|如果仅有I1则返回I1后面所有数值 
# [数值截取: substr] t.substring(I1,I2) //数值从左边第0个开始数|在t中获取从I1开始往后数I2个的数值,(I1如为负数则从后往前数);获取不包含I1和I2数值本身|如果仅有I1则返回I1后面所有数值 
# [数值查找: indexOf] t.indexOf("I1",I2) //查找t中是否存在I1数值,存在则返回对应下标|I2是查找开始位置 
# [清除前后空格: trim] t.trim() //清除t前后存在的空格 
# [清除头部空格·ES6: trimStart] t.trimStart() //清除t头部存在的空格 
# [清除尾部空格·ES6: trimEnd] t.trimEnd() //清除t尾部存在的空格 
# [数值分割-部分: split] T.split("|",I) //"T=t1|t2|t3";将T分割成"t1","t2","t3"并合并为一个数值数组['t1','t2','t3']|从左数第I个数值处停止分割,不填则不停止 
# [数值分割-全部: split] T.split("") //"()"为空时,分割T中的每一个数值并组成一个数组 

数组———————————————————————————————————————————
# [数组] t = ["I1","I2","I3","I4"] //定义t为一个数组,使用下标定位数据I
# [数组-遍历: ...]  for(let i=0;i<t.lenget;i++){T= t[i]} //获取t数组中的所有元素:"定义i从0开始遍历","t.lenget获取数组长度,i<t.lenget定义i的遍历次数(次数已由lenget获取)","i++定义每次遍历i的下标序列进一位" 
# [数组-判断: Array.isArray] Array.isArray(t) //a：true是数组,flase不是数组 
# [数组-增加尾: push] t.push("In") //在数组t的末端添加一个新元素"In",并返回t的数组长度 
# [数组-删除尾: pop] t.pop("In") //在数组t的末端删除一个元素"In",并返回t的数组长度 
# [数组-删除头: shift] t.shift("In") //在数组t的头部删除一个元素"I1",并返回删除的元素 
# [数组-增加头: unshift] t.unshift("In") //在数组t的头部添加一个新元素"I1",并返回t的数组长度 
# [数组-删除指定: splice] t.splice(I,t) //I：起始位置,t删除几个元素
# [数组-遍历清空: shift] while(t = I.shift()){console.log(t)} 
# [数组-元素组合: join] t.join() //将一个数组中的所有元素合并成一个字符串|join括号内规范：join()逗号隔开;join(|)分割号隔开;join("")不隔开;join(" ")空格隔开 
# [数组-翻转排列: reverse] t.reverse() //将t中的数组进行倒序排列,不会影响t,此方法也可用于字符串的翻转 
# [数组-元素查找: indexOf] t.indexOf(I1,I2) //查找t数组中是否有I1元素,如果有返回对应下标,不存在返回-1,I2是查找开始位置 

# [数组扩展ES6-展开符号: ...t] t= [1,2,3,4]//...简单快速直接展开数组中的值
# [数组扩展ES6-运算符号替代: ] Math.max.apply(null,arr) ==> Math.max(...a) //令数组借用函数max找出已经展开的数组中的最大值
# [数组扩展ES6-类数组转换: ] 
                                 
# [数据结构ES6-Set添加: set] t = new set() //类似于数组
# [数据结构ES6-Set-数组元素去重: set] t1=[1,2,3] ; t2 = new set(t1)  //将t1数组中的重复数据进行去重并赋值给t2
# [数据结构ES6-Set-字符串字符去重: set] t1= [1,2,3] ; t2 = ([...new set("abcabcdd")].join(""))  //将t1中的重复字符进行去重并赋值给t2
# [数据结构ES6-Set-数据判断: set] t= new set();t.add(100);t.add(200);t.delete(100);a=t;var t2=t.has(100);console.log(flag);  //返回一个布尔值，判断该值是否为Set成员
# [数据结构ES6-Set-清除所有成员: clear] t= new set();t.add(100);t.add(200);t.delete(100);s.clear()  //s.clear清除所有成员，没有返回值


# [函数-公式: function]  function + 函数名称(函数变量,函数变量) + {函数变量组成的公式} //函数一般读取方式:t = h(I1,I2)
# [函数-示范: function]  function h(I1+I2){t I1+I2}
# [函数-参数引入: function]  function h(I1,I2){t I1+I2} 
 参数改变: h(I1,I2)，//更改I1和I2即可将I1和I2的参数同步改变{"t I1+I2"后不能有计算,否则不执行}
# [函数扩展ES6-箭头函数: =>] h= function(x,y){return x+y;} 相当于 h =(x,y)=> x+y //相当于=>替代了function

# [对象-声明调用: key-value] t= {t1:I1,t2:I2} //t内可以包含多个不同类型数据|对象使用方式: T= t.t1|对象链式读取方式: T= t.t1.ta 
# [对象扩展ES6-简洁表示法: ] return {x=1, y=2} ===> function getPoint(){const x=1;const y= 10;return {x, y};}getPoint() // {x:1，y:10}//这种写法用于函数的返回值，将会非常方便

# [数学-绝对值: Math.abs] Math.abs.t //t转换为正数 
# [数学-最大值: Math.max] Math.max.t //t中取最大值 
# [数学-最小值: Math.min] Math.min.t //t中取最小值 
# [数学-向下取整: Math.floor] Math.floor.t //小数抹去 
# [数学-向上取整: Math.ceil] Math.ceil.t //小数抹去,进一位 
# [数学-伪随机小数: Math.random] Math.random() //随机生成0-1之间的数,不包括1本身 
# [数学-伪随机整数: function getRandomArbitrary()]  function getRandomArbitrary(min,max){let h= Math.random()*(max-min)+min} //随机生成min-max之间的整数|函数一般调用方式: getRandomArbitrary(I1,I2) 

# [时间-系统时间: data]  console.log(Data.now()) //获取当前时间栈|转换方法：T= new Data()| getTime():返回实例距离1970年1月1日00:00:00的亳秒数 

# [仓库盒子: container]  container.

# //------------------------------------------------------------------------------------------------------- 
# //DOM概述 
# [文档获取-document: document]  a= document //获取整个网页文档并赋a 
# [元素获取-标签: document.getElementsByTagName("")]  a= document.getElementsByTagName("t") //通过网页标签获取t元素 
# [元素获取-class: document.getElementsByClassName("")]  a = document.getElementsByClassName("t"); //获取class选择器的t元素 
# [元素获取-name: document.getElementsByName("")]  a= document.getElementsByName("t") //获取name选择器的t元素 
# [元素获取-id: document.getElementsById("")]  a= document.getElementsById("t") //获取Id选择器的t元素 
# [元素获取-H5新增: document.querySelector()]  a= document.querySelector(".t") //此方法仅获取选择器指定id的元素, 
# [元素获取-H5新增: document.querySelectorAII()]  a= document.querySelectorAII(".t") //此方法仅获取选择器指定id的全部元素-成数组, 

# [元素放置: .appendChild()]  t1.appendChild(t)的作用是把t标签放入t1标签中

# [元素创建-生成节点: createElement]  a= document.createElement('t') //生成元素标签 
# [元素创建-成成文本: createTextNode]  a= document.createTextNode('t') //生成元素文本 
# [元素创建-生成属性: createAttribute]  a= document.createAttribute('t') //生成元素属性 

# [元素操作-id更改: .id]  t1.id = "t2" //将t1的id改成t2 
# [元素操作-添加样式: .className]  t.className = "t1 t2" //将t1和t2的样式赋值给class名称为t的元素 
# [元素操作-添加或删除] [.classList]  t1.classList.add("t2")//添加或删除元素属性|可选属性:".add()"增加一个属性,".remover()"移除一个属性,".cintains()"检查当前元素是否包含某个属性,".toggle()"如果元素存在则移除,不存在则添加 
# [元素操作-标签读取: .innerHTML]  t.innerHTML //读取t中的内容,可以识别标签 
# [元素操作-文本读取: .innerText]  t.innerText //读取t中的内容,不支持识别标签,会把标签识别为一个字符串 

# [位置获取-元素位置: Element.clientHeight, Element.clientWidth]  a= Element.clientHeight.t //获取t的元素高宽 
# [位置获取-视口高度: document.documentElement.clientHeight]  a= document.documentElement.clientHeight //获取网页当前的可见高度(屏幕高度) 
# [位置获取-网页高度: document.body.clientHeight]  a= document.body.clientHeight //获取网页的页面总高度 
# [位置获取-滚动高度: document.documentElement.scro1lTop]  a= document.documentElement.scro1lTop //获取网页的上下滚动条的距离 

# [CSS操作-网页style: setAttribute]  t.setAttribute("style""t1;t2;t3") //为网页内"style"中的t添加t1,t2,t3样式 
# [CSS操作-元素style: .style]  a= document.querySelector("t").style //获取t元素,并通过.tyle修改t的样式, | 修改方法：box.style.width="??px"; 
# [CSS操作-cssText: csstext]  a= document.querySelector("t").style //获取t元素,并通过.tyle修改t的样式, | 修改方法：box.style.csstext ="width:??px;height:??px; 

# [事件方式-HTML事件: onclick] function hhh1(){a=1+2} http[button>:|<onclick>=："hhh1" //使用function函数生成hhh1函数,在button中引入hhh1函数,当点击按钮后会执行hhh1函数中的内容 
# [事件方式-DOM0级事件: onclick] var t=document.getElementsById("t"); t.onclick=function(){a=1+2} //注释:("t")为id选择器声明变量|获取t内容并将其赋值给t.|t.onclick=function(){a=1+2}是指:函数内容赋值给t,onclick(鼠标点击)事件执行函数内容 
# [事件方式-DOM2级事件: addEventListener] var t=document.getElementsById("t"); t.addEventListener("click",function(){a=1+2} //注释:("t")为id选择器声明变量|获取t内容并将其赋值给t.|t.addEventListener("click",function(){a=1+2}是指:函数内容赋值给t,onclick(鼠标点击)事件执行函数内容 

# [事件对象-Event-属性: Event.Target] var t=document.getElementsById("t"); t.onclick = function(event){Event.Target.innerHTML="0"} //event返回事件当前所在节点参数|点击t按钮后同时用innerHTML="0"改变t文本参数为0
# [事件对象-Event-查询: Event.type] var t=document.getElementsById("t"); t.onclick = function(event){a= Event.type}  //{a= Event.type}获取Event当前的事件类型
# [事件对象-Event-阻止事件: event.preventDefault] var t=document.getElementsById("t"); t.onclick = function(event){event.preventDefault} //阻止默认事件
# [事件对象-Event-阻止冒泡: event.stopPropagation] var t=document.getElementsById("t"); t.onclick = function(event){event.stopPropagation}  //阻止事件冒泡(阻止传播,防止触发其他节点监听函数,但不影响当前节点的监听函数)

# [事件操作-鼠标事件: click]  事件注意选择合适的事件方式执行函数|可选择鼠标事件
  on+
  click:按下鼠标时触发
  dblclick:在同一个元素上双击鼠标时触发
  mousedown:按下鼠标键时触发
  mouseup:释放按下的鼠标键时触发
  mousemove:当鼠标在节点内部移动时触发。当鼠标持续移动时，该事件会连触发
  mouseenter:鼠标进入一个节点时触发，进入子节点不会触发这个事件
  mouseleave:鼠标离开一个节点时触发，离开父节点不会触发这个事件
  mouseover:鼠标进入一个节点时触发，进入子节点会再一次触发这个事件
  mouseout:鼠标离开一个节点时触发，离开父节点也会触发这个事件
  wheel:滚动鼠标的滚轮时触发
# [事件操作-键盘事件: key] 
  on+
  keydown:按下键盘时触发
  keypress:按下有值时的健触发
  keyup:松开键盘时触发的事件
  keycode:每个键唯一标识ASCII码 //"13"为回车ASCII码,用于确认并进行下一步
# [事件操作-表单事件: key] 
  on+
  input:内容输入改变时触发  //input事件当 <input>、<select>、<textarea>的值发生变化时触发,对于复选(<input type=checkbox>或单选框( <inputtype=radio>)，用户改变选项时，也会触发这个事件
  select:选中输入时内容触发
  Change:内容完全输入或修改回车后触发，或内容失去焦点后触发
  reset: 重置表单时触发,同时返回默认值 //发生的对象为fron
  submit: 将数据提交至服务器时触发 //发生的对象为fron
# [滚动事件-: window.onscro1l = showTop] window.onscroll=debounce(scrollHandle,t)//此处t可以是任意时间数量
# [事件操作-事件代理-delegation: ...] var ul= document.querySelector('ul');ul.addEventListener('click',function(event){3if(event.target.tagName.toLowercase()==='i'){/*some code*/}}) //由于事件会在冒泡阶段向上传播到父节点，因此可以把子节点的监听函数定义在父节点上，由父节点的监听函数统一处理多个子元素的事件。这种方法叫做事件的代理
# [定时器-延时执行-Setlnterval: ...] hhh(function(){console.1og("定时器")，1000) //指定某个函数或某段代码，在多少毫秒之后执行。它返回一个整数，表示定时器的编号，以后可以用来取消这个定时器
# [定时器-间隔执行-Setlnterval: ...]  //指定某个函数或某段代码间隔多少秒执行1次，无限次执行

# [防抖事件1-滚动时间检测: ] 
|window.onscroll=debounce(scrollHandle,t)
|function debounce(t1,t2){var timer = null;return function(){if(timer){clearTimeout(timer)}timer = setTimeout(t1,t2)} //需要搭配滚动事件调整时间检测频率
|window.onscroll=debounce(scrollHandle,t)//此处t可以是任意时间数量
|function scrollHandle(){var scrollTop =document.documentElement.scrollTop;a=scrollTop;} //获取滚动信息并赋值给a
# [防抖事件2-节流函数: ] 
|function throttle(t1,t2){var valid = true;return function(){if(!valid){return false;}valid = false;setTimeout(function(){t1();valid = true;})}}
|window.onscroll=scrollHandle
|function scrollHandle(){var scrollTop =document.documentElement.scrollTop;a=scrollTop;} //获取节流信息并赋值给a
|window.onscroll=debounce(scrollHandle,t)//此处t可以是任意时间数量

# [命令行指令集-CMD]:
|打开命令行窗口:"win+r"
|选择盘符:"盘符名"+"冒号"
|查看盘符及目录下文件与文件夹:"dir"
|清空命令行信息:"cis"
|进入文件夹或目录:"cd"
|快速补全:"tab"
|创建文件夹: "mkdir" 
|查看历史输入过的命令:上下按键

# [解构赋值: ...]:格式: const+{需要简化省略的词}=属性名称 
# [遍历循环: ...]for (let i of 't'){console.1og(i);}

# [字符串模板]://使用方法 a= ta
|var t1 ="t1.com"
|var t2 ="t"
|var ta = "<a href ='"+ t1 +"'>"+ t2 +"</a>" //传统动态代码结构
|var tb =`<a href ="${t1}">"${t2}"</a>"`//字符串模板动态代码结构

# [字符串查查找]://使用方法 a= t.includes(???,?) /其中???是要在t中查找的字符串,?表示查找开始的位置
|includes():返回布尔值，表示是否找到了参数字符串
|startsWith():返回布尔值，表示参数字符串是否在原字符串的头部
|endswith():返回布尔值，表示参数字符串是否在原字符串的尾部
# [字符串重复: repeat] a= t.repeat(?)//返回一个新字符串,将原字符串重复?次
# [字符串补全: padStart(),padEnd()] a= t1.padStart(?位数,'要补的参数')] //padStart(头部补全),padEnd(尾部补全)
# [字符串空格去除: trimStart(),trimEnd()] a= t.trimStart() //trimStart(消除头部字符串空格),trimEnd(消除尾部字符串空格)
# [字符串下标索引: at] t.at(?) //?表示的是第几个字符串的下标 


# [promise-异步操作: promise] const promise = new Promise{function(resolve, reject){}} //异步对象


# [Async-同步操作: Async] function print(){setTimeout(() =>{console.1og(“定时器");},1000) console.1og("He11o");}
print() //Async可以将函数从异步操作变为同步操作

# [Class-类方法: Person]class Person{constructor(name,age) ;{this.name = name;this.age = age} //创建类
# [constructor: constructor] //类的默认方法，通过new命令生成对象实例时自动调用该方法。
# [Class-类属性: ] 


# [MODULE语法-export-模块命令: export]
|//export命令导出变量
|export var firstName ='sxt'
|export var lastName =itbaizhan';
|export var year = 2000;
|//export命令导出函数
|export function add(x，y){return x+y;}


# [MODULE语法-import-模块命令: impor]//使用 expon 命令定义了模块的对外接口以后，其他js文件就可以通过 impor 命令加载这个模块
|// name.js
|export var firstName ='sxt';
|export var lastName ='itbaizhan';
|export var year =2000;
|//main.js
|import {firstName,lastName,year }from'./profile.js';
|//如果想为输入的变量重新取一个名字，impon 命令要使用as关键字，将输入的变量重命名
|// value.js
|export var value = 1;
|// main.js
|import {value as val }from'./value.js';
|//除了指定加载某个输出值，还可以使用整体加载，即用星号(·)指定一个对象，所有输出值都加载在这个对象上面
|// circle.js
|export function area(radius){return Math.PI *radius * radius;}export function circumference(radius){return 2 *Math.PI * radius;}

# [MODULE语法-exportdefault-模块命令: exportdefault]//不用阅读文档就能加载模块，为模块指定默认输出。
|//export-default.js
|export defaut function(){console.1og('foo');}
|//其他模块加载该模块时，impon 命令可以为该匿名函数指定任意名字
|//import-default.js1
|import customName from'./export-default';customName();//'foo'

—————————————————————————————————————————————————————————————————————————————————————————————————————————————
—————————————————————————————————————————————————————————————————————————————
    1.变量的练习(var): 弹窗获取用户的基础信息,信息结果打印在页面上
    let uname = prompt('请输入你的姓名')
    let age = prompt('请输入您的年龄')
    let gender_x = prompt('请输入您的性别')
    document.write(uname)
    document.write(age)
    document.write(gender)

    2.数组的练习(array)：定义一个数组,存放7种水果,控制台打印第三个水果
    let shuiguo = ['苹果', '橙子', '香蕉', '草莓', '西瓜', '菠萝', '蓝莓']
    console.log(shuiguo[2])

    3.表格案列：实现一个用户输入商品数量和地址,js自动计算表格并将结果打印到页面上.
    涉及知识点：字符模板串：${}
    let pricd = +prompt('请输入商品数量')
    let address = prompt('请输入您的地址')
    let total = 1999 * pricd
    document.write(`
        <h2 class="navone">订单确认</h2>
        <table>
            <tr>
                <th>商品名称</th>
                <th>商品价格</th>
                <th>商品数量</th>
                <th>总价</th>
                <th>收获地址</th>
            </tr>
            <tr>
                <td>小米收手机青春版plus</td>
                <td>1999元</td>
                <td>${pricd}</td>
                <td>${total}</td>
                <td>${address}</td>
            </tr>
        </table>
    `)

    4.比较符练习: 用户输入一个数值,判断是否能被4整除同时不能被100整除。
    let number = +prompt("请输入一个数值")
    if ((number % 4 === 0) && (number % 100 !== 0)){alert("数值符合条件")}else{alert("数值不符合条件")}

    5.比较符案列：用户输入高考成绩,分数大于700,弹窗输出""拟录取"否则"已滑档"
    let grades = +prompt("请输入您的高考成绩")
    if(grades >= 700 ){alert("拟录取")}else{alert("已滑档")}

    6.比较符案列：用户输入年份，判断是为闰年还是为平年,弹窗输出。
    let year = +prompt("请输入年份")
    if ((year % 4 === 0) && (year % 100 !== 0) || (year % 400 === 0)){alert(year + "为闰年")}else{alert(year + "为平年")}

    7.比较符案列：根据输入的不同成绩，反馈不同的评价(优秀/良好/及格/不及格)
    let grades = +prompt("请输入您的成绩")
    if (grades >=90 && grades <= 150){"您的成绩优秀"}else if(grades >= 70 && grades <= 89.9) {"您的成绩良好"} else if (grades >= 60 && grades <= 69.9) { "您的成绩及格" } else if (grades >= 0 && grades <= 59.9) {alert("您的成绩不及格")}else if (grades >=150.01 ||grades <=0.09 ||grades === null ||grades === NAN){alert("请输入有效数值")}

    8.判断式案列(三元运算)：用户输入一个值，数值小于10则为数值前面补0
    let time = +prompt("请输入一个0-60的数值决定时")
    let divide = +prompt("请输入一个0-60的数值决定分")
    let second = +prompt("请输入一个0-60的数值决定秒")
    time = time < 10 ? '0' + time : time
    divide = divide < 10 ? "0" + divide : divide
    second = second < 10 ? "0" + second : second
    let times = time + " : " + divide + " : " + second
    alert(times)

    9.判断式案列(switch)：用户输入两个数，然后输入计算符号,自动输出计算结果
    let number = +prompt("请输入要计算的第一个数值")
    let number2 = +prompt("请输入要被计算的第二个数值")
    let noperator = prompt("请输入要进行的计算方式,可选(+)(-)(*)(/)")
    let outcome = 0
    switch (noperator) {
        case "+":
            outcome = number + number2
            break
        case "-":
            outcome = number - number2
            break
        case "*":
            outcome = number * number2
            break
        case "/":
            outcome = number / number2
            break
        case null:
            alert("空值,请检查您的计算符号是否输入正确")
        case Number:
            alert("出错,请检查您的计算符号是否输入正确")
            default:
    }
    alert(number + " " + noperator + " " + number2 + " " + "=" + " " + outcome)

    10.循环练习(while)：标准的模板(需要包含:变量起始值,终止条件,变量的变化量)
    let i = 1
    while(i <= 10){
        console.log("我要月薪过万！")
        i++
    }

    11.循环练习(while): 计算从1加到100的总和并输出控制台[结果应该为5050]
    let i = 1 
    let sum =0
    while (i <=100){
        sum= sum + i
        i++
    }
    console.log(sum)

    11.循环练习(while): 计算1-100之间的偶数和[结果应该为2500]
    let i= 1
    let sum = 0
    while (i<=100){
        if (i % 2 ==0){
            sum =sum+i
        }
        i++
    }
    console.log(sum)

    12.循环练习(while): 页面弹出对话框"你爱我吗?",输入"爱",则结束,否则一直弹.
    注：小依的练习包含创意性改造,您可以通过AI简化下面内容以明确具体逻辑哦。
    let love = String(prompt("你爱我吗？可选值:'爱','不爱'",))
    let i = 1
    let L = /(对不起|抱歉|错了|原谅|有意|)/
    let N =false
    while (i <= 50 && T == true) {
        if (love === "爱") {
            alert("真的吗？我也爱你(开心！)")
            break
        }
        if (love === "不爱" ) {
            love = String(prompt("真的不考虑一下吗？",))
            continue
            T = false
        }
        if (typeof love === 'number' || love === undefined) {
            love = String(prompt("你只能输入'爱'或者'不爱'哦~",))
            T = false
        }
        if (i >= 5 && love === "不爱") {
            love = String(prompt("哼~！不爱就不爱，再也不理你啦！",))
            alert("...")
            while (N == true) {
                str = prompt("对方生气了！小浏建议你反思一下哦，年轻人不要太烦反骨,有时候顺从一次也不会损失什么哒！快向她道歉吧。")
                if (L.test(str)) {
                    alert("好吧,我原谅你了...所以,..你爱我吗？")
                    N = true
                    break
                }
            }
            T = false
            break
        }
        i++
    }

    13.循环练习(while): 用户可以选择存钱,取钱，查看余额和退出功能
    let t = 0
    let balance = 0
    let balance_c = 0
    let balance_q = 0
    while (true) {
        t = +prompt("您要进行何种业务? 1.存钱 2.取钱 3.查看余额 4.退出")
        switch (t) {
            case 1:
                balance_c = +prompt("请输入您要存钱的额度")
                balance = balance + balance_c
                alert(`"已存入${balance_c}元"`)
                break
            case 2:
                if (balance != -balance) {
                    balance_q = +prompt("请输入您要取钱的额度")
                    balance = balance - balance_q
                } else if (balance == -balance) {
                    alert("您的余额不足")
                } else {
                    alert(`"已取出${balance_q}元"`)
                }
                break
            case 3:
                alert(`"您的余额为${balance}元"`)
                break
        }
        if (t == 4) {
            alert("感谢您的使用，再见！")
            break
        }
        if (t != 1 || t != 2) {
            alert("感谢您的使用，再见！")
            break
        }
    }

    14.循环练习(for): 利用for循环输出1-100岁/求1-100之间所有偶数/打印数组
    循环输出1-100岁:
    for (let i = 1; i <= 100; i++) {
        document.write(`"${i}岁"`)
    }
    求1-100之间所有偶数:
    t = 0
    for (let i = 1; i <= 100; i++) {
        if (i % 2 == 0) {
            t = t + i
        }
    }
    alert(t)
    打印数组：
    let array = [1, 33, 44, 55, 66,1000000000000]
    for (let i = 0; i <= array.length -1; i++) {
        alert(array[i])
    }



—————————————————————————————————————————————————————————————————————————————————————————————————————————————

|//项目目录:-------------------------------------------------------------------------------------------------
|
资源库正在整理中,等待更新...
|//End-------------------------------------------------------------------------------------------------------

# //---------------------------------------------------------------------------------------------------------
|项目"我的第一个网页"|环境"HTML>"|引用"HEX.CSS"|练习内容"Var,Couse,Let"

|//End-------------------------------------------------------------------------------------------------------