Bir dizeyi bir sınırlayıcıya göre bir dizi diziye bölme


85

Bir giriş dizesini bir sınırlayıcıya göre bir dizi diziye bölecek bir Delphi işlevi bulmaya çalışıyorum. Google'da çok şey buldum, ancak hepsinin kendi sorunları var gibi görünüyor ve hiçbirinin çalışmasını sağlayamadım.

Sadece: gibi bir dizeyi "word:doc,txt,docx"':' temelinde bir diziye bölmem gerekiyor. Sonuç olacaktır ['word', 'doc,txt,docx'].

Çalıştığını bildiği bir işlevi olan var mı?

teşekkür ederim

Yanıtlar:


87

bir dizeyi bölmek için TStrings.DelimitedText özelliğini kullanabilirsiniz

bu örneği kontrol et

program Project28;

{$APPTYPE CONSOLE}

uses
  Classes,
  SysUtils;

procedure Split(Delimiter: Char; Str: string; ListOfStrings: TStrings) ;
begin
   ListOfStrings.Clear;
   ListOfStrings.Delimiter       := Delimiter;
   ListOfStrings.StrictDelimiter := True; // Requires D2006 or newer.
   ListOfStrings.DelimitedText   := Str;
end;


var
   OutPutList: TStringList;
begin
   OutPutList := TStringList.Create;
   try
     Split(':', 'word:doc,txt,docx', OutPutList) ;
     Writeln(OutPutList.Text);
     Readln;
   finally
     OutPutList.Free;
   end;
end.

GÜNCELLEME

Bir açıklama için bu bağlantıya bakın StrictDelimiter.


22
Ne yazık ki birçok "eski" Delphi sürümünde (bunun hangi sürümde düzeltildiğinden emin değil) boşluk karakterinin her zaman sınırlayıcı olarak kullanılması etkisine sahip bir hata vardır . Bu yüzden dikkatli olun !!
Leo

16
Evet. StrictDelimiter'ı true olarak ayarlamak isteyeceksiniz ve StrictDelimiter özelliği Delphi sürümünüzde mevcut değilse bu tekniği kullanmayın! Ama eğer öyleyse, bu çok kullanışlıdır.
Mason Wheeler

3
Bu bir hata değildi, D1 veya D2'de (can sıkıcı) bir tasarım kararıydı. CommaText'in tüm alanları boşluklarla ve tırnak işaretleriyle kapatması gerekiyordu. Girişte boşluklu alanların etrafında çift tırnak işareti varsa, sonuç doğrudur.
Gerry Coll

1
Benim evcil hayvanımdan biri, insanların değişken / parametre adlarına gereksiz yere tür göstergeleri koymasıdır. Pascal kuvvetle yazıldığında - bu tip gösterge bu durumda olduğu gibi, yanlış olduğunda yanıltıcı karışıklığa gereksiz (parmak egzersiz çeşitliliği) yazarak ve açıklanmıştır: ArrayOfStrings değil olduğu gibi bir dizi (ve bu nedenle soruyu sorulduğu gibi yanıtlamaz) .
Deltics

6
Bu yanıta oy veren herkes için, sorunun soruda belirtildiği gibi bir dizi vermediğini lütfen unutmayın. Eksik gereksinim belirtimi bu sektörde büyük bir sorundur, belirtilen gereksinimleri göz ardı etmek ve istenmeyen bir şeyi teslim etmek başka bir büyük sorundur. Her ikisinin de onaylanması, kötü uygulamayı teşvik eder. ;)
Deltics

69

Bir Splitişlevi tasarlamaya gerek yoktur . Zaten bakın mevcut: Classes.ExtractStrings.

Aşağıdaki şekilde kullanın:

program Project1;

{$APPTYPE CONSOLE}

uses
  Classes;

var
  List: TStrings;
begin
  List := TStringList.Create;
  try
    ExtractStrings([':'], [], PChar('word:doc,txt,docx'), List);
    WriteLn(List.Text);
    ReadLn;
  finally
    List.Free;
  end;
end.

Ve soruyu tam olarak cevaplamak için; Lististenen diziyi şu öğelerle temsil eder:

List[0] = 'word'
List[1] = 'doc,txt,docx'

14
ExtractStrings çok esnek değildir: "Satır başları, satırsonu karakterleri ve tırnak karakterleri (tek veya çift) her zaman ayırıcı olarak kabul edilir."; ve "Not: ExtractStrings listeye boş dizeler eklemez."
awmross

