跳至主要內容

第5章 基础引用类型

南风2024年10月26日大约 17 分钟

第5章 基础引用类型

Date类型

使用不带任何参数的Date构造函数时，将为创建的对象分配当前日期和时间。要基于其他日期或时间创建日期，必须传入日期的毫秒数表示法（Unix UTC 1970年 1 月 1 日午夜之后的毫秒数）。为了完成此过程,ECMAScript提供了两种方法：Date.parse（）和Date.UTC（）。Date.parse（）方法接受表示日期的字符串参数。它尝试将字符串转换为日期的毫秒数形式。 ECMA-262第五版定义了Date.parse（）应该支持的日期格式，填补了第三版留下的空白。现在，所有实现都必须支持以下日期格式：

  • month/date/year (如：5/23/2019)

  • month_name date, year(如：May 23, 2019)

  • day_of_week month_name date year hours:minutes:seconds time_zone (如：Tue May 23 2019

    00:00:00 GMT-0700)

  • ISO 8601 extended format YYYY-MM-DDTHH:mm:ss.sssZ (如：2019-05-23T00:00:00). 这要求兼容

    ES5。

如下所示：

let someDate = new Date(Date.parse("Oct 15, 2020"));
// let someDate = new Date("Oct 15, 2020"); 效果同上
console.log(someDate); //Thu Oct 15 2020 00:00:00 GMT+0800 (中国标准时间)

Date.UTC()的参数分别为：年份，以 0 为基础的月数，每月的天数(1-31)，小时数(0-23),分钟数，秒数，毫秒数。年和月是必须要有的。天数不提供则默认为 1 ，其他默认为 0 。如下所示：

let today = new Date(Date.UTC(2020, 9));
let NationalDay = new Date(Date.UTC(2020, 9, 1, 2, 1, 0, 1000));
console.log(today); //Thu Oct 01 2020 08:00:00 GMT+0800 (中国标准时间)
console.log(NationalDay); //Thu Oct 01 2020 10:01:01 GMT+0800 (中国标准时间)

Date.now()返回该函数执行时时间的毫秒数。

继承的方法

Date类型覆写了toLocaleString()、toString()和valueOf()方法。

let time = new Date();
console.log(time.toString()); //Thu Oct 15 2020 16:12:56 GMT+0800(中国标准时间)
console.log(time.toLocaleString()); //2020/10/15 下午4:12:56

valueOf()方法主要用于日期比较：

let date1 = new Date(2020, 0, 1);
let date2 = new Date(2020, 1, 1);
console.log(date1 < date2); // true
console.log(date1 > date2); // false

日期格式方法

如下Date方法将日期格式化为字符串：

let day = new Date();
console.log(day.toDateString());//Tue Jul 28 2020
console.log(day.toTimeString());//22:33:49 GMT+0800 (中国标准时间)
console.log(day.toLocaleDateString());//2020/7/28
console.log(day.toLocaleTimeString());//下午10:33:49
console.log(day.toUTCString());//Tue, 28 Jul 2020 14:33:49 GMT

其他方法：

let now = new Date();
console.log(now.getTime()); //1602750293438
now.setTime(1602750288888);
console.log(now.toLocaleString()); //2020/10/15 下午4:24:48
console.log(now.getFullYear()); //2020
console.log(now.getUTCFullYear()); //2020
now.setFullYear(2077);
console.log(now.toLocaleString()); //2077/10/15 下午4:24:48
console.log(now.getMonth()); //9
console.log(now.getDate()); //15
console.log(now.getDay()); //5 一周的第几天,0是周末
console.log(now.getHours()); //16
console.log(now.getMinutes()); //24
console.log(now.getSeconds()); //48
console.log(now.getMilliseconds()); //888

RegExp类型

ECMAScript通过RegExp类型支持正则表达式。正则表达式易于使用类似于Perl的语法创建，如下所示：

let expression = /pattern/flags;

表达式的模式部分可以是任何简单或复杂的正则表达式，包括字符类(character classes)，量词 (quantifiers)，分组(grouping)，正向预查(lookaheads)和后向引用(backreferences)。每个表达式可以具有零个或多个标志（flags)。

支持的flag有如下这些：

  • g 全局模式 意味着模式将应用到所有字符串而不是只匹配一个就返回

  • i 不区分大小写模式 匹配不区分大小写

  • m 多行模式 匹配到最后一行

  • y sticky模式 意味着模式将只着眼于字符串内容的lastIndex处开始。

  • u 使用Unicode模式

  • s 允许'.'匹配换行符

