2025年javaScript入门基础知识点

javaScript入门基础知识点编程的由来 1 前端 JavaScript 2 后端 java PHP Python Go Node 特殊 计算机软件 编程 计算机为了解决某个问题而使用某种程序设计语言编写代码 并最终得到结果的过程 这个过程我们就叫编程 计算机程序

大家好,我是讯享网,很高兴认识大家。

编程的由来

1、前端:JavaScript

2.后端:java PHP Python Go Node(特殊)

 

计算机软件

编程:计算机为了解决某个问题而使用某种程序设计语言编写代码,并最终得到结果的过程,这个过程我们就叫编程

 

计算机程序:就是计算机所执行的一系列的集合指令,而程序全部都是我们所掌握的语言来编写的,计算机一定是通过计算机语言向计算机发送指令

 

计算机语言

-汇编语言 二进制 0

-机器语言

-高级语言 JavaScript java PHP Python Go Node(特殊)等等

 

计算机数据储存

 

位(bit) 1bit可以保存一个0或者1(最小的储存单位)

字节(Byte) 1B=8b

千字节(KB) 1KB=1024B

兆字节 (MB) 1MB=1024KB

吉字节 (GB) 1GB=1024MB

太字节 (TB) 1TB=1024GB

 

计算机运行程序的过程

1、打开某个程序时,先从硬盘把程序的代码加载到内存中

2、再从CPU执行内存中的二进制

3、把js代码编译成二进制进行执行

 

 

JavaScript祖师爷

布兰登 艾奇 (Brendan Eich) ,设计Javascript 10天完成

原名LiveScript 后改为JAvaScript

 

javascript是什么

1、javascript 是一种运行在客户端的脚本语言,运行在浏览器中

2、脚本语言:不需要编译,运行过程中由 JS 解释器(JS引擎)逐行进行解释并执行

3、javascript 也可以基于Node js 技术进行服务器开发

 

javascript的作用

1、表单动态效验(js最初目的)

2、网页特效

3、服务端开发

4、桌面程序

5、APP

6、微信公众号,小程序开发

7、控制硬件-物联网(Ruff)

8、游戏开发(CoCo2d-js)

js语言它是单进程单线程的语言,一旦报错,后面的代码无法运行

 

前端三大核心

1.html 版本 4.0 5.0

2.css 版本2.0 3. 0

3.javascript 版本 5.0 6.0-10.0

 

javascript 三大核心

1.DOM 文档对象模型

2.BOM 浏览器对象模型

3.ECMAScript javascript核心语法

 

 

javascript三种使用方式

1.行内式

 onclick="alert('我是按钮弹窗')" ​ <button onclick="alert('我是按钮弹窗')">按钮</button>

讯享网

 

2.内嵌式

直接在Html文件中写

讯享网 <script> //声明变量   var a;   // 输入   a=prompt("请输入姓名");   // 弹窗   alert(a);   // 编译器显示   console.log(a);   // 页面显示   document.write(a); </script>

3.外部引入

<script  src="test.js"></script>

 

 

a标签的不跳转

讯享网<a href="javaScript: ;"></a>

 

 

 

javascript注释方式

1.单行注释 //

快捷键ctrl +/

2、多行注释

/* */

快捷键 shift + alt +A

 

什么是变量

1.变量是储存数据的容器,白话就是装东西的盒子

2、变量是储存在内存当中的,本质是程序在内存申请的一块来存放数据的空间

 

3.变量的使用

1.变量的声明 使用关键字 var,ES6有新的 let 关键字

2.变量的赋值 等号的右边的值赋给左边的变量

var 是js 的关键字,用来声明变量,使用关键字声明变量后,计算机会自动分配内存空间,不需要程序管了

var a=10;

javascript 常用单词

1.输入 prompt 弹窗

讯享网prompt('请输入');

括号里的是提示语,有返回值,不输入默认null

 

2,声明变量

var a=10; var a=prompt('请输入'); //声明多个变量 1、var a=10; var b=10; var a=10, b=10;

 

 

声明变量的特殊情况

声明了变量,未赋值, undefined 未定义(声明了变量,但是没有赋值。就叫未定义)

讯享网var d; console.log(d)

 

不声明变量,也不赋值,直接使用会报错

console.log(d)

 

不声明,直接赋值使用,赋值在前,打印输出在后,可以使用

讯享网d=200; console.log(d);

 

变量名的命名规范

由字母,数字,下划 _ 美元符号$组成

不能以数字开头

严格区分大小写

不能是关键字或者保留字

保留字:未来可能成为关键字的单词

变量名必须有意义

遵守驼峰命名法,

小驼峰:第一个单词首字母小写,第二单词首字母大写

userName

大驼峰:所有单词首字母大写

UserName

 

3.输出

控制台输出 console.log(a); console.log( prompt('请输入') ); 页面输出 document.write(a); document.write( prompt('请输入') );

 

 

 

关键字

ECMAScript关键字:

break 结束

case 容器

catch 捕获

continue 继续

default 默认的

delete 删除

do 执行

else 否则

finally 最后

for 因为 --由于

function 运转

if 如果

in 在---之内

instanceof 运算符

new 新

return 返回值

switch 开关

this 这个

throw 投掷

try 试用

typeof 运算符

var 声明变量

void 空

while 虽然

with 由于

 

保留字

ECMAScript保留字:

保留字在某种意义上是为将来的关键字而保留的单词。所有保留字也是不能用作变量名和函数名的。

讯享网abstract    提取 boolean    布尔值 byte   字节 ​ char   字符 class   类 const  常数 debugger   调试器 double   两倍 enum   枚举 export   输出 extends  继承 final      结束 float    浮点 goto    转到 implements    执行 import    输入 int    整数 interface   接口 long    长 native  本地 package    打包 private      私有 protected    保护 public    公共的 short   短暂 static   静止 super   极好的 synchronized   同步 throws       投 transient  临时的 volatile   易变的 ​ ​

 

 

二进制 八进制 十进制 十六进制

二进制:10011

转十进制 1* 2^0+1 *2^1+0 *2^2+ 0 *2^3 + 1 *2^4

 

八进制 :067 0开头(零开头)

转十进制 7* 8^0+6 *8^1+0 *8^2

 

十进制

转二进制 整数除以2,取余,除到最后,倒序写

 

format,png
讯享网

转八进制

 

e8c2df5bb0b61861c35d4c5e89b598f6.png

 

转十六进制

 

46971c9a0b775bd4d0efdd06c7fc1b31.png

 

十六进制 0x464 0x开头(零x开头)

转十进制

4 *16^0 +6 * 16^1 +4 * 16^2

 

 

js变量的数据类型

1.js的基本数据类型

01.字符串(String)单双引号括起来的文本

字符串转义字符,都是用 \ (反斜杠) 开头

换行

var text="晶方科技撒付款,\n 哈哈飞机孔";

转义字符

var text="晶方科技撒付款:\“里边\” ";

 

里面有引号的文本可以采取 外单内双 或者外双内单

var text="晶方科技撒付款:'里边 ' ";

var text='晶方科技撒付款:"里边 " ';

 

 

字符串拼接

var name="zhangsan";

var age=16;

var sex="男";

 

console.log("我的名字叫"+name+" ,"+"年龄"+age+"岁"+",性别"+sex);

任何类型的数据和字符串拼接,最终的结果都是字符串

字符串的长度判断 length

cosole.log(a.length);

 

 

02、数字(Number) 不需要加单双引号

数字分为整数型和浮点型

数字型进制,二进制 八进制 0开头·

十进制 十六进制 0x 开头

数字在js中最大值是1.7976E^308 最小值 5E^-32

数字的三个特殊值

1.Infinity 代表无穷大

2.INfinitesimal,代表无穷小

3.NaN (Not a Number),代表一个非数值 NaN != NaN,它不等于它本身,所以不好做判断

例如:

var a ;

Number( a ) == NaN //false

if( Number( a ) == NaN ){

console.log("请输入数字")

} //即使变量a不是数字,转换为NaN, NaN != NaN,进不去if

 

改为 if( isNaN( a ) ){

console.log("请输入数字")

} //如果变量a不是数字,isNaN( a ) 返回true 可以进去if

 

  1. isNaN() 用来判断一个变量是否为非数值的类型,返回true或者false;

 

03 布尔值 (Boolean)

只有true和false

04 未定义 (Undefined)

声明了变量,但是没有赋值

05 空(Null)

 

 

 

 

判断字符串的类型

第一种写法

var tex="fff";

console.log(typeof tex);

第二种写法

var tex="fff";

console.log(typeof(tex) );

 

其他数据类型转化为字符串类型

强制转换

1.String(其他数据类型)

var num=10;

console.log(typeof String(num) );

 

2.其他数据类型.toString

var num=10;

console.log(typeof num.toString() );

 

3.数字类型转化为二进制,八进制 ,十六进制

toString(2~32)

转化后的进制变为字符串类型

var num=10;

二进制

console.log(typeof num.toString(2) );

八进制

console.log(typeof num.toString(8) );

十六进制

console.log(typeof num.toString(16) );

 

隐式转化

数字加一个空格

console.log( num+"" )

任何数据类型与字符串相加都会变成字符串

 

其他数据类型转化为数字类型

注意:转换字符,数字,布尔类型,首字母必须大写!!!

1.Number(其他数据类型) 强制转换

如果字符串是纯数字(不包含任何非数字字符),可以转化

如果不是,则转化为NaN(非数字),NaN属于Number类型

var str="1234";

var tex="fff1233"

转化为数字

console.log( Number(str) );

console.log( typeof Number(str) );

转化为NaN(属于Number类型的一种)

console.log( Number(tex) );

console.log( typeof Number(tex) );

常见转换

var  tex="12jjj"; ​ console.log(Number(tex));       // NaN ​ console.log(Number(true));       // 1 ​ console.log(Number(false));    //0 ​ console.log(Number(Undefined));    //NaN ​ console.log(Number(null));    //0 ​ console.log(Number("") );    //0 ​ console.log(Number(" ") );    //0

 

 

2.parseInt(变量,进制数) 把字符转换为数字型,得到整数

如果字符串是纯数字或者是数字开头的,可以转换把字符中的字符串中的数字转换成数字,如果不是转换为NaN

2.1、转换顺序是从左往右转的,

如果第一个字符不是数字,就会直接转换成NaN,

如果第一个是数字,就按顺序继续转换,直到碰到非数字,就停止转换,输出前面转换的结果

2.2、第二个参数是进制的数字,正常范围是2-36,为什么是36,它是由26个字母加0-9的10个数字组成。默认为0

2.2.1、特殊情况:

0:如果前面的数字是由0x开头的转换为16进制,由0开头转换为8进制,正常数字转为10进制,非数字转为NaN

1:如果为1,则不管前面是不是数字都转换为NaN

讯享网var  str="12.45"; ​ var  tex="12jjj"; ​ var  re="dd12jjj"; ​ console.log(parseInt(str));       // 12 ​ console.log(parseInt(tex));       // 12 ​ console.log(parseInt(re));       // NaN ​ console.log(parseInt(true));       // NaN ​ console.logparseInt(false));    //NaN ​ console.log(parseInt(Undefined));    //NaN ​ console.log(parseInt(null) );    //NaN ​ console.log(parseInt("") );    //NaN ​ console.log(parseInt(" ") );    //NaN

 

 

 

3.parseFloat(变量) 把字符型转换为浮点数,保留小数

如果字符串是纯数字或者是数字开头的,可以转换把字符中的字符串中的数字转换成数字,如果不是转换为NaN

   var  str="12.45"; ​ var  tex="12.45jjj"; ​ var  re="dd12jjj"; ​ console.log(parseFloat(str));       // 12.45 ​ console.log(parseFloat(tex));       // 12.45 ​ console.log(parseFloat(re));       // NaN ​ console.log(parseFloat(true));       // NaN ​ console.log(parseFloat(false));    //NaN ​ console.log(parseFloat(Undefined));    //NaN ​ console.log(parseFloat(null) );    //NaN ​ console.log(parseFloat("") );    //NaN ​ console.log(parseFloat(" ") );    //NaN ​ ​

 

 

4.利用算术运算 +(2特别注意) 任何类型数据跟字符相加,都是拼接成字符串

console.log("12"+12) //1212

- * / 隐式转换 调用Number() 强制转换

讯享网console.log("14"-12)     // 2 ​ console.log("12"*2)     // 24 ​ console.log("12"/2)     //6 ​ console.log(true-12)     // -11 ​ console.log(false-12)     // -12 ​ console.log(""*12)     // 0 ​ console.log("   "*12)     // 0   ​ console.log(null*12)     // 0 ​ console.log(Undefined-12)     // NaN

 

 

 

 

其他数据类型转化为布尔类型

口诀: 非0 非空(字符串) 非Undefined 非null,都是true

boolean(其他类型)   ​ var  str="12.45"; ​ var  num=0; ​ var  tt="发GV" ​ console.log(Boolean(str));       // true ​ console.log(Boolean(tt));       // true ​ console.log(Boolean(num));       // false ​ console.log(Boolean(45));    //true ​ console.log(Boolean(Undefined));    //false ​ console.log(Boolean(null) );    //false ​ console.log(Boolean("") );    //false ​ console.log(Boolean(" ") );    //true

 

 

 

运算符

 

算术运算符 + - * / %

讯享网console.log(1+1)    //1 ​ document.write("1" + 1)   //11 ​ alert("1"  -  1)    //0 ​ console.log(1*2)    //2 ​ document.write(6 /  2)   //3

 

取余数

alert(7 % 2) //1

 

 

 

 

js设计缺陷

面试题: js中 0.1+0.2===0.3 吗 答案:不等于

解释:js对浮点数的计算有时候会出现溢出的情况

console.log(0.1+0.2) ; //0.

不能拿着浮点数进行比较

 

 

 

 

 

表达式与返回值

var num=1+1;

表达式是指由数字、运算符、变量等组成的式子,称为表达式 1+1

右边的表达式计算完毕会把结果返回给左边,叫做返回值

 

 

 

一元运算符 ++ --

​ a++      相当于   a=a+1 ​ a--       相当于    a=a-1

 

 

 

前置的递增运算符 ++a --a 先运算后赋值

var a=10;

var b= ++a;

console.log(a) // 11

console.log(b) // 11

 

后置的递增运算符 a++ a-- 先赋值后运算

 

var a=10;

var b= a++;

console.log(a) // 11

console.log(b) // 10

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2F%25E5%25B1%258F%25E5%25B9%2595%25E6%2588%25AA%25E5%259B%25BE_20221116_123228.png%3FlastModify%3D1694242997&pos_id=PHonTngb

 

讯享网 var a=10; ​ •    var c=++a; ​ •    console.log(c);      //11 ​ •    console.log(a);    //11 ​ •    var b=a++; ​ •    console.log(b);     //11 ​ •    console.log(a);     //12 ​ •    console.log(b +1 +c);     //23

 

 

 

 

 

比较运算符 > >= < <= == === != !==

console.log(1>3)       //false ​ console.log(1>=3)       //false ​ console.log(1<3)       //true ​ console.log(1<=3)       //true ​ console.log(1==3)       //false ​ console.log("3"==3)       //true ​ console.log("3"===3)       //false ​ console.log(1  !=  3)       //true ​ console.log("3" !== 3)       //true ​ console.log("3" != 3)       //false

 

 

双等和三等的区别:双等只判断他们的值是否相等(把字符串的数据类型转换成数字类型去比较),三等需要判断值和数据类型是否相等。

 

特殊情况 null和undefined是转换成布尔值进行比较

console.log( null == undefined ) //true

console.log(null === undefined ) //false

 

console.log( null != undefined ) //false

console.log(null !== undefined ) //true

 

 

 

逻辑运算符 && 与 || 或 !非

 

优先级: () > ! >&& > ||

所以比较时先看 括号内 在看 ! 再看 && 最后看 ||

console.log(9<9 && 7<8 || 0 && 3>2 || 0 && 3>4 || 5>2) //true

false false false true

&& and 两边的表达式都为真,即为真,如果一个假,即为假

 

 

|| or 两边的表达式都为假,即为假,如果一个真,即为真

 

! 取反

console.log( !true ); //false

 

逻辑运算符的短路现象

&& 会出现短路现象 ,为假时,最终输出的值会获取第一个false的值。为真时,最终输出的值会获取最后一个为true的值。

为假时

console.log(0 && 1+2 && 10*2); //0

console.log(10 && 1+2 && 10*2 &&0 && 2); //0

为真时

console.log(1 && 1+2 && 10*2); // 20

 

|| 会出现短路现象 ,为真时,最终输出的值会获取第一个true的值。为假时,最终输出的值会获取最后一个为false的值

为真时

console.log(0 || 1+2 ||10*2); // 3

console.log(10 || 1+2 || 1>5 || 0 || 2); // 10

