5基本引用类型

基本引用类型

---

1. Date 日期保存为自协调世界时（UTC）时间1970年1月1日零时至今所经过的毫秒数。

   1. Date.parse()方法接收一个表示日期的字符串参数，尝试将该字符串转化为表示该日期的毫秒数，所有实现必须支持下列格式

      1. 月/日/年 如“5/23/2019”
      2. 月名 日，年 如“May 23,2019”
      3. 周几 月名 日 年 时：分：秒 时区 如“Tue May 23 2019 00:00:00 GMT-0700”
      4. YYYY-MM-DDTHH:mm:ss:sssZ 如“2019-05-23T00：00：00”

      若传给该方法的字符串不表示日期，则返回NaN

      let someDate = new Date(Date.parse("May 23,2019"))
      // 以上代码与下方代码等价，会在后台调用Date.parse
      let someDate = new Date("May 23,2019")
      

   2. Date.UTC()接收的参数是年、零起点月数（1 月是 0，2 月是 1，以此类推）、日（1_{31）、时（0}23）、分、秒和毫秒。这些参数中，只有前两个（年和月）是必需的。如果不提供日，那么默认为 1 日。其他参数的默认值都是 0

      // GMT 时间 2000 年 1 月 1 日零点
      let y2k = new Date(Date.UTC(2000, 0)); 
      // GMT 时间 2005 年 5 月 5 日下午 5 点 55 分 55 秒
      let allFives = new Date(Date.UTC(2005, 4, 5, 17, 55, 55));
      

      以上代码创建的日期是由系统设置决定的本地时区的日期。

   3. Date.now()方法返回表示方法执行时日期和时间的毫秒数。

      // 起始时间
      let start = Date.now()
      // 调用函数
      doSomething()
      // 结束时间
      let stop = Date.now()
      result = stop - start
      

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

      let now = new Date()
      console.log(now)//Thu Dec 23 2021 16:14:39 GMT+0800 (中国标准时间)
      console.log(now.toString())//Thu Dec 23 2021 16:14:39 GMT+0800 (中国标准时间)
      console.log(now.toLocaleString())//2021/12/23 下午4:14:39
      

   5. valueOf()方法返回日期的毫秒显示，因此操作符可以直接使用其返回的值进行计算等

