взять (1) против первого ()

Я нашел несколько реализаций, AuthGuardкоторые используют take(1). В своем проекте я использовал first().

Оба работают одинаково?

import 'rxjs/add/operator/map';
import 'rxjs/add/operator/first';
import { Observable } from 'rxjs/Observable';

import { Injectable } from '@angular/core';
import { CanActivate, Router, ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
import { AngularFire } from 'angularfire2';

@Injectable()
export class AuthGuard implements CanActivate {

    constructor(private angularFire: AngularFire, private router: Router) { }

    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): Observable<boolean> | boolean {
        return this.angularFire.auth.map(
            (auth) =>  {
                if (auth) {
                    this.router.navigate(['/dashboard']);
                    return false;
                } else {
                    return true;
                }
            }
        ).first(); // Just change this to .take(1)
    }
}

Операторы first()и take(1)не одно и то же.

first()Оператор принимает необязательную predicateфункцию и выдает errorуведомление , когда значение не соответствует , когда источник завершен.

Например, это приведет к ошибке:

import { EMPTY, range } from 'rxjs';
import { first, take } from 'rxjs/operators';

EMPTY.pipe(
  first(),
).subscribe(console.log, err => console.log('Error', err));

... а также это:

range(1, 5).pipe(
  first(val => val > 6),
).subscribe(console.log, err => console.log('Error', err));

Хотя это будет соответствовать первому выданному значению:

range(1, 5).pipe(
  first(),
).subscribe(console.log, err => console.log('Error', err));

С другой стороны, take(1)просто берет первое значение и завершается. Никакой дополнительной логики здесь нет.

range(1, 5).pipe(
  take(1),
).subscribe(console.log, err => console.log('Error', err));

Тогда с пустым источником Observable он не выдаст никаких ошибок:

EMPTY.pipe(
  take(1),
).subscribe(console.log, err => console.log('Error', err));

Январь 2019: Обновлено для RxJS 6

Совет: используйте только first()если:

• Вы считаете, что ноль отправленных элементов является условием ошибки (например, завершение перед отправкой) И если вероятность ошибки больше 0%, вы правильно ее обрабатываете
• ИЛИ Вы на 100% знаете, что наблюдаемый источник испускает 1+ элементов (поэтому никогда не может выбросить) .

Если выбросы нулевые и вы явно не обрабатываете их (с помощью catchError), то эта ошибка будет распространяться вверх, возможно, вызовет неожиданную проблему в другом месте, и ее может быть довольно сложно отследить, особенно если она исходит от конечного пользователя.

По большей части вы безопаснее использовать take(1)при условии, что:

• Вы в порядке, take(1)если ничего не испускаете, если источник завершается без эмиссии.
• Вам не нужно использовать встроенный предикат (например first(x => x > 10)).

Примечание: Вы можете использовать предикат с take(1)так: .pipe( filter(x => x > 10), take(1) ). Это не приведет к ошибке, если ничто не превышает 10.

Что о single()

Если вы хотите быть еще строже и запретить два выброса, вы можете использовать single()какие ошибки, если выбросы равны нулю или 2+ . В этом случае вам снова придется обрабатывать ошибки.

Совет: Singleиногда может быть полезен, если вы хотите, чтобы ваша наблюдаемая цепочка не выполняла лишнюю работу, например, дважды вызывала http-службу и генерировала две наблюдаемые. Добавление singleна конец трубы сообщит вам, если вы сделали такую ​​ошибку. Я использую его в «средстве выполнения задач», где вы передаете наблюдаемую задачу, которая должна выдавать только одно значение, поэтому я передаю ответ, single(), catchError()чтобы гарантировать хорошее поведение.

Почему бы всегда не использовать first()вместо take(1)?

ака. Как first потенциально может вызвать больше ошибок?

Если у вас есть наблюдаемый объект, который берет что-то из службы, а затем передает это по first()конвейеру, в большинстве случаев все будет в порядке. Но если кто-то по какой-то причине придет и отключит службу - и изменит ее на emit, of(null)иначе NEVERлюбые последующие first()операторы начнут выдавать ошибки.

Теперь я понимаю, что это может быть именно то , что вам нужно, поэтому это всего лишь подсказка. Оператор firstобратился ко мне, потому что это звучало немного менее «неуклюже», чем, take(1)но вам нужно быть осторожным с обработкой ошибок, если когда-либо есть вероятность того, что источник не будет излучать. Однако все будет зависеть от того, что вы делаете.

Если у вас есть значение по умолчанию (константа):

Также .pipe(defaultIfEmpty(42), first())подумайте, есть ли у вас значение по умолчанию, которое следует использовать, если ничего не испускается. Это, конечно, не вызовет ошибку, потому firstчто всегда будет получать значение.

Обратите внимание, что defaultIfEmptyзапускается только в том случае, если поток пуст, а не в том случае, если значение того, что испускается, равно null.

Вот три Observables A, Bи Cс мраморными диаграммами, чтобы изучить разницу между first , takeи singleоператоры:

* Легенда :
--o-- значение
----! ошибки
----| завершения

Поиграйте с ним на https://thinkrx.io/rxjs/first-vs-take-vs-single/ .

Уже имея все ответы, я хотел добавить более наглядное объяснение

Надеюсь, это кому-то поможет

Есть одно действительно важное отличие, о котором нигде не упоминается.

take (1) излучает 1, завершает, отписывается

first () выдает 1, завершает, но не отказывается от подписки.

Это означает, что ваш наблюдаемый в восходящем направлении будет все еще активен после first (), что, вероятно, не является ожидаемым поведением.

UPD: это относится к RxJS 5.2.0. Эта проблема может быть уже исправлена.

Похоже, что в RxJS 5.2.0 у .first()оператора есть ошибка ,

Из-за этой ошибки .take(1)и .first()может вести себя совершенно иначе, если вы используете их сswitchMap :

С take(1)вы получите ожидаемое поведение:

var x = Rx.Observable.interval(1000)
   .do( x=> console.log("One"))
   .take(1)
   .switchMap(x => Rx.Observable.interval(1000))
   .do( x=> console.log("Two"))
   .subscribe((x) => {})

// In the console you will see:
// One
// Two
// Two
// Two
// Two
// etc...

Но с .first()вами будет неправильное поведение:

var x = Rx.Observable.interval(1000)
  .do( x=> console.log("One"))
  .first()
  .switchMap(x => Rx.Observable.interval(1000))
  .do( x=> console.log("Two"))
  .subscribe((x) => {})

// In console you will see:
// One
// One
// Two
// One
// Two
// One
// etc... 

Вот ссылка на код