Quels sont les nouveaux types de données de base js dans es6 ?

Nouveaux types de données de base dans es6 : 1. Type de symbole, qui représente une valeur unique, c'est-à-dire qu'une instance de symbole est unique et immuable, elle est générée car elle est utilisée comme une marque unique puis utilisée comme une non-chaîne ; Les attributs d'objet du formulaire garantissent que les attributs d'objet utilisent des identifiants uniques et qu'il n'y a aucun risque de conflits d'attributs. 2. Le type BigInt prend en charge les entiers de n'importe quelle longueur, principalement pour exprimer des entiers supérieurs à "2^53-1".

L'environnement d'exploitation de ce tutoriel : système Windows 7, ECMAScript version 6, ordinateur Dell G3.

基本数据类型 也称为原始数据类型，包括String、Number、Boolean、undefined、null、Symbol、BigInt，其中Symbol和BigIntNouveau pour ES6.

Type de symbole

Symbol est un nouveau type de données introduit dans ECMAScript6, qui représente une valeur unique. Les symboles sont des valeurs primitives (le type de données sous-jacent) et les instances de symboles sont uniques et immuables. Il est généré car il est utilisé pour marquer de manière unique, puis être utilisé comme attributs d'objet sous forme non chaîne pour garantir que les attributs d'objet utilisent des identifiants uniques sans risque de conflits d'attributs.

Avant ES6, la clé d'un objet ne pouvait être que de type chaîne. Cependant, cela provoquait un conflit de nom avec le nom de la clé. , une valeur unique était nécessaire pour servir de nom de clé. Le symbole s'est avéré être Born.

1. Concept

symbol est un type de données de base La fonction Symbol() renverra une valeur de type symbole, qui a des propriétés et des méthodes statiques. Mais ce n'est pas un constructeur et ne peut pas être créé avec new Symbol().

let symbol = Symbol();
typeof symbol; // "symbol"

Symbole Lorsqu'il est utilisé comme attribut d'objet, il doit être mis entre crochets lorsqu'il se trouve à l'intérieur de l'objet. S'il n'est pas entre crochets, il représente une chaîne.

let s = Symbol();
let obj = {
  [s]: "Jack",
};
obj[s]; // "Jack"
obj.s; // undefined

Et lorsque vous souhaitez obtenir la valeur de cet attribut, vous ne pouvez pas utiliser l'opérateur point, car l'opérateur point est également suivi d'un type chaîne.

Lors de la création de types de données Symbol, ils sont tous créés avec Symbol(). Une fois imprimés, ils sont tous Symbol(). Cela rend difficile la distinction de la signification de chaque variable de type Symbol. Par conséquent, la fonction Symbol peut recevoir un paramètre de chaîne, qui représente la description de la variable de type Symbol définie.

let s1 = Symbol("a");
console.log(s1); // Symbol(a)
s1.toString(); // "Symbol(a)"

Si le type Symbol reçoit un type d'objet, sa méthode interne toString sera d'abord appelée pour le convertir en chaîne, puis une valeur Symbol sera générée.

let arr = [1, 2, 3];
let s1 = Symbol(arr);
console.log(s1); // Symbol(1,2,3)
let obj = {
  toString: () => "abc",
};
let s2 = Symbol(obj);
console.log(s2); // Symbol(abc)

Les variables de type symbole ne peuvent pas participer aux opérations avec d'autres variables et elles ne peuvent être converties qu'en type String et en type Boolean.

let s = Symbol();
console.log("1" + s); // TypeError: Cannot convert a Symbol value to a string
s.toString(); // "Symbol()"
Boolean(s); // true
Number(s); // TypeError: Cannot convert a Symbol value to a number

2, Symbol.prototype.description

Lors de l'ajout d'une description à Symbol, vous pouvez obtenir la description via Symbol.prototype.description.

let s = Symbol("Jack");
s.description; // 'Jack'

3, Symbol.for(key) et Symbol.keyFor(sym)