2. RegExp 正则表达式，其模式可以是任何简单或复杂的正则表达式，包括字符类、限定符、分组、向前查找以及反向引用。每个正则表达式可以带零个或多个flags，即标记，用于控制正则表达式的行为

   1. g：全局模式，查找字符串的全部内容
   2. i：不区分大小写，忽略pattern以及字符串的大小写
   3. m：多行模式
   4. y：粘附模式，只查找从lastIndex开始及之后的字符串
   5. u：Unicode模式
   6. s：dotAll模式，表示元字符，匹配任何字符（包括\n或\r）

   // 匹配字符串中所有“at”
   let pattern1 = /at/g
   // 匹配第一个“bat”或“cat”，忽略大小写
   let pattern2 = /[bc]at/i
   // 匹配所有以“at”结尾的三字符组合，忽略大小写
   let pattern3 = /.at/gi
   

   所有的元字符在模式中也必须转义，包括( [ { \ ^ $ | ) ] } ? * + .

   let pattern1 = /[bc]at/i; 
   // 匹配第一个"[bc]at"，忽略大小写
   let pattern2 = /\[bc\]at/i; 
   // 匹配所有以"at"结尾的三字符组合，忽略大小写
   let pattern3 = /.at/gi; 
   // 匹配所有".at"，忽略大小写
   let pattern4 = /\.at/gi;
   

   其中 . 表示前面的任意字符都可以匹配，[]表示其中的一项。正则表达式可以使用RegExp构造函数来创建，接收两个参数：模式字符串以及标记字符串：

   // 匹配第一个"bat"或"cat"，忽略大小写
   let pattern1 = /[bc]at/i
   // 跟 pattern1 一样，只不过是用构造函数创建的
   let pattern2 = new RegExp("[bc]at", "i")
   

   RegExp的模式参数是字符串，在某些情况下需要二次转义：

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wb6tQz9S-1641293737955)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1640249337349.png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8XHxcTe1-1641293737955)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1640249528612.png)]

   let pattern1 = /\[bc\]at/i; 
   console.log(pattern1.global); // false 
   console.log(pattern1.ignoreCase); // true 
   console.log(pattern1.multiline); // false 
   console.log(pattern1.lastIndex); // 0 
   console.log(pattern1.source); // "\[bc\]at" 
   console.log(pattern1.flags); // "i" 
   let pattern2 = new RegExp("\\[bc\\]at", "i"); 
   console.log(pattern2.global); // false 
   console.log(pattern2.ignoreCase); // true 
   console.log(pattern2.multiline); // false 
   console.log(pattern2.lastIndex); // 0 
   console.log(pattern2.source); // "\[bc\]at" 
   console.log(pattern2.flags); // "i"
   

   RegExp实例的主要方法是exec()，用于配合捕获组使用，只接收要应用模式的字符串。若找到匹配项，则返回包含第一个匹配信息的数组，若找不到，则返回null；返回的Array实例，包含两个额外属性，index为字符串中匹配到的起始位置，input即为要查找的字符串，该数组的第一个元素是匹配整个模式的字符串，其它元素是表达式中捕获组匹配的字符串，若没有捕获组，则数组只包含一个元素

   let str = "mom and dady and baby"
   let str1 = "hingfiad ans dsd"
   let str2 = "mom and asdi sad"
   let str3 = "mom and "
   let str4 = " and baby"
   let str5 = "joadjisa sada and dady and baby"
   let rule = /mom( and dady( and baby)?)?/gi
   
   let match = rule.exec(str)
   let match1 = rule.exec(str1)
   let match2 = rule.exec(str2)
   let match3 = rule.exec(str3)
   let match4 = rule.exec(str4)
   let match5 = rule.exec(str5)
   console.log(match)
   console.log(match1)
   console.log(match2)
   console.log(match3)
   console.log(match4)
   console.log(match5)
   

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KFv45vgi-1641293737956)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1640258372133.png)]

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nchf70AJ-1641293737956)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1640258403827.png)]

   若在该模式上设置了g标记，则每次调用exec之后都会在该字符串中向前搜索下一个匹配项

   ---

   RegExp静态属性

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-khZLgfaq-1641293737957)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1640259154398.png)]

   捕获组 与 非捕获组

   正则表达式

   let str = 'sq0000.'
   str1 = str.replace(/(sq000)0./,'$1g')
   str2 = str.replace(/(sq000)(?:0)/,'$1g')
   str3 = str.replace(/(sq000)(0.)/,'$1g,$2g')
   str4 = str.replace(/(sq000)(?:0)/,'$1g,$2g')
   console.log(str)
   console.log(str1)
   console.log(str2)
   console.log(str3)
   console.log(str4)
   /**
    * sq0000.
    * sq000g
    * sq000g.
    * sq000g,0.g
    * sq000g,$2g.
    */
   

3. 以读模式访问字符串值的任何时候，后台都会执行以下步骤

   1. 创建一个String类型的实例
   2. 调用实例上的特定方法
   3. 销毁实例

   let s1 = "some text"
   let s2 = s1.substring(2)
   // 实际上相当于
   let s1 = new String("some text")
   let s2 = s1.substring(2)
   s1 = null
   

   **对于Boolean以及Number值而言也会发生。**但自动创建的原始值包装对象只存在于访问它的那行代码执行期间，即不能再运行时给原始值添加属性和方法。Object构造函数作为一个工厂方法，能够根据传入值的类型返回相应原始值包装类型的实例。

4. slice substr substring之间的区别以及联系

   1. 三者接受的两个参数，第一个是截取的第一个字符的位置索引，第二个是结束的位置；substr第二个参数所获取的是子字符串的数量。
   2. 当传入的值中有负数时，slice将所有负值理解为字符串长度加上负参数值；substr将第一个参数理解与slice相同，将第二个参数若为负，理解为0，即所需要输出的字符串长度为0，因此输出为空字符串；substring将输入的负数都理解为0，该参数实际上将传入的两个参数中较小的作为开始索引，较大的作为结束索引；

   let str = "Hello World!"
   console.log(str.slice(1,4))       //"ell"
   console.log(str.substring(1,4))   //"ell" 
   console.log(str.substr(1,4))      //"ello"
   
   console.log(str.slice(-3))        //"ld!"
   console.log(str.substring(-3))    //"Hello World!" 由于传入的是一个负数，因此识别为0，即从0开始，可以等价为str.substring(0)
   console.log(str.substr(-3))       //"ld!"
   
   console.log(str.slice(3,-4))      //"lo Wo"
   console.log(str.substring(3,-4))  //"Hel"	由于传入的第二个值是负数，识别为0，由于0的位置比3更低位，因此可等价为str.substring(0,3)
   console.log(str.substr(3,-4))     //""	由于末尾是负数，因此识别为0，即输出0个字符，结果为空字符
   

