ES6

Creo que hay un pequenio error. Promise.prototype.finally son parte de ES9

ES6: mejoras más importantes

.
ES6, también conocido como ECMAScript 2015, es una versión relevante de JavaScript que fue lanzada en junio de 2015. Es la primera actualización significativa del lenguaje en varios años, y trae consigo una gran cantidad de mejoras y nuevas características.
.
Entre las mejoras más importantes de ES6 se encuentran:
.

• Declaración de variables mejorada: Con ES6, se introdujeron dos nuevas formas de declarar variables: “let” y “const”. Esto permite un mejor control del alcance de las variables y ayuda a prevenir errores comunes en JavaScript.
  .
• Arrow functions: Las funciones de flecha, o arrow functions, son una forma más corta y legible de escribir funciones en JavaScript. Son especialmente útiles cuando se trabaja con arrays y objetos.
  .
• Template literals: Los template literals son una forma más fácil y legible de crear cadenas de texto. Permiten la interpolación de variables y expresiones dentro de cadenas de texto, lo que hace que el código sea más limpio y fácil de entender.
  .
• Promesas: Las promesas son una forma de manejar tareas asíncronas en JavaScript. Con ES6, se introdujeron las promesas nativas en el lenguaje, lo que hace que sea más fácil trabajar con operaciones asíncronas.
  .
• Módulos: ES6 introduce un nuevo sistema de módulos que permite a los desarrolladores dividir su código en pequeñas piezas reutilizables. Esto hace que sea más fácil de mantener y de trabajar en proyectos más grandes.

Dado que los objetos en JS son referencias a espacios en memoria, que se halla incluido el spread operator es muy importante para evitar side effects

Las funciones anónimas en JavaScript son aquellas que no han sido declaradas con un nombre. En este lenguaje de programación, podemos declarar este tipo de elemento usando cualquiera de los modos de escribir funciones.

31/89 ES6
ES6 trae una fran cantidad de características nuevas y mejoras al lenguaje JavaScript incluyendo:

Parametros por defecto: ES6 permite la asignación de valores por defecto a los parámetros de una función

function suma(a, b = 0) {
  return a + b;
}
suma(2); // Output: 2
suma(2, 3); // Output: 5

Object literal shortland: ES6 introduce una nueva sintaxis para crear objetos literales de manera más sencillas y legible

const nombre = "Juan";
const edad = 30;
const persona = { nombre, edad };
console.log(persona); // Output: { nombre: "Juan", edad: 30 }

Promises: ES6 incluye una nueva forma de manejar operaciones asíncronas mediante la utilización de promesas

function miFuncion() {
  return new Promise((resolve, reject) => {
    // código asíncrono
    if (error) {
      reject(error);
    } else {
      resolve(resultado);
    }
  });
}
miFuncion().then(resultado => console.log(resultado)).catch
(error => console.log(error));

Móduloes dinámicos: Es6 permite la carga dinámica de módulo mediante la utilización del método ìmport()`

import('./miArchivo.js').then(miModulo => {
  miModulo.miFuncion();
}).catch(error => console.log(error));

Rest parameters: ES6 introduce la sintaxix ‘…’ para permitir la captura de argumentos restantes en una función en un array

function suma(...numeros) {
  return numeros.reduce((acumulado, numero) => acumulado + numero, 0);
}
console.log(suma(1, 2, 3, 4, 5)); // Output: 15

Mi ejemplo

class DragonBall {
	constructor(personaje, ki) {
	this.personaje = personaje;
	this.ki = ki;
	}
	saludar() {
		console.log(`Yo soy ${this.personaje} y mi poder es ${this.ki}`);	
	}
}
const persona = new DragonBall("Goku", 300000000000000000000000000000000000);;
persona.saludar();

Además del spread operator, se añadió otra función con los tres puntos (…) llamada rest operator.

Dejo un ejemplo:

/*-----------------------Operador de propagación (...)-----------------------*/

let person = { name: "Alexa", age: 24 };
let country = "COL";
//let data = [...person, country ]; //error por ser array. Solo se pueden copiar de array a arrays y objects a objects
let data = {...person, country }; //... permite que se copien los elementos del object person a un nuevo objeto
console.log(data); //{ name: 'Alexa', age: 24, country: 'COL' } Adiciona en su contenido el contenido del object person y el valor de country (en este caso se guarda como una propiedad-valor)

let pares = [2,4,6,8,10]; //para arrays también sirve
let copyPar = [...pares];
let paresVeinte = [...pares,12,14,16,18,20];
console.log(copyPar); //[ 2, 4, 6, 8, 10 ]
console.log(paresVeinte); //[2,  4,  6,  8, 10, 12, 14, 16, 18, 20]

/*-----------------------Parámetro rest (resto)-----------------------*/

const array = [1,2,3,4,5];

function hola (primero, segundo, ...resto) { // Parámetro Rest (... + nombre de variable que almacenará el array). A diferencia del spread operator, este siempre va al final y guarda el resto de elementos que se pasen como argumento a la función en un array
    console.log(primero, segundo)  // 1 2
    console.log(resto) // [3,4,5, "final"]
}

hola(...array, "final") //<- Operador de propagación (pasa como argumentos 1,2,3,4,5)
//Lo mismo que hacer -> hola(1,2,3,4,5, "final")

//También sirve para obtener los elementos restantes de un array u objeto usando desestructuración

const objeto = {
    nombre: "Andres",
    age: 23,
    plataforma: "Platzi"
}
const arrayNumber = [0,1,2,3,4,5]

const {plataforma, ...usuario} = objeto;
const [cero, ...positivos] = arrayNumber;

console.log(usuario); // { nombre: 'Andres', age: 23 }
console.log(positivos); // [ 1, 2, 3, 4, 5 ]