TypeScript StringWrapper.charCodeAt方法代码示例

 scanComplexOperator(start:int, code:int, one:string, two:string):Token {
   assert(this.peek == StringWrapper.charCodeAt(one, 0));
   this.advance();
   var str:string = one;
   if (this.peek == code) {
     this.advance();
     str += two;
   }
   assert(SetWrapper.has(OPERATORS, str));
   return newOperatorToken(start, str);
 }

 /**
  * Tokenize a 2/3 char long operator
  *
  * @param start start index in the expression
  * @param one first symbol (always part of the operator)
  * @param twoCode code point for the second symbol
  * @param two second symbol (part of the operator when the second code point matches)
  * @param threeCode code point for the third symbol
  * @param three third symbol (part of the operator when provided and matches source expression)
  * @returns {Token}
  */
 scanComplexOperator(start: number, one: string, twoCode: number, two: string, threeCode?: number,
                     three?: string): Token {
   assert(this.peek == StringWrapper.charCodeAt(one, 0));
   this.advance();
   var str: string = one;
   if (this.peek == twoCode) {
     this.advance();
     str += two;
   }
   if (isPresent(threeCode) && this.peek == threeCode) {
     this.advance();
     str += three;
   }
   assert(SetWrapper.has(OPERATORS, str));
   return newOperatorToken(start, str);
 }

 scanOperator(start:int, str:string):Token {
   assert(this.peek == StringWrapper.charCodeAt(str, 0));
   assert(SetWrapper.has(OPERATORS, str));
   this.advance();
   return newOperatorToken(start, str);
 }

  scanToken():Token {
    var input = this.input,
      length = this.length,
      peek = this.peek,
      index = this.index;

    // Skip whitespace.
    while (peek <= $SPACE) {
      if (++index >= length) {
        peek = $EOF;
        break;
      } else {
        peek = StringWrapper.charCodeAt(input, index);
      }
    }

    this.peek = peek;
    this.index = index;

    if (index >= length) {
      return null;
    }

    // Handle identifiers and numbers.
    if (isIdentifierStart(peek)) return this.scanIdentifier();
    if (isDigit(peek)) return this.scanNumber(index);

    var start:int = index;
    switch (peek) {
      case $PERIOD:
        this.advance();
        return isDigit(this.peek) ? this.scanNumber(start) :
          newCharacterToken(start, $PERIOD);
      case $LPAREN:   case $RPAREN:
      case $LBRACE:   case $RBRACE:
      case $LBRACKET: case $RBRACKET:
      case $COMMA:
      case $COLON:
      case $SEMICOLON:
        return this.scanCharacter(start, peek);
      case $SQ:
      case $DQ:
        return this.scanString();
      case $HASH:
        return this.scanOperator(start, StringWrapper.fromCharCode(peek));
      case $PLUS:
      case $MINUS:
      case $STAR:
      case $SLASH:
      case $PERCENT:
      case $CARET:
      case $QUESTION:
        return this.scanOperator(start, StringWrapper.fromCharCode(peek));
      case $LT:
      case $GT:
      case $BANG:
      case $EQ:
        return this.scanComplexOperator(start, $EQ, StringWrapper.fromCharCode(peek), '=');
      case $AMPERSAND:
        return this.scanComplexOperator(start, $AMPERSAND, '&', '&');
      case $BAR:
        return this.scanComplexOperator(start, $BAR, '|', '|');
      case $TILDE:
        return this.scanComplexOperator(start, $SLASH, '~', '/');
      case $NBSP:
        while (isWhitespace(this.peek)) this.advance();
        return this.scanToken();
    }

    this.error(`Unexpected character [${StringWrapper.fromCharCode(peek)}]`, 0);
    return null;
  }

 advance() {
   this.peek = ++this.index >= this.length ? $EOF : StringWrapper.charCodeAt(this.input, this.index);
 }

function expectCharacterToken(token, index, character) {
  expect(character.length).toBe(1);
  expectToken(token, index);
  expect(token.isCharacter(StringWrapper.charCodeAt(character, 0))).toBe(true);
}