@angular/http

class BaseRequestOptions

class BaseRequestOptions extends RequestOptions {}

• Subclass of RequestOptions, with default values.

  Default values: * method: * headers: empty Headers object

  This class could be extended and bound to the RequestOptions class when configuring an Injector, in order to override the default options used by Http to create and send .

  import {BaseRequestOptions, RequestOptions} from '@angular/http';
  
  class MyOptions extends BaseRequestOptions {
    search: string = 'coreTeam=true';
  }
  
  {provide: RequestOptions, useClass: MyOptions};

  The options could also be extended when manually creating a Request object.

  import {BaseRequestOptions, Request, RequestMethod} from '@angular/http';
  
  const options = new BaseRequestOptions();
  const req = new Request(options.merge({
    method: RequestMethod.Post,
    url: 'https://google.com'
  }));
  console.log('req.method:', RequestMethod[req.method]); // Post
  console.log('options.url:', options.url); // null
  console.log('req.url:', req.url); // https://google.com

  Deprecated

  see https://angular.io/guide/http

class BaseResponseOptions

class BaseResponseOptions extends ResponseOptions {}

• Subclass of ResponseOptions, with default values.

  Default values: * status: 200 * headers: empty Headers object

  This class could be extended and bound to the ResponseOptions class when configuring an Injector, in order to override the default options used by Http to create .

  ### Example

  import {provide} from '@angular/core';
  import {bootstrap} from '@angular/platform-browser/browser';
  import {HTTP_PROVIDERS, Headers, Http, BaseResponseOptions, ResponseOptions} from
  '@angular/http';
  import {App} from './myapp';
  
  class MyOptions extends BaseResponseOptions {
    headers:Headers = new Headers({network: 'github'});
  }
  
  bootstrap(App, [HTTP_PROVIDERS, {provide: ResponseOptions, useClass: MyOptions}]);

  The options could also be extended when manually creating a Response object.

  ### Example

  import {BaseResponseOptions, Response} from '@angular/http';
  
  var options = new BaseResponseOptions();
  var res = new Response(options.merge({
    body: 'Angular',
    headers: new Headers({framework: 'angular'})
  }));
  console.log('res.headers.get("framework"):', res.headers.get('framework')); // angular
  console.log('res.text():', res.text()); // Angular;

  Deprecated

  see https://angular.io/guide/http

class BrowserXhr

class BrowserXhr {}

• A backend for http that uses the XMLHttpRequest browser API.

  Take care not to evaluate this in non-browser contexts.

  Deprecated

  see https://angular.io/guide/http

class Connection

abstract class Connection {}

• Abstract class from which real connections are derived.

  Deprecated

  see https://angular.io/guide/http

class ConnectionBackend

abstract class ConnectionBackend {}

• Abstract class from which real backends are derived.

  The primary purpose of a ConnectionBackend is to create new connections to fulfill a given Request.

  Deprecated

  see https://angular.io/guide/http

class CookieXSRFStrategy

class CookieXSRFStrategy implements XSRFStrategy {}

• XSRFConfiguration sets up Cross Site Request Forgery (XSRF) protection for the application using a cookie. See https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF) for more information on XSRF.

  Applications can configure custom cookie and header names by binding an instance of this class with different cookieName and headerName values. See the main HTTP documentation for more details.

  Deprecated

  see https://angular.io/guide/http

class Headers

class Headers {}

