एक स्ट्रिंग को एक सीमांकक के आधार पर स्ट्रिंग की एक सरणी में विभाजित करें

Question 1

मैं एक डेल्फी फ़ंक्शन खोजने की कोशिश कर रहा हूं जो एक इनपुट स्ट्रिंग को एक सीमांकक के आधार पर स्ट्रिंग की एक सरणी में विभाजित करेगा। मैंने Google पर बहुत कुछ पाया है, लेकिन लगता है कि सभी के पास अपने मुद्दे हैं और मैं उनमें से किसी को भी काम करने में सक्षम नहीं कर पाया हूं।

मुझे बस एक स्ट्रिंग को विभाजित करने की आवश्यकता है जैसे: "word:doc,txt,docx"':' पर आधारित एक सरणी में। परिणाम होगा ['word', 'doc,txt,docx']।

क्या किसी के पास एक फ़ंक्शन है जो वे जानते हैं कि काम करता है?

धन्यवाद

Question 2

आप एक स्ट्रिंग को विभाजित करने के लिए 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।

Question 3

एक 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'

Question 4

आप उपयोग कर सकते हैं StrUtils.SplitString।

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

प्रलेखन से इसका विवरण :

अलग-अलग हिस्सों में एक स्ट्रिंग को विभाजित करता है जो निर्दिष्ट सीमांकक वर्णों द्वारा सीमांकित होता है।

स्प्लिटस्ट्रिंग अलग-अलग हिस्सों में एक स्ट्रिंग को विभाजित करता है जिसे निर्दिष्ट सीमांकक वर्णों द्वारा सीमांकित किया जाता है। एस विभाजित होने के लिए स्ट्रिंग है। डेलीमीटर एक स्ट्रिंग है जिसमें सीमांकक के रूप में परिभाषित वर्ण होते हैं।

स्प्लिटस्ट्रिंग प्रकार के स्ट्रिंग्स का एक प्रकार देता है System.Types.TStringDynArray जिसमें मूल स्ट्रिंग के विभाजन भागों होते हैं।

Question 5

डेल्फी XE3 में पेश SysUtils.TStringHelper.Split फ़ंक्शन का उपयोग करना :

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

यह स्ट्रिंग के एक सरणी में दिए गए सीमांकक के साथ एक स्ट्रिंग को विभाजित करेगा।

Question 6

मैं हमेशा कुछ इसी तरह का उपयोग करें:

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;

Question 7

करने के लिए इसी तरह के विस्फोट () MEF द्वारा की पेशकश समारोह, लेकिन मतभेद (जिनमें से एक मैं बग समाधान पर विचार करें) के एक जोड़े के साथ:

  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;

अंतर:

aMax पैरामीटर वापस आने के लिए स्ट्रिंग्स की संख्या को सीमित करता है
यदि इनपुट स्ट्रिंग को एक विभाजक द्वारा समाप्त किया जाता है तो एक नाममात्र "खाली" अंतिम स्ट्रिंग मौजूद माना जाता है

उदाहरण:

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% विभाजक तारों से मिलकर बन सकता है, खाली तत्वों की एक सरणी पैदा करता है!)

Question 8

धमाका बहुत हाई स्पीड फंक्शन है, सोर्स एल्होरीटम टीस्ट्रेस घटक से मिलता है। मैं विस्फोट के लिए अगले परीक्षण का उपयोग करता हूं: 134217733 डेटा के बाइट्स की व्याख्या करें, मुझे 19173962 तत्व मिलते हैं, काम का समय: 2984 एमएस।

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;

Question 9

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

सी सूची में लाइनों में विभाजित तार शामिल होंगे।

Question 10

आप अपना खुद का फंक्शन बना सकते हैं जो स्ट्रिंग का ट्रेयर लौटाता है:

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;

Question 11

यहां एक विस्फोट कार्य का कार्यान्वयन है जो मानक फ़ंक्शन के रूप में कई अन्य प्रोग्रामिंग भाषाओं में उपलब्ध है:

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);

Question 12

मैंने यह फ़ंक्शन लिखा है जो विशिष्ट सीमांकक द्वारा अलग किए गए तारों की लिंक की गई सूची देता है। मॉड्यूल के बिना शुद्ध मुक्त पास्कल।

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.

Question 13

जेडी कोड लाइब्रेरी बिल्ट-इन स्प्लिट फ़ंक्शन के साथ एक बढ़ी हुई स्ट्रिंगलिस्ट प्रदान करता है, जो मौजूदा पाठ को जोड़ने और बदलने दोनों में सक्षम है। यह संदर्भ-गणना इंटरफ़ेस भी प्रदान करता है। तो इसका उपयोग पुराने डेल्फी संस्करणों के साथ भी किया जा सकता है, जिसमें कोई स्प्लिटस्ट्रीम नहीं है और बिना सावधानी के और स्टॉक TStringList के थोड़े थकाऊ कस्टमाइज़ेशन केवल निर्दिष्ट सीमांकक का उपयोग करने के लिए।

उदाहरण के लिए, लाइनों की टेक्स्ट फाइल जैसे कि 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

Question 14

इससे आपकी समस्या दूर हो जाएगी

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;

Question 15

विभाजन के लिए मेरा पसंदीदा कार्य:

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;

Question 16

*

//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;

*

Question 17

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;

यह सभी डेल्फी संस्करणों में काम करता है।

Question 18

डेल्फी 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,':')

Question 19

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;

Question 20

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.