Quand j'ai vu ces deux méthodes pour la première fois, j'ai pensé qu'il s'agissait de deux méthodes de traversée.

• Symbol.for(key) : Recherchez un symbole existant à l'aide de la clé donnée et renvoyez le symbole s'il est trouvé. Sinon, un nouveau symbole sera créé dans le registre global des symboles avec la clé donnée.

• Symbol.keyFor(sym) : Récupère une clé pour un symbole donné dans le registre global des symboles.

let s1 = Symbol.for("foo");
let s2 = Symbol.for("foo");
s1 === s2; // true

Symbol.for recherchera une valeur de symbole avec ce paramètre comme nom. Si tel est le cas, renvoyez cette valeur de symbole, sinon créez une nouvelle valeur de symbole nommée avec cette chaîne et enregistrez-la globalement. Ainsi, deux valeurs de même description créées par celui-ci seront égales. Ce type de création a des résultats complètement différents de Symbol() ordinaire :

let s1 = Symbol("foo");
let s2 = Symbol("foo");
s1 === s2; // false

Parce que Symbol() renvoie une toute nouvelle valeur quoi qu'il arrive. En d'autres termes, la valeur générée par Symbol() n'est pas enregistrée globalement. les valeurs sont toutes nouvelles et Symbol.for() recherchera d'abord dans le monde global et renverra la valeur si elle existe. Sinon, une nouvelle valeur sera créée, mais la nouvelle valeur sera également montée. dans le monde global.

Symbol.keyFor(sym) recherche globalement la valeur du symbole et renvoie la description si elle existe.

let s1 = Symbol.for("Jack");
Symbol.keyFor(s1); // 'Jack'
let s2 = Symbol("Rose");
Symbol.keyFor(s2); // undefined

Parce que s2 n'est pas monté globalement, Symbol.keyFor() ne peut pas le trouver, il renvoie donc undefined.

4. Attribut de symbole intégré

除了定义自己使用的 Symbol 值以外，ES6 还提供了 13（有可能今后会更多 ?） 个内置的 Symbol 值，指向语言内部使用的方法。

4.1 Symbol.asyncIterator

Symbol.asyncIterator 符号指定了一个对象的默认异步迭代器。如果一个对象设置了这个属性，它就是异步可迭代对象，可用于 for await...of 循环。换句话说一个异步可迭代对象内部必须有 Symbol.asyncIterator 属性。

const myAsyncIterable = new Object();
myAsyncIterable[Symbol.asyncIterator] = async function* () {
  yield "hello";
  yield "async";
  yield "iteration!";
};

(async () => {
  for await (const x of myAsyncIterable) {
    console.log(x);
    // expected output:
    //    "hello"
    //    "async"
    //    "iteration!"
  }
})();

当执行 for await...of 时，就会执行该变量中 Symbol.asyncIterator 属性值。

4.2、Symbol.hasInstance

Symbol.hasInstance 用于判断某对象是否为某构造器的实例。因此你可以用它自定义 instanceof 操作符在某个类上的行为。换句话说当判断一个实例是否为一个类的实例时，其实就是执行该类里面的 Symbol.hasInstance 属性。

class Fu {
  [Symbol.hasInstance](num) {
    return num === 1;
  }
}
1 instanceof new Fu(); // true
2 instanceof new Fu(); // false

4.3、Symbol.isConcatSpreadable

内置的 Symbol.isConcatSpreadable 符号用于配置某对象作为 Array.prototype.concat()方法的参数时是否展开其数组元素。

// 默认情况下
let arr = [1, 2, 3];
let brr = [4, 5, 6];
arr.concat(brr); // [1, 2, 3, 4, 5, 6]
// 设置了Symbol.isConcatSpreadable后
let arr = [1, 2, 3];
let brr = [4, 5, 6];
brr[Symbol.isConcatSpreadable] = false;
arr.concat(brr); // [1, 2, 3, [4, 5, 6]]