匹配这些元字符必须转义：( [ { \ ^ $ | ) ] }? * +.

let pattern1 = /[bc]at/i;//匹配首个bat或cat不区分大小写
let pattern01 = new RegExp("[bc]at","i");//同上
let pattern2 = /\[bc\]at/i;//匹配首个“[bc]at”,不区分大小写
let pattern3 = /.bc/gi;//匹配所有三字符“某bc”, 不区分大小写

正则表达式也可使用RegExp构造函数创建，接受两个字符串参数：要匹配的模式和标志。在构造函数中，所有的元字符必须双重转义。如下所示：

模式字面量等效的模式字符串
/[bc]at /\\[bc\\]at
/.at /\\.at
/name/age /name\\/age
/\d.\d{1,2} /\\d.\\d{1,2}
/\w\hello\123/\\w\\\\hello\\\\123

正则表达式总是共享同样的RegExp实例，而通过构造函数创建的是新实例。如下所示：

let re = null;
for (let i = 0; i < 10; i++) {
    re = /cat/g;
    re.test("catastrophe");
}
for (let i = 0; i < 10; i++) {
    re = new RegExp("cat", "g");
    re.test("catastrophe");
}

可通过构造函数复制已经存在的正则表达式实例并修改其标志：

const re1 = /cat/g;
console.log(re1); // "/cat/g"
const re2 = new RegExp(re1);
console.log(re2); // "/cat/g"
const re3 = new RegExp(re1, "i");
console.log(re3); // "/cat/i"

RegExp实例属性

每个正则表达式实例有如下属性：

  • global 布尔值，指示g标志是否设置

  • ignoreCase 布尔值，指示i标志是否设置

  • unicode 布尔值，指示u标志是否设置

  • sticky 布尔值，指示y标志是否设置

  • multiline 布尔值，指示m标志是否设置

  • lastIndex 一个整数，指示下次匹配时应在源字符串的哪个字符位置开始。第一次以 0 开始。

  • sourse 正则表达式的字符串形式，返回的是字面量形式去除前后斜杠后的字符串，而不是传入构造函数

    的模式字符串。

  • flags 标志的字符串

let pattern = /\[SC\]iri/i;
let pattern2 = new RegExp("\\[SC\\]iri","i");
console.log(pattern.global);//false
console.log(pattern.ignoreCase);//true
console.log(pattern.multiline);//false
console.log(pattern.source);//\[SC\]iri
console.log(pattern2.source);//\[SC\]iri 同上
console.log(pattern.flags);//i

RegExp实例方法

exec()方法用于捕获组，接受一个参数：要使用的字符串。返回第一次匹配的信息的数组，若没匹配到则返回null。返回的数组是Array的实例，包含两个额外的属性：index，模式匹配时在字符串中的位置；input，表达式运行的字符串。在数组中，第一项是与整个模式匹配的字符串，其他项代表表达式中的捕获组。如下所示：

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

此例中，pattern有两个捕获组，最里面的匹配and baby,然后是and dad and baby。

exec（）方法一次只返回一个匹配项有关的信息，即使正则该表达式是全局模式的。如果未指定全局标志，则多次在同一字符串上调用exec（）将始终返回有关第一个匹配项的信息。如下所示：

let text = "cat, bat, sat, fat";
let pattern = /.at/;
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

全局匹配：

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

当设置stiky模式，调用exec()将在lastIndex处开始匹配，y标记会覆盖g标记。如下所示：

let text = "cat, bat, sat, fat";
let pattern = /.at/y;
let matches = pattern.exec(text);
console.log(matches.index); // 0
console.log(matches[0]); // cat
console.log(pattern.lastIndex); // 3
// 字符索引3处没有匹配,所以exec()返回null。exec()没找到匹配将重置lastIndex为0
matches = pattern.exec(text);
console.log(matches); // null
console.log(pattern.lastIndex); // 0
// 更改lastIndex将允许sticky regex exec()找到匹配:
pattern.lastIndex = 5;
matches = pattern.exec(text);
console.log(matches.index); // 5
console.log(matches[0]); // bat
console.log(pattern.lastIndex); // 8

