智能交易*姚文档站

第九章字符串函数

这是一组用于处理字符串类型数据的函数。

函数	功能
StringAdd	在一个字符串结尾加上另一个字符串(合并字符串)
StringBufferLen	返回为字符串分配的缓冲区的大小
StringCompare	比较两个字符串 1 表示第一个字符串大于第二个字符串； 0 表示两个字符串相等； -1 表示第一个字符串小于第二个字符串。
StringConcatenate	把多个形式参数组成一个字符串，并返回字符串的长度值(整数)
StringFill	用选定的字符填充指定的字符串
StringFind	在一个字符串中搜索子字符串
StringGetCharacter	返回位于字符串指定位置的字符
StringInit	按指定的字符初始化字符串，并指定字符串长度
StringLen	返回字符串中字符的数量
StringReplace	在一个字符串中，用一个指定的字符串查找并替换所有找到子字符串
StringSetCharacter	在字符串中，从指定位置开始，复制指定数量的字符，组成新的字符串返回。
StringSplit	通过字符串中指定的分隔符，来分割子字符串，返回获得的子字符串的数量
StringSubstr	从指定位置提取字符串
StringToLower	将字符串中所有字符转换为小写
StringToUpper	将字符串中所有字符转换为大写
StringTrimLeft	剪切字符串左边的换行符，空格和制表符
StringTrimRight	剪切字符串右边的换行符，空格和制表符

# 9.1 StringAdd

在字符串末尾添加一个子字符串。

bool  StringAdd( 
   string&  string_var,        // 将要添加内容的字符串 
   string   add_substring      // 被添加的子字符串 
   );

1
2
3
4

参量 string_var

[in][out] 字符串，用于在末尾添加内容的字符串。

add_substring

[in] 被添加的子字符串，将添加到源字符串的末尾

返回值

成功返回true,否则返回false,为了获得错误代码，可以调用 GetLastError() 函数。

示例：

