Будучи ребенком, который любит набирать код вручную, я считаю, что код следует набирать самому, чтобы лучше запомнить его наизусть, поэтому сегодня я представлю возможности ES6 ~ ES12. Если у вас есть «слепые пятна» при использовании ES или вы мало что знаете о новых функциях , я считаю, что эта статья сможет вам очень помочь ~

Чтобы лучше понять, мы объясним это в режиме регистра , поэтому чтобы лучше понять, и в то же время корпус также поддерживает отладку в режиме разработчика, я надеюсь, что вы сможете это поддержать ~

ECMAScript

ECMAScript — это язык программирования сценариев, стандартизированный Ecma International (ранее Европейской ассоциацией производителей компьютеров) через ECMA -262 . Также можно сказать, что

в мире программистов в качестве стандарта существуют только две версии JavaScript: ES5 и ES6 . Говорят, что ES6 фактически был выпущен в 2015 году, что также является временем, когда официально началась эра большого фронтенда. То есть в качестве границы используется 2015 год, до 2015 года он назывался ES5 , а после 2016 года — ES6

Информацию о возможностях ES6 можно прочитать в разделе «Введение в стандарты ES6»

Учитель Жуань Ифэн.

Объявление

ES6

let и const

Разница между let, const и var:

• переменные, объявленные var, существуют. Продвижение переменных, в то время как let и const не имеют проблем с продвижением переменных. Продвижение переменной: можно ли вызывать переменную до
• объявления var. Нет области действия на уровне блока, let и const имеют область действия на уровне блока.
• Var может объявлять переменные повторно, let и const не могут быть объявлены повторно в области видимости. , а const объявляет переменные, доступные только для чтения , и им должно быть присвоено значение.

Кроме того, когда объект объявляется с помощью const , свойства объекта могут быть изменены, поскольку: obj, объявленный const, сохраняет только его ссылочный адрес

Пока адрес остается неизменным, ошибки

при деструктуризации не будет.

Деструктуризация

• позволяет
• извлекать значения из массива по порядку и присваивать значения переменным согласно соответствующим позициям. метод принадлежит сопоставлению с образцом и
• может быть деконструирован с использованием ... для представления всех оставшихся
.
• Если в исходном массиве его нет, то соответствующее значение может быть установлено значение по умолчанию, если оно не установлено, оно будет undefined ,

пусть [ а, б, в] = [1, 2, 3]
 console.log(a, b, c) // 1 2 3
 
 пусть [a, , c] = [1, 2, 3]
 console.log(a, , c) // 1 3
 
 пусть [a, b, ...c] = [1, 2, 3, 4, 5]
 console.log(a, b, c) // 1 2 [3, 4, 5]
 
 пусть [a, b, ...c] = [1]
 console.log(a, b, c) // 1 неопределенное []
 
 пусть [a = 1, b = a] = []
 const.log(a, b) // 1 1
 
 пусть [a = 1, b = a] = [2]
 const.log(a, b) // 2 2

Структура объекта

• не имеет порядка. Требуется только, чтобы имя переменной и атрибута было одинаковым,
• если имена атрибутов переменной и объекта не повторяются
.
• , значение переменной будет undefined
• Примечание : ,other Эквивалент псевдонима

let { a, b } = { a: 1, b: 2 };
 console.log(а, б); // 1 2;
 
 пусть {а} = {б: 2};
 console.log(а); // не определено
 
 пусть { a, b = 2 } = { a: 1 };
 console.log(а, б); // 1 2;
 
 пусть {а: б = 2} = {а: 1};
 console.log(a); // Переменная a не существует console.log(b); // 1

Деструктуризация строк Строки

• также можно деконструировать, что эквивалентно преобразованию их в объекты типа массива
• с атрибутом length . , представляющий число

let [a, b, c, d, e] = "привет"
 console.log(a, b, c, d, e) // привет
 
 let { length } = "привет"
 console.log(length) // 5

Деструктуризация чисел и логических значений

• Пока объект или массив не мертв, он сначала преобразуется в объект, поэтому числовые типы и логические типы также преобразуются в объекты

let { toString: с} = 123;
 console.log(s === Number.prototype.toString) // true
 
 пусть {toString: s} = true;
 console.log(s === Boolean.prototype.toString) // истинная

деконструкция параметров функции.

• Параметры функции могут быть деконструированы или иметь
• неопределенное значение по умолчанию.
• Обратите внимание
.
• два метода указания значения по умолчанию. Один — указать переменные, другой — указать параметры, и вы получите разные ответы:

let arr = [[1,2], [3, 4]]
 пусть res = arr.map([a, b] => a + b)
 console.log(res) // [3, 7]
 
 пусть arr = [1, не определено, 2]
 let res = arr.map((a = 'test') => a);
 console.log(res) // [1, 'тест', 2]
 
 пусть func = ({x, y} = {x: 0, y: 0}) => {
    вернуть [х, у]
 }
 console.log(func(1, 2)) // [не определено, не определено]
 console.log(func()) // [0, 0]
 console.log(func({})) // [не определено, не определено]
 console.log(func({x: 1})) // [1, не определено]
 
 
 let func = ({x=0, y=0}) => {
    вернуть [х, у]
 }
 
 console.log(func({x:1,y:2})) // [1, 2]
 console.log(func()) // ошибка
 console.log(func({})) // [0, 0]
  console.log(func({x: 1})) // [1, 0]

Регулярное расширение

на самом деле очень сложный для понимания вопрос. Если кто-то может полностью освоить его, это действительно очень мощно. Давайте упростим его. здесь Прежде всего,

он разделен на два стиля: JS分格и perl 分格

: RegExp()

let re = new RegExp('a'); //Находим, есть ли в строке.
 let re = new RegExp('a', 'i'); //Первый — это объект поиска, второй — опция

perl style:/rule/option, за которой может следовать несколько символов, независимо от порядка.

let re = /a/; //Узнаем, есть ли в строке
 let re = /a/i;//Первый — это объект, который нужно искать, второй — опция.

Здесь мы представляем онлайн-тест регулярных выражений (с общими регулярными выражениями):

Расширение строки

• Unicode :大括号包含символы Юникода
• codePointAt() : возвращает кодовую точку, соответствующую символу, соответствующую fromCharCode()
• String.fromCharCode() : возвращает соответствующую кодовую точку как символ, соответствует codePointAt()
• String.raw() : возвращает символ. Результат замены всех переменных в строке и экранирования косых черт.
• startWith() : Возвращает логическое значение, указывающее, находится ли строка параметра в начале исходной строки.
• EndWith() : возвращает логическое значение, указывающее, находится ли строка параметра в конце исходной строки.
• повтор() : метод возвращает новую строку, что означает повторение исходной строки n раз
• : for-of
• include() : возвращает логическое значение, указывающее, найдена ли строка параметра.
• TrimStart() : метод удаляет пробелы в начале строки. TrimLeft() — это псевдоним этого метода.
• TrimEnd() : метод удаляет пробельные символы из конца строки. TrimRight() — это псевдоним этого метода.