test()方法接受一个字符串参数，若模式匹配该参数则返回true，否则返回false。如下所示：

let text = "000-00-0000";
let pattern = /\d{3}-\d{2}-\d{4}/;
if (pattern.test(text)) {
    console.log("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

RegExp构造函数属性

RegExp构造函数有几个属性(同其他语言的静态属性,暂未标准化)，这些属性适用于范围内的所有正则表达式，并且它们基于上次执行的正则表达式操作而更改。如下表所示：

属性名简写名描述
input&_返回当前所作用的字符串，初始值为空字符串""
lastMatch最后匹配到的字符串
lastParen$+最后匹配到的捕获组
leftContext$`输入字符串中出现在lastMatch之前的文本
rightContext$'输入字符串中出现在lastMatch之后的文本

这些属性可用于提取有关exec（）或test（）执行的操作的具体信息。如下所示：

let text = "this has been a short summer";
let pattern = /(.)hort/g;
if (pattern.test(text)) {
    console.log(RegExp.input); // this has been a short summer
    console.log(RegExp.leftContext); // this has been a
    console.log(RegExp.rightContext); // summer
    console.log(RegExp.lastMatch); // short
    console.log(RegExp.lastParen); // s
}

简写版：

let text = "this has been a short summer";
let pattern = /(.)hort/g;
//Opera和IE可能存在兼容问题
if (pattern.test(text)) {
    console.log(RegExp.$_); // this has been a short summer
    console.log(RegExp["$`"]); // this has been a
    console.log(RegExp["$'"]); // summer
    console.log(RegExp["$&"]); // short
    console.log(RegExp["$+"]); // s
    console.log(RegExp["$*"]); // false
}

RegExp.$1-9代表匹配的1-9个匹配组：

let text = "this has been a short summer";
let pattern = /(..)or(.)/g;
if (pattern.test(text)) {
    console.log(RegExp.$1); // sh
    console.log(RegExp.$2); // t
}

模式限制

ECMAScript正则表达式不支持如下特性：

  • The \A and \Z anchors (matching the start or end of a string, respectively)

  • Lookbehinds

  • Union and intersection classes

  • Atomic grouping

  • Unicode support (except for matching a single character at a time)

  • Named capturing groups

  • The s (single-line) and x (free-spacing) matching modes

  • Conditionals

  • Regular-expression comments

基本包装类型

三种特殊引用类型:Boolean,String,Number。

每次基本值被读取，相应的包装对象在幕后被创建：

let s1 = 'Ciri and Geralt';
let s2 = s1.substring(2);//创建String类型的实例,调用实例方法,销毁实例
console.log(s2);//ri and Geralt

自动创建的基本包装对象只会存在一行代码的时间：

let c = 'Ciri';
c.age = 18;
console.log(c.age);//undefined

Object的构造函数还充当工厂方法，能够根据传递给构造函数的值的类型返回原始包装对象的实例：

let obj = new Object('Ciri');
console.log(obj instanceof String);//true

Boolean类型

Boolean实例覆写了valueOf（）方法以返回true或false的原始值。调用时，toString（）方法也被覆写以返回字符串“true”或“false”。不幸的是，不仅布尔对象在ECMAScript中很少使用，而且它们实际上可能非常混乱。尝试在布尔表达式中使用布尔对象时，通常会发生此问题，如下所示：

let falseObject = new Boolean(false);
let result = falseObject && true;
console.log(result); // true
let falseValue = false;
result = falseValue && true;
console.log(result); // false
console.log(typeof falseObject); // object
console.log(typeof falseValue); // boolean
console.log(falseObject instanceof Boolean); // true
console.log(falseValue instanceof Boolean); // false

最好别使用布尔对象。

Number类型

Number类型覆写了valueOf(),toLocaleString()和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(10)); // "10"
console.log(num.toString(16)); // "a"

toFixed（）方法返回具有指定小数位数(通常为0~20位)的数字的字符串表示形式:

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

toExponential()方法返回指数表示法格式的数字：

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

toPrecision（）方法返回数字的固定表示或指数表示(通常为1~21位)：

let num = 99;
console.log(num.toPrecision(1)); // "1e+2"
console.log(num.toPrecision(2)); // "99"
console.log(num.toPrecision(3)); // "99.0"

使用Number对象也有问题：