为假时

console.log(1>3 || 1<0 || 0 ); // 0

console.log(1>3 || 1<0 || 0 ||1+2 ); // 0

 

 

 

 

赋值运算符 (二元运算符)= += -= *= /= %=

 

var a+=5 ; //相当于a=a+5

var a-=5 ; //相当于a=a-5

var a * =5 ; //相当于a=a * 5

var a/=5 ; //相当于a=a / 5

var a%=5 ; //相当于a=a % 5

 

 

算术 比较 逻辑 递增/递减 赋值 运算符的优先级

 

分组 ( ) > 后置递增/递减 >逻辑非 (!) > 一元加法(+)/减法(-) > 前置递增/递减 > 乘、除、余 > 加、减 > 逻辑运算符 > 赋值运算符

 

 

 

分支语句 if else

if语法 条件表达式为true,执行语句块1,false执行语句块2

条件表达式中不要出现=,=为赋值,==或者===,才是比较

if(条件表达式){

语句块1;

}else{

语句块1;

}

例题

判断输入是字符串还是数字

if( isNaN(num) ){

alert("输入错误,请输入正确年份")

}else{

if (year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) {

alert(year+"是"+"闰年");

} else {

alert(year+"是"+"平年");

}

}

判断用户输入的数字是不是年龄还是年份

1.用字符长度判断 年龄字符长度在1-3,年份字符长度为4

2.年龄在200以内 年份在1000以上

3.&& 与 输入的数字>=18 && (2022-输入的数字)>=18

 

 

 

多分支判断语句

if( ){

}else if( ){

}else if( ){

}else{

}

1.多选一,只能执行一个

2.else if(){} 可以写多个

3.else if 用空格隔开

讯享网<script>       var mon = prompt("请输入星期数:1,2,3,4,5,6,7");       if (isNaN(mon)) {            alert("请输入数字1--7");       } else {            if (mon == 1) {                alert("今天星期"+mon+",监督邹志进跳舞");           } else if (mon == 2) {                alert("今天星期"+mon+",监督邹志进唱歌");           } else if (mon == 3) {                alert("今天星期"+mon+",监督邹志进喊方艳文爸爸");           } else if (mon == 4) {                alert("今天星期"+mon+",打邹志进");           } else if (mon == 5) {                alert("今天星期"+mon+",打邹志进");           } else if (mon == 6) {                alert("今天星期"+mon+",打邹志进");           } else if (mon == 7) {                alert("今天星期"+mon+",打邹志进");           } else {                alert("没有此星期数,请输入数字1--7");           }       }            </script>

 

 

 

 

三元运算符 (表达式) time<10?'0'+time:time;

1.一元运算符 ++ --

2.二元运算符 += -= *= /= %=

3.三元运算符

var   num=10; ​ var   re=  num>5?"是的“:"不是的"; ​ alert(re);        //是的 ​ ​ ​ var  time = prompt("请输入0—9之间的数字"); ​ var times=time<10?'0'+time:time; ​ alert(times);        //输入1,输出01

 

 

 

 

Switch分支语句

讯享网Switch(表达式  ||  固定值){ ​ •       case   value : ​ •                 执行语句1; ​ •                  break; ​ •      case   value : ​ •                 执行语句2; ​ •                  break; ​ •       case   value : ​ •                 执行语句3; ​ •                  break; ​ •        default: ​ •                 最终语句; ​ •                  break; ​ }

 

注意事项:

1.case 里面匹配的value值的时候,是做的完全相等的匹配(值和类型都要相等)

2.case 里面匹配的value值是单个类型,不能使用逻辑运算

 

 

if else 和 switch case的区别?

1、if支持逻辑运算和固定值,switch只支持固定值,所以当只有固定值时就用switch

2.switch能实现的if都能实现,if能实现的,switch不一定能全部实现。

 

 

for 循环

for 语法

for(初始变量;条件表达式;操作表达式){

循环语句(执行语句);

}

 

1.初始变量,就是用var声明一个普通的变量,通常用作计数器使用

先执行计数器变量

 

2.条件表达式,就是用来决定每一次循环是否继续,就是终止条件(注意不要出现死循环)

再进行条件判断,为true时进入循环体,为false时跳出,

 

3.操作表达式 是每次循环最后的执行的代码,通常用于我们计数器变量进行递增或者递减的操作

最后执行操作表达式,进行变量的递增或递减,第一轮循环结束,再来一轮,直到条件表达式不成立,跳出循环。

 

i为一个三位数,取个位数parseInt(i%10) 取十位parseInt( i%100/10) 取百位parseInt(i/100)

注意:直接计算的除法得到的值为真实值,值为小数时需要用parseInt() 转换为整数型。 3/2=1.5 parseInt(3/2)=1;转换不遵循四舍五入,直接取整。

 

for循环特殊情况

1.for循环也可以把变量放在外面,操作表达式写在循环体内,但是格式不变,分号也要打出来

var i=0

for( ; i<0 ; ){

i++;

}

 

2.for循环上面打印得到的是undefined, for循环下面打印得到的是不满足条件表达式的最后的值 。

 

console.log(i); //undefined

for(var i=0 ; i<10;i++){

 

}

console.log(i); //10

 

 

 

 

双重for循环

for(var i=0 ; i<10;i++){

for(var j=0 ; j<10;j++){

}

}

 

1.外层for循环一次,里面for循环执行一遍

2.两个for循环声明的变量不能相同

 

 

 

 

while循环

声明变量 ​ while(条件表达式){ ​ •     循环体 ​ •      递增/递减 ​ } ​ ​ ​ var i=1; ​ var sum=0; ​ while (i<=100){ ​ sum +=i; ​ i++; ​ }

 

 

 

while循环与for循环的区别

1.while循环把初始变量声明在外面,操作表达式写在循环体内,容易造成死循环

 

2.for循环也可以把变量放在外面,操作表达式写在循环体内,但是格式不变,分号也要打出来

var i=0

for( ; i<0 ; ){

i++;

}

 

3.for循环上面打印得到的是undefined, for循环下面打印得到的是不满足条件表达式的最后的值 。

 

console.log(i); //undefined

for(var i=0 ; i<10;i++){

 

}

console.log(i); //10

 

 

 

 

 

do while循环

 

do{

console.log("不管条件成不成立,都会执行一次);

}while(表达式);

 

 

do while循环与while循环的区别

1、do while 先执行一次,再判断条件,如果条件表达式结果为真则继续执行循环体,否则退出循环。 while 是先判断条件表达式是否为真,后执行。

 

 

 

循环的关键字

 

break 终止

执行到break时,跳出循环,不执行循环操作

 

 

continue 继续

执行到continue时,跳出本次循环,继续执行下一次循环

 

 

 

获取表单的值 input.value

获取表单的值

input.value

 

表单事件:oninput

表单输入的时候实时触发,获取表单的值

讯享网<body> ​  <input type="text" class="inp">  <script>   var inp=document.getElementsByClassName("inp") ​ // 表单事件:实时获取值 ​ inp[0].οninput=function (){ ​ •    console.log(inp[0].value) ​ } ​  </script> </body> ​

 

 

 

表单改变事件:onchange

表单输入完成时失去焦点后触发,获取表单的值

<body> ​  <input type="text" class="inp">  <script>   var inp=document.getElementsByClassName("inp") ​ // 表单改变事件 失去焦点获取值 ​ inp[0].onchange =function (){ ​ •    console.log(inp[0].value) ​ } ​  </script> ​ </body>

 

 

 

2,复杂数据类型

06.Object 它是泛指js中的一切对象

1.数组 Array

数组:就是一组数据的集合,存储在单个变量中

var arr = [1,2,3,"s","aesdfs",true] ;

创建数组的几种方式

1.利用new 创建数组

注意:使用new Array() 创建数组时,如果只有一个数字,则表示创建了一个这个数字长度的空数组

 

var arr= new Array() ; 创建了一个空数组 [ ]

 

2.利用数组的字面量创建数组

 

var arr = [ ]; 创建了一个空数组 [ ]

 

数组的使用方法

1.数组里面的数据一定要用逗号分隔,比如下面的数组里的1,2,3,我们称为数组元素

 

2.获取数组元素 格式 数组名[索引号] 索引号都是从0开始的

 

3.如果数组中没有这个元素,输出的结果为undefined

 

var arr2 = [1,2,3] ;

console.log( arr[0] ) // 1

console.log( arr[5] ) // undefined

 

 

 

遍历数组

1.因为数组的索引是从0开始

讯享网 var arr=[1,3,2,4,"d","fd"]; //arr.length动态监测数组元素的个数,不要跟索引号混淆 for(var i=0;i<arr.length;i++){ ​ //输出的时候,使用 数组名[ 索引号] 获取遍历的元素 console.log(arr[i]); }

 

 

分隔数字与字符

  var arr=[1,3,2,4,"d","fd",5,8];    var str=[];    var num=[];    for(var i=0;i<arr.length;i++){ ​ •      if(typeof(arr[i]) === "number"){ •        num[i]=arr[i]; •     }else if(typeof(arr[i]) === "string"){ •        str[i]=arr[i]; •     }else{ •        console.log("不属于数字和字符"); •     } •   } •    console.log("数字:"+num); •    console.log("字符:"+str); ​ ​

 

 

求最大值

讯享网  var arr=[23,34,88,111,55,32];    var max =arr[0];    for(var i=1;i<arr.length;i++){      if (arr[i]>max){        max=arr[i];     }else{        continue;     }   } ​ console.log( "最大值:"+max);

 

 

 

求最小值

 var arr=[23,34,88,111,55,2,32]; var min =arr[0]; for(var i=1;i<arr.length;i++){ if (arr[i]<min){ min=arr[i];     }else{ continue;     }   } console.log( "最小值:"+min ); ​ ​

 

 

 

 

数组的属性 length

数组的方法 push 追加元素

数组追加元素方式

1.通过数组索引

2. 通过push( )

往数组后面追加元素

3. 通过unshift( )

往数组前面追加元素

var arr=[1,2,'e',2];

arr.push("a");

arr.unshift( 0 );

 

数组删除元素

1. 通过splice(删除元素的下标,删除的个数 )

删除元素,

01.通过splice也可以用作替换

---splice(删除元素的下标,删除的个数 ,添加的元素 )

02,通过splice也可以用作追加

----splice(删除元素的下标,0 ,添加的元素 ),加在删除元素的下标的前面

arr.splice(2 , 0 , "two" );

arr.splice(2 , 1 , "two" );

03通过splice切割,删除不要的返回想要的

arr.splice(4,3)

 

2.通过 pop( ) 删除数组中最后一个元素

arr.pop();

 

3.通过 shift( ) 删除数组中第一个元素

arr.shift( ) ;

 

4.通过 slice(开始元素的下标,结束位置的下标)截取

数组元素, 口诀:包头不包尾(包含开始元素,不包含结尾元素)

arr. slice( 2 , 5 ) ;

 

 

数组转字符串

1.通过遍历数组,用字符串拼接

2.通过toString( )

console.log(arr.toString( )) ;

3.通过 join( 可以传递需要拼接的字符串)方法,如果没有参数,则和toString( ) 一样

console.log(arr.join("-") ) ;

 

 

 

数组翻转

1.通过 reverse( ) 翻转数组

 

数组合并

1.通过concat( ) 合并

 

console.log(arr1.concat( arr2) ) ;

 

 

 

数组查询 includes()

includes(查询包含的子项) ,返回布尔值,有返回true

[1,2,3].includes( 2 ) //true

[1,2,3].includes( "2" ) // false

 

数组查询 indexOf('s',开始查询的下标 )

//从左到右查找第一个元素在数组中对应的下标,如果没有查询到,返回的是 -1

 

 

数组的排序

1.通过 sort( ) 方法排序 无参

console.log(arr1.sort( ) ) ; //没有参数,按ASCII码排序,如果是字符串则按首字母排序,如果是纯数字,按开头数字排序,开头数字一样在按第二个数字排。

纯数字最好用有参数的排序

2. sort() 排序 有参

没有参数,按ASCII码排序,如果有参数(函数),可以设置它排序的方式

a代表元素数字小一点的元素

b代表元素数字大一点的元素

如果是复合数字,要找到排序比较的数字

sort(function(a,b){

return a-b; //从小到大

})

 

sort(function(a,b){

return b-a; //从大到小

})

 

 

 

数组.reduce(回调函数)累计器

数组.reduce((初始值,下一个值,下标,数组本身)=>{})累计器

数组.reduce((初始值,下一个值)=>初始值 + 下一个值) 可以做累加,累乘

 

 

 

数组.flat( 数字或者Infinity(无穷大) ) :将多维数组转为普通数组

 

 

 

 

数组去重

1.第一种

讯享网 var array = [3,10,15,2,15,76,55,22,18,24,3,10] ​ for(var i=0;i<array.length;i++){ for(var j=0;j<array.length;j++){ if(array[i]==array[j] && i != j){ array.splice(j,1);         }     }     } console.log(array); ​ ​

 

 

2.第二种

for(var i=0;i<array.length;i++){ for(var j=i+1;j<array.length;j++){ if(array[i]==array[j]){ array.splice(j,1); j--;         }     }     } console.log(array); ​ ​

 

 

冒泡排序

1.使用双重for循环

2.交换元素的位置

 

从小到大排列

讯享网 var array = [10,15,3,22,18,23,11,9,21,13]; var max=0; for(var i=0;i<array.length;i++){ for(var j=i+1;j<array.length;j++){ if(array[i]>array[j]){ max=array[i]; array[i]=array[j]; array[j]=max; } } } console.log(array); 

 

 

从大到小

 var array = [10,15,3,22,18,23,11,9,21,13]; var min=0; for(var i=0;i<array.length;i++){ for(var j=i+1;j<array.length;j++){ if(array[i]<array[j]){ min=array[i]; array[i]=array[j]; array[j]=min;       }     }     } console.log(array);

 

 

2.函数 Function

参数: 形参:不需要声明的变量,实参:实际的数值

function name(a,b){ // a,b属于形参 ,

函数体;

}

console.log(name(2,3)); // 2,3属于实参

 

 

函数:就是封装了一段可以被重复执行调用的代码片段

目的:就是让大量的代码可以重复使用

function text(min,max) {

var sum=0;

for(var i=min; i<=max ; i++){

sum +=i;

}

console.log( sum );

}

 

 

使用函数把相同调用的代码封装

传递参数

text(5,10); //5到10的和

 

 

函数的创建

1.声明函数 关键字 function

function 函数名(){

 

函数体---代码片段

 

}

 

 

2.调用函数

讯享网函数名() ​ <body> <div id="txt">div盒子</div>  <button οnclick="block()">显示,引用函数 </button> •    <button οnclick="none()">隐藏,引用函数</button> <script>    function none(){      var  div=document.getElementById("txt");      div.style.display="none";         } •        function block(){ •             var div=document.getElementById("txt"); •             div.style.display="block"; •       } •    </script> </body>

 

 

 

 

函数的注意点:

1.function 声明函数的关键字,字母全部小写

2.函数名命名规范一样,最好见名知意;

3.函数不调用不会执行

4.函数调用不分上下关系

 

 

获取元素的方式

1.通过元素的id document.getElementById('id名称')

获取的是单数

注意:

1.改变样式的属性是字符串,所以要打双引号或单引号

var div=document.getElementById("txt");

div.style.color="red";

 

 

2.通过元素class document.getElementsByClassName('class名称')

获取的是元素的集合,一个元素也是集合

注意:

1.获取的是一个数组,所以引用变量时要加索引

2.改变样式的属性是字符串,所以要打双引号或单引号

var div=document.getElementsByClassName("txt");

div[0].style.color="red";

 

3.通过元素标签名 document.getElementsByTagName('标签名')

获取的是元素的集合,一个元素也是集合

注意:获取的是一个数组,所以引用变量时要加索引

 

4.通过元素的name属性名 document.getElementsByName('name属性名 ')

获取的是元素的集合,一个元素也是集合

注意:获取的是一个数组,所以引用变量时要加索引

 

 

获取元素的文本内容 得到的内容为字符串

1.innerHTML -- 获取元素里面的文本内容带有标签

可以更改标签

div.innerHTML="<p>你好</p>" ;

 

把改变的文本赋值回去

<body> <h1 id="n">10</h1> ​ <button οnclick="jia()">自增,引用函数</button> ​ <script> ​ function jia(){ ​ var num=document.getElementById('n'); ​ var zeng=Number(num.innerHTML); ​ zeng++; ​ 把改变的文本赋值回去 ​ num.innerHTML=zeng; ​ } ​ </script> </body> 

 

 

 

 

2.innerText -- 只是获取元素的文本内容

只能改变文本

 

函数的声明方式(类型)

注意:

1.tex是变量名而不是函数名

2.函数表达式声明方式跟声明变量是一样的,只不过变量储存的是值,而函数表达式变量储存的是函数

3.函数表达式可以进行传递参数

 

1.命名函数 -- 使用关键字function 函数名(),这种函数叫做命名函数

function name(){ //name是函数名

 

}

 

2.匿名函数 -- 函数表达式

var tex = function () { // tex是变量名而不是函数名

 

}

调用

tex() ;

 

 

按钮

var te=document.getElementById("a"); te.οnclick=function () { console.log("我是匿名函数"); }

 

函数的四种形态 函数默认没有返回值

\1. 无参无返

function demo(){

 

}

 

2.有参无返

function demo(a,b){ // a,b 形参

console.log(a+b);

}

 

demo(10,14); // 10,14 实参

 

3.有参有返 函数默认没有返回值

function demo(a,b){

console.log(a+b);

// return 返回值;

return a+b;

}

var sum=demo(1,3)

console.log( sum); // 4

 

 

4.无参有返

function demo(){

 

return “我是返回值”;

}

var str=demo();

 

 

函数的return

1.返回值

function name(){

return :100;

}

 

2.终止 return 后面的代码无法执行

function name(){

return :100;

console.log("我是return后面的代码");

}

 

3.如果返回的结果有多个,那么我们可以把这些值放置在数组或者对象中统一返回

 

 

函数的arguments

实参的集合 - 伪数组

伪数组的特点

1.具有数组的属性length

2.按照索引的方式进行存储或者获取其中的元素

3.它没有真正数组的一些方法,比如 push() ,shift() ,slice() .....

 

 

js中只有函数才有arguments 对象,而且是每个函数都内置了这个

function fn1( ){

console.log( arguments ) ; //里面储存了所有传过来的实参 arguments= [12,23,22]

console.log( arguments[0] ) ;

}

console.log( fn1(12,23,22) );

 

 

js的作用域:

变量的作用范围 ,一般在当前的script标签或者一个单独的js文件)的范围

 

