もちろんだ。プロミスは、例えばコールバックを直接使うよりもずっとエレガントで実用的な方法で非同期問題を解決するためのコンセプトだ。

## プロミスとは？

その名前が示すように、プロミスとは、最初は実現されると考えているものですが、将来いくつかのことが起こる可能性があります：
- プロミスが**満たされる**(プロミスが解決される)。
- 約束が**果たされない**（約束が拒否される）。
- 約束が**不確かな状態**にいつまでも留まる（約束が保留される）。

これらの簡単な基本を理解することで、Javascriptでプロミスがどのように機能するかを理解することができます。始める前に、プロミスには2つの重要な部分があることも明確にしておく必要があります：**プロミスを消費する方法**（プロミスの使用__）と、プロミスを作成する方法**（プロミスを使用する関数の準備__）です。

## JavaScriptの約束

Javascriptの約束は``オブジェクト``で表現され、それぞれの約束は保留、受諾、拒否という特定の状態になります。さらに、各プロミスは以下のメソッドを持っており、それを使用することができます：

| メソッド** | **説明** |
|:---:|:---:|
| ``.then(FUNCTION resolve)`` | プロミスが満たされた時に ``resolve`` コールバック関数を実行する。
| | ``.catch(FUNCTION reject)`` | 約束が拒否されたときに ``reject`` コールバック関数を実行します。|
| | ``.then(FUNCTION resolve, FUNCTION reject)`` | 同じ ``.then()`` の中で、前の2つと同等のメソッドです。|
| | ``.finally(FUNCTION end)`` | 成功時と拒否時の両方で ``end`` コールバック関数を実行する。|

## プロミスを消費する

プロミスを消費する一般的な方法は、1つのパラメータで ``.then()`` を使用することです：

```js
fetch("/robots.txt").then(function(response) {
  /* Código a realizar cuando se cumpla la promesa */
});
```

前の例で見たのは、``fetch()``関数の使用です。この関数は、リクエストからのレスポンスを取得したときに満たされるプロミスを返します。このようにして、リクエストのレスポンスに応答するコードの動作を（読みやすい方法で）準備することになります。

プロミスが拒否されたときに ``.catch()`` メソッドを使うことができることを覚えておいてください：

```js
fetch("/robots.txt")
  .then(function(response) {
    /* Código a realizar cuando se cumpla la promesa */
  })
  .catch(function(error) {
    /* Código a realizar cuando se rechaza la promesa */
  });
```
.then()``メソッドと ``.catch()``メソッドをインデントしていることに注目してください。また、プロミスを生成し続けて ``return`` で返す場合は、 ``.then()`` を複数連結することができます：

```js
fetch("/robots.txt")
  .then(response => {
    return response.text(); // Devuelve una promesa
  })
  .then(data => {
    console.log(data);
  })
  .catch(error => { /* Código a realizar cuando se rechaza la promesa */ });
```

> 以下のプロミスを ``.then()`` でチェーンできるように、``return`` を忘れないでください。また、``.catch()`` の後に ``.then()`` をつなげてプロミスの処理を続けることもできます。

実際、**arrow 関数** を使用することで、このコードの可読性をさらに向上させることができます。**arrow 関数** のボディにステートメントが 1 つしかない場合、暗黙の **return** があることを覚えておいてください：

```js
fetch("/robots.txt")
  .then(response => response.text())
  .then(data => console.log(data))
  .finally(() => console.log("Terminado."))
  .catch(error => console.error(data));
```
また、``.finally()``メソッドを追加して、**約束が達成されるか拒否されるか**に関わらず実行されるコールバック関数を追加していることにも注意してください。これにより、``.then()``や``.catch()``で関数を繰り返す必要がなくなります。

> このセクションを通して、私たちは ``.then()`` を使ってプロミスを利用する方法を見てきました。しかし、次のセクションで、プロミスを作成したり、後で利用するためにプロミスを実装する方法について説明します。

## プロミスを使った非同期処理

プロミスを使って次の練習をしてみましょう：

numbers``という配列があり、そこに数字を入れる。numbers``という配列があり、そこに数字を挿入する。各反復には ``numbers`` が挿入される。これはダイスのシミュレーションによって生成されたものである（_1から6までの乱数）。6の場合、ループを中断する：

最初に行うことは、 ``doTask()`` タスク関数全体を ``wrapped`` する新しい ``PROMISE`` オブジェクトを作成することです。

この ``new Promise()`` は2つのコールバックを持つ関数をパラメータとして渡されます。最初の ``resolve`` はプロミスが達成されたときに使用し、2番目の ``reject`` はプロミスが拒否されたときに使用します：

```js
const iterations = 10;
const numbers = [];

/* Implementación con promesas */
const doTask = (iterations) => new Promise((resolve, reject) => {
  const numbers = [];
  for (let i = 0; i < iterations; i++) {
    const number = 1 + Math.floor(Math.random() * 6);
    numbers.push(number);
    if (number === 6) {
      reject({
        error: true,
        message: "Se ha sacado un 6"
      });
    }
  }
  resolve({
    error: false,
    value: numbers
  });
});
```

ダイスを投げるたびに**（乱数を生成する部分）より高価な処理が行われ、**かなりの時間がかかる**場合を想像してみてください。

この情報がお役に立てば幸いです。何か質問があればお知らせください。
Por supuesto. Las promesas son un concepto para resolver el problema de asincronía de una forma mucho más elegante y práctica que, por ejemplo, utilizando funciones callbacks directamente.

## ¿Qué es una promesa?

