# refCount
馃挕 Utilizar el operador [share](https://github.com/puntotech/rxjs-docu/blob/master/operators/multicasting/share/README.md) es equivalente a utilizar el operador [publish](https://github.com/puntotech/rxjs-docu/blob/master/operators/multicasting/publish/README.md) (convirtiendo el Observable en uno caliente) junto al operador refCount.
Signatura
#### Firma
`refCount(): MonoTypeOperatorFunction`
#### Par谩metros
No recibe ning煤n par谩metro.
### Retorna
`MonoTypeOperatorFunction`
## Descripci贸n
Al utilizar alguna de las variantes del operador [publish](https://github.com/puntotech/rxjs-docu/blob/master/operators/multicasting/publish/README.md), o el operador [multicast](https://github.com/puntotech/rxjs-docu/blob/master/operators/multicasting/multicast/README.md), era necesario llamar manualmente al m茅todo connect() para suscribirse a la fuente y, posteriormente, gestionar la cancelaci贸n de la suscripci贸n para evitar posibles p茅rdidas de memoria.
Para que automatizar el proceso y evitar errores, se cre贸 el operador refCount, que hace ambas cosas autom谩ticamente.
Internamente, cuenta las suscripciones al Observable y se suscribe (una sola vez) a la fuente si el n煤mero de suscripciones es mayor que 0. Si el n煤mero de suscripciones es menor que 1, se cancela la suscripci贸n a la fuente. De esta manera se puede garantizar que cualquier operador anterior a `refCount` se ejecuta una 煤nica vez por cada evento, independientemente del n煤mero de suscripciones al Observable objetivo.
## Ejemplos
**Compartir el Observable fuente de forma autom谩tica con multicast + refCount**
[StackBlitz](https://stackblitz.com/edit/docu-rxjs-refcount-multicast?file=index.ts)
```javascript
import { interval, Subject, timer } from "rxjs";
import { take, takeUntil, tap, multicast, refCount } from "rxjs/operators";
const number$ = interval(1000).pipe(take(10));
// En lugar de cancelar la suscripci贸n manualmente, se va a utilizar la t茅cnica takeUntil + Subject
const stop$ = new Subject();
const multicasted$ = number$.pipe(
tap(() =>
console.log("Fuente compartida, efecto secundario se ejecuta una sola vez")
),
multicast(() => new Subject()),
// Al usar refCount, ya no es necesario llamar a connect() manualmente
refCount(),
takeUntil(stop$)
);
// refCount === 1, se hace la suscripci贸n a number$
multicasted$.subscribe((val) => console.log(`Observador 1: ${val}`));
// refCount === 2
multicasted$.subscribe((val) => console.log(`Observador 2: ${val}`));
// refCount === 0, se cancela la suscripci贸n a number$
timer(2000)
.pipe(
tap(() => stop$.next()),
tap(() => console.log("Fin"))
)
.subscribe();
/* Salida:
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 0,
Observador 2: 0,
(1s)
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 1,
Observador 2: 1,
(1s)
Fin
*/
```
**Compartir el Observable fuente de forma autom谩tica con publish + refCount**
馃挕 El operador publish es equivalente a `multicast(() => new Subject())`
[StackBlitz](/operadores/multicasting/refcount.md)
```javascript
import { interval, Subject, timer } from "rxjs";
import { take, takeUntil, tap, multicast, refCount } from "rxjs/operators";
const number$ = interval(1000).pipe(take(10));
// En lugar de cancelar la suscripci贸n manualmente, se va a utilizar la t茅cnica takeUntil + Subject
const stop$ = new Subject();
const multicasted$ = number$.pipe(
tap(() =>
console.log("Fuente compartida, efecto secundario se ejecuta una sola vez")
),
multicast(() => new Subject()),
// Al usar refCount, ya no es necesario llamar a connect() manualmente
refCount(),
takeUntil(stop$)
);
// refCount === 1, se hace la suscripci贸n a number$
multicasted$.subscribe((val) => console.log(`Observador 1: ${val}`));
// refCount === 2
multicasted$.subscribe((val) => console.log(`Observador 2: ${val}`));
// refCount === 0, se cancela la suscripci贸n a number$
timer(2000)
.pipe(
tap(() => stop$.next()),
tap(() => console.log("Fin"))
)
.subscribe();
/* Salida:
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 0,
Observador 2: 0,
(1s)
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 1,
Observador 2: 1,
(1s)
Fin
*/
```
**Compartir el Observable fuente de forma autom谩tica con publishReplay + refCount**
馃挕 El operador publish es equivalente a `multicast(() => new ReplaySubject())`.
Para que los observadores que se suscriban tarde puedan recibir los valores que se hayan emitido anterioremente, se puede utilizar publishReplay:
[StackBlitz](https://stackblitz.com/edit/docu-rxjs-refcount-publishreplay?file=index.ts)
```javascript
import { interval, Subject, timer } from "rxjs";
import { publishReplay, take, takeUntil, tap, refCount } from "rxjs/operators";
const number$ = interval(1000).pipe(take(10));
const stop$ = new Subject();
const multicasted$ = number$.pipe(
tap(() =>
console.log("Fuente compartida, efecto secundario se ejecuta una sola vez")
),
publishReplay(),
refCount(),
takeUntil(stop$)
);
// refCount === 1, se hace la suscripci贸n a number$
multicasted$.subscribe((val) => console.log(`Observador 1: ${val}`));
// refCount === 2
timer(3000)
.pipe(
tap(() =>
multicasted$.subscribe((val) => console.log(`Observador tard铆o: ${val}`))
)
)
.subscribe();
// refCount === 0, se cancela la suscripci贸n a number$
timer(4000)
.pipe(
tap(() => stop$.next()),
tap(() => console.log("Fin"))
)
.subscribe();
/* Salida:
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 0,
(1s)
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 1,
(1s)
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 2,
Observador tard铆o: 0,
Observador tard铆o: 1,
Observador tard铆o: 2,
(1s)
Fuente compartida, efecto secundario se ejecuta una sola vez,
Observador 1: 3,
Observador tard铆o: 3,
Fin
*/
```
### Ejemplo de la documentaci贸n oficial
En el siguiente ejemplo hay dos Observables intervalo transformados en Observables conectables mediante el operador `publish`. El primero utiliza el operador `refCount`, mientras que el segundo no. Se debe tener en cuenta que un Observable conectable no hace nada hasta que no se haga una llamada a su funci贸n `connect`.
```javascript
import { interval } from "rxjs";
import { tap, publish, refCount } from "rxjs/operators";
// Transformar el Observable interval en un ConnectableObservable (caliente)
const refCountInterval = interval(400).pipe(
tap((num) => console.log(`refCount ${num}`)),
publish(),
refCount()
);
const publishedInterval = interval(400).pipe(
tap((num) => console.log(`publish ${num}`)),
publish()
);
refCountInterval.subscribe();
refCountInterval.subscribe();
/* 'refCount 0' -----> 'refCount 1' -----> etc.
Todas las subscripciones recibir谩n el mismo valor y tanto tap como cualquier otro operador
que est茅 antes del operador publish se ejecutar谩 una vez por cada evento, independientemente del n煤mero de suscripciones
*/
publishedInterval.subscribe();
// No ocurre nada hasta que no se llame a la funci贸n connect() del Observable
```
### Recursos adicionales
[](https://github.com/ReactiveX/rxjs/blob/master/src/internal/operators/refCount.ts)
[Documentaci贸n oficial en ingl茅s](https://rxjs.dev/api/operators/refCount)
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://www.rxjs.es/operadores/multicasting/refcount.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.