基本类型对应的内置对象

元子不圆呀
242 阅读17分钟

持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第21天，点击查看活动详情

根据前面的文章我们知道，JavaScript的基本类型有string, number, boolean, null, undefined, symbol, bigInt。我们在定义一个基本类型变量的时候可以调用方法和属性就是因为它会自动调用这些基本类型对应的内置对象的方法和属性。下面我们来介绍一下有哪些内置的对象。

string ---> String

String 全局对象是一个用于字符串或一个字符序列的构造函数。

1. 语法
String(thing)
new String(thing)
2. 参数说明
  • thing: 任何可以被转换成字符串的值。

特殊字符需要转义。

CodeOutput
\0空字符
'单引号
"双引号
\反斜杠
\n换行
\r回车
\v垂直制表符
\t水平制表符
\b退格
\f换页
\uXXXXunicode 码
\u{X} ... \u{XXXXXX}unicode codepoint 实验性
\xXXLatin-1 字符 (x 小写)
3. 基本字符串字面量和字符串对象的区别

字符串字面量 (通过单引号或双引号定义) 和 直接调用 String 方法 (没有通过 new 生成字符串对象实例) 的字符串都是基本字符串。JavaScript 会自动将基本字符串转换为字符串对象，只有将基本字符串转化为字符串对象之后才可以使用字符串对象的方法。当基本字符串需要调用一个字符串对象才有的方法或者查询值的时候 (基本字符串是没有这些方法的)，JavaScript 会自动将基本字符串转化为字符串对象并且调用相应的方法或者执行查询。

var s_prim = "foo";
var s_obj = new String(s_prim);

console.log(typeof s_prim); // Logs "string"
console.log(typeof s_obj);  // Logs "object"
4. 属性

