MyGetAverageWordLengthFromFile

[PeterPanino]

Hallo und schönen Tag!

Inspiriert von dem Wikipedia-Artikel Wortlänge habe ich als kleine Fingerübung eine Funktion geschrieben, um die durchschnittliche Wortlänge einer Textdatei bzw. eines definierbaren Abschnittes einer Textdatei zu ermitteln (wobei ich Wortlänge hier natürlich als Zeichenanzahl definiere):

Delphi-Quellcode:

program GetWordLengthFromFile;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  CodeSiteLogging,
  System.Classes,
  System.SysUtils;

function MyGetAverageWordLengthFromFile(const sFile: TFileName; MaxBytesToRead: Integer): Single;
var
  fs: TFileStream;
  ReadByte: Integer;
  SpacesCount, WordChars: Integer;
  ThisByte: Byte;
  SpaceRead, WordRead: Boolean;
begin
  Result := -1;
  fs := TFileStream.Create(sFile, fmOpenRead or fmShareDenyNone);
  try
    if MaxBytesToRead > fs.Size then
      MaxBytesToRead := fs.Size;

    SpacesCount := 0;
    WordChars := 0;
    SpaceRead := False;
    WordRead := False;
    for ReadByte := 1 to MaxBytesToRead do
    begin
      fs.Read(ThisByte, 1);
      //CodeSite.Send('ThisByte', IntToStr(ThisByte) + ' ' + Chr(ThisByte));
      if ThisByte = 32 then
      begin
        if WordRead then
        begin
          if not SpaceRead then
            Inc(SpacesCount);
          SpaceRead := True;
        end;
        if ReadByte = MaxBytesToRead then
          Dec(SpacesCount);
      end
      else
      begin
        WordRead := True;
        SpaceRead := False;
        Inc(WordChars);
      end;
    end;
    //CodeSite.Send('SpacesCount', SpacesCount);

    Result := WordChars / (SpacesCount + 1);
  finally
    FreeAndNil(fs);
  end;
end;

var
  ThisAverageWordLengthFromFile: Single;

begin
  try
    CodeSite.Send('Start');
    ThisAverageWordLengthFromFile := MyGetAverageWordLengthFromFile('C:\mytext.txt', 1000);
    CodeSite.Send('ThisAverageWordLengthFromFile', ThisAverageWordLengthFromFile);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
end.

Natürlich kann man die Funktion ganz einfach um eine größere Menge von Wortgrenze-Zeichen erweitern. Wie gesagt, es war ja nur eine Fingerübung.

Bisher hat es bei allen Textdateien sehr gut funktioniert. Findet jemand einen Fehler oder etwas zu verbessern?

[PeterPanino]

Ach ja, wenn die Textdatei nur Leerzeichen enthält, wäre diese Bedingung natürlich nützlich:

Delphi-Quellcode:

if SpacesCount <> -1 then
  Result := WordChars / (SpacesCount + 1);

[PeterPanino]

Auch sollte man

Delphi-Quellcode:

if ThisByte = 32 then

ersetzen durch

Delphi-Quellcode:

