ES5基础
...大约 45 分钟
ES5基础
语法规范
- 变量名可以字母、数字、下划线、横线、美元符；不能以数字、保留字、关键字名
- 严格区分大小写
- 分号是语句结束的标志
- 驼峰命名为首字母大写，小驼峰则是第二个单词大写
- 建议使用驼峰命名，尤其是小驼峰，见名知意
- 不能省略关键字，声明未赋值，不会报错，但不能使用
错误排查
语法错误会阻止所有代码都不执行
除语法错误外的其它错误(包含自定义错误)，只会阻止后续代码执行
语法错误，只要出现SyntaxError
- 引用错误，只要出现ReferenceError
- 类型错误，只要出现TypeError
- 范围错误，只要出现RangeError
- 自定义错误，只有Uncaught和自定义的提示文字
- 自定义错误是程序员自己制定的错误
- 语法：throw "提示文字"
throw "错误"
- 如果不想阻止后续代码执行，可使用try{} catch(){}尝试执行，不会阻止后续代码执行，也叫异常捕获
try{
尝试执行，可能出现错误的代码
}catch(err){
捕获错误
err具体错误信息
具体处理错误方案
}
变量和常量
- 可以改变的量，存储的数据可以重复动态修改，再次赋值就是修改
- 省略关键字表示全局，加上关键字是局部
创建变量、声明和赋值
代码理解思路：代码从左向右写，从右向左读代码
- 语法：
var a = 10; //Var为关键字，表示把10赋值给a；
- 语法：
在ES5里，可以先声明后赋值
- 例：
Var a; //先声明一个变量a
a = 20； //后赋值
- 也可以声明多个变量后赋值，以逗号隔开，分号结束
- 例：
Var a,b,c; //声明了三个不同的变量
a = 1; //赋值给a
b = 2; //赋值给b
c = 3; //赋值给c
当然也可以同时声明并赋值多个变量
- 例：
var m = 1,n = 2;
- 例：
如声明了未赋值，会输出Undefind，表示未定义，不会报错
- 例：
var a; console(a) //输出Undefind
- 例：
如省略关键字和赋值，则输出会报错（is not defind）,意思提示未定义
- 例：
a; console(a) //a is not defind
- 例：
常量
- 存储固定不变的数据，一经定义就不能修改，任何尝试给常量再次赋值的操作都会报错
- 常量使用const声明，为了区分变量，常量一般采用全大写字母表示
- 语法：
const PI = 3.14;
- 语法：
数据类型
- 原始类型数据是直接存储在栈内存中，当一个变量的值赋值给另一个变量后，当改变其中一个变量的值后，另一个不受影响，因为他们在栈内存中是不同的变量，但值相同而已
- 原始类型中，如果一个变量没有调用，计算机会自动回收该代码，以节省内存空间
- 示例：
var a=1; //在栈内存中创建了一块新空间
var b=a; //把a的值复制了一份赋值给了b，同样也是在栈内存中创建了一块新空间
a=2; //修改a的值
console.log(b); //因为a和b在栈内存中分在不同的空间，所以改变a不会影响b
- 引用类型是在堆内存中创建了一块新的空间，并且生成了一个16进制地址保存在栈内存中
- 当一个引用类型的值赋值给另一个引用类型，并不是复制的值，而是复制的地址
- 所以当改变a引用类型的数据时，b引用类型也在改变，他们都使用的是一个16进制地址去堆内存中访问的
- 如果一个引用类型没有再使用，需要手动解除引用类型再栈内存中的地址，计算机才能实现自动回收
- 图示：
原始类型
- 数值类型(number)
- 整型(整数)
- 代码中如果以0开始或0x开始，计算机会默认为是八进制和十六进制的表示方式
- 计算机会把各种进制转换为十进制进行输出
- 建议自定义变量存储整数时不要以0开始，以免计算机误判
var a 10; //十进制表示方法
var b = 053; //八进制表示方法，0开头前缀
var c = 0x53; //十六进制表示方法，0x开头前缀
- 浮点型(小数)
var a = 3.14;
console.log(a);
- 使用幂运算进行科学计数法，表示较大或较小的数据
- 使用字母e表示10为底（意思就是e*10的n次方）
var a2 = 1.5e5; //表示1.5 * 10^5次方（e5）
- 字符串类型(string)
- 字符串有0个或多个字符组成，用单引号或双引号表示、
- 会自动为每一位字符分配下标索引
- 下标(索引)是从0开始，依次往后
- charAt()和charCodeAt()方法如不指定具体下标，则表示的是最前面第一个索引（也就是0），做条件判断时常用
- 使用charAt()方法查看指定下标字符
console.log(a.charAt(1)); //查看变量a的索引1对应的字符
- 使用charCodeAt()查看指定下标对应字符的编码值
console.log(a.charCodeAt(1)); //查看变量a的索引1对应的字符编码
- 布尔类型(boolean)
- 只有俩个合法值true和false，常用于条件判断的结果或状态的标识？
- 表示真假
var a = true;
var b = false;
- 未定义(undefined)
- 变量声明未赋值时为undefined
var a; //声明变量未赋值
console.log(a); //输出未undefined
- 空类型(NULL)
- 属于对象类型，用于解除对象引用（解除引用类型的地址，让计算机实现自动回收无效的引用类型）
- 语法：
var obj1 = {
name:"tom",
play:function (a,b){
console.log(a+b);
}
}
var obj2 =obj1;
//解除俩个对象栈内存地址，实现自动回收俩个对象
obj1=null;
obj2=null;
引用类型
- 函数、对象、数组等都属于引用类型
检测数据类型
- 使用typeof检测数据的类型
console.log(typeof a); //检测变量a的值是什么类型
类型转换
自动类型转换(隐式转换)
数值运算
- 数值运算时，会自动把俩个数值运算，并不需要转换
字符运算
- 字符串参与加法运算：一律视为字符串的拼接，返回结果永远都是字符串
- 字符串拼接使用 + 。
- 非数字字符串无法转number，返回NaN(不是一个数字)
- 字符串参与除加法以外的运算，会自动将字符串转换成数值进行运算
var a = "hello" + undefined; //返回helloundefined，类型为string
var b = "3" - 1; //输出为2，类型为number
var c = "hello123" - 2; //输出为NaN
- 布尔运算
- 布尔true代表数字1，false代表数字0
- 布尔与数值参与运算时，会自动把布尔转为数值运算，输出结果也为数值
var a = 10 - true; //返回为9，类型为数值
- 布尔值和字符串参与除加法以外的运算时，会把双方转换为数值进行运算
- 如无法转换为数值，则输出NaN
var a = “3”- true; //返回2，类型为数值
var a = “hello123" - false; //返回NaN
- 布尔和布尔参与运算，返回为数值
var a = true - true; //返回为0 类型为数值
- 特殊值运算（undefined和null）
- 特殊值参与运算时，undefined输出为NaN，null为0
var a = 1+undefined; //输出为NaN
var b = 1+null; //输出为1
强制类型转换
数值类型转换
- Number方法转换
- 转换数值类型时，字符串中含有字母无法解析
- 布尔类型中的true代表数字1，false代表数字0
- 示例：
console.log(Number("100")) //输出100
console.log(Number("h1")) //输出NaN
console.log(Number("true")) //输出NaN
console.log(Number(true)) //输出1
- 字符串中提取数值
- parseInt是在字符串里从左到右转换数值，如遇到无法转换的，则立即停止，返回已经转换的，
- parseInt提取字符串中的整数部分
- parseFloat提取字符串中的小数部分
- parseFloat是在字符串里从左到右转换数值，如遇到无法转换的，则立即停止，返回已经转换的，会保留第一个小数点，第二个则不保留
- 示例：
//parseInt
console.log(parseInt("100")) //输出100
console.log(parseInt("100hello")) //输出100
console.log(parseInt("H100")) //输出NaN
console.log(parseInt(true)) //输出NaN
console.log(parseInt(3.5)) //输出3
//parseFloat
console.log(parseFloat(3.5)) //输出3.5
console.log(parseFloat("3.5hello")) //输出3.5
console.log(parseFloat("h3.5")) //输出NaN
console.log(parseFloat("3.5.6")) //输出3.5
console.log(parseFloat("3.5true")) //输出3.5
- 特殊值转Number
console.log("---Number()---")
console.log(Number(undefined)); //输出NaN
console.log(Number(null)); //输出0
console.log("---parseInt()---")
console.log(parseInt(undefined)); //输出NaN
console.log(parseInt(null)); //输出NaN
console.log("---parseFloat()---")
console.log(parseFloat(undefined)); //输出NaN
console.log(parseFloat(null)); //输出NaN
转字符串
- . 代表访问对象的属性方法，讲对象类型时详细说明
- 使用toString方法转换字符串
- undefin和null无法转换字符串，其他均可
- 语法示例:
console.log(s1.toString());
转布尔
- 非0的都输出true，包括非空字符串（空格字符串）
- 0\0.0\undefined\null \NaN都出书false
- 示例：
console.log(Boolean(100));
console.log(Boolean("100"));
console.log(Boolean(3.5));
console.log(Boolean(' '))
console.log(Boolean(''));
console.log(Boolean(0));
console.log(Boolean(0.0));
console.log(Boolean(undefined))
console.log(Boolean(null));
console.log(Boolean(NaN));
运算符
运算符优先级
- 运算符优先级是一套规则。该规则在计算表达式时控制运算符执行的顺序。具有较高优先级的运算符先于较低优先级的运算符执行。例如，乘法的执行先于加法。
- 圆括号可用来改变运算符优先级所决定的求值顺序。这意味着圆括号中的表达式会优先圆括号外的表达式优先执行
- 从高到低排序
| 运算符 | 描述 |
|---|---|
| . [] () | 字段访问、数组下标、函数调用以及表达式分组 |
| ++ -- - ~ ! delete new typeof void | 一元运算符、返回数据类型、对象创建、未定义值 |
| * / % | 乘法、除法、取模 |
| + - + | 加法、减法、字符串连接 |
| << >> >>> | 移位 |
| < <= > >= instanceof | 小于、小于等于、大于、大于等于、instanceof |
| == != === !== | 等于、不等于、严格相等、非严格相等 |
| & | 按位与 |
| ^ | 按位异或 |
| | | 按位或 |
| && | 逻辑与 |
| || | 逻辑或 |
| ?: | 条件 |
| = oP= | 赋值、运算赋值 |
| , | 多重求值 |
赋值运算
- 将右侧的值赋值给左侧的变量
var a = 100; //
算数运算符
- / 有+ - * / %等算数运算符
console.log(5/2);/5除以2
console.log(5%2);//取余或取模运算
自增和自减，对自身进行+1或-1的操作
自增和自减只能与变量结合
自增或自减会把变量转Number来自增或自减运算
单独与变量结合
//单独与变量结合，放前或放后都可以
b++;
console.log(b);
++b;
console.log(b);
- 与赋值运算符结合使用
- ++或--放前放后的区别，放在变量前就先运算，放变量后就后运算
var c = 10;
var r1 = c++; //放后，先赋值后++
console.log("c:",c,"r1:",r1);//c:11,r1:10
Var r2 = ++c; //先++，后赋值
console.log("c:",c,"r2:",r2);//c:12,r2:12
复合运算符（扩展运算符）
- +=、-=、*=、/=、%=
- 常用于字符串拼接，左侧的变量等于左侧变量和右侧变量运算后的值
- 语法：
var a = 1;
var b = 2;
a += b; // a = a+b
逻辑运算符
- &&(逻辑与)、| |(逻辑或)、！(逻辑非)
- 连接俩个表达式，检测条件是否成立，最终结果为布尔值
- 逻辑与&&
- 俩个表达式同时成立，则返回true
var r1 = 5>3 && 10>5;
console.log(r1);
var r2 = 5<3 && 10>5;
console.log(r2)
- 逻辑或 | |
- 只要有一个表达式成立，则返回true
var r3 = 5<3 || 10>5;
console.log(r3);
var r4 = 5<3 || 10<5;
console.log(r4)
- 逻辑非 ！
- 对当前表达式结果取相反结果（如果真，就取假，如果假，就取真）
var r5 = !(5>3);
console.log(r5);
var r6 = !0;
console.log(r6);
比较运算符（关系运算符）
、<、>=、<=、==、!=、===、!==、
- 比较运算返回的结果是布尔值
- 字符串参与比较运算时，比较的是字符串对应的unicode编码，逐位比较
- 查询unicode编码方法为charCodeAt();方法
- 如果NaN参与比较运算，结果一律为false
- 示例：
r1 = 5>3;
console.log.log(r1);
r2 = "5" > 3; //5>3
r3 = "5" > true; //5>1
r4 = true >5; 1>5
r5 = true > false; //1>0
console.log(r2,r3,r4,r5);
var r6 = "hello" > 10; //NaN > 10
console.log(r6)
r1 = "2" >"10";
console.log("2".charCodeAt(),"1".charCodeAt(),r1)
- 区分相等和全等
- 相等==
- 松散比较，包含自动类型转换，只要值相等就成立，返回 true
r1 ="10" == 10;
console.log(r1) //输出true
- 全等===
- 严格比较，不包含数据类型转换，只有类型一致并且值相等结果才成立，返回 true
r2 ="10" === 10;
console.log(r2) //输出false
- 比较运算符练习，奇偶数练习
- 判读是否被2整除
var add = 2021;
var even = add%2 ==0;
console.log(even);
- 判断是否被300整除，或被4整除且不能被100整除
var add2 = 20;
var even2 = add2%400 == 0 || add2%4 == 0 && add2%100 != 0;
console.log(even2);
三目运算符
三目运算符有三个表达式参与运算，？前面第一个表达式参与运算，不参与结果执行 三个以上表达式可使用三目运算符嵌套
语法为：表达式1 ？ 表达式2 ：表达式3 如果表达式1成立，则执行表达式2，不成立则执行表达式3
语法示例：
var a = 18>20 ? "YES" : "NO";
console.log(a);
- 三目嵌套运算示例：
var num = 95;
good = num >= 90 ? "优秀" : num >= 80 ? "良好" : num >= 60
? "及格" : "不及格";
console.log(good);
位运算符
直接操作数据的二进制位，除异或运算，其他运算应用较少 将十进制的整除转换二进制后，对二进制数的每一位进行操作
位与运算 &
- 将俩个数转换为二进制后，逐位进行操作，返回1或0
- 运算流程示例：
- 位或运算 |
- 将俩个数转换为二进制后，逐位进行操作，运算后转为十进制返回结果
- 运算流程示例：
- 异或运算 ^ 将俩个数转换为二进制后，逐位进行操作，运算后转为十进制返回结果
- 练习：交换俩个变量的值
var a = 3, b=5;
//传统做法：定义第三个变量，保存某个变量的初始值
var c = a;
a = b; //a = 5, b = 5
b = c;
console.log(a,b);
//不借助第三方变量
a = a ^ b; //3 ^ 5 -> 6
b = a ^ b; //6 ^ 5 -> 3
a = a ^ b; //6 ^ 3 -> 5
网页基本弹框
- 网页警告框
alert("提示信息")
- 带有输入框的弹框，返回输入的内容
- 返回结构一律是字符串类型
- 点击确定时，返回弹框中的内容
- 如果未输入，则返回空字符串，点击取消时，直接返回结果为null
- 示例：
var r = prompt( );
流程控制
- 控制代码执行的顺序和次数
- 三种结构
- 顺序结构 代码按照书写顺序从上到下依次执行
- 选择结构/分支结构 根据条件是否成立，选择执行某段代码
- 循环结构 根据条件是否成立，决定是否重复执行某段代码
选择结构/分支结构
IF语句
- 单if语句
- 当条件满足时，执行语句块，然后执行IF语句下面的语句； 否则跳过语句块，直接执行IF语句外面的语句
- 语法：
if("条件"){
console.log("执行此语句");
}
console.log('我是IF语句外面的语句');
- if-else语句
- 用于处理分支逻辑
- 当条件满足时，执行语句块1，然后执行if-else外面的语句 条件不满足时，执行语句块2，然后执行if-else外面的语句
- 语法：
if ("条件"){
console.log("条件为真");
}else {
console.log("条件为假");
}
console.log("我是if-else外面的语句");
- 多重分支语句if-else-if
- 示例练习：
switch case语句
- 用于判断值的全等匹配（===）不会类型转换
- 和if不一样的是，if是判断条件，switch是接收匹配全等的值
- default用于设置所有case都匹配失败后的操作，和if语句最后的else一样
- break是防止穿透，不加break的情况下，如果其中一个case匹配上，还是会继续输出当前case 匹配后的值，所以默认情况下，每个case下加break防止穿透
- case后写匹配的值，需和接收变量的类型一样
- 练习示例：
- 多个case共用代码段
循环结构
- 如循环结构中有switch语句，那么switch里的break只对switch本身生效，并不影响循环本身
while语句
- 循环操作一般需要存在使循环终止的可能性，否则将成为“死循环”
- break关键字在循环结构中代表终止循环的意思
- continue关键字是跳过一次循环，继续下一次循环，需要在continue上一行加变量自增（i++）配合使用才能跳过循环
- 语法示例：1~100之间偶数的和
var even = 0;
var odd = 2;
while (even<=99){
even++;
if(even%2==0){
odd = even+odd;
}
}
console.log(odd);
do while语句
- 与while语句相反，先执行后判断
- 当初始值不满足循环条件时，while循环一次都不会执行，do-while循环不管任何情况都至少执行一次
for语句
- 语法执行逻辑：
- 简写模式：
- for循环中的表达式均可移到外面或添加三个以上，如下：
- 多个条件表达式时，后边的表达式起作用
嵌套循环练习
- 九九乘法表：
for (var i = 1; i<=9; i++){ //最外层的for循环控制的是遍历的行数
//内层循环的str+"",等同于放到此处
for (var j =1,str=""; j<=i;j++){ //内层的for循环控制的是具体的操作
str +=i+"*"+j+"="+i*j+" ";
//str = 每次i遍历的值+每次j遍历的值+字符串"="+每次算法后的空格
}
console.log(str); //外层遍历一次，输出一次
}
函数
普通函数
函数名可以作为参数传递
函数分为系统函数和自定义函数
功能、函数、方法、接收若干个数据，返回处理的结果。
用于封装多次重复执行的代码，实现代码复用
函数使用完整代码解析：
- 形参可填写一个或多个，函数调用时，实参可填写一个和多个，填写一个时，如果形参为俩个或多个，那其他形参的值为undefined，调用结果为NaN
- 填写多个实参代码后续整理
- 形参也可填写一个或多个
//函数声明->保存代码段
function 函数名(形参1，形参2){
//执行函数体
console.log(形参1+形参2);
return 返回值;
}
//函数调用->执行函数体
函数名字(实参1，实参2);
- 模块化开发时，变量声明和调用可能会在不同的文件中，此时如果断点调试，只会在当前文件函数调用中调试，如需跳入内部看整体执行调试，则需在浏览器端中点击下图此处：箭头上为跳入内部调试，下为跳出内部调试
- 练习示例：输出等腰三角形
//第一步找到规律
//如总行数为5，第1行空格为4，以此类推，规律：总行数-每行的行数=每一行的空格数
// * 数为奇数排列1、3、5、7、9，2倍数 * 每行的行数-1=每一行的 * 数量
//2*1-1=1，2*2-1=3，以此类推...
//第二步封装一个函数，创建循环
function xx(h){
//循环行数h
for (var i = 1;i<=h;i++){
//str为*，spa为空格
for (var j =1,str="",spa="";j<=h-i;j++){
//空格数 = 总行数-每次循环的行数
spa+=" ";
}
for (var x =1;x<=2*i-1;x++){
// * 数量=2*每一行的行数-1
str+="*";
}
//空格和 * 做拼接赋值给num做输出
var num = spa+str;
console.log(num);
}
}
//第三步调用
xx(5);
return返回值
- 函数内声明的变量，函数外无法直接访问，只能通过保存接收return返回的值，才能调用
- switch里如果有retrun返回值，就不必再加break，俩者的作用是一样，都是阻断往后执行
- if里面也一样，只加retrun也是起到阻断作用
- 函数调用时，如果里面有retrun，则调用的时return返回的值
- return用于获取函数调用后的结果，如果函数中没有retrun或者return后不加任何值，返回undefined，retrun一旦执行后，会立即结束函数，不会执行后续函数体内的代码
- return返回值需要把值保存在变量中，才能方便后续调用
- 示例：
function get(a,b,c){
//比较a与b哪个最大，返回哪个
var max=a>b ? a : b;
//return返回max和c比较时最大的值
return max>c ? max : c;
}
//调用函数填写实参并保存在res函数中
var res = get(5,3,6);
//输出res的值
console.log(res);
作用域
作用域链：访问变量时，会经历从当前作用域到上一级作用域逐级查找的过程（就近原则）
意思是变量和函数的可访问范围
在函数中，不加var关键字声明的变量为全局变量，但是不推荐，严格模式不兼容，会报错
全局作用域（变量）
- 函数外部使用var关键字声明的变量为全局变量，任何位置都可以访问
函数(局部)作用域（变量）
- 函数内部使用var关键字声明的变量为局部变量，只能在当前函数内访问
函数的作用域
- 函数的可访问范围，同样也分为全局函数和局部函数，全局函数可以在任何未知访问 局部函数只能在所在作用域下访问
- 示例：
function fn(){
console.log(1);
}
function foo(){
fn();
//函数作用域
//fun是局部函数
function fun(){
console.log(2);
}
fun();
}
foo();
变量提升
- 在ES5中，如果变量在代码后声明，代码执行不会报错，而是会输出undefind，因为ES5执行过程中，会把变量提升至执行代码前，但不赋值，然后在执行代码后赋值
- 在ES6中不存在该问题
- 使用function 关键字创建的函数也会和变量一样提升到所在作用域的最前边
- 示例：
//原代码
console.log(a);
var a =1;
//ES5执行时的代码
var a;
console.log(a);
a=1;
匿名函数
- 匿名函数不能直接在代码中写，会报错，必须用函数表达式或回调函数等方式使用
函数表达式
- 就是省去函数名的函数，没有名称的函数，用变量接收函数的声明
- 语法示例：
//函数声明方式
function fn(){
//执行代码块
}
fn();
//匿名函数 - 创建变量接收匿名函数(也叫函数表达式)，函数表达式不存在函数提升
//变量名存储的就是函数代码段，作用等价于函数名，同样可以使用 "变量()"调用函数
var a = function(){
//执行代码块
}
a();
匿名函数自调用
- 构建一个局部作用域，避免全局污染，也可以避免函数需要手动调用
- 语法：
- 第一个()中是具体匿名函数，第二个()中表示函数调用，传递实参
- 语法：
//定义匿名函数开始 (function(){
console.log(a+b);
}) //定义匿名函数结束 (10.20); //函数自调用，传递实参
回调函数
- 匿名函数作为实参传递，先传递匿名函数赋值给函数名，然后回来调用具体匿名函数里的代码块
- 语法示例：
//计算俩数相加的和
function add(a,b){
var c = a()+b(); //实参a和实参b相加的和赋值给c
console.log(c); //输出c
}
//回调
add(function (){ //赋值给形参a
return 2;
},
function (){ //赋值给形参b
return 4;
});
全局系统内置函数
Number()
- 对象值转数字
String()
- 对象值转字符串
parseInt()
- 字符串转整数
parseFloat()
- 字符串转浮点数
encodeURI()
- 字符串编码为URL，针对非英文
- 语法：
var url = "https://search.bilibili.com/all?keyword=OBS直播间界面设置"
var str = encodeURI(url);
console.log(str)
- decodeURI()
- 解码某个编码的URL，针对非英文
- 语法：
- 解码某个编码的URL，针对非英文
//已编码的字符串
var url = "https://search.bilibili.com/all?keyword=OBS直播间界面设置"
var str = encodeURI(url);
console.log(str)
//解码字符串
console.log( decodeURI(str) );
- isNaN()
- 检测是否是NaN，返回布尔值，是就返回true，不是就返回false isFinite()
- 检测是否是有限的值或无穷大的值，返回布尔值，如果是Infinity，返回false，相反则返回true eval()
- 执行字符串中的表达式，如果字符串中的表达式存在错误，则会报错
- 语法：
console.log ( eval ( "parseInt ( 3.145 )" ) );
还有其它表达式后期补充，.......等
递归算法（简单理解，面试笔试多用）
- >>递归算法入门讲解<<
- 函数的递归调用，意思就是函数在自身内调用自己
- 如下：
function fn(){
console.log(1);
fn();//函数自身调用自身
}
- 递归执行流程：
对象(object)
- 属于引用类型的数据
- 对象是一组属性(property)和方法(method)的集合
对象分类
- 内置对象(ES对象)：JS提供的对象
- 宿主对象：根据不同的执行环境划分，node.js等等...
- 自定义对象：用户自己创建的对象
创建对象
对象字面量创建对象
- 使用 { } 花括号创建空对象，属性名和值之间冒号隔开，多组属性之间用逗号隔开，属性名中的引号可加可不加，如果含有特殊字符必须加
- 语法：
内置构造函数创建对象
- 使用new关键字创建一个空对象，然后添加属性，如果是没有属性的空对象，( )可以省略
- 示例：
//使用new Object( )创建空对象
var obj1 = new Object( );
//若对象没有属性，是空对象，可以省略( )
var obj1 = new Object;
//给新创建的空对象添加属性
obj1.name = "John";
自定义构造函数创建对象
- 后期第三阶段讲到
访问对象属性
- 通过 . 连接属性名访问或新建对象中的属性，或者[ "" ]也可以,，如果属性名没有创建不存在，则不会报错，返回undefined
- 示例：
//通过 . 连接
obje1.name="tom" //修改或添加属性
console.log(obje1.name) //访问
//通过 [""] 连接，属性必须要加 " " 包起来
obje1["sex"] = "女" //修改或添加属性
console.log(obje1["sex"]) //访问
//访问不存在的属性，返回undefined
console.log(obje1.id) //undefined
//如果属性名中存在关键字、非法字符、空格之类，就只能使用 [ " " ]访问或修改
obje1["book name"] = "深入分析Java";
obje1["for"] = "Evething"
遍历对象属性
- 使用for in遍历对象属性，原理是在遍历条件中创建一个新的变量保存每一个属性的值，然后通过 "对象名[新的变量名] " 访问对象属性的值
- 示例
//创建对象
var obj1 = new Object( );
//添加属性和值
obj1["name"] = "tom";
obj1.sex = "女";
//遍历对象属性，不包含值
//key代表创建的新变量，in代表的是从哪个对象开始遍历，in后面则是对象
//把对象每一个属性值保存至"key"变量中
for ( var key in obj1 ) {
//如果只输出"key"变量，返回的则是属性name 和 sex，但不包含值
console.log( key );
//需要输出属性的值，则需要通过 "对象名[保存的变量]"来使用
console.log( obj1[key] )
//俩者结合则可以输出属性和值
console.log( key+":"+obj1[key] )
}
检测对象属性是否存在
- 第一种通过判断是否为undefined来检测属性是否存在 方法："对象名.属性名 === undefined"
- 第二种通过 "对象名.hasOwnProperty("属性名")" 方法检测
- 第三种通过 in 关键字检测
- 都是返回布尔值
- 语法：
//如果属性为undefined，也就是属性不存在，返回true，反之则false
console.log(obj1.id === undefined);
//如果属性存在返回true，反之则false
console.log(obj1.hasOwnProperty("id"));
//如果属性存在返回true，反之则false
console.log("name" in obj1);
对象的方法
- 对象的方法指的是绑定在对象内部的函数，只能由对象调用，就称为对象的方法
- 调用方法：对象名.绑定函数的属性(实参)
- 语法示例：
var obj2 = {
name:"tom",
play:function (a,b){ //绑定函数的属性
console.log(a+b);
}
}
obj2.play(1,2); //对象调用绑定函数的属性，并填入实参
this关键字
- this常用于方法或函数的内部，指代当前的调用者，当前的对象...
- 第三阶段讲DOM操作细说
数组(Array)
- 保存批量数据的数据结构，每个数据称为元素，存储的类型不限，变量、函数、对象、数组等等
- 是一种有序可变的存储结构，有序是数组中的元素自动分配下标，从0开始。可变是元素、长度可变
创建数组
字面量创建数组
- 使用 [ ]创建空数组，每个元素用逗号隔开
- 语法：
var a = [ ];
内置构造函数创建数组
- 使用“ new Array”创建一个空数组，然后访问或修改添加元素，如果创建数组中里面只有一个数字，则代表初始化数组场长度
- 语法：
var b = new Array( );
访问数组元素
- 数组中是通过下标(索引)访问或添加修改元素，下标(索引)是从0开始，也就是每一个元素对应的下标是长度减一
- 语法：
//正常情况下的排序是1-tom，2-jerry，3-john，4-sam
//下标则是每个元素的长度减一，也就是0-tom，1-jerry，2-john，3-sam
var a = ["tom","jerry","john","sam"];
- 通过“数组名[下标] ”来访问或添加修改元素
- 语法：
//创建数组
var a = ["tom","jerry","john","sam"];
//访问、修改、添加元素
console.log( a[0] ) //访问第一个下标为0的元素
a[1]="locy" //修改第二个下标为1的元素
a[4]="news" //添加第五个元素，下标为4
- 可以随机根据不同下标添加元素，中间隔着的下标元素则为空内容
- 例如：
//现在只有四个元素，下标为0~3
var a = ["tom","jerry","john","sam"];
a[6]="test"; //之前下标为4、5的元素内容则为空内容
数组的长度
- 通过 "数组名.length" 方法可以获取数组的长度
- 通过“ 数组名 [ 数组名.length ] ”可以在数组末尾(最后一位)追加元素，而不用指定下标添加元素
- 语法：
//创建数组
var a = ["tom","jerry","john","sam"];
//获取数组长度
console.log( a.length );
//数组最后一位追加元素
a[a.length]="tom";
数组分类
索引数组
- 以0以上的整数排序做下标，分为一维数组、二维数组
- 一维数组的元素时不同类型的数据，二维数组的元素是多个一维数组
- 一维数组的length指的是，数组的元素个数
- 二维数组的length指的是数组内一维数组的个数
关联数组
- 以字符串做下标，只能单独添加每一项元素，只能通过添加元素的方式实现字符串做下标
遍历数组
- 通过for in遍历数组，和遍历对象一样
var arr1 = [ 'tom','jerry','john']
for (var arrkey in arr1) {
console.log(arrkey+":"+arr1[arrkey]);
}
- 对象和数组可以互相嵌套，也可以使用for in遍历
- 如需遍历对象中的数组或数组中的对象，则可以直接在for in条件中写入需要遍历的对象或数组
- 示例：
//创建对象或数组
var obj={
name:'tom',
sex:'男',
friends:["jerry","john","jack"]
}
//在obj对象中的friends数组中添加元素
obj.friends[obj.friends.length] = "locy"
//遍历数组或对象内的指定数组或对象
for ( var objkey in obj.friends ){
console.log ( obj.friends [ objkey ] )
}
- 遍历数组中，做数组比较运算时，需定义变量存储最终返回的值，赋值也必须是该数组中存在的值
//求最大值
var array = [22,45,34,56,75];
//定义变量存储最大值，参与比较运算是一定要有初始值，初始值必须是数组中存在的值
//如果不给初始值，则是undefined参与比较运算，条件不会成立，没有初始值可以使用函数方法遍历
var max = array[0];
for(var k in array){
if(array[k]>max){
max+=array[k]
}
}
console.log(max)
数组API
API：JS ( 其他多数编程语言，这里特指JS ) 中预定义好的一些函数和方法
toString()
- 将数组元素转为字符串，默认按照逗号分隔，
- 方法为：数组名.toString();
- 语法：
//创建一个数组
var arr = [1,2,3,4,5]
//声明一个变量接收拼接转换后的元素
var arrSting = arr.toString(); //使用方法
console.log(arr,typeof arr);
- join()
- 将元数组元素按照指定的字符拼接起来转换为字符串，如果不加任何字符拼接，只需要 "" 即可
- 方法为：数组名.join("")
- 语法：
//创建一个数组
var arr = [1,2,3,4,5]
//声明一个变量接收拼接转换后的元素
var arrSting = arr.join(""); //使用方法
console.log(arr,typeof arr);
- concat()
- 拼接多个数组为一个数组
- 方法为：数组名1.concat(数组名2，数组名3，...), ( )内也可只写一个
- 语法：
//创建数组
var arr = [1,2,3,4,5]
var arr2 = [1,2,3,4,5]
var arr3 = [1,2,3,4,5]
//声明一个变量接收拼接后的元素
var arrSting = arr.concat(arr2,arr3); //使用方法
console.log(arr,typeof arr);
- slice()
- 截取数组指定范围内的元素，start这里代指开始下标，end代指结束的下标，截取范围不包括end结束的下标，如果是负数表示倒数，如果end为空，则表示截取到最后
- 数组索引，只能在API中使用负数索引
- 方法为：数组名.slice(strat,end)
- 语法：
//创建一个数组
var arr = [1,2,3,4,5]
//声明一个变量接收截取后的数组
var array = arr.slice(1,3); //使用方法,1,3表示数组元素开始和结束下标
console.log(array,typeof array);
- reverse()
- 翻转数组中的元素，也就是根据数组索引颠倒数组中元素的排序
- 方法为：数组名.reverse()
- 语法：
//创建一个数组
var arr = [1,2,3,4,5]
//声明一个变量接收翻转后的数组元素
var array = arr.reverse(); //使用方法
console.log(array,typeof array);
- sort()
- 对数组中的元素进行排序，可以是字符串，默认（）内没有任何值是按照Unicode码进行从小到大排序
- 如果对数字进行排序，则可以在（）内定义回调函数，sort()方法会自动传递实参进行排序
- 方法为：数组名.sort()
- 默认语法：
var str = ["一","das","哈哈"] //可以是字符串，数字等
console.log(str.sort()); //默认Unicode码排序
- 数字排序语法：
var num = [4,23,12,1,7,56]; //定义一个元素为数字的数组
//正序排列
num.sort(function (a,b){
retrun a-b; //如果a(实参)-b(实参) >0，则是正序
})
//倒序排列
num.sort(function (a,b){
retrun b-a; //如果b(实参)-a(实参) <0，则是倒序
})
- splice()
- 删除数组指定范围内的元素，删除的同时也可新增元素，新增的元素会插入在删除的元素位置上，索引位置可以给负数，表示倒数
- 方法为：数组名.splice(start,count,val1,va2...)
- start代指开始的元素索引位置，count代指删除几个元素，val代指新增插入的新元素
- 如果只填入一个数值，则表示从指定的元素索引位置，一直删除到最后
- 如果输入俩个数值，则表示从指定的元素索引位置，删除指定数量的元素
- 如果输入俩个以上数值，则从第三个数值开始就表示插入的新元素
- 如果从指定的元素索引位置，删除到最后并新增元素，count则可以用“数组名.length”表示
- 语法：
//定义一个数组
var arr = [4,23,12,1,7,56]
//一个数值
arr.splice(1,3) //从索引“1”开始，删除“3”个元素
//俩个数值
arr.splice(3) //从索引“3”开始，删除到最后
//俩个以上数值
arr.splice(1,3,45,123) //从索引“1”开始，删除“3”个元素，并在删除的位置上新增“45”、“123”俩个元素
//指定位置开始，删除到最后并新增
arr.splice(1,arr.length,34,56,76) //从索引“1”开始，删除到数组最后的元素，并在删除的位置上新增“35”、“56”、“76”三个元素
- push()
- 数组末尾增加一个或多个元素
- 方法为：数组名.push()
- 语法：
//定义一个数组
var arr = [4,23,12,1,7,56]
//数组末尾增加元素
arr.push(32,56,17)
- pop()
- 数组末尾删除最后一个元素，只能删除最后一个
- 方法为：数组名.pop()
- 语法：
//定义一个数组
var arr = [4,23,12,1,7,56]
//数组末尾删除元素
arr.pop()
- unshift()
- 数组头部增加一个或多个元素
- 方法为：数组名.unshift()
- 语法：
//定义一个数组
var arr = [4,23,12,1,7,56]
//数组头部增加元素
arr.unshift(32,56,17)
- shift()
- 数组头部删除第一个元素，只能删除第一个
- 方法为：数组名.shift()
- 语法：
//定义一个数组
var arr = [4,23,12,1,7,56]
//数组头部删除元素
arr.shift()
字符串
特点
- 字符串可以有0个或多个字符组成，会给每一位字符分配下标，是一种有序不可变的存储结构，用“”包含字符表示
- 可以和数组一样，使用[ ]访问指定索引下的字符，但是不能对字符串进行，增加、删除、修改操作，不会报错，但是操作无效
- 和其他类型一样，可以由字面量创建，也可以使用构造函数“new String”创建
- 字面量必须要加“”号，构造函数方式如果遇到纯数字，则不用加“”号，其它字符则需要
- 语法：
//字面量方式
var a = "hello";
//构造函数方式
var str = new String("hello")
//访问指定索引下的字符
console.log(str2[3])
转义字符
- \ 表示可以把编程中一些特殊含义的字符进行转义输出，在前面添加 " \"\" "
- \n 是换行符，对字符串的某个位置进行换行 "字符\n串"
- \t 是制表符，也就是tab键，对字符串头部位置进行tab缩进 "\t字符串"
- ......等
字符串API
- charAt()
- 获取指定下标的字符，省略下标表示获取第一个
- 方法：字符串名.charAt(下标)
- 语法：
//创建字符串
var str = "hello"
//获取指定下标的字符
console.log(str.charAt(3))
- charCodeAt()
- 获取指定下标的字符对应的Unicode编码，省略下标表示获取第一个
- 方法：字符串名.charCodeAt(下标)
- 语法：
//创建字符串
var str = "hello"
//获取指定下标的字符对应的Unicode编码
console.log(str.charCodeAt(3))
- toUpperCase()
- 把字符串中的小写转换为大写，但对原字符串不变，不能指定下标转换，转换的是字符串全部的小写字符
- 方法：字符串名.toUpperCase()
- 语法：
//创建字符串
var str = "hello"
//转换小写字母为大写
console.log(str.toUpperCase())
- toLowerCase()
- 把字符串中的大写转换为小写，但对原字符串不变，不能指定下标转换，转换的是字符串全部的大写字符
- 方法：字符串名.toLowerCase()
- 语法：
//创建字符串
var str = "hello"
//转换小写字母为小写
console.log(str.toLowerCase())
- indexOf()
- 查找字符对应的下标位置，str代指需要查找下标的字符，start代从指定下标位置开始查找，可以只写一个，代表查找的字符，默认从第一个开始，如果字符写入俩个，则只会查找第一个字符对应的下标，如果找不到，则会返回-1
- 方法：字符串名.indexOf(str,start)
- 语法：
//创建字符串
var str = "hello"
//从下标0开始查找字符 "el"，找到"e"对应的下标就结束，不会找"l"
console.log(str.indexOf("el"))
- lastIndexOf()
- 查找字符最后一次出现的下标位置，str代指需要查找下标的字符，如果字符写入俩个，则只会查找第一个字符，如果找不到，则会返回-1
- 方法：字符串名.lastIndexOf(str)
- 语法：
//创建字符串
var str = "hello"
//找到"e"对应的最后一次出现的下标位置就结束，不会找"l"
console.log(str.lastIndexOf("el"))
- slice()
- 截取字符串中的字符，根据索引截取字符串中指定范围内的字符
- start这里代指开始下标，end代指结束的下标，截取范围不包括end结束的下标，如果下标是负数表示倒数，如果end为空，则表示截取到最后，只能在API中使用负数索引，如果start索引大于end索引，则无法截取
- 方法：字符串名.slice(start,end)
- 语法：
//创建字符串
var str = "hello"
//截取开始索引 '1' 开始到结束索引 '3' 包含的字符，但不包含结束索引
console.log(str.slice(1,3));
- substr()
- 截取字符串中的字符，根据长度截取字符串中指定范围内的字符
- start这里代指开始下标，count代指截取的长度，如果下标是负数表示倒数，如果count为空，则表示截取到最后，只能在API中使用负数索引
- 方法：字符串名.substr(start,count)
- 语法：
//创建字符串
var str = "hello"
//从索引‘1’开始截取3个字符
console.log(str.substr(1,3))
- substring()
- 截取字符串中的字符，根据索引截取字符串中指定范围内的字符
- start这里代指开始下标，end代指结束的下标，截取范围不包括end结束的下标，如果end为空，则表示截取到最后，如果start索引大于end索引，俩者位置则会自动交换，无法使用负数，会自动转为0(空字符串)，无法截取
- 方法：字符串名.substring(start,end)
- 语法：
//创建字符串
var str = "hello"
//自动调换开始与结束索引位置，然后截取第二位到第三位的字符，不包含结束索引
console.log(str.substring(4,2))
- split()
- 将字符串按照指定的字符切割为数组，此处sep代指指定的字符，必须是字符串中存在的字符，如果字符存在开头或结尾，数组中会存储空字符串，如果分割的字符不存在，则会把整个字符串转换为一整个数组元素
- 方法：字符串名.split(sep)
- 语法：
//创建字符串
var str = "123455@qq.com"
//将字符串根据字符串中的"@"切割转换为数组
console.log(str.split("@")) //输出数组元素为123455和qq.com俩个元素，不包含@字符
支持匹配模式的字符串API
用于查找、替换字符串，一般配合正则进行模式匹配
正则语法规则是在 /规则语法/ ig 填入，后面的ig代表，不区分大小写进行全局查找，i代表不区分大小写，g代表全局查找，俩个都可以单独写
search()
- 查找字符串中满足条件中的第一个字符，并返回所在的下标，找不到返回-1
- 方法：字符串名.search(/查找的字符/i)
- 语法：
//创建字符串
var str = "heEllo"
//查找符合 "e" 的字符，不区分大小写，并返回所在下标
console.log(str.search(/e/i))
- match()
- 查找字符串中满足条件中的所有字符，转换成数组并返回，找不到返回null
- 方法：字符串名.match(/查找的字符/ig)
- 语法：
//创建字符串
var str = "china+China+CHINA+chinA"
//查找符合 "china" 的字符，全局查找，不区分大小写，转换成数组并返回
console.log(str.match(/china/ig))
- replace()
- 查找字符串中满足条件中的所有字符，替换成指定字符后转换成数组并返回
- 方法：字符串名.replace(/查找的字符/ig,"替换的字符")
- 语法：
//创建字符串
var str = "china+China+CHINA+chinA"
//查找符合 "china" 的字符，全局查找，不区分大小写，替换成“中国”后转换成数组并返回
console.log(str.replace(/china/ig,"中国"))
Math对象API
- Math对象不需要创建，可以直接使用
圆周率
- Math.PI可以直接输出圆周率
console.log(Math.PI)
取整
- Math.ceil
- 向上取整，表示不管小数位是多少，整数位都+1
console.log(Math.ceil(3.23123));
//输出为4
- Math.floor
- 向下取整，表示舍弃小数位，只保留整数位
console.log(Math.ceil(3.23123));
//输出为3
- Math.round
- 四舍五入取整，逢小数点第一位是5便+1
console.log(Math.round(3.23123));
//输出为3
取大小值
取一组数字的最大最小值
Math.max(n1,n2,n3,...)
- 取最大值
console.log(Math.max(1, 3, 4, 545, 43, 23));
- Math.min(n1,n2,n3,...)
- 取最小值
console.log(Math.max(1, 3, 4, 545, 43, 23));
取绝对值
- 返回绝对值，X必须是数值或者数学运算
console.log(Math.abs(1)); //1
console.log(Math.abs(-1)); //1
console.log(Math.abs(6 / 2)); //3
console.log(Math.abs(null)); //0
console.log(Math.abs("hello")); //NaN
Math.random()
- 取随机数，不需要使用new来创建，可以直接使用
- 随机生成小数
- Math.random默认就是生成0~1之间的小数
console.log(Math.random());
- 随机生成整数
- 使用Math.random方法配合Math.floor随机生成整数
- Math.random*字符或数组名.length，可以根据当前字符或数组的长度随机生成随机整数
- 语法示例：
//定义一个字符串
var str = "hello"
//根据str的字符长度生成随机数，并用Math.floor取整
console.log(Math.floor(Math.random() * str.length));
- 随机验证码练习
//生成验证码函数
function create(n) { //create(验证码长度)形参
//验证码数据源
var str = "asdasdfsdfjdlgjdfigjkf12345n345647566";
//循环次数
for (var i = 0,code = "";i<n;i++){
//根据str长度随机获取索引，再通过Math.floor转换为整数
var num = Math.floor(Math.random() * str.length);
//把每次随机索引所对应的字符取出赋值给code
code+=str[num];
}
//返回给外界使用
return code;
}
//获取验证么并验证
function ver(){
//获取固定长度的随机生成的验证码
var codenum = create(4); //4为create(验证码长度)实参
//提示用户输入并验证
var res = prompt("输入验证码："+codenum);
//判读输入是否非空，非空则进入内层判断
if (res) {
//把随机生成的验证码和输入的验证码全等比较判断
if(res.toUpperCase()==code.toUpperCase()){//值全等后，提示正确
alert("Yes")
} else {
//值不全等后，提示错误
alert("No")
//重新执行函数再次输入验证码
ver();
}
}else {
//输入为空值后提示错误
alert("未输入")
//并重新执行函数再次输入验证码
ver();
}
}
//调用函数
ver();
Math.pow(次方)
- 次方计算，计算X的Y次幂
- 语法：Math.pow(x,y)
console.log(Math.pow(5, 4));
Data对象
- 只能使用构造函数创建Date对象
Date创建方法
- 获取系统日期时间
- 直接使用构造函数关键字Date创建，并不加任何值，代表获取当前系统日期及时间
- 从左到右依次为星期、月份、日期、年份、时、分、秒、时区
var date1 = new Date();
console.log(date1);
- 传递参数，指定创建日期对象
- 指定日期字符串创建对象，年月日必填，时分秒选填
var date2 = new Date("2022-2-21");
var date3 = new Date("2022-2-21 21:00:32")
console.log(date2);
console.log(date3);
- 分别传入年月日时分秒
- 从左到右分别取值为年、月、日、时、分、秒
- 月份取值范围是011对应现实中的112
var date4 = new Date(2021,3,29,22,35,48)
console.log(date4);
- 使用时间戳创建日期对象
- 时间戳是指距离计算机元年的毫秒数
- 计算机元年为：1970-1-1 00:00:00，中国时区为8:00:00
var date5 = new Date(1000);
console.log(date5)
Date对象的API
- 获取年月日
- 获取年份
console.log(date2.getFullYear());
- 获取月份，实际使用中需要手动+1再显示
console.log(date2.getMonth());
- 获取日
console.log(date2.getDate());
- 获取时分秒、毫秒
- 获取时
console.log(date2.getHours());
- 获取分
console.log(date2.getMinutes());
- 获取秒
console.log(date2.getSeconds());
- 获取毫秒
console.log(date2.getMilliseconds());
- 获取星期
- 获取星期的范围是0~6，0代表星期日
- 西方国家以每周的星期日为每个星期的第一天
console.log(date2.getDay());
- 获取时间戳
console.log(date2.getTime());
- 转换本地字符串格式
- 转换年月日时分秒
console.log(date2.toLocaleString());
- 单独转换年月日
console.log(date2.toLocaleDateString());
- 单独转换时分秒
console.log(date2.toLocaleTimeString());
- 设置日期对象的年月日时分秒
- 设置中，如果值超出设置范围，系统会自动推算
- 月份范围0~11
- 日期范围按现实中的日期范围设置
- 时范围0~23，设置24时会自动归0
- 分、秒范围是0~59，设置60自动进1
- 设置年，也可同时设置月份和日期
console.log(date2.setFullYear(2022));
console.log(date2.setFullYear(2022,3,21));
- 设置月
- 取值范围是011对应现实中的112
date2.setMonth(5)
console.log(date2);
- 设置日
date2.setDate(31)
console.log(date2);
- 设置时
date2.setHours(21)
console.log(date2);
- 设置分
date2.setMinutes(47)
console.log(date2);
- 设置秒
date2.setSeconds(58)
console.log(date2);
- 设置毫秒
date2.setMilliseconds(3)
console.log(date2);
- 使用时间戳修改日期对象
date2.setTime(3000)
console.log(date2);
Number对象
- 数值类型也可使用构造函数关键字创建
- 加new关键字创建的数值，会自动转为数值，类型为对象类型
- 不加new关键字创建的对象，会自动转为数值，类型式数值类型
var n1 = new Number(true);
console.log(n1,typeof n1) //数字1 object类型
var n2 = Number(true)
console.log(n2,typeof n2) //数字1 number类型
- 如创建数值类型时，填入布尔值或纯数字的字符串，会自动隐式转换
var num = Number(true);
var num2 = Number("1");
console.log(num+num2);
数值API
- toString()
- 数字转换字符串，转换进制
- 可转换为字符串，也可单独转换为指定进制数
- base代指进制，如base值不填写，则默认转换为字符串
- 语法：数值名.toString(base)
var num3 = 12;
console.log(num3.toString()); //转换字符串
console.log(num3.toString(2)); //转换进制
- toFixed()
- 保留小数点后面的位数
- 可保留小数点后面具体多少位，一般常用2位
- n代指位数
- 语法：数值名.toFixed(n)
var num3 = 12.323213;
console.log(num3.toFixed(2));
- 更多API
Boolean对象
- 也可使用构造函数创建
- 空对象和空数组也会自动转换为true
- 构造函数无法将部分非布尔类型隐式转换，可使用 !! 将非布尔类型转换为布尔类型，如：!!undefined，!!null，!!NaN
- 加new关键字创建的，会自动转为布尔值，返回是对象类型
- 不加new关键字创建的，会自动转为布尔值，返回时布尔类型
var bo1 = new Boolean(3);
console.log(bo1,typeof bo1); //转为true，为object类型
var bo2 =Boolean(5);
console.log(bo2,typeof bo2); //转为true，为boolean类型
var bo3 = Boolean({}) //空对象
console.log(bo3,typeof bo3); //转为true，为boolean类型
var bo4 = Boolean([]) //空数组
console.log(bo4,typeof bo4); //转为true，为boolean类型
布尔API
- toString()
- 布尔转字符串
var b6 = Boolean(true)
var str = b6.String();
console.log(str,typeof str)
- 更多......