Skip to content

Commit 3e3569c

Browse files
authored
Traducido observables.md a español
Se mantiene el uso de streams para referirse a flujos ya que se conocen más por su nombre en inglés, incluso en la comunidad hispana.
1 parent 05535d9 commit 3e3569c

File tree

1 file changed

+60
-58
lines changed

1 file changed

+60
-58
lines changed

aio/content/guide/observables.md

+60-58
Original file line numberDiff line numberDiff line change
@@ -1,119 +1,121 @@
1-
# Using observables to pass values
1+
# Usando observable spara pasar valores
22

3-
Observables provide support for passing messages between parts of your application.
4-
They are used frequently in Angular and are the recommended technique for event handling, asynchronous programming, and handling multiple values.
3+
Los observables proporcionan soporte al pase de mensajes entre partes de su aplicación.
4+
Se usan frecuentemente en Angular y son la técnica recomendada para el manejo de eventos, programación asíncrona y manejar valores múltiples.
55

6-
The observer pattern is a software design pattern in which an object, called the *subject*, maintains a list of its dependents, called *observers*, and notifies them automatically of state changes.
7-
This pattern is similar (but not identical) to the [publish/subscribe](https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern) design pattern.
6+
El patrón de observador es un patrón de diseño en el cual un objeto, llamado el *sujeto*, mantiene una lista de sus dependientes, llamados *observadores* y los notifica automáticamente de cambios de estado.
7+
Este patrón es similar (pero no idéntico) al patrón de diseño editor/suscriptor.
88

9-
Observables are declarative—that is, you define a function for publishing values, but it is not executed until a consumer subscribes to it.
10-
The subscribed consumer then receives notifications until the function completes, or until they unsubscribe.
9+
Los observables son declarativos—esto es, se define una función para publicar valores, pero no se ejecuta hasta que un consumidor se suscribe a ésta.
10+
El consumidor suscrito ahora recibe notificaciones hasta que la función termina, o hasta que anule su suscripción.
1111

12-
An observable can deliver multiple values of any type—literals, messages, or events, depending on the context. The API for receiving values is the same whether the values are delivered synchronously or asynchronously. Because setup and teardown logic are both handled by the observable, your application code only needs to worry about subscribing to consume values, and when done, unsubscribing. Whether the stream was keystrokes, an HTTP response, or an interval timer, the interface for listening to values and stopping listening is the same.
12+
Un observable puede entregar múltiples valores de cualquier tipo—literales, mensajes o eventos dependiendo del contexto. La API para recibir valores es la misma sin importar que los valores sean entregados sincrónicamente o asincrónicamente. Ya que el observable se encarga de la lógica de inicio y desmontaje, su codigo en la aplicación sólo debe preocuparse sobre suscribirse para consumir valores, y al terminal, anular la suscripción. Sin importar que el flujo fuera presiones de teclas, una respuesta HTTP o un intervalo del temporizador, la interface para escuchar a los valores y dejar de escuchar es la misma.
1313

14-
Because of these advantages, observables are used extensively within Angular, and are recommended for app development as well.
14+
Debido a estas ventajas, los observables son usados extensamente en Angular y se recomiendan para el desarrollo de aplicaciones también.
1515

16-
## Basic usage and terms
16+
## Uso y términos básicos
1717

18-
As a publisher, you create an `Observable` instance that defines a *subscriber* function. This is the function that is executed when a consumer calls the `subscribe()` method. The subscriber function defines how to obtain or generate values or messages to be published.
18+
Como un emisor, puede crear una instancia `Observable` que define una función *suscriber*. Esta es la función queque es ejecutada cuando un consumidor llama al método `subscribe()`. La función suscriptora define cómo obtener o generar valores o mensajes a ser publicados.
1919

20-
To execute the observable you have created and begin receiving notifications, you call its `subscribe()` method, passing an *observer*. This is a JavaScript object that defines the handlers for the notifications you receive. The `subscribe()` call returns a `Subscription` object that has an `unsubscribe()` method, which you call to stop receiving notifications.
20+
Para ejecutar el observable que ha creado y empezar a recibir notificaciones, llame al método `subscribe()`, pasando un *observer*. Este es un objeto JavaScript que define los manejadores para las notificaciones que recibe. La llamada `subscribe()` retorna un objeto`Subscription` que tiene un método `unsubscribe()`, que puede llamar para dejar de recibir notificaciones.
2121

