TypeScript lang.NumberWrapper类代码示例

 scanNumber(start: int): Token {
   assert(isDigit(this.peek));
   var simple: boolean = (this.index === start);
   this.advance();  // Skip initial digit.
   while (true) {
     if (isDigit(this.peek)) {
       // Do nothing.
     } else if (this.peek == $PERIOD) {
       simple = false;
     } else if (isExponentStart(this.peek)) {
       this.advance();
       if (isExponentSign(this.peek)) this.advance();
       if (!isDigit(this.peek)) this.error('Invalid exponent', -1);
       simple = false;
     } else {
       break;
     }
     this.advance();
   }
   var str: string = this.input.substring(start, this.index);
   // TODO
   var value: number =
       simple ? NumberWrapper.parseIntAutoRadix(str) : NumberWrapper.parseFloat(str);
   return newNumberToken(start, value);
 }

 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
   });
 }

 return function validate(control: AbstractControl): {[key: string]: any} {
   if (NumberWrapper.isNaN(control.value) || control.value <= length) {
     return null;
   }
   return {
     mdMax: true
   };
 }

    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;
            }
          }
        }
      }
    });

 return new MockStep((parent, current, control) => {
   var parentCountStr = DOM.getAttribute(current.element, wrapperId);
   if (isPresent(parentCountStr)) {
     var parentCount = NumberWrapper.parseInt(parentCountStr, 10);
     while (parentCount > 0) {
       control.addParent(new CompileElement(el(`<a id="${wrapperId}#${nextElementId++}"></a>`)));
       parentCount--;
     }
   }
   logEntry(log, parent, current);
 });

 this._printStringRow(this._metricNames.map(metricName => {
   var samples = validSamples.map(measureValues => measureValues.values[metricName]);
   var mean = Statistic.calculateMean(samples);
   var cv = Statistic.calculateCoefficientOfVariation(samples, mean);
   var formattedMean = ConsoleReporter._formatNum(mean)
                           // Note: Don't use the unicode character for +- as it might cause
                           // hickups for consoles...
                           return NumberWrapper.isNaN(cv) ?
                           formattedMean :
                           `${formattedMean}+-${Math.floor(cv)}%`;
 }));

  scanString():Token {
    assert(this.peek == $SQ || this.peek == $DQ);
    var start:int = this.index;
    var quote:int = this.peek;
    this.advance();  // Skip initial quote.

    var buffer:StringJoiner;
    var marker:int = this.index;
    var input:string = this.input;

    while (this.peek != quote) {
      if (this.peek == $BACKSLASH) {
        if (buffer == null) buffer = new StringJoiner();
        buffer.add(input.substring(marker, this.index));
        this.advance();
        var unescapedCode:int;
        if (this.peek == $u) {
          // 4 character hex code for unicode character.
          var hex:string = input.substring(this.index + 1, this.index + 5);
          try {
            unescapedCode = NumberWrapper.parseInt(hex, 16);
          } catch (e) {
            this.error(`Invalid unicode escape [\\u${hex}]`, 0);
          }
          for (var i:int = 0; i < 5; i++) {
            this.advance();
          }
        } else {
          unescapedCode = unescape(this.peek);
          this.advance();
        }
        buffer.add(StringWrapper.fromCharCode(unescapedCode));
        marker = this.index;
      } else if (this.peek == $EOF) {
        this.error('Unterminated quote', 0);
      } else {
        this.advance();
      }
    }

    var last:string = input.substring(marker, this.index);
    this.advance();  // Skip terminating quote.

    // Compute the unescaped string value.
    var unescaped:string = last;
    if (buffer != null) {
      buffer.add(last);
      unescaped = buffer.toString();
    }
    return newStringToken(start, unescaped);
  }

 private _parseChromeVersion(userAgent: string): number {
   if (isBlank(userAgent)) {
     return -1;
   }
   var v = StringWrapper.split(userAgent, /Chrom(e|ium)\//g)[2];
   if (isBlank(v)) {
     return -1;
   }
   v = v.split('.')[0];
   if (isBlank(v)) {
     return -1;
   }
   return NumberWrapper.parseInt(v, 10);
 }

 scanNumber(start) {
   assert(isDigit(this.peek));
   var simple = (this.index === start);
   this.advance();
   while (true) {
     if (isDigit(this.peek)) {} else if (this.peek == $PERIOD) {
       simple = false;
     } else if (isExponentStart(this.peek)) {
       this.advance();
       if (isExponentSign(this.peek))
         this.advance();
       if (!isDigit(this.peek))
         this.error('Invalid exponent', -1);
       simple = false;
     } else {
       break;
     }
     this.advance();
   }
   var str = this.input.substring(start, this.index);
   var value = simple ? NumberWrapper.parseIntAutoRadix(str) : NumberWrapper.parseFloat(str);
   return newNumberToken(start, value);
 }

 scanString() {
   assert(this.peek == $SQ || this.peek == $DQ);
   var start = this.index;
   var quote = this.peek;
   this.advance();
   var buffer;
   var marker = this.index;
   var input = this.input;
   while (this.peek != quote) {
     if (this.peek == $BACKSLASH) {
       if (buffer == null)
         buffer = new StringJoiner();
       buffer.add(input.substring(marker, this.index));
       this.advance();
       var unescapedCode;
       if (this.peek == $u) {
         var hex = input.substring(this.index + 1, this.index + 5);
         try {
           unescapedCode = NumberWrapper.parseInt(hex, 16);
         } catch (e) {
           this.error(`Invalid unicode escape [\\u${hex}]`, 0);
         }
         for (var i = 0; i < 5; i++) {
           this.advance();
         }
       } else {
         unescapedCode = unescape(this.peek);
         this.advance();
       }
       buffer.add(StringWrapper.fromCharCode(unescapedCode));
       marker = this.index;
     } else if (this.peek == $EOF) {
       this.error('Unterminated quote', 0);
     } else {
       this.advance();
     }
   }
   var last = input.substring(marker, this.index);
   this.advance();
   var unescaped = last;
   if (buffer != null) {
     buffer.add(last);
     unescaped = buffer.toString();
   }
   return newStringToken(start, unescaped);
 }