JS基础 易忘点

一、自增自减符号

1. 从左到右依次运算
2. ++(--)在后，返回表达式之前的值；++(--)在前，返回表达式之后的值
3. 例：let x = 1; y = x + x++ + ++x应计算为 y = 1 + 1 + 3
4. 例：let x = 1; y = x + x++ * (x = x + x++ * ++x) + x应计算为 y = 1 + 1 * ( x = 2 + 2 * 4 ) + 10

二、比较运算符

1、大小比较（>, <, >=, <=）

1. 两个数字类型直接比较
2. 两个字符串类型比较，比较字符串的ASCII码
3. 只要有一个不是字符串类型，都先转化为数字类型再进行比较
4. NaN与任意类型比较，得到结果false
5. Infinity比任何数字都大，-Infinity比任何数字都小
6. 如果有对象类型，将对象类型转换为原始类型（字符串类型[object Object]）后再进行比较，

2、相等比较（==, !=）

1. 两边类型相同，直接比较（两个对象比较地址）
2. 两边类型不同：
   1). null == undefined // true 其他原始类型 == null || undefined // false
   2). 其他原始类型，先转化为数字类型再进行比较
   3). NaN == 任意数字 || NaN // false
   4). ±Infinity只与自身相等
   5). 对象比较，先转换为原始类型（字符串类型[object Object]）后，再进行比较

3、全等比较（===, !==）

1. 两边类型相同，规则和相等比较一致
2. 两边类型不同，为false
3. NaN === 任意数字 || NaN // false
4. ±Infinity只与自身相等

三、数组

1. const arr = [1, 2, 3]; arr[10] = 'abc'; // arr.length = 11
2. const arr = [1, 2, 3]; arr.length = 5; // arr = [1, 2 ,3 ,empty, empty]

四、Object

1. Object.toString(); 默认得到'[object Object]'
2. Object.valueOf(); 默认得到该对象本身
3. 如果对象自动进行类型转换时，实际上先调用valueOf()，再调用toString();
   例：

const obj = {
  x: 13,
  y: 34534,
  valueOf() {
    return 123;
    }
  }
const obj1 = {
  x: 13,
  y: 34534,
  toString() {
    return 'hello';
  }
}
console.log(obj + 1) // 124  如果调用了valueOf已经得到了原始类型，则不再调用toString
console.log(obj.valueOf().toString() + 1) // '1231'
console.log(obj1 + 1) // 'hello1'
console.log(obj1.valueOf().toString() + 1) // 'hello1'

五、Function

1. apply、call方法：后面的参数是前面具体方法的参数
2. bind方法：使用方法类似于call，但是是得到一个新函数（需要手动调用）

六、Number

1. Number.parseInt(string[, radix])
   从字符串开始位置进行查找，找到第一个有效的数字进行转换，如果没有找到，则返回NaN，左右空白字符会忽略
   例：parseInt(103, 2) // 2，因为3不是有效数字，2进制的有效数字只有0,1

七、String

1. String.fromCharCode(num1[, …[, numN]])
   通过unicode编码创建字符串
   例：String.fromCharCode(65, 66,...) // AB...，可以使用此函数遍历26个字母
2. slice: 从某个位置取到某个位置；位置可以是负数；
   substr: 从某个位置开始取，取指定的长度；位置可以是负数；
   substring: 从某个位置取到某个位置；不可以是负数；参数位置是可调换的。

八、Date

1. 使用new Date()创建对象，
   没有参数：表示当前时间
   一个参数：表示传入时间戳
   两个以上参数：分别表示年、月、日、时、分、秒、毫秒并且可以传递负数，会向前计算
2. 实例方法：
   1）getDate()：得到日期部分
   2）getDay()：得到星期几
   3）getFullYear()：得到年
   4）getMonth()：得到月（0-11）
   5）getHours()：得到时
   6）getMinutes()：得到分
   7）getSeconds()：得到秒
   8）getMilliseconds()：得到毫秒
   9）getTime()：得到时间戳
   对应setxxx方法
   10）toDateString()：将日期部分转换为可读的字符串。Mon Aug 09 2021
   11）toISOString()：将整个对象转换为ISO标准的字符串格式。2021-08-09T13:42:27.441Z
   12）toLocaleDateString()：根据当前系统的地区设置，将日期部分转换为可读的字符串2021/8/9
   13）toLocaleString()：根据当前系统的地区设置，将整个日期对象转换为可读的字符串2021/8/9 下午9:42:27
   14）toLocaleTimeString()：根据当前系统的地区设置，将时间部分转换为可读的字符串下午9:42:27