将数组的 Symbol.isConcatSpreadable 属性设置为 false 后，使用 concat 方法时该数据就不会展开。

对于类数组而言，默认数组使用 concat 方法该类数组是不展开的，我们可以给类数组的 Symbol.isConcatSpreadable 设置为 true，这样就可以展开了，并且完成了类数组转换为数组，这样类数组转数组又多了一个方法。

// 默认情况下
function foo(x, y) {
  let arr = [].concat(arguments);
  console.log(arr); //[Arguments(2)]
}
foo(1, 2);
// 设置了Symbol.isConcatSpreadable为true后
function foo(x, y) {
  arguments[Symbol.isConcatSpreadable] = true;
  let arr = [].concat(arguments);
  console.log(arr); //[1, 2]
}
foo(1, 2);

4.4、Symbol.iterator

Symbol.iterator 为每一个对象定义了默认的迭代器。该迭代器可以被 for...of 循环使用。

const myIterable = {};
myIterable[Symbol.iterator] = function* () {
  yield 1;
  yield 2;
  yield 3;
};

[...myIterable]; // [1, 2, 3]

对象进行 for...of 循环时，会调用 Symbol.iterator 方法，

4.5、Symbol.match

Symbol.match 指定了匹配的是正则表达式而不是字符串。String.prototype.match() 方法会调用此函数。换句话说就是当 str.match()执行时如果该属性存在，就会返回该方法的返回值。

class foo {
  [Symbol.match](string) {
    return string;
  }
}
"Jack".match(new foo()); // 'Jack'

除上述之外，MDN 还提出了该属性另外一个功能：此函数还用于标识对象是否具有正则表达式的行为。比如， String.prototype.startsWith()，String.prototype.endsWith() 和 String.prototype.includes() 这些方法会检查其第一个参数是否是正则表达式，是正则表达式就抛出一个 TypeError。现在，如果 match symbol 设置为 false（或者一个 假值），就表示该对象不打算用作正则表达式对象。

"/bar/".startsWith(/bar/); // TypeError: First argument to String.prototype.startsWith must not be a regular expression
// 当设置为false之后
var re = /foo/;
re[Symbol.match] = false;
"/foo/".startsWith(re); // true
"/baz/".endsWith(re); // false

4.6、Symbol.matchAll

Symbol.matchAll 返回一个迭代器，该迭代器根据字符串生成正则表达式的匹配项。此函数可以被 String.prototype.matchAll() 方法调用。

"abc".matchAll(/a/);
// 等价于
/a/[Symbol.matchAll]("abc");

4.7、Symbol.replace

Symbol.replace 这个属性指定了当一个字符串替换所匹配字符串时所调用的方法。String.prototype.replace() 方法会调用此方法。

String.prototype.replace(searchValue, replaceValue);
// 等同于
searchValue[Symbol.replace](this, replaceValue);
// 例子
class Replace1 {
  constructor(value) {
    this.value = value;
  }
  [Symbol.replace](string) {
    return `s/${string}/${this.value}/g`;
  }
}

console.log("foo".replace(new Replace1("bar"))); // "s/foo/bar/g"

4.8、Symbol.search

Symbol.search 指定了一个搜索方法，这个方法接受用户输入的正则表达式，返回该正则表达式在字符串中匹配到的下标，这个方法由以下的方法来调用 String.prototype.search()。

String.prototype.search(regexp);
// 等价于
regexp[Symbol.search](this);
// 例子
class Search1 {
  [Symbol.search](str) {
    return `${str} Word`;
  }
}
"Hello".search(new Search1()); // Hello Word

4.9、Symbol.species

Symbol.species 是个函数值属性，其被构造函数用以创建派生对象，换句话说 species 访问器属性允许子类覆盖对象的默认构造函数。

我们举个例子：

// 默认情况下
class MyArray extends Array {}
let arr = new MyArray(1, 2, 3);
let brr = arr.map((item) => item);
brr instanceof MyArray; // true
brr instanceof Array; // true