//Юникод
 console.log("a", "u0061"); // аа
 console.log("d", "u{4E25}"); // строго let str = 'Domesy');
 
 //codePointAt()
 console.log(str.codePointAt(0)) // 68
 
 //String.fromCharCode()
 console.log(String.fromCharCode(68)) // D
 
 //Строка.raw()
 console.log(String.raw`Hin${1 + 2}` // Приветn3);
 console.log(`Приветn${1 + 2}` // Привет 3;
 
 let str = 'Домашний'
 
 //начинаетсяс()
 console.log(str.startsWith("D")) // true
 console.log(str.startsWith("s")) // false

 //кончаетсяс()
 console.log(str.endsWith("y")) // true
 console.log(str.endsWith("s")) // false
 
 //repeat(): переданный параметр будет автоматически округлен в большую сторону. Если это строка, он будет преобразован в число console.log(str.repeat(2)) // DomesyDomesy.
 console.log(str.repeat(2.9)) // DomesyDomesy
 
 // Обход: for-of
  for(пусть код str){
    console.log(code) // Возвращаем Domesy один раз
  }
  
  //включает()
  console.log(str.includes("s")) // true
  console.log(str.includes("a")) // ложь
  
  // начало обрезки()
  const string = «Привет, мир!»;
  console.log(string.trimStart()); // «Привет, мир!»
  console.log(string.trimLeft()); // «Привет, мир!»
  
  // обрезкаКонца()
  const string = «Привет, мир!»;
  console.log(string.trimEnd()); // "Привет, мир!"
  console.log(string.trimRight()); // «Привет, мир!»

Другие

шаблоны строк можно вставлять в одну или несколько строк, используйте `

let str = `Dome
    си`
 console.log(str) //Автоматически переносит строки//Купол
 //

шаблон метки sy:

const str = {
     название: 'Маленький Дуду',
     информация: «Всем привет»
 }

console.log(`${str.info}, я `${str.name}`) // Привет всем, я Сяо Дуду

Расширение массива

• Array.of() : Преобразование набора значений в массив и вернуть новый массив, независимо от количества или типа аргументов.
• copyWithin() : копирует элементы из указанной позиции в другие позиции и возвращает исходный массив
• find() : возвращает первое уточненное значение
• findIndex() : возвращает первые квалифицированные индексные
• ключи() : проходит по именам ключей, возвращает объект обхода
,
• который
• можно использовать в цикле for-of
• . пары.
• Array.from() : Создает новый экземпляр массива из объекта, подобного массиву или итерируемого.
• fill() : заполняет массив указанными элементами и возвращает исходный массив .
• include() : определяет, включен ли определенный элемент, и возвращает логическое значение. Это также допустимо для NaN, но не может быть позиционировано

. 1, 2, 3, 4, 5]

 //Массив.of()
 пусть arr1 = Array.of(1, 2, 3);
 console.log(arr1) // [1, 2, 3]
 
 //copyWithin(): три параметра (цель, начало = 0, конец = this.length)
 // цель: позиция цели // начало: начальная позиция, которая может быть опущена и может быть отрицательным числом.
 // end: конечная позиция, может быть опущена, может быть отрицательным числом, фактическая позиция — end-1.
 console.log(arr.copyWithin(0, 3, 5)) // [4, 5, 3, 4, 5]
 
 //находить()
 console.log(arr.find((item) => item > 3 )) // 4
 
 //найтиИндекс()
 console.log(arr.findIndex((item) => item > 3 )) // 3
 
 //ключи()
 for (пусть индекс arr.keys()) {
     console.log(index); // Возвращаем 0 1 2 3 4 за раз
 }
 
 // ценности()
 for (пусть индекс arr.values()) {
     console.log(index); // Возвращаем 1 2 3 4 5 за раз
 }
 
 // записи()
 for (пусть индекс arr.entries()) {
     console.log(index); // Возвращаем [0, 1] [1, 2] [2, 3] [3, 4] [4, 5] один раз
 }
 
  пусть arr = [1, 2, 3, 4, 5]
 
 // Array.from(): Обход может быть псевдомассивом, таким как String, Set структура, Node node let arr1 = Array.from([1, 3, 5], (item) => {
     вернуть товар * 2;
 })
 console.log(arr1) // [2, 6, 10] 
 
 // fill(): три параметра (цель, начало = 0, конец = this.length)
 // цель: позиция цели // начало: начальная позиция, которая может быть опущена и может быть отрицательным числом.
 // end: конечная позиция, может быть опущена, может быть отрицательным числом, фактическая позиция — end-1.
 console.log(arr.fill(7)) // [7, 7, 7, 7, 7]
 console.log(arr.fill(7, 1, 3)) // [1, 7, 7, 4, 5]
 
 пусть arr = [1, 2, 3, 4]
 
 //включает()
 console.log(arr.includes(3)) // правда
 console.log([1, 2, NaN].includes(NaN)); // true

другие

операторы расширения:...

// Его функция — расширить массив let arr = [3, 4, 5]
 console.log(...arr) // 3 4 5
 
 пусть arr1 = [1, 2, ...arr]
 console.log(...arr1) // 1 2 3 4 5

Расширение объекта

• Object.getPrototypeOf() : возвращает объект-прототип объекта
• Object.setPrototypeOf() : устанавливает объект-прототип объекта
• proto : возвращает или устанавливает объект-прототип объекта
• Object .getOwnPropertyNames()
: возвращает массив ключей свойств, не являющихся символами, самого объекта.
• Object.getOwnPropertySymbols
• () : возвращает массив ключей свойств, не являющихся символами, самого объекта.
• : Возвращает массив всех ключей свойств самого объекта.
• Object.is() : Определяет, равны ли два объекта. Адреса, на которые указывают массивы, различны, поэтому, пока это сравнение массивов, оно должно быть ложным. .
• Обход: for-in
• Object.keys() : Возвращает имя атрибута
• Object.assign() : Используется для присвоения всех перечислимых элементов. Скопируйте значение атрибута из одного или нескольких исходных объектов в целевой объект и верните целевой объект . на этот раз целевой объект также изменится

//Object.is()
console.log(Object.is('abc', 'abc')) // true
console.log(Object.is([], [])) // ложь 

//Обход: for-in
let obj = { name: 'Domesy', value: 'React' }

for(введите ключ в obj){
    console.log(key); // Возвращаем значение имени атрибута по очереди
    console.log(obj[key]); // Возвращаем значения атрибутов по порядку Domesy React
}

//Объект.ключи()
console.log(Object.keys(obj)) // ['имя', 'значение']

 //Объект.назначить()
 константная цель = {а: 1, б: 2};
 константный источник = {б: 4, с: 5};
 
 const result = Object.assign(цель, источник)
 
 console.log(result) // {a: 1, b: 4, c: 5}
 console.log(target) // {a: 1, b: 4, c: 5}

другие

краткие выражения

let a = 1;
  пусть б = 2;
  пусть obj = { a, b }
  console.log(obj) // { a: 1, b: 2 }
  
  пусть метод = {
      привет() {
          console.log('привет')
      }
  }
  console.log(method.hello()) // выражение атрибута приветствия

: напрямую используйте переменные или выражения для определения ключа объекта