5. Number类型的方法使用

   1. 该类型重写了valueOf、toString以及toLocaleString方法，其中valueOf返回该对象的原始数值，后两个方法返沪数值的字符串；toString方法可以接收一个参数来表示基数

      let num = 10
      console.log(num.toString())	  //"10"
      console.log(num.toString(2))  //"1010"
      console.log(num.toString(8))  //"12"
      console.log(num.toString(16)) //"a"
      

   2. toFixed方法返回包含指定小数点位数的数值字符串，其中传入的参数为小数位的位数。

      let num = 10
      console.log(num.toFixed(2))	 //"10.00"
      

      toExponential返回科学计数法表示的数值字符串，也可以接收一个参数，表示结果中小数的位数。

      let num = 10
      console.log(num.toExponential(1))	//"1.0e+1"
      

      toPrecision方法返回最恰当的形式，其结果根据情况而定，可能是固定长度或科学计数法等形式。该方法传入一个参数，表示结果中的数字的总位数（不包含指数）

      let num = 99
      console.log(num.toFixed(2))         //"99.00"
      console.log(num.toExponential(1))   //"9.9e+1"
      console.log(num.toPrecision(2))     //"99"
      
      console.log(num.toPrecision(1))     //"1e+2" 需要用一位数来表示数值，因此需要四舍五入
      console.log(num.toPrecision(3))     //"99.0"  使用三位数来表示
      

      isInteger方法辨别一个数值是否保存为整数

6. javaScript字符串由16位码元组成，每16位码元对应一个字符。

   1. charAt方法返回给定索引位置的字符，由传给方法的整数参数指定。
   2. charCodeAt方法可查看指定码元的字符编码，可以返回指定索引位置的码元值，索引以整数指定。
   3. fromCharCode可以根据给定的码元来创建字符串中的字符，可以接收任意多个数值，并返回将所有数值对应的字符拼接起来的字符串

7. 16位码元只能表示65536个字符，为基本多语言平面BMP。可以使用另外16位去选择一个增补平面，这种每个字符使用两个16位码元的策略为代理对。

   [page117](D:.Study\javascript\JavaScript高级程序设计（第4版 中文高清）.pdf)

8. 字符串的位置方法

   1. indexOf从字符串的开头查找字符串，并返回位置，否则返回-1
   2. lastIndexOf则从字符串的末尾开始查找
   3. 此两方法皆可指定第二参数，第二参数表示开始搜索位置。indexOf从该参数位置开始向字符串莫搜索，忽略掉该位置之前的字符；lastIndexOf则从该参数指定位置开始向字符串开头搜索；

   let str = "Lorem ipsum dolor sit amet, consectetur adipisicing elit"
   let pos = str.indexOf("e")
   let position = new Array()
   
   while(pos > -1){
     position.push(pos)
     pos = str.indexOf("e",pos+1)
   }
   
   console.log(position)
   //使用该方法可以循环调用indexOf，最终找到所有的目标子字符串
   

9. 字符串包含方法

   1. 判断字符串中是否包含另一个字符串方法startsWith、endsWith以及includes。从字符串中搜索传入的字符串，并返回一个表示是否包含的布尔值。

   2. startsWith从索引0开始，endsWith从索引(string.length - substring.length)开始，includes检索整个字符串

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

      startsWith以及includes方法可以接收第二个参数，表示开始搜索位置，即从指定位置开始向字符串末尾搜索。endsWith所接受的第二个参数目标是应该当作字符串末尾的位置，即从后往前搜索开始的位置；

10. trim repeat等方法

    1. trim 创建字符串的一个副本，删除前后（即中间的空格符不受影响）所有空格符，再返回结果
    2. repeat 接收一个整数参数，表示将字符串复制的次数，返回拼接所有副本后的结果
    3. padStart padEnd 复制字符串，若小于指定长度，则再相应一侧填充字符直到满足长度条件。传入参数第一位长度，第二是可选的填充字符串，默认空格，且不限于一个字符，超出长度时会截断