if Chr(ThisByte) in [' ', #13, #10] then

!

[Zacherl]

Komm schon .. du bist doch lange genug dabei, um zu wissen, dass man seine Posts 24h lang editieren kann :wink:

Variante für nicht-Dateien:

Delphi-Quellcode:

function AvgWordLength(const Text: String): Single;
var
  I: Integer;
  B: Boolean;
  TotalWordCount,
  TotalWordLength: UInt64;
begin
  Result := 0;
  B := false;
  TotalWordCount := 0;
  TotalWordLength := 0;
  for I := Low(Text) to High(Text) do
  begin
    if (not CharInSet(Text[I], [#00..#32, ',', ';', '.', ':'])) then
    begin
      if (not B) then
      begin
        B := true;
        Inc(TotalWordCount);
      end;
      Inc(TotalWordLength);
    end else
    begin
      B := false;
    end;
  end;
  if (TotalWordCount <> 0) then
  begin
    Result := TotalWordLength / TotalWordCount;
  end;
end;

Inklusive folgender Modifikationen:

1. CharInSet für Unicode Support
2. UInt64 statt Integer für Strings > 2GiB (sicher ist sicher :P)

Hier noch meine Version für Dateien:

Delphi-Quellcode:

function AvgWordLength(const Filename: String; MaxLength: UInt64 = 0): Single;
const
  BUFFERSIZE = 1024 * 16;
var
  FS: TFileStream;
  Buffer: array[0..BUFFERSIZE - 1] of AnsiChar; // Replace with AnsiChar for non-unicode files
  BytesRead,
  I: Integer;
  B: Boolean;
  TotalWordCount,
  TotalWordLength: UInt64;
begin
  Result := 0;
  FS := TFileStream.Create(Filename, fmOpenRead);
  try
    B := false;
    TotalWordCount := 0;
    TotalWordLength := 0;
    while (FS.Position < FS.Size) and ((MaxLength = 0) or (FS.Position < MaxLength)) do
    begin
      BytesRead := FS.Read(Buffer[0], BUFFERSIZE * SizeOf(Buffer[0]));
      for I := 0 to BytesRead div SizeOf(Buffer[0]) - 1 do
      begin
        if (not CharInSet(Buffer[I], [#00..#32, ',', ';', '.', ':'])) then
        begin
          if (not B) then
          begin
            B := true;
            Inc(TotalWordCount);
          end;
          Inc(TotalWordLength);
        end else
        begin
          B := false;
        end;
      end;
    end;
  finally
    FS.Free;
  end;
  if (TotalWordCount <> 0) then
  begin
    Result := TotalWordLength / TotalWordCount;
  end;
end;

Inklusive folgender Modifikationen:

1. Liest Datei Blockweise statt Byteweise aus (stark erhöhte Performance)

[PeterPanino]

Danke für den Code! Heute ist der Tag für Fingerübungen!

Mit deiner Funktion kriege ich aber bei der angehängten Textdatei einen Wert von 1,00, mit meiner Funktion (inkl. Berichtigungen) einen Wert von 9,21!

Hier ist nochmals meine berichtigte Funktion:

Delphi-Quellcode:

function MyGetAverageWordLengthFromFile(const sFile: TFileName; MaxBytesToRead: Integer; const WordBoundaries: string = ' ' + #13 + #10): Single;
var
  fs: TFileStream;
  ReadByte: Integer;
  SpacesCount, WordChars: Integer;
  ThisByte: Byte;
  SpaceRead, WordRead: Boolean;
begin
  Result := -1;
  fs := TFileStream.Create(sFile, fmOpenRead or fmShareDenyNone);
  try
    if MaxBytesToRead > fs.Size then
      MaxBytesToRead := fs.Size;

    SpacesCount := 0;
    WordChars := 0;
    SpaceRead := False;
    WordRead := False;
    for ReadByte := 1 to MaxBytesToRead do
    begin
      fs.Read(ThisByte, 1);
      //CodeSite.Send('ThisByte', IntToStr(ThisByte) + ' ' + Chr(ThisByte));
      //if ThisByte = 32 then
      //if Chr(ThisByte) in WordBoundaries then
      if Pos(Chr(ThisByte), WordBoundaries) > 0 then
      begin
        if WordRead then
        begin
          if not SpaceRead then
            Inc(SpacesCount);
          SpaceRead := True;
        end;
        if ReadByte = MaxBytesToRead then
          Dec(SpacesCount);
      end
      else
      begin
        WordRead := True;
        SpaceRead := False;
        Inc(WordChars);
      end;
    end;
    //CodeSite.Send('SpacesCount', SpacesCount);

    if SpacesCount <> -1 then
      Result := WordChars / (SpacesCount + 1);
  finally
    FreeAndNil(fs);
  end;
end;

[PeterPanino]

Habe es mit dem Taschenrechner nachgeprüft: 9,21 stimmt!
Mit deiner neuesten Version kriege ich jetzt 6,42.

[Zacherl]

Zitat:

Zitat von PeterPanino (Beitrag 1336108)

Habe es mit dem Taschenrechner nachgeprüft: 9,21 stimmt!
Mit deiner neuesten Version kriege ich jetzt 6,42.

Die deutschen Umlaute liegen im Bereich 128..255, wodurch sie bei meinem Filter als Trennzeichen erkannt wurden. Habe diese Range jetzt auch mal zugelassen, allerdings werden jetzt auch Zeichen wie € als korrekter Buchstabe erkannt.

Um das zu 100% korrekt berechnen zu können, müsste man das verwendete Alphabet der Textdatei kennen. Anders wird es immer nur eine Näherung sein.

[PeterPanino]

Zitat:

Zitat von Zacherl (Beitrag 1336110)

Zitat:

Zitat von PeterPanino (Beitrag 1336108)

Habe es mit dem Taschenrechner nachgeprüft: 9,21 stimmt!
Mit deiner neuesten Version kriege ich jetzt 6,42.

Die deutschen Umlaute liegen im Bereich 128..255, wodurch sie bei meinem Filter als Trennzeichen erkannt wurden. Habe diese Range jetzt auch mal zugelassen, allerdings werden jetzt auch Zeichen wie € als korrekter Buchstabe erkannt.

Um das zu 100% korrekt berechnen zu können, müsste man das verwendete Alphabet der Textdatei kennen. Anders wird es immer nur eine Näherung sein.

Stell dir vor, du zahlst 1 Million Euro auf dein Bankkonto ein und nach einer Woche ist leider nur noch die Hälfte davon da. Als du den Banker zur Rechenschaft ziehst, sagt dieser: "Ja, wir haben jetzt eine neue Banking-Software von Zacherl, die hat eine unheimlich gute Performance ..." :wink:

[Zacherl]

Zitat:

Zitat von PeterPanino (Beitrag 1336169)

Stell dir vor, du zahlst 1 Million Euro auf dein Bankkonto ein und nach einer Woche ist leider nur noch die Hälfte davon da. Als du den Banker zur Rechenschaft ziehst, sagt dieser: "Ja, wir haben jetzt eine neue Banking-Software von Zacherl, die hat eine unheimlich gute Performance ..." :wink:

Die Performanceoptimierung ist doch gar nicht das Problem, sondern das verwendete Alphabet. Meine Funktion war auf die standard printable-ASCII-Range (#32..#127) ausgerichtet. Das ist für englische Texte perfekt, aber um bei deinem Vergleich zu bleiben, muss eine Bank in Deutschland natürlich auch darauf achten, dass sie den Betrag in € und nicht in $ überweist.

Sprich: Für deutsche Texte muss man die Umlaute mit ins Alphabet aufnehmen, bei französischen Texten, sollte man alle Buchstaben mit Accent oder Circumflex beachten, und so weiter.

[Amateurprofi]

Für mich ist keine der bisher gezeigten Versionen überzeugend.

In #1 des TE werden alle Zeichen, die keine Alphazeichen sind als Zeichen eines Wortes angesehen.

In #4 werden immerhin Steuerzeichen und ein paar Interpunktionszeichen als nicht zu Worten gehörend angesehen, was auch nicht wirklich Sinn macht.
Nehmen wir den SourceCode des Autors dieses Beitrags als Beispiel, dann sehen wir auf Anhieb ein Dutzend weitere Zeichen, die offensichtlich in Texten vorkommen aber nicht zu Worten gehören.

Auch die Modifikation "2.UInt64 statt Integer für Strings > 2GiB (sicher ist sicher)" ist überflüssig, denn ein String mag > 2GiB sein, aber die Länge (Anzahl Zeichen) liegt innerhalb des Integerbereiches.
Der Autor selbst läuft ja mit

Delphi-Quellcode:

for I := Low(Text) to High(Text) do

durch den Text, wobei I als Integer deklariert ist.
Hier wird deutlich, dass als Integer deklarierte Zähler für Zeichen und Worte unter keinen Umständen "überlaufen" können.

Hier ist mein Vorschlag in dem die in der Windows API deklarierte Funktion "IsCharAlpha" benutzt wird um zu Worten gehörende Zeichen zu erkennen.
Auch das ist sicher nicht optimal, denn je nach Definition des Begriffs "Wort" kann diese Prüfung unvollständig sein.

Delphi-Quellcode:

type
   TFileMetrics=Record
      Chars:Integer;
      AlphaChars:Integer;
      ControlChars:Integer;
      Words:Integer;
      AvgWordLen:Single;
   End;

FUNCTION GetFileMetrics(Dsn:String):TFileMetrics;
var List:TStrings; S:String; P,P1:PChar;
begin
   FillChar(Result,SizeOf(Result),0);
   List:=TStringList.Create;
   try
      try
         List.LoadFromFile(Dsn);
         S:=List.Text;
         if S='' then Exit;
         P:=PChar(S);
         Result.Chars:=Length(S);
         while P^<>#0 do
            if IsCharAlpha(P^) then begin
               P1:=P;
               while IsCharAlpha(P^) do Inc(P);
               Inc(Result.AlphaChars,P-P1);
               Inc(Result.Words);
            end else begin
               if P^<#32 then Inc(Result.ControlChars);
               Inc(P);
            end;
         if Result.Words>0 then Result.AvgWordLen:=Result.AlphaChars/Result.Words;
      except
         on E:Exception do ShowMessage(E.Message);
      end;
   finally
      List.Free;
   end;
end;

PROCEDURE TMain.Test;
begin
   if OpenDialog.Execute then
      with GetFileMetrics(OpenDialog.FileName) do
         ShowMessage('Worte '+IntToStr(Words)+#13+
                     'Avg Länge '+FloatToStr(AvgWordLen)+#13+
                     'Zeichen '+IntToStr(Chars)+#13+'Davon:'+#13+
                     ' - Kontroll Zeichen '+IntToStr(ControlChars)+#13+
                     ' - Alpha Zeichen '+IntToStr(AlphaChars)+#13+
                     ' - Non Alpha Zeichen '+IntToStr(Chars-AlphaChars-ControlChars));
end;

[Zacherl]

Ich kann mich nur wiederholen: Ohne das korrekte Alphabet der Eingabedatei zu kennen, ist es unerheblich, ob man IsCharAlpha nimmt, oder eigenen Filter verwendet. Am Ende ist es trotzdem nicht perfekt. Warum IsCharAlpha auch nicht besser ist? Deshalb:

Zitat:

Determines whether a character is an alphabetical character. This determination is based on the semantics of the language selected by the user during setup or through Control Panel.

Viel Spaß auf einem deutschen Windows die Wörter in einer französischen Textdatei zu zählen.

Zitat:

Zitat von Amateurprofi (Beitrag 1336263)

ein String mag > 2GiB sein, aber die Länge (Anzahl Zeichen) liegt innerhalb des Integerbereiches.

Da hast du wohl recht, die Zählervariable habe ich tatsächlich vergessen zu ändern :wink: Die Version mit dem FileStream betrifft das allerdings nicht.

[Amateurprofi]

Zitat:

Zitat von Zacherl (Beitrag 1336302)

Ich kann mich nur wiederholen: Ohne das korrekte Alphabet der Eingabedatei zu kennen, ist es unerheblich, ob man IsCharAlpha nimmt, oder eigenen Filter verwendet. Am Ende ist es trotzdem nicht perfekt. Warum IsCharAlpha auch nicht besser ist? Deshalb:

Zitat:

Determines whether a character is an alphabetical character. This determination is based on the semantics of the language selected by the user during setup or through Control Panel.

Viel Spaß auf einem deutschen Windows die Wörter in einer französischen Textdatei zu zählen.

Bei mir gibt IsCharAlpha auch bei den von dir zitierten französischen Alpha Zeichen recht korrekt True zurück, ebenso bei zum Beipiel giechischen, kyrillischen und auch bei den asiatischen Zeichen.
Somit kann man bei der Verwendung von IsCharAlpha davon ausgehen, dass ein relativ korrektes Ergebnis geliefert wird, auch bei fremdländischen Texten.

Bei deinen Funktionen, die alles als Alpha Zeichen betrachten was kein Steuerzeichen (#0..#31), Blank, Komma, Semikolon, Punkt oder
Doppelpunkt ist kann man dagegen sicher sein, dass mit großer Zuverlässigkeit ein falsches Ergebnis geliefert wird, sogar bei rein deutschen Texten.

Nachstehend eine Tabelle, bei welchen Codeblöcken wieviel Zeichen als Alpha, Numeric oder nicht Alphanumeric erkannt werden.
Ich hätte gern auch die Tabelle für die einzelnen Zeichen geliefert, aber die erstellte PDF ist zu groß (17 MB).

Im Anhang ist ein kleines Programm, das die Tabellen erzeugt und anzeigt.
Mit dem Button "Details" kann man die Tabelle für alle Zeichen ins Clipboard stellen und dann zum Beispiel in eine Word Dokument kopieren (Word braucht dafür allerdings einige Zeit).

Code:

Start  Ende  Anzahl Alpha   Num Andere Block
----- -----  ------ ----- ----- ------ ----------------------------------------------
$0000 $FFFF   65536 47455   313  17768 Total
----- -----  ------ ----- ----- ------ ----------------------------------------------
$0000 $007F     128    52    10     66 Basic Latin
$0080 $00FF     128    65     3     60 Latin-1 Supplement
$0100 $017F     128   128     0      0 Latin Extended-A
$0180 $024F     208   208     0      0 Latin Extended-B
$0250 $02AF      96    96     0      0 IPA Extensions
$02B0 $02FF      80    24     0     56 Spacing Modifier Letters
$0300 $036F     112     0     0    112 Combining Diacritical Marks
$0370 $03FF     144   127     0     17 Greek and Coptic
$0400 $04FF     256   248     0      8 Cyrillic
$0500 $052F      48    36     0     12 Cyrillic Supplement
$0530 $058F      96    78     0     18 Armenian
$0590 $05FF     112    30     0     82 Hebrew
$0600 $06FF     256   152    20     84 Arabic
$0700 $074F      80    34     0     46 Syriac
$0750 $077F      48    48     0      0 Arabic Supplement
$0780 $07BF      64    39     0     25 Thaana
$07C0 $07FF      64    36    10     18 NKo
$0800 $083F      64     0     0     64 Samaritan
$0840 $085F      32     0     0     32 Mandaic
$08A0 $08FF      96     0     0     96 Arabic Extended-A
$0900 $097F     128    73    10     45 Devanagari
$0980 $09FF     128    53    10     65 Bengali
$0A00 $0A7F     128    51    10     67 Gurmukhi
$0A80 $0AFF     128    52    10     66 Gujarati
$0B00 $0B7F     128    53    10     65 Oriya
$0B80 $0BFF     128    37    10     81 Tamil
$0C00 $0C7F     128    54    10     64 Telugu
$0C80 $0CFF     128    53    10     65 Kannada
$0D00 $0D7F     128    59    10     59 Malayalam
$0D80 $0DFF     128    59     0     69 Sinhala
$0E00 $0E7F     128    73    10     45 Thai
$0E80 $0EFF     128    40    10     78 Lao
$0F00 $0FFF     256    49    10    197 Tibetan
$1000 $109F     160    74    20     66 Myanmar
$10A0 $10FF      96    82     0     14 Georgian
$1100 $11FF     256   240     0     16 Hangul Jamo
$1200 $137F     384   326     0     58 Ethiopic
$1380 $139F      32    16     0     16 Ethiopic Supplement
$13A0 $13FF      96    85     0     11 Cherokee
$1400 $167F     640   628     0     12 Unified Canadian Aboriginal Syllabics
$1680 $169F      32    26     0      6 Ogham
$16A0 $16FF      96    78     0     18 Runic
$1700 $171F      32    17     0     15 Tagalog
$1720 $173F      32    18     0     14 Hanunoo
$1740 $175F      32    18     0     14 Buhid
$1760 $177F      32    16     0     16 Tagbanwa
$1780 $17FF     128    54    10     64 Khmer
$1800 $18AF     176   130    10     36 Mongolian
$18B0 $18FF      80     0     0     80 Unified Canadian Aboriginal Syllabics Extended
$1900 $194F      80    29    10     41 Limbu
$1950 $197F      48    35     0     13 Tai Le
$1980 $19DF      96    49    10     37 New Tai Lue
$19E0 $19FF      32     0     0     32 Khmer Symbols
$1A00 $1A1F      32    23     0      9 Buginese
$1A20 $1AAF     144     0     0    144 Tai Tham
$1AB0 $1AFF      80     0     0     80 Combining Diacritical Marks Extended
$1B00 $1B7F     128    54    10     64 Balinese
$1B80 $1BBF      64    32    10     22 Sundanese
$1BC0 $1BFF      64     0     0     64 Batak
$1C00 $1C4F      80    39    10     31 Lepcha
$1C50 $1C7F      48    36    10      2 Ol Chiki
$1CC0 $1CCF      16     0     0     16 Sundanese Supplement
$1CD0 $1CFF      48     0     0     48 Vedic Extensions
$1D00 $1D7F     128   128     0      0 Phonetic Extensions
$1D80 $1DBF      64    64     0      0 Phonetic Extensions Supplement
$1DC0 $1DFF      64     0     0     64 Combining Diacritical Marks Supplement
$1E00 $1EFF     256   256     0      0 Latin Extended Additional
$1F00 $1FFF     256   218     0     38 Greek Extended
$2000 $206F     112     0     0    112 General Punctuation
$2070 $209F      48     7     0     41 Superscripts and Subscripts
$20A0 $20CF      48     0     0     48 Currency Symbols
$20D0 $20FF      48     0     0     48 Combining Diacritical Marks for Symbols
$2100 $214F      80    46     0     34 Letterlike Symbols
$2150 $218F      64    41     0     23 Number Forms
$2190 $21FF     112     0     0    112 Arrows
$2200 $22FF     256     0     0    256 Mathematical Operators
$2300 $23FF     256     0     0    256 Miscellaneous Technical
$2400 $243F      64     0     0     64 Control Pictures
$2440 $245F      32     0     0     32 Optical Character Recognition
$2460 $24FF     160     0     0    160 Enclosed Alphanumerics
$2500 $257F     128     0     0    128 Box Drawing
$2580 $259F      32     0     0     32 Block Elements
$25A0 $25FF      96     0     0     96 Geometric Shapes
$2600 $26FF     256     0     0    256 Miscellaneous Symbols
$2700 $27BF     192     0     0    192 Dingbats
$27C0 $27EF      48     0     0     48 Miscellaneous Mathematical Symbols-A
$27F0 $27FF      16     0     0     16 Supplemental Arrows-A
$2800 $28FF     256     0     0    256 Braille Patterns
$2900 $297F     128     0     0    128 Supplemental Arrows-B
$2980 $29FF     128     0     0    128 Miscellaneous Mathematical Symbols-B
$2A00 $2AFF     256     0     0    256 Supplemental Mathematical Operators
$2B00 $2BFF     256     0     0    256 Miscellaneous Symbols and Arrows
$2C00 $2C5F      96    94     0      2 Glagolitic
$2C60 $2C7F      32    29     0      3 Latin Extended-C
$2C80 $2CFF     128   101     0     27 Coptic
$2D00 $2D2F      48    38     0     10 Georgian Supplement
$2D30 $2D7F      80    55     0     25 Tifinagh
$2D80 $2DDF      96    79     0     17 Ethiopic Extended
$2DE0 $2DFF      32     0     0     32 Cyrillic Extended-A
$2E00 $2E7F     128     0     0    128 Supplemental Punctuation
$2E80 $2EFF     128     0     0    128 CJK Radicals Supplement
$2F00 $2FDF     224     0     0    224 Kangxi Radicals
$2FF0 $2FFF      16     0     0     16 Ideographic Description Characters
$3000 $303F      64    17     0     47 CJK Symbols and Punctuation
$3040 $309F      96     0     0     96 Hiragana
$30A0 $30FF      96     0     0     96 Katakana
$3100 $312F      48    41     0      7 Bopomofo
$3130 $318F      96    94     0      2 Hangul Compatibility Jamo
$3190 $319F      16     0     0     16 Kanbun
$31A0 $31BF      32    24     0      8 Bopomofo Extended
$31C0 $31EF      48     0     0     48 CJK Strokes
$31F0 $31FF      16     0     0     16 Katakana Phonetic Extensions
$3200 $32FF     256     0     0    256 Enclosed CJK Letters and Months
$3300 $33FF     256     0     0    256 CJK Compatibility
$3400 $4DBF    6592  6582     0     10 CJK Unified Ideographs Extension A
$4DC0 $4DFF      64     0     0     64 Yijing Hexagram Symbols
$4E00 $9FFF   20992 20932     0     60 CJK Unified Ideographs
$A000 $A48F    1168  1165     0      3 Yi Syllables
$A490 $A4CF      64     0     0     64 Yi Radicals
$A4D0 $A4FF      48     0     0     48 Lisu
$A500 $A63F     320   287    10     23 Vai
$A640 $A69F      96    69     0     27 Cyrillic Extended-B
$A6A0 $A6FF      96     0     0     96 Bamum
$A700 $A71F      32     0     0     32 Modifier Tone Letters
$A720 $A7FF     224   109     0    115 Latin Extended-D
$A800 $A82F      48    32     0     16 Syloti Nagri
$A830 $A83F      16     0     0     16 Common Indic Number Forms
$A840 $A87F      64    52     0     12 Phags-pa
$A880 $A8DF      96    50    10     36 Saurashtra
$A8E0 $A8FF      32     0     0     32 Devanagari Extended
$A900 $A92F      48    28    10     10 Kayah Li
$A930 $A95F      48    23     0     25 Rejang
$A960 $A97F      32     0     0     32 Hangul Jamo Extended-A
$A980 $A9DF      96     0     0     96 Javanese
$A9E0 $A9FF      32     0     0     32 Myanmar Extended-B
$AA00 $AA5F      96    52    10     34 Cham
$AA60 $AA7F      32     0     0     32 Myanmar Extended-A
$AA80 $AADF      96     0     0     96 Tai Viet
$AAE0 $AAFF      32     0     0     32 Meetei Mayek Extensions
$AB00 $AB2F      48     0     0     48 Ethiopic Extended-A
$AB30 $AB6F      64     0     0     64 Latin Extended-E
$AB70 $ABBF      80     0     0     80 Cherokee Supplement
$ABC0 $ABFF      64     0     0     64 Meetei Mayek
$AC00 $D7AF   11184 11172     0     12 Hangul Syllables
$D7B0 $D7FF      80     0     0     80 Hangul Jamo Extended-B
$D800 $DB7F     896     0     0    896 High Surrogates
$DB80 $DBFF     128     0     0    128 High Private Use Surrogates
$DC00 $DFFF    1024     0     0   1024 Low Surrogates
$E000 $F8FF    6400     0     0   6400 Private Use Area
$F900 $FAFF     512   467     0     45 CJK Compatibility Ideographs
$FB00 $FB4F      80    56     0     24 Alphabetic Presentation Forms
$FB50 $FDFF     688   591     0     97 Arabic Presentation Forms-A
$FE00 $FE0F      16     0     0     16 Variation Selectors
$FE10 $FE1F      16     0     0     16 Vertical Forms
$FE20 $FE2F      16     0     0     16 Combining Half Marks
$FE30 $FE4F      32     0     0     32 CJK Compatibility Forms
$FE50 $FE6F      32     0     0     32 Small Form Variants
$FE70 $FEFF     144   140     0      4 Arabic Presentation Forms-B
$FF00 $FFEF     240   104    10    126 Halfwidth and Fullwidth Forms
$FFF0 $FFFF      16     0     0     16 Specials

[Zacherl]

Zitat:

Zitat von Amateurprofi (Beitrag 1336383)

Bei mir gibt IsCharAlpha auch bei den von dir zitierten französischen Alpha Zeichen recht korrekt True zurück, ebenso bei zum Beipiel giechischen, kyrillischen und auch bei den asiatischen Zeichen.

Dann nehme ich selbstverständlich alles zurück und verfluche stattdessen Microsoft für die offensichtlich fehlerhafte Dokumentation der API :P