测试 System.SysUtils.TStringHelper

添加时间:2013-6-16 点击量:

大小写转换:


function ToLower: string;

function ToLower（LocaleID: TLocaleID）: string;

function ToLowerInvariant: string;

function ToUpper: string;

function ToUpper（LocaleID: TLocaleID）: string;

function ToUpperInvariant: string;



class function LowerCase（const S: string）: string;

class function LowerCase（const S: string; LocaleOptions: TLocaleOptions）: string;

class function UpperCase（const S: string）: string;

class function UpperCase（const S: string; LocaleOptions: TLocaleOptions）: string;

//--------------------------------------------------------------------------------

var

  str: string;

begin

  str := Delphi;

  str := str.ToLower; // delphi

  str := str.ToUpper; // DELPHI

end;

清除两边空格或指定字符:


function Trim: string;

function TrimLeft: string;

function TrimRight: string;

function Trim（const TrimChars: array of Char）: string;

function TrimLeft（const TrimChars: array of Char）: string;

function TrimRight（const TrimChars: array of Char）: string;

//--------------------------------------------------------------------------------

var

  str1， str2: string;

begin

  str1 :=    Delphi 10000   ;



  str2 := str1.TrimLeft;  // Delphi 10000   

  str2 := str1.TrimRight; //    Delphi 10000

  str2 := str1.Trim;      // Delphi 10000



  str2 := str1.Trim（[ ， 0]）; // Delphi 1

end;

字符串对比:


function CompareTo（const strB: string）: Integer;



class function Compare（const StrA: string; const StrB: string）: Integer;

class function CompareText（const StrA: string; const StrB: string）: Integer;

class function Compare（const StrA: string; const StrB: string; LocaleID: TLocaleID）: Integer;

class function Compare（const StrA: string; const StrB: string; IgnoreCase: Boolean）: Integer;

class function Compare（const StrA: string; const StrB: string; IgnoreCase: Boolean; LocaleID: TLocaleID）: Integer;

class function Compare（const StrA: string; IndexA: Integer; const StrB: string; IndexB: Integer; Length: Integer）: Integer;

class function Compare（const StrA: string; IndexA: Integer; const StrB: string; IndexB: Integer; Length: Integer; LocaleID: TLocaleID）: Integer;

class function Compare（const StrA: string; IndexA: Integer; const StrB: string; IndexB: Integer; Length: Integer; IgnoreCase: Boolean）: Integer;

class function Compare（const StrA: string; IndexA: Integer; const StrB: string; IndexB: Integer; Length: Integer; IgnoreCase: Boolean; LocaleID: TLocaleID）: Integer;

class function CompareOrdinal（const StrA: string; const StrB: string）: Integer;

class function CompareOrdinal（const StrA: string; IndexA: Integer; const StrB: string; IndexB: Integer; Length: Integer）: Integer;

//--------------------------------------------------------------------------------

var

  str1， str2: string;

  n: Integer;

begin

  str1 := ABC 123;

  str2 := abc 123;



  n := str1.CompareTo（str2）;              // -32



  n := str1.Compare（str1， str2）;          // 1

  n := str1.CompareText（str1， str2）;      // 0; 雷同



  n := str1.Compare（str1， str2， True）;    // 0; 不区分大小写

  n := str1.CompareOrdinal（str1， str2）;   // -32



  n := str1.Compare（str1， 4， str2， 4， 3）; // 0; 只对比后三位

end;

搜刮字符串:


function IndexOf（value: Char）: Integer;

function IndexOf（const Value: string）: Integer;

function IndexOf（Value: Char; StartIndex: Integer）: Integer;

function IndexOf（const Value: string; StartIndex: Integer）: Integer;

function IndexOf（Value: Char; StartIndex: Integer; Count: Integer）: Integer;

function IndexOf（const Value: string; StartIndex: Integer; Count: Integer）: Integer;

function IndexOfAny（const AnyOf: array of Char）: Integer;

function IndexOfAny（const AnyOf: array of Char; StartIndex: Integer）: Integer;

function IndexOfAny（const AnyOf: array of Char; StartIndex: Integer; Count: Integer）: Integer;



function LastIndexOf（Value: Char）: Integer;

function LastIndexOf（const Value: string）: Integer;

function LastIndexOf（Value: Char; StartIndex: Integer）: Integer;

function LastIndexOf（const Value: string; StartIndex: Integer）: Integer;

function LastIndexOf（Value: Char; StartIndex: Integer; Count: Integer）: Integer;

function LastIndexOf（const Value: string; StartIndex: Integer; Count: Integer）: Integer;

function LastIndexOfAny（const AnyOf: array of Char）: Integer;

function LastIndexOfAny（const AnyOf: array of Char; StartIndex: Integer）: Integer;

function LastIndexOfAny（const AnyOf: array of Char; StartIndex: Integer; Count: Integer）: Integer;

//--------------------------------------------------------------------------------

var

  str: string;

  n: Integer;

