a755b715ed
The Router use the type `Params` for all of:
- position parameters,
- matrix parameters,
- query parameters.
`Params` is defined as follow `type Params = {[key: string]: any}`
Because parameters can either have single or multiple values, the type should
actually be `type Params = {[key: string]: string | string[]}`.
The client code often assumes that parameters have single values, as in the
following exemple:
```
class MyComponent {
sessionId: Observable<string>;
constructor(private route: ActivatedRoute) {}
ngOnInit() {
this.sessionId = this.route
.queryParams
.map(params => params['session_id'] || 'None');
}
}
```
The problem here is that `params['session_id']` could be `string` or `string[]`
but the error is not caught at build time because of the `any` type.
Fixing the type as describe above would break the build because `sessionId`
would becomes an `Observable<string | string[]>`.
However the client code knows if it expects a single or multiple values. By
using the new `ParamMap` interface the user code can decide when it needs a
single value (calling `ParamMap.get(): string`) or multiple values (calling
`ParamMap.getAll(): string[]`).
The above exemple should be rewritten as:
```
class MyComponent {
sessionId: Observable<string>;
constructor(private route: ActivatedRoute) {}
ngOnInit() {
this.sessionId = this.route
.queryParamMap
.map(paramMap => paramMap.get('session_id') || 'None');
}
}
```
Added APIs:
- `interface ParamMap`,
- `ActivatedRoute.paramMap: ParamMap`,
- `ActivatedRoute.queryParamMap: ParamMap`,
- `ActivatedRouteSnapshot.paramMap: ParamMap`,
- `ActivatedRouteSnapshot.queryParamMap: ParamMap`,
- `UrlSegment.parameterMap: ParamMap`
40 lines
1.4 KiB
TypeScript
40 lines
1.4 KiB
TypeScript
/**
|
|
* @license
|
|
* Copyright Google Inc. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
|
|
import {ParamMap, convertToParamMap} from '../src/shared';
|
|
|
|
describe('ParamsMap', () => {
|
|
it('should returns whether a parameter is present', () => {
|
|
const map = convertToParamMap({single: 's', multiple: ['m1', 'm2']});
|
|
expect(map.has('single')).toEqual(true);
|
|
expect(map.has('multiple')).toEqual(true);
|
|
expect(map.has('not here')).toEqual(false);
|
|
});
|
|
|
|
it('should support single valued parameters', () => {
|
|
const map = convertToParamMap({single: 's', multiple: ['m1', 'm2']});
|
|
expect(map.get('single')).toEqual('s');
|
|
expect(map.get('multiple')).toEqual('m1');
|
|
});
|
|
|
|
it('should support multiple valued parameters', () => {
|
|
const map = convertToParamMap({single: 's', multiple: ['m1', 'm2']});
|
|
expect(map.getAll('single')).toEqual(['s']);
|
|
expect(map.getAll('multiple')).toEqual(['m1', 'm2']);
|
|
});
|
|
|
|
it('should return `null` when a single valued element is absent', () => {
|
|
const map = convertToParamMap({});
|
|
expect(map.get('name')).toEqual(null);
|
|
});
|
|
|
|
it('should return `[]` when a mulitple valued element is absent', () => {
|
|
const map = convertToParamMap({});
|
|
expect(map.getAll('name')).toEqual([]);
|
|
});
|
|
}); |