11. 字符串迭代与解构

    字符串的原型上暴露了一个@@iterator方法，表示可以迭代字符串的每个字符

    let message = "abc"; 
    let stringIterator = message[Symbol.iterator](); 
    console.log(stringIterator.next()); // {value: "a", done: false} 
    console.log(stringIterator.next()); // {value: "b", done: false} 
    console.log(stringIterator.next()); // {value: "c", done: false} 
    console.log(stringIterator.next()); // {value: undefined, done: true}
    
    //在 for-of 循环中可以通过这个迭代器按序访问每个字符：
    for (const c of "abcde") { 
     console.log(c); 
    } 
    // a 
    // b 
    // c 
    // d 
    // e
    
    
    //有了这个迭代器之后，字符串就可以通过解构操作符来解构了。比如，可以更方便地把字符串分割为字符数组：
    let message = "abcde"; 
    console.log([...message]); // ["a", "b", "c", "d", "e"]
    

12. 字符串大小写转换

    toLowerCase、toLocaleLowerCase、toUpperCase、toLocaleUpperCase

13. 字符串模式匹配方法

    match 接收一个参数，可以是一个正则表达式字符串，也可以是一个RegExp对象。返回的数组与RegExp对象的exec方法所返回的数组一样：第一个元素是与整个模式匹配的字符串，其余元素则是与表达式中的捕获组匹配的字符串。

    let msg = "aatc, batr, sdat, atss"
    let pattern = /.at/
    
    let matches = msg.match(pattern)
    console.log(matches.index)
    console.log(matches[0])
    console.log(matches.lastIndex)
    console.log(matches)
    

    search 接收与match相同，返回模式第一个匹配的位置索引，若为找到则返回-1，始终从字符串开头向后匹配

    let text = "cat, bat, sat, fat"; 
    let pos = text.search(/at/); 
    console.log(pos); // 1
    

    replace 接收参数一为RegExp对象或一个字符串，参数二为一个字符串或一个函数。若第一个参数是字符串，则只会替换第一个子字符串。要想替换所有子字符串，则第一个参数必须是正则表达式，并且带全局标记[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQ85qrA3-1641293737957)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1641199225928.png)]

    let msg = "cat, bat, sat, fat"
    result = msg.replace(/(.at)/g, "word($1)")
    console.log(result)
    //"word(cat), word(bat), word(sat), word(fat)"
    

    split 根据传入的分隔符将字符串拆分成数组。作为分隔符的参数可以是字符串，也可以是RegExp对象。可以传入第二个参数，即数组大小，可以确保返回的数组不会超过指定大小。

    let msg = "red,blue,green,yellow"
    let col1 = msg.split(",")
    let col2 = msg.split(",",2)
    let col3 = msg.split(/[^,a-d]+/)
    console.log(col1)	// ["red", "blue", "green", "yellow"]
    console.log(col2)	// ["red", "blue"]
    console.log(col3)	// ['', 'd,b', ',', ',', '']   此处在返回的数组前后包含两个空字符串，是因为正则表达式中所指定的分隔符出现在了字符串开头和末尾
    

    localCompare 比较两个字符串，返回如下三个值中的一个

    1. 若按照字母表顺序，字符串应该排在字符串参数前面，即返回负值（-1）；
    2. 若相等，则返回0；
    3. 若字符串应该排在字符串参数后面，则返回正值（1)
    

    let msg = "yellow"
    console.log(msg.localeCompare("block"))     //1
    console.log(msg.localeCompare("yellow"))    //0
    console.log(msg.localeCompare("zoo"))       //-1
    
    console.log(msg.localeCompare("yes"))       //-1 若前面的字符无法比较，则往后继续比较
    console.log(msg.localeCompare("yellow"))    //0 
    console.log(msg.localeCompare("year"))      //1
    

    返回的具体值可能因具体实现而异，不同的地区实现可能不一样，且区分大小写，大写字母排在小写字母之前

    function determineOrder(value, compareValue) {
      let res = value.localeCompare(compareValue)
      if(res < 0){
        console.log(`The string '${value}' comes before the string '${compareValue}'.`)
      }
      else if(res > 0){
        console.log(`The string '${value}' comes after the string '${compareValue}'.`)
      }
      else{
        console.log(`The string '${value}' is equal to the string '${compareValue}'.`)
      }
    }
    
    let val = "yellow"
    determineOrder(val,"brick")
    determineOrder(val,"yellow")
    determineOrder(val,"zoo")
    /**
     * The string 'yellow' comes after the string 'brick'.
     * The string 'yellow' is equal to the string 'yellow'.
     * The string 'yellow' comes before the string 'zoo'.
     */
    

14. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AochWJNF-1641293737957)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1641209004417.png)]

15. 内置对象 任何由ES实现提供、与宿主环境无关，且在ES程序开始执行时就存在的对象，包括Object、Array和String

