Embarcadero Delphi
Zeichenketten

String-Typen

Delphi verfügt über die folgenden Zeichenfolgentypen (in Reihenfolge der Beliebtheit):

UnicodeString und AnsiString sind Referenzzähler und Copy-on-Write (COW).
ShortString und WideString werden nicht als Referenz gezählt und haben keine COW-Semantik.

Zeichenketten

uses
  System.Character;

var
  S1, S2: string;
begin
  S1 := 'Foo';
  S2 := ToLower(S1); // Convert the string to lower-case
  S1 := ToUpper(S2); // Convert the string to upper-case

Zeichen

uses
  Character;

var
  C1, C2: Char;
begin
  C1 := 'F';
  C2 := ToLower(C1); // Convert the char to lower-case
  C1 := ToUpper(C2); // Convert the char to upper-case

Die uses sollte System.Character wenn die Version XE2 oder höher ist.

Groß-und Kleinschreibung

uses
  SysUtils;

var
  S1, S2: string;
begin
  S1 := 'Foo';
  S2 := LowerCase(S1); // S2 := 'foo';
  S1 := UpperCase(S2); // S1 := 'FOO';

Zuordnung

Zuweisen von string zu verschiedenen String-Typen und wie sich die Laufzeitumgebung in Bezug auf sie verhält. Speicherzuordnung, Referenzzählung, indizierter Zugriff auf Zeichen und Compiler-Fehler, falls zutreffend beschrieben.

var
  SS5: string[5]; {a shortstring of 5 chars + 1 length byte, no trailing `0`}
  WS: Widestring; {managed pointer, with a bit of compiler support}
  AS: ansistring; {ansistring with the default codepage of the system}
  US: unicodestring; {default string type}
  U8: UTF8string;//same as AnsiString(65001)
  A1251: ansistring(1251); {ansistring with codepage 1251: Cryllic set}
  RB: RawbyteString; {ansistring with codepage 0: no conversion set}
begin
  SS5:= 'test'; {S[0] = Length(SS254) = 4, S[1] = 't'...S[5] = undefined}
  SS5:= 'test1'; {S[0] = 5, S[5] = '1', S[6] is out of bounds}
  SS5:= 'test12'; {compile time error}
  WS:= 'test'; {WS now points to a constant unicodestring hard compiled into the data segment}
  US:= 'test'+IntToStr(1); {New unicode string is created with reference count = 1}
  WS:= US; {SysAllocateStr with datacopied to dest, US refcount = 1 !}
  AS:= US; {the UTF16 in US is converted to "extended" ascii taking into account the codepage in AS possibly losing data in the process}  
  U8:= US; {safe copy of US to U8, all data is converted from UTF16 into UTF8}
  RB:= US; {RB = 'test1'#0 i.e. conversion into RawByteString uses system default codepage}
  A1251:= RB; {no conversion takes place, only reference copied. Ref count incremented }

Referenzzählung

Das Zählen von Referenzen auf Strings ist Thread-sicher. Sperren und Ausnahmebehandler werden verwendet, um den Prozess abzusichern. Betrachten Sie den folgenden Code mit Kommentaren, die angeben, wo der Compiler zur Kompilierzeit Code einfügt, um Referenzzählungen zu verwalten:

procedure PassWithNoModifier(S: string);
// prologue: Increase reference count of S (if non-negative),
//           and enter a try-finally block
begin
  // Create a new string to hold the contents of S and 'X'. Assign the new string to S,
  // thereby reducing the reference count of the string S originally pointed to and
  // brining the reference count of the new string to 1.
  // The string that S originally referred to is not modified.
  S := S + 'X';
end;
// epilogue: Enter the `finally` section and decrease the reference count of S, which is
//           now the new string. That count will be zero, so the new string will be freed.
    
procedure PassWithConst(const S: string);
var
  TempStr: string;
// prologue: Clear TempStr and enter a try-finally block. No modification of the reference
//           count of string referred to by S.
begin
  // Compile-time error: S is const.
  S := S + 'X';
  // Create a new string to hold the contents of S and 'X'. TempStr gets a reference count
  // of 1, and reference count of S remains unchanged.
  TempStr := S + 'X';
end;
// epilogue: Enter the `finally` section and decrease the reference count of TempStr,
//           freeing TempStr because its reference count will be zero.

Wie oben gezeigt, erfordert das Einführen einer temporären lokalen Zeichenfolge zum Speichern der Änderungen an einem Parameter den gleichen Aufwand wie das direkte Durchführen von Änderungen an diesem Parameter. Das Deklarieren einer Zeichenfolge const nur das Zählen von Referenzen, wenn der Zeichenfolgenparameter wirklich schreibgeschützt ist. Um zu vermeiden, dass Implementierungsdetails außerhalb einer Funktion durchsickern, sollten Sie immer einen der Parameter const , var oder out für den String verwenden.

Kodierungen

String-Typen wie UnicodeString, AnsiString, WideString und UTF8String werden mit ihrer jeweiligen Codierung in einem Speicher gespeichert (weitere Informationen finden Sie unter String-Typen). Das Zuweisen eines Typs eines Strings in einen anderen kann zu einer Konvertierung führen. Der Typ string ist so konzipiert, dass er unabhängig von der Codierung ist. Sie sollten niemals seine interne Darstellung verwenden.

Die Klasse Sysutils.TEncoding stellt die Methode GetBytes zum Konvertieren von string in TBytes (Array von Bytes) und GetString zum Konvertieren von TBytes in string TBytes . Die Klasse Sysutils.TEncoding bietet auch viele vordefinierte Kodierungen als Klasseneigenschaften.

Eine Möglichkeit, mit Codierungen umzugehen, besteht darin, in Ihrer Anwendung nur den string Typ zu verwenden und jedes Mal, wenn Sie eine bestimmte Codierung verwenden müssen, TEncoding zu verwenden - normalerweise bei E / A-Operationen, DLL-Aufrufen usw.

procedure EncodingExample;
var hello,response:string;
    dataout,datain:TBytes;
    expectedLength:integer;
    stringStream:TStringStream;
    stringList:TStringList;
     
begin
  hello := 'Hello World!Привет мир!';
  dataout := SysUtils.TEncoding.UTF8.GetBytes(hello); //Conversion to UTF8
  datain := SomeIOFunction(dataout); //This function expects input as TBytes in UTF8 and returns output as UTF8 encoded TBytes.
  response := SysUtils.TEncoding.UTF8.GetString(datain); //Convertsion from UTF8

  //In case you need to send text via pointer and length using specific encoding (used mostly for DLL calls)
  dataout := SysUtils.TEncoding.GetEncoding('ISO-8859-2').GetBytes(hello); //Conversion to ISO 8859-2
  DLLCall(addr(dataout[0]),length(dataout));
  //The same is for cases when you get text via pointer and length
  expectedLength := DLLCallToGetDataLength();
  setLength(datain,expectedLength);
  DLLCall(addr(datain[0]),length(datain));
  response := Sysutils.TEncoding.GetEncoding(1250).getString(datain);

   //TStringStream and TStringList can use encoding for I/O operations
   stringList:TStringList.create;
   stringList.text := hello;
   stringList.saveToFile('file.txt',SysUtils.TEncoding.Unicode);
   stringList.destroy;
   stringStream := TStringStream(hello,SysUtils.TEncoding.Unicode);
   stringStream.saveToFile('file2.txt');
   stringStream.Destroy;
end;