let a = "b"
 пусть объект = {
     [а]: «с»
 }
 

Оператор расширения

{b : "c"}

• добавляет множество дополнительных функций в ES9 , таких как слияние, экранирование строк и т. д.

// Его функция — расширение массива let { a, b , ...c } = { а: 1, б: 2, в: 3, д: 4};
 console.log(c) // {c: 3, d: 4}
 
 пусть obj1 = { c: 3 }
 пусть obj = { a: 1, b: 2, ...obj1}
 console.log(obj) // { a: 1, b: 2, c: 3}

Расширенный

• двоичный формат : начиная с 0b или 0B , что указывает на двоично-
• восьмеричный код: начиная с 00 или 0O , что указывает на двоичный код
• Number.isFinite() : используется чтобы проверить, ограничено ли значение, возвращает логическое значение.
• Number.isNaN() : используется для проверки того, является ли значение NaN, возвращает логическое значение.
• Number.isInteger() : используется для проверки, является ли значение целым числом, возвращает логическое значение. value
• Number.isSafeInteger() : используется для проверки того, является ли значение «безопасным целым числом», возвращает логическое значение.
• Math.cbrt() : возвращает куб и
• Math.abrt()() : возвращает куб и
• Math.cbrt( ) : Возвращает куб и
• Math .clz32() : Возвращает 32-битное целое число без знака
• Math.imul() : Возвращает произведение двух значений
• Math.fround() : Возвращает 32-битное однозначное значение
.
• точная форма значения с плавающей запятой
• Math.hypot() : Возвращает все Квадратный корень из суммы квадратов значений
• Math.expm1() : Возвращает e^n - 1
• Math.log1p() : Возвращает натуральное значение. логарифм 1 + n (Math.log(1 + n))
• Math.log10() : Возвращает натуральный логарифм 1 + n Логарифм n с основанием 2
• Math.log2() : Возвращает логарифм n с основанием 2
• Math.trunc() : удаляет десятичную часть числа, оставляя только целую часть.
• Math.sign() : возвращает正数为1 ,负数为-1 ,正零0 ,负零-0 , NaN
• Math.abrt() : Возвращает корень куба
• Math.sinh() : Возвращает гиперболический синус
• Math.cosh() : Возвращает гиперболический косинус
• Math.tanh() : Возвращает гиперболический тангенс
• Math.asinh() : Возвращает обратный гиперболический синус
• Math.acosh() : Возвращает обратный гиперболический косинус
• Math.atanh() : Возвращает обратный гиперболический тангенс
• Number.parseInt() : Возвращает целое число значения Part, этот метод эквивалентен parseInt
• Number.parseFloat() : Возвращает часть значения с плавающей запятой, этот метод эквивалентен parseFloat

//Двоичный файл console.log(0b101) // 5
 console.log(0o151) //105
 
 //Число.isFinite()
 console.log(Number.isFinite(7)); // правда
 console.log(Number.isFinite(истина)); // ложь
 
 //Число.isNaN()
 console.log(Number.isNaN(NaN)); // правда
 console.log(Number.isNaN("истина" / 0)); // правда
 console.log(Number.isNaN(истина)); // ложь
 
 //Число.isЦелое()
 console.log(Number.isInteger(17)); // правда
 console.log(Number.isInteger(17.58)); // ложь
 
 //Number.isSafeInteger()
 console.log(Number.isSafeInteger(3)); // правда
 console.log(Number.isSafeInteger(3.0)); // правда
 console.log(Number.isSafeInteger("3")); // ложь
 console.log(Number.isSafeInteger(3.1)); // ложь
 
  //Математика.trunc()
 console.log(Math.trunc(13.71)); // 13
 console.log(Math.trunc(0)); // 0
 console.log(Math.trunc(истина)); // 1
 console.log(Math.trunc(false)); // 0 
 
 //Математика.sign()
 console.log(Math.sign(3)); // 1
 console.log(Math.sign(-3)); // -1;
 console.log(Math.sign(0)); // 0
 console.log(Math.sign(-0)); // -0);
 console.log(Math.sign(NaN)); // NaN;
 console.log(Math.sign(true)); // 1
 console.log(Math.sign(false)); // 0
 
 //Математика.abrt()
 console.log(Math.cbrt(8)); // 2
 
  //Число.parseInt()
 console.log(Number.parseInt("6.71")); // 6
 console.log(parseInt("6.71")); // 6
 
 //Number.parseFloat()
 console.log(Number.parseFloat("6.71@")); // 6.71
 console.log(parseFloat("6.71@")); // 6.71

• Запятая в конце параметра функции: разрешите последнему параметру функции иметь
• завершающую запятую. Параметру по умолчанию присваивается определенное значение
.

//По умолчанию параметру присваивается определенное значение.
 функция fun(x, y = x){
    консоль.log(х, у)
 }
 функция fun1(c, y = x){
    console.log(c, x, y)
 }
 веселье(2); //2 2;
 fun1(1); //1 1 1

другие

остальные параметры (оператор расширения...)

function fun(...arg){
   console.log(arg) // [1, 2, 3, 4]
 }
 
 

Стрелочная функция

fun(1, 2, 3, 4)

• определяется как =>

let стрелка = (v) => v + 2
 console.log(arrow(1)) // 3

Разница между стрелочными функциями и обычными функциями.

• Стили стрелочных функций и обычных функций различаются. Синтаксис стрелочных функций => определенных функций. , а обычные функции — это функции, определяемые функцией.
• У Set нет ключей, только значения. Можно считать, что ключи и значения одинаковы
• . Стрелочные функции на самом деле этого не имеют. Это зависит только от this первой обычной функции, которая оборачивает стрелку. функция.
• Стрелочные функции не имеют собственных аргументов. Доступ к аргументам стрелочной функции фактически позволяет получить значение во внешней локальной (функциональной) среде выполнения.
• вызов, применение и привязка не повлияют на направление этого процесса.
• This функции стрелки указывает на контекст , но this обычной функции не указывает на контекст. Добавить привязку (this), когда это необходимо.

Set

Set — это новая структура данных в ES6, которая похожа на массив. но значение члена уникально и нет повторяющихся

объявлений значений: const set = new Set()

Атрибуты:

• size : Возвращает количество значений в объекте Set.

Метод:

• add() : Добавляет элемент в объект. конец объекта Set. Возвращает объект Set
• delete() : удаляет элементы Set, равные этому значению, возвращает true, если они есть, в противном случае возвращает false.clear
• () : очищает все элементы Set
• has() : существует ли это значение, если да, то в противном случае — ложь.keys
• () : объект итератора со значениями атрибутовvalues
• () : объект итератора со значениями атрибутовentries
• () : объект итератора со значениями атрибутов и
• значениями
атрибутов
• forEach() : перебирать каждый элемент

отдельно. Примечание.

• Траверсер является объектом iterator . В порядке вставки
• значение, добавляемое в набор в форме [Key, Value], не подвергается преобразованию типа, поэтому 1 и «1». " - это два разных значения
• . Внутри Set они передаются === Чтобы судить, то есть два объекта никогда не могут быть одинаковыми, потому что адреса разные.
• Единственная разница - NaN