void OnStart() 
  { 
   long length=1000000; 
   string a="a",b="b",c; 
//--- 第一函数 
   uint start=GetTickCount(),stop; 
   long i; 
   for(i=0;i<length;i++) 
     { 
      c=a+b; 
     } 
   stop=GetTickCount(); 
   Print("time for 'c = a + b' = ",(stop-start)," milliseconds, i = ",i); 
  
//--- 第二函数 
   start=GetTickCount(); 
   for(i=0;i<length;i++) 
     { 
      StringAdd(a,b); 
     } 
   stop=GetTickCount(); 
   Print("time for 'StringAdd(a,b)' = ",(stop-start)," milliseconds, i = ",i); 
  
//--- 第三函数 
   start=GetTickCount(); 
   a="a"; // 重新初始化变量 a 
   for(i=0;i<length;i++) 
     { 
      StringConcatenate(c,a,b); 
     } 
   stop=GetTickCount(); 
   Print("time for 'StringConcatenate(c,a,b)' = ",(stop-start)," milliseconds, i = ",i); 
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

相关参考

StringConcatenate

# 9.2 StringBufferLen

此函数返回为指定字符串分配的缓冲区大小。

int  StringBufferLen( 
   string  string_var      // 字符串 
   )

1
2
3

参数 string_var

[in] 字符串

返回值

值0表示该字符串是常量，缓冲区大小不能更改。 -1表示该字符串属于客户端，修改缓冲区内容可能会导致不确定的结果。

示例：

void OnStart() 
  { 
   long length=1000; 
   string a="a",b="b"; 
//--- 
   long i; 
   Print("before: StringBufferLen(a) = ",StringBufferLen(a), 
         "  StringLen(a) = ",StringLen(a)); 
   for(i=0;i<length;i++) 
     { 
      StringAdd(a,b); 
     } 
   Print("after: StringBufferLen(a) = ",StringBufferLen(a), 
         "  StringLen(a) = ",StringLen(a)); 
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

相关参考

StringAdd， StringInit， StringLen， StringFill

# 9.3 StringCompare

该函数是比较两个字符串并且以整数形式返回比较结果。

int  StringCompare( 
   const string&  string1,                 // 用于比较的第一个字符串 
   const string&  string2,                 // 用于比较的第二个字符串 
   bool           case_sensitive=true      // 区分大小写  
   );

1
2
3
4
5

参数 string1

[in] 用于比较的第一个字符串。

string2

[in] 用于比较的第二个字符串。

case_sensitive=true

[in] 大小写敏感模式。如果是true，则 "A">"a"。如果是false，则"A"="a"。默认值为 true。

返回值 • -1 (负一), 表示 string1<string2 • 0 (零), 表示 string1=string2 • 1 (一), 表示 string1>string2

注意

字符串是字符与字符相比较，字符根据当前字符编码集以字母表的顺序比较。

示例：

void OnStart()
  {
//--- 哪个更大 - apple or home?
   string s1="Apple";
   string s2="home";
 
//--- 区分大小写的比较 
   int result1=StringCompare(s1,s2);
   if(result1>0) PrintFormat("Case sensitive comparison: %s > %s",s1,s2);
   else
     {
      if(result1<0)PrintFormat("Case sensitive comparison: %s <%s",s1,s2);
      else PrintFormat("Case sensitive comparison: %s = %s",s1,s2);
     }
 
//--- 不区分大小写的比较
   int result2=StringCompare(s1,s2,false);
   if(result2>0) PrintFormat("Case insensitive comparison: %s > %s",s1,s2);
   else
     {
      if(result2<0)PrintFormat("Case insensitive comparison: %s < %s",s1,s2);
      else PrintFormat("Case insensitive comparison: %s = %s",s1,s2);
     }
/* 结果: 
     区分大小写的比较: Apple < home 
     不区分大小写的比较: Apple <home 
*/
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

相关参考

字符串类型， CharToString()， ShortToString()， StringToCharArray()， StringToShortArray()， StringGetCharacter()，使用字符编码集

# 9.4 StringConcatenate

把多个形式参数组成一个普通字符串，并返回字符串的长度值(整数)。参数可以为任意类型。传递的参数总数不得少于2个或超过64个。

int  StringConcatenate( 
   string&  string_var,      // 要形成的字符串 
   void argument1 ,         // 任何简单类型的第一参数 
   void argument2 ,         // 任何简单类型的第二参数 
   ...                      // 任何简单类型的下一个参数 
   );

1
2
3
4
5
6

参数 string_var

[out] 作为串联结果最终形成的字符串。

argumentN

[in] 用逗号分隔的值，数量的范围从2 - 63个，类型为任意简单类型的参数。

返回值

返回字符串长度，并将传递的形式参数串联起来转变成一个字符串类型，根据与 Print() 和 Comment()相同的规则把参数转变成字符串。

示例：

void OnStart() 
  { 
   int a;
   string str1,str2,str3;
   //--- 赋值
   str1="Programming";
   str2="in MQL5";
   str3="for MetaTrader 5";
   //--- 调用组合多个字符串的函数
   a = StringConcatenate(str1,str1," ",str2," ",str3);
   Print("str1 = ",str1);
   Print("a = ", a);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13

相关参考

StringAdd

# 9.5 StringFill

用指定的字符填充字符串。

bool  StringFill( 
   string&   string_var,       // 要添加的字符串 
   ushort    character         // 添加字符串的交易品种 
   );

1
2
3
4

参数 string_var

[in][out] 用来填充的字符串。

character

[in] 指定的字符。如果是一个数字，则表示对应的 ASCII 字符集上的字符。

返回值

如果成功返回true，否则是false，想要获得错误代码可调用函数 GetLastError()。

注意

在字符串中填充字符意味着将字符直接插入到字符串中，而无需创建或复制新字符串的过渡操作。这可以节省操作时间。

示例：

void OnStart() 
  { 
   string str; 
   StringInit(str,20,'_');   // 把字符串 str 初始化为 由20个空格组成的字符串
   Print("str = ",str); 
   StringFill(str,36);  // 第二个参数36，表示用ASCII字符集上的对应的字符 $ 来填充字符串
   Print("str = ",str,": StringBufferLen(str) = ", StringBufferLen(str)); 
   StringFill(str,’$’); // 第二个参数是一个字符 $，即直接用该字符来填充字符串

   Print("str = ",str,": StringBufferLen(str) = ", StringBufferLen(str));   
} // 字符编码与字符集（Encoding & CharSet）——害死多少程序员

1
2
3
4
5
6
7
8
9
10
11

相关参考

StringBufferLen ， StringLen ， StringInit=

# 9.6 StringFind

在字符串中搜索子字符串。

int  StringFind( 
   string  string_value,        // 进行搜索的字符串 
   string  match_substring,     // 搜索内容 
   int     start_pos=0          // 搜索开始位置 
   );

1
2
3
4
5

参数string_value

[in] 用来被搜索的母字符串。

match_substring

[in] 用于搜索的子字符串。

start_pos=0

[in] 指定母子符串中开始搜索的位置索引。默认值0，表示从头开始搜索。

返回值

如果找到子字符串，返回子字符串在母字符串中的开始位置索引编号；

如果没有找到子字符串，则返回 -1。

# 9.7 StringGetCharacter

获取字符串中指定位置的一个字符，返回该字符对应的 ASCII 编号。

ushort  StringGetCharacter( 
   string  string_value,     // 字符串 
   int     pos               // 指定字符的位置 
   );

1
2
3
4

参数 string_value

[in] 字符串

pos

[in] 指定字符串中的位置，取值范围从 0 到 StringLen(text) -1。

返回值

一个字符的ASCII 编号或 0表示出错。想要获得错误代码可调用函数 GetLastError()。

# 9.8 StringInit

用指定字符初始化一个字符串，并指定字符串缓冲区的大小。

bool  StringInit( 
   string&   string_var,       // 要初始化的字符串 
   int       new_len=0,        // 初始化后字符串缓冲区的大小 
   ushort    character=0       // 用来填充字符串的字符 
   );

1
2
3
4
5

参数 string_var

[in][out] 用于初始化和反初始化的字符串。

new_len=0

[in] 初始化结束后的字符串长度，如果长度是0，则表示没有进行字符串初始化，例如，清除字符串的缓冲器，将缓冲器的地址调到0的位置。

character=0

[in] 将交易品种填充字符串。

返回值

如果成功返回true,否则返回false。想要获得错误代码可调用函数 GetLastError()。

注意

如果第三个参数character = 0，并且第二个参数 new_len > 0，则指定长度的字符串的缓冲区将被分配并填充为零。字符串长度将等于零，因为整个缓冲区由字符串终止符填充。

示例：

void OnStart() 
  { 
//--- 
   string str; 
   StringInit(str,200,0); 
   Print("str = ",str,": StringBufferLen(str) = ", 
         StringBufferLen(str),"  StringLen(str) = ",StringLen(str)); 
  } 
/*  Result 
str = : StringBufferLen(str) = 200   StringLen(str) = 0 
*/

1
2
3
4
5
6
7
8
9
10
11

相关参考

StringBufferLen，StringLen

# 9.9 StringLen

返回字符串中字符的数量。

int  StringLen( 
   string  string_value      // 字符串 
   );

1
2
3

参数 string_value

[in] 用于计算长度的字符串。

返回值

字符串中包含字符的数量，不含以 0 结尾的字符。

# 9.10 StringReplace

用一组字符序列替换一个字符串中的搜索到的所有子字符串。(查找并替换)

int  StringReplace( 
   string&         str,              // 子字符串将被替代的字符串 
   const string    find,             // 搜索的子字符串 
   const string    replacement       // 子字符串将被插入到发现位置 
   );

1
2
3
4
5

参数 str

[in][out] 用于查找并替换的母字符串。

find

[in] 查找的子字符串。

replacement

[in] 用来替换的字符串。

返回值

如果成功，函数返回替换的数量，否则为 -1。想要获得错误代码可调用函数 GetLastError()。

注意

如果函数成功运行但是没有替换任何字符串(没有找到符合替换条件的子字符串)，则返回0。

错误可能是因为第一个参数str或第二个参数 find不正确(空或非初始化字符串，请参阅StringInit())导致的。此外，如果没有足够的内存来完成查找替换，也会发生错误。

例如：

  string text="The quick brown fox jumped over the lazy dog."; 
  int replaced=StringReplace(text,"quick","slow"); 
  replaced+=StringReplace(text,"brown","black"); 
  replaced+=StringReplace(text,"fox","bear"); 
  Print("Replaced: ", replaced,". Result=",text); 
   
//  结果 
//  替换：3. Result=The slow black bear jumped over the lazy dog. 
//

1
2
3
4
5
6
7
8
9

相关参考

StringSetCharacter(), StringSubstr()

# 9.11 StringSetCharacter

在字符串中，从指定位置开始，复制指定数量的字符，组成新的字符串返回。

bool  StringSetCharacter( 
   string&   string_var,       // 字符串 
   int       pos,              // 位置 
   ushort    character         // 字符 
   );

1
2
3
4
5

参数 string_var

[in][out] String.

pos

[in] 在字符串上的位置索引编号，从0 开始到 StringLen (text)

character

[in] Unicode字符集中的字符。

注意如果第二个参数pos 小于字符串长度并且第三个参数符号代码值 = 0，则字符串被截断(但为字符串分配的缓冲区大小，保持不变)。字符串长度等于pos。

如果第二个参数pos 等于字符串长度，则在字符串结尾添加指定的字符，并将长度加1。

示例：

void OnStart() 
  { 
   string str="0123456789"; 
   Print("before: str = ",str,",StringBufferLen(str) = ", 
         StringBufferLen(str),"  StringLen(str) = ",StringLen(str)); 
//--- 在中心添加零值 
   StringSetCharacter(str,6,0); 
   Print("  after: str = ",str,",StringBufferLen(str) = ", 
         StringBufferLen(str),"  StringLen(str) = ",StringLen(str)); 
//--- 在末尾添加交易品种 
   int size=StringLen(str); 
   StringSetCharacter(str,size,'+'); 
   Print("addition: str = ",str,",StringBufferLen(str) = ", 
         StringBufferLen(str),"  StringLen(str) = ",StringLen(str)); 
  } 
/* Result 
   before: str = 0123456789 ,StringBufferLen(str) = 0   StringLen(str) = 10 
    after: str = 012345 ,StringBufferLen(str) = 16   StringLen(str) = 6 
   addition: str = 012345+ ,StringBufferLen(str) = 16   StringLen(str) = 7 
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

相关参考

StringBufferLen， StringLen， StringFill， StringInit

# 9.12 StringSplit

通过字符串中指定的分隔符，来分割子字符串，返回获得的子字符串的数量。

int  StringSplit( 
   const string   string_value,       // 用于搜索的字符串 
   const ushort   separator,          // 被搜索子字符串使用的分隔符 
   string         & result[]          // 通过引用传递数组得到寻找的子字符串 
   );

1
2
3
4
5

参数 string_value

[in] 用来分隔的母字符串。该字符串不会被改变。

pos

[in] 分隔符的ASCII代码。要获得字符对应的字符集代码，可以使用 StringGetCharacter() 函数。

result[]

[out] 获取的子字符串所在的字符串数组。

返回值 result[]数组中的子字符串的数量。如果在传递的字符串没有找到分隔符，那么将只有母字符串被保存在数组中。

如果母字符串 string_value 为空或 NULL，函数将返回零。如果发生错误，则函数返回 -1。想要获得错误代码可调用函数 GetLastError()。

例如：

string to_split="_life_is_good_"; // 字符串分成子字符串 
   string sep="_";                // 分隔符为字符 
   ushort u_sep;                  // 分隔符字符代码 
   string result[];               // 获得字符串数组 
   //--- 获得分隔符代码 
   u_sep=StringGetCharacter(sep,0); 
   //--- 字符串分为子字符串 
   int k=StringSplit(to_split,u_sep,result); 
   //--- 显示注释  
   PrintFormat("Strings obtained: %d. Used separator '%s' with the code %d",k,sep,u_sep); 
   //--- 现在输出所有获得的字符串 
   if(k>0) 
     { 
      for(int i=0;i<k;i++) 
        { 
         PrintFormat("result[%d]=\"%s\"",i,result[i]); 
        } 
     }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

相关参考

StringReplace(), StringSubstr(), StringConcatenate()

# 9.13 StringSubstr

从字符串中指定位置开始提取子字符串。

string  StringSubstr( 
   string  string_value,     // 字符串 
   int     start_pos,        // 初始位置 
   int     length=-1         // 提取的字符串的长度 
   );

1
2
3
4
5

参数 string_value

[in] 用来提取子串的母字符串。

start_pos

[in] 子串在母字符串中的初始位置，从0到 StringLen(text) -1。

Length = -1

[in] 提取子串的长度，如果参数值是 -1或者没有参数，子串会从指定位置开始提取直到母字符串结束。

返回值

如果可能的话，复制提取的子串，否则返回空字符串

# 9.14 StringToLower

将字符串中所有字符转换为小写

bool  StringToLower( 
   string&  string_var      // 要处理的字符串 
   );

1
2
3

参数 string_var

[in][out] 字符串。

返回值

如果成功，返回值是true,否则是false，想要获得错误代码可调用函数 GetLastError()。

# 9.15 StringToUpper

将字符串中所有字符转换为大写

bool  StringToUpper( 
   string&  string_var      // 要处理的字符串 
   );

1
2
3

参数c string_var

[in][out] 字符串

返回值

如果成功，返回值是true,否则是false，想要获得错误代码可调用函数 GetLastError()。

# 9.16 StringTrimLeft

剪切字符串左边的换行符，空格和制表符

int  StringTrimLeft( 
   string&  string_var      // 要剪切的字符串 
   );

1
2
3

参数 string_var

[in][out] 要剪切的字符串。

返回值

返回剪切的字符数量。

# 9.17 StringTrimRight

剪切字符串右边的换行符，空格和制表符

int  StringTrimRight( 
   string&  string_var      // 要剪切的字符串 
   );

1
2
3

参数 string_var

[in][out] 要剪切的字符串。

返回值

返回剪切的字符数量。

← 09 第九章数学函数 11 第十一章日期和时间 →

第九章 字符串函数

# 9.1 StringAdd

# 9.2 StringBufferLen

# 9.3 StringCompare

# 9.4 StringConcatenate

# 9.5 StringFill

# 9.6 StringFind

# 9.7 StringGetCharacter

# 9.8 StringInit

# 9.9 StringLen

# 9.10 StringReplace

# 9.11 StringSetCharacter

# 9.12 StringSplit

# 9.13 StringSubstr

# 9.14 StringToLower

# 9.15 StringToUpper

# 9.16 StringTrimLeft

# 9.17 StringTrimRight

第九章字符串函数