类 MyArray 继承于 Array，arr 为 MyArray 的实例，brr 为 arr 的衍生物，所以 brr 是 MyArray 的实例，并且由于原型链的缘故，brr 也是 Array 的实例。如果此时，我们只想让 brr 为 Array 的实例，那 Symbol.species 属性值就派上用场了。

class MyArray extends Array {
  static get [Symbol.species]() {
    return Array;
  }
}
let arr = new MyArray(1, 2, 3);
let brr = arr.map((item) => item);
brr instanceof MyArray; // false
brr instanceof Array; // true
// 默认情况下
class MyArray extends Array {
  static get [Symbol.species]() {
    return this;
  }
}

值得注意的是，定义 Symbol.species 属性时，前面必须声明是静态的 static 并且要运用 get 取值器。

4.10、Symbol.split

Symbol.split 指向 一个正则表达式的索引处分割字符串的方法。 这个方法通过 String.prototype.split() 调用。

String.prototype.split(separator, limit);
// 等价于
separator[Symbol.split](this, limit);
// 例子
class Split1 {
  [Symbol.split](str) {
    return `${str} Word`;
  }
}
"Hello".split(new Split1()); // Hello Word

4.11、Symbol.toPrimitive

Symbol.toPrimitive 是一个内置的 Symbol 值，它是作为对象的函数值属性存在的，当一个对象转换为对应的原始值时，会调用此函数。该函数在调用时，会传递一个字符串参数 hint，表示要转换到的原始值的预期类型。字符串 hint 的类型有三种：'number', 'string', 'default'。

let obj =
  {
    [Symbol.toPrimitive](hint) {
      switch (hint) {
        case "number":
          return 123;
        case "string":
          return "123";
        case "default":
          return "default";
        default:
          throw new Error();
      }
    },
  } + obj; // 123
`${obj}`; // '123'
obj + ""; // "default"

4.12、Symbol.toStringTag

Symbol.toStringTag 是一个内置 symbol，它通常作为对象的属性键使用，对应的属性值应该为字符串类型，这个字符串用来表示该对象的自定义类型标签，通常只有内置的 Object.prototype.toString() 方法会去读取这个标签并把它包含在自己的返回值里。通俗点讲就是在 Object.prototype.toString()去判断自定义对象的数据类型时，返回的都是 object，可以通过这个属性来给自定义对象添加类型标签。 

Object.prototype.toString.call('123'); // [object String]
...more

另外一些对象类型则不然，toString() 方法能识别它们是因为引擎为它们设置好了 toStringTag 标签：

Object.prototype.toString.call(new Map()); // "[object Map]"
Object.prototype.toString.call(function* () {}); // "[object GeneratorFunction]"
Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
...more

当我们自己定义一个类时，调用 Object.prototype.toString()时，由于没有内部定义 toStringTag 标签，所以只能返回"[object Object]"

class Foo {}
Object.prototype.toString.call(new Foo()); // "[object Object]"
// 设置Symbol.toStringTag
class Foo {
  get [Symbol.toStringTag]() {
    return "Foo";
  }
}
Object.prototype.toString.call(new Foo()); // "[object Foo]"

4.13、Symbol.unscopabless

Symbol.unscopables 指用于指定对象值，其对象自身和继承的从关联对象的 with 环境绑定中排除的属性名称。说白了其属性就是控制，在 with 词法环境中哪些属性会被 with 删除。

Array.prototype[Symbol.unscopabless];
// {
//   copyWithin: true,
//   entries: true,
//   fill: true,
//   find: true,
//   findIndex: true,
//   includes: true,
//   keys: true
// }

这里简单的讲解一下 with 函数，with 主要是用来对对象取值的，举个简单的例子：

let obj = {};
with (obj) {
  let newa = a;
  let newb = b;
  console.log(newa + newb);
}
// 等价于
let newa = obj.a;
let newb = obj.b;
console.log(newa + newb);