Como su propio nombre indica, una promesa es algo que, en principio pensamos que se cumplirá, pero en el futuro pueden ocurrir varias cosas:
- La promesa se **cumple** (promesa resuelta)
- La promesa no se **cumple** (promesa se rechaza)
- La promesa se queda en un **estado incierto** indefinidamente (promesa pendiente)

Con estas sencillas bases, podemos entender el funcionamiento de una promesa en Javascript. Antes de empezar, también debemos tener claro que existen dos partes importantes de las promesas: **como consumirlas** (_utilizar promesas_) y **como crearlas** (_preparar una función para que use promesas y se puedan consumir_).

## Promesas en Javascript

Las promesas en Javascript se representan a través de un ``object``, y cada promesa estará en un estado concreto: pendiente, aceptada o rechazada. Además, cada promesa tiene los siguientes métodos, que podremos utilizar para utilizarla:

| **Métodos** | **Descripción** |
|:---:|:---:|
| ``.then(FUNCTION resolve)`` | Ejecuta la función callback ``resolve`` cuando la promesa se cumple. |
| ``.catch(FUNCTION reject)`` | Ejecuta la función callback ``reject`` cuando la promesa se rechaza. |
| ``.then(FUNCTION resolve, FUNCTION reject)`` | Método equivalente a las dos anteriores en el mismo ``.then()``. |
| ``.finally(FUNCTION end)`` | Ejecuta la función callback ``end`` tanto si se cumple como si se rechaza. |

## Consumir una promesa

La forma general de consumir una promesa es utilizando el ``.then()`` con un sólo parámetro, puesto que muchas veces lo único que nos interesa es realizar una acción cuando la promesa se cumpla:

```js
fetch("/robots.txt").then(function(response) {
  /* Código a realizar cuando se cumpla la promesa */
});
```

Lo que vemos en el ejemplo anterior es el uso de la función ``fetch()``, la cuál devuelve una promesa que se cumple cuando obtiene respuesta de la petición realizada. De esta forma, estaríamos preparando (_de una forma legible_) la forma de actuar de nuestro código a la respuesta de la petición realizada, todo ello de forma asíncrona.

Recuerda que podemos hacer uso del método ``.catch()`` para actuar cuando se rechaza una promesa:

```js
fetch("/robots.txt")
  .then(function(response) {
    /* Código a realizar cuando se cumpla la promesa */
  })
  .catch(function(error) {
    /* Código a realizar cuando se rechaza la promesa */
  });
```
Observa como hemos indentado los métodos ``.then()`` y ``.catch()``, ya que se suele hacer así para que sea mucho más legible para él. Además, se pueden encadenar varios ``.then()`` si se siguen generando promesas y se devuelven con un ``return``:

```js
fetch("/robots.txt")
  .then(response => {
    return response.text(); // Devuelve una promesa
  })
  .then(data => {
    console.log(data);
  })
  .catch(error => { /* Código a realizar cuando se rechaza la promesa */ });
```

> No olvides indicar el ``return`` para poder encadenar las siguientes promesas con ``.then()``. Tras un ``.catch()`` también es posible encadenar ``.then()`` para continuar procesando promesas.

De hecho, usando **arrow functions** se puede mejorar aún más la legibilidad de este código, recordando que cuando sólo tenemos una sentencia en el cuerpo de la **arrow function** hay un **return** implícito:

```js
fetch("/robots.txt")
  .then(response => response.text())
  .then(data => console.log(data))
  .finally(() => console.log("Terminado."))
  .catch(error => console.error(data));
```
Observese además que hemos añadido el método ``.finally()`` para añadir una función callback que se ejecutará **tanto si la promesa se cumple o se rechaza**, lo que nos ahorrará tener que repetir la función en el ``.then()`` como en el ``.catch()``.

> En todo este apartado hemos visto como utilizar o consumir una promesa haciendo uso de ``.then()``, que es lo que en la mayoría de los casos necesitaremos. Sin embargo, vamos a ver en el siguiente apartado como crear o implementar las promesas para su posterior consumo.

## Asincronía con promesas

Vamos a implementar el siguiente ejercicio utilizando promesas:

Tenemos un array ``numbers``, en el cuál insertaremos números. Insertaremos la cantidad de números que figura en ``iterations``. En cada iteración se insertará un ``number``, que habrá sido generado con una simulación del lanzamiento de un dado (_un número aleatorio del 1 al 6_). En el caso de obtener un 6, paramos y rompemos el bucle:

Observa que lo primero que haremos es crear un nuevo objeto ``PROMISE`` que «envuelve» toda la función de la tarea ``doTask()``.

Al ``new Promise()`` se le pasa por parámetro una función con dos callbacks, el primero ``resolve`` el que utilizaremos cuando se cumpla la promesa, y el segundo ``reject`` cuando se rechace:

```js
const iterations = 10;
const numbers = [];

/* Implementación con promesas */
const doTask = (iterations) => new Promise((resolve, reject) => {
  const numbers = [];
  for (let i = 0; i < iterations; i++) {
    const number = 1 + Math.floor(Math.random() * 6);
    numbers.push(number);
    if (number === 6) {
      reject({
        error: true,
        message: "Se ha sacado un 6"
      });
    }
  }
  resolve({
    error: false,
    value: numbers
  });
});
```

Imagina el caso de que **cada lanzamiento del dado** (_la parte donde genera el número aleatorio_) fuera un proceso más costoso que **tardara un tiempo considerable**, quizás de esa forma se vea más clara la necesidad de una tarea asíncrona, controlada con promesas.

Espero que esta información te haya resultado de utilidad. Por favor, si tienes alguna duda, házmela saber.