begin

  str := A1 A2 A3 A4;



  n := str.IndexOf（A）;     // 0

  n := str.LastIndexOf（A）; // 9

  n := str.IndexOf（B）;     // -1; 没找到



  n := str.IndexOf（A， 1， str.Length - 1）;                  // 3

  n := str.LastIndexOf（A， str.Length - 1， str.Length - 1）; // 9



  n := str.IndexOfAny（[1， 2， 3， 4]）;     // 1

  n := str.LastIndexOfAny（[1， 2， 3， 4]）; // 10

end;

是否包含:


function Contains（const Value: string）: Boolean;



function StartsWith（const Value: string）: Boolean;

function StartsWith（const Value: string; IgnoreCase: Boolean）: Boolean;



function EndsWith（const Value: string）: Boolean;

function EndsWith（const Value: string; IgnoreCase: Boolean）: Boolean;



class function EndsText（const ASubText， AText: string）: Boolean;

//--------------------------------------------------------------------------------

var

  str: string;

  b: Boolean;

begin

  str := Delphi XE4;



  b := str.Contains（XE）; // True

  b := str.Contains（xe）; // False



  b := str.StartsWith（delphi）;       // False

  b := str.StartsWith（delphi， True）; // True



  b := str.EndsWith（XE4）;            // True



  b := str.EndsText（xe4， str）;       // True

end;

添加或解除引号:


function QuotedString: string;

function QuotedString（const QuoteChar: Char）: string;



function DeQuotedString: string;

function DeQuotedString（const QuoteChar: Char）: string;

//--------------------------------------------------------------------------------

var

  str1， str2: string;

begin

  str1 := Delphi;



  str2 := str1.QuotedString;        // Delphi

  str2 := str1.QuotedString（）;   // Delphi



  str1 := Delphi;

  str2 := str1.DeQuotedString（）; // Delphi

end;

适宽处理惩罚:


function PadLeft（TotalWidth: Integer）: string;

function PadLeft（TotalWidth: Integer; PaddingChar: Char）: string;

function PadRight（TotalWidth: Integer）: string;

function PadRight（TotalWidth: Integer; PaddingChar: Char）: string;

//--------------------------------------------------------------------------------

var

  str: string;

begin

  str := 1;

  str := str.PadLeft（4， 0）; // 0001

end;

插入与删除:


function Insert（StartIndex: Integer; const Value: string）: string;



function Remove（StartIndex: Integer）: string;

function Remove（StartIndex: Integer; Count: Integer）: string;

//--------------------------------------------------------------------------------

var

  str1， str2: string;

begin

  str1 := Delphi 4;

  str2 := str1.Insert（7， XE）; // Delphi XE4



  str1 := Delphi XE4;

  str2 := str1.Remove（6）;    // Delphi

  str2 := str1.Remove（7， 2）; // Delphi 4

end;

截取:


function Substring（StartIndex: Integer）: string;

function Substring（StartIndex: Integer; Length: Integer）: string;

//--------------------------------------------------------------------------------

var

  str1， str2: string;

begin

  str1 := Delphi XE4;

  str2 := str1.Substring（7）;    // XE4

  str2 := str1.Substring（7， 2）; // XE

end;

调换:


function Replace（OldChar: Char; NewChar: Char）: string;

function Replace（OldChar: Char; NewChar: Char; ReplaceFlags: TReplaceFlags）: string;

function Replace（const OldValue: string; const NewValue: string）: string;

function Replace（const OldValue: string; const NewValue: string; ReplaceFlags: TReplaceFlags）: string;

//--------------------------------------------------------------------------------

var

  str1， str2: string;

begin

  str1 := ABC ABC ABC;

  str2 := str1.Replace（A， ）;                 // BC BC BC

  str2 := str1.Replace（A， ， [rfIgnoreCase]）; // BC ABC ABC

end;

分别:


function Split（const Separator: array of Char）: TArray<string>;

function Split（const Separator: array of Char; Count: Integer）: TArray<string>;

function Split（const Separator: array of Char; Options: TStringSplitOptions）: TArray<string>;

function Split（const Separator: array of string; Options: TStringSplitOptions）: TArray<string>;

function Split（const Separator: array of Char; Count: Integer; Options: TStringSplitOptions）: TArray<string>;

function Split（const Separator: array of string; Count: Integer; Options: TStringSplitOptions）: TArray<string>;

//--------------------------------------------------------------------------------

var

  str: string;

  arr: TArray<string>;

begin

  str := A-1，B-2，，，C-3，D-4;



  arr := str.Split（[，]）;                                   // arr[0] = A-1; Length（arr） = 6

  arr := str.Split（[，]， TStringSplitOptions.ExcludeEmpty）; // 忽视空项; Length（arr） = 4

  arr := str.Split（[，]， 2）;                                // 只提取前 2



  arr := str.Split（[，， -]， ExcludeEmpty）; //arr[0] = A; Length（arr） = 8



  arr := str.Split（[，，，]， None）;            // 分隔符可所以一个字符串数组

end;

连接:


class function Join（const Separator: string; const values: array of const）: string;

class function Join（const Separator: string; const Values: array of string）: string;