22-
Here's an example that demonstrates the basic usage model by showing how an observable could be used to provide geolocation updates.
22+
Encuentre al continuar un ejemplo que demuestra el modelo de uso básico demostrando cómo un observable puede ser usado para emitir actualizaciones de geolocalización.
2323

24-
<code-example class="no-auto-link" path="observables/src/geolocation.ts" header="Observe geolocation updates"></code-example>
24+
<code-example class="no-auto-link" path="observables/src/geolocation.ts" header="Observar actualizaciones de geolocalización"></code-example>
2525

26-
## Defining observers
26+
## Definiendo observadores
2727

28-
A handler for receiving observable notifications implements the `Observer` interface. It is an object that defines callback methods to handle the three types of notifications that an observable can send:
28+
Un manejador para recibir notificaciones de un observable implementa la interface `Observer`. Es un objeto que defina los métodos de retrollamada (callback) para manejar los tres tipos de notificaciones que un observador puede enviar:
2929

30-
| Notification type | Description |
31-
|:---------|:-------------------------------------------|
32-
| `next` | Required. A handler for each delivered value. Called zero or more times after execution starts.|
33-
| `error` | Optional. A handler for an error notification. An error halts execution of the observable instance.|
34-
| `complete` | Optional. A handler for the execution-complete notification. Delayed values can continue to be delivered to the next handler after execution is complete.|
30+
| Tipo de notificación | Descripción |
31+
| :------------------- | :----------------------------------------------------------- |
32+
| `next` | Requerido. Un manejador por cada valor entregado. Llamado cero o más veces después de que la ejecución empieza. |
33+
| `error` | Opcional. Un manejador para una notificación de error. Un error detiene la ejecución de la instancia observable. |
34+
| `complete` | Opcional. Un manejador de la notificación "ejecución completa". Los valores retrasados pueden seguir siendo entregados al siguiente manejador después de que la ejecución se completa. |
3535

36-
An observer object can define any combination of these handlers. If you don't supply a handler for a notification type, the observer ignores notifications of that type.
36+
Un objeto observador puede difinir cualquier combinación de estos manejadores, Si no provee un método para un tipo de notificación, el observador ignora notificaciones de ese tipo.
3737

38-
## Subscribing
38+
## Suscribiéndose
3939

40-
An `Observable` instance begins publishing values only when someone subscribes to it. You subscribe by calling the `subscribe()` method of the instance, passing an observer object to receive the notifications.
40+
Una instancia `Observable` empieza publicando valores sólo cuando alguien se suscribe a ésta. Se suscribe llamando al método `subscribe()` de la instancia, pasando un objeto observer para recibir las notificaciones.
4141

4242
<div class="alert is-helpful">
4343

44-
In order to show how subscribing works, we need to create a new observable. There is a constructor that you use to create new instances, but for illustration, we can use some methods from the RxJS library that create simple observables of frequently used types:
4544

46-
* `of(...items)`&mdash;Returns an `Observable` instance that synchronously delivers the values provided as arguments.
47-
* `from(iterable)`&mdash;Converts its argument to an `Observable` instance. This method is commonly used to convert an array to an observable.
45+
En orden para mostrar cómo funcionan las suscripciones, necesitamos crear un observable. Hay un constructor que se usa para crear nuevas instancias, pero a manera ilustrativa, podemos usar algunos médotos de la librería RxJS que crea observables simples de tipos usados frecuentemente:
46+
47+
* `of(...items)`&mdash;Retorna una instancia `Observable` que entrega sincrónicamente los valores envíados como argumentos.
48+
* `from(iterable)`&mdash;Convierte sus argumentos a una instancia `Observable`. Éste método es usado comúnmente para convertir un arreglo en un observable.
4849

4950
</div>
5051

51-
Here's an example of creating and subscribing to a simple observable, with an observer that logs the received message to the console:
52+
Acá hay un ejemplo creando y suscribiéndose a un observable simple, con son observador que muestra los mensajes recibidos en la consola:
5253

5354
<code-example
5455
path="observables/src/subscribing.ts"
5556
region="observer"
56-
header="Subscribe using observer"></code-example>
57+
header="Subscribirse usand observador"></code-example>
5758