let numberObject = new Number(10);
let numberValue = 10;
console.log(typeof numberObject); // "object"
console.log(typeof numberValue); // "number"
console.log(numberObject instanceof Number); // true
console.log(numberValue instanceof Number); // false

ES6中新引入的Number.isInteger（）方法能够辨别数字值是否存储为整数：

console.log(Number.isInteger(1)); // true
console.log(Number.isInteger(1.00)); // true
console.log(Number.isInteger(1.01)); // false

isSafeInteger（）方法：

console.log(Number.MIN_SAFE_INTEGER); //-9007199254740991
console.log(Number.MAX_SAFE_INTEGER); //9007199254740991
console.log(-1 * (2 ** 53) + 1); //-9007199254740991
console.log((2 ** 53) - 1); //9007199254740991
console.log(Number.isSafeInteger(-1 * (2 ** 53))); // false
console.log(Number.isSafeInteger(-1 * (2 ** 53) + 1)); // true
console.log(Number.isSafeInteger(2 ** 53)); // false
console.log(Number.isSafeInteger((2 ** 53) - 1)); // true

显式转换与使用new关键字创建的类型不一样：

let x = '18';
let y = Number(x);
console.log(typeof y);//number
let z = new Number(x);
console.log(typeof z);//object
console.log(99 === 0x63);//true

字符串

字符串里双字节字符长度仍为 1 ：

let str = "你好,世界";
console.log(str.length);//5

length属性、charCodeAt()、charAt()方法；String.fromCharCode()返回拼接的字符串:

let str = "Hello,Ciri";
console.log(str.length); //10
console.log(str.charAt(6)); //C
console.log(str.charCodeAt(6)); //67
console.log(String.fromCharCode(0x61, 0x62, 0x63, 0x64, 0x65)); // "abcde"
// console.log(String.fromCharCode(97, 98, 99, 100, 101)); 同上

