구분 기호에 따라 문자열을 문자열 배열로 분할


84

입력 문자열을 구분 기호를 기반으로 문자열 배열로 분할하는 Delphi 함수를 찾으려고합니다. Google에서 많은 것을 찾았지만 모두 고유 한 문제가있는 것 같고 그 중 어느 것도 작동하도록 할 수 없었습니다.

"word:doc,txt,docx"':'를 기반으로하는 배열로 문자열을 분할해야합니다 . 결과는입니다 ['word', 'doc,txt,docx'].

작동하는 기능이있는 사람이 있습니까?

감사합니다

답변:


86

TStrings.DelimitedText 속성을 사용하여 문자열을 분할 할 수 있습니다.

이 샘플 확인

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.

최신 정보

에 대한 설명은 이 링크 를 참조하십시오 StrictDelimiter.


22
불행히도 많은 "이전"Delphi 버전에는 공백 문자가 항상 구분 기호로 사용되는 효과가있는 버그가 있습니다 (어떤 릴리스에서 수정되었는지 확실하지 않음) . 그러니 조심해서 다루세요 !!
Leo

16
네. StrictDelimiter를 true로 설정하고 StrictDelimiter 속성을 사용중인 Delphi 버전에서 사용할 수없는 경우이 기술을 사용하지 마십시오! 그러나 그렇다면 이것은 매우 유용합니다.
Mason Wheeler

3
그것은 버그가 아니었고, D1이나 D2에서 (성가신) 디자인 결정 방식이었습니다. CommaText는 공백으로 필드를 따옴표로 묶어야했습니다. 입력에서 공백이있는 필드 주위에 큰 따옴표가 있으면 결과가 올바른 것입니다.
Gerry Coll

1
내 애완 동물 중 하나는 사람들이 변수 / 매개 변수 이름에 유형 표시기를 불필요하게 넣는 경우입니다. ArrayOfStrings이 :이 유형 표시이 경우처럼 잘못된 경우 오해의 소지가 혼동 중복 (손가락 운동 다양한) 입력과의 - 파스칼은 강력한 형식입니다 아닌 배열 (와 같은도 제기로 질문에 대답하지 않습니다) .
Deltics 2010

6
이 답변을 찬성하는 모든 사람은 질문에 지정된대로 배열을 생성하지 않습니다. 불완전한 요구 사항 사양은이 업계에서 큰 문제입니다. 명시된 요구 사항을 무시하고 요청하지 않은 것을 제공하는 것은 또 다른 큰 문제입니다. 둘 중 하나를 승인하는 것은 단순히 나쁜 습관을 조장합니다. ;)
Deltics 2010

67

Split기능 을 엔지니어링 할 필요가 없습니다 . 이미 존재합니다. 참조 : Classes.ExtractStrings.

다음과 같은 방식으로 사용하십시오.

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.

그리고 질문에 완전히 답하기 위해; List요소가있는 원하는 배열을 나타냅니다.

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

14
ExtractStrings는 매우 유연하지 않습니다. "캐리지 리턴, 개행 문자 및 따옴표 문자 (단일 또는 이중)는 항상 구분 기호로 처리됩니다."; 및 "참고 : ExtractStrings는 목록에 빈 문자열을 추가하지 않습니다."
awmross

문제는 split기능 을 설계하는 것이 아니라 TStrings객체 의 필요성입니다 . 그리고 비 유연성 (@awmross) 언급 때문에 Frank의 솔루션을
Wolf

50

사용할 수 있습니다 StrUtils.SplitString.

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

설명서 의 설명 :

문자열을 지정된 구분 문자로 구분 된 다른 부분으로 분할합니다.

SplitString 은 문자열을 지정된 구분 문자로 구분 된 다른 부분으로 분할합니다. S 는 분할 할 문자열입니다. 구분 기호는 구분 기호로 정의 된 문자를 포함하는 문자열입니다.

SplitString 은 원래 문자열의 분할 부분을 포함하는 System.Types.TStringDynArray 형식의 문자열 배열을 반환 합니다.


3
흠, 내 버전의 Delphi 2010에는 없습니다 (XMLDoc 및 (Indy 단위) IdStrings에 SplitString 루틴이 있지만 이들 중 어느 것도 포스터가 원하는 것을 수행하지 않으며 XMLDoc 루틴은 어쨌든 단위 인터페이스를 통해 노출되지 않습니다).
Deltics 2010

3
function SplitString (const S, Delimiters : string) : TStringDynArray; StrUtils.pas에 정의
alex

StrUtils.pas 파일을 포함 할 수 없습니다 (있는 경우에도).
truthseeker

이것은 문자열을 "배열"로 분할하는 예입니다.
bvj 2014

가장 좋은 점은 다른 답변의 문자 구분 기호와 달리 문자열 구분 기호를 허용한다는 것입니다.
user30478

42

Delphi XE3에 도입 된 SysUtils.TStringHelper.Split 함수 사용 :

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

이렇게하면 지정된 구분 기호가있는 문자열이 문자열 배열로 분할됩니다.


18

나는 항상 다음과 비슷한 것을 사용합니다.

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
이전 Delphi 버전 사용자를위한 훌륭한 솔루션입니다.
Wolf

C ++ 빌더 6 사용자 : 해당 기능이Strutils::AnsiReplaceText
늑대