`String.prototype： 可以为 String 对象增加新的属性。

5. 方法

字符串的常用方法挺多的，我在这里主要介绍几种常见的方法，如果想要了解更多，可以参考mdn官方文档查看

5.1 String.prototype.at()

at()  方法接受一个整数值，并返回一个新的 String，该字符串由位于指定偏移量处的单个 UTF-16 码元组成。该方法允许正整数和负整数。负整数从字符串中的最后一个字符开始倒数。

5.1.1 语法

at(index)
  • index: 要返回的字符串字符的索引（位置）。当传递负数时，支持从字符串末端开始的相对索引；也就是说，如果使用负数，返回的字符将从字符串的末端开始倒数。
// A function which returns the last character of a given string
function returnLast(arr) {
  return arr.at(-1);
}

let invoiceRef = 'myinvoice01';

console.log( returnLast(invoiceRef) );
// Logs: '1'

invoiceRef = 'myinvoice02';

console.log( returnLast(invoiceRef) );
// Logs: '2'

5.2 String.prototype.charAt()

charAt()  方法从一个字符串中返回指定的字符。

5.2.1 语法

str.charAt(index)
  • index: 一个介于 0 和字符串长度减 1 之间的整数。
var anyString = "Brave new world";

console.log("The character at index 0   is '" + anyString.charAt(0)   + "'");  // The character at index 0 is 'B'

5.3 String.prototype.charCodeAt()

charCodeAt()  方法返回 0 到 65535 之间的整数，表示给定索引处的 UTF-16 代码单元

5.3.1 语法

str.charCodeAt(index)
  • index: 一个大于等于 0，小于字符串长度的整数。如果不是一个数值，则默认为 0

指定 index 处字符的 UTF-16 代码单元值的一个数字；如果 index 超出范围，charCodeAt() 返回 NaN。

"ABC".charCodeAt(0) // returns 65:"A"

5.4 String.prototype.concat()

concat()  方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。

5.4.1 语法

str.concat(str2, [, ...strN])
  • str2 [, ...strN]： 需要连接到 str 的字符串。

concat 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。 concat 方法并不影响原字符串。

如果参数不是字符串类型，它们在连接之前将会被转换成字符串。

let hello = 'Hello, '
console.log(hello.concat('Kevin', '. Have a nice day.'))
// Hello, Kevin. Have a nice day.

5.5 String.prototype.endsWith()

endsWith()  方法用来判断当前字符串是否是以另外一个给定的子字符串“结尾”的，根据判断结果返回 true 或 false。

5.5.1 语法

str.endsWith(searchString[, length])
  • searchString： 要搜索的子字符串。
  • length： 可选。作为 str 的长度。默认值为 str.length。

这个方法帮助你确定一个字符串是否在另一个字符串的末尾。这个方法是大小写敏感的。

var str = "To be, or not to be, that is the question.";

alert( str.endsWith("question.") );  // true

5.6 String.prototype.includes()

includes()  方法用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。

5.6.1 语法

str.includes(searchString[, position])

  • searchString： 要在此字符串中搜索的字符串。

  • position：可选。从当前字符串的哪个索引位置开始搜寻子字符串，默认值为 0。

这个方法可以帮你判断一个字符串是否包含另外一个字符串。

var str = 'To be, or not to be, that is the question.';

console.log(str.includes('To be'));       // true

5.7 String.prototype.indexOf()

indexOf()  方法，给定一个参数：要搜索的子字符串，搜索整个调用字符串，并返回指定子字符串第一次出现的索引。给定第二个参数：一个数字，该方法将返回指定子字符串在大于或等于指定数字的索引处的第一次出现。

5.7.1 语法

indexOf(searchString)
indexOf(searchString, position)

查找的字符串 searchValue 的第一次出现的索引，如果没有找到，则返回 -1。

'hello world'.indexOf('') // 返回 0
'hello world'.indexOf('', 0) // 返回 0

5.8 String.prototype.lastIndexOf()

lastIndexOf()  方法返回调用String对象的指定值最后一次出现的索引，在一个字符串中的指定位置 fromIndex处从后向前搜索。如果没找到这个特定值则返回 -1。

5.8 语法

str.lastIndexOf(searchValue[, fromIndex])
  • searchValue： 一个字符串，表示被查找的值。如果searchValue是空字符串，则返回fromIndex。
  • fromIndex：可选。待匹配字符串 searchValue 的开头一位字符从 str 的第 fromIndex 位开始向左回向查找。fromIndex默认值是 +Infinity。如果 fromIndex >= str.length ，则会搜索整个字符串。如果 fromIndex < 0 ，则等同于 fromIndex == 0。

字符串中的字符被从左向右索引。首字符的索引（index）是 0，最后一个字符的索引是 stringName.length - 1。

"Blue Whale, Killer Whale".lastIndexOf("blue"); // returns -1

5.9 String.prototype.match()

match()  方法检索返回一个字符串匹配正则表达式的结果。

5.9.1 语法

str.match(regexp)
  • regexp：一个正则表达式对象。如果传入一个非正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp。如果你没有给出任何参数并直接使用 match() 方法，你将会得到一 个包含空字符串的 Array ：[""] 。
var str = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
var regexp = /[A-E]/gi;
var matches_array = str.match(regexp);

console.log(matches_array);
// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

5.10 String.prototype.matchAll()

matchAll()  方法返回一个包含所有匹配正则表达式的结果及分组捕获组的迭代器。

5.10.1 语法

str.matchAll(regexp)
  • regexp：正则表达式对象。如果所传参数不是一个正则表达式对象，则会隐式地使用 new RegExp(obj) 将其转换为一个 RegExp。RegExp必须是设置了全局模式g的形式，否则会抛出异常TypeError。
var regexp = /t(e)(st(\d?))/g;
var str = 'test1test2';

str.match(regexp);
// Array ['test1', 'test2']

5.11 String.prototype.repeat()

repeat()  构造并返回一个新字符串，该字符串包含被连接在一起的指定数量的字符串的副本。

5.11.1 语法

str.repeat(count)
  • count: 介于 0 和 +Infinity之间的整数。表示在新构造的字符串中重复了多少遍原字符串。
"abc".repeat(0)      // ""
"abc".repeat(1)      // "abc"
"abc".repeat(2)      // "abcabc"

5.12 String.prototype.replace()

replace()  方法返回一个由替换值（replacement）替换部分或所有的模式（pattern）匹配项后的新字符串。模式可以是一个字符串或者一个正则表达式，替换值可以是一个字符串或者一个每次匹配都要调用的回调函数。如果pattern是字符串，则仅替换第一个匹配项。

语法

str.replace(regexp|substr, newSubStr|function)
  • regexp (pattern): 一个RegExp对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。
  • substr (pattern): 一个将被 newSubStr 替换的 字符串。其被视为一整个字符串，而不是一个正则表达式。仅第一个匹配项会被替换。
  • newSubStr (replacement): 用于替换掉第一个参数在原字符串中的匹配部分的字符串。该字符串中可以内插一些特殊的变量名。参考下面的使用字符串作为参数。
  • function (replacement): 一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。参考下面的指定一个函数作为参数。
var str = 'Twas the night before Xmas...';
var newstr = str.replace(/xmas/i, 'Christmas');
console.log(newstr);  // Twas the night before Christmas...

5.13 String.prototype.replaceAll()

replaceAll()  方法返回一个新字符串，新字符串所有满足 pattern 的部分都已被replacement 替换。pattern可以是一个字符串或一个 RegExp， replacement可以是一个字符串或一个在每次匹配被调用的函数。

语法同replace。

'aabbcc'.replaceAll(/b/g, '.');
"aa..cc"

5.14 String.prototype.search()

search()  方法执行正则表达式和 String对象之间的一个搜索匹配。

5.14.1 语法

str.search(regexp)
  • regexp：一个正则表达式（regular expression）对象。如果传入一个非正则表达式对象 regexp，则会使用 new RegExp(regexp) 隐式地将其转换为正则表达式对象。

如果匹配成功，则 search() 返回正则表达式在字符串中首次匹配项的索引;否则，返回 -1。

var str = "hey JudE";
var re = /[A-Z]/g;
var re2 = /[.]/g;
console.log(str.search(re)); // returns 4, which is the index of the first capital letter "J"
console.log(str.search(re2)); // returns -1 cannot find '.' dot punctuation

5.15 String.prototype.slice()

slice()  方法提取某个字符串的一部分，并返回一个新的字符串，且不会改动原字符串。

5.15.1 语法

str.slice(beginIndex[, endIndex])
  • beginIndex：从该索引（以 0 为基数）处开始提取原字符串中的字符。如果值为负数，会被当做 strLength + beginIndex 看待，这里的strLength 是字符串的长度（例如，如果 beginIndex 是 -3 则看作是：strLength - 3）
  • endIndex：可选。在该索引（以 0 为基数）处结束提取字符串。如果省略该参数，slice() 会一直提取到字符串末尾。如果该参数为负数，则被看作是 strLength + endIndex，这里的 strLength 就是字符串的长度 (例如，如果 endIndex 是 -3，则是，strLength - 3)。
var str = 'The morning is upon us.';
str.slice(-3);     // 返回 'us.'
str.slice(-3, -1); // 返回 'us'
str.slice(0, -1);  // 返回 'The morning is upon us'

5.16 String.prototype.split()

split()  方法使用指定的分隔符字符串将一个String对象分割成子字符串数组，以一个指定的分割字串来决定每个拆分的位置。

5.16.1 语法

str.split([separator[, limit]])
  • separator：指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。如果纯文本分隔符包含多个字符，则必须找到整个字符串来表示分割点。如果在 str 中省略或不出现分隔符，则返回的数组包含一个由整个字符串组成的元素。如果分隔符为空字符串，则将 str 原字符串中每个字符的数组形式返回。
  • limit：一个整数，限定返回的分割片段数量。当提供此参数时，split 方法会在指定分隔符的每次出现时分割该字符串，但在限制条目已放入数组时停止。如果在达到指定限制之前达到字符串的末尾，它可能仍然包含少于限制的条目。新数组中不返回剩下的文本。
var myString = "Hello World. How are you doing?";
var splits = myString.split(" ", 3);

console.log(splits);  // ["Hello", "World.", "How"]

5.17 String.prototype.startsWith()

startsWith()  方法用来判断当前字符串是否以另外一个给定的子字符串开头，并根据判断结果返回 true 或 false。

5.17.1 语法

str.startsWith(searchString[, position])
  • searchString：要搜索的子字符串。
  • position： 可选。在 str 中搜索 searchString 的开始位置，默认值为 0。
var str = "To be, or not to be, that is the question.";

alert(str.startsWith("To be"));         // true
alert(str.startsWith("not to be"));     // false

5.18 String.prototype.substring()

substring()  方法返回一个字符串在开始索引到结束索引之间的一个子集，或从开始索引直到字符串的末尾的一个子集。

5.18.1 语法

str.substring(indexStart[, indexEnd])
  • indexStart： 需要截取的第一个字符的索引，该索引位置的字符作为返回的字符串的首字母。
  • indexEnd：可选。一个 0 到字符串长度之间的整数，以该数字为索引的字符不包含在截取的字符串内。

substring 提取从 indexStart 到 indexEnd（不包括）之间的字符。特别地：

  • 如果 indexStart 等于 indexEnd，substring 返回一个空字符串。
  • 如果省略 indexEnd，substring 提取字符一直到字符串末尾。
  • 如果任一参数小于 0 或为 NaN，则被当作 0。
  • 如果任一参数大于 stringName.length，则被当作 stringName.length。
  • 如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。
var anyString = "Mozilla";

// 输出 "Moz"
console.log(anyString.substring(0,3));
console.log(anyString.substring(3,0));
console.log(anyString.substring(3,-3));
console.log(anyString.substring(3,NaN));
console.log(anyString.substring(-2,3));
console.log(anyString.substring(NaN,3));

// 输出 "lla"
console.log(anyString.substring(4,7));
console.log(anyString.substring(7,4));

// 输出 ""
console.log(anyString.substring(4,4));

// 输出 "Mozill"
console.log(anyString.substring(0,6));

// 输出 "Mozilla"
console.log(anyString.substring(0,7));
console.log(anyString.substring(0,10));

5.19 String.prototype.toLowerCase()

toLowerCase()  会将调用该方法的字符串值转为小写形式，并返回。

console.log( "ALPHABET".toLowerCase() );
// "alphabet"

5.20 String.prototype.toUpperCase()

toUpperCase()  方法将调用该方法的字符串转为大写形式并返回（如果调用该方法的值不是字符串类型会被强制转换）。

console.log('alphabet'.toUpperCase()); // 'ALPHABET'

5.21 String.prototype.toString()

字符串对象的 toString()  方法返回一个字符串，表示指定的字符串。

const x = new String("Hello world");

console.log(x.toString()); // 输出 'Hello world'

5.22 String.prototype.trim()

trim()  方法会从一个字符串的两端删除空白字符。在这个上下文中的空白字符是所有的空白字符 (space, tab, no-break space 等) 以及所有行终止符字符（如 LF，CR 等）。

var orig = '   foo  ';
console.log(orig.trim()); // 'foo'

number ---> Number

Number 对象是经过封装的能让你处理数字值的对象。Number 对象由 Number() 构造器创建。JavaScript 的Number类型为双精度 IEEE 754 64 位浮点类型。

1. 语法
new Number(value);
var a = new Number('123'); // a === 123 is false
var b = Number('123'); // b === 123 is true
a instanceof Number; // is true
b instanceof Number; // is false
2. 参数说明
  • value：被创建对象的数字值。

Number 对象主要用于：

  • 如果参数无法被转换为数字，则返回 NaN。
  • 在非构造器上下文中 (如：没有 new 操作符)，Number 能被用来执行类型转换。
3. 属性
  • Number.EPSILON：表示 1 与Number可表示的大于 1 的最小的浮点数之间的差值。
  • Number.MAX_SAFE_INTEGER：表示在 JavaScript 中最大的安全整数（maxinum safe integer)（2^53 - 1）
  • Number.MAX_VALUE：表示在 JavaScript 里所能表示的最大数值。
  • Number.MIN_SAFE_INTEGER：代表在 JavaScript 中最小的安全的 integer 型数字 (-(2^53 - 1))。
  • Number.MIN_VALUE：表示在 JavaScript 中所能表示的最小的正值。
  • Number.NaN：表示“非数字”（Not-A-Number）。和 NaN相同。
  • Number.NEGATIVE_INFINITY：表示负无穷大。
  • Number.POSITIVE_INFINITY：表示正无穷大。
4. 方法

4.1 Number.isFinite()

Number.isFinite()  方法用来检测传入的参数是否是一个有穷数。

4.1.1 语法

Number.isFinite(value)
  • value：要被检测有穷性的值。

和全局的 isFinite()函数相比，这个方法不会强制将一个非数值的参数转换成数值，这就意味着，只有数值类型的值，且是有穷的（finite），才返回 true。

Number.isFinite(Infinity);  // false
Number.isFinite(NaN);       // false
Number.isFinite(-Infinity); // false

Number.isFinite(0);         // true
Number.isFinite(2e64);      // true

4.2 Number.isInteger()

Number.isInteger()  方法用来判断给定的参数是否为整数。

4.2.1 语法

Number.isInteger(value)

-value：要判断此参数是否为整数

Number.isInteger(0);         // true
Number.isInteger(1);         // true
Number.isInteger(-100000);   // true

Number.isInteger(0.1);       // false
Number.isInteger(Math.PI);   // false

4.3 Number.isNaN()

Number.isNaN()  方法确定传递的值是否为 NaN，并且检查其类型是否为 Number。

Number.isNaN(value)
  • value: 要检测是否为 NaN的值。
Number.isNaN(NaN);        // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)       // true

4.4 Number.isSafeInteger()

Number.isSafeInteger()  方法用来判断传入的参数值是否是一个“安全整数”（safe integer）。

Number.isSafeInteger(testValue)
  • testValue: 需要检测的参数。
Number.isSafeInteger(3);                    // true
Number.isSafeInteger(Math.pow(2, 53))       // false
Number.isSafeInteger(Math.pow(2, 53) - 1)   // true

4.5 Number.parseFloat()

Number.parseFloat()  方法可以把一个字符串解析成浮点数。

4.5.1 语法

Number.parseFloat(string)
  • string：被解析的字符串。

4.6 Number.parseInt()

Number.parseInt()  方法依据指定基数，解析字符串并返回一个整数。

4.6 语法

Number.parseInt(string)
Number.parseInt(string, radix)
  • string： 要被解析的值。如果参数不是一个字符串，则将其强制转化为字符串。字符串开头的空白符将会被忽略。
  • radix: 可选.从 2 到 36 的整数，表示进制的基数。如果超出这个范围，将返回 NaN。假如 radix 未指定或者为 0，除非数字以 0x 或 0X 开头（此时假定为十六进制 16），否则假定为 10（十进制）。

4.7 Number.prototype.toFixed()

toFixed()  方法使用定点表示法来格式化一个数值。

4.7.1 语法

numObj.toFixed(digits)
  • digits：小数点后数字的个数；介于 0 到 20（包括）之间，实现环境可能支持更大范围。如果忽略该参数，则默认为 0。
var numObj = 12345.6789;

numObj.toFixed();         // 返回 "12346"：进行四舍六入五看情况，不包括小数部分
numObj.toFixed(1);        // 返回 "12345.7"：进行四舍六入五看情况

4.8 Number.prototype.toPrecision()

toPrecision()  方法以指定的精度返回该数值对象的字符串表示。

4.8.1 语法

numObj.toPrecision(precision)
  • precision： 可选。一个用来指定有效数个数的整数。
let numObj = 5.123456

console.log(numObj.toPrecision())    // 输出 '5.123456'
console.log(numObj.toPrecision(5))   // 输出 '5.1235'
console.log(numObj.toPrecision(2))   // 输出 '5.1'
console.log(numObj.toPrecision(1))   // 输出 '5'

4.9 Number.prototype.toString()

toString()  方法返回指定 Number对象的字符串表示形式。

4.9.1 语法

numObj.toString([radix])
  • radix：指定要用于数字到字符串的转换的基数 (从 2 到 36)。如果未指定 radix 参数，则默认值为 10。
var count = 10;

console.log(count.toString());    // 输出 '10'
console.log((17).toString());     // 输出 '17'
console.log((17.2).toString());   // 输出 '17.2'

4.10 Number.prototype.valueOf()

valueOf()  方法返回一个被 Number 对象包装的原始值。

var numObj = new Number(10);
console.log(typeof numObj); // object

var num = numObj.valueOf();
console.log(num);           // 10
console.log(typeof num);    // number

boolean ---> Boolean

Boolean 对象是一个布尔值的对象包装器。它相比其他内置对象，要简单的多

如果需要，作为第一个参数传递的值将转换为布尔值。如果省略该参数或参数值为 0、-0、null、false、[NaN，或空字符串（""），则该对象具有的初始值为 false。所有其它值，包括任何对象，空数组（[]）或字符串 "false"，都会创建一个初始值为 true` 的对象。

