Angular5升级Angular8遇类型错误：'unknown'无法赋值给类型'T'

Hey there, let’s work through this error you’re hitting while migrating from Angular 5 to 8. First, let’s break down why this is happening, then go over your options for fixing it.

Why the Error Occurs #

Angular 8 uses a newer, stricter TypeScript version than Angular 5, and that’s where this issue stems from. In your catchError block, your handleError function is returning an Observable<unknown>, but your method is declared to return Observable<T>. TypeScript now correctly flags this mismatch: unknown is a top-level type that can’t be safely assigned to a more specific generic type T, even if T is constrained to {}.

Option 1: Fix the Generic Endpoint Version #

If you want to keep using generics (maybe because this endpoint needs to return different types across different parts of your app), you just need to ensure your handleError function preserves the generic type T.

First, update your handleError method to be generic:

private handleError<T>(error: HttpErrorResponse, retryFn: () => Observable<T>): Observable<T> {
  // Your existing error handling logic (log the error, show user feedback, etc.)
  console.error('Request failed:', error.message);
  
  // Return the retry function (or throw an error if you don't want to retry)
  return retryFn();
  // Or if you don't retry: return throwError(() => new Error(error.message)) as Observable<T>;
}

Then, explicitly pass the generic type T when calling handleError in your endpoint method:

public getClientCompanyAccountsEndpoint<T>(clientCompanyId: number): Observable<T> {
  const url = this._baseUrl + this._clientCompanyAccountsUrl + clientCompanyId;
  return this.http.get<T>(url, this.getRequestHeaders())
    .pipe(catchError(error => {
      // Pass <T> here to ensure handleError returns Observable<T>
      return this.handleError<T>(error, () => this.getClientCompanyAccountsEndpoint(clientCompanyId));
    }));
}

This tells TypeScript the error handler will return the same type T as the original request, resolving the type mismatch.

Option 2: Switch to Specific Return Types (Your Proposed Rewrite) #

Your idea to replace generics with concrete types like Observable<AccountModel[]> and Observable<SettlementAccountModel[]> is actually a fantastic choice for most scenarios—here’s why:

• Stronger type safety: TypeScript can catch mistakes at compile time, like trying to access properties that don’t exist on the returned model.
• Clearer code: Anyone reading your service immediately knows what data to expect from each endpoint, no guessing required.
• Fewer errors: You won’t accidentally pass the wrong generic type when calling the endpoint.

Your proposed rewrite is fully valid and will eliminate the type error entirely. Each endpoint method explicitly declares its return type, so TypeScript doesn’t have to infer ambiguous types.

Which Option Should You Pick? #

• Stick with generics only if this endpoint needs to return multiple unrelated types across different parts of your app.
• Use concrete types if each endpoint has a single, well-defined return type (which seems to be your case with AccountModel[] and SettlementAccountModel[]). This is the more maintainable approach long-term.

内容的提问来源于stack exchange，提问作者Tom