[JavaScript知识库]第五章 基本引用类型（没什么重点，要用的时候翻一翻）

一、Date

• parse(参数字符串)：参数为表示日期的字符串参数，如果参数无效，返回NaN。此方法是将字符串转换为表示该日期的毫秒数。

let date = new Date("May,23,2019")
//内部调用了parse方法,等于以下这行代码
//let date = new Date(Date.parse("May,23,2019"))
console.log(date) //2019-05-22T16:00:00.000Z

• UTC()：参数至少传年月，可传年月日时分秒。月份从0开始算1月(和parse的区别)

let date = new Date(Date.UTC(2000,0)) //2000-01-01T00:00:00.000Z
console.log(date)
let date1 = new Date(Date.UTC(2000,1,1,13,30,20))
console.log(date1) //2000-02-01T13:30:20.000Z

继承方法
toLocaleString()：返回与浏览器运行的本地环境一致的时间
toString()：返回带时区信息的日期和时间

let date = new Date();
console.log(date.toLocaleString()); //2021/10/21 下午6:35:00
let date1 = new Date();
console.log(date1.toString()); //Thu Oct 21 2021 18:35:00 GMT+0800 (中国标准时间)

二、RegExp 实例方法

1. **exec():配合捕获数组使用。**这个方法只接收一个参数，即要应用的模板字符串。如果找到匹配项，返回包含第一个匹配信息的数组，否则返回null。返回数组包含额外两个属性：index和input。index是字符串匹配模式的起始位置，input是要查找的字符串。这个数组的第一个元素是匹配整个模式的字符串，其他元素是与表达式中的捕获组匹配的字符串。如果模式中没有捕获组，则数组中只包含一个元素。

let text = "mom and dad and baby";
let pattern = /mom( and dad( and baby)?)?/gi;
//gi是全局标志
let matches = pattern.exec(text);
console.log(matches.index);   // 0
console.log(matches.input);   // "mom and dad and baby"
console.log(matches[0]);      // "mom and dad and baby"
console.log(matches[1]);      // " and dad and baby"
console.log(matches[2]);      // " and baby"

如果模式设置了全局标记，则每次调用exec()方法会返回一个匹配的信息。如果没有设置全局标记，则无论对同一个字符串调用多少次exec()，也只会返回同一个匹配信息。

let text = "cat, bat, sat, fat";
let pattern = /.at/;  //不设置gi全局
let matches = pattern.exec(text);
console.log(matches.index);      // 0
console.log(matches[0]);         // cat
console.log(pattern.lastIndex);  // 0
matches = pattern.exec(text);
console.log(matches.index);      // 0
console.log(matches[0]);         // cat
console.log(pattern.lastIndex);  // 0
//lastIndex在非全局模式下始终不变

如果这个模式设置g标识，每次调用exec()都会在字符串中向前搜索下一个匹配项。

let text = "cat, bat, sat, fat";
let pattern = /.at/g;
let matches = pattern.exec(text);
console.log(matches.index);      // 0
console.log(matches[0]);         // cat
console.log(pattern.lastIndex);  // 3

matches = pattern.exec(text);
console.log(matches.index);      // 5
console.log(matches[0]);         // bat
console.log(pattern.lastIndex);  // 8

matches = pattern.exec(text);
console.log(matches.index);      // 10
console.log(matches[0]);         // sat
console.log(pattern.lastIndex);  // 13
//在全局匹配模式下，每次调用exec()都会更新lastIndex的值，
//来反映上次匹配的最后一个字符的索引

2. test():接收字符串参数。如果输入文本与模式匹配，返回true，否则为false。常用于if语句中。常用于验证用户输入。

let text = "000-00-0000";
let pattern = /\d{3}-\d{2}-\d{4}/
if(pattern.test(text)){
    console.log("the pattern was matched")//the pattern was matched
}

无论正则表达式是怎么创建的，继承的方法toLocaleString()和toString()都返回正则表达式的字面量表示。比如：

let pattern = new RegExp("\\[bc\\]at", "gi");
console.log(pattern.toString());       // /\[bc\]at/gi
console.log(pattern.toLocaleString()); // /\[bc\]at/gi

valueOf()方法返回正则表达式本身。

三、原始值包装类型
为方便操作原始值，ECMA提供三种引用类型：Boolean、Number、String。当用到某个原始值属性和方法时，后台都会创建一个相应的原始包装类型对象，从而暴露出操作原始值的各种方法。