let list = new Set()
 
 //добавлять()
 список.добавить("1")
 список.добавить(1)
 консоль(список) // Set(2) {1, "1"}
 
 //размер
 консоль(список.размер) // 2
 
 //удалить()
 список.delete("1")
 консоль(список) // Установить(1) {1}
 
 //имеет()
 list.has(1) // правда
 list.has(3) // ложь
 
 //прозрачный()
 список.очистить()
 консоль(список) // Set(0) {}
 
 let arr = [{id: 1}, {id: 2}, {id: 3}]
 let list = новый набор (arr)
 
 //ключи()
 for (пусть ключ list.keys()) {
    console.log(key); // Распечатываем это: {id: 1} {id: 2} {id: 3}
 }
 
 //ценности()
 for (пусть ключ list.values()) {
    console.log(key); // Распечатываем это: {id: 1} {id: 2} {id: 3}
 }
 
 //записи()
 for (пусть данные list.entries()) {
    console.log(data); // Распечатываем это: [{id: 1},{id: 1}] [{id: 2},{id: 2}] [{id: 3},{id: 3 } ]
 }
 
 //длякаждого
 list.forEach((item) => {
    console.log(item)//Распечатайте это: {id: 1} {id: 2} {id: 3}
 });

Применение:

Дедупликация массива.

• Следует отметить, что new Set не может удалять объекты

. неопределенное, ноль, ноль, NaN, NaN, 'NaN', 0, 0, 'a', 'a'];
 
 console.log([...новый набор(arr)]) 
 //или console.log(Array.from(new Set(arr)))
 // [1, 'истина', правда, 15, ложь, неопределенное, ноль, NaN, 'NaN', 0, 'a']

может найти объединение, пересечение и разность

let a = new Set([1, 2 , 3])
 пусть b = новый набор ([2, 3, 4])
 
 //Union console.log(new Set([...a, ...b])) // Set(4) {1, 2, 3, 4}
 
 //Пересечение console.log(new Set([...a].filter(v => b.has(v)))) // Set(2) {2, 3}
 
 

Набор сопоставлений

Set(1) {1}

let set = new Set([1,2, 3])
 console.log(new Set([...set].map(v => v * 2))) // Set(3) {2, 4, 6}

WeakSet

: та же структура, что и Set, но член значения могут

быть объявлены только для объекта: const set = new WeakSet()

метод WeakSet():

• add() : добавить элемент в конец объекта WeakSet. Вернуть экземпляр
• delete() : удалить элемент в WeakSet, равный этому значению,
• has() : существует ли это значение, если оно существует, оно истинно, в противном случае оно ложно.

Примечание.

• Объекты членов WeakSet. все это слабые ссылки, то есть сборка мусора. Механизм не учитывает применение объекта. Проще говоря ,
• преимущество объектов WebSet, которые невозможно пройти, заключается в том, что при удалении экземпляра не будет утечек памяти.

Индекс рекомендаций

карты

Карта — это новая структура данных в ES6, которая представляет собой аналогичный объект. ключ — это объявление значения любого типа

: const map = new Map()

Атрибуты Map():

• конструктор : конструктор, возвращает
• Размер карты: возвращает количество значений в экземпляре карты.

Метод:

• set() : добавляет пару ключ-значение после Карта, возвращает экземпляр
• get() : возвращает значение ключа. Для
• delete() : удалите элементы карты, равные этому значению, верните true, если таковые имеются, в противном случае верните false.clear
• () : очистите все элементы карты. Map
• has() : существует ли это значение, если оно существует, оно истинно, в противном случае — ложное.keys
• () : объект обходчика с ключами атрибутовvalues
• () : объект обходчика со значениями атрибутовentries
• () : объект обходчика с ключами атрибутов и значениями атрибутов
• forEach() : обходит каждый элемент.

Специальное примечание:

• ссылки на один и тот же объект рассматриваются как
• ключи с тем же ключом и будут перезаписаны.

let map = new Map()
 
 //набор()
 map.set('а', 1)
 map.set('b', 2)
 console.log(map) // Map(2) {'a' => 1, 'b' => 2}
 
 //получать
 map.get("а") // 1
 
 //размер
 console.log(map.size) // 2
 
 //удалить()
 map.delete("a") // правда
 console.log(map) // Map(1) {'b' => 2}
 
 //имеет()
 map.has('b') // правда
 map.has(1) // ложь
 
 //прозрачный()
 карта.очистить()
 console.log(карта) // Карта(0) {}
 
 let arr = [["a", 1], ["b", 2], ["c", 3]]
 пусть карта = новая карта (обр.)
 
 //ключи()
 for (let key of map.keys()) {
    console.log(key); // Распечатаем это: abc
 }
 
 //ценности()
 for (пусть значение map.values()) {
    console.log(value); // Распечатаем это: 1 2 3
 }
 
 //записи()
 for (пусть данные map.entries()) {
    console.log(data); // Распечатываем это: ["a", 1] ["b", 2] ["c", 3]
 }
 
 //длякаждого
 map.forEach((item) => {
    console.log(item)//Распечатайте это: 1 2 3
 });

WeakMap

: и структура карты, но значения членов могут

быть объявлены только для объектов: const set = new WeakMap()

метод:

• set() : добавить пары ключ-значение, вернуть экземпляры
• get() : вернуть ключ- пары значений
• delete() : удалить пару ключ-значение. Если оно существует, оно истинно. В противном случае
• оно имеет значение false. has() : если оно существует, оно истинно.

Символ (исходный тип)

Символ — это примитивный тип данных, представленный в ES6, который представляет独一无二Объявление

: const sy = Stmbol()

Параметры: строка (необязательно).

Метод:

• Символ.for() : Создайте Symbol值описанное параметрами. этот параметр существует, верните исходное Symbol值(сначала выполните поиск, а затем создайте, зарегистрировано в глобальной среде).
• Символ.keyFor() : возвращает описание зарегистрированного Symbol值(может быть возвращен только key Symbol.for() ).
• Object.getOwnPropertySymbols() : возвращает массив всех Symbol值используемых в качестве имен свойств в объекте

