Comment retourner la valeur d'une fonction qui contient un abonnement à un Observable ?

Question

Je ne sais pas comment extraire la valeur d'un Observable qui sera retournée par une fonction dans laquelle l'Observable est présent. J'ai juste besoin d'une valeur à retourner, rien d'autre.

Version actuelle qui fonctionne

function getValueFromObservable() {
    this.store.subscribe(
        (data:any) => {
            console.log(data)
        }
    )
}
getValueFromObservable()

J'ai besoin que ça fonctionne, que la fonction renvoie une valeur, puis.. :

function getValueFromObservable() {
    this.store.subscribe(
        (data:any) => {
            return data
        }
    )
}
console.log(getValueFromObservable())

Qu'est-ce que je fais de mal ici ?

Answer 1

Je me rends compte que cette question date d'il y a un certain temps et que vous avez sûrement déjà trouvé une solution appropriée, mais pour tous ceux qui recherchent cette solution, je suggère de la résoudre avec une Promise pour conserver le modèle asynchrone. Une version plus verbeuse serait de créer une nouvelle Promise :

function getValueFromObservable() {
    return new Promise(resolve=>{
        this.store
         .take(1) //useful if you need the data once and don't want to manually cancel the subscription again
         .subscribe(
            (data:any) => {
                console.log(data;
                resolve(data);
         })
    }
}

À l'extrémité réceptrice, vous devrez ensuite "attendre" la résolution de la promesse avec quelque chose comme ceci :

getValueFromObservable()
   .then((data:any)=>{
   //... continue with anything depending on "data" after the Promise has resolved
})

Une solution plus légère consisterait à utiliser .toPromise() de RxJS à la place :

function getValueFromObservable() {
    return this.store
       .take(1)
       .toPromise()   
}

Le côté réception reste le même que ci-dessus, bien sûr. J'espère que cela vous aidera !

Answer 2

Ce n'est pas exactement l'idée correcte d'utiliser Observable

Dans le composant, vous devez déclarer un membre de la classe qui contiendra un objet (quelque chose que vous allez utiliser dans votre composant).

export class MyComponent {
  name: string = "";
}

Alors un Service vous renverra un Observable :

getValueFromObservable():Observable<string> {
    return this.store.map(res => res.json());
}

Component doit se préparer à récupérer une valeur :

OnInit(){
  this.yourServiceName.getValueFromObservable()
    .subscribe(res => this.name = res.name)
}

Vous devez attribuer une valeur à partir d'un Observable à une variable :

Et votre modèle consommera une variable name :

<div> {{ name }} </div>

Une autre façon d'utiliser Observable est par async tuyau http://briantroncone.com/?p=623

Note : Si ce n'est pas ce que vous demandez, veuillez mettre à jour votre question avec plus de détails.

Answer 3

Si vous souhaitez vous préinscrire au même Observable que celui qui sera renvoyé, utilisez simplement

.do() :

function getValueFromObservable() {
    return this.store.do(
        (data:any) => {
            console.log("Line 1: " +data);
        }
    );
}

getValueFromObservable().subscribe(
        (data:any) => {
            console.log("Line 2: " +data)
        }
    );

Answer 4

Le problème est que les données sont capturées à l'intérieur de l'observable et que je peux simplement les consigner dans la console. Je veux retourner cette valeur et console.log ou autre à partir d'un fichier différent en appelant la fonction dans laquelle elle réside.

On dirait que vous cherchez un getter "current value" à l'intérieur d'un observable, quand il émet et après une émission.

Subject et Observable n'a pas une telle chose. Lorsqu'une valeur est émise, elle est transmise à ses abonnés et la balise Observable en a fini avec elle.

Vous pouvez utiliser BehaviorSubject qui stocke la dernière valeur émise et l'émet immédiatement aux nouveaux abonnés.

Il dispose également d'un getValue() pour obtenir la valeur actuelle ;

Pour en savoir plus :

RxJS BehaviorSubject

Comment obtenir la valeur actuelle d'un sujet ou d'un observable RxJS ?

Answer 5

Les valeurs observables peuvent être récupérées à n'importe quel endroit. La séquence source est d'abord poussé sur une observateur qui est capable d'émettre ailleurs. Pour ce faire, on utilise le Classe de sujet des extensions réactives (RxJS).

var subject = new Rx.AsyncSubject();  // store-last-value method

Stocker la valeur sur le observateur .

subject.next(value); // store value
subject.complete(); // publish only when sequence is completed

Pour récupérer la valeur d'un autre endroit, abonnez-vous à l'observateur de la manière suivante :

subject.subscribe({
  next: (response) => {
      //do stuff. The property name "response" references the value
  }
});

Les sujets sont à la fois des Observables et des Observateurs. Il existe d'autres Types de sujets comme BehaviourSubject et ReplaySubject pour d'autres scénarios d'utilisation.

N'oubliez pas d'importer RxJS.

var Rx = require('rxjs');