Sorun, bir splitişlevi tasarlamak değil , bir TStringsnesneye olan ihtiyaçtır . Ve esneklikten (@awmross) bahsettiğinden, Frank'in çözümünü
Wolf

51

Kullanabilirsiniz StrUtils.SplitString.

function SplitString(const S, Delimiters: string): TStringDynArray;

Belgelerden açıklaması :

Bir dizeyi, belirtilen sınırlayıcı karakterlerle ayrılmış farklı parçalara böler.

SplitString , bir dizeyi belirtilen ayırıcı karakterlerle ayrılmış farklı parçalara böler. S , bölünecek dizedir. Sınırlayıcılar , sınırlayıcı olarak tanımlanan karakterleri içeren bir dizedir.

SplitString , orijinal dizenin bölünmüş kısımlarını içeren System.Types.TStringDynArray türünde bir dizi döndürür .


3
Hmmm, benim Delphi 2010 sürümümde değil (XMLDoc'ta ve IdStrings'de bir SplitString rutini var, ancak bunların hiçbiri posterin istediğini yapmıyor ve XMLDoc rutini zaten birim arabirimi aracılığıyla gösterilmiyor).
Deltics

3
function SplitString (const S, Delimiters: string): TStringDynArray; tanım StrUtils.pas
alex

StrUtils.pas dosyasını dahil edemiyorum (mevcut olsa bile).
truthseeker

Bu, bir dizeyi "diziye" bölmenin bir örneğidir.
bvj

en iyi şey, diğer yanıtlardaki karakter sınırlayıcıların aksine bunun bir dize sınırlayıcıyı kabul etmesidir.
user30478

42

Delphi XE3'te sunulan SysUtils.TStringHelper.Split işlevini kullanma :

var
  MyString: String;
  Splitted: TArray<String>;
begin
  MyString := 'word:doc,txt,docx';
  Splitted := MyString.Split([':']);
end.

Bu, belirli bir sınırlayıcıya sahip bir dizeyi bir dizi diziye böler.


19

Ben her zaman buna benzer bir şey kullanırım:

Uses
   StrUtils, Classes;

Var
  Str, Delimiter : String;