// Объявить let a = Symbol();
 пусть b = Символ();
 console.log(a === b // ложь);
 
 //Символ.для()
 let c = Symbol.for("domesy");
 let d = Symbol.for("domesy");
 console.log(c === d // true);
 
 //Символ.keyFor()
 const e = Symbol.for("1");
 console.log(Symbol.keyFor(e)); // 1
 
 //Символ.описание
 пусть символ = Символ("эс");
 console.log(symbol.description); //es
 console.log(Symbol("es") === Символ("es")); // false
 console.log(symbol === символ // true);
 console.log(symbol.description === "es"); // true

Proxy

Прокси используется для изменения поведения определенных операций по умолчанию, что эквивалентно внесению изменений на уровне языка, поэтому это своего рода «мета». программирование"), то есть программирование на языке программирования

можно понимать именно так. Прокси — это уровень拦截установленный перед целевым объектом. Внешний мир должен пройти через этот уровень перехвата, если хочет получить к нему доступ. Следовательно, предусмотрен механизм фильтрации и фильтрации доступа из внешнего мира.

Здесь прокси можно понимать代理器

объявление прокси: const proxy = new Proxy(target, handler)

• target : обработчик перехваченного объекта
• : определяет

метод перехвата:

• get() : перехватывает чтение атрибутов объекта
• set() : перехватывает настройку объекта Свойства , возвращает логическое значение
• has() : перехватывает операцию propKey в прокси, возвращает логическое значение
• ownKeys() : перехватывает обход свойств объекта, возвращает массив
• deleteProperty() : перехватывает операцию удаления proxy[propKey], возвращает логическое значение value ()
• apply() : Перехват вызовов функций, вызов и применение операций.struct
• () : Перехват новой команды, возврат объекта: Перехват новой команды, возврат объекта

let obj = {
  имя: 'домашний',
  время: '27.01.2022',
  значение: 1
 }
 
 пусть данные = новый прокси (obj, {
     //получать()
     получить (цель, ключ) {
         return target[key].replace("2022", '2015')
     },
     
     //набор()
     set(цель, ключ, значение) {
        если (ключ === "имя") {
           возврат (цель [ключ] = значение);
        } еще {
           вернуть цель [ключ];
         }
     },
     
     // имеет()
    имеет (цель, ключ) {
        если (ключ === "имя") {
            вернуть цель [ключ];
        } еще {
            вернуть ложь;
        }
    },
    //удалитьсвойство()
    deleteProperty(цель, ключ) {
        если (key.indexOf("_") > -1) {
            удалить цель[ключ];
            вернуть истину;
        } еще {
            вернуть цель [ключ];
        }
    },
    // собственныеКлючи()
    ownKeys (цель) {
        return Object.keys(target).filter((item) => item != "time");
    },
 })
 
 console.log(data.time) // 27.01.2015
 
 данные.время = '2020'
 data.name = 'Реагировать'
 console.log(data) //Прокси {имя: 'React', время: '2022-01-27', значение: 1}
 
 //Перехват имеет()
 console.log("имя" в данных) // true
 console.log("время" в данных) // false
 
 // Удалить deleteProperty()
 удалить данные.время // правда;
 
 // Обходим ownKeys()
 console.log(Object.keys(data)); //['имя', 'значение']

 //применять()
 пусть sum = (...args) => {
    пусть число = 0;
    args.forEach((item) => {
        число += элемент;
    });
    вернуть число;
 };

 сумма = новый прокси(сумма, {
    применить (цель, ctx, args) {
        return target(...args) * 2;
    },
 });
 
 console.log(сумма(1, 2)); // 6
 console.log(sum.call(null, 1, 2, 3)); // 12
 console.log(sum.apply(null, [1, 2, 3])); // 12
 
 //конструктор()
 пусть Пользователь = класс {
    конструктор(имя) {
        это.имя = имя;
    }
 }
 Пользователь = новый прокси(Пользователь, {
    конструкция (цель, аргументы, newTarget) {
        вернуть новую цель(...args);
    },
  });
 console.log(new User("domesy")); // User {name: 'domesy'}

Reflect

Reflect похож на Proxy, за исключением того, что он сохраняет поведение Object по умолчанию и

• заменяет некоторые методы объекта Object, которые, очевидно, внутренний для языка (например, Object. defineProperty) и поместите его в объект Reflect.
• На этом этапе некоторые методы развертываются как на объектах Object, так и на объектах Reflect. В будущем новые методы будут развернуты только на объектах Reflect,
• чтобы изменить возвращаемые результаты некоторых методов Object, чтобы сделать их более разумными. Например, Object.defineProperty(obj, name, desc) выдаст ошибку, если свойство не может быть определено, а Reflect.defineProperty(obj, name, desc) вернет false,
• чтобы превратить операцию Object в функциональное поведение

Reflect

и методы Proxy соответствуют один в один, поэтому мы не будем вводить их здесь.

Класс

: абстракция класса вещей с общими характеристиками (синтаксис конструктора),

базовое определение конструктора () и сгенерированный экземпляр

класса Parent {.
     конструктор(имя = 'es6'){
         это.имя = имя
     }
 }
 let data = новый родитель('domesy')
 console.log(data) // Parent { name: 'domesy'}

расширяет наследует

класс Parent {
     конструктор(имя = 'es6'){
         это.имя = имя
     }
 }
 
 // Обычный класс наследования Child расширяет Parent {}
 console.log(new Child()) // Дочерний элемент { name: 'es6'} 
 
 // Передача параметров class Child расширяет Parent {
    конструктор(имя = "ребенок") {
        супер(имя);
        this.type = "ребенок";
    }
 }
 console.log(new Child('domesy')) // Child { name: 'domesy', type: 'child'}

getter и setter

• более важны и часто используются для инкапсуляции API
• get и set
.
• атрибуты, а не

класс метода Parent {
     конструктор(имя = 'es6'){
         это.имя = имя
     }
     // геттер
     получить getName() {
         вернуть 'sy' + this.name
     } 
     // установщик
     установить setName(значение){
         это.имя = значение
     }
 }
 
 пусть данные = новый родитель()
 console.log(data.getName) // syes6
 
 data.setName = 'домашний'
 console.log(data.getName) // домашний

статический статический метод

• Статический метод не может быть вызван для экземпляра класса, но его следует вызывать через сам класс

class Parent {
     статический getName = (имя) => {
         вернуть `Привет! ${имя}`
     }
 }
 
 console.log(Parent.getName('domesy')) // Привет!

статических свойств

Domesy

Parent {}
 Родитель.тип = "тест";
 
 console.log(Parent.type); //тестовое

обещание.

Promise решить проблему «ада обратных вызовов». Оно может сделать обработку асинхронных операций очень элегантной.

Promise может поддерживать несколько одновременных запросов и получать данные в одновременных запросах. Это Promise может решить асинхронную проблему. Само по себе Promise нельзя назвать асинхронным

определением: Статус объекта, содержащий результаты асинхронной операции

:

• в ожидании: [ожидание] Исходное состояние
• выполнено: [Реализация] Операция успешно
• отклонена: [Отклонено] Операция не удалась

. Примечание.

• Promise определит, какой метод выполнить, на основе состояния
• . При создании экземпляра Promise состояние по умолчанию является ожидающим. Если асинхронное состояние является ненормальным, в противном случае оно отклоняется.
• переход состояния является односторонним и необратимым , определенное состояние (выполнено/отклонено) не может быть переведено обратно в исходное состояние (ожидание) и может переходить только от состояния ожидания к выполнению или отклонению.

Базовое использование

//Нормальное определение let ajax = ( обратный вызов) => {
     console.log('≈')
     setTimeout(() => {
         обратный вызов && callback.call();
     }, 1000)
 } 
 аякс(() => {
     console.log('тайм-аут')
 })
 // Сначала он будет напечатан для начала выполнения, затем через 1 с будет напечатан тайм-аут.
 
 //Обещать
 пусть ajax = () => {
    console.log("Начать выполнение");
    вернуть новое обещание((разрешить, отклонить) => {
        setTimeout(() => {
            решать();
        }, 1000);
    });
 };
 ajax().then(() => {
    console.log("Тайм-аут"); 
 });
 // Сначала он будет напечатан для начала выполнения, затем через 1 с будет напечатан тайм-аут.
 
 //затем()
 пусть ajax = () => {
    console.log("Начать выполнение");
    вернуть новое обещание((разрешить, отклонить) => {
        setTimeout(() => {
            решать();
        }, 1000);
    });
 };
 аякс()
 .then(() => {
     вернуть новое обещание((разрешить, отклонить) => {
        setTimeout(() => {
            решать();
        }, 2000);
    });
 })
 .then(() => {
     console.log("тайм-аут")
 })
 // Сначала он будет введен для начала выполнения, затем будет введен таймаут через 3 секунды (1+2)
 
 // ловить()
 пусть ajax = (num) => {
    console.log("Начать выполнение");
    вернуть новое обещание((разрешить, отклонить) => {
        если (число > 5) {
            решать();
        } еще {
            throw new Error("Произошла ошибка");
        }
    });
 };
 
 аякс(6)
 .then(функция () {
    console.log("timeout"); // Сначала начнется выполнение, затем через 1 с будет напечатан таймаут
 })
 .catch(функция (ошибка) {
    console.log("поймать", ошибка);
 });
 
  аякс(3)
 .then(функция () {
    console.log("Тайм-аут"); 
 })
 .catch(функция (ошибка) {
    console.log("catch"); // Сначала начнем выполнение, а затем перехватим через 1 с.
 });

Promise.all() Пакетная операция

• Promise.all(arr) используется для упаковки нескольких экземпляров обещания в новый экземпляр обещания. Возвращаемый экземпляр представляет собой обычное обещание,
• которое получает массив в качестве параметра.
• Массив может. Объект обещания, или это может быть другие
• значения
• .
• Обещание не удается, и возвращаемое значение является первым

.
     вернуть новое обещание (Resolve, dresect) => {
        let img = document.createElement ("img");
        img.src = src;
        img.onload = function () {
                Resolve (IMG);
        };
        img.onerror = function (err) {
                отклонить (err);
        };
    });
 }
 
 const showimgs = (imgs) => {
     imgs.foreach ((img) => {
         document.body.appendchild (img);
     })
 }
 
 Обещание. Все ([[[[[[[[[[[[[[[[[[[[[[[[
    LoadImg ("https://ss0.baidu.com/7po3dsag_xi4khgko9wtanf6hhy/zhidao/pic/item/71cf3bc79f3df8dcc65551159cd11728b46102889.jpg")
    LoadImg ("https://ss0.baidu.com/7po3dsag_xi4khgko9wtanf6hhy/zhidao/pic/item/71cf3bc79f3df8dcc65551159cd11728b46102889.jpg")
    LoadImg ("https://ss0.baidu.com/7po3dsag_xi4khgko9wtanf6hhy/zhidao/pic/item/71cf3bc79f3df8dcc65551159cd11728b46102889.jpg")
 ]. Тогда (

Showimgs

)

• ;

{
    вернуть новое обещание (Resolve, dresect) => {
       let img = document.createElement ("img");
       img.src = src;
       img.onload = function () {
               Resolve (IMG);
       };
       img.onerror = function (err) {
               отклонить (err);
       };
   });
}

const showimgs = (imgs) => {
   let p = document.createElement ("p");
   P.AppendChild (IMG);
   document.body.appendchild (p);
}

Обещание.
   LoadImg ("https://ss0.baidu.com/7po3dsag_xi4khgko9wtanf6hhy/zhidao/pic/item/71cf3bc79f3df8dcc65551159cd11728b46102889.jpg")
   LoadImg ("https://ss0.baidu.com/7po3dsag_xi4khgko9wtanf6hhy/zhidao/pic/item/71cf3bc79f3df8dcc65551159cd11728b46102889.jpg")
   LoadImg ("https://ss0.baidu.com/7po3dsag_xi4khgko9wtanf6hhy/zhidao/pic/item/71cf3bc79f3df8dcc65551159cd11728b46102889.jpg")
]. Затем (

• ShowiMgs
• )

;

• Функции и ошибки, которые проводят обещание, не будут отражать,
• как внешнее обещание выполняется внутри. Должен быть завершенным)

генератора

,

функция, которую можно использовать для управления итератором , также является асинхронным программным решением, которое инкапсулирует несколько внутренних состояний

• .
В рамках
• done value
• value объект done
• завершен)
• Далее используется для恢复выполнения
• программы

.
     уступить "A";
     урожай "B";
     вернуть "c"
 }
 
 let Generator = data ();
 console.log (Generator.next ()) // {value: 'a', dode: false} 
 console.log (Generator.next ()) // {value: 'b', Dode: false} 
 console.log (Generator.next ()) // {value: 'c', dode: true} 
 console.log (generator.next ()) // {value: undefined, ded: true}

итератор итератор

итератор - это интерфейс, который обеспечивает единый механизм доступа для различных структур данных. Пока любая структура данных развертывает интерфейс итератора, она может завершить операцию обхода (то есть обрабатывать все члены структуры данных в последовательности).

Функции итератора:

• во -первых, он обеспечивает унифицированный и простой интерфейс доступа для различных структур данных
• ,
• чтобы члены структуры данных могли быть организованы в определенном порядке.
• Главным образом для ... для
• упорядочения потребления на обход: различные двигатели согласились с тем, как итерация свойств, таким образом, стандартизируя поведение ES11

Примечание:

• в ES6 некоторые структуры данных имеют границу итератора назначно (например, массивы), то есть, то есть, то есть, то есть Без какой-либо обработки может быть пройденна a для ... цикла, но некоторые не могут (например
• 数组Map结构Set某些类似数组的对象Map结构.
• Пример добавления интерфейса итератора к объекту.

// в основном используйте lem arr = ["hello", "world"];
 let Map = arr [symbol.iterator] ();
 console.log (map.next ());
 console.log (map.next ());
 console.log (map.next ());
 
 // для петли пусть arr = ["hello", "world"];
 для (let value of arr) {
    Console.log (значение);
 }
 
 // Обработка объекта пусть obj = {
     Начало: [1, 5, 2],
     Конец: [7, 9, 6],
     [Символ.итератор](){
         Пусть индекс = 0;
         Пусть arr = this.start.concat (this.end)
         возвращаться {
             следующий(){
                 if (index <arr.length) {
                     возвращаться {
                         значение: arr [index ++],
                         Сделано: ложь
                     }
                 }еще{
                     возвращаться {
                         значение: arr [index ++],
                         сделано: правда
                     }
                 }
             }
         }
     }
 }
 для (пусть ключ OBJ) {
    Console.log (ключ);
 }

Декораторы декораторы

для

• core-decorators
• @ изменения поведения класса.

     target.name = "domesy"
 }
 
 @имя
 Класс Тест {}
 
 

Модуляризация

Domesy

В первые годы это был общий метод для использования немедленных функций выполнения для достижения

модуляризации Использование модуляризации:

• решающие конфликты именования
• обеспечивают повторные возможности
• и улучшение решений по обслуживанию кода

:

• Commonjs : для серверов (динамические зависимости)
• AMD : для браузеров (динамические зависимости, редко используются)
CMD: для браузеров (динамические зависимости, редко используются)
• UMD : используется для браузеров: для браузеров
• ( динамические зависимости, редко используются).
• и серверы (динамические зависимости)
• ESM : используется для браузеров и серверов (статические зависимости)

Экспорт экспорта модуля экспорта

• по
умолчанию:
• экспорт
• export default Index
• {name, value, id} '
• renamed export: export { name as newName }

импорт импорт импорт

• импорт (рекомендуется): import Index from './Index'
• Общий импорт: import * as Index from './Index'
• по требованию
Импорт (
• Рекомендуется
• ): import { name, value, id } from './Index'
• Переименованное импорт: import { name as newName } from './Index'
• самостоятельный импорт: import './Index'
• ): import Index, { name, value, id } from './Index'

export命令и import命令объединяется и записана в одной строке

.

Интерфейс, в результате чего текущий модуль не может напрямую использовать свои импортные

• переменные
• .

'

• ./index'
Импорт
• и
• экспорт по делту

Расширение массива

• включает () : добавлен один на основе индекса ES6, представляющий, где найти ES7

LET ARR = [1, 2, 3, 4]
 
 // Включает () ES6
 console.log (arr.includes (3)) // true
 Console.log ([1, 2, NAN]. Includes (NAN));
 
 // Включает () ES7
 console.log (arr.includes (1, 0)) // true
 Console.log (arr.includes (1, 1)) // Файлсферный

расширенной

• энергии : используйте ** для представления Math.pow()

// Оператор питания ES7
 Console.log (Math.Pow (2, 3)) // 8
 Console.log (2 ** 8) // 256

ES8

Расширение передачи символов

• () : используется для завершения головы
• Padend () : используется для завершения хвоста.

Пусть str = 'domesy'
 
 // padstart (): будет ли он заполнен в виде пространств? "0"));
 Console.log ("8-27" .padstart (10, "yyyy-0M-0D");
  
 

что

• (
• )

console.log ("1" .padend (2, "0"));

• Возвращает массив имен атрибутов и значений атрибутов

let obj = {name: 'domesy', value: 'React'}

//Object.values ​​()
console.log (object.values ​​(obj)) // ['React', 'React']

//Object.Entries ()
Console.log (object.Entries (obj)) // [['name', 'value'], ['React', 'React']]

Async Await

Функция: изменить асинхронную функцию на синхронную функцию (синтаксический сахар генератора)

const func = async () => {
    Пусть обещание = новое обещание ((Resolve, Dize) => {
    setTimeout(() => {
          Resolve ("выполнить");
        }, 1000);
    });
     
      console.log (ожидая обещания);
      console.log (ждать 0);
      console.log (wait resport.resolve (1));
      консоль.журнал(2);
      return promise.resolve (3);
 }
 
 func (). Тогда (val => {
      console.log (val);
 

}

)

• forEach()
• Promise then
• ​

Async

• async/await for-of Promise.all()
• try catch reject

Есть две ситуации: это объект обещания

. Это не прозвена, как и в результате выражения.

Если он ждет объекта Promise, wawait также приостановит код за Async, сначала выполните код синхронизации снаружи Async, дождитесь выполнения объекта обещания, а затем используйте параметры разрешения в качестве результата операции выражения ожидания.

недостатки Async Watch и обещают

:

он
• достигает
• истинного
• серийного синхронного письма, а код относительно легко читать.

ясность

• кода улучшается

• . , заставляя код потерять параллелизм.

Расширение передачи символа

ES9

• ослабляет ограничения на выезд из строки в шаблонах тегов : undefined возвращается, когда встречается нелегальное выброс строки, а исходная строка может быть получена из raw .

// расслаблять ограничения строки const test = (value) => {
     console.log (значение)
 }
 

• '

domesy

', raw: [" domesy "]]

обещание обещание

.

     вернуть новое обещание ((res, rej) => {
         setTimeout(() => {
             if (время <500) {
                 res (время)
             }еще{
                 rej (время)
             }
         }, время)
     })
 }
 
 Веселье (300)
 .then ((val) => console.log ('res', val)))
 .catch ((erro) => console.log ('rej', erro))
 .finally (() => console.log ('закончил'))
 // Результат выполнения: res 300 завершен Func (700)
 .then ((val) => console.log ('res', val)))
 .catch ((erro) => console.log ('rej', erro))
 .finally (() => console.log ('закончил'))
 // Результат выполнения: REJ 700 Завершен

для того, чтобы навсеивать

, асинхронные итератор, цикл ожидает, пока каждый Promise对象станет resolved状态прежде чем вступить в следующий шаг,

пусть getTime = (seconds) => {
     вернуть новое обещание (res => {
         setTimeout(() => {
             res (секунды)
         }, секунды)
     })
 }
 
Async Function Test () {
    Пусть arr = [gettime (2000), gettime (500), gettime (1000)]
    для ожидания (пусть x arr) {
        console.log (x); 
    }
}

test () // Выполнить 2000 500 1000

ES10

Расширение передачи символов

• json.stringify () : можно вернуть строки, которые не соответствуют стандартам UTF-8 (U+2028 и U+2029 могут быть введены непосредственно)

//JSON.Stringify ( ) Обновление консоли.log (json.stringify (" ud83d  ude0e")); 
 

• (

"

 u {d800}"));

• (Примечание. Это почти то же самое, что и карта, за которой следует плоская с значением глубины 1, но плоская карта обычно немного более эффективна при объединении в один метод.)
• Плоский : метод рекурсивно проходит массив на определенную глубину и объединяет все Элементы объединяют его с элементами в пересеченной поджале, чтобы сформировать новый массив и вернуть его. По умолчанию 1. (Приложение: сглаживание массива (автоматически решается до дна при введении Infinity )).

Пусть Arr = [1, 2, 3, 4]
 
 // flatmap ()
 Console.log (arr.map ((x) => [x * 2]));
 console.log (arr.flatmap ((x) => [x * 2]);
 console.log (arr.flatmap ((x) => [[x * 2]));
 
 const arr1 = [0, 1, 2, [3, 4]];
 const arr2 = [0, 1, 2, [[[3, 4]]];

 Console.log (arr1.flat ());
 Console.log (arr2.flat (2));
 

(

arr2.flat (Infinity)

• )

;

• Object.entries()
• Вы можете сделать некоторое преобразование типа данных

из карты в объект

let map = new Map ([[

    ["a", 1],
    ["B", 2],
 ]);
 
 let obj = object.fromentries (map);
 Console.log (obj

)

;
    ["a", 1],
    ["B", 2],
 ]
 let obj = object.fromentries (arr);
 

Console.log

(obj)

;
    A: 1,
    b: 2,
    C: 3
 }
 
 пусть res = object.fromentries (
     Object.Entries (obj) .filter (([key, val]) => value! == 3)
 )
 
 console.log (res) // {a: 1, b: 2}

числовое расширение

• toString () преобразование : вернуть исходный код функции (согласуется с кодированием)

// toString ()
 функциональный тест () {
     consople.log ('domesy')
 }
 console.log (test.toString ());
 // function test () {
 //consople.log('domesy ')
 //}

Необязательные параметры подъема

в ES10, попытка Catch Cange может игнорировать параметры подъема

let func = (name) => {
      пытаться {
         вернуть json.parse (имя)
      } ловить {
         вернуть ложь
      }
  }
  
  Консоль.log (func (1)) // 1
  console.log (func ({a: '1'})) // false

es11

bigint (оригинальный тип)

• Новый примитивный тип данных: bigint, который представляет целое число произвольной точности и может представлять очень длинные данные, которые могут превышать 2 из

безопасно

• представлять
• только значения в диапазоне-(2^53-1) до 2^53-1

• . Может быть только 53 бинарные цифры (эквивалентные 16 десятичных цифр, плюс или минус 9007199254740992).
• Bigint не имеет ограничения на количество цифр, и любое целое число может быть точно представлено. Однако его можно использовать только для представления целых чисел, и для того, чтобы отличить его от числа, данные типа BigInt должны быть добавлены с помощью суффикса N.

но

• не
• может использовать положительные знаки.

 Console.log (2 ** 53) // 9007199254740992
 console.log (number.max_safe_integer) // 9007199254740991
 
 // bigint
 const bigint = 9007199254740993n
 Console.log (bigint) // 9007199254740993n
 console.log (typeof bigint) // bigint
 console.log (1n == 1) // true
 Console.log (1n === 1) // Неверно
 Const Bigintnum = Bigint (9007199254740993n)
 Console.log (bigintnum) // 9007199254740993n

основных типов данных

, а именно: srting , number , boolean object null undefined symbol

,

Array Function Date object RegExp

8. Это: srting , number , boolean , object , null , undefined , symbol , BigInt

Promise

Orders.allSettled ():

• упаковать несколько экземпляров в новый экземпляр и верните массив состояния после изменений статуса всех экземпляров (измените все изменения а затем вернуть)
• независимо от того, выполнен ли результат или отклонен, не подвозится, что улов не
• является эквивалентным для расширенного Promise.all()

Ording.LlSetTled ([[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[

    Обещание.ereject ({
      Код: 500,
      MSG: "Исключение службы",
    }),
    Обещание.resolve ({
      Код: 200,
      Данные: ["1", "2", "3"],
    }),
    Обещание.resolve ({
      Код: 200,
      Данные: ["4", "5", "6"],
    }),
  ]). Тогда ((res) => {
      console.log (res) // [{anpuse: {code: 500, msg: 'Исключение службы'}, статус: "Отклонено"},
                      // {Причина: {Code: 200, Data: ["1", "2", "3"]}, Статус: "Отклонено"},
                      // {Причина: {Code: 200, Data: ["4", "5", "6"]}, статус: "Отклонено"}]
      const data = res.filter ((item) => item.status === "fulfiled");
      console.log (data);
                          // {Причина: {Code: 200, Data: ["4", "5", "6"]}, статус: "Отклонено"}]
  })

Import ():

• динамический динамический импорт
• , полученный require() import() require загрузка

// then ()
 let modulepage = "index.js";
 Import (modulePage) .Then ((module) => {
    module.init ();
 });
 
 // в сочетании с Async Wait
 (асинхронный () => {
  const modulepage = 'index.js'
  const module = await import (modulepage);
  Console.log (модуль)
 })

Global This

• Global This, независимо от того, какая среда (браузер, узл и т. Д.) Всегда указывает на глобальный объект

// Консоль среды браузера.

//узел
Console.log (GlobalThis) // Глобальный

• символ

цепочки

,

• существует ли
• TypeScrief.

 // до es11 let a = user && user.name
 
 

пусть

B =

• пользователь
• ?
• .

"||"
  "??"
  
 const b = 0;
 const a = b || 5;
 Консоль.log (A); // 5
 
 const b = null // не определен
 const a = b ?? 123;
 

(

A);

//

123

• ES12 Передача
• символов . исходная строка, которая соответствует шаблону с заменой.
• Паттерн может быть строкой или регулярным выражением, а замена может быть строкой или функцией, которая применяется к каждому совпадению.
• ReplaceAll () эквивалентен улучшению характеристик reply (), заменив все

let str = "hi!, Это новая особенность ES6 ~ es12, в настоящее время ES12"
 
 console.log (str.replace ("es", "sy"); , это новая особенность SY6 ~ ES12, в настоящее время ES12
 console.log (str.replace (/es/g, "sy")); , это новая особенность Sy6 ~ sy12, в настоящее время это Sy12
 
 console.log (str.replaceall ("es", "sy")); , это новая особенность Sy6 ~ sy12, в настоящее время это Sy12
 console.log (str.replaceall (/es/g, "sy")); Это новая особенность Sy6 ~ Sy12, в настоящее время SY12

обещание

. Любой

• () отличается от обещания. вернуть обещание, которое разрешается первым.

Обещание.
    Обещание.
    Обещание. Resolve ("Second"),
    Обещание. Resolve ("First"),
 ])
 .then ((res) => console.log (res)) // секунд
 .catch ((err) => console.error (err)); 
 
 Обещание.
    Ording.reject ("ошибка 1"),
    Ording.reject ("ошибка 2"),
    Ording.reject ("ошибка 3"),
 ])
 .then ((res) => console.log (res))
 .catch ((err) => console.error (err));
 // AggregateError: все обещания были отклонены
 
 Обещание.
    Обещание.resolve ("третий"),
    Обещание. Resolve ("Second"),
    Обещание. Resolve ("First"),
 ])
 .then ((res) => console.log (res)) // третий
 

• err

(

err));

• Это позволяет отслеживать существующие объекты, не мешая их собирать мусор.
• Очень
полезно для
• кэширования
• и картирования объектов
• . возможный. Также важно не полагаться на какое -либо конкретное поведение, которое не гарантируется спецификацией. Когда, как и происходит ли сбор мусора, зависит от реализации любого данного двигателя JavaScript.

Пусть SleedRef = new SleedRef ({name: 'domesy', год: 24})
 
 SleedRef.deref () // {name: 'domesy', год: 24}
 SleedRef.deref ().

Год

//

24

Пусть num2 = 10;
num1 && = num2;
Консоль.log (num1);

// эквивалентно num1 && (num1 = num2);
if (num1) {
    num1 = num2;
 }

|| =

let num1;
Пусть num2 = 10;
num1 || = num2;
Консоль.log (num1);

// эквивалентно num1 || (num1 = num2);
if (! num1) {
   num1 = num2;
}

?

• ​

​
Пусть num2 = 10;
Пусть num3 = null;

num1 ?? = num2;
Консоль.log (num1);

num1 = false;
num1 ?? = num2;
console.log (num1);

num3 ?? = 123;
Консоль.log (num3);

// эквивалент // num1 ?? (num1 = num2

)

;

Пусть num2 = 100_000;

Консоль.log (num1);
Консоль.log (num2);

const num3 = 10.12_34_56
Консоль.log (num3);