Embarcadero Delphi
strings

Stringtypen

Delphi heeft de volgende stringtypen (in volgorde van populariteit):

UnicodeString en AnsiString zijn referentietellingen en copy-on-write (COW).
ShortString en WideString worden niet geteld als referentie en hebben geen COW-semantiek.

strings

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

chars

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

De uses moet System.Character als de versie XE2 of hoger is.

Kleine en hoofdletters

uses
  SysUtils;

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

toewijzing

String toewijzen aan verschillende stringtypen en hoe de runtime-omgeving zich daarover gedraagt. Geheugentoewijzing, referentietelling, geïndexeerde toegang tot tekens en compilerfouten, waar van toepassing kort beschreven.

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 }

Referentie tellen

Het tellen van referenties op tekenreeksen is thread-safe. Sloten en uitzonderingshandlers worden gebruikt om het proces te beveiligen. Overweeg de volgende code, met opmerkingen die aangeven waar de compiler code invoegt tijdens het compileren om referentietellingen te beheren:

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.

Zoals hierboven getoond, brengt het introduceren van tijdelijke lokale string om de wijzigingen aan een parameter te bevatten dezelfde overhead met zich mee als wijzigingen rechtstreeks in die parameter aanbrengen. Het declareren van een string const vermijdt alleen referentietelling wanneer de stringparameter echt alleen-lezen is. Om echter lekkende implementatiedetails buiten een functie te voorkomen, is het raadzaam om altijd een parameter const , var of out on string te gebruiken.

coderingen

Stringtypen zoals UnicodeString, AnsiString, WideString en UTF8String worden in een geheugen opgeslagen met hun respectieve codering (zie Stringtypen voor meer informatie). Het toewijzen van een type string aan een ander kan leiden tot een conversie. Type string is ontworpen om onafhankelijk van de codering te zijn - u mag de interne weergave ervan nooit gebruiken.

De klasse Sysutils.TEncoding biedt methode GetBytes voor het converteren van string naar TBytes (array van bytes) en GetString voor het converteren van TBytes naar string . De klasse Sysutils.TEncoding biedt ook veel vooraf gedefinieerde coderingen als klasse-eigenschappen.

Een manier hoe om te gaan met coderingen is om alleen gebruik maken van string typ uw toepassing en het gebruik TEncoding elke keer dat je nodig hebt om specifieke codering - meestal in I / O-bewerkingen, DLL gesprekken, etc ...

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;