let s1 = "some text"; //相当于下面这句
//在已读模式访问字符串的任何时候，会执行三步操作：
//1: let s1 = new String("some text");  创建String实例
//2:调用实例上特定方法
let s2 = s1.substring(2);  //以读模式访问s1,从内存中读取变量保存的值
console.log(s2); //me text
//3:  s1 = null;  销毁实例

本来原始值不是对象，因此逻辑上不该有方法，但是确实是运行出来，说明后台做了处理。三步处理，创建实例，调用方法，销毁实例。
引用类型与原始类型包装类型主要区别在于对象的生命周期。在new实例化引用类型后，得到的实例会在离开作用域时被销毁，而自动创建的原始值包装对象只存在于访问它的那行代码执行期间。这意味着不能在运行时给原始值添加属性和方法。比如：

let s1 = "some text";
s1.color = "red";//代码运行时临时创建String对象,但很快这个对象就被销毁了。
console.log(s1.color);//这里又创建了自己的对象，但是这个对象无color属性，显示undefined

Object构造函数能够根据传入值的类型返回相应原始值包装类型实例。

//给Object传字符串，就会创建String实例。其它同理。
let obj = new Object("new text");
console.log(obj instanceof String);//true

注意：调用同名转型函数和调用原始值构造函数不一样。

let value = '25';
let number = Number(value); //调用同名转型函数,保存的是原始值
console.log(typeof number); //number
let number1 = new Object(value); //使用new调用原始值构造函数，保存的是一个实例
console.log(typeof number1); //Object

1.Boolean

let falseObject = new Boolean(false);
let result = falseObject && true; //对falseObject对象而不是对其表示的值(false)求值。
console.log(result); //true,所有对象在布尔表达式中都会自动转换成true，所以是true。
let falseValue = false;
result = falseValue && true;
console.log(result); //false

建议永远不要使用Boolean对象。

2.Number

let num = 10;
console.log(num.toString(2)) //1010
console.log(num.toString(16)) //a 
console.log(num.toFixed(2)) //10.00

toFixed(): 接收参数返回指定小数点位数的数值字符串。
toExponential():格式化数值，返回科学计数法的数值字符串。
toPrecision():接收参数表示这个数值的长度。根据情况返回最合理的输出结果，可能是固定长度，也可能是科学计数法。这个会根据数值和精度调用上面的两种方法。

Number.isInteger():判断数值是否保存为整数
只要这个数是整数就返回true，否则返沪false

console.log(Number.isInteger(10.00))//true
console.log(Number.isInteger(10.01))//false

3.String

每个String()对象都有length属性，表示字符串长度。
charAt()：返回给定索引值的字符。
charCodeAt():查看指定码元的字符编码。
codePointAt():和charCodeAt()功能一样，但是这个解析更准确。上面那个遇到表情符号就无法解析出来。

let message = "abcde";
console.log(message.charAt(2));//c
console.log(message.charCodeAt(2))//99

字符串操作方法：
?拼接：concat()
?分割提取:slice(),substring(),substr()

//concat()方法用于拼接字符串
let stringValue = "hello ";
let result = stringValue.concat("world");
console.log(result); //hello world
console.log(stringValue)//hello
//提取字符串方法:slice(),substr(),substring()
//slice(字符串开始位置,字符串提取位置) subString接收参数和slice一样
console.log(stringValue.slice(1)) //ello
console.log(stringValue.slice(1,3))//el
console.log(stringValue.substring(1)) //ello
console.log(stringValue.substring(1,3)) //el
//slice()接收负数参数会变成倒数第几个
console.log(result.slice(-3)); //o
console.log(result.slice(3,-4));//lo w
//substring()接收参数变负数时自动转换为0
console.log(result.substring(-3)) //hello world
console.log(result.substring(3,-4)) //hel   -4自动转换为0，这个方法会以最小点为起始点。
//substr(字符串开始位置,提取个数)
console.log(stringValue.substr(1))//ello
console.log(stringValue.substr(1,2))//el
//substr()接收参数为负数时
console.log(result.substr(-4))//orld 返沪最后四个字符
console.log(result.substr(3,-2)) //空字符,第二个参数被转换成0

字符串位置方法：indexOf(),lastIndexOf()
前者从头开始找，后者从尾开始找，找到返回所在下标，没找到返回-1。
第一个参数接收查找字符，第二个参数表示开始搜索的位置。

let str = "hello world"
console.log(str.indexOf("o")); //4
console.log(str.indexOf("o",6));//7
console.log(str.lastIndexOf("o")); //7
console.log(str.lastIndexOf("o",6));//4

查找指定字符的所有位置：

let str = "hello world";
let arr = new Array();
let pos = str.indexOf("o");
while(pos>-1){
    arr.push(pos);
    pos = str.indexOf("o",pos+1);
}
console.log(arr) //[4,7]