注意不要将基本类型中的布尔值 true 和 false 与值为 true 和 false 的 Boolean 对象弄混了。

其值不是 undefined 或 null的任何对象（包括其值为 false 的布尔对象）在传递给条件语句时都将计算为 true。

const x = new Boolean(false);
if (x) {
  // 这里的代码会被执行
}

const x = false;
if (x) {
  // 这里的代码不会执行
}
1. 方法

1.1 Boolean.prototype.toString()

toString()  方法返回表示指定的布尔对象的字符串。

const flag = new Boolean(true);
const myVar = flag.toString();  // true

1.2 Boolean.prototype.valueOf()

valueOf()  方法返回一个Boolean对象的原始值。

Boolean的 valueOf 方法返回一个Boolean对象或Boolean字面量的原始值作为布尔数据类型。

x = new Boolean();
myVar = x.valueOf()      // assigns false to myVar

symbol ---> Symbol

symbol是新增的数据类型，而且它的适用场景也很复杂，所以这个单独有一篇文章介绍，敬请期待一下下。

bigInt ---> BigInt

BigInt 是一种内置对象，它提供了一种方法来表示大于 2^53 - 1 的整数。这原本是 Javascript 中可以用 Number表示的最大数字。BigInt 可以表示任意大的整数。相比其他的内置对象，它也算是比较简单的。