codePointAt()和(String.fromCodePoint()方法：

let message = "ab☺de";
console.log(message.codePointAt(1)); // 98
console.log(message.codePointAt(2)); // 9786
console.log(String.fromCodePoint(9786)); //☺
console.log(message.codePointAt(3)); // 100
console.log(message.codePointAt(4)); // 101
console.log([..."ab☺de"]); //["a", "b", "☺", "d", "e"]

字符串操纵方法

concat()方法用于拼接一个或多个字符串到另一个，并返回拼接后的字符串：

let stringValue = "hello ";
let result = stringValue.concat("world","!");
console.log(result); // "hello world!"
console.log(stringValue); // "hello "

slice()、substr()、substring()方法：

let str ="南风知我意,吹梦到西洲";
console.log(str.slice(3));//我意,吹梦到西洲 返回索引3到最后
console.log(str.substring(3));//我意,吹梦到西洲 返回索引3到最后
console.log(str.substr(3));//我意,吹梦到西洲 返回索引3到最后
console.log(str.slice(3,7));//我意,吹 返回索引3(包含)到索引7(不包含)
console.log(str.substring(3,7));//我意,吹 返回索引3(包含)到索引7(不包含)
console.log(str.substr(3,7));//我意,吹梦到西 返回索引3(包含)后7个字符

字符串定位方法

indexOf()和lastIndexOf()：

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

字符串包含方法

startsWith(), endsWith()和includes()：

let message = "foobarbaz";
console.log(message.startsWith("foo")); // true
console.log(message.startsWith("foo", 1)); // false
console.log(message.startsWith("bar")); // false
console.log(message.endsWith("baz")); // true
console.log(message.endsWith("bar")); // false
console.log(message.endsWith("bar", 6)); // true
console.log(message.endsWith("bar", 5)); // false
console.log(message.includes("bar")); // true
console.log(message.includes("bar", 1)); // true
console.log(message.includes("bar", 4)); // false
console.log(message.includes("qux")); // false

trim（）方法创建字符串的副本，删除所有前置和尾部空格，然后返回：

let stringValue = "   hello world   ";
let trimmedStringValue = stringValue.trim();
console.log(stringValue); // "   hello world   "
console.log(stringValue.length); //16
console.log(trimmedStringValue); // "hello world"
console.log(trimmedStringValue.length); //11
console.log(stringValue.trimLeft().length); //14
console.log(stringValue.trimRight().length); //13

trimLeft()只移除前置空格，trimRight()只移除后面的空格。

repeat（）方法接受单个整数参数count，复制字符串count次，并拼接所有复制的字符串：

let stringValue = "na ";
console.log(stringValue.repeat(16) + "batman");
// na na na na na na na na na na na na na na na na batman

padStart()和padEnd()将复制字符串：

let stringValue = "foo";
console.log(stringValue.padStart(6)); // "   foo"
console.log(stringValue.padStart(9, ".")); // "......foo"
console.log(stringValue.padEnd(6)); // "foo   "
console.log(stringValue.padEnd(9, ".")); // "foo......"

console.log(stringValue.padStart(8, "bar")); // "barbafoo"
console.log(stringValue.padStart(2)); // "foo"
console.log(stringValue.padEnd(8, "bar")); // "foobarba"
console.log(stringValue.padEnd(2)); // "foo"

字符串迭代器和解构

字符串原型暴露了@@iterator方法，可用于迭代字符串的每个字符：

let str = 'Ciri';
let strIterator = str[Symbol.iterator]();
console.log(strIterator.next());//{"done":false,"value":"C"}
console.log(strIterator.next());//{"done":false,"value":"i"}
console.log(strIterator.next());//{"done":false,"value":"r"}
console.log(strIterator.next());//{"done":false,"value":"i"}
console.log(strIterator.next());//{"done":true}
console.log([...str]);//["C","i","r","i"]
console.log([...[1,2,3,4]]);// [1,2,3,4]

toLowerCase(), toLocaleLowerCase(), toUpperCase()和toLocaleUpperCase()方法：

let stringValue = "Hello world";
console.log(stringValue.toLocaleUpperCase()); // "HELLO WORLD"
console.log(stringValue.toUpperCase()); // "HELLO WORLD"
console.log(stringValue.toLocaleLowerCase()); // "hello world"
console.log(stringValue.toLowerCase()); // "hello world"

字符串模式匹配方法

match()方法，本质上同RegExp对象的exec()方法，该方法接受一个正则表达式字符串或RegExp对象：

let text = 'Ciri,Geralt,Yennefer,Triss';
let pattern = /.e/g;
let matches = text.match(pattern);
let m = pattern.exec(text);
let m2 = text.match("ir");
console.log(matches.index); // undefined 匹配多个是undefined
console.log(m2.index); //1 匹配一个正常
console.log(matches[0]); //Ge
console.log(matches[1]); //Ye
console.log(matches); //["Ge","Ye","ne","fe"]
console.log(m);
//["Ge", index: 5, input: "Ciri,Geralt,Yennefer,Triss", groups: undefined]
console.log(pattern.lastIndex); //7

search()方法参数同match(),返回匹配索引或-1(未匹配到):

let text = 'Ciri,Geralt,Yennefer,Triss';
let pos = text.search(/.e/); //返回第一个匹配的索引
//let pos = text.search("Triss");//同上
console.log(pos); //5

replace()语法：

str.replace(regexp|substr, newSubStr|function)

该方法接受两个参数，第一个参数可以是RegExp对象或字符串(字符串不转换为正则表达式)；第二个参数可以是字符串或函数。如果第一个参数是字符串，仅能替换第一个。如下所示：

let text = 'Ciri,Geralt,Yennefer,Triss';
let result = text.replace('e', 'O'); //如果第一个参数为字符串,仅能替换第一个
console.log(result); //Ciri,GOralt,Yennefer,Triss
console.log(text); //Ciri,Geralt,Yennefer,Triss
console.log(typeof result); //string
let result2 = text.replace(/e/g, 'O'); //加g标志可替换所有
console.log(result2); //Ciri,GOralt,YOnnOfOr,Triss

当第二个参数是字符串时，可以使用几种特殊的字符序列来插入来自常规表达式操作的值。 ECMA-262指定下表的值：

字符序列将匹配替换成
$$"$"符号
$&匹配的子串。同RegExp.lastMatch
$`当前匹配的子串左边的内容。同RegExp.leftContext.
$'当前匹配的子串右边的内容。同RegExp.rightContext.
$n第n个捕获组,n值为0~9。如 $1 为第一个,$2为第二个...若没有匹配组,则使用空字符串
$nn第nn个捕获组,nn值为0~99。如 $01 为第一个, $02为第二个...若没有匹配组,则使用空字符串

如下所示：

let text = "cat, bat, sat, fat";
result = text.replace(/at/g, "$$");
console.log(result); //c$, b$, s$, f$

result = text.replace(/at/g, "~$&");
console.log(result); //c~at, b~at, s~at, f~at

result = text.replace(/bat/, "$`");
console.log(result); //cat, cat, , sat, fat

result = text.replace(/bat/, "$'");
console.log(result); //cat, , sat, fat, sat, fat

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

replace()的第二个参数可以是函数，在这种情况下，当匹配执行后，该函数就会执行。 函数的返回值作为替换字符串。如果第一个参数是正则表达式，并且为全局匹配模式，那么这个方法将被多次调用，每次匹配都会被调用。

function htmlEscape(text) {
    return text.replace(/[<>"&]/g, function(match, pos, originalText) {
        switch (match) {
            case "<":
                return "&lt;";
            case ">":
                return "&gt;";
            case "&":
                return "&amp;";
            case "\"":
                return "&quot;";
        }
    });
}
console.log(htmlEscape("<p class=\"greeting\">Hello world!</p>"));
// "&lt;p class=&quot;greeting&quot;&gt;Hello world!</p>"

函数的参数为：

变量名代表的值
match匹配的子串。(对应于上述的。)
p1, p2, ...假如replace()方法的第一个参数是一个RegExp对象,则代表第n个捕获组匹配的字符串。(对应于上述的$1, $2等。) 例如,如果是用 /(\a+)(\b+)/ 这个来匹配, p1 就是匹配的 \a+, p2 就是匹配的 \b+。
offset匹配到的子字符串在原字符串中的偏移量。(比如,如果原字符串是 'abcd',匹配到的子字符串是 'bc',那么这个参数将会是 1)
string被匹配的原字符串。
NamedCaptureGroup命名捕获组匹配的对象

split()方法以分隔符为基础拆分字符串为子字符串的数组。分隔符可以是字符串或RegExp对象。第二个为可选参数，限制返回的数组的长度。如下所示：

let colorText = "red,blue,green,yellow";
console.log(colorText.split(",")); // ["red", "blue", "green", "yellow"]
console.log(colorText.split(",", 2)); // ["red", "blue"]
console.log(colorText.split(/[^\,]+/)); // ["", ",", ",", ",", ""]

encodeURU()、decodeURI()、encodeURIComponent()、decodeURIComponent()方法：

let uri = "http:// www.nfzwy.com/";
console.log(encodeURI(uri));
//http://%20www.nfzwy.com/
 空格替换为%20 其他保持不变 对应decodeURI解码
console.log(encodeURIComponent(uri));
//http%3A%2F%2F%20www.nfzwy.com%2F
//编码非字母数字字符
 对应decodeURIComponent解码

Math对象

console.log(Math.E);//2.718281828459045
console.log(Math.PI);//3.141592653589793
console.log(Math.LN10);//logE10
console.log(Math.E**Math.LN10);//10
console.log(Math.LN2); //0.6931471805599453
console.log(Math.LOG10E); //0.4342944819032518
console.log(Math.LOG2E); //1.4426950408889634
console.log(Math.SQRT2); //1.4142135623730951
console.log(Math.SQRT1_2);//根号下0.5
let array = [1,3,4,5,3,5,3,66,666,4,4,5,7];
let max = Math.max(...array);//...延展操作符
console.log(max);//666
console.log(Math.max(array));//undefined
let pi = 3.14;
console.log(Math.fround(pi));//3.140000104904175
let x = 6;
console.log(Math.exp(x));//E的x次幂
console.log(Math.expm1(1));//1.71828 E的x次幂减1
console.log(Math.log(2.71828));//1 E为底的x的对数
console.log(Math.log1p(1.71828));//1 E为底的(x+1)的对数
console.log(Math.pow(2,3));//8 2的3次幂
let num = [3,4];
console.log(Math.hypot(...num));//5 返回所有元素平方和的平方根
console.log(Math.clz32(0));//32 返回一个 32 位整数的前导零的数量
console.log(Math.sign(x));//1 返回x的符号
console.log(Math.trunc(3.14));//3 截掉小数部分
console.log(Math.sqrt(9));//3 平方根
console.log(Math.cbrt(8));//2 立方根
console.log(Math.cos(0));//1 cos(0);
console.log(Math.acos(1));//0 反余弦
上次编辑于: 2024/10/26 10:14:36
贡献者: nfzwy
默认页脚
Copyright © 2024 南风