16. Global 所针对的是不属于任何对象的属性和方法，事实上，不存在全局变量或全局函数，在全局作用域中定义的变量和函数都会变成Global对象的属性。

17. encodeURI、encodeURIComponent、decodeURI、decodeURIComponent

    前两个用于编码统一资源标识符URI，以便传给浏览器，有效的URI不能包含比如空格等的字符。

    encodeURI用于给整个URI进行编码，且不会编码不属于URL组件的特殊字符，如冒号、斜杠、问号、井号等；

    encodeURIComponent编码所有它发现的非标准字符

    后两个是前两个相对应的逆操作，四个方法取代了escape以及unescape方法

    let uri =  "http://www.wrox.com/illegal value.js#start"
    
    //http://www.wrox.com/illegal%20value.js#start
    console.log(encodeURI(uri))
    //http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.js%23start
    console.log(encodeURIComponent(uri))
    
    let uri1 =  "http%3A%2F%2Fwww.wrox.com%2Fillegal%20value.js%23start"
    
    //http%3A%2F%2Fwww.wrox.com%2Fillegal value.js%23start
    console.log(decodeURI(uri1))
    //http://www.wrox.com/illegal value.js#start
    console.log(decodeURIComponent(uri1))
    

18. eval 接收一个参数，即一个要执行的ES字符串，会被解释为实际的ES语句，并被插入到当前位置。在eval内执行的代码属于该调用所在的上下文，被执行的代码与该上下文拥有相同的作用域链。即意味着定义在包含上下文的变量可以在eval调用内部被引用。通过eval定义的任何变量和函数都不会被提升。

    let msg = "hello world!"
    eval("console.log(msg)")    //输出msg
    
    eval("function sayHi(){console.log('hi');}")
    sayHi()     //外部可调用该函数
    

19. window对象 ECMA-262没有规定直接访问Global对象的方式，因此浏览器将window对象实现为Global对象的代理。所有全局作用域中声明的变量和函数都变成了window的属性。

    var color = "red"
    
    function sayColor() {
      console.log(window.color)
    }
    
    window.sayColor()   //"red"
    

20. 当一个函数在没有明确（通过成为某个对象的方法，或者通过call()/apply()）指定this值得情况下执行时，this值等于Global对象。调用一个简单返回this得函数是在任何执行上下文中获取Global对象的通用方式。

21. ES中提供了Math对象作为保存数学公式、信息和计算的地方，且提供了一些辅助计算的属性和方法。Math对象上提供的计算要比直接在JS上实现快得多，因为Math对象上的计算使用了JavaScript引擎中更高效的实现和处理器命令。但精度因多方面不同而异。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NxG5JO6H-1641293737958)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1641222575622.png)]

    min max 用于确定数值中的最大最小，可以接收任意多的参数

    Math.ceil 始终向上舍入为最接近的整数

    Math.floor 始终向下舍入为最接近的整数

    Math.round 执行四舍五入

    Math.fround 返回数值最接近的单精度（32位）浮点值表示

22. random方法

    Math.random()方法返回一个0~1范围内的随机数，包含0但不包含1。从一组整数中随机获取一个数公式：

    number = Math.floor(Math.random() * total_number_of_choices + first_possible_value)

    其中 total_number_of_choices 指的是这组整数的总数， first_possible_value 为这组整数最小的可能数

    function selectFrom(lowerNum, upperNum) {
      let choices = upperNum - lowerNum + 1
      let res = Math.floor(Math.random() * choices + lowerNum)
      return res
    }
    
    let num = selectFrom(2, 10)
    console.log(num)
    
    // 用于从一个数组中随机选择一个元素
    let colors = ["red", "green", "blue", "yellow", "black", "purple", "brown"]
    let color = colors[selectFrom(0, colors.length - 1)]
    console.log(color)
    
    // 加密而需要产生随机数，建议使用window.crypto.getRandomValues()
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZOB4UpKY-1641293737958)(C:\Users\czhho\AppData\Roaming\Typora\typora-user-images\1641223641036.png)]

erNum, upperNum) {
let choices = upperNum - lowerNum + 1
let res = Math.floor(Math.random() * choices + lowerNum)
return res
}

let num = selectFrom(2, 10)
console.log(num)

// 用于从一个数组中随机选择一个元素
let colors = ["red", "green", "blue", "yellow", "black", "purple", "brown"]
let color = colors[selectFrom(0, colors.length - 1)]
console.log(color)

// 加密而需要产生随机数，建议使用window.crypto.getRandomValues()
```

[外链图片转存中...(img-ZOB4UpKY-1641293737958)]