TypeScript RegExpWrapper.firstMatch方法代码示例

 _propertiesFromRule(rule): string {
   var cssText = rule.style.cssText;
   // TODO(sorvell): Safari cssom incorrectly removes quotes from the content
   // property. (https://bugs.webkit.org/show_bug.cgi?id=118045)
   // don't replace attr rules
   var attrRe = RegExpWrapper.create('[\'"]+|attr');
   if (rule.style.content.length > 0 &&
       !isPresent(RegExpWrapper.firstMatch(attrRe, rule.style.content))) {
     var contentRe = RegExpWrapper.create('content:[^;]*;');
     cssText =
         StringWrapper.replaceAll(cssText, contentRe, 'content: \'' + rule.style.content + '\';');
   }
   // TODO(sorvell): we can workaround this issue here, but we need a list
   // of troublesome properties to fix https://github.com/Polymer/platform/issues/53
   //
   // inherit rules can be omitted from cssText
   // TODO(sorvell): remove when Blink bug is fixed:
   // https://code.google.com/p/chromium/issues/detail?id=358273
   // var style = rule.style;
   // for (var i = 0; i < style.length; i++) {
   //  var name = style.item(i);
   //  var value = style.getPropertyValue(name);
   //  if (value == 'initial') {
   //    cssText += name + ': initial; ';
   //  }
   //}
   return cssText;
 }

 it('should write all data into a file', inject([AsyncTestCompleter], (async) => {
      createReporter({
        sampleId: 'someId',
        descriptions: [{'a': 2}],
        path: 'somePath',
        metrics: {'script': 'script time'}
      })
          .reportSample(
              [mv(0, 0, {'a': 3, 'b': 6})],
              [mv(0, 0, {'a': 3, 'b': 6}), mv(1, 1, {'a': 5, 'b': 9})]);
      var regExp = /somePath\/someId_\d+\.json/g;
      expect(isPresent(RegExpWrapper.firstMatch(regExp, loggedFile['filename']))).toBe(true);
      var parsedContent = Json.parse(loggedFile['content']);
      expect(parsedContent).toEqual({
        'description':
            {'id': 'someId', 'description': {'a': 2}, 'metrics': {'script': 'script time'}},
        'completeSample': [
          {'timeStamp': '1970-01-01T00:00:00.000Z', 'runIndex': 0, 'values': {'a': 3, 'b': 6}}
        ],
        'validSample': [
          {'timeStamp': '1970-01-01T00:00:00.000Z', 'runIndex': 0, 'values': {'a': 3, 'b': 6}}, {
            'timeStamp': '1970-01-01T00:00:00.001Z',
            'runIndex': 1,
            'values': {'a': 5, 'b': 9}
          }
        ]
      });
      async.done();
    }));

