Steuerzeichen-String umwandeln in "echtes" Steuerzeichen

[bogdan]

Habe ein String Array mit Steuerzeichen-Strings:

Code:

const
  sZeichen : Array [1..3] of String = ('#128064', '#128125', '#128148');

Wie kann ich den String in ein echtes Steuerzeichen umwandeln um zb. folgendes machen zu können

Code:

sText := StringReplace(sText, #128064, '', [rfReplaceAll, rfIgnoreCase]); // funktioniert

Und sol wollte ich es anwenden, was aber nicht funktioniert:

Code:

for i := Low(sZeichen) to High(sZeichen) do
begin
  sText := StringReplace(sText, sZeichen[i], '', [rfReplaceAll, rfIgnoreCase]); // funktioniert natürlich nicht, weil String
  sText := StringReplace(sText, PChar(sZeichen[i]), '', [rfReplaceAll, rfIgnoreCase]); // funktioniert nicht
  sText := StringReplace(sText, PAnsiChar(AnsiString(sZeichen[i]), '', [rfReplaceAll, rfIgnoreCase]); // funktioniert auch nicht
end;

Was mache ich falsch?

[Der schöne Günther]

Die Drei Zeichen #128064, #128125 und #128148 stehen für "Eyes", "EXTRATERRESTRIAL ALIEN 👽 und "Broken heart". Was machst du für okkulte Sachen :shock:

Dein Array "sZeichen" ist falsch. Sie enthalten drei Strings wie z.B. "#128064". Das ist ein Text mit mehreren Zeichen. Du möchtest aber nur drei Zeichen mit der Nummer 128064 usw aus dem String entfernen. Der Methode StringReplace musst du aber Strings geben, keine Zeichen.

Einen String der nur dieses Zeichen enthält erstellst du entweder indem du eine lokale Variable (String) deklarierst und dort in jedem Durchlauf das Zeichen (Char) zuweist oder mit String.Create(..):

Delphi-Quellcode:

const
   forbiddenCharacter = #128064;
var
   stringOfForbiddenCharacter: String;
begin
   stringOfForbiddenCharacter := forbiddenCharacter;
   stringOfForbiddenCharacter := String.Create([forbiddenCharacter]);
   stringOfForbiddenCharacter := String.Create(forbiddenCharacter, 1);
end.

[bogdan]

Hallo Günther,

vielen Dank für deine Antwort.

Das Steuerzeichen-String soll als Quelle dienen.
Da sporadisch weitere Steuerzeichen hinzukommen, will ich nicht jedesmal im Quellcode ein Steuerzeichen einfügen, sondern möchte diesen aus einer zb. Datei oder Datenbank entnehmen, welche ich ohne weiteres immer wieder erweitern kann.
Deshalb ist es wichtig, dass ich das Steuerzeichen-String in ein "echtes" Steuerzeichen umwandeln kann.

Gibt es keine Funktion wie zb. "StringToSteuerZeichen"? :gruebel:

[samso]

Vielleicht so?

Delphi-Quellcode:

function StringToSteuerZeichen(const s: String): Char;
begin
  Result := Char(StrToInt(copy(s, 2, MaxInt)));
end;

[nahpets]

Du möchtest das machen:

Delphi-Quellcode:

sText := StringReplace(sText, #128064, '', [rfReplaceAll, rfIgnoreCase]); // funktioniert

Wenn Du aber mit Deinem Stringarray arbeitest, machst Du (soweit ich das verstehe) aber jenes:

Delphi-Quellcode:

sText := StringReplace(sText, '#128064', '', [rfReplaceAll, rfIgnoreCase]); // funktioniert

Müsste Dein Array nicht eher so aussehen?

Delphi-Quellcode:

const
  sZeichen : Array [1..3] of Char = (#128064, #128125, #128148);

[Der schöne Günther]

Zitat:

Zitat von bogdan (Beitrag 1375622)

Deshalb ist es wichtig, dass ich das Steuerzeichen-String in ein "echtes" Steuerzeichen umwandeln kann.

Gibt es keine Funktion wie zb. "StringToSteuerZeichen"?

Ich habe dir drei Möglichkeiten gezeigt.


Oder meinst du dass du, aus welchen Gründen auch immer, Strings (z.B. '#1234') schon vorliegen hast und diese nun zu Chars (z.B. #1234) machen möchtest?


//// Edit

Bist du sehr sicher mit diesen "großen" Zahlen? Der Delphi-Typ "Char" ist anscheinend fest ein Word (also von 0-65535). Die Länge von

Delphi-Quellcode:

alien: String = '��';

gibt Delphi lustigerweise auch mit 2 an, denn es sind zwei Character, vier Byte.

(http://www.fileformat.info/info/unic...f47d/index.htm)


// Edit2
Die Delphi-Praxis macht auch aus dem Alien-Emoji zwei Fragezeichen (der Browser konnte es). Delphi ist also nicht die einzige Software auf dem Planeten für die das zu spacig ist.

[bogdan]

nahpets:

Diese Variante habe ich aktuell im Code:

Zitat:

const
sZeichen : Array [1..3] of Char = (#128064, #128125, #128148);

Das Problem ist nur, dass ich bei jedem neuen ungewollten Zeichen den Quellcode erweitern muss.

Günther:

Zitat:

Strings (z.B. '#1234') schon vorliegen hast und diese nun zu Chars (z.B. #1234) machen möchtest?

ja, genau!

samso:

Zitat:

Result := Char(StrToInt(copy(s, 2, MaxInt)));

Das sollte der richtige Ansatz sein. Funktioniert leider nur bis #255.

[Der schöne Günther]

Gut, dann habe ich es jetzt erst richtig verstanden, sorry :oops:

Aber wie gesagt: Ein Char nimmt eh maximal 65535 auf. Um deinen Wert abzuspeichern bräuchtest du zwei Character.

[bogdan]

Zwei Character?
Wie soll das funktionieren?
Result := Char() + Char()

[nahpets]

Zitat:

Zitat von Der schöne Günther (Beitrag 1375630)

Oder meinst du dass du, aus welchen Gründen auch immer, Strings (z.B. '#1234') schon vorliegen hast und diese nun zu Chars (z.B. #1234) machen möchtest?

Genau da dürfte das Problem liegen:

Im Array steht '#1234', ersetzt werden soll aber #1234. Gesucht wird eine Methode, um aus '#1234' #1234 zu machen.

Einfacher wäre es, direkt ein Array mit Steuerzeichen zu machen, statt eine Array mit Zeichenfolgen, die so aussehen, wie Steuerzeichen im Delphiquelltext, wenn man deren mit # beginnenden Pedant nutzt.

Statt #1234 müsste doch auch Chr(1234) gehen, oder irre ich mich da?

In dem Fall könnte auch ein Array of Word (oder sowas) gehen und in der Ersätzroutine könnte es dann so aussehen:

Delphi-Quellcode:

const
  sZeichen : Array [1..3] of Word = (128064, 128125, 128148); 

sText := StringReplace(sText, Chr(128064), '', [rfReplaceAll, rfIgnoreCase]);

(Bitte nicht hauen, wenn ich mich da jetzt irre ;-))

Ok, wenn das Ganze nun nicht im Quelltext sein soll, dann hilft das Array so ja auch nicht.
Also z. B. eine Datei, die in jeder Zeile eine "Zahl" enthält, also

Code:

128064
128125
128148

Die Datei einlesen und dann zeilenweise abarbeiten.

Sinngemäß ungefähr sowas?

Delphi-Quellcode:

var
  sl : TStringList;
  i : Integer;
  ch : WideChar;
begin
  sl := TStringList.Create;
  sl.LoadFromFile('Steuerzeichen.cfg');
  for i := 0 to sl.Count - 1 do begin
    ch := WideChar(StrToInt(sl[i]));
    sText := StringReplace(sText, ch, '', [rfReplaceAll, rfIgnoreCase]); 
  end;
  sl.Free;
end;

Edit: Geht das bei aktuellen Delphis mit WideChar?
Laut Delphi-7-Hilfe handelt es sich um: "WideChar-Werte stellen Zeichen mit einer Länge von mehr als einem Byte dar."

[bogdan]

nahpets:
Genau in die Richtung soll es gehen, also aus einer Datei den String auslesen und in ein echtes Steuerzeichen umwandeln.

Aber wie der Günther schon schrieb habe ich das Problem, dass der Char max. 65535 aufnimmt und die Emoticons weit drüber liegen.

[Der schöne Günther]

Niemand zwingt uns ja mit Char zu arbeiten, vor allem da StringReplace(..) eh nur mit Strings arbeitet.

Ich persönlich habe es jetzt eine Weile versucht, aber ich scheitere ehrlich gesagt daran den String '128064' in einen String mit dem Alien-Emoji umzurechnen.

Ich dachte mache mir einen Integer mit dem Wert 128064, rechne das ein Byte-Array mit 4 Elementen und gebe das letztendlich an TEncoding.Unicode.GetBytes(meinArray) welches einen String liefert.

Leider klappt das auch nicht, das Byte-Array ist ein völlig anderes als

TEncoding.Unicode.GetBytes(stringMitAlienEmoji) liefert.


Wir brauchen einen Profi!

[samso]

Ja, das habe ich übersehen, dass wir es hier mit 4 Byte Unicode zu tun haben. Deshalb muss hier UCS4 zu UTF16 gewandelt werden. Damit das funktioniert wird Delphi ab 2009 benötigt.

Delphi-Quellcode:

function StringToSteuerZeichen(const s: String): String;
var
  C: Cardinal;
  sl, sh: Word;
begin
  C := StrToInt(copy(s, 2, MaxInt));
  if c>=$10000
  then begin
    dec(c, $10000);
    sl := c and $3FF;
    sl := sl or $DC00;  //$DC00 = $37 shl 10
    sh := c shr 10;
    sh := sh or $D800;  //$D800 = $36 shl 10
    SetLength(Result, 2);
    Result[1] := Char(sh);
    Result[2] := Char(sl);
  end
  else begin
    SetLength(Result, 1);
    Result[1] := Char(c);
  end;

Vielleicht bekommt ja irgend jemand heraus, wie man UCS4StringToUnicodeString benutzen muss, um zum richtigen Ergebnis zu kommen?

[bogdan]

samso:
Perfekt, es funktioniert :cheer:

Vielen Dank an Alle für Eure Zeit.

[nahpets]

Heißt das, dass dashier funktioniert

Delphi-Quellcode:

var
  sl : TStringList;
  i : Integer;
begin
  sl := TStringList.Create;
  sl.LoadFromFile('Steuerzeichen.cfg');
  for i := 0 to sl.Count - 1 do begin
    sText := StringReplace(sText, StringToSteuerZeichen(sl[i]), '', [rfReplaceAll, rfIgnoreCase]);
  end;
  sl.Free;
end;

wenn der Inhalt der Datei so

Code:

#128064
#128125
#128148

aussieht?

[freimatz]

Nein.

[samso]

Zitat:

Zitat von freimatz (Beitrag 1375647)

Nein.

Warum nicht? Genau so wie nahpets es schreibt, hätte ich gedacht funktioniert es.

[samso]

Wenn man lieber UCS4StringToUnicodeString benutzen möchte, dann geht das so:

Delphi-Quellcode:

function StringToSteuerZeichen(const s: String): String;
var
  c: Cardinal;
  t: UCS4String;
begin
  c := StrToInt(copy(s, 2, MaxInt));
  SetLength(t, 2);
  t[0] := UCS4Char(c);
  t[1] := UCS4Char(0);
  Result := UCS4StringToUnicodeString(t);
end;

[Fritzew]

In Delphi ist der UCS4 Deklariert als Cardinal

UCS4Char = type Cardinal;
und
UCS4String = array of UCS4Char;

Leider ist in der Function UCS4StringToUnicodeString ein Fehler.....
es wird immer ein UCS4 char zu wenig ausgewertet........
Also selber machen.

Delphi-Quellcode:

function myUCS4StringToUnicodeString(const S: UCS4String): UnicodeString;
var
  I: Integer;
  CharCount: Integer;
  Tmp: array of Char;
begin
  SetLength(Tmp, Length(S) * 2); //Maximum possible number of characters
  CharCount := -1;

  I := 0;
  while I < Length(S) do  // Removed -1
  begin
    if S[I] >= $10000 then
    begin
      Inc(CharCount);
      Tmp[CharCount] := WideChar((((S[I] - $00010000) shr 10) and $000003FF) or $D800);
      Inc(CharCount);
      Tmp[CharCount] := WideChar(((S[I] - $00010000) and $000003FF)or $DC00);
    end
    else
    begin
      Inc(CharCount);
      Tmp[CharCount] := WideChar(S[I]);
    end;

    Inc(I);
  end;

  SetString(Result, PChar(Tmp), CharCount + 1);
end;


procedure TForm32.Button1Click(Sender: TObject);
const
  u41: UCS4Char = 128064;
  u42: UCS4Char = 128125;
  u43: UCS4Char = 128148;

Var
  test: Ucs4String;
  temp: String;
begin

  test := [u41, u42, u43];

  temp := myUCS4StringToUnicodeString(test);
  ShowMessage(temp);
end;

[freimatz]

Ah Sorry, dachte es ginge immer um "in ein echtes Steuerzeichen umwandeln".
Das "StringReplace(sText, ..., '', [rfReplaceAll, rfIgnoreCase]);" löscht aber 8-)
Also so könnte es funktionieren. Vermutlich ist es aber umständlich und langsam.

Ggf, macht es Sinn die Liste im Speicher zu halten.
Ggf, macht es auch Sinn auf die Liste zu verzichten und gleich ganze Unicode-Blöcke zu löschen. Oder alle Surrogaten, oder alle combined Chars ...

[samso]

@Fritzew: Zu UCS4StringToUnicodeString:
Ja, so wie Du es schreibst würde ich das auch logischer finden. Du musst bei Dir noch die maximal Anzahl der Character vergößern.

Delphi-Quellcode:

  SetLength(Tmp, Length(S) * 2); //Maximum possible number of characters

[Fritzew]

stimmt danke

[bogdan]

Zitat:

Ggf, macht es Sinn die Liste im Speicher zu halten.

Ja, die Liste wird in ein globales Array gepackt und bei Bedarf verarbeitet.

Zitat:

Ggf, macht es auch Sinn auf die Liste zu verzichten und gleich ganze Unicode-Blöcke zu löschen. Oder alle Surrogaten, oder alle combined Chars ...

Daran hatte ich auch schon gedacht. Will aber zur Zeit den Prozess nicht unnötig aufblähen, deshalb ist eine kleine Liste mit Erweiterungspotenziall im Moment noch OK und mit Samson's Funktion tut es einwandfrei.

[samso]

Leider habe ich erst jetzt die ultimative Funktion gefunden mit der man das realisieren kann... :oops:

Delphi-Quellcode:

function StringToSteuerZeichen(const s: String): String;
begin
  Result := Char.ConvertFromUtf32(StrToInt(copy(s, 2, MaxInt)));
end;