九、正则

1. 特殊字符：
   '.'：匹配任意字符串
   '^'：匹配字符串开始
   '$'：匹配字符串结尾
   '\'：转义符
   '|'：或者
2. 转义符：
   \n：换行符
   \r：回车符
   \t：制表符
   \s：空白符[\f \n \r \t \v]
\S：非空白符
   \b：边界符
   \B：非边界符
   \d：数字符
   \D：非数字符
   \w：字母符[A-Za-z0-9_]
\W：非字母符
   \u：匹配码点
3. 量词：
   *：匹配0次或多次
+：匹配1次或多次
?：匹配0次或1次
{n}：匹配n个
{n,}：匹配>=n个
{n,m}：匹配n-m个
4. 标志：
   g：全局匹配
   m：多行匹配
   i：忽略大小写匹配
5. 实例成员：
   source：得到规则字符串
   test()：测试字符串是否满足规则（会受到全局匹配影响，根据lastIndex影响）
   exec()：执行搜索匹配，返回一个结果数组或 null。

const reg = /\d/g;
const str = '15830ad';
console.log(reg.exec(str)) // ["1", index: 0, input: "15830ad", groups: undefined]

6. 捕获组：
   1）用小括号包裹的部分叫做捕获组，捕获组会出现在匹配结果中
   2）可以给捕获组命名?<name>，会将具名捕获组存入匹配结果的groups中
   3）非捕获组 ?:

var s = "2015-5-1, 2019-6-19, 2000-04-28";
//得到每一个日期，并得到每个日期的年月日
var reg = /(?<year>\d{4})-(?:\d{1,2})-(\d{1,2})/g;
while (result = reg.exec(s)) {
  console.log(result); // ["2000-04-28", "28", index: 21, input: "2015-5-1, 2019-6-19, 2000-04-28", groups: undefined]
}

var reg = /(\d{4})-(\d{1,2})-(\d{1,2})/g;
s = s.replace(reg, "$1/$2/$3")
console.log(s); // 2015/5/1
}

7. 反向引用：const reg = /(捕获组)\捕获组编号/

var s = "aaaaaaaabbbbbbbbbccccccdefgggggggg";
//找出该字符串中连续的字符
var reg = /(?<char>\w)\k<char>+/g;
while (result = reg.exec(s)) {
  console.log(result[1]); // a // b // c // g
}

8. 正向断言（正向预查）?=：检查某个字符后面的字符是否满足某个规则，该规则不成为匹配结果，并且不称为捕获组

var s = "sdfsdf3434343sdfsa545454dfsdfsfsd6754";
var reg = /[a-zA-Z](?=\d+)/g;
while (result = reg.exec(s)) {
  console.log(result); // ["f", index: 5, input: "sdfsdf3434343sdfsa545454dfsdfsfsd6754", groups: undefined]
}

var s = "334353456";
// var result = "43,534,512,312";
var reg = /\B(?=(\d{3})+$)/g;
s = s.replace(reg, ",");
console.log(s);

// 判断密码强度
// 要求密码中必须出现小写字母、大写字母、数字、特殊字符(!@#_,.)，6-12位
var s = "asdfsdAf234."
var reg = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#_,.]).{6,12}$/;

// 判断密码强度
// 密码长度必须是6-12位
// 出现小写字母、大写字母、数字、特殊字符(!@#_,.)  -> 强
// 出现小写字母、大写字母、数字  -> 中
// 出现小写字母、大写字母  -> 轻
// 其他  -> 不满足要求
function judgePwd(pwd) {
  if (/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#_,.]).{6,12}$/.test(pwd)) {
    return "强";
  } else if (/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{6,12}$/.test(pwd)) {
    return "中";
  } else if (/^(?=.*[a-z])(?=.*[A-Z]).{6,12}$/.test(pwd)) {
    return "轻";
  } else {
    return "不满足要求";
  }
}

9. 负向断言（负向预查）?!：检查某个字符后面的字符是否不满足某个规则，该规则不成为匹配结果，并且不称为捕获组

var s = "afg43223444wr423424243";
var reg = /[a-zA-Z](?!\d+)/g;
while (result = reg.exec(s)) {
  console.log(result);
}

正则表达式，默认情况下，使用贪婪模式（尽可能多的匹配）；
在量词后，加上?，表示进入非贪婪模式（尽可能少的匹配）