String.prototype.charAt()

Die charAt()-Methode gibt das angegebene Zeichen eines Strings wieder.

Syntax

str.charAt(index)

Parameter

index

Eine Zahl zwischen 0 und 1 minus die Gesamtlänge des Strings. Ist kein index gegeben, ist dieser automatisch 0.

Wiedergegebener Wert

Ein String, der das Zeichen an der angegebenen index-Stelle wiedergibt. Der String ist leer, wenn index außerhalb der Reichweite liegt.
 

Beschreibung

Zeichen in einem String werden von links nach rechts indexiert. Der Index des ersten Zeichens ist 0, dabei ist der Index des letzten Zeichens eines Strings namens stringName stringName.length - 1. Wenn der Index außerhalb der Reichweite liegt, gibt JavaScript einen leeren String wieder.

Wenn kein Index bereitgestellt wird, ist dieser standardmäßig 0.

Beispiele

Wiedergabe von Zeichen an verschiedenen Stellen eines Strings

Das folgende Beispiel gibt Zeichen an verschiedenen Orten im String "Brave new world" wieder:

var anyString = 'Brave new world';
console.log("Das Zeichen bei Index 0   ist '" + anyString.charAt()   + "'"); 
// kein Index definiert, 0 als Standard genutzt

console.log("Das Zeichen bei Index 0   ist '" + anyString.charAt(0)   + "'");
console.log("Das Zeichen bei Index 1   ist '" + anyString.charAt(1)   + "'");
console.log("Das Zeichen bei Index 2   ist '" + anyString.charAt(2)   + "'");
console.log("Das Zeichen bei Index 3   ist '" + anyString.charAt(3)   + "'");
console.log("Das Zeichen bei Index 4   ist '" + anyString.charAt(4)   + "'");
console.log("Das Zeichen bei Index 999 ist '" + anyString.charAt(999) + "'");

Diese Zeilen geben folgendes wieder:

Das Zeichen bei Index 0   ist 'B'
Das Zeichen bei Index 0   ist 'B'
Das Zeichen bei Index 1   ist 'r'
Das Zeichen bei Index 2   ist 'a'
Das Zeichen bei Index 3   ist 'v'
Das Zeichen bei Index 4   ist 'e'
Das Zeichen bei Index 999 ist ''

Erhalten von vollständigen Zeichen

Das folgende versichert, dass der Gebrauch eines String-Loops immer das vollständige Zeichen wiedergibt - auch wenn der String Zeichen enthält, die nicht auf der mehrsprachigen Basisebene (MBE) vorhanden sind.

var str = 'A \uD87E\uDC04 Z'; // direkter Einsatz von nicht MBE-Zeichen auch möglich
for (var i = 0, chr; i < str.length; i++) {
  if ((chr = getWholeChar(str, i)) === false) {
    continue;
  }
  // Übernehme diese Zeile zu Beginn jedes Loops, 
  // gib den kompletten String und Iterator an
  // und gebe eine Variable wieder, die das individuelle Zeichen wiederspiegelt.

  console.log(chr);
}

function getWholeChar(str, i) {
  var code = str.charCodeAt(i);

  if (Number.isNaN(code)) {
    return ''; // Position not found
  }
  if (code < 0xD800 || code > 0xDFFF) {
    return str.charAt(i);
  }

  // High surrogate (could change last hex to 0xDB7F to treat high private
  // surrogates as single characters)
  if (0xD800 <= code && code <= 0xDBFF) {
    if (str.length <= (i + 1)) {
      throw 'High surrogate without following low surrogate';
    }
    var next = str.charCodeAt(i + 1);
      if (0xDC00 > next || next > 0xDFFF) {
        throw 'High surrogate without following low surrogate';
      }
      return str.charAt(i) + str.charAt(i + 1);
  }
  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
  if (i === 0) {
    throw 'Low surrogate without preceding high surrogate';
  }
  var prev = str.charCodeAt(i - 1);

  // (could change last hex to 0xDB7F to treat high private
  // surrogates as single characters)
  if (0xD800 > prev || prev > 0xDBFF) {
    throw 'Low surrogate without preceding high surrogate';
  }
  // We can pass over low surrogates now as the second component
  // in a pair which we have already processed
  return false;
}

