js总结
文章目录
JavaScript
页面输入输出
var 变量名 = prompt("输出的内容")
alert(变量名)//浏览器弹窗
console.log (变量名)
document.write() 写在网页上的字
JS数据基础
js数据结构包括
1.标识符:就是给变量 函数 属性 或者函数的某个参数 起的名字
2.关键字:是指在JS语言中有特定的含义的名字, 它已经成了JS语言中的一部分(禁用)
3.常量:不可以改变的值 true (对) false(错) 数字
4.变量:是指在程序运行的过程中,值是可以改变的
5.保留字:在后面编写的代码中,有可能会出现语法当中的class
声明变量
var 关键字 用来声明一个变量
var age = 18 //声明变量
console.log(age)//输出变量变量命名规则
1.顾名思义 (变量名取名一眼就能看出含义 比如 imgSrc oldPrice)
2.第一个字符必须是字母、下划线_ 或者是美元符号$符号,其他字符可以是字母,数字,下划线,还有美元符号。
3.按照惯例 ECMAScript 标识符 采用驼峰命名法 小驼峰:第一个字母小写,第二个字母大写imgSrc 大驼峰:每一个单词的首字母都是大写字母 FirstName
4.变量命名不能使用关键字 和保留字
JS数据类型
JS数据类型:决定了一个数据的特征 比如100是数字和"100"加引号是字符串
JS基本数据类型;字符串 数值型 布尔值 underind型 null型 除此 五种外的都叫对象 object,所以一个是6种
1.字符串 使用单引号 或者 双引号 包裹起来的数据
var age = "18"2.数值型 Number Number类型数据:用来表示整数 和浮点数 最大的功能就是表示10进制的整数和浮点数值 Number数据:表示数值大小是有限制的 如果超过这个范围,将会显示Infinity正无穷 如果最小值超出表示范围将会显示-Infinity负无穷
NaN不是数字
isNaN() 方法 判断非数字 如果是数字返回 false,不是数字返回 true
3.布尔值 Boolean 布尔值也被称为逻辑值类型或者真假数值类型 布尔类型 只能取值 true和false 其他值都不支持
4.undefined型 undefined只有一个值 就是特殊的undefined 一般情况变量声明了,但是没有赋值,会显示undefind
5.null型 表示空对象:只有一个值 主要作用于赋值给一些可能返回对象的变量,作为初始化
underfined 和 null 的区别
underfined表示 未定义 null 表示空对象
6.object对象
运算符
1.typeof运算符
判断一个值得数据类型 可以判断常量 也可以判断变量
var studentName = "自己"
console.log(typeof studentName);
console.log(typeof 100);//number
console.log(typeof true);//boolean
console.log(typeof abc); //underfind未定义JS算法运算符
console.log(1+1); //+ 加号 加法运算console.log(10-9); //- 减号 减法运算 console.log(2*3); // * 乘法运算console.log(81 / 9); // 除号 除法运算 商console.log(34 % 3); // % 百分号 取模(取余数)var age = 18; // 前自增 先+1 在赋值
console.log(++ age); // 19var cunt = 18; // 后自增 先赋值 再+1
console.log(cunt++); //18
console.log(cunt); // 19var i = 20; // 后自减 先赋值 在-1
console.log(i--); // 20
var x = 20; // 前自减 先-1 在赋值
console.log(--x); // 19 // () 小括号 提高运算顺序
console.log(3 + 5 * 2); // 13
console.log((3+5) * 2); // 16比较运算符
比较运算符 比较两个值是否相等,如果两个值相等返回true 否者返回false
1. == 双等号 做相等运算
var a = 10;
var b = 10;
var c = "10";
console.log(a == b); //true
console.log(a == c); //true
如果双等号 比较两个值时,如果值得类型不同,则会自行转化为相同得类型,然后再表现2. === 三等号 做相等运算 (判断数据类型)
console.log(a === c); //false
console.log('张三' == '李四'); //false3. !=用来不全等运算 (不判断数据类型)
不相等用来判断两个值是否不相等,如果不相等返回true,否者返回false,不相等也会对变量进行自动的类型转换,如果转换后相等它也会返回false
console.log(a != b); // false- !==用来做不全等运算 (判断数据类型)
(1) 值和类型 全都不等 "zhaoliying" !== 10 // true
(2) 值相等,类型不等 10 !== "10" // true
(3) 类型相等,值不等 10 !== 20 // true
(4) 值和类型 都相等 10 !== 10 // false
值和类型 只要有一个不相等时候,就会返回true ,否则为false
逻辑运算符
1. && (and 与运算) 两边都为true 否则为false
两个值 只要有一个为false,结果就是false
var x = 10;
var y = 5;
console.log(x > 7 && y == 3); // false
JS中 与运算 属于短路的与如果一个值为false 则不会检查另一个,如果两个都为trur 则会返回第二个值,如果两个都为false,则会返回第靠前的值2. || 或运算 一边为true ,则结果为true ,否则为false;
console.log(x > 7 || y == 3); //true3. ! 非 ,取反 布尔值时: 先会将其转换为布尔值,然后在取反
console.log(!x == y); //true三元表达式
// var result = b ? x : y
var age =15;
var result = age < 18 ? "未成年" : "成年"
x和y可以是任意类型的参数 ,可以是变量 常量 和表达式 (也可以计算)
b参数 必须是一个布尔类型的表达式
如果b的返回值是true,则把x的运算结果 赋值给 redult
如果b的返回值是false,则把y的运算结果 赋值给result运算顺序
算数运算符 > 比较运算符 > 逻辑运算符 > 赋值运算符
逻辑运算 取反! > 与 && 或 > ||
var x = 2;
var result = x + 3 == 5 || false && "张三" == "张三"
true || false && true //true
var i = 1;
!i 强制转换成布尔型
console.log(i && true == "abc"); //false转化为字符串
强制类型转化将一个数据类型 强制转化为其他类型, 一般是指,将其他类型的数据,转化成数值型,字符串型、数值型、和布尔值
将数值 转化为字符串 有三种方法
1.toString 把数字转化为字符串 改方法 不会改变原来的变量 他将转化的结果返回
null和undefined没有该方法(报错)
Var a = 100;
var a = a.toString()
console.log(a);
console.log(typeof a);2.String() ()括号里面需要转化的数据
var b = 10;
b = String(b);
console.log(b);
console.log(typeof b);3.+""
var c = 1;
c = c + ""
console.log(c);
console.log(typeof c);转化为数字型
有三种方法: Number()、parseInt()和 parseFloat()
1.使用Number()函数 需要被转化的带有数字的字符串
var a = "100"
a = Number(a)
console.log(a);
console.log(typeof a);2.parseInt 将字符串转化为整数
var b = "12.58px"
b = parseInt(b);
console.log(b); // 12
console.log(typeof b); //Number3.parseFloat() 将字符串转化为浮点数,保留小数
var c = "12.546px"
c = parseFloat(c);
console.log(c); // 12.546
console.log(typeof C); // Number
var d = "pm12.5" // 如果第一个字符是字母,则不会继续转化 直接返回NaN
d = parseInt(d);
console.log(d); // NaN布尔型转化
把其他数据类型转化为布尔型,只能用Boolean() 函数
var a = Boolean(6); 数字型数据 非0即为真,NaN和0都是false
var b = Boolean("ZHAJLJI")
除了空串,其他都是true
null和undefined也会转化为false
对象会转化为trueif条件语句
| 名称 | 描述 |
|---|---|
| if | 当指条件为true时,执行if语句对应的代码 |
| if...else | 当条件为 true 时,执行 if 语句对应的代码<br/>当条件为 false 时,执行 else 语句对应的代码 |
| if...else if... | 满足条件时,执行它所对应的代码 |
| case | 在 switch 中使用,表示要匹配的每一种情况 |
| default | 在 switch 中使用,表示默认情况,当不满足所有的 case 条件时,会执行默认情况 |
| switch | 根据不同的条件来执行不同的动作。示例:<br/>switch (month) {<br/> case 1:<br/> alert("这个月有 31 天")<br/> break;<br/> case 4:<br/> alert("这个月有 30 天")<br/> break;<br/> default:<br/> alert("请输入正确的月份!!")<br/>} |
| boolean_expression ? true_value : false_value | 三元运算符,当条件表达式 boolean_expression 为真,执行表达式 true_value,为假时执行表达式 false_value |
循环语句
| 名称 | 描述 |
|---|---|
| for | 循环执行一段代码,示例:<br/>for(var i = 0; i <10;i++) {<br/> console.log(i);<br/>} |
| while | 条件为真时循环执行代码块 |
| do-while | while 循环的变体,语法: do{ 循环体 }while(循环执行条件) 注意事项: 1、do-while 循环在检查条件之前一定会执行一次循环体 2、如果条件为真,就会继续执行循环体 3、如果条件为假,则会终止循环 |
break和continue语句
| 名称 | 描述 |
|---|---|
| break | 用于退出循环<br/>1、在 switch 中使用,用于跳出 switch 语句<br/>2、在循环 for、while 中使用,直接跳出循环 |
| continue | 跳出当前循环,继续执行下一次循环 |
switch语句
switch ... case 语句 是另一种流程控制语句
switch 语句更合适 多分支使用同一种语句的情况
var today = 1;
switch(语句) { 待匹配的数值
case 表达式1:
语句...
case表达式2:
}while循环
1. while(条件表达式) {
// 条件成立执行
// 循环体
}
var i = 1;
while(i <= 10){
console.log(i);
i++;
}2.do...while 和 while 非常相似 只不过判断条件再尾部 所以至少执行一次 所以不是特别常用
do {
执行语句
}while(条件表达式)for循环
for(初始化表达式;条件表达式;更新表达式;){
循环体 循环语句
}
双重循环 外循环执行一次,内循环执行一轮数组初级使用
1.数组是一种用于表达式有顺寻关系的集合,也是数据元素的有序合集。
2.每个元素都可以通过索引(下标) 来快速读取
3.索引是从零开始的整数
4.支持数组可以是不同元素,数组内的各个值被称作元素
1. 使用new对象创建
var are = new Array();
// 创建一个数组
console.log(typeof arr);
arr[0] = "张三";
arr[1] = "18";
arr[2] = "本科";
arr[3] = "小宝";
arr[4] = "168cm";
arr[5] = "50kg";
console.log(arr.length); // length返回值是数组元素的个数2. 使用字面量创建 []
var arr1 = ["李四", 46,"本科","无敌", "185cm" , "75kg", "男"];
console.log(typeof arr1);
console.log(arr1.length)
console.log(arr1);
for(i = 0; i<=arr.length - 1; i++){// i用来做数据的索引号
document.write("<p>")
document.write(arr[i])
document.write('</p>')
}字符串拼接
字符串拼接 使用 + 加号,,字符串型数据 + 任何数据都是字符串
var phoneNumber = "15644646";
var studentName = "张三";
var result = studentName + null;
console.log(result);
console.log(typeof result); // stringES6模板字符串
1.模板字符串 es6新增的 允许嵌入表达式的字符串
可以使用多行字符串 和 字符串插值功能
他和普通字符串不同, 他保留空格 换行 缩进
- 用 反撇号·· 使用$(变量名), 可以进行字符串插值
转义符
无法被键盘录入的字符,被当作特殊用途而需转换回它原来的意义的字符,而转义字符的转义是指字符已经被转换了意义
| 符号 | 说明 |
|---|---|
| \t | 制表符 |
| \n | 换行 |
| \ | 斜杠符号 |
| \' | 单引号 |
| \" | 双引号R |
数学对象
ceil
进一法取整
echo ceil(10.2); //输出11floor
向下取整
echo floor(10.2); //输出10max
找出最大值
echo max(1, 3); //返回3min
找出最小值
echo min(1, 3); //返回1round
对浮点数进行四舍五入处理
echo round(12.567,2)abs
求一个数的绝对值
console.log(Math.abs(-8));pow
返回x的y次幂
console.log(Math.pow(3,4));sqrt
求一个数的开平方
console.log(Math.sqrt(9));random
随机正数
console.log(Math.random(Math.random()*(y-x)+x));日期对象
1.如果()没有参数,返回当前的系统时间
var date = new date();
初始化日期对象
console.log(date);2.()参数,写字符串型,日期 年-月-日 时:分:秒
var input_date = new Date("2022-1-1 18:30:00")
console.log(input_date);3.(0) 参数为0,返回的是1970年1月1日
var date1970 = new Date(0);
console.log(date1970);4. 获取当前时间
var date = new Date();
console.log(date); // 初始化日期对象,
console.log(date);
显示当前系统时间
console.log(date.getFullYear());
获取当前日期对象的年份 (四位数年份)
console.log(date.getMonth() + 1);
// 获取当前日期的月份 (0 - 11)
// 比实际月份少1,所以要手动加1
console.log(date.getDate());
// 获取当前日期对象的日数 (1 - 31)
console.log(date.getHours());
// 获取当前日期对象的小时 (0 - 23)
console.log(date.getMinutes());
// 获取分钟数 (0 - 59 )
console.log(date.getSeconds());
// 获取秒钟数 (0 - 59)
console.log(date.getDate());
// 获取星期几,(0 - 6) 0 表示周日时间差
时间差 就是某一时间到另一个时间,中间相隔的是时间差
获取几天的日期
var date = new Date();数组对象
反回数组长度
arr.length
console.log(arr.length)反回数组对象的原理函数
arr.constructor
console.log(arr.constructor)可以在数组末尾添加一个或多个元素元素,返回值是新数组的长度
arr.push
let arr = ["你好", "cms"];
console.log(arr.push('开心', 'unren')); //4
console.log(arr); //["你好", "cms", "开心", "unren"]删除数组的最后一个元素,并将删除的元素作为返回值返回
arr.pop
let arr = ["你好", "hdcms"];
console.log(arr.pop()); //hdcms
console.log(arr); //["你好"]从数组前面添加元素
arr.unshift
let arr = ["你好", "hdcms"];
console.log(arr.unshift('世界', 'houdunren')); //4
console.log(arr); //["世界", "houdunren", "你好", "hdcms"]从数组前面取出一个数组
arr.shift
let arr = ["你好", "cms"];
console.log(arr.shift()); //你好
console.log(arr); //["cms"]使用 slice 方法从数组中截取部分元素组合成新数组(并不会改变原数组),不传第二个参数时截取到数组的最后元素。
arr.slice(x,y)
let arr = [0, 1, 2, 3, 4, 5, 6];
console.log(arr.slice(1, 3)); // [1,2]不设置参数是为获取所有元素
let arr = [0, 1, 2, 3, 4, 5, 6];
console.log(arr.slice()); //[0, 1, 2, 3, 4, 5, 6]使用 splice 方法可以添加、删除、替换数组中的元素,会对原数组进行改变,返回值为删除的元素。
删除数组元素第一个参数为从哪开始删除,第二个参数为删除的数量。
arr.splice
let arr = [0, 1, 2, 3, 4, 5, 6];
console.log(arr.splice(1, 3)); //返回删除的元素 [1, 2, 3]
console.log(arr); //删除数据后的原数组 [0, 4, 5, 6]通过修改length删除最后一个元素
let arr = ["你好", "hdcms"];
arr.length = arr.length - 1;
console.log(arr);通过指定第三个参数来设置在删除位置添加的元素
let arr = [0, 1, 2, 3, 4, 5, 6];
console.log(arr.splice(1, 3, 'cms', '你好')); //[1, 2, 3]
console.log(arr); //[0, "cms", "你好", 4, 5, 6]向末尾添加元素
let arr = [0, 1, 2, 3, 4, 5, 6];
console.log(arr.splice(arr.length, 0, 'cms', '你好')); //[]
console.log(arr); // [0, 1, 2, 3, 4, 5, 6, "cms", "你好"]向数组前添加元素
let arr = [0, 1, 2, 3, 4, 5, 6];
console.log(arr.splice(0, 0, 'cms', '你好')); //[]
console.log(arr); //["cms", "你好", 0, 1, 2, 3, 4, 5, 6]数组元素位置调整函数
function move(array, before, to) {
if (before < 0 || to >= array.length) {
console.error("指定位置错误");
return;
}
const newArray = [...array];
const elem = newArray.splice(before, 1);
newArray.splice(to, 0, ...elem);
return newArray;
}
const array = [1, 2, 3, 4];
console.table(move(array, 0, 3));字符串方法
srt.constructor 返回字符串对象的原型函数
var str "Hello,World"
console.dir(str.constructor)charAt 返回指定索引所在的字符串,默认第一个字符串位置为0,空格也算一个字符串
console.log(str.charAt(0));charCodeAt() 该方法获取指定位置字符的ASCII码值
console.log(str.charCodeAt(0));str.concat() 该方法用来连接字符串
var str1 = "你好";
console.log(str.concat(str1,"世界","赵丽颖"));
console.log(result);//Hello,World你好世界赵丽颖str.length 获取字符串的长度
console.log(result.length);str.indexOF();
该方法 可以检测一个字符串中是否包含指定符号,如果字符串中包含该内容,返回第一次出现的索引号
如果没有找到指定内容,则返回-1,同时可以指定第二个参数,指定开始查找的位置
可以指定第二个参数,指定开始查找的位置
result = "Hello,World你好世界赵丽颖"
var newStr1 = result.indexOf("o")
var newStr2 = result.indexOf("A")
console.log(newStr1); // o
console.log(newStr2); // -1
var newStr3 = result.indexOf('o',5);
console.log(newStr3); // 7str.slice() 该方法可以从字符串截取指定内容,不会原字符串,将截取到的内容返回
x 开始位置 (包括开始位置)
y 结束位置 (不包括结束位置),如果不写,默认截取到末尾
索引可以传递一个负数,如果是负数,则从后边往前计算
var newStr1 = result.slice(1,5); // ello
console.log(newStr1);str.substring(x , y) 截取字符串 ,包含x起始位置,不包含y
如果没有第二个参数,默认截取到末尾
console.log(result.substring(11,15)); // 你好世界 str.substy(x,y) 截取字符串 x 开始位置,y截取的长度
console.log(result.substr(11,4)); // 你好世界str.split() 方法 将一个字符串拆分成数组,
需要一个字符串作为参数,根据该字符串去拆分
newStr = result.split(",");
console.log(newStr);str.touppercase() // 将字符串转化成大写字母
var str = "abcd
console.log(str.toUpperCase()); //ABCDstr.tolowercase() 转成小写字母
var str1 = "ABCD"
console.log(str1.toLowerCase());//abcdstr.endswith() 该方法确定字符串是否以指定字符串的字符结尾,返回true和false 两种值
result = "Hello,World你好世界赵丽颖";
console.log(result.endsWith("颖"));//truestr.trim() 该方法删除字符串前后空格
var str= " 中国万岁 "
console.log(str.length); // 15对象
Object类型 是JavaScript中引用数据类型,它是一个复合值,将什么数据聚合到一起,通过名字来访问,对象也可以看做一类属性的无序集合,每一个属性是键值对形式,对象可以创建自有属性,也可以继承名为原型的对象的属性
使用new关键字创建
var person = new Object();
person.name = "赵丽颖";
person.age = 25;
person.height = "172cm",
person.vocation = "演员";
console.log(person);使用字面量{}创建
var person1 = {
name: "张艺谋",
属性之间用逗号隔开
age: 72,
height: "175cm",
vocation: "导演"
};访问形式 使用 进行链式调用
console.log(person.name);对象名["属性名"]
console.log(person["age"]);删除对象中属性 使用delete关键字
delete person.height;
console.log(person);使用for...in遍历
// for (var key in object) {
// key键 表示当前遍历对象的属性名 object[key] 表示当前遍历对象的属性值
// }
for (var key in person) {
console.log(key + ":" + person[key]);
}函数
函数是由一连串的子代代码,(程序)所组成的,可以被外部的程序调用,向函数传递参数以后,函数可以返回一定的值。
通常情况下JS的程序都是从上往下以此执行,但是函数中的代码不是这样,如果你只是创建了一个函数,而没有调用,他不会执行
注意:函数也是对象,使用typeof检查一个函数对向的时候,会返回function
方法1. 创建函数,使用new关键字 (这个办法几户不用)
var fun1 = new Function("console.log("这是new关键字创建的函数")");方法2.使用函数声明来创建
function fun2(){
//fun2是函数名
console.log("这是函数声明创建的函数")
}方法3 使用表达式来创建函数(常用)
匿名函数
var fun3 = function(){
console.log("这是表达式创建的函数");
}
console.log("我在学习函数")
fun() //调用函数函数调用
什么是函数的参数?
- JS中所有的函数都是按值进行传递,也就是说把函数外部的值赋值给函数内部的参数
- 简单说就是把值从一个变量赋值给另外一个变量时一样的,所以,函数调用时可以在函数function()括号里,先写形式参数变量名,外部调用时再写 实际参数
- JS解析器不会判断实参类型,所有实参可以是任意数据类型
- 调用函数时,解析器不会检查实参的数量,多余的实参不会赋值,如果形参的数量大于实参,则没有对应实参的形参将是undefind
return函数的进阶
- 在函数中return后的语句不在执行,如果return语句后不在执行,如果return语句后不跟任何值,相当于返回undefined
- 如果函数中不写return 也会返回undefind
- return后的语句不在执行
嵌套函数
嵌套函数 在函数中声明的函数就是嵌套,嵌套函数只能在当前函数中访问调用,在当前函数处无法访问
立即执行函数
立即执行函数 函数定义完以后,直接调用 这种函数只会执行一次
对象中的函数
对象中的属性值 可以时任何属性类型
如果一个函数作为对象属性进行保存,那么我们称这个函数是这个对象的方法
调用这个函数,这就是调用这个对象的方法
注意:方法和函数只是名称上的区别,没有其他区别
this指向
JS 引擎解析器,在调用函数时,都回向函数内部传递一个隐藏参数,这个参数就是this
this指向的是一个对象,根据函数调用方法不同,this会指向不同的对象
以函数的形式调用时,this永远指向的window对象
以方法的形式调用,this指向的是调用方法的对象
(谁调用谁就是this,this永远指向最后一个调用它的对象)
定时器
JavaScript 提供了两种定时器,定时器的作用 定时执行代码
1.创建一个延时器 多少毫秒之后执行代码,只执行一次
var outTimer = setTimeout(function(){
alert("延时器,延时1s")
},2000)
// 清除延时器
clearTimeout(outTiemr)- 定时器 每个多少毫秒执行一次代码 widow.setInterval(函数,间隔时间)
var serTimer = setInterval(function(){
console.log("每隔三秒执行")
},2000)
// 秦楚定时器
clearInterval(setTimer);JavaScript高级
1.预处理
1.JavaScript的解析和执行过程
/*javascript是一种描述型的脚本语言,是一种解析语言,由浏览器动态解析,不同种类的浏览器不同
版本的浏览器对于js的解析有着微小的差别,不同浏览器的js解析引擎效率也有高低。
js的执行过程分为两大部分:
第一部分,解析过程,也称预编译期 。主要工作就是对于js的代码中声明的所有变量和函数进行预
处理。需要注意的是,再此进行处理的仅是声明函数,而对于变量的处理仅是声明,并开辟出一块内存
空间,不进行赋值操作。
第二部分,执行过程,在执行过程中,浏览器的js引擎对于每个代码块进行顺序执行,如果有外部
引用的js,且js有相互关联,此时就要注意,不同js的引入顺序,如果声明代码块在调用代码块后调用则
将不会达到预期的效果。
总的来说,JS的执行分为两部分,解析过程和执行过程。解析时按照代码块,一段一段进行解析,
执行时按照代码块顺序逐行执行,解析一个代码块,执行一个代码块。
因为是解释性语言,所以js如果在解析过程有错误,则不会提示,也可以理解为js不会出现编译错
误,但如果出现了运行时错误,出现错误的所有javascript代码将不会继续执行。*/
2.预处理
预处理:创建一个词法环境(LexicalEnvironment,在后面简写为LE),扫描JS中的用声明的方式 声明的函数,用var定义的变量并将它们加到预处理阶段的词法环境中去。 预处理阶段先读取代码块,不是一行一行的解析执行定义的方法和用var 定义的变量,会放到一个 (不同的环境,会有对应的词法环境)词法环境中
var a = 1; //用var定义的变量,以赋值
var b; //用var定义的变量,未赋值
c = 3; //未定义,直接赋值
function d(){ //用声明的方式声明的函数
console.log('hello');
}
var e = function(){ //函数表达式
console.log('world');
}
词法环境
LE{ //此时的LE相当于window a:undefined b:undefined 没有c d:对函数的一个引用 e: undefined }- 预处理的函数必须是JS中用声明的方式声明的函数(不是函数表达式)。
示例
d();
e();
function d(){//用声明的方式声明的函数
console.log('hello');
}
var e = function(){//函数表达式
console.log('world');
}LE{ //此时的LE相当于window
d:对函数的一个引用
e: undefined
}
// 结果:hello;报错e is not a function。3.命名冲突
变量和函数同名冲突 —— 函数优先,函数是一等公民,在既有函数声明又有变量声明的时候,函数 声明的权重总是高一些,所以最终结果往往是指向函数声明的引用。
console.log(f);
var f = 1;
function f(){
console.log('foodoir');
}
//结果 [Function: f]
console.log(f);
function f(){
console.log('foodoir');
}
var f = 1;
// 结果: [Function: f]<font size=4 color=red>变量和函数同名名冲突 —— 后者会覆盖前者</font>
f()
function f(){
console.log('foodoir');
}
function f(){
console.log('hello world');
}
//结果: ‘hello world’var f = 1;
var f = 2;
console.log(f)
//结果 24.执行阶段
console.log(a); //为什么是undefined?
console.log(b);
console.log(c); //函数在任意地方都可以调用
console.log(d);
var a = 1;
b = 2;
console.log(b);
function c(){
console.log('c');
}
var d = function(){
console.log('d');
}
console.log(d);
//词法环境
LE{
a:undefined
没有b
c:对函数的一个引用
d:undefined
}
undefined
报错
function c(){console.log(‘c’);
undefined- 注释掉上面代码第二行
// 1. 在第6行代码执行完,LE中的a的值变为1;
LE{
a:1
没有b
c:对函数的一个引用
d:undefined
}
// 2.第7行代码执行完,LE中就有了b的值(且b的值为2,此时b的值直接变为全局变量);
LE{
a:1
b:2
c:对函数的一个引用
d:undefined
}
//3.第10行代码执行完
LE{
a:1
b:2
c:指向函数
d:undefined
}
//4.第14行代码执行完,此时
LE{
a:1
b:2
c:指向函数
d:指向函数
}5.函数冲突原则
- 1.处理函数声明有冲突时,会覆盖。
2 .处理变量声明时有冲突,会忽略。以传入参数的值为准。
<font size = 4 color=red>预处理阶段传入参数值一一对应</font>
function f(a,b){
alert(a);
alert(b);
var b = 100;
function a(){}
}
f(1,2);
LE{
b:2
a:指向函数的引用
arguments:2
}
//arguments,调用函数时实际调用的参数个数
// 执行到第6行的时候
LE{
b:2
a:指向定义好的函数
arguments:2
}
//arguments,调用函数时实际调用的参数个数<font size=4 color=red>传入没有参数的值时</font>
function f(a,b){
alert(a);
alert(b);
var b = 100;
function a(){}
}
f(1);
LE{
b:undefined
a:对函数的一个引用
arguments:1
}
<font size=4 color=red>没有用var声明的变量,会变成最外部LE的成员,即全局变量</font>
function a(){
function b(){
g = 12;
}
b();
}
a();
console.log(g);//12
2.作用域
1.什么是作用域?
作用域是在运行时代码中的某些特定部分中变量,函数和对象的可访问性。
换句话说,作用域决定 了代码区块中变量和其他资源的可见性。
例如:
function outFun2() {
var inVariable = "内层变量2";
}
outFun2();//要先执行这个函数,否则根本不知道里面是啥
console.log(inVariable); // Uncaught ReferenceError: inVariable is not undefined从上面的例子可以体会到作用域的概念,变量 inVariable 在全局作用域没有声明,所以在全局作用 域下取值会报错:
- <font size=4 color=red> 作用域就是一个独立的地盘,让变量不会外泄、暴露出去。</font>
- <font size=4 color=red>作用域最大的用处就是隔离变量,不同作用域下同名变量不会有冲突。</font>
- <font size= 4 color=red> ES6 之前 JavaScript 没有块级作用域,只有全局作用域和函数作用域。</font>
ES6 的到来,为我们提供 了‘块级作用域’,可通过新增命令 let 和 const 来体现。
2.全局作用域
在代码中任何地方都能访问到的对象拥有全局作用域,一般来说以下几种情形拥有全局作用域:
1.最外层函数
和在最外层函数外面定义的变量拥有全局作用域
var outVariable = "我是最外层变量"; //最外层变量
function outFun() { //最外层函数
var inVariable = "内层变量";
function innerFun() { //内层函数
console.log(inVariable);
}
innerFun();
}
console.log(outVariable); //我是最外层变量
outFun(); //内层变量
console.log(inVariable); //inVariable is not defined
innerFun(); //innerFun is not defined
2.末定义
直接赋值的变量自动声明为拥有全局作用域
function outFun2() {
variable = "未定义直接赋值的变量";
var inVariable2 = "内层变量2";
}
outFun2();//要先执行这个函数,否则根本不知道里面是啥
console.log(variable); //未定义直接赋值的变量
console.log(inVariable2); //inVariable2 is not defined
3. window 对象
所有window的属性拥有全局作用域
一般情况下,window 对象的内置属性都拥有全局作用域,例如 window.name、 window.location. 等等。
函数作用域,是指声明在函数内部的变量,和全局作用域相反,局部作用域一般只在固定的代码片段 内可访问到,最常见的例如函数内部。
function doSomething(){
var blogName="浪里行舟";
function innerSay(){
alert(blogName);
}
innerSay();
}
alert(blogName); //脚本错误
innerSay(); //脚本错误4.作用域是分层
内层作用域可以访问外层作用域的变量,反之则不行。
例如:
function fun(a){
var b = a*2;
function bar(c){
consloe.log(a,b,c)
}
bar(b*3)
}
fun(2);//2,4,12
//泡泡 a 是全局作用域,有标识符 fun;
//泡泡 b 是作用域 fun,有标识符 a,bar,b;
//泡泡 3 是作用域 bar,仅有标识符 c。注意的是:块语句(大括号“{}”中间的语句),如 if 和 switch 条件语句或 for 和 while 循 环语句,不像函数,它们不会创建一个新的作用域。
在块语句中定义的变量将保留在它们已经存在的作 用域中。
if (true) {
// 'if' 条件语句块不会创建一个新的作用域
var name = 'Hammad'; // name 依然在全局作用域中
}
console.log(name); // 'Hammad'3.块级作用域
块级作用域可通过新增命令 let 和 const 声明,所声明的变量在指定块的作用域外无法被访问。块 级作用域在如下情况被创建:
- 1.在一个函数内部。
- 2.在一个代码块(由一对花括号包裹)内部。
<font color=red>块级作用域特点</font>
1.let/const 关键字
并不会被提升到当前代码块的顶部,
因此你需要手动将 let/const 声明放置到顶部, 以便让变量在整个代码块内部可用。
function getValue(condition) {
if (condition) {
let value = "blue";
return value;
} else {
// value 在此处不可用
return null;
}
// value 在此处不可用
}
2.禁止重复声明
如果一个标识符已经在代码块内部被定义,那么在此代码块内使用同一个标识符进行 let 声明就会 导致抛出错误。
例如:
var count = 30;
let count = 40; // Uncaught SyntaxError: Identifier 'count' has already been
declared在本例中, count 变量被声明了两次:一次使用 var ,另一次使用 let 。
因为 let 不能在同一作用域 内重复声明一个已有标识符,此处的 let 声明就会抛出错误。
但如果在嵌套的作用域内使用 let 声明一个 同名的新变量,则不会抛出错误。
var count = 30;
// 不会抛出错误
if (condition) {
let count = 40;
// 其他代码
}
3.循环中绑定块级作用域的妙用
开发者可能最希望实现 for 循环的块级作用域了,因为可以把声明的计数器变量限制在循环内,
例 如,以下代码在 JS 经常见到:
<button>测试1</button>
<button>测试2</button>
<button>测试3</button>
<script type="text/javascript">
var btns = document.getElementsByTagName('button')
for (var i = 0; i < btns.length; i++) {
btns[i].onclick = function () {
console.log('第' + (i + 1) + '个')
}
}
我们要实现这样的一个需求: 点击某个按钮, 提示"点击的是第 n 个按钮",此处我们先不考虑事件代理, 万万没想到,点击任意一个按钮,后台都是弹出“第四个”,这是因为 i 是全局变量,执行到点击事件时,此 时 i 的值为 3。那该如何修改,最简单的是用 let 声明 i。
for (let i = 0; i < btns.length; i++) {
btns[i].onclick = function () {
console.log('第' + (i + 1) + '个')
}
}4.作用域链
1.什么是自由变量
首先认识一下什么叫做 自由变量 。如下代码中, console.log(a) 要得到 a 变量,但是在当前的 作用域中没有定义 a(可对比一下 b)。当前作用域没有定义的变量,这成为自由变量 。自由变量的值 如何得到 —— 向父级作用域寻找(注意:这种说法并不严谨,下边会重点解释)。
var a = 100
function fn() {
var b = 200
console.log(a) // 这里的a在这里就是一个自由变量
console.log(b)
}
fn()2 .什么是作用域链?
父级没有自由变量的值?再一层一层向上寻找,直到找到全局作用域还是没找到,就宣布放弃。这种一层 一层的关系,就是作用域链 。
var a = 100
function F1() {
var b = 200
function F2() {
var c = 300
console.log(a) // 自由变量,顺作用域链向父作用域找
console.log(b) // 自由变量,顺作用域链向父作用域找
console.log(c) // 本作用域的变量
}
F2()
}
F1()
3.自由变量的值
关于自由变量的值,上文提到要到父作用域中取,其实有时候这种解释会产生歧义。
var x = 10
function fn() {
console.log(x)
}
function show(f) {
var x = 20
(function() {
f() //10,而不是20
})()
}
show(fn)在 fn 函数中,取自由变量 x 的值时,要到哪个作用域中取?
要到创建 fn 函数的那个作用域中 取,无论 fn 函数将在哪里调用。
所以,不要在用以上说法了。相比而言,用这句话描述会更加贴切:
要到创建这个函数的那个域”。 作用域中取值,这里强调的是“创建”,而不是“调用”,
切记切记——其实这就是所谓的"静态作用域"。
var a = 10
function fn() {
var b = 20
function bar() {
console.log(a + b) //30
}
return bar
}
var x = fn(),
b = 200
x() //bar()
fn()返回的是 bar 函数,赋值给 x。执行 x(),即执行 bar 函数代码。
取 b 的值时,直接在 fn 作用域 取出。
取 a 的值时,试图在 fn 作用域取,但是取不到,
只能转向创建 fn 的那个作用域中去查找,结果 找到了,所以最后的结果是 30。
3.变量提升
1.什么是变量提升?
通常JS引擎会在正式执行之前先进行一次预编译,
在这个过程中,首先将变量声明及函数声明提升 至当前作用域的顶端,然后进行接下来的处理。
(注:当前流行的JS引擎大都对源码进行了编译,由于引 擎的不同,编译形式也会有所差异,我们这里说的预编译和提升其实是抽象出来的、易于理解的概念)。 下面的代码中,我们在函数中声明了一个变量,不过这个变量声明是在if语句块中:
function hoistVariable() {
if (!foo) {
var foo = 5;
}
console.log(foo); // 5
}
hoistVariable();
运行代码,我们会发现foo的值是5,大家可能对此不甚理解,如果外层作用域也存在一个foo变 量,就更加困惑了,该不会是打印外层作用域中的foo变量吧?答案是:不会,如果当前作用域中存在此 变量声明,无论它在什么地方声明,引用此变量时就会在当前作用域中查找,不会去外层作用域了。
那么至于说打印结果,这要提到预编译机制了,经过一次预编译之后,上面的代码逻辑如下:
// 预编译之后
function hoistVariable() {
var foo;
if (!foo) {
foo = 5;
}
console.log(foo); // 5
}
hoistVariable();是的,引擎将变量声明提升到了函数顶部,初始值为undefined,
自然,if语句块就会被执行,foo 变量赋值为5,下面的打印也就是预期的结果了。
var foo = 3;
function hoistVariable() {
var foo = foo || 5;
console.log(foo); // 5
}
hoistVariable();foo || 5这个表达式的结果是5而不是3,
虽然外层作用域有个foo变量,但函数内是不会去引用的, 因为预编译之后的代码逻辑是这样的:
var foo = 3;
// 预编译之后
function hoistVariable() {
var foo;
foo = foo || 5;
console.log(foo); // 5
}
hoistVariable();
如果当前作用域中声明了多个同名变量,那么根据我们的推断,它们的同一个标识符会被提升至作 用域顶部,其他部分按顺序执行,比如下面的代码:
function hoistVariable() {
var foo = 3;
{
var foo = 5;
}
console.log(foo); // 5
}
hoistVariable()由于JavaScript没有块作用域,只有全局作用域和函数作用域,所以预编译之后的代码逻辑为:
// 预编译之后
function hoistVariable() {
var foo;
foo = 3;
{
foo = 5;
}
console.log(foo); // 5
}
hoistVariable()2.什么是函数提升?
function hoistFunction() {
foo(); // output: I am hoisted
function foo() {
console.log('I am hoisted');
}
}
hoistFunction();
为什么函数可以在声明之前就可以调用,并且跟变量声明不同的是,它还能得到正确的结果,
其实 引擎是把函数声明整个地提升到了当前作用域的顶部,预编译之后的代码逻辑如下:
// 预编译之后
function hoistFunction() {
function foo() {
console.log('I am hoisted');
}
foo(); // output: I am hoisted
}
hoistFunction();
相似的,如果在同一个作用域中存在多个同名函数声明,后面出现的将会覆盖前面的函数声明:
function hoistFunction() {
function foo() {
console.log(1);
}
foo(); // output: 2
function foo() {
console.log(2);
}
}
hoistFunction();对于函数,除了使用上面的函数声明,更多时候,我们会使用函数表达式,下面是函数声明和函数表达 式的对比:
// 函数声明
function foo() {
console.log('function declaration');
}
// 匿名函数表达式
var foo = function() {
console.log('anonymous function expression');
};
// 具名函数表达式
var foo = function bar() {
console.log('named function expression');
};可以看到,匿名函数表达式,其实是将一个不带名字的函数声明赋值给了一个变量,而具名函数表 达式,则是带名字的函数赋值给一个变量,需要注意到是,这个函数名只能在此函数内部使用。我们也 看到了,其实函数表达式可以通过变量访问,所以也存在变量提升同样的效果。 那么当函数声明遇到函数表达式时,会有什么样的结果呢,先看下面这段代码:
function hoistFunction() {
foo(); // 2
var foo = function() {
console.log(1);
};
foo(); // 1
function foo() {
console.log(2);
}
foo(); // 1
}
hoistFunction();
运行后我们会发现,输出的结果依次是2 1 1,为什么会有这样的结果呢? 因为JavaScript中的函数是一等公民,函数声明的优先级最高,会被提升至当前作用域最顶端,所以 第一次调用时实际执行了下面定义的函数声明,然后第二次调用时,由于前面的函数表达式与之前的函 数声明同名,故将其覆盖,以后的调用也将会打印同样的结果。上面的过程经过预编译之后,代码逻辑 如下:
// 预编译之后
function hoistFunction() {
var foo;
foo = function foo() {
console.log(2);
}
foo(); // 2
foo = function() {
console.log(1);
};
foo(); // 1
foo(); // 1
}
hoistFunction();我们也不难理解,下面的函数和变量重名时,会如何执行:
var foo = 3;
function hoistFunction() {
console.log(foo); // function foo() {}
foo = 5;
console.log(foo); // 5
function foo() {}
}
hoistFunction();
console.log(foo); // 我们可以看到,函数声明被提升至作用域最顶端,然后被赋值为5,而外层的变量并没有被覆盖, 经过预编译之后,
上面代码的逻辑是这样的:
// 预编译之后
var foo = 3;
function hoistFunction() {
var foo;
foo = function foo() {};
console.log(foo); // function foo() {}
foo = 5;
console.log(foo); // 5
}
hoistFunction();
console.log(foo); // 3所以,函数的优先权是最高的,它永远被提升至作用域最顶部,然后才是函数表达式和变量按顺序 执行,这一点要牢记。
3.为什么要进行提升?
由于第一代JS虚拟机中的抽象纰漏导致的,编译器将变量放到了栈槽内并编入索引,然后在(当前 作用域的)入口处将变量名绑定到了栈槽内的变量。(注:这里提到的抽象是计算机术语,是对内部发 生的更加复杂的事情的一种简化。) 函数提升要了解一下相互递归(就是A函数内会调用到B函数,而B函数也会调用到A函数),函数 提升就是为了解决相互递归的问题,大体上可以解决像ML语言这样自下而上的顺序问题。
// 验证偶数
function isEven(n) {
if (n === 0) {
return true;
}
return isOdd(n - 1);
}
console.log(isEven(2)); // true
// 验证奇数
function isOdd(n) {
if (n === 0) {
return false;
}
return isEven(n - 1);
}
相互递归函数示例:
// 验证偶数
function isEven(n) {
if (n === 0) {
return true;
}
return isOdd(n - 1);
}
console.log(isEven(2)); // true
// 验证奇数
function isOdd(n) {
if (n === 0) {
return false;
}
return isEven(n - 1);
}
如果没有函数提升,而是按照自下而上的顺序,当isEven函数被调用时,isOdd函数还未声明,所 以当isEven内部无法调用isOdd函数。所以Brendan Eich设计了函数提升这一形式,将函数提升至当前 作用域的顶部:
// 验证偶数
function isEven(n) {
if (n === 0) {
return true;
}
return isOdd(n - 1);
}
// 验证奇数字
function isOdd(n) {
if (n === 0) {
return false;
}
return isEven(n - 1);
}
console.log(isEven(2)); // true
这样一来,问题就迎刃而解了。变量提升是人为实现的问题,而函数提升在当初设计时是有目的 的。
4.最佳案例
理解变量提升和函数提升可以使我们更了解这门语言,更好地驾驭它,但是在开发中,我们不应该 使用这些技巧,而是要规范我们的代码,做到可读性和可维护性。 具体的做法是:无论变量还是函数,都必须先声明后使用。下面举了简单的例子:
var name = 'Scott';
var sayHello = function(guest) {
console.log(name, 'says hello to', guest);
};
var i;
var guest;
var guests = ['John', 'Tom', 'Jack'];
for (i = 0; i < guests.length; i++) {
guest = guests[i];
// do something on guest
sayHello(guest);
}
如果对于新的项目,可以使用let替换var,会变得更可靠,可维护性更高:
let name = 'Scott';
let sayHello = function(guest) {
console.log(name, 'says hello to', guest);
};
let guests = ['John', 'Tom', 'Jack'];
for (let i = 0; i < guests.length; i++) {
let guest = guests[i];
// do something on guest
sayHello(guest);
}
/*ES6中的class声明也存在提升,不过它和let、const一样,被约束和限制了,其规定,如果再声明
位置之前引用,则是不合法的,会抛出一个异常。
所以,无论是早期的代码,还是ES6中的代码,我们都需要遵循一点,先声明,后使用。*/DOM和node节点
1.什么是DOM?(防止面试)
DOM:Document Object Model 文档对象模型,简称DOM模型
他是JS操作网页html文档的接口API(函数、方法)
(Application Program Interface 应用程序接口)
他的作用是网页上的各种元素(标签)转化为相应的js对象,从而使用js对象对浏览器中的网页文档进行增删改查等各种操作
2.什么是DOM树?
DOM树:HTML DOM 模型被结构化为对象树
通过这个对象树,js可以创建动态的html文档
HTML DOM是关于如何 获取、更改、添加、删除、html网页元素的标准
3.什么是DOM文档节点 节点是构成网页文档的最基本的单元
节点Node,是构成我网页文档的最基本的部分,网页中任何一个部分都可以称为节点
比如 html标签、属性、文本、注释、整个文档都是节点
节点 至少拥有三个基本属性:nodeType(节点类型)、数值1表示节点数值2表示属性节点 数值3 表示 文本节点
nodeName(节点名称)和nodeValue(节点值)
4.节点类型(属性)大致分为四类
1.文档节点:整个html文档
文档节点(Document)代表了整个html网页文档,网页中所有的节点,都是他的子节点
document是作为window对象的属性存在的,我们不需要自己获取
2.元素节点:html文档中的标签
html中各种标签都属于元素节点(Element),这个也是我们经常用的,最常用的一个节点
浏览器会将页面上的所有标签转化成为一个元素节点,我们可以通过document的方法进行截取
document.getElementById(),根据id属性值获取一个元素点对象
3.属性节点:元素的属性
属性节点 Attribute 标签中一个一个的属性,这里属性节点不是元素节点中的子节点,而是元素点中的一部分
我们可以通个元素节点来获取指定的属性节点
<a href="https://www.baidu.com" id="baidu"></a>
var baidu = document.getElementById("baidu");
baidu.getAttributeNode("href") // 根据元素节点的属性名获取一个属性节点对象(一般不用)3.文本节点:html标签中的文字内容
文本节点表示html标签以外的文本内容
文本节点 一般作为元素节点的子元素存在,获取和修改文本节点,一般要先获取元素
DOM的获取
getElement(s)ByXXX()推荐,兼容性好
1.document.getElementById 通过id获取元素,(单个)
2.document.getElementByTagName 通过签名获取元素(多个)
3.document.getElementsByClassName 通过类名获取元素(多个)
4.document.getElementsByName 通过name属性获取元素(多个)
html5版本的查找元素方式,兼容性差
5.document.querySelector(css选择器)通过css选择器选择器查找元素(单个)
6.doucument.querySelectorAll(各种选择器)
通过别名获取:(不推荐)
document.title // 标题
document.head // 头部
document.body // 主体
document.images // 文档上所有的图片
document.all // 获取文档所有的节点
document.anchors // 获取锚点。
document.forms // 获取所有表单
document.scripts // 获取所有脚本 */获取和修改元素内容
1.获取元素的文本内容
var h1 = document.getElementsByTagName("h1");
console.log(h1);
console.log(h1[0].innerText);
获取h1标签的文本
console.log(h1[0].textContent);
获取h1标签的文本(可以识别符号)
console.log(h1[0].innerHTML);
获取h1标签的文本(可以识别标签和符号)2.获取元素的属性值
var baidu = document.getElementsByTagName("a")[0];
方法1 直接加 .
console.log(baidu.href);
console.log(document.getElementsByTagName("img")[0].src);
方法2 元素节点.getAttribute("属性名")
var img = document.getElementsByTagName("img")[0];
var imgAlt = img.getAttribute("alt");
console.log(imgAlt);3.获取元素节点的css样式(只能获取行内样式)
var p = document.querySelector("p");
console.log(p.style.width);
console.log(p.style.height);
console.log(p.style.color);
console.log(p.style.backgroundColor);
console.log(p.style.display);控制元素样式
var btn1 = document.getElementsByTagName("button")[1];
获取button按钮
btn1.onclick = function () {
给button按钮绑定事件
p.class = "changeRed"; // 错误写法 ,错误原因 :class是js关键字
p.className ="changeRed"; // 不推荐使用
p.className ="changeStyle";// 多次赋值时,最后一次有效,会覆盖之前的值
给元素添加类名 元素.classList.add("类名1","类名2","类名3",。。。。。)
p.classList.add("changeRed");
p.classList.add("changeStyle");
p.classList.add("changeRed", "changeStyle");// 推荐写法
}
移动类名
function removeClass() {
p.classList.pemove("changeStyle"); //推荐写法
// 移除style样式
// p.style = "";
p.serAttribute("style","") // 推荐
// 设置属性
// 元素.setAttribute("属性名","属性值")
}function judge(){
// 元素.classList.contains("changeRed")判断元素是否存在某个类名
// 如果存在返回true,如果不存在返回false
var div = document.querySelector("div");
// console.log(div.classList.contains(changeRed));
var falg = div.classList.contains("changeRed");
console.log(!falg);
if(!falg) {
div.classList.add("changeRed")
}else{
div.classList.remove("changeRed")
}
}
元素的增删改查
1.创建一个html元素的节点
function create(){
var div = document.createElement("div");
// 创建一个div元素
div.innerText = "好好学习,天天向上";
// document.body; //元素的容器,div是通过js创建的新元素
//获取body元素
document.body.appendchild(div);
// 在body元素容器最末尾添加子元素
}2.插入一个元素 容器.insertBefore(新元素,参照物元素)
function insert(){
var section = document.createElement("section");
// 创建元素
var createBtn = document.getElementById("create");
// 寻找参照物
document.body.insertBefore(section,createBth);
// 容器.insertBefore(新元素,参照物元素)
}3.appendChild()和append()的区别
function add() {
// 创建标签 追加元素 appendChild()参数必须是node,不能是字符串,所以他不能添加文本
var a = document.createElement("a");
a.href = "https://www.baidu.com";
a.textContent = "百度一下";
document.body.append("我是测试文本,没有意义")
}4.删除元素 父级容器.removeChile("子节点")
var p = document.getElementsByTagName(p)[0];
console.log(p);
function remove() {
// 移除p元素
// p.remove();
document.log(p);
}5.替换元素
function replace(){
var h1 = document.createElement("h1");
var h1text = document.createTextNode("学习完dom操作后,所有元素全部用js生成")
// 创建文本节点
h1.appendChild(h1text);
// 创建好的文本节点内容 添加到h1标签中
h1.classList.add("h1position",h1style);
// 给h1追加类名
h1.setAttribute("title","Dom真好,我爱dom")
// 给h1设置属性
// 元素容器,replaceChild(新元素,旧元素)
document.body.replaceChild(h1,p)
}缩小dom的查找范围
1.方法1 通过css选择器缩小范围
var baidu = document.querySelector("span a");
console.log(baidu);2.方法2 先找一个合适的父容器,在父容器中查找
var div = document.getElementsByTagName("div")[0];
var baidu2 = div.querySelector("a");
console.log(baidu2);3.方法3 先找一个适合的父容器,查询父容器中的子元素
var p =document.getElementsByTagName("p")[0];
console.log(p.childElementCount);
查找p元素的所有节点数量,注意:纯文本不算,孙子节点也不算
console.log(p.childNodes);
获取p元素的所有的子节点(文本,注释,元素,属性等都是节点)
console.log(p.children);
返回的只有元素节点,而childNodes包含了所有的节点
console.log(p.childNodes[i].data);
显示p标签中的注释节点
console.log(p.childNodes[3].querySelector(“a));查询父子节点和兄弟节点
previous 上一个 Element文档 Sibling相邻
console.log(ul.previousElementSibling);// p标签
console.log(ul.previousSibling);//会把相邻的文本也包含进去
带element查找的是元素节点,不带element会把换行的空白符也当成兄弟
看父寻子
var box2 = document.getElementById("box2");
console.log(box2.childNodes);
获取box2元素的所有的子节点(文本,注释,元素,属性等都是节点);
查找box2的所有子节点
console.log(box2.children);
返回的只有元素节点,而childNodes包含了所有的节点;
看子寻父
var span = document.getElementsByTagName("span")[0];
console.log(span.parentElement.parentElement);
查找span元素的父元素,一直向上查找,找不到返回null
console.log(span.parentNode);
查找父节点input事件
input属性,oninput表示在文本框输入文本时执行的事件,那些元素支持输入
input和textarea,普通元素div和p 不支持,如果你希望div等普通块元素之支持文本输入,你需要设置全局属性 contenteditable设置true,这样就支持输入,并且也支持oninput事件
value值 input标签中的内容
形参 表示接收过来的参数
oninput表示用户在输入框中输入文本时执行的事件
onchange事件 应用到input标签,文本框内容发生改变执行
ele和sel没有区别 sel有提示
focus事件
input获得焦点时执行onfocus事件
失去焦点时执行onblur事件
input提交事件onsubmit
onsubmit 用于表单提交时执行的事件
平时我们提交表单数据时,有两种方法
第一种,给form表单的button绑定onclick点击事件
第二种 控制form表单的onsubmit事件这个方法有个前提,form中的button必须时提交按钮
action 跳转的行为,表单提交后跳转的页面
method = "get/post" get是向服务器请求数据 post是提交数据
load和unload事件
代码从上往下执行,执行到此处,下方的p元素还没有创建
window最大的浏览器对象,浏览器窗口加载完成后才会执行,一般要保证
浏览器网页文档完全加载才会执行
鼠标事件
onmouseenter和onmouseover,有区别
onmouseleave和onmouseout,也有区别
所以说两组鼠标进入和离开 不要交叉使用
键盘事件
onkeyDown 用户按下任意键执行(如果不松手,会一直执行)
onkeyup 用户按下任意键 松手时执行 (按下弹起瞬间执行)
onkeypress 用户按下任意键 不松手时执行 (一直按,没有松手)
在这个元素范围内 按下某个键
事件对象event三个重要属性
key 按下的哪个键 比如你按下的时A键,结果就是A
keyCode 按下那个键所代表的keyCode编码
滚动事件
1.窗口滚动事件
window.onscroll = function(event){
console.log("滚动条动了")
}2.浏览器窗口的可见高度
console.log(document.body.clientHeight); //慎用3.滚动条滚动的距离
console.log(document.body.scrollTop);
console.log(document.documentElement.scrollTop)4.滚动的总高度 = 窗口的可见高度 + 滚动条滚动的距离
var clientHeight = document.documentElement.clientHeight;
// 窗口可视高度
var scrollTop = document.documentElement.scrollTop; //滚动距离
var scrollHeight = document.documentElement.scrollHeight; // 总高度窗口改变事件
window.onresize = function(){
console.log(this);
console.log("窗口大小发生改变了")
}拖拽事件
ondragstart:目标元素开始拖拽时执行的事件
ondrag:目标元素被拖动时执行(拖动的过程中会一直执行,每350毫秒触发一次)
ondragend:元素完成拖拽时执行
ondragenter:当被拖拽的元素进入时执行事件
ondragover:当被拖拽元素在接收元素中时执行
ondragleave:当被拖拽元素离开接收元素时执行
ondrop:当被拖拽元素放在接收元素上执行
DOM的发展
DOM0 绑定事件第一种方法 行内样式 可以添加多个回调函数,用分号隔开
温馨提示:事件绑定不要在行内绑定 ,容易造成html结构混乱,不利于代码维护(不建议)
DOM0 绑定事件第2种形式
// 通过此形式绑定的事件,多次赋值,最后一次有效,所以这样绑定,只会执行第二种
DOM2级 绑定事件通过addEventListener添加事件监听,可以多次绑定不同类型的事件,
且每个事件都有效 addEventListener在低版本浏览器不支持,但是这是未来300年的趋势,强烈推荐
事件流
事件的概念
HTML 事件是发生在html元素上的事情,当用户在html页面使用JS时,JS能够控制页面的行为,可以理解为事件是用户基于浏览器对网页一种交互行为,比如点击事件,鼠标事件,键盘事件
事件有一种特征,泄后,必须要等到用户操作,才会相应
事件流三个阶段:事件捕获阶段,处于目标阶段,事件冒泡阶段
1.事件捕获 由网景公司 团队提出来的 事件是先由最上一级的节点先接收,然后向下传播到具体的节点。(从外边向内层执行“挖洞”)
2.事件冒泡 是由IE开发团队提出来的,事件开始时由最具体的元素(文档中嵌套层次最深的那个节点)接收,然后逐级向上传播执行。就像冒泡一样(从内层向外层执行)
click事件,单击事件,就是单击才会执行的事件
cookie
js是运行在浏览器上,因此当我们的浏览器刷新,或者关闭,当前网页运行时生成的数据都会丢失
cookie可以帮我们将数据进行持久化的保存,即使浏览器重启或者刷新
chrome不支持file协议上的cookie
cookie的存储()
使用document.cookie = "key = value"的方式在浏览器的cookie中存储一个数据
key为改数据的名称,value为该数据的值
多次调用存储多个数据,不会将之前的数据覆盖
默认cookie存储的是会话级
btn.onclick = function () {
// 默认cookie存储的是会话级(当浏览器被关闭,cookie自动清除,刷新依旧保留)
document.cookie = 'name=小熊饼干';
document.cookie = 'food=小熊';
}设置该cookie的寿命
expires.onclick = function () {
// ;max-age=10 设置该cookie的寿命,单位为秒,只有手动删除或者到期cookie才会消失
document.cookie = 'people=老六;max-age=10';
// ;expires=时间 时间必须是GMT格式的时间
const time = new Date();
// 设置过期时间为我们想要的时间
time.setFullYear(time.getFullYear() + 1);
// 转换成GMT格式的字符串
const timeString = time.toUTCString();
document.cookie = 'friend=老七;expires=' + timeString;
}删除过期时间
delBtn.onclick = function () {
// cookie的删除只需要将过期时间设置为0即可
document.cookie = 'people=;max-age=0';
}设置cookie生效的ip地址
domain.onclick = function () {
// ;domain 设置该cookie生效的ip地址或者域名
document.cookie = 'age=10;domain=localhost'
}设置cookie的path属性为当前文件目录
pathCookie.onclick = function () {
// 默认设置cookie的path属性为当前文件的目录
// 127.0.0.1:5555/cookie.html => /
// 127.0.0.1:5555/test/cookie.html => /test
// path规定该cookie生效的位置, 该目录以及子目录都可以访问该cookie
// / => /xxx.html /test/xxx.html /1/2/3/xxx.html
// /test=> /test/xxx.html /test/1/2/xxx.html
document.cookie = 'sex=男;path=/test';
// 可以同时添加多个配置
document.cookie = 'sex=男;path=/test;max-age=10';
}cookie的读取
read.onclick = function () {
// 读取到cookie字符串,可以实现一个函数手动拆分
const cookie = readCookie(document.cookie);
console.log(cookie);
}webstorage
localstorage
长期本地存储,存储在localstorage中的数据只要不删除,将会永远存在,即使页面重新打开
sessionstorage
会话本地存储,页面存储的数据只能在当前标签页使用,一旦标签页关闭,该会话结束,数据自动删除
cookie与webstorage的区别
1.存储大小不同
cookie的大小不能超过4k;webstorage也是有大小限制的,不过比cookie大很多,5m或更大
2,数据有效期不同
(1),sessionStorage:更在当前浏览器窗口关闭前有效。
(2),localStorage:始终有效,即使窗口被关闭也有效。需手动清除
(3),cookie:在设置cookie时,设置的过期时间都是有效的,即使关闭了浏览器
3,作用域不同
(1),sessionStorage:不在不同的浏览器窗口中共享,即使是同一个页面。
(2),lecalStorage和cookie:在所有同源窗口都是共享的
4,webStorage支持事件通过机制,可以将数据更新的通知发送给监听者
5,cookie数据始终在同源的http请求中携带(即使不需要),即cookie在浏览器和服务器间来回传递
JSON
JSON 对象记法,是一种清凉的数据交换格式,json数据的语法是基于js的对象语法,本质上是字符串JSON通常也会进行手动书写,要注意以下几个点:
1.json的格式和js的对象十分相似,只是更加严格
2.json中不能写注释
3.必须使用{}或者[]包裹
4.json中的属性名必须使用双引号进行包裹
5.不能拥有函数和变量,其他的类型都可以使用
6.对象的末尾属性不能加逗号
JSON.stringify(obj);//将对象转换为JSON字符串,如果对象中有函数,将会自动将该函数删除JSON.parse(str);//将json字符串转换成对象JQUERY
jquery一共提供了两个全局变量
// $ jquery,都表示jquery是等价的
// $函数调用会返回一个jQuery对象,这个对象内部拥有jquery的一些功能函数
$(function () {
console.log($ === jQuery);
// 直接调用个不传递参数,会得到一个空的jquery对象
console.log($());
// 一般上会传递一个css选择器,用来进行元素的查找
console.log($('#three'));
console.log($('div:eq(2)'));
})jQuery选择器
jQuery选择器用于查询dom中的元素
console.log($('#one')); // id选择器
console.log($('div')); // 标签选择器
console.log($('.red')); // 类选择器
console.log($('.red,span')); // 类下的标签
console.log($('*')); // 匹配所有元素使用jQuery查询出来的元素对象属性于jQuery对象,只有jQuery对象才能调用jQuery的方法
console.log('======', document.querySelectorAll('div')); // 原生元素对象,不能使用jquery的方法原生元素对象转换成jQuery对象
console.log($(document.querySelector('div')));jQuery对象转换成元素元素对象数组
console.log($('div').toArray());
console.log(Array.from($('div')));取出查询集合中的某一个
console.log($('div')[1]); // 使用索引取值,得到的是原生元素对象
console.log($('div').get(1)); // 使用索引取值,得到的是原生元素对象
console.log($('div').eq(1)); // 使用eq取到的是jquery对象查询没有 red class的div
console.log($('div:not(.red)'));
console.log($(':not(.red)')); // 查询没有red class的所有元素
console.log($('input:checked')); // 获取被选中的input
console.log($('input:not(:checked)')); // 获取未被选中的input
console.log($(':header')); // 获取所有 h1、h2... 标签DOM操作
尾部增加元素
$('div').append("<h2>我是jquery添加的h2</h2>", '添加的第二个');头部添加元素
$('div').prepend('<span>看看好不好使</span>', '头部添加的第二个');将标签添加到目录元素尾部
$('<p>p标签</p>').appendTo('div').css('color', 'red');将标签添加到目录元素头部
$('<b>b标签</b>').prependTo(document.querySelector('div'));绑定点击事件
$('.test1,.test2').click(function (e) {
console.log(e.target);
});元素删除
function del() {
const one = $('.test1').remove(); // 移除元素,并且移除事件监听
const two = $('.test2').detach(); // 移除元素,不会移除事件监听
setTimeout(function () {
$('body').append(one, two);
}, 1000);
$('.test3').empty(); // 清空内容
}内容修改
$('.update1').text("<b>测试修改的标签</b>");
$('.update2').html("<b>测试修改的标签</b>");读取标签内容
console.log($('.update2').text());
console.log($('.update2').html());jQuery提供了遍历元素集合的方法
$('div').each(function (index, ele) {
console.log('索引', index);
console.log('元素', ele);
})样式和属性
jQuery中基本上所有的查询api,查询样式、class列表、宽度、属性等等,都是查询的第一个元素的属性
设置css
$('.style1').css('color', 'red'); // 支持传递两个字符串,一个是属性名一个是属性值
$('.style2').css({ // 支持传递一个对象,配置样式表
color: 'yellow',
fontSize: 30
});还可以传递函数,函数的返回值为当前元素的样式
const colors = ['red', 'blue', 'yellow'];
let i = 0;
$('div').css('color', function (index, value) {
i++;
if (i === colors.length) i = 0;
return colors[i];
})获取样式
console.log($('.style1').css('color'));
console.log($('.style1').css(['color', 'font-size']));属性
设置属性
$('.style3').attr('title', '测试属性');
// 读取属性
console.log($('.style3').attr('title'));
// 移除属性
// $('.style4').removeAttr('title');
$('.style4').attr('title', null);有些属性比较特殊,比如选择框的checked属性,只有属性名没有属性值
$('input').prop('checked', true); // 参数1为属性名称,参数2由布尔值决定添加或删除class的操作
$('p').addClass('ccc'); // 添加class
$('p').removeClass('b'); // 删除class
console.log($('p').hasClass('a')); // 判断是否拥有该class
$('p').toggleClass('d'); // 拥有该class就删除,没有该class就添加
$('p').toggleClass('d');
$('p').toggleClass('d');自定义属性
自定义属性用于在元素上存储一些数据
$('.data').data('info', { name: "张三", age: 18 });
// 自定义属性的读取
$('.data').data('info');常用的jQueryAPI
function getValue() {
// val() 读取输入框内容
console.log($('input').val());
// val(数据) 设置输入框数据
$('input').val(Math.random());
}寻找某个元素的兄弟标签
console.log($('.find').siblings());
console.log($('.find').next()); // 下一个兄弟元素
console.log($('.find').nextAll()); // 下面所有的兄弟元素
console.log($('.find').prev()); // 上一个兄弟元素
console.log($('.find').prevAll()); // 上面所有的兄弟元素查询所有的子元素
console.log($('ul').children());查询父元素
console.log($('.find').parent());查询所有的祖先元素
console.log($('.find').parents());替换h1元素为h2文本
$('h1').replaceWith('h2');
$('h2').replaceWith(`<h3>${$('h2').html()}</h3>`);
$('<b>我将替换h3</b>').replaceAll('h3');jQuery常用事件
1.事件ready(fn)
当DOM(文档对象模型) 已经加载,并且页面(包括图像)已经完全呈现时,会发生ready事件。通俗的来讲就是当页面加载完时就会执行此函数事件。可以在同一共页面中无限次地使用$(document).ready()事件。其中注册的函数会按照(代码中的)先后顺序依次执行
$(document).ready(function(){
// 在这里写你的代码...
});
使用 $(document).ready() 的简写(**最常用**),同时内部的 jQuery 代码依然使用 $ 作为别名,而不管全局的 $ 为何。
$(function($) {
// 你可以在这里继续使用$作为别名...
});
2.单击事件click([data],fn)
触发每一个匹配元素的click事件
这个函数会调用执行绑定到click事件的所有函数
//为id为btn的按钮添加单击事件
$("#btn").click(function(){
alert("触发单击事件");
})
//单击p后,该p被隐藏
$("p").click( function () { $(this).hide(); });双击事件 dblclick([data],fn)
当鼠标指针停留在元素上方,然后按下并松开鼠标左键时,就会发生一次click。在很短的事件内发生两次click,既是一次double click事件。提示:如果把dblclick和click事件应用于同一元素,可能会产生问题
//为id为btn的按钮添加双击事件
$("#btn").dblclick(function(){
alert("触发双击击事件");
})
鼠标移入事件mousemove([data],fn)
当鼠标指针在指定的元素中移动时,就会发生mousemove事件
mousemove事件处理函数会被传递一个变量——事件对象,其clientX和clientY属性代表鼠标的坐标
不论鼠标指针离开被选元素还是任何子元素,都会被触发mousemove事件。只有在鼠标指针离开被选元素时,才会触发mouseenter事件
//当鼠标移入页面获得鼠标指针在页面中的位置,显示在span中
$(document).mousemove(function(e){
$("span").text(e.pageX + ", " + e.pageY);
});鼠标移出事件mouseout([data],fn)
当鼠标指针从元素上移开时,发生mouseout事件
该事件大多数时候会与mouseover事件一起使用
注释:与mouseleave事件不同,不论鼠标指针离开被选元素还是任何子元素,都会触发mouseout事件。只有在鼠标指针离开被选元素时,才会触发mouseleave事件。请看下面列子的演示
//当鼠标从元素上移开时,改变元素的背景色:
$("p").mouseout(function(){
$("p").css("background-color","#E9E9E4");
});
鼠标符合事件(hover([over,]out))
一个模仿悬停事件(鼠标移动到一个对象上面及移出这个对象)的方法。这是一个自定义的方法,它为频繁使用的任务提供了一种“保持在其中”的状态
当鼠标移动到一个匹配的元素上面时,会触发指定的第一个函数。当鼠标移出这个元素时,会触发指定的第二个函数。而且,会伴随着对鼠标是否任然处在特定元素中的检测(列如,处在div中的图像),如果是,则会继续保持“悬停”状态,而不触发移出事件(修正了使用mouseout事件的一个常见错误)。
over:鼠标移到元素上要触发的函数
out:鼠标移出元素要触发的函数
$(window).keydown(function(event){
//当在页面按下键盘,弹出该键的Keycode
alert(event.keyCode);
// ...
// 不同的按键可以做不同的事情
// 不同的浏览器的keycode不同
// 更多详细信息: http://unixpapa.comjs/key.html
// 常用keyCode: 空格 32 Enter 13 ESC 27
});键盘松开事件keyup([data],fn)
当按钮被松开时,发生keyup事件。它发生在当前获得焦点的元素上
注释:如果在文档元素上进行设置,则无论元素是否获得焦点,该事件都会发生
$("input").keyup(function(){
//键盘松开,改变文本域颜色
$("input").css("background-color","red");
});键盘打字事件keypress([data],fn)
当键盘或按钮被按下时,发生keypress事件。
keypress事件与keydown事件类似。当按钮被按下时,会发生该事件。它发生在前获得焦点的元素上。不过,与keydown事件不同,每插入一个字符,就会发生keypress事件。注释:如果在文档元素上进行设置,则无论元素是否获得焦点,该事件都会发生
$("input").keypress(function(){
//键盘产生可打印字符
alert(“键盘打字”);
});元素获得焦点focus([data],fn)
当元素获得焦点时,触发focus事件。
可以通过鼠标点击或者键盘上的TAB导航触发。还将触发所有绑定的focus函数,注意,某些对象不支持focus方法
//为type=text的文本框添加获得焦点事件
$("input[type=text]").focus(function(){
//使人无法使用文本框:
this.blur();//当前节点失去焦点
});
元素失去焦点blur([data],fn)
当元素失去焦点时触发blur事件
这个函数会调用执行绑定到blur事件的所有函数,包括浏览器的默认行为。可以通过返回false来防止触发浏览器的默认行为。blur事件会在元素失去焦点的时候触发,既可以是鼠标行为,也可以是按tab键离开的
//任何段落失去焦点时弹出一个 "Hello World!"在每一个匹配元素的blur事件中绑定的处理函数。
$("p").blur( function () { alert("Hello World!"); } );元素值改变 change([data],fn)
当元素的值发生改变时,会发生change事件
该事件仅适用于文本域(text field)以及textarea和select元素。当用于select元素时,change事件会在选择某个选项时发生。当用于text field或text area时,该事件会在元素失去焦点时发生
$("input[type='text']").change( function() {
// 这里可以写些验证代码
});表单提交事件submit([data],fn)
当提交表单时,会发生submit事件
该事件只适用于表单元素
//提交本页的第一个表单
$("form:first").submit();
//如果你要阻止表单提交:
$("form").submit( function () {
return false;
} );绑定事件
在选择元素上绑定一个或多个事件的事件处理函数
on()方法绑定事件处理程序到当前选定的jQuery对象中的元素。在jQuery中,on()方法 提供绑定事件处理程序所需的所有功能
$("form").on("submit",function(){
//提交表单时触发
alert("提交成功!");
})
//代码2
//当调整浏览器窗口的大小时,发生 resize 事件。
//当用户滚动指定的元素时,会发生 scroll 事件。
$(window).on("resize scroll",function(){
//用户触发resize或scroll时,背景变红
$("body").css("background","red");
})
//代码3
//以对象的新式添加多个事件
$("#name").on({
//获取焦点
focus:function(){
$("#name").val("");
},
//失去焦点时
blur:function(){
if ($("#name").val()=="") {
$("#name").val("请输入用户名")
}
}
})移出事件
在元素上移出一个或多个事件的事件处理函数
$("form").on("submit",function(){
//提交表单时触发
alert("提交成功!");
})
//代码2
//当调整浏览器窗口的大小时,发生 resize 事件。
//当用户滚动指定的元素时,会发生 scroll 事件。
$(window).on("resize scroll",function(){
//用户触发resize或scroll时,背景变红
$("body").css("background","red");
})
//代码3
//以对象的新式添加多个事件
$("#name").on({
//获取焦点
focus:function(){
$("#name").val("");
},
//失去焦点时
blur:function(){
if ($("#name").val()=="") {
$("#name").val("请输入用户名")
}
}
})
$("#btndel").on("click",function(){
//解除submit事件绑定
$("form").off("submit");
//解除文本框focus和blur事件绑定
$("#name").off("focus blur");
})最后在插入一个知识点 jQuery核心each(function{}) 就相当于循环遍历
定义和用法
each() 方法规定为每个匹配元素规定运行的函数。
提示:返回 false 可用于及早停止循环。
$(selector).each(function(index,element))
参数:
function(index,element)
描述:
必需。为每个匹配元素规定运行的函数。
index - 选择器的 index 位置
element - 当前的元素(也可使用 "this" 选择器)//输出每个 li 元素的文本:
$("button").click(function(){
$("li").each(function(){
alert($(this).text())
});
});动画
$('.test1-show').on('click', function () {
// 参数1:动画的速度,可以为"slow","normal", or "fast"或者是一个毫秒数 (默认没有动画)
// 参数2:动画效果,默认swing,可以修改为linear表示匀速的
// 参数3:函数,这个函数将会在动画完成之后执行
$('.test1').show("slow", "swing", function () {
console.log('动画执行完毕');
});
})
$('.test1-hide').on('click', function () { // 和show的参数相同
$('.test1').hide(3000, "linear");
})
$('.test1-toggle').on('click', function () { // 和show的参数相同
// 如果当前为显示,则隐藏。如果当前为隐藏则显示
$('.test1').toggle(1000);
})
$('.test2-show').on('click', function () {
// 和show的参数相同
$('.test2').slideDown("slow", "swing", function () {
console.log('动画执行完毕');
});
})
$('.test2-hide').on('click', function () {
// 和show的参数相同
$('.test2').slideUp(1000, "linear");
})可以使用animate创建自定义动画
$('.test3-1').click(function () {
// 参数1:动画的终止效果
// 参数2: 动画执行时间
// 参数3: 动画执行速率
// 参数4:回调函数(不局限于参数的位置)
$('.test3')
.animate({
width: 200,
height: 50,
borderRadius: '50%'
}, 2000)
.animate({
width: 700,
height: 200,
borderRadius: '70%'
})
.fadeOut()
.css({ // 这个操作不会等待其他的动画执行
backgroundColor: 'yellow'
})
.fadeIn()
})
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论