1,全局作用域:在函数外部声明的变量,整个的script标签,或者一个单独的js文件

 

2.局部作用域:在函数内部声明的变量,他的作用域叫局部作用域(整个函数内部起效果)

 

注意:

3、在js的任意地方,不声明直接赋值,它都会变成全局变量

 

总结:

1.函数内部可以拿到函数外部的变量

2、函数外部不能拿到函数内部的变量

3.除非函数内部的变量不声明直接赋值,变量就会变成全局变量

 

 

作用域链:内部函数访问外部函数的变量,采取的链式查找的方式来决定取那个值,这种方式,我们就称为作用域链

 

特点:就近原则

 

js解析器解析分两步:

1.变量提升

如果是声明的全局变量,会把声明的变量,隐形集中起来放到顶部script标签的下方第一行。但是变量赋的值在原处。

所以:

1.如果输出在变量赋值下方则正常输出

var a=10;

console.log(a) //10

 

2.如果如果输出在变量赋值上方则输出undefined

//变量提升 var a;

console.log(a); // undefined

var a=12;

 

如果是声明的函数局部变量,会把声明的变量,隐形集中起来放到函数内的顶部。但是变量赋的值在原处。

所以:

1.如果输出在变量赋值下方则正常输出

function name(){

var a=10;

console.log(a) //10

}

 

2.如果如果输出在变量赋值上方则输出undefined

var a=10;

function name(){

//变量提升 var a;

console.log(a); // undefined

var a=12;

}

 

2.变量赋值

声明变量赋值 :

声明在函数外的变量为全局变量,声明在函数内为局部变量,有变量提升

1.如果声明变量赋值在前,输出在后,正常输出

2.如果声明变量赋值在后,输出在前,undefined

 

未声明变量赋值 :

无论在哪都会变成全局变量,但是没有变量提升,如果在函数内,没有引用函数,则无法在函数外部得到这个值。

3.如果变量未声明,直接赋值,赋值在前,输出在后,正常输出

4.如果变量未声明,直接赋值,赋值在后,输出在前,直接报错

 

 

3.实例 Object

对象的创建

1.利用对象的字面量创建对象

var girl={

name:"loli",

age:12,

sex:"女",

say:function() {

console.log("小哥哥,你好帅");

}

}

 

对象的特点

1.里面的属性或者方法采取的是键值对的形式( 键: 属性名 值: 属性值),键和值之间使用逗号隔开

2.多个键值对之间使用逗号隔开

3.方法冒号后面跟的是一个匿名函数

 

 

对象的使用

1.调用对象的属性。采取打点的方式获取,比如girl.name girl.age 对象.属性名

 

console.log( girl.name );

 

2.调用属性,可以使用跟数组相似的方法, 对象["属性名"]

 

console.log( girl[ 'name' ] );

 

3.调用对象的方法 对象.方法名( ) , 记得加小括号

girl.say( )

 

注意事项:对象的属性名都是字符串类型的,

按以前的写法,对象的属性名其实都是要加引号的,但是后面习惯以后可以把属性名的双引号省略掉。

 

 

对象的创建

1.利用对象的字面量创建对象

var girl={

name:"loli",

age:12,

sex:"女",

say:function() {

console.log("小哥哥,你好帅");

}

}

 

 

1.变量:

储存数据的容器,单独声明和赋值

 

2.属性:

属性属于对象 (Array Function Obiect),不需要使用var 声明,调用时,对象.属性名

 

3.函数:

封装一段可以重复使用的代码片段 ,调用 :函数名()

 

4.方法:

在对象里面声明的函数叫做方法

调用:对象.方法名() 比如: array.push() 方法本质上也是一个函数

 

 

使用new关键字创建数组,函数,对象

数组

var arr=new Array();

console.log(arr)

 

函数

var fn= new Function();

console.log(fn)

 

对象

var obj=new Object();

console.log(obj)

obj.name="zhangshan";

obj.age=20;

obj.sex="男";

obj.say=function(){

console.log("你好");

}

console.log(obj)

 

给new关键字创建的对象添加属性和方法,

对象.属性名=属性值

obj.age=20;

obj.say=function(){

console.log("你好");

}

 

 

函数分为普通函数和构造函数

1.普通函数首字母不需要大写,构造函数首字母大写,本质上没有区别,

function fn1(){

 

}

 

function Fn1(){

 

}

 

1.为什么我们需要一个构造函数,

就是因为我们前面学的创建对象的两种方式一次只能创建一个对象

 

2.原因:

我们一次创建一个对象,里面很多的属性,方法有大量相同的,只能重复书写,不能复用,

我们可以使用函数的特性(封装可以重复使用的代码),重复这些代码,我们就把这个函数称为构造函数(为了与普通函数区分,函数名首字母大写)

 

3.构造函数里面封装的不是普通的代码片段,而是对象,

就是把对象重复的属性和方法抽象出来封装到函数里面,调用的时候使用 new 关键字实例化成对象

1.字面量创建对象

var obj={}

 

2.关键字new 创建

var obj=new Object();

 

 

 

构造函数创建对象

语法

function 构造函数名(属性值,属性值,属性值){ //构造函数名首字母大写

this.属性名=属性值;

this.属性名=属性值;

this.属性名=属性值;

this.方法名=function(){

 

}

}

 

调用或者实例化构造函数

new 构造函数名()

 

 

利用构造函数抽象对象的属性方法,封装到构造函数中

讯享网function Girl(name,age,msg){ ​ this.name=name; ​ this.age=age; ​ this.say=function(msg){ ​ console.log(msg); ​ }; } var girl1=new Girl("zhangsan",18,"哈哈"); var girl2=new Girl("qing",16,"哥哥"); var girl3=new Girl("jiu",17,"小哥哥"); console.log(girl1); // Girl {name: 'zhangsan', age: 18, say: ƒ}

 

 

 

总结:

1.构造函数名字首字母要大写

 

2.我们构造函数不需要return,就可以返回结果

 

3.调用构造函数,必须使用new关键字

 

4.只要使用了new关键字调用构造函数,那么就创建了一个对象,这个过程称为实例化对象

 

5.我们的属性和方法前面必须加this

 

 

函数的this指向

1.全局下的this,指向 window对象

console.log(this)

函数里的this,根据函数调用的情况this指向不同的对象

var a=function(){

console.log(this)

}

a();

2.全局内通过 函数名( ) 调用函数,this指向window对象

 

HTML事件 把事件写在开始标签的头部里面

3.在HTML事件中调用函数,this指向window对象

<button οnclick="a( )"></button>

 

4.通过获取元素,绑定事件,函数里面的this指向当前的调用者

var btn=document.getElementsByTagName("button")[0];

btn.οnclick=function ( ) {

console.log(this)

}

 

 

this指向分类

 

1、普通函数的this指向 指向window

 

2、对象的方法 this指向当前对象

 

3、绑定事件的this指向当前事件调用者

 

4、构造函数中的this指向当前实例化对象

 

5、原型对象的 this 指向当前实例化对象

 

6、定时器函数的this指向window

 

7、立即执行函数(自调用函数自运行)的this指向window

 

8、箭头函数没有this指向,它里面的this会往上一层一层的找this

 

 

改变函数内的this指向

1、call() 转变函数中的this指向

1.1、函数名.call(表示要this指向的对象 , 函数的参数1,函数的参数2)

 

1.2、主要作用可以实现继承:第一个可以调用函数,第二个可以改变函数内的this指向

 

let obj={

name:"fff"

}

 

function fn(a,b){

console.log(this) //window

console.log(a+b)

}

 

fn.call(obj,1,2)

 

 

 

2、apply() 方法 转变函数中的this指向

2.1、函数名.apply(表示要this指向的对象 , [ 函数的参数1,函数的参数2 ] )

 

2.2、主要作用可以实现继承:第一个可以调用函数,第二个可以改变函数内的this指向

 

2.3、与call()方法不同的是传参的方式不同,apply()方法是通过数组(伪数组)的方式传参,而call()方法是通过单个参数传参。

 

2.4、通过 apply()方法求数组的最大值

 //如果不想转指向,可以写null ​ let max = Math.max.apply(null,arr); ​ let max = Math.max.apply(Math,arr); ​ let max = Math.max.apply(arr,arr); let obj={ ​ name:"fff" } function fn(a,b){ ​ console.log(this) //window ​ console.log(a+b) //3 } fn.apply( obj,[1,2] ) 

 

 

 

 

3、bind() 方法 转变函数中的this指向

3.1、主要作用可以实现继承:可以改变函数内的this指向

 

3.2、与前两个不同的地方:不会调用原来的函数,会返回一个新的函数,需要声明一个变量接收之后再调用一次。

 

3.3、运用场景:需要改this指向,不需要立即调用的函数。

 

let fn1= fn.bind( obj,1,2 );

fn1();

 

小练习:

btn[i].οnclick=function(){

 

setTimeout(function(){

console.log( this )

}.bind(this),3000);

 

}

 

 

 

 

 

自调用自运行函数(立即执行函数)

;(匿名函数)();

 

加分号的作用:分隔两个立即执行函数(自调用函数)

 

;( function(w,d){

console.log(立即执行,不需要调用)

} ) (window,document)

 

立即执行函数(自调用函数)的作用:

1、最主要的作用是避免框架和框架之间的变量名命名发生冲突。

 

2、大多用于编写框架

 

 

注意:自运行函数的前面一个函数必须加分号间隔,否则报错

 

 

 

 

 

new关键字执行过程

1.new构造函数可以在内存中创建一个空的对象

 

2.把this指向刚才创建的这个空对象

 

3.执行构造函数里面的代码,给这个空对象添加属性和方法

 

4.返回这个对象给我们

 

new帮我们做了两件事情

1.new 把this指向刚才创建的这个空对象

2.new 把所以的属性和方法返回出来了,而不需要我们自己手动添加return

 

 

 

 

1.获取对象的属性值,通过打点的方式, 对象.属性名

console.log(obj.name);

2.获取对象的属性值,通过数组的方式 对象["属性名"]

console.log(obj["name"]);

 

遍历对象,对象没有length属性

键值对 key:value 形式叫做键值对

for in 遍历对象

语法:

for(var 变量 in 对象){

console.log( 变量 ); //对象里面的属性名遍历出来了

console.log( 对象 [ 变量 ] ); // 对象的属性值遍历出来了

}

 

 

var obj = {

name="栈山"

age=13;

sex="男"

}

for(var key in obj){

console.log( key ); //对象里面的属性名遍历出来了

console.log( obj [ key ] ); // 对象的属性值遍历出来了

}

 

 

内置对象

Math 数学对象

不是一个构造函数,所以用的时候不需要new调用,而是直接使用

1.圆周率 Math.PI

console.log(Math.PI) ; //圆周率

 

2.Math.max() 可得到数组中的最大值

console.log( Math.max(1,33,22,33,999 ) ); 可得到数组中的最大值

console.log( Math.max( ) ); //-Infinity 无穷大

console.log( Math.max("d",11,22 ) ) //NaN

 

3.Math.min() 可得到数组中的最小值

console.log( Math.min(1,33,22,33,999 ) ); 可得到数组中的最小值

 

4.Math.abs() 绝对值

console.log( Math.abs(-1) ); // 1 绝对值

console.log( Math.abs("-1") ); //1 绝对值

console.log( Math.abs("ss") );//NaN 绝对值

 

 

5.取整 Math.floor()

1.向下取整 -- 把小数点后面的数字抹掉

console.log( Math.floor(5.9233) ); //5 取整

2.向上取整 -- 小数点后面有值,整数部分加 1

console.log( Math.ceil(5.9233) ); // 6 小数点后面有值,整数部分加 1

console.log( Math.ceil(5.1233) ); //6

6.四舍五入 round()

console.log( Math.round(5.1233) ); // 5

console.log( Math.round(5.5233) ); // 6

负数的时候不遵循四舍五入

console.log( Math.round( -2.1 ) ); // -2

console.log( Math.round( -2.5 ) ); // -2

 

 

7.获取随机数 random()

不写参数,写了参数不会报错,但是也没作用

console.log( Math.random( ) ); //返回一个随机的小数 0<= x <1 出现0的概率很低

 

应用场景:

1.效验码

2.随机点名

3.游戏

4、抽奖

 

使用随机数的公式

Math.floor( Math.random()*(max-min+1)+min )

 

var ran=function (min,max){ return Math.floor( Math.random()*(max-min+1)+min ) } console.log(ran(10,20));

 

8.数的幂次方 Math.pow(底数,几次方)

 

 

9. Math.sqrt() 开平方

它的类型应该是Number。如果x不是Number类型的,那么它会先被强制类型转换为Number类型

Math.sqrt()同样要求它的参数不能为负数,但有一个例外,那就是-0;在JavaScript中,-0的平方根就是-0本身。

\1. 如果x是NaN,那么结果也是NaN;

\2. 如果x是+0,那么结果也是+0;

\3. 如果x是-0,那么结果也是-0;

\4. 如果x是正无穷(Infinity),那么结果也是正无穷(Infinity);

\5. 如果x小于0(包括负无穷,-Infinity),那么结果就是NaN;

\6. x为其它大于0的数字,结果为x的平方根。

算术平方根没有负数。只有正数和0有平方根

 

 

 

 

Date() 日期对象

是一个构造函数,要用new ,来创建对象

 

1.使用Date() 如果没有参数,则返回当前电脑的系统时间

 

var time=new Date() ; //拿到当前系统的日期

console.log( time ); //Wed Nov 23 2022 10:06:26 GMT+0800 (中国标准时间)

 

 

2.使用使用Date() 如果有参数,则返回设置的时间

2.1 数字类型 年,月,日,时,分,秒 用逗号隔开

注意:数字类型设置日期,真实月份=月份-1,想设置11月,参数写10月

var time =new Date( 2022,10,23,12,0,0 ) ;

console.log( time );

 

2.2 字符串类型 "2022-11-24 12:00:00"

var time =new Date( "2022-11-24 12:00:00" ) ;

console.log( time );

 

应用场景:倒计时

 

格式化中国式的时间格式 20022年11月23号

getFullYear( ) 拿到年份

console.log( time.getFullYear( ) ); //2022

 

getMonth() 拿到月份,比实际月份小一个月,所以获取实际月份要加1

console.log( time.getMonth() +1 );

 

getDate() 拿到日

console.log( time.getDate() );

 

getDay() 拿到星期

console.log( time. getDay() ); //0 - 6,0代表星期天

 

 

var time = new Date(); //拿到当前系统的日期

//格式化日期

var date = time.getFullYear() + "年" + (time.getMonth() + 1) + "月" + time.getDate() + "日" + "星期" + time.getDay();

console.log(date);

 

格式化时间

const now = new Date()

new Intl.DateTimeFormat('zh-CN', { dateStyle: 'full' }).format(now) // '2022年3月30日星期三'

new Intl.DateTimeFormat('zh-CN', { dateStyle: 'long' }).format(now) // '2022年3月30日'

