ECMA
关于js
1.什么是js（JavaScript）：轻量级的脚本语言
2.能做什么：交互，行为
3.js包含：
a.核心（ECMAScript）
b.Dom（Document Object Model）文档对象模型
c.Bom（Browser）浏览器对象模型
（一）js的引入方式
1.直接在标签里写js代码
<!--<div οnclick="js代码"></div>-->
<div onclick="alert('我被点了')">点我</div> <!--所有on开头的属性 事件名称-->
2.a标签引入（需要在href里面写js代码）
<a href="javascript:alert('hahahaah')">a标签点击</a>
3.内嵌（body的最后一个子元素）
4.外联
<script src="demo1.js"></script>
（二）页面输出
1.弹框输出，浏览器弹框
alert("弹框内容")
2.控制台输出
console.log("内容")
3.页面输出
document.write(<br/><h1>页面输出的内容</h1>)
(三) 变量
<script>
//备注
/*多行注释*/
</script>
变量
1.什么是变量
容器，能随时改变得量
2.为什么用变量？
1341156用一个容器把它装起来更方便
<script>
//3.如何定义容器（申明变量的方式）
//关键词 var 变量名;
var shuibei=""
//关键词 let 变量名; es6
let a="";
</script>
变量命名规范：
1.命名必须以字母、下划线(_)、$开头
2.变量名中不允许使用空格和其他标点符号，首字母不能是数字
3.不能出现中文
4.驼峰命名法 shuiBei （css中一般这样写：shui-bie）
5.不能使用关键词 myIf
4.容器内可以装什么？
任何东西都可以装，在程序中装的所有的东西称之为数据
数据
基本数据类型（重点）：
1.number：数值 1111111
2.string：字符串 "111111" 打了引号的都是字符串
3.boolean：布尔值 true/false
4.null：空
5.undefined：未定义(let shuibei;没装东西，未初始化)
引用数据类型（知道）：
1.object 对象
2.array 数组
3.function 函数
<script>
//数字
let myNum=123; //申明变量的同时为它赋值
let myNum2;
myNum2=333;
//字符串
let myStr="11111";
myStr="hello";
myStr="你好";
console.log(myStr);
//布尔值
let myBoolean=true;
//空
let myNull=null;
//未定义
let myUnde=undefined;
//检测数据类型 typeof（可以查看变量的数据类型）
console.log(typeof myUnde)
console.log(typeof myNull) //object
console.log(typeof myBoolean)
console.log(typeof myNum2)
console.log(typeof myStr)
</script>
运算符
1.算数运算符：+ 减- 乘* 除/ 取余%
<script>
//取余（取模）
// console.log(10%3); //1
//乘法、除法
// console.log(null*100); //null转0
// console.log(undefined*100) //undefined转NaN（Not a Number不是一个数字）
//减法
// console.log(100-100);
// console.log(100-"100"); //会将字符串转成数字再进行运算（隐式转换）
// console.log(true-"100"); //true转1，false转0
//加法
// console.log("100"+100); //字符串：100100
// console.log(100+45); //数值：145
// console.log(null+100); //数值：100
// console.log(null+"100"); //字符串：null100 只要看到""都是做字符串拼接
</script>
2.比较运算符：< > <= >= != == !== ===
==和===的区别：==只比较值，===既要比较值又要比较数据类型
<script>
// console.log(100=="100") //true
// console.log(100==="100") //false
// console.log(100!=="100") //true
</script>
3.逻辑运算符：并且&& 或者|| 取反(非)！
<script>
// console.log(!true); //false
// console.log(!(5>3)); //false
// console.log(!(5>3&&5<6)); //false
// console.log(5<3&&5<6); //false &&运算符两边的表达式都成立才是true
// console.log(5<3||5<6||6>1) //true ||运算符两边有一边满足表达式则是true
</script>
4.一元运算符(有1个操作数)：++ --
<script>
//++在后（先赋值后运算）
// let b=2;
// console.log(b++); //输出2 b变成3
// console.log(b--); //输出3 b变成2
//
// let c=b++; //输出2 b变成3
// console.log(c); //2
// console.log(b); //3
//++在前（先运算后赋值）
// let d=3;
// let n=++d;
// console.log(n); //4
</script>
5.二元运算符(有2个操作数)：
a+b
a/b
之类的
6.三元运算符(3个操作数)：
<script>
// let sex="男";
// sex==="女"?alert("可爱"):alert("脸红")
</script>
7.赋值运算符：= += -= *= /=
<script>
let a=13;
a+=2; //a=a+2 15
console.log(a)
a-=1; //a=a-1 14
console.log(a)
</script>
数据类型的转换
undefined
number
string
null
boolean
1.转数值
<script>
// (1)parseInt（第一个值开始转换，如果第一个值不能转换为数字则结果为NaN。如果可转则一个一个依次转为数字，直到不能转换为止，但是它只转换小数点之前的数字。）
// let a="a6.2哈哈a";
// let b="6.2哈哈a";
// console.log(parseInt(a)); //NaN
// console.log(parseInt(b)); //6
// (2)parseFloat（别的都和parseInt一样，唯一区别就是可以转小数）
// let e="12.561adf";
// console.log(parseFloat(e)); //12.561
// (3)Number（首字母大写，不是一个一个转，必须整体是一个数字才可以转，否则结果为NaN）
// let c="19";
// console.log(Number(c)); //19
//判断是否NaN（ isNaN() ）
// let d="15a";
// console.log(isNaN(d)); //true
</script>
2.转字符串
<script>
//String
// let a=true;
// let b=5;
// console.log(String(a));
// console.log(String(b));
//
// console.log(true+"nvsnvsl"); //也是转字符串，不规范
</script>
3.转布尔值
<script>
//Boolean（除了""会转成false，别的字符串都会转为true；除了0会转为false，别的数字都会转为true）
// console.log(Boolean("乱写点啥都是true")); //true
// console.log(Boolean("")); //false
// console.log(Boolean(" ")); //true
// console.log(Boolean(43)); //true
// console.log(Boolean(0)); //false
</script>
了解转义符
<script>
//转义字符
// document.write("哈哈哈\n嘻嘻嘻\n嘿嘿嘿"); //转不了
// alert("哈哈哈\n嘻嘻嘻\n嘿嘿嘿");
// console.log("哈哈哈\n嘻嘻嘻\n嘿嘿嘿");
</script>
隐式转换
<script>
let num1=true;
let num2="true";
console.log(true=="1"); //true
/*
*在比较运算中，如果有一个操作数是布尔值，先将布尔值转为 true转1，false转0
* */
console.log(NaN==NaN); //无法比较false
</script>
转义符
编程三大结构
1.顺序结构（代码原始顺序，自上而下顺序执行）
2.选择（分支）结构
单分支：
if(条件){ <!--条件：true/false-->
如果条件成立执行里面的内容
}双分支：
if(条件){
执行语句1
}else{
执行语句2
}
多分支：
if(条件){
执行语句1
}else if(条件2){
执行语句2
}else if(条件3){
执行语句3
}
......
else{ <!--不是必须的-->
执行语句
}
switch case（一般需要搭配break使用，用来跳出只执行当前语句）
switch(变量){
case 值:执行语句1;
case 值2:执行语句2;
case 值3:执行语句3;
......
default:执行默认语句
}
3.循环结构
结构：
for(表达式1;表达式2;表达式2){
循环体
}
表达式1：循环变量初始化
表达式2：条件判断（哪里结束）会得到布尔值
表达式3：循环变量的改变（如何循环）
单分支选择结构
<script>
/*单分支*/
// let a=-10;
// if(a<0){ //true
// alert("a是"+a);
// }
// alert("程序结束");
/*双分支*/
// let a=10;
// if(a>=0){
// alert("大于等于0")
// }else{
// alert("小于0")
// }
/*多分支*/
// let grade=80;
// if(grade>=60&&grade<70){
// alert("D")
// }else if(grade>=70&&grade<80){
// alert("C")
// }else if(grade>=80&&grade<90){
// alert("B")
// }else if(grade>=90&&grade<=100){
// alert("A")
// }else{
// alert("其他")
// }
//单分支、多分支、双分支，只会选择其中一个执行
//多分支如果条件都满足的话，只会执行最前面一条满足的条件
/*多个if：依然是单分支，只要条件满足就执行*/
// let a=50;
// if(a<100){
// alert("a<100")
// }
// if(a==50){
// alert("a==50")
// }
// if(a>49){
// alert("a>49")
// }
// let a=prompt("输入数字"); //6，通过输入框拿到的数据类型是字符串
// console.log(a);
// console.log(typeof a);
//
// console.log(a===6); //全等：false及比较类型也比较值
let day=prompt("请输入今天是星期几：");
// switch (day){
// case "1":alert("今天星期1");break;
// case "2":alert("今天星期2");break;
// case "3":alert("今天星期3");break;
// case "4":alert("今天星期4");break;
// case "5":alert("今天星期5");break;
// case "6":alert("今天星期6");break;
// case "7":alert("今天星期7");break;
// default:alert("输入错误！！！");
// }
// if(day==="1"){
// alert("星期1")
// }else if(day==="2"){
// alert("星期2")
// }
// ......
// else {
// alert("输入错误")
// }
</script>
if的嵌套
<script>
/*1.如果是女的才考虑
* 白？
* 富？
* 美？
* 我要！
* */
let an1=prompt("是不是女的？ 1.是 2.不是");
if(an1==1){ //女的
let an2=prompt("白吗？1.白 2.不白");
if(an2==1){ //女=>白
let an3=prompt("富吗？1.富 2.不富");
if(an3==1){ //女=>白=>富
let an4=prompt("美吗？1.美 2.不美");
if(an4==1){ //女=>白=>富=>美
alert("我要！！！");
}else{
alert("女生白富美！！！");
}
}else{ //女=>不富
alert("不富");
}
}else{ //女=>不白
alert("不白");
}
}else{ //男的
alert("男的");
}
</script>
循环基本结构
<script>
// for(let i=0;i>100;i++){
// document.write("下次一定")
// }
/*
* 1.申明循环变量，进行变量初始化（只执行一次） let i=0
* 2.判断条件 i>100
* 3.执行循环体内容 document.write("下次一定")
* 4.循环变量的改变 i++
* 5.再次进入条件判断 i>100
* 6.执行循环体内容 document.write("下次一定")
*
* 反复执行4-6的步骤
*/
//道歉不知道是否被原谅，需要一直道歉，1.不原谅 2.考虑一下 3.原谅了
// for(let i=1;true;i++){
// let a=prompt("原谅了吗？1.不原谅 2.考虑一下 3.原谅了" )
// if(a==1){
// document.write("下次一定改正，第"+i+"次道歉")
// }else if(a==2){
// continue; //本次循环不执行，后面的代码同样不执行
// document.write("考虑一下，第"+i+"次，休息一下")
// }else if(a==3){
// document.write("原谅了，第"+i+"次，原谅你了")
// break; //跳出本层循环
// document.write("break后面的代码不执行了")
// }
// }
//求1加到100的总和
let sum=0;
for(i=1;i<=100;i++){
sum=sum+i;
}
console.log(sum)
</script>
while循环、循环嵌套
while循环
<script>
//先验证后循环
// for(i=0;i<0;i++){
// console.log("执行吗？")
// }
/*
while循环（先验证后循环）
while(条件){
循环体
}
*/
// let c=1;
// while(c<=3){
// console.log("c小于3");
// c++;
// }
/*
先循环后验证（不管条件是否满足，至少先执行一次）
*/
// let c=5;
// do{
// console.log("祝我发财！！！");
// c++;
// }while(c<=3)
//死循环
// for(let a=0;a>=0;a++){
// console.log("出不去")
// if(a>50){
// break;
// }
// }
</script>
循环嵌套
<script>
/*
//第一行
for(let i=0;i<50;i++){
document.write("*");
}
document.write("<br>");
//第二行
for(let i=0;i<50;i++){
document.write("*");
}
document.write("<br>");
*/
// for(let j=0;j<5;j++){
// for(let i=0;i<50;i++){
// document.write("*");
// }
// document.write("<br>");
// }
//跳出多层循环
//可为每层循环做标记，break跳出指定标记层，如：break one
one:
for(let i=1;i<=9;i++){
two:
for(let j=1;j<=i;j++){
if(i==5){
alert(i+"跳出多层循环")
break one;
}
}
alert(i+"测试是否跳出成功")
}
</script>
数组
1.什么是数组？
是一个连续的存储空间
数组是用来装数据的，可以装多个数据，并且可以装任意数据类型
2.如何创建数组
（字面量方式创建数组）：
let arr3=[];
let arr4=[1,true,"dcdc",undfinde];
数组的长度：arr.length
数组的下标是从0开始的
数组的循环（遍历）
（通过new创建数组）
let arr1=new Array(); //创建一个空数组
let arr2=new Array(132,6,"acd",null,undefined,true); //创建数组的同时进行初始化赋值
let arr5=Array(6); //new可省略，创建数组，并设置数组长度
3.数组的方法（记忆）
（1）添加：
（通过赋值添加数据）：通过下标赋值的方法向数组添加内容：arr[1]="a";
（通过数组提供的push方法添加数据）：let a="b"; arr3.push(a); 或者 arr3.push(数据);
（2）删除：
arr.pop(); //从后往前删
arr.shift(); //从前往后删
arr.splice(起始下标,删除几个); //删除指定的内容
（3）替换：
（通过下标重新赋值替换）：
arr[0]="1";
arr[0]="hello";
arr.splice(起始下标,删除几个,要替换的内容)
（4） 插入：（不删除原有内容，插入新的数据） arr.splice(起始下标,0,插入的内容)
（5）合并：（合并之后会返回一个新数组，原有数组不受影响） arr.concat(arr3)
push，splice，concat都可以向数组添加数据，区别？
push向数组最后添加数据，会改变原有数组长度
splice向数组的指定位置添加数据，会改变原有数组长度
concat返回一个新的数组，不会改变原有的数组
（6）抽取/截取：（截取之后会返回一个新的数组，不会改变原有的数组） arr.slice(起始下标(包含),结束下标(不包含))
（7）数组的串联：（返回一个字符串，不会改变原有的数组） 数组.join(连接符)
[1,2,3] 变成 1连接符2连接符3
（8）数组的反转：数组.reverse()
（9）清空数组：
arr=[];
arr.length=0;
arr.splice(0,arr.length);
（10）复制（注意：堆-栈中的地址指向问题，见4.堆栈html）：重新申明一个数组，循环复制，不要直接赋值
4.Math对象
js原生内置对象，主要提供一些常用的数学方法和计算
1）随机数： Math.random() 拿到的是[0,1)之间的随机数
其它区间公式（注意根据需求是否要包含下限）： 随机数*(大数-小数)+小数
2）四舍五入：Math.round(5.5)
数组的方法
<script>
// var a=1;
// let b=1;
// let c=3;
let arr=[1,true,"dcdc",null,undefined,3];
console.log(arr); //整个数组
console.log(arr.length); //数组长度
console.log(arr[0]); //第0位
//遍历数组
for(let i=0;i<arr.length;i++){
console.log(arr[i])
}
let arr1=new Array(132,6,"acd",null,undefined,true);
console.log(arr1.length);
console.log(arr1[0]);
let arr2=Array(5); //只有1个值的时候代表数组长度（new可省略）
console.log(arr2); //空数组
console.log(arr2.length); //数组长度：5
console.log(arr2[0]); //undefined
//已知长度把值存进去
for(let i=0;i<arr2.length;i++){
arr2[i]=i;
}
console.log(arr2);
//添加arr.push()，在最后添加
arr2.push("a");
console.log(arr2);
//删除arr.pop()，从末尾往前删1个
arr2.pop();
console.log(arr2)
//删除arr.shift()，从开头往后删1个
arr2.shift();
console.log(arr2)
//删除arr.splice()，指定位置，删除几个
arr2.splice(1,2)
console.log(arr2)
//替换
arr2[0]="下标重新赋值替换"
console.log(arr2)
//替换arr.splice()
arr2.splice(1,1,"hello")
console.log(arr2)
//插入arr.splice()，删除0个
arr2.splice(1,0,"哈哈哈哈")
console.log(arr2)
//合并arr.concat(arr3)，会返回一个新数组，原有数组不会影响
let arr3=["嘿嘿嘿"];
let newArra=arr2.concat(arr3)
console.log(newArra)
console.log(arr2); //原有数组不会影响
console.log(arr3);
//截取，截取之后会返回一个新的数组，原有数组不会影响
let arrNew=arr2.slice(1,3);
// let arrNew=arr2.slice(1,-1); //负数就是反着数-1开始
console.log(arrNew);
console.log(arr2); //原有数组不会影响
//数组的串联
let str=arr2.join("+");
console.log(str);
console.log(typeof str);
console.log(arr2);
//数组的反转
console.log(arr2.reverse())
//清空数组
// arr2=[]
// console.log(arr2)
//
// arr2.length=0;
// console.log(arr2)
arr2.splice(0,arr2.length)
console.log(arr2)
</script>
Math对象
<script>
//随机数
let num=Math.random(); //获取[0,1)之间的随机数
console.log(num)
console.log(parseInt(num*100)); //[0-100)之间
//20-50之间的数（需要注意：根据需求是否需要包含下限）
let num1=parseInt(Math.random()*30+20); //Math.random()*30表示[0,30)的数，+20表示抬高底数，变成[20,50)
console.log(num1)
//四舍五入
console.log(Math.round(5.5)); //6
//向上取整
console.log(Math.ceil(5.01)); //6
//向下取整
console.log(Math.floor(5.9)); //5
//数幂
console.log(Math.pow(2,3)); //2的3次方
//平方根
console.log(Math.sqrt(9)); //3
//绝对值
console.log(Math.abs(-123)); //123
</script>
堆-栈的理解
<script>
//定义一个数组，并给出8个任意的随机初始值
let arr=Array(8);
for(let i=0;i<arr.length;i++){
arr[i]=parseInt(Math.random()*100);
}
//arr2的数组内容和arr一样，怎样正确赋值？
//错误赋值：
// let arr2=arr; //不能修改，改一个另一个也会变化。栈存的是指向堆的地址，arr中的地址给力arr2，所以它们指向堆的同一个地址，所以内容一样
// arr[0]=6; //改的还是arr[0]，但是arr2[0]，也随着改变了
// console.log(arr);
// console.log(arr2);
//正确赋值：
let arr2=[]; //让arr2是一个新数组
for(let i=0;i<arr.length;i++){
arr2[i]=arr[i];
}
arr[0]=6; //这里就只改了arr[0]，没有改arr2[0]的内容
console.log(arr);
console.log(arr2);
let arr6=Array(5); //只是定了它的初始长度，如果后面继续添加也是可以的
arr6[5]=9;
console.log(arr6)
</script>
函数
什么是函数？
可以理解为方法，方法里面有很多步骤。
语法：
1.无参函数：
function 函数名(){
//函数体，要执行的内容
}
调用：函数名()
2.有参函数：
function 吃饭(钱){
去食堂
排队
拿餐盘
打饭菜
给钱
开始吃饭
}
吃饭(100)
钱：形参（可以在函数内部看做是变量来使用，但是函数外部不可用）
100：实参
不给形参接也可以，形参也可以直接在函数内部使用arguments来替代
3.有返回值的函数：
function 函数名(){
return 返回的内容
//return之后的内容都不会被执行
}
4.匿名函数：
function (){
//函数体
}
通常结合变量去使用：
let fun=function (){
console.log("匿名函数")
}
fun();
函数必须调用才会执行，不会自动执行
undefined：未赋值
xx is not defined：变量未声明
全局变量：函数外部的变量，全局都可以随意调用
局部变量：声明在函数内部的变量，它只作用于函数的内部
所有变量尽量放在顶部：局部变量在函数顶部，全局变量在整个js顶部
function
<style>
.div{
color: red;
}
</style>
<script>
//全局变量（放在js顶部）
//局部变量（放在函数内顶部）
//函数的无参\有参：----------------------------------------------------------------//
// for(let i=0;i<10;i++){
// for(let j=0;j<50;j++){
// document.write("*");
// }
// document.write("<br>")
// }
function juxing(gao,kuan){
//形参可以当做变量使用
gao=7;
console.log(gao);
for(let i=0;i<gao;i++){
for(let j=0;j<kuan;j++){
document.write("*");
}
document.write("<br>")
}
}
// console.log(gao,kuan); //函数外部不可用
juxing(10,50)
// juxing(20,100)
// juxing()
// juxing()
//未赋值与未声明：----------------------------------------------------------------//
// let a;
// console.log(a); //undefined
// console.log(b); //b is not defined
//全局与局部变量：----------------------------------------------------------------//
// let a=1; //全局变量，所有的地方都可以调用
// function test(){
// let b=2; //局部变量，只作用于函数内部
// console.log(a); //全局
// }
// console.log(a); //1
// test();
// console.log(b); //局部（函数外部无法获取函数内部的变量）：b is not defined
//函数返回值：----------------------------------------------------------------//
// function sum(){
// return 999
// }
// let c=sum();
// console.log(c)
// function sum(num1,num2){
// let result=num1+num2;
// console.log("2222")
// return result;
// console.log("1111"); //return后面的内容都不会被执行
// }
// let c=sum(22,33);
// console.log(c)
//返回多个结果
function myMath(num1,num2){
let mySum=num1+num2;
let myjian=num1-num2;
// return [mySum,myjian]; //返回个数组
return { //返回个对象
mySum:mySum,
myjian:myjian,
};
}
let obj=myMath(8,1);
// console.log(obj[0]);
// console.log(obj[1]);
console.log(obj.mySum);
console.log(obj.myjian);
//对象的写法：-----------------------------------------------------------------//
// //数组
// let arr=[1,2,3]; //arr[0]
// //对象
// let obj1={
// name:"月月",
// sex:"女",
// age:"23"
// };
// console.log(obj1.name)
// arr=[
// {
// name:"月月",
// sex:"女",
// age:"23"
// },
// {},
// {}
// ]
// console.log(arr[0].sex);
</script>
匿名函数
<script>
//匿名函数
// let fun=function (){
// console.log("匿名函数")
// }
// fun();
//匿名函数-自执行
//括号：()
// (function (){
// console.log("hahaha ")
// })()
//符号: ! + - ~
!function (){
console.log("啊啊啊 ")
}()
</script>
es6-Function
<script>
function fName(){
//函数体
}
//或者
let myFun=function (){
//函数体
}
//es6中的写法：
// let myF=()=>{
// //函数体
// console.log("heheh");
// }
// myF();
//带参
// let myF=(str)=>{
//等同于：
let myF=str=>{ //只有一个参数可以不打括号
//函数体
console.log(str);
}
myF("hahahha");
//有return的
let myFF=aaa=>aaa;
console.log(myFF("给什么就直接返回什么"));
//等同于：
let myFF=(aaa)=>{
return aaa;
}
//等同于：
function myFF(aaa){
return aaa;
}
let a=myFF("嘿嘿嘿");
console.log(a);
</script>
arguments
<script>
// function test(a,b){
// let sum=a+b;
// return sum;
// }
// let result=test(9,9);
// console.log(result)
//形参不确定需要几个来接（对用户传的参数个数没有硬性要求的时候arguments）
function test(){
let sum=0;
console.log(arguments); //arguments是数组
for(let i=0;i<arguments.length;i++){
sum+=arguments[i];
}
return sum;
}
let result=test(9,9,56,48,98);
console.log(result);
</script>
字符串
字符串的创建：
1.字面量方式： let str="字符串";
2.创建字符串对象： let str=new String("123456");
注意：字符串可以遍历，可以读取，但是不能赋值改变其中某个值，唯一能够改变就是重新全部赋值
字符串的方法：
1.str.charAt(下标) 找到字符
2.str.slice(起始下标,结束下标(不包含)) 截取字符串
3.str.indexOf("字符") 字符在字符串中第一次出现的位置
str.search("字符") 可以配合正则表达式使用
4.str.replace(要替换谁,替换成什么) 替换字符串，只能替换找到的首个字符
5.str.split(根据哪个字符来进行分割) 分割字符串（返回的是数组）
6.str.trim() 清空首尾空格
7.str.includes("字符") 是否包含某个字符（会返回布尔值）
<script>
//注意：
// fun(); //函数可在前调
// function fun() {
//
// }
// fun(); //可在后调
// fun2(); //报错（初始化前无法访问"fun2"）：Cannot access 'fun2' before initialization，应该声明变量在前，使用变量在后
// let fun2=function (){
// console.log("hahah")
// }
</script>
字符串方法
<script>
// let str="字符串";
// let str2=new String("字符串");
// console.log(str); //字符串string
// console.log(str2); //字符串对象object
// console.log(str==str2); //true它们的值是相同的。如果===那么就是false数据类型不同。它们都是不可控长度的，都能继续往里面添加内容、属性。
// console.log(str.length)
// console.log(str[0]); //通过下标找到某个指定字符
// str[0]="不"; //字符串可以遍历，可以读取，但是不能赋值改变其中某个值，唯一能够改变就是重新全部赋值
// console.log(str);
//
// for(let i=0;i<str.length;i++){
// str[0]="不";
// //这样也改不了
// }
//字符串的方法：
//1.str.charAt(下标) 找到字符
let str="一个字字符串";
console.log(str.charAt(2));
//2.str.slice(起始下标,结束下标(不包含)) 截取字符串
console.log(str.slice(1,3));
//3.str.indexOf("字符") 字符在字符串中第一次出现的位置
//str.search("字符") 可以配合正则表达式使用
console.log(str.indexOf("字"));
console.log(str.search("字"));
//4.str.replace(要替换谁,替换成什么) 替换字符串，只能替换找到的首个字符
let newStr=str.replace("字符","富")
console.log(newStr)
console.log(str)
//5.str.split(根据哪个字符来进行分割) 分割字符串（返回的是数组）
let str1="你好啊~哈哈哈哈哈~很美好~ ~";
let strArr=str1.split(" "); //是数组
console.log(strArr)
strArr[1]="呵呵呵"; //变成数组后就能够重新赋值
console.log(strArr)
//转换一下：字符串通过分割.split()，转换成数组后，再进行数组的串联.join()，重新变回字符串
console.log(strArr.join(""))
//6.str.trim() 清空首尾空格
let str2=" 哈哈哈哈 "
console.log(str2)
console.log(str2.trim())
//7.str.includes("字符") 是否包含某个字符（会返回布尔值）
let str3="你好啊你在吗";
let str4="啊好";
let str5="在吗";
console.log(str3.includes(str4))
console.log(str3.includes(str5))
</script>
日期对象
<script>
let d=new Date(); //日期对象，系统当前时间
console.log(typeof d); //object，但凡使用了new关键字得到的数据都是object
console.log(d); //Fri Dec 08 2023 12:09:22 GMT+0800 (中国标准时间)
// let d=new Date(2001,0,1,0,0,0); //年月日时分秒，月份是从0开始的
// console.log(d)
console.log("显示系统语言的日期方式："+d.toLocaleString()); //2023/12/8 12:08:51
console.log("获取年份："+d.getFullYear());
console.log("获取月份："+(d.getMonth()+1)); //月份从0开始的
console.log("获取日期："+d.getDate());
console.log("获取星期几："+d.getDay());
console.log("获取时："+d.getHours());
console.log("获取分："+d.getMinutes());
console.log("获取秒："+d.getSeconds());
console.log("获取毫秒："+d.getMilliseconds());
/*
练习：
调用函数，如果向函数传入参数，年月日时分秒，则页面显示传入日期。
如果没有传入参数，则显示系统当前时间。
2010年11月9日11时56分
2022年6月8日14时39分
*/
function myDate(){
// console.log(arguments);
let d=new Date();
if(arguments.length==0){
//没传参
document.write(d.getFullYear()+"年"+(d.getMonth()+1)+"月"+d.getDate() +"日"
+d.getHours()+"时"+d.getMinutes()+"分"+d.getSeconds()+"秒")
}else{
//传了参
document.write(arguments[0]+"年"+arguments[1]+"月"+arguments[2]+"日"
+arguments[3]+"时"+arguments[4]+"分");
}
}
myDate(2010,11,9,11,56)
myDate();
</script>
let与var的区别
<script>
//let（es6中的），var这两个关键词申明变量
//let的作用域在块，不存在变量提升
//var存在变量提升
//例子：
// var a=["a",1,true,null,undefined,{},[],function(){}];
// var a=[];
//
// for(let i=0;i<10;i++){ //i=0
// a[i]=function (){ //a[0]=function(){console.log(0)}
// console.log(i);
// }
// }
//
// //let每一次循环的i都是单独的，var的i混用的
// console.log(a);
// a[0](); //var 10 let 0
// a[1](); //var 10 let 1
//
// console.log(i); //var的i 10
// console.log(i); //let的i i is not defined
// // let hehe;
// function test(){
// // hehe="呵呵";
// hehe="呵呵"; //不写let或var，不声明，全局变量（不过这个全局变量声明在函数的内部而已，要调用函数才能知道函数内部有个全局变量，外部才可以去获取到它）
// }
//
// // console.log(hehe); //hehe is not defined 因为没声明
// // console.log(hehe); //undefined 没调函数所有没赋值
// test();
// console.log(hehe); //呵呵
function test(num){
// console.log(num); //在函数内部可以当做变量使用
if(num!=undefined){
//传了参
var a=9;
}else{
//没传参
let a=3;
console.log("条件判断中a的值："+a);
}
console.log("条件判断外a的值："+a);
}
test(); //3 undefined
test(7); //9
</script>
200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