可以用在一个整数字面量后面加 n 的方式定义一个 BigInt ，如：10n，或者调用函数 BigInt()（但不包含 new 运算符）并传递一个整数值或字符串值。

它在某些方面类似于 Number，但是也有几个关键的不同点：不能用于 Math对象中的方法；不能和任何 Number实例混合运算，两者必须转换成同一种类型。在两种类型来回转换时要小心，因为 BigInt 变量在转换成 Number变量时可能会丢失精度。

1. 方法

1.1 BigInt.asIntN()

BigInt.asIntN 静态方法将 BigInt 值转换为一个 -2^(width-1) 与 2^(width-1)-1 之间的有符号整数。

1.1.1 语法

BigInt.asIntN(width, bigint);

  • width：可存储整数的位数。

  • bigint：要存储在指定位数上的整数。

const max = 2n ** (64n - 1n) - 1n;

BigInt.asIntN(64, max);
// ↪ 9223372036854775807n

1.2 BigInt.asUintN()

BigInt.asUintN 静态方法将 BigInt 转换为一个 0 和 2^width-1 之间的无符号整数。

1.2.1 语法

BigInt.asUintN(width, bigint);

  • width：可存储整数的位数。

  • bigint：要存储在指定位数上的整数。

const max = 2n ** 64n - 1n;

BigInt.asUintN(64, max);
// ↪ 18446744073709551615n

1.3 BigInt.prototype.toString()

toString()  方法返回一个字符串，表示指定 BigInt 对象。后面的 "n" 不是字符串的一部分。

1.3.1 语法

bigIntObj.toString([radix])
  • radix： 可选，介于 2 到 36 之间的整数，指定用于表示数值的基数。
17n.toString();      // '17'
66n.toString(2);     // '1000010'
254n.toString(16);   // 'fe'
-10n.toString(2);    // -1010'
-0xffn.toString(2);  // '-11111111'

1.4 BigInt.prototype.valueOf()

valueOf()  方法返回 BigInt对象包装的原始值。

typeof Object(1n); // object
typeof Object(1n).valueOf(); // bigint
avatar
文章
阅读
粉丝