new Intl.DateTimeFormat('zh-CN', { dateStyle: 'medium' }).format(now) // '2022年3月30日'

new Intl.DateTimeFormat('zh-CN', { dateStyle: 'short' }).format(now) // '2022/3/30'

new Intl.DateTimeFormat('en-US', { dateStyle: 'long' }).format(now) // 'March 30, 2022'

new Intl.DateTimeFormat('en-CA', { dateStyle: 'short' }).format(now) // '2022-03-30'

 

 

格式化时分秒

获取小时 :time.getHours()

 

获取分:time.getMinutes()

 

获取秒:time.getSeconds()

 

获取毫秒:time.getTime()

 

时分秒补零

封装函数实现数字不足10,进行补0

讯享网function zero(num){ num=num<10?"0"+num : num; } var time = new Date(); //拿到当前系统的日期 //格式化日期 var date = time.getFullYear() + "年" + (time.getMonth() + 1) + "月" + time.getDate() + "日" + "星期" + time.getDay()+zero(time.getHours() )+"时"+zero(time.getMinutes())+"分"+zero(time.getSeconds() )+"秒"; console.log(date); 

 

 

 

 

定时器

1.循环定时器 setInterval

间隔多少毫秒执行一次循环

 

语法:setInterval(匿名函数,毫秒数) 1秒=1000毫秒

setInterval(function( ){

console.log("循环定时器");

},1000)

 

2.清除循环定时器 clearInterval( 参数是循环定时器的返回值 )

1.用变量清除hover()产生的多个循环定时器

参数是循环定时器的返回值:返回值是数字编号,第一个定时器返回1,第二个返回2, clearInterval( 也可以直接写数字编号清除定时器 )

 // 鼠标悬停暂停播放 ​ var num1 = 0; ​ •    $(".lun").stop().hover(function () { ​ •      num1++; ​ •      clearInterval(num1); ​ •   }, function () { ​ •      time1= setInterval(function () { ​ •        num--; ​ •        if (num < 0) { ​ •          num = $(".img").length - 1; ​ •       } ​ •        $(".img").eq(num).addClass("block").siblings().removeClass("block") ​ •        // 关联鼠标悬停 ​ •        $(".dianJi").eq(num).css("background", "rgb(121, 117, 117)").siblings().css("background", "") ​ •     }, 500) ​ •   })

 

 

 

2.用stop()停止动画来去除 hover() 产生的多个循环定时器

// stop() 停止上一个动画