• Polyfill for [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers/Headers), as specified in the [Fetch Spec](https://fetch.spec.whatwg.org/#headers-class).

  The only known difference between this Headers implementation and the spec is the lack of an entries method.

  ### Example

  import {Headers} from '@angular/http';
  
  var firstHeaders = new Headers();
  firstHeaders.append('Content-Type', 'image/jpeg');
  console.log(firstHeaders.get('Content-Type')) //'image/jpeg'
  
  // Create headers from Plain Old JavaScript Object
  var secondHeaders = new Headers({
    'X-My-Custom-Header': 'Angular'
  });
  console.log(secondHeaders.get('X-My-Custom-Header')); //'Angular'
  
  var thirdHeaders = new Headers(secondHeaders);
  console.log(thirdHeaders.get('X-My-Custom-Header')); //'Angular'

  Deprecated

  see https://angular.io/guide/http

class Http

class Http {}

• Performs http requests using XMLHttpRequest as the default backend.

  Http is available as an injectable class, with methods to perform http requests. Calling request returns an Observable which will emit a single Response when a response is received.

  ### Example

  import {Http, HTTP_PROVIDERS} from '@angular/http';
  import {map} from 'rxjs/operators';
  
  @Component({
    selector: 'http-app',
    viewProviders: [HTTP_PROVIDERS],
    templateUrl: 'people.html'
  })
  class PeopleComponent {
    constructor(http: Http) {
      http.get('people.json')
        // Call map on the response observable to get the parsed people object
        .pipe(map(res => res.json()))
        // Subscribe to the observable to get the parsed people object and attach it to the
        // component
        .subscribe(people => this.people = people);
    }
  }

  ### Example

  http.get('people.json').subscribe((res:Response) => this.people = res.json());

  The default construct used to perform requests, XMLHttpRequest, is abstracted as a "Backend" ( XHRBackend in this case), which could be mocked with dependency injection by replacing the XHRBackend provider, as in the following example:

  ### Example

  import {BaseRequestOptions, Http} from '@angular/http';
  import {MockBackend} from '@angular/http/testing';
  var injector = Injector.resolveAndCreate([
    BaseRequestOptions,
    MockBackend,
    {provide: Http, useFactory:
        function(backend, defaultOptions) {
          return new Http(backend, defaultOptions);
        },
        deps: [MockBackend, BaseRequestOptions]}
  ]);
  var http = injector.get(Http);
  http.get('request-from-mock-backend.json').subscribe((res:Response) => doSomething(res));

  Deprecated

  see https://angular.io/guide/http

class HttpModule

class HttpModule {}

• The module that includes http's providers

  Deprecated

  see https://angular.io/guide/http

class Jsonp

class Jsonp extends Http {}

• Deprecated

  see https://angular.io/guide/http

class JSONPBackend

class JSONPBackend extends ConnectionBackend {}

• A ConnectionBackend that uses the JSONP strategy of making requests.

  Deprecated

  see https://angular.io/guide/http

class JSONPConnection

class JSONPConnection implements Connection {}

• Base class for an in-flight JSONP request.

  Deprecated

  see https://angular.io/guide/http

class JsonpModule

class JsonpModule {}

• The module that includes jsonp's providers

  Deprecated

  see https://angular.io/api/common/http/HttpClient#jsonp

class ɵangular_packages_http_http_e

class BrowserJsonp {}

class ɵangular_packages_http_http_f

abstract class Body {}

• HTTP request body used by both Request and Response https://fetch.spec.whatwg.org/#body

class QueryEncoder

class QueryEncoder {}

• Deprecated

  see https://angular.io/guide/http

class Request

class Request extends Body {}

• Creates Request instances from provided values.

  The Request's interface is inspired by the Request constructor defined in the [Fetch Spec](https://fetch.spec.whatwg.org/#request-class), but is considered a static value whose body can be accessed many times. There are other differences in the implementation, but this is the most significant.

  Request instances are typically created by higher-level classes, like Http and Jsonp, but it may occasionally be useful to explicitly create Request instances. One such example is when creating services that wrap higher-level services, like Http, where it may be useful to generate a Request with arbitrary headers and search params.

  import {Injectable, Injector} from '@angular/core';
  import {HTTP_PROVIDERS, Http, Request, RequestMethod} from '@angular/http';
  
  @Injectable()
  class AutoAuthenticator {
    constructor(public http:Http) {}
    request(url:string) {
      return this.http.request(new Request({
        method: RequestMethod.Get,
        url: url,
        search: 'password=123'
      }));
    }
  }
  
  var injector = Injector.resolveAndCreate([HTTP_PROVIDERS, AutoAuthenticator]);
  var authenticator = injector.get(AutoAuthenticator);
  authenticator.request('people.json').subscribe(res => {
    //URL should have included '?password=123'
    console.log('people', res.json());
  });

  Deprecated

  see https://angular.io/guide/http

class RequestOptions

class RequestOptions {}

• Creates a request options object to be optionally provided when instantiating a Request.

  This class is based on the RequestInit description in the [Fetch Spec](https://fetch.spec.whatwg.org/#requestinit).

  All values are null by default. Typical defaults can be found in the BaseRequestOptions class, which sub-classes RequestOptions.

  import {RequestOptions, Request, RequestMethod} from '@angular/http';
  
  const options = new RequestOptions({
    method: RequestMethod.Post,
    url: 'https://google.com'
  });
  const req = new Request(options);
  console.log('req.method:', RequestMethod[req.method]); // Post
  console.log('options.url:', options.url); // https://google.com

  Deprecated

  see https://angular.io/guide/http

class Response

class Response extends Body {}

• Creates Response instances from provided values.

  Though this object isn't usually instantiated by end-users, it is the primary object interacted with when it comes time to add data to a view.

  ### Example

  http.request('my-friends.txt').subscribe(response => this.friends = response.text());

  The Response's interface is inspired by the Response constructor defined in the [Fetch Spec](https://fetch.spec.whatwg.org/#response-class), but is considered a static value whose body can be accessed many times. There are other differences in the implementation, but this is the most significant.

  Deprecated

  see https://angular.io/guide/http

class ResponseOptions

class ResponseOptions {}

• Creates a response options object to be optionally provided when instantiating a Response.

  This class is based on the ResponseInit description in the [Fetch Spec](https://fetch.spec.whatwg.org/#responseinit).

  All values are null by default. Typical defaults can be found in the BaseResponseOptions class, which sub-classes ResponseOptions.

  This class may be used in tests to build for mock responses (see MockBackend).

  ### Example

  import {ResponseOptions, Response} from '@angular/http';
  
  var options = new ResponseOptions({
    body: '{"name":"Jeff"}'
  });
  var res = new Response(options);
  
  console.log('res.json():', res.json()); // Object {name: "Jeff"}

  Deprecated

  see https://angular.io/guide/http

class URLSearchParams

class URLSearchParams {}

• Map-like representation of url search parameters, based on [URLSearchParams](https://url.spec.whatwg.org/#urlsearchparams) in the url living standard, with several extensions for merging URLSearchParams objects: - setAll() - appendAll() - replaceAll()

  This class accepts an optional second parameter of $QueryEncoder, which is used to serialize parameters before making a request. By default, QueryEncoder encodes keys and values of parameters using encodeURIComponent, and then un-encodes certain characters that are allowed to be part of the query according to IETF RFC 3986: https://tools.ietf.org/html/rfc3986.

  These are the characters that are not encoded: ! $ \' ( ) * + , ; A 9 - . _ ~ ? /

  If the set of allowed query characters is not acceptable for a particular backend, QueryEncoder can be subclassed and provided as the 2nd argument to URLSearchParams.

  import {URLSearchParams, QueryEncoder} from '@angular/http';
  class MyQueryEncoder extends QueryEncoder {
    encodeKey(k: string): string {
      return myEncodingFunction(k);
    }
  
    encodeValue(v: string): string {
      return myEncodingFunction(v);
    }
  }
  
  let params = new URLSearchParams('', new MyQueryEncoder());

  Deprecated

  see https://angular.io/guide/http

class XHRBackend

class XHRBackend implements ConnectionBackend {}

• Creates XHRConnection instances.

  This class would typically not be used by end users, but could be overridden if a different backend implementation should be used, such as in a node backend.

  ### Example

  import {Http, MyNodeBackend, HTTP_PROVIDERS, BaseRequestOptions} from '@angular/http';
  @Component({
    viewProviders: [
      HTTP_PROVIDERS,
      {provide: Http, useFactory: (backend, options) => {
        return new Http(backend, options);
      }, deps: [MyNodeBackend, BaseRequestOptions]}]
  })
  class MyComponent {
    constructor(http:Http) {
      http.request('people.json').subscribe(res => this.people = res.json());
    }
  }

  Deprecated

  see https://angular.io/guide/http

class XHRConnection

class XHRConnection implements Connection {}

• Creates connections using XMLHttpRequest. Given a fully-qualified request, an XHRConnection will immediately create an XMLHttpRequest object and send the request.

  This class would typically not be created or interacted with directly inside applications, though the MockConnection may be interacted with in tests.

  Deprecated

  see https://angular.io/guide/http

class XSRFStrategy

abstract class XSRFStrategy {}

• An XSRFStrategy configures XSRF protection (e.g. via headers) on an HTTP request.

  Deprecated

  see https://angular.io/guide/http

interface ɵangular_packages_http_http_d

interface RequestArgs extends RequestOptionsArgs {}

• Required structure when constructing new Request();

interface RequestOptionsArgs

interface RequestOptionsArgs {}

• Interface for options to construct a RequestOptions, based on [RequestInit](https://fetch.spec.whatwg.org/#requestinit) from the Fetch spec.

  Deprecated

  see https://angular.io/guide/http

interface ResponseOptionsArgs

interface ResponseOptionsArgs {}

• Interface for options to construct a Response, based on [ResponseInit](https://fetch.spec.whatwg.org/#responseinit) from the Fetch spec.

  Deprecated

  see https://angular.io/guide/http

enum ReadyState

enum ReadyState {
    Unsent = 0,
    Open = 1,
    HeadersReceived = 2,
    Loading = 3,
    Done = 4,
    Cancelled = 5,
}

• All possible states in which a connection can be, based on [States](http://www.w3.org/TR/XMLHttpRequest/#states) from the XMLHttpRequest spec, but with an additional "CANCELLED" state.

  Deprecated

  see https://angular.io/guide/http

enum RequestMethod

enum RequestMethod {
    Get = 0,
    Post = 1,
    Put = 2,
    Delete = 3,
    Options = 4,
    Head = 5,
    Patch = 6,
}

• Supported http methods.

  Deprecated

  see https://angular.io/guide/http

enum ResponseContentType

enum ResponseContentType {
    Text = 0,
    Json = 1,
    ArrayBuffer = 2,
    Blob = 3,
}

• Define which buffer to use to store the response

  Deprecated

  see https://angular.io/guide/http

enum ResponseType

enum ResponseType {
    Basic = 0,
    Cors = 1,
    Default = 2,
    Error = 3,
    Opaque = 4,
}

• Acceptable response types to be associated with a Response, based on [ResponseType](https://fetch.spec.whatwg.org/#responsetype) from the Fetch spec.

  Deprecated

  see https://angular.io/guide/http