class function Join（const Separator: string; const Values: IEnumerator<string>）: string;

class function Join（const Separator: string; const Values: IEnumerable<string>）: string;

class function Join（const Separator: string; const value: array of string; StartIndex: Integer; Count: Integer）: string;

//--------------------------------------------------------------------------------

var

  S: string;

  str: string;

  strArr: TArray<string>;

begin

  str := A1，B2，C3，，，，D4，E5，F6，G7;

  strArr := str.Split（[，]， ExcludeEmpty）;



  str := S.Join（-， strArr）;             // A1-B2-C3-D4-E5-F6-G7



  str := S.Join（; ， [1，2，3，4，5]）;       // 1; 2; 3; 4; 5



  str := S.Join（，， [abc， 123， true]）; // abc，123，True

end;

类型转换:


function ToBoolean: Boolean;

function ToInteger: Integer;

function ToSingle: Single;

function ToDouble: Double;

function ToExtended: Extended;



class function ToBoolean（const S: string）: Boolean;

class function ToInteger（const S: string）: Integer;

class function ToSingle（const S: string）: Single;

class function ToDouble（const S: string）: Double;

class function ToExtended（const S: string）: Extended;



class function Parse（const Value: Integer）: string;

class function Parse（const Value: Int64）: string;

class function Parse（const Value: Boolean）: string;

class function Parse（const Value: Extended）: string;

//--------------------------------------------------------------------------------

var

  S: string;

  str: string;

  n: Integer;

  b: Boolean;

  f: Double;

begin

  str := S.Parse（123）;

  n := str.ToInteger;  // 123

  b := str.ToBoolean;  // True



  str := S.Parse（True）;

  b := str.ToBoolean;  // True

  n := str.ToInteger;  // -1



  str := S.Parse（3.14159260000）;

  f := str.ToDouble;  //3.1415926

end;

定界符:


function IsDelimiter（const Delimiters: string; Index: Integer）: Boolean;

function LastDelimiter（const Delims: string）: Integer;

//--------------------------------------------------------------------------------

var

  str: string;

  b: Boolean;

  n: Integer;

begin

  str := http://del.cnblogs.com;



  b := str.IsDelimiter（:， 4）;  // True

  b := str.IsDelimiter（//， 5）; // True



  n := str.LastDelimiter（.）;   // 18

  n := str.IndexOf（.）;         // 10

end;

空字符串:


const Empty = ;



function IsEmpty: Boolean;



class function IsNullOrEmpty（const Value: string）: Boolean;

class function IsNullOrWhiteSpace（const Value: string）: Boolean;

//--------------------------------------------------------------------------------

var

  S: string;

  str: string;

  b: Boolean;

begin

  str :=        ;



  b := str.IsEmpty;               // False

  b := S.IsNullOrWhiteSpace（str）; // True

end;

String 与 Char:


class function Create（C: Char; Count: Integer）: string;

class function Create（const Value: array of Char; StartIndex: Integer; Length: Integer）: string;

class function Create（const Value: array of Char）: string;



property Chars[Index: Integer]: Char read GetChars;

property Length: Integer read GetLength;



function CountChar（const C: Char）: Integer;



function ToCharArray: TArray<Char>;

function ToCharArray（StartIndex: Integer; Length: Integer）: TArray<Char>;



procedure CopyTo（SourceIndex: Integer; var destination: array of Char; DestinationIndex: Integer; Count: Integer）;

//--------------------------------------------------------------------------------

var

  S: string;

  str， str2: string;

  charArr: TCharArray;

  n: Integer;

  c: Char;

begin

  str := ABC;

  n := str.Length;   // 3

  c := str.Chars[0]; // A = str[1]



  str := S.Create（A， 7）; // AAAAAAA



  charArr := ABCDEFG.ToCharArray;

  str := s.Create（charArr）;       // ABCDEFG

  str := S.Create（charArr， 1， 3）; // BCD



  charArr := 1234567890.ToCharArray;

  str := ABCDEFG;

  str.CopyTo（1， charArr， 2， 3）;

  str := S.Create（charArr）;       // 12BCD67890

end;

其他:


function Equals（const Value: string）: Boolean;

function GetHashCode: Integer;



class function Equals（const a: string; const b: string）: Boolean;

class function Format（const Format: string; const args: array of const）: string;

class function Copy（const Str: string）: string;

//--------------------------------------------------------------------------------



// 用 Equals 不如直接用 = 号

// 用 Copy 不如直接用 :=

// 用 string.Format 不如直接用 Format（）



// 总之， 还是有效处的多!

我俩之间有着强烈的吸引力。短短几个小时后，我俩已经明白：我们的心是一个整体的两半，我俩的心灵是孪生兄妹，是知己。她让我感到更有活力，更完美，更幸福。即使她不在我身边，我依然还是感到幸福，因为她总是以这样或者那样的方式出现在我心头。——恩里克·巴里奥斯《爱的文明》

分享到：

相关文章

按版本划分

按功能划分

企业管理软件

测试 System.SysUtils.TStringHelper