讯享网    $(".lun").stop().hover(function () { ​ •      clearInterval(time1); ​ •   }, function () { ​ •      time1= setInterval(function () { ​ •        num--; ​ •        if (num < 0) { ​ •          num = $(".img").length - 1; ​ •       } ​ •        $(".img").eq(num).addClass("block").siblings().removeClass("block") ​ •        // 关联鼠标悬停 ​ •        $(".dianJi").eq(num).css("background", "rgb(121, 117, 117)").siblings().css("background", "") ​ •     }, 500) ​ •   })

 

 

 

 

var  num=0; ​ var time1= setInterval(function( ){ ​ console.log("循环定时器"); ​ num++; ​ if(num>=5){ ​ console.log("清除循环定时器"); ​   clearInterval(time1); ​ } ​ },1000) ​ ​

 

 

3.延时定时器 setTimeout(匿名函数,毫秒数)

延迟一段时间执行一次(只执行一次,不循环)

 

清除循环定时器 clearTimeout( 参数是延时定时器的返回值 )

 

var time2= setTimeout(function( ){

console.log("延时定时器");

},3000);

 

btn.οnclick=function(){

clearTimeout( time2);

}

 

 

获取Date()日期对象中的毫秒数

var date=new Date();

 

\1. getTime()

//获取时间戳 -- 不是当前时间的毫秒数,而是距离1970年1月1日子时到现在的时间的毫秒数

console.log( date.getTime() ) ;

 

 

2.valueOf() 返回原来一模一样的数组

console.log( date.valueOf() ) ;

 

 

3.简单的常用写法 + new Date()

console.log( +new Date() ) ;

 

 

4.H5新增的方法 Date.now()

console.log( Date.now() ) ;

 

 

H5新增了很多js的API(说明文档就是API)

MSD网站,CSDN ,菜鸟,博客网 等等

 

 

原生js获取DOM元素, 获取网页中已存在的或者是后期动态添加的元素

1.getElementById

2.getElementsByClassName

3.getElementsByName

4.getElementsByTagName

 

 

H5新增2种获取元素方法 只能获取网页中已经存在的,不能获取后面动态添加的元素

获取的元素永远是单数,,参数写id,类名都要加前缀

1.querySelector("#name" )

querySelector(" .name" )

 

 

获取的元素是伪数组,是一个集合,参数写id,类名都要加前缀

2.querySelectorAll( )

 

相比较getElementsByClassName它们的不同:

1.get可以动态获取后面创建的HTML标签元素,而query只能获取当前页面已经存在的HTML标签元素,动态生成的元素无法获取

 

 

原生js DOM创建元素节点

1. createElement( )

var li=document.createElement( "li" );

 

2. innerHTML

 

3.document.write( " " )

 

 

 

 

 

 

 

倒计时练习

讯享网<body>    <div>        <h2>距离1+X考试还剩余 XX天XX时XX分XX秒 </h2>    </div>    <script>        var h2 = document.getElementsByTagName("h2")[0];        var hui = function () {            // 现在时间            var date1 = new Date();            var dateTime1 = date1.getTime();            //未来时间            var date2 = new Date("2022-11-26 8:30:00")            var dateTime2 = date2.getTime();            //剩余时间            var date3 = dateTime2 - dateTime1            var tian = parseInt(date3 / 1000 / 60 / 60 / 24)            var shi = parseInt((date3 / 1000 / 60 / 60) % 24)            var fen = parseInt((date3 / 1000 / 60) % 60)            var miao = parseInt((date3 / 1000) % 60)            var h = "距离1+X考试还剩余" + " " + tian + "天" + shi + "时" + fen + "分" + miao + "秒";            h2.innerHTML = h;       }        hui();        var zong = setInterval(function () {            hui()       }, 1000)    </script> </body> ​ ​

 

 

 

字符串对象

属性:length

length 可以获取字符串长度,但是不能设置,数组长度可以获取和设置

 

方法:

str1.charAt( 字符串的下标) //返回对应的字符串

 

str1.charCodeAt( 字符串的下标) //返回对应的字符串的ASCII码

 

str1.concat( str2) //合并字符串,返回新的字符串

 

String.fromCharCode( ASCII码) 返回对应ASCII码的字符串

 

str1.indexOf('s',开始查询的下标 ) //从左到右查找第一个字符在字符串中对应的下标,如果没有查询到,返回的是 -1

 

lastIndexOf ( 's',开始查询的下标 ) //从右到左查找第一个字符在字符串中对应的下标,如果没有查询到,返回的是 -1

 

match( ) //返回字符的数组形式,如果没有为 null

 

str1.replace('f',5 ) //替换从左到右第一个字符 f

str1.replace( /f/g ,5 ) //替换所有相同的字符 f

str1.replaceAll('f',5 ) //替换所有相同的字符 f

 

search('s',开始查询的下标 ) //从左往右查询下标,如果没有,返回-1

 

slice(开始截取的下标,结束截取的下标) //如果是一个数字,代表从对应的下标开始截取到字符串结尾 口诀:包头

如果是2个数字,代表从对应的下标开始截取到字符串结尾 口诀:包头不包尾

不能从后往前截取 但是支持负数

 

split() //参数为空,则把字符串变成数组中的一个元素

split(“ ”) //如果没有参数,表示把字符串每个字符变成数组中的一个元素

如果有参数,则以参数为界限截取,参数左边组成一个数组元素,参数右边组成一个数组元素,不包括参数,可以通过下标获取左右两边的数组。

 

substr(开始截取的下标,截取的长度)

 

substring(开始截取的下标,结束截取的下标) 参数不支持负数,

 

 

toLowerCase() 统一把单词中字母转换成小写字母

 

toUpperCase() 统一把单词中字母转换成大写字母

 

 

 

 

 

 

原生js操作类名

 

var h2=docment.getElementByTagName("h2")[0];

 

获取元素的类名

div[0].className //获取的是字符串

div[0].classList //获取的是数组,类名的集合

 

改变类名,会把原来的类名覆盖掉

h2.className=“color";

 

1.在不删除原来的类名的情况下加一个类名

1.设置类名的时候拼接上原来的类名

h2.className=“ demo color";

 

2.使用 元素名.classList.add("类名") 追加类名

h2.classList.add("color");

 

删除类名

1、改变类名,会把原来的类名覆盖掉

h2.className=“color";

 

2.元素名.cl assList.remove("类名");

h2.classList.remove("color");

 

 

 

原生js获取父级

1.原生js获取父元素 parentElement

元素名.parentElement

 

2.原生js删除父元素

for (var i = 0; i < del.length; i++) {

del[i].onclick = function () {

if (confirm) {

this.parentElement.remove();

}

}

}

 

 

2.原生js获取父节点 parentNode

如果找不到返回 null

 

 

3.区别:

1,在获取html的父级时,获取父节点parentNode返回#document,

但是获取父元素 parentElement 会报错

2.获取的父节点会包含空格,父元素不会

 

 

原生js获取子级

1.子节点 childNodes

获取该元素的所有子节点 包含元素节点 文本节点 等等 也会获取换行和空格、注释

 

1.1.节点类型 nodeType

1.元素

2.属性

3.文本

8.注释

9.#document

 

1.2.节点名称 nodeName

 

1.3. 获取节点的值 nodeValue

ul.childNodes[3].childNodes[0].nodeValue

 

 

2.子元素 children

得到的是所有子元素,实际开发常用

 

区别:

1.1.子节点 childNodes会获取该元素的所有子节点 包含元素节点 文本节点 等等 也会获取换行和空格、注释,而子元素 children不会

 

 

 

第一个子节点 firstChild

ul.firstChild

 

第一个子元素 firstElementChild

ul. firstElementChild

 

最后一个子节点 lastChild

ul.lastChild

 

最后一个子元素 lastElementChild

ul.lastElementChild

 

获取所有子元素的数量

1 childElementCount

ul.childElementCount

 

2. children.length

ul.children.length

 

 

 

原生js获取兄弟级

1.下一个兄弟节点 nextSibling 会拿的空格,不常用

 

2.下一个兄弟元素 nextElementSibling 开发常用

 

3.上一个兄弟节点 previousSibling 同理

 

4.上一个兄弟元素 previousElementSibling 同理

 

 

 

 

 

 

 

 

 

 

 

 

原生js怎么实现排他思想

var lis=document.getElementByTagName("LI");

//给每个li添加一个点击事件

for(var i=0;i< lis.length;i++){

//在循环的时候,把循环对应的下标赋值给对应 li 的属性index,让他保持起来

lis[i].index=i;

lis[i].οnclick=function{

 

//this是获取点击对应的当前元素

console.log(this);

//this.index获取点击对应的当前元素的下标

console.log(this.index);

//this.innerHTML获取点击对应的当前元素的内容

console.log(this.innerHTML);

//排他思想

for(var j=0;j<lis.length;j++){

lis[j].style.color="";

}

// 当前这个DOM元素,颜色变成红色

this.style.color="red";

 

}

}

 

 

 

 

 

 

 

原生js的window.onload事件 DOM元素加载事件

注意:只能出现一个,如果出现两个,下面的会覆盖上面的

 

 

jquery的加载事件

$(function(){ })

可以出现多个,不会覆盖

 

 

原生js中获取DOM元素样式

 

1.给DOM元素设置的是行内样式

div.style.display="none";

​​

 

 

2.js获取style获取元素的样式,只能获取行内样式

console.log(div.style.display);

 

 

3.获取内部或者外部样式

只能通过 window.getComputedStyle(元素名).属性名

 

console.log( window.getComputedStyle(div).display );

 

4. js中css样式复合写法 cssText

div.style.cssText="width:100px ; height:100px;background-color:red;"

 

 

 

原生js获取特殊元素

1.获取HTML标签

一般通过 document.documentElement

 

 

 

2.获取head标签

var head =document.head;

 

 

 

3.获取body标签

var body =document.body;

 

 

 

开关(js非常通用的判断条件)

1.全局下声明一个变量,值为true获取false

if判断true进入,执行语句,最后在把布尔值赋相反的布尔值,else也是一样的操作

 

 

 

 

 

 

原生js设置自定义属性

\1. 设置 setAttribute("属性","值")

 

 

2.获取自定义属性 getAttribute("属性")

 

 

3.删除自定义属性 removeAttribute("属性")

 

 

 

 

 

 

 

原生 js 添加元素节点

1.在元素的后面添加元素 appendChild( )

 

2. 在指定的元素前面添加元素 insertBefore(追加的元素,指定的元素)

 

 

 

原生js复制和删除节点

 

节点复制 cloneNode( )

\1. node.cloneNode() 括号为空或false ,默认为浅拷贝,只复制标签,不复制内容

 

ul.children[0].cloneNode()

 

 

\2. node.cloneNode(true) 括号为true ,为深拷贝,复制标签和内容

 

ul.children[0].cloneNode(true)

 

 

 

 

删除节点 removeChild()

\1. 节点删除 removeChild( 子节点 ) 删除某个节点

ul.removeChild( ul.children[4] );

 

\2. 全部删除 remove() 删除本身

ul.remove();

 

 

 

原生js事件大概分为4种类型

1.鼠标事件

click (单击)

dblclick 双击

移入移出

mouseover/mouseout

mouseenter/mouseleave

mouseover/mouseout || mouseleave

mousedown / mouseup 鼠标按住不放,松手

 

移入事件的区别

mouseover mouseenter 和 mousemove区别:

mouseover和mouseenter : 进入元素时触发一次

mousemove : 进入元素时,移动鼠标可以连续触发多次

 

 

2.表单事件

输入框获取焦点 focus

输入框失去焦点 blur

输入框改变文本 change

输入框实时触发 input

提交-form表单 submit

重置-form表单 reset

下拉-selsect标签 selset

 

 

3.键盘事件

1、键盘按键 keydown

btn.οnkeydοwn=function(e){

console.log( e.key ) //获取输入的键盘值

console.log( e.keyCode ) //获取输入的键盘值的ACSLL码

}

2、键盘按下不松手 keypress

3、键盘按下抬起 keyup

 

 

4.UI事件

加载 load

窗口改变 resize

滚动条 scroll

页面显示隐藏 visibilitychange :

事件属性:document.visibilityState 隐藏时返回 ”hidden“

 

 

 

原生js事件的三要素

1.事件源 - 事件触发对象

var btn=document.getElementById("id")

 

2.事件类型 -- 注册事件 使用on注册(事件四大类)

 

 

3.事件处理程序 - 通过一个函数赋值给事件的方式,本质上就是一个匿名函数

 

btn.οnclick=function(){

alert("点击“)

}

 

 

4.事件名前面加 on 是绑定事件 例如 onclick 点击事件

 

 

事件处理函数的3种方式

\1. HTML事件 --- 把事件写在标签的始标签中

this默认执行window

把this作为参数传递到函数里,那么this指向当前DOM对象

 

 

2.DOM 0级事件 --- 把事件写在script标签里面

同一个事件只能写一个,多个的话下面的事件会把前面的事件覆盖掉

2.1.btn.on后面加事件名=函数

btn.οnmοuseοver=function(){

alert("dd1")

}

2.2、 DOM 0级事件优先级大于HTML事件

 

 

3. DOM 2级事件也叫监听事件 --- btn.addEventListener("事件名" ,匿名函数或者函数名, 布尔值),布尔值可以不写

同一个事件可以写多个

 

3.1.匿名函数 布尔值可不写

btn.addEventListener("dblclick" , function(){} , true)

 

3.2 . 函数名 布尔值可不写 注意:函数名不要加括号

btn.addEventListener("dblclick" , demo , true);

function demo(){

alert("2");

}

 

4.删除DOM 2级事件 removeEventListener("事件名称",函数名)

注意:删除事件监听,只能删除带有函数名的监听事件

div.removeEventListener("click",demo);

 

5.删除0级事件

btn.onclick = null;

 

 

 

 

滚动条事件

原生js的滚动条方法

window.οnscrοll=function(){

console.log(1);

}

 

清除滚动条事件

window.onscroll = null;

 

 

原生js获取滚动条高度

var html=document.documentElement;

var scrollTop=html.scrollTop;

 

谷歌浏览器 html.scrollTop

火狐浏览器 document.body.scrollTop

苹果浏览器window.pageYOffset

var height = html.scrollTop || document.body.scrollTop || window.pageYOffset ;

 

 

 

监听页面关闭开启

window.addEventListener( "visibilitychange",函数 )

document.visibilityState 隐藏时返回 ”hidden“

document.visibilityState只在visibilitychange中有效

 

 window.addEventListener("visibilitychange", function () { if (document.visibilityState == "hidden") { console.log("当前页面隐藏"); }else{ ​ console.log("当前页面显示"); } })

 

 

 

 

监听页面关闭开启轮播

讯享网   window.addEventListener("visibilitychange", function () { ​ •      if (document.visibilityState == "hidden") { ​ •        console.log("当前页面隐藏"); ​ •        clearInterval(time1) ​ •     } else { ​ •        console.log("当前页面显示"); ​ •        time1 = setInterval(function () { ​ •          num++; ​ •          if (num == 1) { ​ •            $(".lun").stop().animate({ ​ •              left: "-800px" ​ •           }, 1000) ​ •            $(".dianJi").eq(num).css("backgroundColor", "rgb(96, 97, 98)").siblings(".dianJi").css("backgroundColor", "") ​ •         } else if (num == 2) { ​ •            $(".lun").stop().animate({ ​ •              left: "-1200px" ​ •           }, 1000) ​ •            $(".dianJi").eq(num).css("backgroundColor", "rgb(96, 97, 98)").siblings(".dianJi").css("backgroundColor", "") ​ •         } else if (num == 3) { ​ •            $(".lun").stop().animate({ ​ •              left: "-1600px" ​ •           }, 1000) ​ ​ ​ •            // 延迟跳转实现无缝衔接 ​ •            setTimeout(function () { ​ •              $(".lun").stop().css("left", "-400px") ​ •           }, 1000) ​ •            $(".dianJi").eq(num - 3).css("backgroundColor", "rgb(96, 97, 98)").siblings(".dianJi").css("backgroundColor", "") ​ •            num = 0; ​ •         } ​ •       }, 1500) ​ •     } ​ •   }) ​ ​

 

 

 

 

 

 

DOM对象转换 jQuery对象

var a =document.getElementById("id1");

$(a);

$(a).css("color","red")

 

 

 

原生js过渡动画效果

btn.οnclick=function(){

div.style.transition="all 2s ease-in";

div.style.width="800px";

}

 

原生js实现动画效果 animate({ 样式},时间(单位毫秒),回调函数)

animate({

opacity:0,

},2000,回调函数(可选))

 

var a=document.getElementsByClassName("a")[0];

a.οnclick=function(){

a.animate({

opacity:0,

},2000)

}

 

 

js事件

js事件:就是用户或浏览器本身的某种行为,

当事件发生时,您可以使用 JavaScript 中的事件处理程序(也可称为事件监听器)来检测并执行某些特定的程序。

JS(JavaScript)与HTML 之间的交互是通过事件(event)实现的,或者说,事件是JavaScript和DOM之间进行交互的桥梁。

 

 

js事件流

js事件流:在js中,事件流就是事件在目标元素和祖先元素间的触发顺序。按照事件传播的顺序,事件流可分两种:

1、冒泡型事件流,事件的传播是从最特定的事件目标到最不特定的事件目标;(从里到外)

 

2.目标阶段:正在触发的事件元素

 

3、捕获型事件流,事件的传播是从最不特定的事件目标到最特定的事件目标。(从外到里)

 

4.每个事件都会触发事件流,默认是冒泡阶段

 

 

DOM 2级事件的布尔值作用

1.布尔值true 表示事件流为捕获阶段(从外到里)

 

2.布尔值false 表示事件流为冒泡阶段(从里到外) 不写布尔值,默认false

 

 

 

事件对象

任何js事件,在事件处理函数中,第一个形参得到的就是当前事件的事件对象 我们称为event事件对象

btn.οnclick=functiom( event ){

console.log( event )

}

 

1、event 只有事件才会存在,它是系统给我们自动创建的,不需要我们在外面传递参数

2、event事件对象 是当前事件的一系列相关数据的集合,跟事件相关的,比如鼠标点击坐标,键盘事件里的按键等等

3、event 事件对象 写形参的时候,可以自定义命名,比如e, event , evt

4、event 事件对象 兼容IE9以下浏览器 var e=e || window.event ;

 

 

 

 

事件对象 -- 源目标

ul.addEventListener( "click",function(e){

//点击那个li,就返回那个

console.log(e.target);

})

 

常见的事件对象的属性和方法

1.e.target 返回的是触发事件的对象(DOM元素) --点击谁指向谁

 

2. this返回的是绑定事件的事件调用者(DOM元素)-- 绑定谁指向谁

 

 

 

 

事件对象--阻止默认行为

1、通过 e.preventDefault( )阻止默认行为,后面的代码能够继续执行

 

2.通过 return false; 阻止默认行为,return后面的代码不能继续执行、只能在HTML事件和DOM 0 级事件中使用

 

3、DOM 2 级事件不能使用return false;阻止默认行为,

只能使用 e.preventDefault( );阻止默认行为

 

4.DOM 2 级事件使用return false,不能阻止默认行为

 

5.总结

普通浏览器 e.preventDefault( );

也可以用 return false;

低版本 IE 6 7 8 e.returnValue;

 

 

var a = document.ElementsByTagName("a")[0];

a.addEventListener("click",function(e){

//阻止a标签跳转

e.preventDefault( );

alert("默认行为")

})

 

 

//阻止form表单跳转

form.onsubmit = function(e){

e.preventDefault( ); //常用

alert("默认行为") //能执行

 

return false;

alert("默认行为") //不能执行

}

 

 

 

 

 

事件对象 -- 阻止事件冒泡

//stop 停止 propagation 传播

1、阻止冒泡 ;把 e.stopPropagation( ); 放在子事件中,点击子事件,只触发子事件

li.addEventListener("click",function(){

// 阻止冒泡

e.stopPropagation( );

alert("er")

})

 

ul.addEventListener("click",function(){

alert("fa")

})

 

2、阻止捕获;把 e.stopPropagation( ); 放在父事件中,点击子事件,只触发父事件

// 捕获阶段

ul.addEventListener("click", function (e) {

alert("fa")

e.stopPropagation();

}, true)

 

li.addEventListener("click", function (e) {

alert("er")

}, true)

 

 

 

 

 

事件对象 -- 事件委托

1、事件委托的核心原理:给父元素添加事件监听,利用事件冒泡影响每一个子元素,子元素的事件都会触发父元素的事件

 

ul.addEventListener("click",function(e){

// e.target返回点击对应的元素

alert( e.target );

})

 

 

 

 

事件对象 -- 鼠标坐标

鼠标事件对象 MouseEvent 鼠标的坐标

1、 client 鼠标在可视化区域的坐标

clientX:860 clientY:50

 

2、page 鼠标在页面文档中的坐标

pageX:860 pageY:50

 

3.screen 鼠标在电脑屏幕分辨率的坐标

screenX:860 screenY:50

 

document.addEventListener("click",function(e){

console.log( e.clientX )

console.log( e.clientY)

 

console.log( e.pageX )

console.log( e.pageY)

 

console.log( e.screenX )

console.log( e.screenY)

 

})

 

 

 

 

BOM浏览器模型

BOM的顶级对象 window对象

 

window常见事件

1、UL加载事件 window.onload = function(){}

 

2、窗口改变事件 window.onresize = function(){}

var  html=document.documentElement;
​
var   htmlWidth=$("html").outerWidth(true);
​
窗口事件
​
window.οnresize=function(){
​
console.log("窗口改变事件")
​
//jQuery获取html标签宽度
​
htmlWidth=$("html").outerWidth(true);
​
//原生js获取html标签宽度
​
htmlWidth=window.getComputedStyle(html).width;
​
//原生js获取可视化区域的宽度
​
 var width=html.clientWidth;
​
获取rem单位的px值
​
注意:htmlWidth是带px的字符串   width获取的是数字
​
document.documentElement.style.fontSize=Width/14.4+"px";
​
}

 

 

原生js获取可视化区域的宽度 /高度 clientWidth clientHeight

var width2=html.clientWidth;

 

 

window 的三大弹窗

1、警告框 alert("警示弹窗")

2、提示框 prompt("输入弹窗")

3、确认框 confirm("判断弹窗")、返回布尔值true、false

 

 

 

window之screen对象

获取电脑屏幕的宽高 window.screen

 

 

1、获取可用的屏幕宽度和高度 screen.availWidth screen.availHeight

 

2、获取屏幕分辨率的宽度和高度 screen.width screen.height

 

 

 

 

 

window之 location

location方法

1、location.href 返回当前网页的URL地址--重点

设置跳转页面:location.href = "百度一下,你就知道" ; 可以回退

 

2、location.assign( "百度一下,你就知道" ) 相当于 location.href 可以回退

 

 

3、location.replace("百度一下,你就知道") 删除当前页面跳转新页面,不能回退

 

4、location.reload( ) 网页重载或者刷新

 

 

location属性

1、location.hostname 返回web主机的域名

 

2、location.pathname 返回当前页面的路径和文件名

 

3、location.port 返回 web 主机的端口(80或443)

 

 

 

 

 

window对象之history 历史记录回退前进

 

1、history.back() -- 与在浏览器点击后退相同

 

2、history.forward() -- 与在浏览器点击前进相同

 

3、history.go(参数) -- 前2个方法的综合写法

3.1、参数为数字 0,表示刷新 相当于 location.reload()

 

3.2、 参数为数字 1,表示前进1个页面 相当于history.forward()

 

3.3、参数为数字 -1,表示后退1个页面 相当于history.back()

 

3.4、参数为数字 2,表示前进2个页面 相当于history.forward()

 

3.5、参数为数字 -2,表示后退2个页面 相当于history.back()

 

 

 

 

移动端建议使用iPhone6/7/8二倍的手机为设计稿,pc端建议使用自己电脑的分辨率的宽度为设计稿

相对单位 rem em

1、rem : 相对于HTML的字体大小(默认16px)单位设置的,它是一个相对单位

 

2、em :相对于父元素的字体大小(默认16px)单位设置的,它是一个相对单位

 

 

 

js缓存

本地缓存 方法

存储 setItem("key","value")

获取 getItem("key")

删除 removeItem("key");

全部删除 clear();

 

本地缓存

应用场景:

1、注册缓存 登陆读取判断

 

 

1、 localStorage 长久保存 ,除非手动删除

localStorage. setItem("password",1234)

 

 

2、sessionStorage 临时保存,页面关闭,自动删除

sessionStorage. setItem("password",1234)

 

 

 

登陆密码用户名输入的正则表达式

if (/^[a-zA-Z0-9]{6,12}$/.test(val1[0].value)) {} 正确为true,错误为false

 

正则表达式的方法

1、正则表达式.test( 需要判断的语句 ) 返回布尔值

检测字符串是否符合正则表达式 返回布尔值

 

2、正则表达式.exec( 需要判断的语句 )

返回的是数组,第一个元素就是匹配到的值,如果不符合正则表达式则返回 null

 

1、用户名

用户名可能包含中文、大小写字母、和数字

中文的匹配规则:\u4e00-\u9fa5

 

大写字母的匹配规则:A-Z

 

小写字母的匹配规则:a-z

 

数字的匹配规则:0-9

 

所以用户名的匹配规则为

^[\u4e00-\u9fa5a-zA-Z0-9]{6,12}$

{6,12} 表示匹配 6-12 个字符

 

2、密码

密码为了安全,一般是要包含数字、大小写的字母,甚至要有特殊字符。

至少1个大写字母:(?=.*?[A-Z])

 

至少1个小写英文字母:(?=.*?[a-z])

 

至少1位数字:(?=.*?[0-9])

至少有1个特殊字符:(?=.?[#?!@$%^&-])

最小8个长度:{8,}

至少8-16个字符,至少1个大写字母,1个小写字母和1个数字,其他可以是任意字符:

/^(?=.[a-z])(?=.[A-Z])(?=.*\d)[^]{8,16}$/

或者:

/^(?=.[a-z])(?=.[A-Z])(?=.*\d)[\s\S]{8,16}$/

其中 [\s\S] 中的\s空白符,\S非空白符,所以[\s\S]是任意字符。也可以用 [\d\D]、[\w\W]来表示。

至少8个字符,至少1个大写字母,1个小写字母和1个数字,不能包含特殊字符(非数字字母):

^(?=.[A-Za-z])(?=.\d)[A-Za-z\d]{8,}$

至少8个字符,至少1个字母,1个数字和1个特殊字符:

^(?=.[A-Za-z])(?=.\d)(?=.[$@$!%#?&])[A-Za-z\d$@$!%*#?&]{8,}$

至少8个字符,至少1个大写字母,1个小写字母,1个数字和1个特殊字符:

^(?=.[a-z])(?=.[A-Z])(?=.\d)(?=.[$@$!%?&])[A-Za-z\d$@$!%?&]{8,}

 

邮箱

只允许英文字母、数字、下划线、英文句号、以及中划线组成

^[a-zA-Z0-9-]+@[a-zA-Z0-9-]+(.[a-zA-Z0-9_-]+)+$

名称允许汉字、字母、数字,域名只允许英文域名

^[A-Za-z0-9\u4e00-\u9fa5]+@[a-zA-Z0-9-]+(.[a-zA-Z0-9-]+)+$

 

 

 

正则表达式在js中的使用

修饰符

修饰符 描述
i 执行对大小写不敏感的匹配。
g 执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)。
m 执行多行匹配。

1、i修饰符,不区分大小写

console.log( str.replace( /o/i , "*" ) ) //替换第一个不区分大小写的o 字符为 *

 

2、g修饰符,全局匹配

console.log( str.replace( /o/g , "*" ) ) //替换所有o 字符为 *

 

3、m修饰符 ,执行多行匹配。

 

 

4、复合使用

4.1、替换不区分大小写所有的a字符为*

console.log(arr.replace(/a/ig, "*"))

 

4.2、三个修饰符可以随便混搭

 

 

正则表达式方法口诀:正2(test,exec) 字4(split,replace,search,match)

 

 

 

正则边界符 ^开始边界符 $结尾边界符

/^abc/ 必须abc开头的字符串

/^abc$/ 必须是abc字符串 (精准匹配)

/abc$/ 必须abc结尾的字符串

 

小练习:手机号码 必须 1 开头,第二个数字必须3-9,必须全部数字,11位

/^13-9{9}$/

 

 

 

正则表达式模式

[abc] 查找方括号之间的任何字符。
(?=.*[a-z]) 至少一个小写字母
(?=.*[A-Z]) 至少一个大写字母
(?=.*[A-Za-z]) 至少一个字母
(?=.*[\d]) 至少一个数字
(?=.*[@-]) 至少一个@
{4,} 字符长度大于等于4
{4,12} 字符长度大于等于4 ,小于等于12
{4} 字符长度等于4
/^[a-z0-9]$/i 有边界符没有大括号,只有一个中括号,匹配所有字母和数字的字符串,长度为 1
[0-9] 查找任何从 0 至 9 的数字。
(x|y) 查找任何包含了x或者y的字符串
[a-z] 所有小写字母
[A-Z] 所有大写字母
[\s] 空格
[\S] 非空
[\w] 匹配字母或数字或下划线 等价于 [A-Za-z0-9_ ]
[\W] 所有非字母、数字、下划线
[!@#$%^&*()-] 特殊字符
[\d] 所有数字
[\D] 所有非数字
[\u4e00-\u9fa5] 中文
量词 描述
n+ /a+/ 匹配任何包含至少一个 n 的字符串。在没有别的字符中断的情况下,可以一直匹配 a ,如果返回字符串,就是从左往右中断字符前面的所有 a
n* 匹配任何包含零个或多个 n 的字符串。
n? 匹配任何包含零个或一个 n 的字符串。

 

 

 

 

 

javascript高级

 

ES6 语法 前面学习的 js 为ES5语法

1、ES6语法对浏览器是有兼容性的 -- 针对IE浏览器

 

2、声明变量的关键字 let

var 声明的变量都有变量提升

var 声明的变量都有作用域

 

2.1、使用let关键字声明的变量具有块级作用域

 

2.2、在一个大括号中,使用let关键字声明的变量才具有块级作用域,var 关键字是不具有这个特点

 

2.3、防止循环变量变成全局变量

 

{

let a=10;

console.log(a) //10

}

console.log(a) //报错

 

2.4、使用 let 关键字声明的变量没有变量提升

 

console.log(a) //报错

let a=10;

console.log(a) //10

 

2.5、使用 let 关键字声明的变量具有暂时性死区特性

暂时性死区:

let声明的变量会锁死在一个区域内,在大括号内使用let声明的变量,只能在大括号中使用,在大括号外是拿不到这个变量的,会报错。因为let没有变量提升所以在let声明的变量上面输出变量都会报错。

当var声明的全局变量与大括号内let声明的局部变量变量名一样时,大括号内是拿不到外面var声明的变量,只能拿到let锁死在大括号内的同名变量,又因为let声明的变量没有变量提升,所以不能在let上面打印输出变量,否则会报错

 

var num3=10;

if(true){

console.log(num3) //10

var num3=12

console.log(num3) //12

}

 

var num3=10;

if(true){

console.log(num3) //报错

let num3=12

console.log(num3) //12

}

 

2.6、let不能重复声明同一个变量,但是可以修改声明过的变量值

 

 

3、const关键字声明常量 常量的值固定

 

3.1、使用const关键字声明的常量具有块级作用域

 

3.2、在一个大括号中,使用const关键字声明的常量才具有块级作用域,var 关键字是不具有这个特点

 

3.3、const关键字声明的常量也没有变量提升,

 

3.4、使用 const 关键字声明的常量具有暂时性死区特性

 

3.5、const关键字不能重复声明同一个常量,且也不可以修改声明过的常量值

 

 

 

4、数组解构

 

4.1、ES6数组解构,允许我们按照一一对应的关系从数组中提取值,然后将值赋给变量

let [a,b,c]=[1,2,3];

console.log(a) //1

console.log(b) //2

console.log(c) //3

 

let [a]=[1,2,3];

console.log(a) //1

 

let [a,,c]=[1,2,3];

console.log(a) //1

console.log(c) //3

 

 

 

5、对象解构

5.1、ES6对象解构,允许我们按照一一对应的关系从对象中提取值,但是key值必须一一对应,不能随便写变量

let {name,age}={name:"kt",age:18}

console.log(name) //kt

console.log(age) //18

 

 

let {a,b}={name:"kt",age:18}

console.log(a) //未定义

console.log(b) //未定义

 

 

 

 

6、箭头函数

6.1、写法一:函数没有参数,小括号不能省,代码片段只有一行,可以省略大括号

const fn1 = ()=> console.log("1");

fn1();

 

6.2、写法二:代码片段有多行,不可以省略大括号

const fn2 = ()=>{

console.log("1");

console.log("2");

console.log("3");

}

fn2();

 

6.3、写法三:函数如果只有一个参数,小括号可以省略

const fn3 = a=> console.log(a);

 

6.4、写法四:函数如果多个参数,小括号不可以省略

const fn4 = (a,b)=> console.log(a);

fn3(10);

 

6.5、写法五:函数如果代码片段只有一行,可以省略return

const fn5 = (a,b)=> a+b;

console.log( fn5(10,20) );

 

 

箭头函数的this指向

1、箭头函数中没有this

箭头函数没有this,会往上找this指向

but.οnclick=function(){

var num=0;

 

setInterval( function(){

this 指向window

},1000 )

 

}

 

but.οnclick=function(){

var num=0;

 

setInterval( ()=>{

this 指向 but

},1000 )

 

}

 

2、箭头函数不能作为构造函数

 

3、箭头函数没有实参集合 arguments

 

 

 

模板字符串 反引号 数字1,感叹号!左边的按键 `

支持换行,空格,字符串模板中的变量使用${ 变量名 }拼接变量

<script> div.innerHTML = ` <div class="ad"> <ul> <li> <a>${num}</a> <span>${num1}</span> <p>${num2}</p> </li> </ul>

</div> ​ console.log( 姓名:${name} 年龄:${age}`);

</script>

 

 

 

 

 

剩余参数 ...变量 扩展运算符 剩余的参数都归 ...变量管

剩余参数是会把参数全部放置在一个数组中

let [a,...a1]=[1,2,3]

console.log( a ); //1

console.log( a1 ); // [2,3]

 

let sum= ( ...argu )=>{

console.log( argu ); // [12,33,424,443,44]

}

sum(12,33,424,443,44)

 

 

forEach遍历

forEach(function(值,下标){

console.log(值,下标 );

}

argu为数组

argu.forEach(function(item,index){

console.log( item,index );

}

 

for 和 forEach 区别?

1、for 和 forEach都可以遍历数组,但是forEach方法不能终止遍历。

 

 

 

 

映射遍历,array.map(function (item,index,arr) {}),改变数组元素,具有返回值,返回新数组, arr 参数为遍历数组,item为数组元素

1、map()方法,改变复合数组元素,返回新数组,因为遍历不会停止,所以数组有多少元素就会遍历多少次

,因此返回的新数组会由多个重复的新数组组成一个数组,

所以打印新数组要加下标0,这样就只会拿到改变的一个新数组。

讯享网let array = [{id:1,age:12,ass:"那会"}, {id:3,age:16,ass:"你哈"}]; ​ let newArr = array.map(function (item,index,arr) { ​ item.id=4; ​ item.age=6 ​ return arr; ​ }) ​ //[ { id: 4, age: 6, ass: '那会' }, { id: 4, age: 6, ass: '你哈' } ] ​ console.log(newArr[0]); ​ ​ ​ //[[ { id: 4, age: 6, ass: '那会' }, { id: 4, age: 6, ass: '你哈' } ],[ { id: 4, age: 6, ass: '那会' }, { id: 4, age: 6, ass: '你哈' ]] ​ console.log(newArr);   ​ ​

 

 

2、与forEach()的区别是,forEach()方法只能遍历数组,没有返回值

let array = [1, 2];

let newArr = array.forEach(function (item) {

return item*2;

})

console.log(newArr); //undefine

 

3、map()方法,既可以遍历数组,又有返回值,可以改变数组元素,返回一个新数组

let array = [1, 2];

let newArr = array.map(function (item) {

return item*2;

})

console.log(newArr); // [2,4]

 

4、map()与forEach()方法一样,都不能终止遍历。

缺点:浪费性能,数组改变成功后不能终止,而是按照数组元素个数多次无效遍历。for()方法可以终止遍历,性能利用率最高。

 

 

 

 

 

扩展运算符 ... 三个点

1、扩展运算符可以拆分数组

let arr=[ "a" , "b" , "c" ];

 

console.log( ...arr ) //a b c

 

2、扩展运算符可以应用于数组合并

let arr=[ "a" , "b" , "c" ];

let arr1=[ "1" , "2" , "3" ];

console.log( [...arr, ...arr1] ) //[ "a" , "b" , "c","1" , "2" , "3"]

 

3、利用扩展运算符将伪数组转为真数组

li 为HTML内标签的集合,是一个伪数组

转为真数组 [ ...li ]

 

 

普通对象不能使用扩展运算符拆分,可以深复制当前的对象,可以合并对象

let obj={name:"aa"};

let obj1={age:16};

{...obj} //深复制当前对象

{ ...obj , ...obj1} //合并对象

 

 

 

对象的深浅复制

1、 对象的浅复制, 复制的是对象的指针, 然后复制之后的对象数据发生改变会影响原来的对象数据

let obj={name:"aa"};

let obj1=obj;

obj1.name="bb"

console.log( obj1 ); // {name:"bb"};

console.log( obj ); // {name:"bb"};

 

 

2、对象的深复制:

2.1、JSON.parse( JSON.stringify( 源对象 ) ) 可以实现对象的真正的深复制

let newObj=JSON.parse( JSON.stringify( obj ) );

 

2.2、递归函数实现真正的深复制

instanceof :判断复杂数据类型

var newObj={ }; function copy( newObj , oldObj ){ ​ for( const key in oldObj ){ ​ var value = oldObj[key]; ​ //判断数据类型 ​ if( value instanceof Array ){ ​ newObj[key]=[ ]; ​ //利用递归函数的方式,实现对象中的数组进行深复制 ​ copy( newObj[ key],value ); ​ }else if( value instanceof Function ){ ​ newObj[ key ] = value; ​ }else if( value instanceof Object ){ ​ newObj[key]={ } ​ //利用递归函数的方式,实现对象中的数组进行深复制 ​ copy( newObj[ key ],value ) ​ }else{ ​ newObj[ key ] = value; ​ } } } copy( newObj , oldObj )

 

 

<script> var obj = { name: "sss", arr: [1, 2, 3], obj: { id: 12, name: '11' }, say() { console.log("q"); } }

讯享网<script>        var obj = {            name: "sss",            arr: [1, 2, 3],            obj: {                id: 12,                name: '11'           },            say() {                console.log("q");           }       }   var newObj = {}; ​    function copy(newObj, obj) {                for (const key in obj) {                        var value = obj[key];                        if (value instanceof Array) {                                newObj[key] = [];                                //利用递归函数深复制                copy(newObj[key], value);                •             } else if (value instanceof Function) { •                    newObj[key] = value; ​ •               } else if (value instanceof Object) { •                    newObj[key] = {};     //利用递归函数深复制 •      copy(newObj[key], value); ​ •               } else { •                    newObj[key] = value; •               } •           } ​ •       } ​ •        copy(newObj, obj); ​ •        newObj.name = "qwa" •        newObj.arr = [3, 4, 5] •        newObj.obj = { •            name: 'new', •            id: 1 •       } •        newObj.say = function () { •            console.log("fff"); •       } •     •        console.log(newObj); •        console.log(obj); ​ •        console.log(newObj.say()); •        console.log(obj.say()); •     ​ •    </script>

 

 

控制台打印结果:

 

 

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2F%25E5%25B1%258F%25E5%25B9%2595%25E6%2588%25AA%25E5%259B%25BE%25202023-01-09%2520165238.png%3FlastModify%3D1694242997&pos_id=orAKLUQH

 

 

2.3、扩展运算符的复制对象的方法只复制第一层的话,是深复制,而第二层的复制是浅复制。(第二层指的是复杂类型(Object ,Array,Function)的属性方法。)

 

let obj={name:"aa"};

let obj1={ ...obj }

obj1.name="bb"

console.log( obj1 ); // {name:"bb"};

console.log( obj ); // {name:"aa"};

 

 

 

 

 

 

复制对象的方法 Object.assign()

let 新对象={ } ;

Object.assign( 目标对象(新对象),源对象(要复制的对象))

1、这个方法只复制第一层的话,是深复制,而第二层的复制是浅复制。(第二层指的是复杂类型(Object ,Array,Function)的属性方法。)

 

2、如果两个对象有属性名相同时,源对象会将目标对象的属性值覆盖变成源目标的属性值。

 

 

 

判断数据类型

1、typeof 判断简单类型

console.log( typeof num ) //返回简单数据类型的字符串名称

 

2、instanceof 判断复杂的(引用类型)数据类型

console.log( arr instanceof Array ) //返回布尔值

 

 

高阶函数

1、函数可以作为参数传递, 例如定时器,find()方法也是一个高级函数

 

2、把一个函数当做另一个函数的参数

fn( function(){} )

 

 

回调函数 callback

function fn(a,b,callback){

callback(a+b);

}

 

fn(13,12,function(result){

console.log( result ); // 25

})

 

1、可以将函数内部的结果返回出来

 

2、先执行完函数,再执行里面的回调函数

 

 

 

闭包 本质上就是函数

 

什么是闭包?

1、闭包:指有权访问另一个函数作用域中变量的函数,这个函数就叫闭包。

 

2、闭包就是能够读取其他函数内部的变量的函数。本质上就是函数,只是这个函数有权访问另一个函数作用域中的变量。

 

3、一个函数内的闭包,在函数外部是不能调用的,也不能拿到这个闭包的返回值。

3.1、要拿到这个闭包的返回值就要通过函数内的return 返回出这个闭包。再通过这个函数就可以在函数外部拿到闭包的返回值了。

 

3.2、在函数内使用return 返回出这个闭包时,同时也调用了这个闭包,所以调用这个函数时闭包内的执行语句也会同时执行。但是返回值还是闭包内的返回值。

 

function   fn(){ ​ •     var  b=20; ​ •          function   backFn(){ ​ •             let c=10; ​ •             console.log(b+c); ​ •            return  b+c; ​ •           } ​ console.log(b) ​  return  backFn();    // backFn() - 闭包 ​ } ​ ​ ​ var fnn=fn();   //fnn = backFn()   //fnn=b+c;     //fn()函数会同时运行本身的执行语句以及闭包的执行语句     20   30 ​ console.log( fnn )     //30 ​ 此时控制台打印    20   30   30 

 

 

3、闭包的作用:

3.1、主要作用是延伸了变量的作用范围,让一个作用域可以访问另一个函数的局部变量

 

3.2、闭包可以作为一个函数内部的私有函数,在这个函数外部是无法调用闭包的。

 

3.3、作为一个函数的闭包,可以直接访问这个函数的内部变量。

 

 

 

闭包的优缺点:

1、优点:

①保护函数内的变量安全,实现封装,防止变量流入其他环境发生命名冲突

②在内存中维持一个变量,可以做缓存(但使用多了同时也是一项缺点,消耗内存)。

③匿名自执行函数可以减少内存消耗。(function(){})();

 

2、 缺点:

①被引用的私有变量不能被销毁,增大了内存消耗,造成内存泄漏,解决方法是可以在使用完变量后手动为它赋值为null。

②其次由于闭包涉及跨域访问,所以会导致性能损失,我们可以通过把跨作用域变量存储在局部变量中,然后直接访问局部变量,来减轻对执行速度的影响。

 

 

闭包的优缺点:简写

一、闭包的优点:

1.变量长期驻扎在内存中,可以重复使用变量,

 

2.避免全局变量的污染

 

3.私有成员的存在

 

二、闭包的缺点

1.常驻内存 增大内存的使用量 使用不当会造成内存的泄露

 

2.闭包会使函数中的变量都被保存在内存中,内存消耗很大,所以不能滥用闭包,

 

3.否则会造成网页的性能问题,可能会导致内存泄露。解决方法是在退出函数之前,将不使用的变量全部删除。

 

 

 

闭包的应用场景

自运行函数 (function(){})() 也叫小闭包

 

1、for循环var声明的 i,在函数内调用 i

 

for(var i = 0 ; i < li.length ; i++ ){

//立即执行函数也称为小闭包,因为立即执行函数里面的任何一个函数都可以使用它的 i 这个变量。

( function(i){

li[i].oncilck=function(){

console.log( i );

}

} )( i )

}

 

 

 

2、 打车闭包应用

讯享网var car = (function () { ​ •            var start = 13; // 起步价 局部变量 ​ •            var total = 0; // 总价 局部变量 ​ •            return { ​ •                // 正常的总价 ​ •                price: function (n) { //n 公里数 ​ •                    if (n <= 3) { ​ •                        total = start; ​ •                   } else { ​ •                        total = start + (n - 3) * 5 ​ •                   } ​ •                    return total; ​ •               }, ​ •                // 拥堵之后的费用 ​ •                yd: function (flag) { ​ •                    return flag ? total + 10 : total; ​ •               } ​ •           } ​ •     })(); ​ ​

 

console.log(car); // 返回一个对象,含有两个方法,方法用到了另一个函数的两个变量,这两个方法就叫闭包。

 

console.log(car.price(5)); // 23

console.log(car.yd(true)); // 33

 

console.log(car.price(1)); // 13

console.log(car.yd(false)); // 13

 

 

 

 

数组的方法

1、Array.from 把一个伪数组变成一个真数组

var li=Array.from( li )

 

2、find() 方法 , 查找返回符合条件的第一个元素

li=[...li];   或者   li= Array.from(li);  //伪数组转真数组     ​ arr代表数组本身 ​ let  arr=  li.find( function( item,index,arr ){ ​ •      console.log(item,index,arr ); ​ •     if(item.innerText >2){ ​ •          return  item; ​   } ​ }) ​ ​ ​ •     console.log(arr);    // item代表的元素 ​ ​ ​ let  arr=[12,33,221,232].find( function( item ){ ​ •    return   item>33; ​ } ) ​ console.log(arr); ​ ​

 

 

3、findIndex() 方法 查找返回符合条件的第一个元素的下标

 

let index=[12,33,221,232].find( function( item ){

return item>33;

} )

console.log(index);

 

 

 

filter() 方法 查找返回符合条件的元素的数组 -- 过滤

 

let a=[1,23,44,23,445,55].filter((item,index)=>{ return item>10; }) console.log(a); //[23, 44, 23, 445, 55]

 

 

 

some() 方法 返回布尔值,当有一个条件成立的时候,返回true。 当所有条件都不成立的时候返回false。

当有一个为真,则返回真。所有条件为假,返回假 相当于或

 

let b=[1,23,44,23,445,55].some((item,index)=>{ return item>10; }) console.log(b); //true

 

let c=[1,23,44,23,445,55].some((item,index)=>{ return item>500; })

console.log(c); //false

 

 

every() 方法 返回布尔值,当有一个条件不成立的时候,返回false。 当所有条件都成立的时候返回true。

当有一个为假,则返回假。所有条件为真,返回真 相当于与

 

let b=[1,23,44,23,445,55].every((item,index)=>{ return item>10; }) console.log(b); //false

 

let c=[1,23,44,23,445,55].every((item,index)=>{ return item>0; })

console.log(c); //true

 

 

 

 

trim() 方法 去除字符串的前后空格 ,不能去除中间的空格

 

trimStart() 去除字符串的前空格

 

trimEnd() 去除字符串的后空格

 

 

 

 

JSON文件格式 后缀名 .json

1、json是一个轻量级的文本格式语言(前后端数据交换)

 

2、JSON.parse(); 转换成json格式的对象或者数组

so是一个定义的复合数组,复合数组是数组的每一个元素都是对象。

JSON.parse( so );

 

 

3、JSON.stringify(); 转换成json格式的字符串

so是一个定义的复合数组,复合数组是数组的每一个元素都是对象。

JSON.stringify( so );

 

将复合数组缓存时,先将复合数组转为JSON格式的字符串再缓存。

 

缓存多条数据 (例如缓存多个账号密码)

讯享网先判断缓存中是否有这个key键值 ​ 没有则先创建一个这个键值的空数组 ​ 然后创建一个对象, ​ 将获取的账号密码放到对象中 ​ 然后通过push这个数组方法将对象追加到数组中 ​ 这时数组变成了一个复合数组 ​ 再通过json.stringify()方法将复合数组转为json格式的字符串 ​ 再将这个字符串通过localStorage.setItem()方法缓存 ​ 缓存过后,就有这个键值了,再写else里面追加多条数据 ​ 先声明一个变量获取缓存中的复合数组, ​ 因为是字符串所以先通过json.parse()方法将字符串转为数组再进行操作 ​ 再声明一个对象接收新创建的账号密码 ​ 先判断这个新创建的账号是否已经被创建 ​ 通过 find() 或者 filter()或者some()方法判断 ​ find()没有重复时返回的是undefind ​ filter没有重复时返回的是空数组 ​ some没有重复时返回是false ​ 最好用some方法,因为它返回的是布尔值,好做判断 ​ 将复合数组通过some()方法判断是否有重复 ​ 有重复弹窗警告说已有账号注册 ​ 如果没有重复再将这个对象追加到复合数组中去 ​ 再将新的复合数组通过json.stringify()方法转为字符串 ​ 再将字符串通过localStorage.setItem()方法缓存 ​ 这样就可以缓存多条数据了 ​ 登陆调用时,再将获取的字符串转为复合数组, ​ 通过forEach方法遍历数组,通过find方法或some方法匹配相同账号密码, ​ 进行判断,有相同的,则登陆成功 ​ 没有相同的则弹窗返回登陆失败

 

 

 

 

 

ES6 对象的属性简写:如果键值和名称一样,比如:userName:userName,就可以简写成 userName。

 

ES6 对象的方法简写:fn(){} 方法名(){}

 

 

startWith() 查找字符串开头第一个的子字符串或者字符是否存在(区分大小写),存在返回true

 

 

endsWith() 查找字符串结尾最后一个的子字符串或者字符是否存在(区分大小写),存在返回true

 

 

repeat() 方法 字符串.repeat(n) n为数字 重复字符串多少个

 

 

Set对象 自动去重,是一个不会有重复值的Set对象

定义Set对象 使用new关键字创建Set对象

 

let srr=new Set( [1,2,3,3,4,1] )

console.log( srr ) // srr是一个Set对象

 

add() 添加元素 实例化对象的add方法添加元素,不能添加同一个元素

srr.add("a");

srr.add("b");

 

 

Set对象的· size属性,获取当前Set对象的长度

 

利用Set对象去重

arr是一个数组

let newArr=new Set( arr )

 

newArr是一个对象

利用扩展运算符(...),把Set对象转换成真数组

[ ...newArr ];

 

一步到位

let newArr= [ ...new Set( [1,2,3,3,4,3,4] ) ];

 

判断是否存在某个元素 实例化对象的has() 方法 返回布尔值 true 、false

srr.has("a")

 

删除指定的Set元素 delete()

srr.delete("a")

 

清空 Set对象所有元素 clear()

srr.clear()

 

 

普通对象:

1、相同的键名,合并时,键名的值会覆盖

2、普通对象的键名永远值都是字符串类型

 

Map对象 键名多样化,可以字符串,数组,对象等等

let mobj=new Map();

 

1、添加元素 实例化对象的set方法添加元素

let obj={name:"ddd"};

mobj.set("name","kfi");

mobj.set( obj , [1,2,3] )

 

2、获取对象的长度 实例化对象的size方法获取对象的长度

mobj.size //2

 

3、获取对象的值 实例化对象的get方法获取对象的值

mobj.get(obj) // [1,2,3]

mobj.get("name") // kfi

 

 

 

js数据类型 8种

简单的数据类型:String Number Boolean Null Undefined Symbol (ES6新增) BigInt (ES10新增)

12 //Number

12n //BigInt : 可以表示任何位数的整数

 

复杂的数据类型 : Object (Array,Function,Object)

 

ES6新增的简单数据类型

Symbol 值是唯一的,不可变的。即使声明两个一模一样的Symbol类型,他们也是不会相等的

let sm=Symbol("定义的Symbol数据类型");

 

let s1=Symbol("name");

let s2=Symbol("name");

console.log( s1==s2 ) // false

 

注意:Symbol前面不能使用 new 操作符。

如果被用作一个对象的属性,那么这个属性也是不能枚举的

 

 

 

 

for in 的使用

 

1、for in 遍历的对象获取的是对象的键值

对象的遍历

for(const key in obj){

console.log( 对象的key是:${key} , 对象的value值:${ obj[key] } );

}

 

2、for in 遍历的数组获取的是数组的下标,然后下标是字符串类型,不能做运算,要转成Number类型

数组的遍历

for(const index in arr){

console.log( 对象的key是:${index} , 对象的value值:${ arr[index] } );

}

 

 

 

for of 的使用 主要遍历具有迭代器的东西

普通对象是没有迭代器的,所以for of 不能遍历普通对象

可以遍历数组和复合数组、Set对象、Map对象及具有迭代器的对象

for(const item of arr ){

console.log( item ) //数组的元素

}

 

 

 

 

for of 和 for in 、for、forEach 的区别?

1、for遍历的效率最高,缺点是不能遍历普通对象

 

2、forEach缺点是遍历时不能终止,同时不能遍历普通对象

 

3、for in遍历的数组的索引(即键名),而for of遍历的是数组元素值(每一项)

 

4、for in 总是得到对象的key 或者数组的,字符串的索引(下标,下标类型是字符串类型)

 

5、for of总是得到对象的value值或者数组、遍历字符串的元素值(每一项)

 

6、for in可以遍历普通对象,for of 、for、forEach 不能遍历普通对象。但是for of 可以遍历Set对象和Map对象和具有迭代器的对象。

 

 

 

 

 

 

Object.keys() 方法 获取对象自身所有的属性(键名),返回的值是数组

 

let arr = Object.keys( obj )

 

 

Object.values() 方法 获取对象自身所有的属性值(键值),返回的值是数组

 

 

 

 

Object.defineProperty() 方法 定义新属性或者修改原有的属性 通过这个方法添加的属性,默认不能被遍历、修改、删除,私有属性。

Object.defineProperty( 目标对象 , key , { value的对象配置 } )

 

添加属性

Object.defineProperty( obj , "num" , {

//value定义属性是值

value:10,

 

// enumerable 默认值为false, 为false时,则不能被遍历,为true,可以被遍历出来

enumerable:false,

 

// writable 默认值为false, 为false时,则不能修改这个属性值,为true,可以修改

writable:false,

 

// configurable 默认值为false, 为false时,则不能删除这个属性值,为true,可以删除

configurable:false

} )

 

修改对象属性

obj.num=13;

 

删除对象属性 delete

delete obj.num;

 

 

 

 

创建类 通过关键字 class 创建 类名首字母大写 本质上也是一个构造函数,

 

class Star {

//1、默认都有一个构造器 constructor 本质上就是一个函数,类的共有属性放到constrctor里面

constructor(name,age){

this.name=name;

this.age=age

}

 

//1.1、类里面所有的函数不需要function

sing(){

consol.log(${this.name}的技能是唱歌)

}

 

//1.2、类里面的函数不需要逗号隔开

dance(){

console.log(${this.name}的技能是跳舞)

}

}

 

//2、利用类创建对象 通过关键字 new 类名()

let lad=new Star("lishi",14);

 

// 3、调用类里面的函数

lad.sing();

lad.dance();

 

 

 

 

 

类的继承 通过extends 继承父类的属性和方法

子类 extends 父类{ }

 

class Son extends Father{

constructor( x, y){

//1、如果继承了父类的属性和方法,需要在子类的constructor里面的顶层创建超级构造函数 super()

 

//2、调用父类的构造函数通过子类传参给父类的属性

super( x, y );

 

//3、如果继承了父类的属性和方法,写了子类的constructor,就必须在子类的constructor里面的顶层创建超级构造函数 super() ,如果没写,则不需要

 

//4、如果子类有属性与父类相同,就近原则,获取的是子类属性,如果没有就继承父类的属性,如果父类没有,就返回undefined。

 

 

}

}

 

 

 

 

 

extends 继承中的属性和方法查找的原则:就近原则

1、继承中如果实例化子类输出一个方法:先看子类是否有这个方法,如果有就先执行子类的方法

 

2、继承中,如果子类里面没有,就去父类中查找有没有这个方法,如果有就执行父类的这个方法

 

3、如果父类没有,就返回undefined。

 

class Son extends Father{

sing{

// super.say() 调用父元素中的普通函数

 

}

 

}

 

 

 

 

对象添加静态成员和实例成员

构造函数中的属性和方法我们称为成员

function Star(name,age){

this.name=name;

this.age=age;

}

 

1、实例成员就是构造函数内部通过this添加的成员,比如name age 就是实例的成员

 

1.1、实例成员只能通过实例化对象来访问

 

 

 

2、静态成员的添加在构造函数本身上添加的成员--变成构造函数的私有成员

Star.sex="男";

 

2.1、静态成员不能通过实例对象来访问

只能通过本身来访问

console.log( Star.sex ) // 男

 

 

 

 

 

 

 

原型 prototype:公共的属性定义到构造函数里面,公共的方法我们放到原型对象上面定义

1、任何对象都有一个原型,所有对象的最终原型都是Object原型对象(Object.prototype),除了最后的Object对象。( Object对象的原型是null)

 

2、构造函数的原型是实例化对象的__ proto__指向的 构造函数的prototype对象

 

 

重点

我们可以把那些不变的方法,直解定义在prototype对象上,这样所有的实例化对象都可以访问这个方法

 

1、什么是原型?

原型就是一个对象,prototype即为原型对象,是构造函数所有对象所共享的。(同一个原型对象)

 

2、原型的作用是什么?

解决构造函数存在的浪费内存问题,同时可以共享方法

let star = new Star();

//Star构造函数的原型上定义了一个公共的方法

Star.prototype.sing=function(){

console.log( "我会唱歌" );

}

//实例化对象调用存到原型对象的公共方法

star.sing(); //我会唱歌

 

 

对象原型 __ proto __

 

1、对象都会有一个属性 __ proto__ 指向 构造函数的prototype对象

 

2、 __ proto __ 对象原型和原型对象prototype是等价的

 

3、__ proto __ 对象原型的意义就是为对象的查找机制提供一个方向,或者一条路线

 

 

原型总结:

1、构造函数通过new 关键字实例化对象 let ldh=new Star();

 

2、构造函数通过prototype得到构造函数的原型对象(prototype) Star.prototype

 

3、ldh实例化对象通过 __ proto__ 指针,指向构造函数的原型对象 ldh.__ proto__ === Star.prototype

 

4、构造函数的原型对象通过 constructor 属性指向 原构造函数( Star() )

 

5、因为ldh实例化对象通过 __ proto__ 指针指向的是构造函数的原型对象,所以ldh实例化对象通过 __ proto__ 指针再通过原型对象的constructor 属性可以指向原构造函数( Star() )

 

6、如5所示,所以 ldh.__ proto__.constructor === Star.prototype.constructor

 

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2F%25E5%259B%25BE%25E7%2589%258720230106170955.jpg%3FlastModify%3D1694242997&pos_id=0rpf2AWx

 

 

 

 

 

构造函数的缺点:存在浪费内存的问题

 

解决方法:通过构造函数的原型 prototype 来规避构造函数的缺点(存在浪费内存的问题)

 

 

 

 

 

javascript规定,每一个构造函数都有一个prototype属性,指向另一个对象,注意prototype就是一个对象,这个对象的所有属性和方法,都会被构造函数所拥有。

 

constructor 构造函数

 

1、对象原型(__ proto__)和构造函数原型对象(peototype)里面都有一个属性 constructor ,constructor我们称为构造函数,它指回构造器本身

 

2、constructor构造函数主要用于记录对象用于那个构造函数,它可以让原型对象重新指向原来的构造函数

 

 

 

 

 

原型链

js 成员的查找机制 (规则)

1、当访问一个对象的属性(包括方法)时,首先查找这个对象自身有没有这个属性和方法。

 

2、如果没有就查找它的原型(也就是 __ proto__ 指向的prototype 原型对象( 构造函数.prototype ))

 

3、如果还没有查到就查找原型对象的原型(Object的原型对象(Object.prototype ) )

 

4、以此类推一直找到null为止

 

5、这种路线或者方法就叫原型链

 

对象.__ proto__ // 构造函数.prototype

 

对象.__ proto__ === 构造函数.prototype //true

 

 

 

构造函数.prototype.__ proto__ // Object.prototype

 

构造函数.prototype.__ proto__ === Object.prototype //true

 

 

 

Object.prototype.__ proto__ //null

 

Object.prototype.__ proto__===null //true

 

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2F%25E5%259B%25BE%25E7%2589%258720230106170200.jpg%3FlastModify%3D1694242997&pos_id=HJJy6EUP

 

 

 

严格模式

 

js开启严格模式 'use strict' : 在js文件或者script标签的首行写上 'use strict' 。

1、在严格模式下,变量必须先声明再使用

 

2、在严格模式下,不能随意删除已经声明好的变量

 

3、在严格模式下,全局作用域下面的this(原指向window)指向 undefined

 

4、在严格模式下,构造函数不加new调用,this指向undefined,使用new实例化对象后,this指向当前对象。

 

5、在严格模式下,特例:定时器的this指向不受影响,还是指向window

 

6、在严格模式下,函数的形参不能重名

 

 

 

 

递归函数:函数内部自己调用自己,这个函数就是递归函数

function fn(){

//使用递归函数第一步找到临界点 使用 if 判断终止函数,不然会陷入死循环。

求阶层

fn( n ){

 

if(n==1){

return 1;

}

 

return n*fn(n-1);

}

 

console.log( fn( 6 ) ); //720

 

 

 

递归函数实现对象真正的深复制

var   newObj={ }; ​ ​ ​ function copy( newObj , oldObj ){ ​ •    for( const  key  in  oldObj ){ ​ •        var   value  =  oldObj[key]; ​ •        //判断数据类型 ​ •        if( value   instanceof  Array ){ ​ •                 newObj[key]=[ ]; ​ ​ ​ •                  //利用递归函数的方式,实现对象中的数组进行深复制 ​ •               copy( newObj[ key ],value ); ​ ​ ​ •         }else  if(  value  instanceof  Function ){ ​ ​ ​ •               newObj[ key ] = value; ​ ​ ​ •             }else  if( value  instanceof  Object ){ ​ •                 newObj[key]={ }; ​ ​ ​ •        //利用递归函数的方式,实现对象中的数组进行深复制 ​ •               copy( newObj[ key ],value ); ​ ​ ​ •           }else{ ​ •              newObj[ key ] = value; ​ •         } ​   } ​ } ​ ​ ​ copy( newObj , oldObj ) ​ ​ ​ ​

 

 

 

 

同步与异步的区别

一:同步与异步

1、同步:同步是指一个进程在执行某个请求的时候,如果该请求需要一段时间才能返回信息,那么这个进程会一直等待下去,直到收到返回信息才继续执行下去。

 

 

2、异步:异步是指进程不需要一直等待下去,而是继续执行下面的操作,不管其他进程的状态,当有信息返回的时候会通知进程进行处理,这样就可以提高执行的效率了。

即异步是我们发出的一个请求,该请求会在后台自动发出并获取数据,然后对数据进行处理,在此过程中,我们可以继续做其他操作,不管它怎么发出请求,不关心它怎么处理数据。

 

 

3、以上总结起来,通俗地讲,也就是说,同步需要按部就班地走完一整个流程,完成一整个动作,打个比方:同步的时候,你在写程序,然后你妈妈叫你马上拖地,你就必须停止写程序然后拖地,没法同时进行。

而异步则不需要按部就班,可以在等待那个动作的时候同时做别的动作,打个比方:你在写程序,然后你妈妈让你马上拖地,而这时你就贿赂你弟弟帮你拖地,于是结果同样是拖好地,你可以继续敲你的代码而不用管地是怎么拖的哈哈。

 

 

二:同步与异步适用的场景

就算是ajax去局部请求数据,也不一定都是适合使用异步的,

比如应用程序往下执行时以来从服务器请求的数据,那么必须等这个数据返回才行,这时必须使用同步。

而发送邮件的时候,采用异步发送就可以了,因为不论花了多长时间,对方能收到就好。总结得来说,就是看需要的请求的数据是否是程序继续执行必须依赖的数据

 

 

 

 

原生js对象object的属性和方法的网站:JavaScript 对象基础 - 学习 Web 开发 | MDN (mozilla.org)

 

 

 

 

object.defineProperty(追加属性的对象,"属性名",{})

1、configurable

当且仅当该属性的 configurable 键值为 true 时,该属性的描述符才能够被改变,同时该属性也能从对应的对象上被删除。 默认为 false。

2、enumerable

当且仅当该属性的 enumerable 键值为 true 时,该属性才会出现在对象的枚举属性中。 默认为 false。

 

 

数据描述符还具有以下可选键值:

3、value

该属性对应的值。可以是任何有效的 JavaScript 值(数值,对象,函数等)。 默认为 undefined。

 

4、writable

当且仅当该属性的 writable 键值为 true 时,属性的值,也就是上面的 value,才能被赋值运算符 (en-US)改变。 默认为 false。

 

 

存取描述符还具有以下可选键值:

5、get

属性的 getter 函数,如果没有 getter,则为 undefined。当访问该属性时,会调用此函数。执行时不传入任何参数,但是会传入 this 对象(由于继承关系,这里的this并不一定是定义该属性的对象)。该函数的返回值会被用作属性的值。 默认为 undefined。

6、set

属性的 setter 函数,如果没有 setter,则为 undefined。当属性值被修改时,会调用此函数。该方法接受一个参数(也就是被赋予的新值),会传入赋值时的 this 对象。 默认为 undefined。

 

let obj={},

var bValue = 38;

 

object.defineProperty(obj,"age",{

//返回你想获取的属性值,与value(属性值)和writable(可以修改)冲突

get(){

return: bValue ;

},

set(newValue){

bValue =newValue

},

//可以枚举

enumerable : true,

//可以删除

configurable : true

})

 

 

 

 

什么是栈,什么是堆

栈(stack):由操作系统自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈;

堆(heap):一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收,分配方式倒是类似于链表。

 

 

 

 

面试题:{ }下的块级作用域下的var和函数声明的变量与let和const声明的变量的不同

 

1、{ }的块级作用域只针对具有块级作用域的声明关键字有作用(let,const)

 

 

2、对var没有影响,在{ }中使用var声明的变量都是全局作用域下的变量

 

 

3、function关键字声明的变量,都会提升到全局作用域的最顶部,因为函数是一等公民,它可以作为变量的值,也可以作为参数,也可以作为函数的返回值

 

 

 

 

子类继承父类中的super()

1、子类的构造器中不写super(),就没有this指向

1.1、因为派生类不会创造新的this,只有通过super(),继承基类的this,才能像基类一样通过this实例化对象

 

 

2、子类的构造器顶部必须写super()

2.1、子类this必须写在super之后

 

 

 

 

 

删除确认 confirm("是否确定删除")

$(".del").on("click", function () {

if (confirm("是否确定删除")) {

$(".del").parent().remove()

}

})

 

 

 

js网页跳转

location.href="百度一下,你就知道";

 

 

 

 

断点调试

1.在浏览器检查中的测试台旁边的源代码中打断点

 

2.在js代码中打断点 debugger

debugger

 

 

 

 

video视频标签方法

1.播放 play()

 

2.重载 load()

 

3、暂停 pause()

 

 

 

页面全屏方法

1、全屏: document.body.requestFullscreen()

2、退出全屏:document.body.exitFullscreen()

 

 

 

 

函数封装过滤敏感词汇方法

1、封装方法

讯享网 //str:所传入需要过滤的字符串 ​ function filterSensitiveWords(str) { ​ // 敏感词列表 ​  const sensitiveWords = ["CNM", "SB", "NMSL", "MB", "FUCK", 'cnm', 'sb', 'nmsl', 'mb', 'fuck', '装逼', '草泥马', '特么的' ​ •   , '**' ​ •   , '撕逼' ​ •   , '玛拉个逼' ​ •   , '爆菊' ​ •   , 'JB' ​ •   , '呆逼' ​ •   , '*' ​ •   , '齐B短裙' ​ •   , '法克鱿' ​ •   , '丢你老母' ​ •   , '打飞机' ​ •   , '傻逼' ​ •   , '绿茶婊' ​ •   , '***' ​ •   , '婊渣' ​ •   , '*爆了' ​ •   , '买了个表' ​ •   , '已撸' ​ •   , '妈蛋' ​ •   , '逗逼' ​ •   , '我靠' ​ •   , '碧莲' ​ •   , '碧池' ​ •   , '日了狗' ​ •   , '吃翔' ​ •   , '你妹' ​ •   , '杂种' ​ •   , '黑鬼' ​ •   , '东亚病夫' ​ •   , '蛮夷' ​ •   , '**' ​ •   , '生殖器' ​ •   , '**' ​ •   , '**泥马' ​ •   , '你妈死了' ​ •   , '你生儿子没**' ​ •   , '***' ​ •   , '***大爸' ​ •   , '***个仙人板板' ​ •   , '***真是个小可爱' ​ •   , '好想摸你' ​ •   , '老板大傻逼' ​ •   , '老板草泥马' ​ •   , '**你妈' ​ •   , '你****光' ​ •   , '套你猴子' ​ •   , '小瘪三' ​ •   , '他妈了个巴子' ​ •   , '抓到你就嘿嘿嘿' ​ •   , '涩情' ​ •   , '黄***' ​ •   , '祝你全家出车祸' ​ ]; ​ // 构造正则表达式 ​  const regExp = new RegExp(sensitiveWords.join('|'), 'gi'); ​  // 将每个敏感词替换为‘*’ ​  return str.replace(regExp,'*'.repeat(str.length)); ​ } ​ ​

 

使用: input.value = filterSensitiveWords(input.value)

 

 

 

 

对防抖和节流的理解

1、防抖和节流都是前端性能优化的常用技术。

 

2、防抖是指在一定时间内,如果事件被触发多次,只执行最后一次。比如说,当用户连续点击一个按钮时,我们可以设置一个时间间隔,只有当用户停止点击一段时间后,才会执行相应的操作。这样可以避免因为用户频繁点击而导致的性能问题。

 

3、节流是指在一定时间内,只执行一次事件。比如说,当用户滚动页面时,我们可以设置一个时间间隔,只有当用户停止滚动一段时间后,才会执行相应的操作。这样可以避免因为用户频繁滚动而导致的性能问题。

 

4、总的来说,防抖和节流都是为了减少事件触发的次数,从而提高页面的性能和用户体验。

 

5、以下是防抖和节流的封装函数示例:

防抖函数:

function debounce(func, delay) {  let timer = null;  return function() {    const context = this;    const args = arguments;    clearTimeout(timer);    timer = setTimeout(function() {      func.apply(context, args);   }, delay); }; }

节流函数:

讯享网function throttle(func, delay) {  let timer = null;  return function() {    const context = this;    const args = arguments;    if (!timer) {      timer = setTimeout(function() {        func.apply(context, args);        timer = null;     }, delay);   } }; }

以上两个函数都接受两个参数:要执行的函数和时间间隔。防抖函数会在时间间隔内只执行最后一次事件,而节流函数会在时间间隔内只执行一次事件。可以根据实际需求选择使用哪个函数。

 

 

 

 

js中获取摄像头权限后实现视频功能的代码: navigator.mediaDevices.getUserMedia({ video: true })

 var btn = document.getElementsByTagName('button')[0] ​ •    btn.onclick = () => { ​      判断浏览器是否支持此方法 ​ •      if(!navigator.mediaDevices.getUserMedia){ ​ •        alert('此浏览器不支持该方法') ​ •        return ​ •     } ​      点击获取摄像头权限 ​ •      navigator.mediaDevices.getUserMedia({ video: true }) ​ •       .then(function (stream) { ​           // 获取到摄像头视频流后的处理逻辑 ​ •          var video = document.querySelector('video'); ​ •          video.srcObject = stream; ​ •          video.play(); ​ •       }) ​ •       .catch(function (error) { ​           // 获取摄像头权限失败的处理逻辑 ​ •              alert('获取权限失败') ​ •       }); ​ •   } ​ ​

 

 

 

 

将多维数组转为一维数组的方法 flat

在JavaScript中,flat是一个数组方法,它用于将嵌套多层的数组降维成一维数组。该方法会创建一个新数组,其中包含原数组中的所有元素,并将嵌套的数组展开。

flat方法的语法如下:

讯享网arr.flat([depth])

这里的arr是要操作的数组,depth是一个可选参数,表示要展开的嵌套层数。默认情况下,depth的值为1,即只展开一层。

让我们看一些示例来理解flat方法的用法:

示例 1:展开一层嵌套数组

const arr = [1, 2, [3, 4]]; const flattened = arr.flat(); console.log(flattened); // 输出: [1, 2, 3, 4]

在上面的示例中,原数组arr中包含一个嵌套的数组[3, 4]。通过使用flat方法,我们将这个嵌套数组展开成了一维数组[1, 2, 3, 4]。

示例 2:展开多层嵌套数组

讯享网const arr = [1, 2, [3, [4, 5]]]; const flattened = arr.flat(2); console.log(flattened); // 输出: [1, 2, 3, 4, 5]

在上面的示例中,原数组arr中包含两层嵌套数组。通过指定depth参数为2,我们将多层嵌套数组展开成了一维数组[1, 2, 3, 4, 5]。

需要注意的是,flat方法会跳过空位(undefined)、删除空位,以及忽略非数组元素。此外,flat方法不会改变原数组,而是返回一个新数组。

如果你的 JavaScript 环境不支持flat方法,你可以使用其他方式实现数组的展开,比如使用递归或使用reduce方法来手动展开数组。

 

 

 

 

事件循环

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703202846941.png%3FlastModify%3D1694242997&pos_id=QFwPgF4J

1、浏览器的进程模型

何为进程?

1、程序运行需要专属的内存空间,内存空间就是进程

2、每个应用至少一个进程,进程之间相互独立,即使通信也要双方同意

3、进程为了隔离,不至于一个程序出问题影响全局

 

何为线程

1、运行代码的环境为线程

2、一个进程至少一个线程,第一个自动创建的线程为主线程,主线程结束,整个进程结束

3、一个进程可以包含多个线程

 

浏览器是一个多进程多线程的应用程序

1、浏览器的进程分类:浏览器进程、网络进程、渲染进程

2、浏览器进程:主要赋值界面交互、子进程管理等。浏览器内部会启动多个线程来处理不同的任务

3、网络进程:负责加载网络资源。网络进程内部会启动多个线程来处理不同的网络任务

4、渲染进程(重点):进程开始会创建一个主线程,主线程主要负责HTML、CSS、JS代码。

5、默认情况下浏览器会为每个标签页开启一个新的渲染进程,以保证不同的标签页之间不相互影响。谷歌浏览器以后会改变,因为太吃内存了,可能改成一个站点一个进程

 

 

2、渲染主线程是如何工作的?

1、渲染主线程做的事情最多:解析HTML、CSS、计算样式、布局、处理图层、每秒把页面画60次,执行全局JS代码、执行事件处理函数、执行计时器的回调函数等等

2、思考:为什么渲染进程不适应多个线程来处理这些事情?结论:没有办法实现

3、如何调度任务?使用排队

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703160637367.png%3FlastModify%3D1694242997&pos_id=jojvxMSL

4、 在w3c标准文档中叫事件循环 event loop,在浏览器中叫消息循环message loop,指的是同一件事

5、在刚开始的时候,渲染主线程会进入一个无限循环

6、 每一次循环会检查消息队列中是否有任务存在。如果有,就取出第一个任务执行,执行完一个后就进入下一循环;如果没有就进入休眠状态。

7、其他所有线程(包括其他进程的线程)可以随时向消息队列添加任务。新任务会加到消息队列的末尾。在添加新任务时,如果主线程是休眠状态,则会将其唤醒以继续循环拿取任务

8、这样一来就可以让每一个任务有条不紊的、持续的进行下去了

10、整个过程,被称为事件循环(消息循环)

 

 

3、何为异步?

1、代码在执行过程中,会遇到一些无法立即处理的任务。

比如:定时器、网络通信的回调函数、用户操作后需要执行的任务(事件委托)

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703162639344.png%3FlastModify%3D1694242997&pos_id=ctUCp27b

2、定时器涉及计时线程,如果主线程要等待计时结束在执行下一个任务2,就会造成阻塞,但是也是有一个好处的,就是它们在时间线上是一样的,这也称之为同步(阻塞模式)

3、因为主线程处理的任务是很多很重要的,所以不能造成阻塞,所以浏览器提出异步来解决这个问题

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703163600163.png%3FlastModify%3D1694242997&pos_id=ned6S3pM

4、如何理解js的异步?

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703163902506.png%3FlastModify%3D1694242997&pos_id=GMJCdV8z

5、js为何会阻碍渲染?

因为js和渲染它们都在浏览器的渲染主线程上,都得排队

6、任务有优先级吗?

在渲染主线程中,任务是没有优先级的,在事件队列(消息队列)中先进先出,但是消息队列有优先级。

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703171232887.png%3FlastModify%3D1694242997&pos_id=6LsXZzYp

7、微队列的单词:microtask queue

8、浏览器以前的微队列不变,依然是VIP,但是以前的宏队列的说法被现在的W3C的最新标准取消,细分了更多的队列,然后浏览器根据实际情况执行不同队列的任务,但是同类的任务必须在一个队列中

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703172659711.png%3FlastModify%3D1694242997&pos_id=LvkobZvM

9、添加任务到微队列的主要方式主要是Promise和MutationObserver

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703172919032.png%3FlastModify%3D1694242997&pos_id=mbKlfL

10、浏览器还有很多队列,但是和我们开发关系不大,不作考虑

11、阐述一下js的事件循环?

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703173637624.png%3FlastModify%3D1694242997&pos_id=Els2Rz4l

12、js中的计时器能做到精确计时吗?答:不行。为什么?

20230724024159.png?origin_url=file%3A%2F%2FD%3A%2Fjavaweb%25E5%25AD%25A6%25E4%25B9%25A0%2F%25E5%25AD%25A6%25E4%25B9%25A0%25E7%25AC%2594%25E8%25AE%25B0%2F%25E5%259B%25BE%25E7%2589%2587%2Fimage-20230703174657018.png%3FlastModify%3D1694242997&pos_id=4lRdZqQM

 

 

 

 

js中保留两位小数的方法

在 JavaScript 中,可以使用以下方法来保留一个数字的两位小数:

  1. 使用 toFixed() 方法:

const num = 3.14159; const roundedNum = num.toFixed(2); console.log(roundedNum); // 输出 3.14
  1. 使用 Math.round() 方法:

讯享网const num = 3.14159; const roundedNum = Math.round(num * 100) / 100; console.log(roundedNum); // 输出 3.14
  1. 使用 parseFloat() 和 toFixed() 方法:

const num = 3.14159; const roundedNum = parseFloat(num.toFixed(2)); console.log(roundedNum); // 输出 3.14

以上方法都是将数字四舍五入到两位小数。请根据你的需求选择适合的方法。

 

 

 

 

将[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]数组中的两个元素相加变成一个元素返回出一个新数组,例如将第一个和第二个相加变成一个新元素插入到新数组,再进行3和4元素相加,可以使用map方法,用js

当然可以使用 JavaScript 的 map 方法来实现这个操作。以下是一个示例代码:

讯享网const arr = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24]; ​ const sumPairs = (array) => {  const result = [];    for (let i = 0; i < array.length; i += 2) {    const sum = array[i] + (array[i + 1] || 0); // 若数组长度为奇数,最后一个元素与 0 相加    result.push(sum); }    return result; } ​ const newArray = arr.map((_, index, array) => {  if (index % 2 === 0) {    return array[index] + (array[index + 1] || 0); } }); ​ console.log(newArray); // 输出 [3, 7, 11, 15, 19, 23, 27, 24]

在上述代码中,我们使用了 map 方法遍历原始数组 arr,并通过索引判断两个元素是否需要相加。如果索引为偶数,则相加;如果为奇数,则不相加。最后将计算得到的新元素添加到 result 数组中。

注意,这里我们使用了 (array[index + 1] || 0) 来处理数组长度为奇数的情况,确保最后一个元素和 0 相加。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

小讯
上一篇 2025-01-16 12:00
下一篇 2025-03-07 11:33

相关推荐

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/79310.html