58-
Alternatively, the `subscribe()` method can accept callback function definitions in line, for `next`, `error`, and `complete` handlers. For example, the following `subscribe()` call is the same as the one that specifies the predefined observer:
59+
Alternativamente, el método `subscribe()` puede aceptar funciónes retrollamada en la línea para los manejadores de `next`, `error`, y `complete`. Por ejemplo, la siguiente llamada `subscribe()` es la misma a la que especifica el observador predefinido:
5960

60-
<code-example path="observables/src/subscribing.ts" region="sub_fn" header="Subscribe with positional arguments"></code-example>
61+
<code-example path="observables/src/subscribing.ts" region="sub_fn" header="Subscribirse con argumentos posicionales"></code-example>
6162

62-
In either case, a `next` handler is required. The `error` and `complete` handlers are optional.
63+
En cualquier caso, un manejador `next`es necesario. Los manejadores `error` y `complete` son opcionales.
6364

64-
Note that a `next()` function could receive, for instance, message strings, or event objects, numeric values, or structures, depending on context. As a general term, we refer to data published by an observable as a *stream*. Any type of value can be represented with an observable, and the values are published as a stream.
65+
Tome en cuenta que la función `next()` puede recibir, por ejemplo, cadenas de mensajes, eventos de objetos, valores numérics o estructuras, dependiendo del contexto. Como un término general, nos referimos a la data publicada por un observable como un *stream*. Cualquier tipo de valor puede representarse con un observable y los valores publicados como un stream.
6566

66-
## Creating observables
67+
## Creando observables
6768

68-
Use the `Observable` constructor to create an observable stream of any type. The constructor takes as its argument the subscriber function to run when the observable’s `subscribe()` method executes. A subscriber function receives an `Observer` object, and can publish values to the observer's `next()` method.
69+
Use el constructor `Observable` para crear un stream observable de cualquier tipo. El constructor toma como su argumento la función de suscriptor para ejecutarse cuando el método `subscribe()` se ejecuta. Una función suscriptora recibe un objeto `Observer` y puede publicar valores al método `next()`.
6970

70-
For example, to create an observable equivalent to the `of(1, 2, 3)` above, you could do something like this:
71+
Por ejemplo, para crear un observable equivalente al `of(1, 2, 3)` encontrado anteriormente, debería hacer algo como esto:
7172

72-
<code-example path="observables/src/creating.ts" region="subscriber" header="Create observable with constructor"></code-example>
73+
<code-example path="observables/src/creating.ts" region="subscriber" header="Crear observable con un constructor"></code-example>
7374

74-
To take this example a little further, we can create an observable that publishes events. In this example, the subscriber function is defined inline.
75+
Para tomar este ejemplo más lejos, podemos crear un observable que publica eventos. En este ejemplo, la función suscriptora se define en la línea.
7576

76-
<code-example path="observables/src/creating.ts" region="fromevent" header="Create with custom fromEvent function"></code-example>
77+
<code-example path="observables/src/creating.ts" region="fromevent" header="Crear con función fromEvent personalizada"></code-example>
7778

78-
Now you can use this function to create an observable that publishes keydown events:
79+
Ahora puede usar esta función para crear un observable que publica eventos de presiones de teclas:
7980

80-
<code-example path="observables/src/creating.ts" region="fromevent_use" header="Use custom fromEvent function"></code-example>
81+
<code-example path="observables/src/creating.ts" region="fromevent_use" header="Usando función fromEvent personalizada"></code-example>
8182

82-
## Multicasting
83+
## Multidifusión
8384

84-
A typical observable creates a new, independent execution for each subscribed observer. When an observer subscribes, the observable wires up an event handler and delivers values to that observer. When a second observer subscribes, the observable then wires up a new event handler and delivers values to that second observer in a separate execution.
85+
Un observable típico crea una ejecución nueva e independiente para cada observador suscrito. Cuando un observador se suscribe, el observable conecta un manejador de evento y entrega valores a ese observador. Cuando un segundo observador se suscribe, el observable conecta a un nuevo manejador de eventos y entrega valores a el segundo observador en una ejecución separada.
8586