with 的 优点： 当 with 传入的值非常复杂时，即当 object 为非常复杂的嵌套结构时，with 就使得代码显得非常简洁。 with 的缺点： js 的编译器会检测 with 块中的变量是否属于 with 传入的对象， 上述例子为例，js 会检测 a 和 b 是否属于 obj 对象，这样就会的导致 with 语句的执行速度大大下降，性能比较差。

回归正题，我们举个例子看一下 Symbol.unscopables 属性的作用。

let obj = {
  foo() {
    return 1;
  }
}
with(obj) {
  foo(); // 1
}
// 设置了Symbol.unscopables
let obj = {
  foo() {
    return 1;
  },
  get [Symbol.unscopables]() {
    return {
      foo: true
    }
  }
}
with(obj) {
  foo(); // Uncaught ReferenceError: foo is not defined
}

设置后报错的原因是因为with已经将obj中的foo方法删除了。

BigInt类型

BigInt 是一种特殊的数字类型，它提供了对任意长度整数的支持。

1、概述

BigInt 是一个新型的内置类型，主要是为了表达大于 2^53-1 的整数。

我们定义一个 BigInt 类型的数据时有两种方式，第一个是在数字后面加 n，另外一种是调用 BigInt()方法。

let theBigInt = 9007199254740991n;
let alsoHuge = BigInt(9007199254740991); // 9007199254740991n

当用 typeof 对其进行类型判断时，返回的是 bigint。

let theBigInt = 9007199254740991n;
typeof theBigInt; // bigint

2、运算

BigInt 支持以下的运算符，+、*、-、**、% ，并且支持除了>>> （无符号右移）之外的 其他位运算符。

let previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER); // 9007199254740991n
let maxPlusOne = previousMaxSafe + 1n; // 9007199254740992n
let maxMinusOne = previousMaxSafe - 1n; // 9007199254740990n
let multi = previousMaxSafe * 2n; // 18014398509481982n
let mod = previousMaxSafe % 10n; // 1n

值得注意的是，BigInt 是不支持单目+运算符的。

+previousMaxSafe; // Uncaught TypeError: Cannot convert a BigInt value to a number

主要原因还是 BigInt 无法和 Number 类型直接运算，如果想要运算的话必须在同一个类型上，但是有一点值得注意的是，当 BigInt 转为 Number 类型时，有可能会丢失精度。

在比较运算符中，BigInt 和 Nunber 类型的之间不是严格相等的。

10n == 10; // true
10n === 10; // false

Number 和 BigInt 是可以进行比较的。

1n < 2; // true
2n > 1; // true
2n >= 2; // true

3、API

BigInt 拥有两个静态方法：

• BigInt.asIntN(width, bigint)：将 BigInt 值转换为一个-2^width-1 与 2^width-1-1 之间的有符号整数。

• BigInt.asUintN(width, bigint)：将一个 BigInt 值转换为 0 与 2^width-1 之间的无符号整数。

这两个方法均接受两个参数，width：可存储整数的位数。bigint：要存储在指定位数上的整数。

const max = 2n ** (64n - 1n) - 1n;
BigInt.asIntN(64, max); // 9223372036854775807n

const max = 2n ** 64n - 1n;
BigInt.asUintN(64, max); // 18446744073709551615n

同时 BigInt 还拥有三个实例方法：

• BigInt.prototype.toLocaleString()：返回此数字的 language-sensitive 形式的字符串。覆盖 Object.prototype.toLocaleString() 方法。

• BigInt.prototype.toString()：返回以指定基数(base)表示指定数字的字符串。覆盖 Object.prototype.toString() 方法。

• BigInt.prototype.valueOf()：返回指定对象的基元值。 覆盖 Object.prototype.valueOf() 方法。

let bigint = 3500n;
bigint.toLocaleString(); // "3,500"
bigint.toString(); // "3500"
bigint.valueOf(); // 3500n

【相关推荐：javascript视频教程、编程视频】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!