In an ECMAScript 2016 environment which allows destructured assignment, the following is a more succinct and somewhat more flexible alternative in that it does incrementing for an incrementing variable automatically (if the character warrants it in being a surrogate pair).
In einer ECMAScript 2016-Umgebung, welche destruktive Benennung erlaubt, ist eine bündigere und  zu gewissem Grad flexiblere Alternative möglich, da es automatisch eine Erhöhung der entsprechenden Variable vornimmt (wenn das Zeichen
ein Ersatzpaar ist).

var str = 'A\uD87E\uDC04Z'; // direkter Einsatz von nicht MBE-Zeichen auch möglich
for (var i = 0, chr; i < str.length; i++) {
  [chr, i] = getWholeCharAndI(str, i);
  // Adapt this line at the top of each loop, passing in the whole string and
  // the current iteration and returning an array with the individual character
  // and 'i' value (only changed if a surrogate pair)
  // Übernehme diese Zeile zu Beginn jedes Loops, 
  // gib den kompletten String und Iterator an
  // und gebe einen Array wieder, der die individuellen Zeichen und 'i'-Wert wiederspiegelt
  // (nur geändert, wenn Ersatzpaar).

  console.log(chr);
}

function getWholeCharAndI(str, i) {
  var code = str.charCodeAt(i);

  if (Number.isNaN(code)) {
    return ''; // Position nicht gefunden
  }
  if (code < 0xD800 || code > 0xDFFF) {
    return [str.charAt(i), i]; // Normales Zeichen, 'i' bleibt gleich
  }

  // High surrogate (could change last hex to 0xDB7F to treat high private 
  // surrogates as single characters)
  if (0xD800 <= code && code <= 0xDBFF) {
    if (str.length <= (i + 1)) {
      throw 'High surrogate without following low surrogate';
    }
    var next = str.charCodeAt(i + 1);
      if (0xDC00 > next || next > 0xDFFF) {
        throw 'High surrogate without following low surrogate';
      }
      return [str.charAt(i) + str.charAt(i + 1), i + 1];
  }
  // Low surrogate (0xDC00 <= code && code <= 0xDFFF)
  if (i === 0) {
    throw 'Low surrogate without preceding high surrogate';
  }
  var prev = str.charCodeAt(i - 1);

  // (could change last hex to 0xDB7F to treat high private surrogates
  // as single characters)
  if (0xD800 > prev || prev > 0xDBFF) {
    throw 'Low surrogate without preceding high surrogate';
  }
  // Return the next character instead (and increment)
  return [str.charAt(i + 1), i + 1];
}

Korrigiere charAt(), um Zeichen der nicht mehrsprachigen Basisebene (MBE) zu unterstützen

While the example above may be more frequently useful for those wishing to support non-BMP characters (since it does not require the caller to know where any non-BMP character might appear), in the event that one does wish, in choosing a character by index, to treat the surrogate pairs within a string as the single characters they represent, one can use the following:

 Das obige Beispiel dürfte häufiger hilfreich sein für diejenigen, die nicht MBE-Zeichen unterstützen möchten (da man nicht wissen muss, wo nicht MBE-Zeichen vorkommen).  Falls man wünscht (durch Angabe eines Indexwerts) die Ersatzpaare innerhalb eines Strings als Einzelcharakter zu behandeln, kann man folgendes nutzen:

function fixedCharAt(str, idx) {
  var ret = '';
  str += '';
  var end = str.length;

  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  while ((surrogatePairs.exec(str)) != null) {
    var li = surrogatePairs.lastIndex;
    if (li - 2 < idx) {
      idx++;
    } else {
      break;
    }
  }

  if (idx >= end || idx < 0) {
    return '';
  }

  ret += str.charAt(idx);

  if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) {
    // Gehe eins weiter, da eins der Zeichen Teil eines Ersatzpaares ist
    ret += str.charAt(idx + 1);
  }
  return ret;
}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• String.prototype.indexOf()
• String.prototype.lastIndexOf()
• String.prototype.charCodeAt()
• String.prototype.codePointAt()
• String.prototype.split()
• String.fromCodePoint()
• JavaScript has a Unicode problem – Mathias Bynens