function _extractMediaQuery(importRule) {
  var match = RegExpWrapper.firstMatch(_mediaQueryRe, importRule);
  if (isBlank(match))
    return null;
  var mediaQuery = match[1].trim();
  return (mediaQuery.length > 0) ? mediaQuery : null;
}

 static _format(value: number, style: NumberFormatStyle, digits: string, currency: string = null,
                currencyAsSymbol: boolean = false): string {
   if (isBlank(value)) return null;
   if (!isNumber(value)) {
     throw new InvalidPipeArgumentException(NumberPipe, value);
   }
   var minInt = 1, minFraction = 0, maxFraction = 3;
   if (isPresent(digits)) {
     var parts = RegExpWrapper.firstMatch(_re, digits);
     if (isBlank(parts)) {
       throw new BaseException(`${digits} is not a valid digit info for number pipes`);
     }
     if (isPresent(parts[1])) {  // min integer digits
       minInt = NumberWrapper.parseIntAutoRadix(parts[1]);
     }
     if (isPresent(parts[3])) {  // min fraction digits
       minFraction = NumberWrapper.parseIntAutoRadix(parts[3]);
     }
     if (isPresent(parts[5])) {  // max fraction digits
       maxFraction = NumberWrapper.parseIntAutoRadix(parts[5]);
     }
   }
   return NumberFormatter.format(value, defaultLocale, style, {
     minimumIntegerDigits: minInt,
     minimumFractionDigits: minFraction,
     maximumFractionDigits: maxFraction,
     currency: currency,
     currencyAsSymbol: currencyAsSymbol
   });
 }

 MapWrapper.forEach(attrs, (attrValue, attrName) => {
   var bindParts = RegExpWrapper.firstMatch(BIND_NAME_REGEXP, attrName);
   if (isPresent(bindParts)) {
     if (isPresent(bindParts[1])) {
       // match: bind-prop
       this._bindProperty(bindParts[4], attrValue, current, newAttrs);
     } else if (isPresent(bindParts[2])) {
       // match: var-name / var-name="iden" / #name / #name="iden"
       var identifier = bindParts[4];
       var value = attrValue == '' ? '\$implicit' : attrValue;
       this._bindVariable(identifier, value, current, newAttrs);
     } else if (isPresent(bindParts[3])) {
       // match: on-event
       this._bindEvent(bindParts[4], attrValue, current, newAttrs);
     } else if (isPresent(bindParts[5])) {
       // match: [prop]
       this._bindProperty(bindParts[5], attrValue, current, newAttrs);
     } else if (isPresent(bindParts[6])) {
       // match: (event)
       this._bindEvent(bindParts[6], attrValue, current, newAttrs);
     }
   } else {
     var expr = this._parser.parseInterpolation(
       attrValue, current.elementDescription
     );
     if (isPresent(expr)) {
       this._bindPropertyAst(attrName, expr, current, newAttrs);
     }
   }
 });

 _applySimpleSelectorScope(selector, scopeSelector, hostSelector) {
   if (isPresent(RegExpWrapper.firstMatch(_polyfillHostRe, selector))) {
     var replaceBy = this.strictStyling ? `[${hostSelector}]` : scopeSelector;
     selector = StringWrapper.replace(selector, _polyfillHostNoCombinator, replaceBy);
     return StringWrapper.replaceAll(selector, _polyfillHostRe, replaceBy + ' ');
   } else {
     return scopeSelector + ' ' + selector;
   }
 }

 _propertiesFromRule(rule) {
   var cssText = rule.style.cssText;
   var attrRe = RegExpWrapper.create('[\'"]+|attr');
   if (rule.style.content.length > 0 && !isPresent(RegExpWrapper.firstMatch(attrRe, rule.style.content))) {
     var contentRe = RegExpWrapper.create('content:[^;]*;');
     cssText = StringWrapper.replaceAll(cssText, contentRe, 'content: \'' + rule.style.content + '\';');
   }
   return cssText;
 }

    events.forEach((event) => {
      var ph = event['ph'];
      var name = event['name'];
      var microIterations = 1;
      var microIterationsMatch = RegExpWrapper.firstMatch(_MICRO_ITERATIONS_REGEX, name);
      if (isPresent(microIterationsMatch)) {
        name = microIterationsMatch[1];
        microIterations = NumberWrapper.parseInt(microIterationsMatch[2], 10);
      }

      if (StringWrapper.equals(ph, 'b') && StringWrapper.equals(name, markName)) {
        markStartEvent = event;
      } else if (StringWrapper.equals(ph, 'e') && StringWrapper.equals(name, markName)) {
        markEndEvent = event;
      }
      if (isPresent(markStartEvent) && isBlank(markEndEvent) &&
          event['pid'] === markStartEvent['pid']) {
        if (StringWrapper.equals(ph, 'B') || StringWrapper.equals(ph, 'b')) {
          if (isBlank(intervalStarts[name])) {
            intervalStartCount[name] = 1;
            intervalStarts[name] = event;
          } else {
            intervalStartCount[name]++;
          }
        } else if ((StringWrapper.equals(ph, 'E') || StringWrapper.equals(ph, 'e')) &&
                   isPresent(intervalStarts[name])) {
          intervalStartCount[name]--;
          if (intervalStartCount[name] === 0) {
            var startEvent = intervalStarts[name];
            var duration = (event['ts'] - startEvent['ts']);
            intervalStarts[name] = null;
            if (StringWrapper.equals(name, 'gc')) {
              result['gcTime'] += duration;
              var amount =
                  (startEvent['args']['usedHeapSize'] - event['args']['usedHeapSize']) / 1000;
              result['gcAmount'] += amount;
              var majorGc = event['args']['majorGc'];
              if (isPresent(majorGc) && majorGc) {
                result['majorGcTime'] += duration;
              }
              if (isPresent(intervalStarts['script'])) {
                gcTimeInScript += duration;
              }
            } else if (StringWrapper.equals(name, 'render')) {
              result['renderTime'] += duration;
              if (isPresent(intervalStarts['script'])) {
                renderTimeInScript += duration;
              }
            } else if (StringWrapper.equals(name, 'script')) {
              result['scriptTime'] += duration;
            } else if (isPresent(this._microMetrics[name])) {
              result[name] += duration / microIterations;
            }
          }
        }
      }
    });

 static parse(url: string, allowNonMatching: boolean): _AssetUrl {
   var match = RegExpWrapper.firstMatch(_ASSET_URL_RE, url);
   if (isPresent(match)) {
     return new _AssetUrl(match[1], match[2], match[3]);
   }
   if (allowNonMatching) {
     return null;
   }
   throw new BaseException(`Url ${url} is not a valid asset: url`);
 }

 scoped = ListWrapper.map(parts, function(p) {
   var t = StringWrapper.replaceAll(p.trim(), _polyfillHostRe, '');
   if (t.length > 0 && !ListWrapper.contains(splits, t) && !StringWrapper.contains(t, attrName)) {
     var re = RegExpWrapper.create('([^:]*)(:*)(.*)');
     var m = RegExpWrapper.firstMatch(re, t);
     if (isPresent(m)) {
       p = m[1] + attrName + m[2] + m[3];
     }
   }
   return p;
 }).join(sep);