编程的由来
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,取余,除到最后,倒序写
转八进制

转十六进制

十六进制 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
- 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

讯享网 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>
控制台打印结果:

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

构造函数的缺点:存在浪费内存的问题
解决方法:通过构造函数的原型 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

严格模式
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方法来手动展开数组。
事件循环

1、浏览器的进程模型
何为进程?
1、程序运行需要专属的内存空间,内存空间就是进程
2、每个应用至少一个进程,进程之间相互独立,即使通信也要双方同意
3、进程为了隔离,不至于一个程序出问题影响全局
何为线程
1、运行代码的环境为线程
2、一个进程至少一个线程,第一个自动创建的线程为主线程,主线程结束,整个进程结束
3、一个进程可以包含多个线程
浏览器是一个多进程多线程的应用程序
1、浏览器的进程分类:浏览器进程、网络进程、渲染进程
2、浏览器进程:主要赋值界面交互、子进程管理等。浏览器内部会启动多个线程来处理不同的任务
3、网络进程:负责加载网络资源。网络进程内部会启动多个线程来处理不同的网络任务
4、渲染进程(重点):进程开始会创建一个主线程,主线程主要负责HTML、CSS、JS代码。
5、默认情况下浏览器会为每个标签页开启一个新的渲染进程,以保证不同的标签页之间不相互影响。谷歌浏览器以后会改变,因为太吃内存了,可能改成一个站点一个进程
2、渲染主线程是如何工作的?
1、渲染主线程做的事情最多:解析HTML、CSS、计算样式、布局、处理图层、每秒把页面画60次,执行全局JS代码、执行事件处理函数、执行计时器的回调函数等等
2、思考:为什么渲染进程不适应多个线程来处理这些事情?结论:没有办法实现
3、如何调度任务?使用排队

4、 在w3c标准文档中叫事件循环 event loop,在浏览器中叫消息循环message loop,指的是同一件事
5、在刚开始的时候,渲染主线程会进入一个无限循环
6、 每一次循环会检查消息队列中是否有任务存在。如果有,就取出第一个任务执行,执行完一个后就进入下一循环;如果没有就进入休眠状态。
7、其他所有线程(包括其他进程的线程)可以随时向消息队列添加任务。新任务会加到消息队列的末尾。在添加新任务时,如果主线程是休眠状态,则会将其唤醒以继续循环拿取任务
8、这样一来就可以让每一个任务有条不紊的、持续的进行下去了
10、整个过程,被称为事件循环(消息循环)
3、何为异步?
1、代码在执行过程中,会遇到一些无法立即处理的任务。
比如:定时器、网络通信的回调函数、用户操作后需要执行的任务(事件委托)

2、定时器涉及计时线程,如果主线程要等待计时结束在执行下一个任务2,就会造成阻塞,但是也是有一个好处的,就是它们在时间线上是一样的,这也称之为同步(阻塞模式)
3、因为主线程处理的任务是很多很重要的,所以不能造成阻塞,所以浏览器提出异步来解决这个问题

4、如何理解js的异步?

5、js为何会阻碍渲染?
因为js和渲染它们都在浏览器的渲染主线程上,都得排队
6、任务有优先级吗?
在渲染主线程中,任务是没有优先级的,在事件队列(消息队列)中先进先出,但是消息队列有优先级。

7、微队列的单词:microtask queue
8、浏览器以前的微队列不变,依然是VIP,但是以前的宏队列的说法被现在的W3C的最新标准取消,细分了更多的队列,然后浏览器根据实际情况执行不同队列的任务,但是同类的任务必须在一个队列中

9、添加任务到微队列的主要方式主要是Promise和MutationObserver

10、浏览器还有很多队列,但是和我们开发关系不大,不作考虑
11、阐述一下js的事件循环?

12、js中的计时器能做到精确计时吗?答:不行。为什么?

js中保留两位小数的方法
在 JavaScript 中,可以使用以下方法来保留一个数字的两位小数:
-
使用 toFixed() 方法:
const num = 3.14159; const roundedNum = num.toFixed(2); console.log(roundedNum); // 输出 3.14
-
使用 Math.round() 方法:
讯享网const num = 3.14159; const roundedNum = Math.round(num * 100) / 100; console.log(roundedNum); // 输出 3.14
-
使用 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 相加。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容,请联系我们,一经查实,本站将立刻删除。
如需转载请保留出处:https://51itzy.com/kjqy/79310.html