字符串包含方法：startsWith(),endsWith(),includes()
搜素传入字符串，返回表示是否包含的布尔值。startsWith()检查开始于0的匹配项，endsWith()检查开始于索引(string.length - substring.length)的匹配项，而includes()检查整个字符串。startWith()和includes()接收第二个参数表示开始搜索的位置。endsWith()接收第二个参数表示应当作字符串末尾的位置。

let arr = "foobarbaz";
console.log(arr.startsWith("foo")) //true
console.log(arr.startsWith("baz")) //false
console.log(arr.endsWith("foo")) //false
console.log(arr.endsWith("baz")) //true
console.log(arr.includes("bar")) //true

删除空格符：
trim():创建字符串副本，删除前后所有空格符，再返回结果。
trimLeft():字符串开始删除空格符。
trimRight():字符串末尾删除空格符。

let char = " hello world "
let charChange = char.trim();
console.log(char)//[空格]hello world[空格]
console.log(charChange) //hello world
console.log(char.trimLeft()) //hello world[空格]
console.log(char.trimRight())//[空格]hello world

repeat():接收一个整数参数，字符串复制多少次，然后返回拼接所有副本后的结果。

let char = 'na';
console.log("ba" + char.repeat(2)) //banana

填充字符串：padStart(),padEnd()

let char = "foo";
//传入一个参数,剩余部分空格填充
//传入两个参数,前者为字符串长度，后者为填充物
//padStart():开头填充
console.log(char.padStart(9)) //"      foo"
console.log(char.padStart(9,"123")) //"123123foo"
//padEnd():结尾填充
console.log(char.padEnd(9))  //"foo      "
console.log(char.padEnd(9,"123"))  //"foo123123"

字符串迭代与解构:@@iterator,迭代字符串的每个字符

let str = "ab";
let strIter = str[Symbol.iterator]();
console.log(strIter.next()); //{ value: 'a', done: false }
console.log(strIter.next()); //{ value: 'b', done: false }
console.log(strIter.next()); //{ value: undefined, done: true }

let str = "abcde";
console.log(...str) //a b c d e
//解构，分割成数组
console.log([...str]) //[ 'a', 'b', 'c', 'd', 'e' ]

字符串大小写转换:小写toLowerCase(),大写toUpperCase()

字符串匹配方法：match()，search()
RegExp对象的exec()方法相同。match()接收一个参数为正则表达式字符串或者RegExp对象。

比较字符串：LocaleCompare()
字符串参数排前面返回负值，字符串参数排后面返回正值，相等返回0。

let str = "yellow";
console.log(str.localeCompare("brick")); //1
console.log(str.localeCompare("yellow")); //0 
console.log(str.localeCompare("zoo")); //-1

四、单例内置对象：Object(),Array(),String(),Global(),Math()

• Global
  全局作用域中定义的变量和函数都会变成Global对象的属性和方法。

• eval()：ECMAScript解释器，接收参数为一个要执行的js字符串。

eval("console.log(123)") //123
//与console.log(123)等价

通过eval()执行的代码属于调用所在上下文，被执行的代码与上下文拥有相同的作用域链。说明包含在上下文的变量可以在eval()调用内部被引用。

let msg = 123;
eval("console.log(msg)") //123

eval()内部定义函数或者变量，也可以在外部被调用。调用时会被替换成一行真正的代码。

eval("function a(){console.log(123)}")
a(); //123

通过eval()定义的任何变量和函数都不会提升，因为在解析代码时，它们是被包含在同一个字符串中。它们只是在eval()执行时才会被创建。

• global对象属性:
  undefined,NaN,Infinity,Object,Array,Symbol,Function,Boolean,String,Number,Date,RegExp,Symbol,Error,EvalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError。

• window对象：Global对象代理，所以全局作用域中声明的变量和函数都成为了window对象的属性。

另一个获取Global对象的方式是使用如下代码：

let global = function(){
    return this;
}();

这是创建了一个立即调用的函数表达式，返回this的值。当一个函数没有明确(通过成为某种对象的方法或者使用call()/apply() )指定this值的情况下，this值等于Global对象。因此，调用一个简单返回this的函数是在执行任何上下文中获取Global对象的通用方式。

2. Math对象
   Math.方法
   min():接收多个参数返回最小值
   max():接收多个参数返回最大值
   舍入方法：ceil() 向上舍入,floor()向下舍入,round()四舍五入,fround()返回数值最接近的单精度浮点值。
   random():返回 0 ~ 1 中的随机数，含0不含1。