TypeScript router.DefaultUrlSerializer类代码示例

  serialize(tree: UrlTree): any {
    let dus = new DefaultUrlSerializer(),
        path = dus.serialize(tree);

    let at = new RegExp(/%40/g);

   // use your regex to replace as per your requirement.
    return path.replace(at, '@');
  }

function createState(
    url: string,
    outletName: string,
    isPageNav: boolean = false,
    isRoot: boolean = false) {
    const urlSerializer = new DefaultUrlSerializer();
    const stateUrlTree: UrlTree = urlSerializer.parse(url);
    const rootOutlets = stateUrlTree.root.children;

    return {
        segmentGroup: isRoot ? stateUrlTree.root : rootOutlets[outletName],
        isPageNavigation: isPageNav,
        isRootSegmentGroup: isRoot,
    };
}

 parse(url: any): UrlTree {
   let dus = new DefaultUrlSerializer();
   return dus.parse(url);
 }

describe('CustomUrlSerializer', () => {

  // The url serializer created for this app that correctly encodes parentheses
  let customUrlSerializer: CustomUrlSerializer;

  // The url serializer that comes with Angular 2 and doesn't encode parentheses
  let defaultUrlSerializer: DefaultUrlSerializer;

  beforeEach(() => {
      customUrlSerializer = new CustomUrlSerializer();
      defaultUrlSerializer = new DefaultUrlSerializer();
  });

  describe('parse', () => {

    describe('when a regular url without need for any special encoding/escaping is given', () => {
      it("the serializer's parsing method does not escape anything ", () => {

        let url: string = '/explore-code/agencies/DOJ';

        let expectedUrlSegments: Object[] = [
          {'path': 'explore-code', 'parameters': {}},
          {'path': 'agencies', 'parameters': {}},
          {'path': 'DOJ', 'parameters': {}}
        ];

        let actualUrlSegments = customUrlSerializer.parse(url).root.children.primary.segments;

        // Compare the value of the url segments, not whether they're techncially the same object in memory
        expect(JSON.stringify(actualUrlSegments)).toEqual(JSON.stringify(expectedUrlSegments));

      });
    });

    describe('when a url with escaped parentheses is used', () => {
      it('the serializer parsed and unescaped correctly', () => {

        let url: string = '/explore-code/agencies/DOJ/repos/Better%20View%20Pane%20Args%20%28Drupal%20module%29';

        let expected: Array<Object> = [
          {path: 'explore-code', parameters: {}},
          {path: 'agencies', parameters: {}},
          {path: 'DOJ', parameters: {}},
          {path: 'repos', parameters: {}},
          {path: 'Better View Pane Args (Drupal module)', parameters: {}}
        ];

        let actual = customUrlSerializer.parse(url).root.children.primary.segments;

        expect(JSON.stringify(actual)).toEqual(JSON.stringify(expected));

      });
    });

    describe('when a url with unescaped spaces and parentheses is used', () => {
      it('the serializer parsed correctly', () => {

        let url: string = '/explore-code/agencies/DOJ/repos/Better View Pane Args (Drupal module)';

        let expected: Array<Object> = [
          {path: 'explore-code', parameters: {}},
          {path: 'agencies', parameters: {}},
          {path: 'DOJ', parameters: {}},
          {path: 'repos', parameters: {}},
          {path: 'Better View Pane Args (Drupal module)', parameters: {}}
        ];

        let actual = customUrlSerializer.parse(url).root.children.primary.segments;

        expect(JSON.stringify(actual)).toEqual(JSON.stringify(expected));

      });
    });

  });

  describe('serialize', () => {
    describe('when a normal url tree without parentheses', () => {
      it('returns the correct url', () => {

        let originalUrl: string = '/explore-code/agencies/NASA';

        let urlTree: UrlTree = defaultUrlSerializer.parse(originalUrl);

        let actualUrl: string = customUrlSerializer.serialize(urlTree);

        /* we're basically checking if the customer url serializer
         * gives the same results as the default url serializer
         * when there are no parentheses present
         */
        expect(actualUrl).toEqual(originalUrl);

      });
    });

    describe('when a urlTree represnting a url with parenthese is given', () => {
      it('the Custom Url Serializer should correctly serialize with escaping', () => {

        let originalUrl: string = '/explore-code/agencies/NASA/' +
          'repos/Abaqus%20User%20Subroutine%20Verification%20%28abaverify%29';
//.........这里部分代码省略.........

      it('returns the correct url', () => {

        let originalUrl: string = '/explore-code/agencies/NASA';

        let urlTree: UrlTree = defaultUrlSerializer.parse(originalUrl);

        let actualUrl: string = customUrlSerializer.serialize(urlTree);

        /* we're basically checking if the customer url serializer
         * gives the same results as the default url serializer
         * when there are no parentheses present
         */
        expect(actualUrl).toEqual(originalUrl);

      });