TypeScript Response.text方法代码示例

 private extractDataFilter(res: Response): Treeable[] {
     const treeables: Treeable[] = [];
     const obj = JSON.parse(res.text());
     const results: any[] = obj.entity.result;
     for (let i = 0; i < results.length; i++) {
         const r: any = results[i];
         let t: Treeable;
         if (r.type === 'folder') {
             t = Object.assign(new Folder(), r);
         } else if (r.type === 'file_asset') {
             t = Object.assign(new File(), r);
         }
         treeables[i] = t;
     }
     return treeables;
 }

export function wrapError(err: Response): Observable<WrappedError> {
  let wrappedError: WrappedError;
  try {
    wrappedError = {
      status: err.status,
      content: err.json()
    };
  } catch (jsonError) {
    wrappedError = {
      status: err.status,
      content: err.text() || jsonError.message
    };
  }
  console.warn(`${wrappedError.status}: ${(wrappedError.content && JSON.stringify(wrappedError.content) || '-')}`);
  return Observable.throw(wrappedError);
}

            .map((res:Response) => {
                let securityToken:SecurityToken = new SecurityToken(
                    {
                    secretKey:res.headers.get(AppUtils.HEADER_X_SECRET),
                    token:res.headers.get(AppUtils.HEADER_X_TOKEN_ACCESS),
                    securityLevel:res.headers.get(AppUtils.HEADER_WWW_AUTHENTICATE)
                    }
                );

                localStorage.setItem(AppUtils.STORAGE_ACCOUNT_TOKEN,res.text());
                localStorage.setItem(AppUtils.STORAGE_SECURITY_TOKEN,JSON.stringify(securityToken));

                let account:Account = new Account(res.json());
                this.sendLoginSuccess(account);
                return account;
            });

 /**
  * Get the body returned in the response 
  * 
  * @private
  * @param {Response} response   http response
  * @returns {*}     null if no body, otherwise the body as an object
  */
 private getBody(response: Response): any {
     this.authService.authenticated(); // a successful API response received
     if (response.status === 204) {
         return null;
     }else {
         try {
             return response.json();
         }catch (e) {
             let text = response.text();
             if (text == null || text === '') {
                 return null;
             }else {
                 return text;
             }
         }
     }
 }

  handleError(res: Response) {
    let text = 'Server error: ';
    text += res.text();
    let json = '';

    try {
      json = res.json();
    } catch (err) { ; }

    const error = {
      json,
      text
    };

    console.error(error);

    return Observable.throw(error);
  }

  protected handleError(error: Response) {
    // In a real world app, we might use a remote logging infrastructure
    // We'd also dig deeper into the error to get a better message
    // let errMsg = (error.message) ? error.message : error.status ? `${error.status} - ${error.statusText}` : 'Server error';

    console.error(error); // log to console instead
    let status = error.status;
    switch (error.status) {
      case 500:
        let errMsg = error.text();
        this.delegateService.emitAlert(new AlertMessage(errMsg.toString(), ALERT_TYPE_DANGER));
        break;
      default:
        this.delegateService.emitAlert(new AlertMessage('System error', ALERT_TYPE_DANGER));
        break;
    }
    return Observable.throw(error);
  }

    private parseResponse(res: Response) {
        console.log("response", res);

        let contentType = res.headers.get("Content-Type");
        if (contentType.indexOf("application/json") > -1) {
            return res.json();
        } else if (
            contentType.indexOf("application/xml") > -1 ||
            contentType.indexOf("text/xml") > -1) {
            var x2js = new X2JS();
            var text = res.text();
            var jsonObj: any = x2js.xml2js<any>(text);
            jsonObj = jsonObj[Object.keys(jsonObj)[0]];

            return jsonObj;
        }

        throw new Error("Unsupported response content type - " + contentType);
    }

 /**
  * Convert response from text to boolean value;
  * @param res
  */
 static convertBooleanResponse(res: Response): boolean {
     return Boolean(res.text());
 }

 this.client.getAllExperimentsWithGET().subscribe((res:Response)=>{
   this.experiments = JSON.parse(res.text())['experiments'];
   this.filteredExperiments = this.experiments;
 },(err)=>{

 /**
  * Convert string to string;
  * @param res
  */
 static convertStringResponse(res: Response):string {
     return res.text();
 }