놀랍도록 간단합니다. Delphi 7에서 작업 : list.Text := AnsiReplaceStr(source, delimiter, #13#10);.
AlainD

델파이 6에서는 SysUtils.StringReplace를 사용할 수 있습니다
pyfyc

14

Mef에서 제공 하는 Explode () 함수와 비슷하지만 몇 가지 차이점이 있습니다 (그 중 하나는 버그 수정으로 간주 됨).

  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;

차이점 :

  1. aMax 매개 변수는 반환 될 문자열 수를 제한합니다.
  2. 입력 문자열이 구분 기호로 종료되면 명목상 "빈"최종 문자열이 존재하는 것으로 간주됩니다.

예 :

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

내가 버그 수정을 고려하는 것은 후행 구분 기호이자 개념적인 "빈 최종 요소"입니다.

또한 내가 제안한 메모리 할당 변경 사항을 개선하여 통합했습니다 (입력 문자열에 최대 50 % 구분 기호가 포함될 수 있다고 잘못 제안했지만 당연히 100 % 구분 문자열로 구성되어 빈 요소의 배열이 생성 될 수 있습니다!)


7

Explode는 매우 빠른 기능이며 소스는 TStrings 컴포넌트에서 가져옵니다. 폭발을 위해 다음 테스트를 사용합니다 : Explode 134217733 바이트의 데이터, 19173962 요소, 작업 시간 : 2984ms를 얻습니다.

Implode는 매우 저속 기능이지만 쉽게 작성합니다.

{ ****************************************************************************** }
{  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
이것은 컴파일되지 않습니다 : Strings유형이 아닙니다.
NGLN 2016

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

si 목록의 줄 에는 분할 된 문자열이 포함됩니다.


6

문자열의 TArray를 반환하는 자체 함수를 만들 수 있습니다.

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

다음 은 다른 많은 프로그래밍 언어에서 표준 함수로 사용할 수있는 분해 함수의 구현입니다.

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; 

샘플 사용법 :

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

2
이 코드에는 결과의 길이를 관리 / 예측하기위한 이상하고 잠재적으로 매우 비효율적 인 선택이 있습니다. 결과 배열을 점진적으로 늘리면 메모리 재 할당 및 조각화 가능성이 높아집니다. 더 효율적인 것은 초기 길이를 가능한 한 크게 설정하는 것입니다. 즉, 입력 문자열이 50 % 구분자 문자열 = Length (S) div (2 * Length (Separator)로 구성되어 있다고 가정합니다. 그런 다음 실제 개수로 설정합니다. 항목 1 개 할당 후 잠재적으로 단일 잘림
Deltics

또한 Limit 매개 변수의 목적을 설명하지 않습니다. 실제로 입력 문자열의 첫 번째 "Limit"문자 수로 하위 문자열 감지를 제한하는 것처럼 보일 때 반환 될 최대 하위 문자열 수를 직관적으로 설정했습니다. 필요한 경우 필요한 하위 문자열의 Copy ()를 통해 Explode ()를 간단히 실행할 수 있기 때문에 이것은 무의미 해 보입니다. Limit를 사용하여 최대 하위 문자열 수를 설정하는 것이 훨씬 더 유용합니다.
Deltics 2010

@Deltics : 아무도 이것이 고도로 최적화 된 기능이라고 주장하지 않았고 아무도 요청하지 않았으므로 귀하의 불만을 다소 이해하지 못합니다. 하지만 필요할지 여부에 관계없이 모든 것을 최적화하는 사람 중 한 명일 수도 있습니다.
Leo

1
필자는 불필요하게 비효율적 인 코드를 작성하지 않고 나중에 최적화하는 것에 대해 걱정하지 않는 사람입니다. 이것은 코드를 세밀하게 분석하고 약간의 최적화 잠재력을 찾은 경우가 아니라 단순히 명백하고 쉽게 해결할 수있는 비 효율성이었습니다. 대신 쉽게 사전 할당되고 이후에 잘릴 수있는 연속 메모리의 점진적 증가입니다.
Deltics 2010

또한 @Mef : 불만이 아니라 의견, 관찰이었습니다. 그러나 더 중요한 것은 귀하의 코드에 버그로 간주되는 내용도 포함되어 있습니다 (설명은 내 대안 참조).
Deltics 2010

5

특정 구분 기호로 구분 된 문자열의 연결 목록을 반환하는이 함수를 작성했습니다. 모듈이없는 순수 프리 파스칼.

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 코드 라이브러리는 기존 텍스트를 추가하고 대체 할 수있는 기본 제공 Split 기능이있는 향상된 StringList를 제공합니다. 또한 참조 횟수 인터페이스를 제공합니다. 따라서 이것은 SplitStrings가없고 지정된 구분 기호 만 사용하기 위해 재고 TStringList를 약간 지루하게 사용자 정의하지 않고 이전 Delphi 버전에서도 사용할 수 있습니다.

예를 들어 다음과 같은 줄의 주어진 텍스트 파일은 Dog 5 4 7다음을 사용하여 구문 분석 할 수 있습니다.

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

이것은 당신의 문제를 해결할 것입니다

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;

코드의 기능에 대해 설명해 주시겠습니까? 감사합니다
Paco 2015 년

구분자 const를 찾기 위해 전달 된 문자열을 실행합니다. 찾을 수없는 경우 배열의 현재 위치와 연결하고, 발견되면 동적 배열의 다음 위치로 이동합니다.
Dennis

1

내가 좋아하는 분할 기능 :

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
마지막 요소는 함수에 누락 된
alijunior

1
ListOfStrings.add(temp);마지막 항목을 추가하려면 루프 뒤에 추가해야합니다 .
rnso

메모 감사합니다. else 블록의 코드를 편집했습니다.
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 답변 https://stackoverflow.com/a/8811242/6619626 의 기본은 다음 기능을 사용할 수 있습니다.

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;

모든 Delphi 버전에서 작동합니다.


0

Delphi 2010의 경우 고유 한 분할 함수를 만들어야합니다.

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;

당신은 그것을 그렇게 참조 할 수 있습니다

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;

솔루션을 명확하고 간결하게 설명하는 답변은 코드 전용 답변보다 훨씬 유용합니다.
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.
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.