begin
  // Str is the input string, Delimiter is the delimiter
  With TStringList.Create Do
  try
    Text := ReplaceText(S,Delim,#13#10);

    // From here on and until "finally", your desired result strings are
    // in strings[0].. strings[Count-1)

  finally
    Free; //Clean everything up, and liberate your memory ;-)
  end;

end;

2
Eski Delphi sürümlerinin kullanıcıları için harika bir çözüm.
Wolf

C ++ Builder 6 kullanıcıları: İlgili fonksiyonudurStrutils::AnsiReplaceText
Kurt

Şaşırtıcı derecede basit. İle Delphi 7 ile çalışma: list.Text := AnsiReplaceStr(source, delimiter, #13#10);.
AlainD

Delphi 6'da SysUtils.StringReplace kullanılabilir
pyfyc

16

Benzer Patlat () MEF tarafından sunulan fonksiyonu, ancak farklılıkların (ı bir hata düzeltmesi düşünün hangi birinin) bir çift:

  type
    TArrayOfString = array of String;


  function SplitString(const aSeparator, aString: String; aMax: Integer = 0): TArrayOfString;
  var
    i, strt, cnt: Integer;
    sepLen: Integer;

    procedure AddString(aEnd: Integer = -1);
    var
      endPos: Integer;
    begin
      if (aEnd = -1) then
        endPos := i
      else
        endPos := aEnd + 1;

      if (strt < endPos) then
        result[cnt] := Copy(aString, strt, endPos - strt)
      else
        result[cnt] := '';

      Inc(cnt);
    end;

  begin
    if (aString = '') or (aMax < 0) then
    begin
      SetLength(result, 0);
      EXIT;
    end;

    if (aSeparator = '') then
    begin
      SetLength(result, 1);
      result[0] := aString;
      EXIT;
    end;

    sepLen := Length(aSeparator);
    SetLength(result, (Length(aString) div sepLen) + 1);

    i     := 1;
    strt  := i;
    cnt   := 0;
    while (i <= (Length(aString)- sepLen + 1)) do
    begin
      if (aString[i] = aSeparator[1]) then
        if (Copy(aString, i, sepLen) = aSeparator) then
        begin
          AddString;

          if (cnt = aMax) then
          begin
            SetLength(result, cnt);
            EXIT;
          end;

          Inc(i, sepLen - 1);
          strt := i + 1;
        end;

      Inc(i);
    end;

    AddString(Length(aString));

    SetLength(result, cnt);
  end;

Farklılıklar:

  1. aMax parametresi, döndürülecek dizelerin sayısını sınırlar
  2. Giriş dizisi bir ayırıcı tarafından sonlandırılırsa, nominal "boş" bir son dizenin var olduğu kabul edilir.

Örnekler:

SplitString(':', 'abc') returns      :    result[0]  = abc

SplitString(':', 'a:b:c:') returns   :    result[0]  = a
                                          result[1]  = b
                                          result[2]  = c
                                          result[3]  = <empty string>

SplitString(':', 'a:b:c:', 2) returns:    result[0]  = a
                                          result[1]  = b

Hata düzeltmesi olarak düşündüğüm, sondaki ayırıcı ve kavramsal "boş son öğe" dir.

Ayrıca önerdiğim bellek ayırma değişikliğini de iyileştirme ile birleştirdim (yanlışlıkla girdi dizesinin en fazla% 50 ayırıcı içerebileceğini öne sürdüm, ancak elbette% 100 ayırıcı dizelerden oluşarak bir dizi boş öğe ortaya çıkarabilir!)


7

Explode çok yüksek hızlı bir fonksiyondur, kaynak alhoritm TStrings bileşeninden alınır. Patlama için bir sonraki testi kullanıyorum: 134217733 bayt veriyi patlat, 19173962 öğeleri alıyorum, çalışma süresi: 2984 ms.

Implode çok düşük hızlı bir fonksiyondur ama ben kolay yazıyorum.

{ ****************************************************************************** }
{  Explode/Implode (String <> String array)                                      }
{ ****************************************************************************** }
function Explode(S: String; Delimiter: Char): Strings; overload;
var I, C: Integer; P, P1: PChar;
begin
    SetLength(Result, 0);
    if Length(S) = 0 then Exit;
    P:=PChar(S+Delimiter); C:=0;
    while P^ <> #0 do begin
       P1:=P;
       while (P^ <> Delimiter) do P:=CharNext(P);
       Inc(C);
       while P^ in [#1..' '] do P:=CharNext(P);
       if P^ = Delimiter then begin
          repeat
           P:=CharNext(P);
          until not (P^ in [#1..' ']);
       end;
    end;
    SetLength(Result, C);
    P:=PChar(S+Delimiter); I:=-1;
    while P^ <> #0 do begin
       P1:=P;
       while (P^ <> Delimiter) do P:=CharNext(P);
       Inc(I); SetString(Result[I], P1, P-P1);
       while P^ in [#1..' '] do P:=CharNext(P);
       if P^ = Delimiter then begin
          repeat
           P:=CharNext(P);
          until not (P^ in [#1..' ']);
       end;
    end;
end;

function Explode(S: String; Delimiter: Char; Index: Integer): String; overload;
var I: Integer; P, P1: PChar;
begin
    if Length(S) = 0 then Exit;
    P:=PChar(S+Delimiter); I:=1;
    while P^ <> #0 do begin
       P1:=P;
       while (P^ <> Delimiter) do P:=CharNext(P);
        SetString(Result, P1, P-P1);
        if (I <> Index) then Inc(I) else begin
           SetString(Result, P1, P-P1); Exit;
        end;
       while P^ in [#1..' '] do P:=CharNext(P);
       if P^ = Delimiter then begin
          repeat
           P:=CharNext(P);
          until not (P^ in [#1..' ']);
       end;
    end;
end;

function Implode(S: Strings; Delimiter: Char): String;
var iCount: Integer;
begin
     Result:='';
     if (Length(S) = 0) then Exit;
     for iCount:=0 to Length(S)-1 do
     Result:=Result+S[iCount]+Delimiter;
     System.Delete(Result, Length(Result), 1);
end;

3
Bu derlemez: Stringsbir tür değil.
NGLN

7
var  
    su  : string;        // What we want split
    si  : TStringList;   // Result of splitting
    Delimiter : string;
    ...
    Delimiter := ';';
    si.Text := ReplaceStr(su, Delimiter, #13#10);

Si listesindeki satırlar bölünmüş dizeleri içerecektir.


6

TArray dizesini döndüren kendi işlevinizi oluşturabilirsiniz:

function mySplit(input: string): TArray<string>;
var
  delimiterSet: array [0 .. 0] of char; 
     // split works with char array, not a single char
begin
  delimiterSet[0] := '&'; // some character
  result := input.Split(delimiterSet);
end;

5

İşte bir standart fonksiyonu olarak diğer birçok programlama dillerinde kullanılabilir olan patlayabilir işlevinin bir uygulamasıdır:

type 
  TStringDynArray = array of String;

function Explode(const Separator, S: string; Limit: Integer = 0): TStringDynArray; 
var 
  SepLen: Integer; 
  F, P: PChar; 
  ALen, Index: Integer; 
begin 
  SetLength(Result, 0); 
  if (S = '') or (Limit < 0) then Exit; 
  if Separator = '' then 
  begin 
    SetLength(Result, 1); 
    Result[0] := S; 
    Exit; 
  end; 
  SepLen := Length(Separator); 
  ALen := Limit; 
  SetLength(Result, ALen); 

  Index := 0; 
  P := PChar(S); 
  while P^ <> #0 do 
  begin 
    F := P; 
    P := AnsiStrPos(P, PChar(Separator)); 
    if (P = nil) or ((Limit > 0) and (Index = Limit - 1)) then P := StrEnd(F); 
    if Index >= ALen then 
    begin 
      Inc(ALen, 5); 
      SetLength(Result, ALen); 
    end; 
    SetString(Result[Index], F, P - F); 
    Inc(Index); 
    if P^ <> #0 then Inc(P, SepLen); 
  end; 
  if Index < ALen then SetLength(Result, Index); 
end; 

Örnek kullanım:

var
  res: TStringDynArray;
begin
  res := Explode(':', yourString);

2
Bu kodda, sonucun uzunluğunu yönetmek / tahmin etmek için bazı garip ve potansiyel olarak oldukça verimsiz seçenekler vardır. Sonuç dizisi aşamalı olarak büyütülerek, bellek yeniden ayırma ve parçalanma şansı artar. Daha verimli, mümkün olduğu kadar büyük bir başlangıç ​​uzunluğu ayarlamak, yani giriş dizesinin% 50 ayırıcı dizelerden oluştuğunu varsaymak = Uzunluk (S) div (2 * Uzunluk (Ayırıcı)). Ardından, gerçek sayıya ayarlayın. 1 ayırma, ardından potansiyel olarak tek bir kesme.
Deltics

Ayrıca Limit parametresinin amacını açıklamıyorsunuz. Aslında alt dizelerin tespitini girdi dizesindeki ilk "Sınır" karakter sayısı ile sınırlıyor göründüğünde, döndürülecek maksimum alt dizge sayısını ayarlamasını sezgisel olarak bekliyordum. Bu anlamsız görünüyor, çünkü bunu yapmanız gerekirse, gerekli alt dizenin bir Kopyası () üzerinde Explode () işlemini basitçe çalıştırabilirsiniz. Maksimum sayıda alt dizeyi ayarlamak için Sınır kullanmak çok daha yararlı olacaktır.
Deltics

@Deltics: Kimse bunun son derece optimize edilmiş bir işlev olduğunu iddia etmedi ve kimse bir tane istemedi, bu yüzden şikayetinizi bir şekilde anlamıyorum. Ama belki de gerekli olup olmadığına bakılmaksızın her şeyi optimize eden adamlardan birisiniz ...
Leo

1
Ben gereksiz yere verimsiz kod yazmayan ve daha sonra optimize etme konusunda endişelenen bir adamım. Bu, kodu çok az analiz etmek ve küçük bir optimizasyon potansiyeli bulmak gibi bir durum değildi, sadece açık ve kolayca ele alınan bir verimsizlikti: Bunun yerine kolayca önceden tahsis edilebilen ve daha sonra kesilebilen bitişik belleğin artan büyümesi.
Deltics

Ayrıca @Mef: Ve bu bir şikayet değildi, bir yorumdu, bir gözlemdi. Ancak daha da önemlisi, kodunuz aynı zamanda bir hata olarak kabul edeceğim şeyleri de içeriyordu (açıklama için alternatifime bakın).
Deltics

5

Belirli bir sınırlayıcıya göre ayrılmış dizelerin bağlantılı listesini döndüren bu işlevi yazdım. Modüller olmadan saf ücretsiz pascal.

Program split_f;

type
    PTItem = ^TItem;
    TItem = record
        str : string;
        next : PTItem;
    end;

var
    s : string;
    strs : PTItem;

procedure split(str : string;delim : char;var list : PTItem);
var
    i : integer;
    buff : PTItem;
begin
    new(list);
    buff:= list;
    buff^.str:='';
    buff^.next:=nil;

    for i:=1 to length(str) do begin
        if (str[i] = delim) then begin
            new(buff^.next);
            buff:=buff^.next;
            buff^.str := '';
            buff^.next := nil;
        end
        else
        buff^.str:= buff^.str+str[i];
    end;
end;

procedure print(var list:PTItem);
var
    buff : PTItem;
begin
    buff := list;
    while buff<>nil do begin
        writeln(buff^.str);
        buff:= buff^.next;
    end;
end;

begin

    s := 'Hi;how;are;you?';

    split(s, ';', strs);
    print(strs);


end.

3

Jedi Kod Kitaplığı, mevcut metni hem ekleyebilen hem de değiştirebilen yerleşik Bölme işlevine sahip gelişmiş bir StringList sağlar. Aynı zamanda referans sayılan arayüz sağlar. Dolayısıyla bu, SplitStrings içermeyen ve stok TStringList'in yalnızca belirtilen sınırlayıcıları kullanmak için dikkatli ve biraz sıkıcı özelleştirmeleri olmadan daha eski Delphi sürümlerinde bile kullanılabilir.

Örneğin, aşağıdaki gibi satırlardan oluşan bir metin dosyası Dog 5 4 7bunları kullanarak ayrıştırabilir:

var slF, slR: IJclStringList; ai: TList<integer>; s: string; i: integer;
    action: procedure(const Name: string; Const Data: array of integer);

slF := TJclStringList.Create; slF.LoadFromFile('some.txt');
slR := TJclStringList.Create;
for s in slF do begin
    slR.Split(s, ' ', true);
    ai := TList<Integer>.Create;
    try
       for i := 1 to slR.Count - 1 do
           ai.Add(StrToInt(slR[i]));
       action(slR[0], ai.ToArray);
    finally ai.Free; end;
end; 

http://wiki.delphi-jedi.org/wiki/JCL_Help:IJclStringList.Split@string@string@Boolean


3

Bu sorununu çözecektir

interface
   TArrayStr = Array Of string;

implementation

function SplitString(Text: String): TArrayStr;
var
   intIdx: Integer;
   intIdxOutput: Integer;
const
   Delimiter = ';';
begin
   intIdxOutput := 0;
   SetLength(Result, 1);
   Result[0] := ''; 

   for intIdx := 1 to Length(Text) do
   begin
      if Text[intIdx] = Delimiter then
      begin
         intIdxOutput := intIdxOutput + 1;
         SetLength(Result, Length(Result) + 1);
      end
      else
         Result[intIdxOutput] := Result[intIdxOutput] + Text[intIdx];
   end;
end;

Lütfen kodun ne işe yaradığı hakkında biraz açıklama yapabilir misiniz? Teşekkürler
Paco

sınırlayıcı sabitini arayan geçirilen dizeden geçer, bulunamadığında dizideki geçerli konumla birleştirir, bulunursa dinamik dizideki sonraki konuma atlar
Dennis

1

Bölme için en sevdiğim işlev:

procedure splitString(delim: char; s: string; ListOfStrings: TStrings);
var temp: string;
    i: integer;
begin
   ListOfStrings.Clear;
   for i:=1 to length(s) do
    begin
      if s[i] = delim then
        begin
          ListOfStrings.add(temp);
          temp := '';
        end
      else
        begin
          temp := temp + s[i];
          if i=length(s) then
             ListOfStrings.add(temp);
        end;
    end;
    ListOfStrings.add(temp);
end;

1
Fonksiyonunuzda son öğe gözden
kaçtı

1
ListOfStrings.add(temp);Son öğeyi eklemek için döngüden sonra eklemeniz gerekir .
rnso

Not için teşekkürler, başka blokta kodu düzenledim.
John Boe

0

*

//Basic functionality of a TStringList solves this:


uses Classes  //TStringList 
    ,types    //TStringDynArray
    ,SysUtils //StringReplace()
    ;

....

 //--------------------------------------------------------------------------
 function _SplitString(const s:string; const delimiter:Char):TStringDynArray;
  var sl:TStringList;
      i:integer;
  begin
  sl:=TStringList.Create;

  //separete delimited items by sLineBreak;TStringlist will do the job:
  sl.Text:=StringReplace(s,delimiter,sLineBreak,[rfReplaceAll]);

  //return the splitted string as an array:
  setlength(Result,sl.count);
  for i:=0 to sl.Count-1
   do Result[i]:=sl[i];

  sl.Free;
  end;



//To split a FileName (last item will be the pure filename itselfs):

 function _SplitPath(const fn:TFileName):TStringDynArray;
  begin
  result:=_SplitString(fn,'\');
  end;

*


0

NGLG cevabının temelinde https://stackoverflow.com/a/8811242/6619626 aşağıdaki işlevi kullanabilirsiniz:

type
OurArrayStr=array of string;

function SplitString(DelimeterChars:char;Str:string):OurArrayStr;
var
seg: TStringList;
i:integer;
ret:OurArrayStr;
begin
    seg := TStringList.Create;
    ExtractStrings([DelimeterChars],[], PChar(Str), seg);
    for i:=0 to seg.Count-1 do
    begin
         SetLength(ret,length(ret)+1);
         ret[length(ret)-1]:=seg.Strings[i];
    end;
    SplitString:=ret;
    seg.Free;
end;

Tüm Delphi sürümlerinde çalışır.


0

Delphi 2010 için kendi bölünmüş fonksiyonunuzu oluşturmanız gerekir.

function Split(const Texto, Delimitador: string): TStringArray;
var
  i: integer;
  Len: integer;
  PosStart: integer;
  PosDel: integer;
  TempText:string;
begin
  i := 0;
  SetLength(Result, 1);
  Len := Length(Delimitador);
  PosStart := 1;
  PosDel := Pos(Delimitador, Texto);
  TempText:=  Texto;
  while PosDel > 0 do
    begin
      Result[i] := Copy(TempText, PosStart, PosDel - PosStart);
      PosStart := PosDel + Len;
      TempText:=Copy(TempText, PosStart, Length(TempText));
      PosDel := Pos(Delimitador, TempText);
      PosStart := 1;
      inc(i);
      SetLength(Result, i + 1);
    end;
  Result[i] := Copy(TempText, PosStart, Length(TempText));
end;

Buna böyle bakabilirsiniz

type
  TStringArray = array of string;
var Temp2:TStringArray;
Temp1="hello:world";
Temp2=Split(Temp1,':')

0
procedure SplitCSV(S:STRING;out SL:TStringList);
var c,commatext:string;
  a,b,up:integer;
begin
   c:=s.Replace(' ','<SPACE>');   //curate spaces

   //first ocurrence of "
   a:=pos('"',c);
   b:=pos('"',c,a+1);
   if (a>0) and (b>0) then
   begin
     commatext:=commatext+copy(c,0,a-1);
     commatext:=commatext+copy(c,a,b-a+1).Replace(',','<COMMA>');   //curate commas
     up:=b+1;
   end
   else
     commatext:=c;

   //while continue discovering "
   while (a>0) and (b>0) do
   begin
     a:=Pos('"',c,b+1);
     b:=pos('"',c,a+1);
     if (a>0) and (b>0) then
     begin
       commatext:=commatext+copy(c,up,a-up);
       commatext:=commatext+copy(c,a,b-a+1).Replace(',','<COMMA>'); //curate commas
       up:=b+1;
     end;
   end;
   //last piece of text end  
   if up<c.Length then
     commatext:=commatext+copy(c,up,c.Length-up+1);

   //split text using CommaText
   sl.CommaText:=commatext;

   sl.Text:=sl.Text.Replace('<COMMA>',',');   //curate commas
   sl.Text:=sl.Text.Replace('<SPACE>',' ');   //curate spaces
end;

Çözümü net ve kısa bir şekilde açıklayan yanıtlar, yalnızca kod içeren yanıtlardan çok daha faydalıdır.
Martyna

0
interface

uses
  Classes;

type
  TStringArray = array of string;

  TUtilStr = class
    class function Split(const AValue: string; const ADelimiter: Char = ';'; const AQuoteChar: Char = '"'): TStringArray; static;
  end;


implementation

{ TUtilStr }

class function TUtilStr.Split(const AValue: string; const ADelimiter: Char; const AQuoteChar: Char): TStringArray;
var
  LSplited: TStringList;
  LText: string;
  LIndex: Integer;
begin
  LSplited := TStringList.Create;
  try
    LSplited.StrictDelimiter := True;
    LSplited.Delimiter := ADelimiter;
    LSplited.QuoteChar := AQuoteChar;
    LSplited.DelimitedText := AValue;

    SetLength(Result, LSplited.Count);
    for LIndex := 0 to LSplited.Count - 1 do
    begin
      Result[LIndex] := LSplited[LIndex];
    end;
  finally
    LSplited.Free;
  end;
end;

end.
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.