86-
Sometimes, instead of starting an independent execution for each subscriber, you want each subscription to get the same values&mdash;even if values have already started emitting. This might be the case with something like an observable of clicks on the document object.
87+
Algunas veces, en vez de comenzar una ejecución independiente ara cada suscriptor, quiere que cada suscripción obtenga los mismos valores&mdash;incluso si los valores ya empezaron e emitirse. Este sería el caso con algo como un observable de click en el objeto de documento.
8788

88-
*Multicasting* is the practice of broadcasting to a list of multiple subscribers in a single execution. With a multicasting observable, you don't register multiple listeners on the document, but instead re-use the first listener and send values out to each subscriber.
89+
*Multidifusión* es la práctica de difundir a una lista de múltiples suscriptores en una sola ejecución. Con un observable en multidifusión, no necesita registrar varios oyentes en el documento, prefiriendo reutilizar el primer oyente y mandar valores a cada suscriptor.
8990

90-
When creating an observable you should determine how you want that observable to be used and whether or not you want to multicast its values.
91+
Cuando cree un observable debería determinar cómo quiere que ese observable se use y si quiere o no que se multidifusión en sus valores.
9192

92-
Let’s look at an example that counts from 1 to 3, with a one-second delay after each number emitted.
93+
Veamos un ejemplo que cuenta de 1 a 3, con un retraso de un segundo después de que cada número es emitido.
9394

94-
<code-example path="observables/src/multicasting.ts" region="delay_sequence" header="Create a delayed sequence"></code-example>
95+
<code-example path="observables/src/multicasting.ts" region="delay_sequence" header="Crer una secuencia retrasada"></code-example>
9596

96-
Notice that if you subscribe twice, there will be two separate streams, each emitting values every second. It looks something like this:
97+
Tome en cuenta que si se suscribe dos veces, habrán dos streams separados, cada una emitiendo valores cada segundo. Se ve parecido a esto:
9798

98-
<code-example path="observables/src/multicasting.ts" region="subscribe_twice" header="Two subscriptions"></code-example>
99+
<code-example path="observables/src/multicasting.ts" region="subscribe_twice" header="Dos suscripciones"></code-example>
99100

100-
Changing the observable to be multicasting could look something like this:
101+
Cambiando al observable a multidifusión se vería similar a esta manera:
101102

102-
<code-example path="observables/src/multicasting.ts" region="multicast_sequence" header="Create a multicast subscriber"></code-example>
103+
<code-example path="observables/src/multicasting.ts" region="multicast_sequence" header="Crear suscriptor multidifusión"></code-example>
103104

104105
<div class="alert is-helpful">
105-
Multicasting observables take a bit more setup, but they can be useful for certain applications. Later we will look at tools that simplify the process of multicasting, allowing you to take any observable and make it multicasting.
106+
Los observables multidifusión toman más tiempo empezando, pero pueden ser más útiles para cieras aplicaciones. Más adelante veremos herramientas que simiplifican el proceso de multidifusión, permitiéndole tomar cualquier observable y volverlo multidifusión.
106107
</div>
107108

108-
## Error handling
109109

110-
Because observables produce values asynchronously, try/catch will not effectively catch errors. Instead, you handle errors by specifying an `error` callback on the observer. Producing an error also causes the observable to clean up subscriptions and stop producing values. An observable can either produce values (calling the `next` callback), or it can complete, calling either the `complete` or `error` callback.
110+
## Manejo de errores
111+
112+
Como los observable producen valores de manera asíncrona, try/catch no va a agarrar errrores efectivamente. Los errores se manejan especificando una retrollamada `error` en el observador. Produciendo un error también causa que el observable limpie sus suscripciones y deje de producir valores. Un observable puede producir (haciendo retrollamada a `next`), o puede completar, con la retrollamda `complete` o `error`.
111113

112114
<code-example>
113115
myObservable.subscribe({
114-
next(num) { console.log('Next num: ' + num)},
115-
error(err) { console.log('Received an error: ' + err)}
116+
next(num) { console.log('Siguiente número: ' + num)},
117+
error(err) { console.log('Se recibió el error: ' + err)}
116118
});
117119
</code-example>
118120

119-
Error handling (and specifically recovering from an error) is covered in more detail in a later section.
121+
El manejo de errores (y especialmente la recuperación de un error) se cubre en mayor detalle más adelante.

0 commit comments

Comments
 (0)