MQL5编程基础：文件

为了创建文件，请使用FileOpen（）函数将其打开。使用FILE_READ标志而不是FILE_WRITE一个打开“ test.txt”文件：

整型 h=FileOpen("test.txt",FILE_WRITE|FILE_ANSI|FILE_TXT);

打开文件后，请确保像读取文件时一样检查手柄。如果该函数执行成功，则将创建新的“ test.txt”文件。如果文件已经存在，则将其完全清除。打开要写入的文件时要小心，不要丢失有价值的数据。 

写入文本文件是由 FileWrite（） 功能。第一个参数设置文件句柄，而第二个参数设置写入文件的行。在FileWrite（）函数的每次调用时都会写入新行。

让我们在循环中将十行写入文件。最终的脚本代码（sTestFileCreate）如下所示：

void OnStart(){
   整型 h=FileOpen("test.txt",FILE_WRITE|FILE_ANSI|FILE_TXT);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }
   for(整型 i=1;i<=10;i++){
      FileWrite(h,"Line-"+IntegerToString(i));
   }
   FileClose(h);
   Alert("File created");
}

执行代码后，“ test.txt”文件应包含十行。要检查文件内容，请在记事本中打开它或执行sTestFileReadToAlert脚本。

请注意FileWrite（）函数。它可能有两个以上的参数。您可以将多个字符串变量传递给该函数，并且在编写时将它们组合为一行。在指定的代码中，FileWrite（）函数的调用可以编写如下：

FileWrite(h,"Line-",IntegerToString(i));

写入时，该功能将自动合并行。

写入文本文件的末尾

有时，有必要在现有文件中添加一个或几个新的文本行，而其余内容保持不变。要执行此类操作，应打开文件以同时进行读写。这意味着在调用FileOpen（）函数时，应同时指定两个标志（FILE_READ和FILE_WRITE）。

整型 h=FileOpen("test.txt",FILE_READ|FILE_WRITE|FILE_ANSI|FILE_TXT);

如果指定名称的文件不存在，则会创建该文件。如果已经存在，则将其打开，同时其内容保持不变。但是，如果我们立即开始写入文件，则其先前的内容将被删除，因为写入是从文件的开头执行的。

处理文件时，会出现“指针”之类的东西-指示位置的数字值，从该位置开始执行下一个条目或从文件中读取。打开文件时，指针会自动设置在文件的开头。在读取或写入数据期间，它会根据读取或写入的数据大小自动重定位。您可以根据需要自己重新定位指针。为此，请使用  FileSeek（） 功能.  

为了保存先前的内容并将新的内容添加到文件的末尾，请在写入之前将指针重定位到文件的末尾：

FileSeek(h,0,SEEK_END);

这三个参数发送到FileSeek（）函数：句柄，指针重定位值和从中计算移位的位置。在此示例中，SEEK_END常量表示文件的结尾。因此，指针从文件末尾移了0个字节（意味着移到其末尾）。

添加到文件中的最终脚本代码如下：

void OnStart(){
   整型 h=FileOpen("test.txt",FILE_READ|FILE_WRITE|FILE_ANSI|FILE_TXT);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }
   FileSeek(h,0,SEEK_END);
   FileWrite(h,"Additional line");
   FileClose(h);
   Alert("Added to file");
}

该脚本也附在下面（sTestFileAddToFile）。启动脚本并检查test.txt文件的内容。每次调用sTestFileAddToFile脚本都会向test.txt添加一行。

更改文本文件的指定行

对于文本文件，在整个文件中自由移动指针的功能只能用于添加文件，不适用于进行更改。由于文件行只是一个概念，因为文件实际上包含连续的一系列数据，因此无法对某个文件行进行更改。有时，此类系列包含在文本编辑器中不可见的特殊字符。他们指出，以下信息应换行显示。如果我们将指针设置在行的开头并开始写入，则如果写入数据的大小小于现有行，则行中的先前数据将保留。否则，新的线符号将与下一部分线数据一起删除。

让我们尝试替换test.txt中的第二行。打开文件进行读取和写入，读取一行以将指针重新定位到第二行的开头，并写入由两个字母“ AB”组成的新行（下面附有sTestFileChangeLine2-1脚本）：

void OnStart(){
   整型 h=FileOpen("test.txt",FILE_READ|FILE_WRITE|FILE_ANSI|FILE_TXT);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }
   力量ing 力量=FileReadString(h);
   FileWrite(h,"AB");
   FileClose(h);
   Alert("Done");
} 

现在，获得的test.txt文件如下所示（图4）：

 
图4.尝试更改一行后的文本文件的内容 

现在，我们有两行而不是一行：“ AB”和“ -2”。 “ -2”是第二行剩下的内容，其中删除了四个字符。原因是当使用FileWrite（）函数编写一行时，它将新的行符号添加到所写文本的末尾。在Windows操作系统中，换行符号由两个字符组成。如果在“ AB”行中向他们添加两个字符，我们可以理解为什么在结果文件中删除了四个字符。 

执行sTestFileCreate脚本以还原test.txt，然后尝试将第二行替换为更长的行。让我们编写“ Line-12345”（下面随附的sTestFileChangeLine2-2脚本）：

void OnStart(){
   整型 h=FileOpen("test.txt",FILE_READ|FILE_WRITE|FILE_ANSI|FILE_TXT);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }
   力量ing 力量=FileReadString(h);
   FileWrite(h,"Line-12345");
   FileClose(h);
   Alert("Done");
}

让我们看一下结果文件（图5）：

 
图5.第二次尝试更改文本文件单行的结果 

由于新行比上一行长，因此第三行也受到了影响。 

更改文本文件的唯一方法是完整读取和重写它们。我们应该将文件读取到数组，更改必要的数组元素，将其逐行保存到另一个文件，删除旧文件并重命名新文件。有时，不需要数组：从一个文件读取行时，可以将它们写入另一个文件。在某个时间点，将进行更改并将其保存在必要的行中。之后，将删除旧文件，然后将新文件重命名。

让我们应用后一个选项（不更改数组即可更改）。首先，我们应该创建一个临时文件。让我们编写一个用于接收临时文件的唯一名称的函数。文件名和扩展名将传递给该函数。检查文件是否存在（按标准 FileIsExists（） 函数）。如果文件存在，则会向其添加一个数字，直到没有检测到具有该名称的文件为止。该函数如下所示：

力量ing TmpFileName(力量ing Name,力量ing Ext){
   力量ing fn=Name+"."+Ext; // forming name
   整型 n=0;
   while(FileIsExist(fn)){ // if the file exists
      n++;
      fn=Name+IntegerToString(n)+"."+Ext; // add a number to the name
   }
   return(fn);
}

让我们创建sTestFileChangeLine2-3脚本，将函数复制到脚本中，并将以下代码放入OnStart（）函数中。

打开test.txt以阅读：

整型 h=FileOpen("test.txt",FILE_READ|FILE_ANSI|FILE_TXT);

接收临时文件的名称并打开它：

力量ing tmpName=TmpFileName("test","txt");

整型 tmph=FileOpen(tmpName,FILE_WRITE|FILE_ANSI|FILE_TXT);

逐行读取文件。所有读取的行都发送到临时文件，第二行被替换：

   整型 cnt=0;
   while(!FileIsEnding(h)){
      cnt++;
      力量ing 力量=FileReadString(h);
      if(cnt==2){
         // replace the line
         FileWrite(tmph,"New line-2");
      }
      else{
         // rewrite the line with no changes
         FileWrite(tmph,str);
      }
   }

关闭两个文件：

FileClose(tmph);
FileClose(h);

现在，我们要做的就是删除原始文件并重命名临时文件。标准 FileDelete（） 功能用于删除。

FileDelete("test.txt");

要重命名文件，我们应该使用标准 FileMove（） 用于移动或重命名文件的功能。该函数接收四个必填参数：重定位文件（源文件）的名称，文件位置标志，新文件名（目标标志），覆盖标志。文件名应该很清楚，所以现在是时候仔细看看第二和第四参数-标志。第二个参数定义源文件的位置。 MQL5中可用于处理的文件不仅可以位于终端的MQL5 / Files文件夹中，还可以位于所有终端的公共文件夹中。我们将在以后更详细地考虑这一点。现在，让我们将其设置为0。最后一个参数定义目标文件的位置。如果目标文件存在，它可能还具有定义操作的附加标志。由于我们已经删除了源文件（目标文件），因此第四个参数设置为0：

FileMove(tmpName,0,"test.txt",0);

在执行sTestFileChangeLine2-3脚本之前，请使用sTestFileCreate脚本还原test.txt。在sTestFileChangeLine2-3脚本操作之后，text.txt应具有以下内容（图6）：

 
图6.替换行后的文件内容

让我们返回FileMove（）函数。如果我们将FILE_REWRITE标志（允许我们重写目标文件）设置为第四个参数：

FileMove(tmpName,0,"test.txt",FILE_REWRITE);

不必从脚本中删除源文件。此选项在下面随附的sTestFileChangeLine2-3脚本中使用。 

代替FileMove（）函数，我们可以使用另一个标准函数 FileCopy（），但是在这种情况下，我们需要删除临时文件：

FileCopy(tmpName,0,"test.txt",FILE_REWRITE);
FileDelete(tmpName); 

将文本文件读取到数组

bool ReadFileToArray(力量ing FileName,力量ing & Lines[]){
   ResetLastError();
   整型 h=FileOpen(FileName,FILE_READ|FILE_ANSI|FILE_TXT);
   if(h==INVALID_HANDLE){
      整型 ErrNum=GetLastError();
      printf("Error opening file %s # %i",FileName,ErrNum);
      return(假);
   }
   整型 cnt=0; // use the variable to count the number of file lines
   while(!FileIsEnding(h)){
      力量ing 力量=FileReadString(h); // read the next line from the file
      // remove spaces to the left 和 to the right to detect 和 avoid using empty lines
      StringTrimLeft(str); 
      StringTrimRight(str);
      if(str!=""){ 
         if(cnt>=ArraySize(Lines)){ // array filled completely
            ArrayResize(Lines,ArraySize(Lines)+1024); // increase the array size by 1024 elements
         }
         Lines[cnt]=str; // send the read line to the array
         cnt++; // increase the counter of read lines
      }
   }
   ArrayResize(Lines,cnt);
   FileClose(h);
   return(真正);
}

整型 h=FileOpen("test.csv",FILE_WRITE|FILE_ANSI|FILE_CSV,";");

   for(整型 i=1;i<=10;i++){
      力量ing 力量="Line-"+IntegerToString(i)+"-";
      FileWrite(h,str+"1",str+"2",str+"3");
   }

整型 h=FileOpen(FileName,FILE_READ|FILE_ANSI|FILE_CSV,";");

void OnStart(){
   ReadFileToAlertCSV("test.csv");
}

void ReadFileToAlertCSV2(力量ing FileName){
   整型 h=FileOpen(FileName,FILE_READ|FILE_ANSI|FILE_CSV,";");
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }   
   Alert("=== Start ===");   
   while(!FileIsEnding(h)){
      力量ing 力量=FileReadString(h);
      Alert(str);
      if(FileIsLineEnding(h)){
         Alert("---");
      }
   }
   FileClose(h);
}

力量uct SLine{
   力量ing line[];
};  

bool ReadFileToArrayCSV(力量ing FileName,SLine & Lines[]){
   ResetLastError();
   整型 h=FileOpen(FileName,FILE_READ|FILE_ANSI|FILE_CSV,";");
   if(h==INVALID_HANDLE){
      整型 ErrNum=GetLastError();
      printf("Error opening file %s # %i",FileName,ErrNum);
      return(假);
   }   
   整型 lcnt=0; // variable for calculating lines 
   整型 fcnt=0; // variable for calculating line fields    
   while(!FileIsEnding(h)){
      力量ing 力量=FileReadString(h);
      // new line (new element of the 结构体 array)
      if(lcnt>=ArraySize(Lines)){ // 结构体 array completely filled
         ArrayResize(Lines,ArraySize(Lines)+1024); // increase the array size by 1024 elements
      }
      ArrayResize(Lines[lcnt].field,64);// change the array size in the 结构体
      Lines[lcnt].field[0]=str; // assign the first field value
      // start reading other fields in the line
      fcnt=1; // till 上e element in the line array is occupied
         while(!FileIsLineEnding(h)){ // read the rest of fields in the line
            str=FileReadString(h);
            if(fcnt>=ArraySize(Lines[lcnt].field)){ // field array is completely filled
               ArrayResize(Lines[lcnt].field,ArraySize(Lines[lcnt].field)+64); // increase the array size by 64 elements
            }     
            Lines[lcnt].field[fcnt]=str; // assign the value of the next field
            fcnt++; // increase the line counter
         }
      ArrayResize(Lines[lcnt].field,fcnt); // change the size of the field array according to the actual number of fields
      lcnt++; // increase the line counter
   }
   ArrayResize(Lines,lcnt); // change the array of 结构体s (lines) according to the actual number of lines
   FileClose(h);
   return(真正);
}

整型 h=FileOpen("test.csv",FILE_WRITE|FILE_ANSI|FILE_TXT);

   力量ing 力量="";
   整型 size=ArraySize(a);
   if(size>0){
      str=a[0];
      for(整型 i=1;i<size;i++){
         力量=str+";"+a[i]; // merge fields using a separator 
      }
   }

FileWriteString(h,str);
FileClose(h);

整型 h=FileOpen(FileName,FILE_READ|FILE_UNICODE|FILE_TXT);

整型 h=FileOpen("test.txt",FILE_WRITE|FILE_UNICODE|FILE_TXT);

在MQL5中使用文件的大多数功能都是为二进制模式设计的。有用于读取/写入不同类型变量的函数：  

在此我们将不描述所有可变的读写功能。我们只需要其中之一，而其余所有都以相同的方式使用。让我们尝试使用FileWriteDouble（）和FileReadDouble（）函数。

首先，创建一个文件，向其中写入三个变量，并以随机顺序读取它们。 

打开文件：

整型 h=FileOpen("test.bin",FILE_WRITE|FILE_BIN);

将三个双精度变量值分别为1.2、3.45和6.789写入文件：

FileWriteDouble(h,1.2);
FileWriteDouble(h,3.45);
FileWriteDouble(h,6.789);

不要忘记关闭文件。

可以在随附的sTestFileCreateBin脚本中找到该代码。结果，test.bin文件出现在MQL5 / Files文件夹中。在记事本中查看其内容（图11）。打开记事本并将文件拖到其中：

 
图11.记事本中的二进制文件

如我们所见，在记事本中查看此类文件毫无意义。

现在，让我们阅读文件。显然，应该使用FileReadDouble（）函数进行读取。打开文件：

整型 h=FileOpen("test.bin",FILE_READ|FILE_BIN);

声明三个变量，从文件中读取它们的值，然后在消息框中显示它们：

双 v1,v2,v3;
   
v1=FileReadDouble(h);
v2=FileReadDouble(h);
v3=FileReadDouble(h);
   
Alert(DoubleToString(v1)," ",DoubleToString(v2)," ",DoubleToString(v3));
  

不要忘记关闭文件。可以在随附的sTestFileReadBin脚本中找到该代码。结果，我们收到以下消息：1.20000000 3.45000000 6.78900000。

知道二进制文件的结构，可以对它们进行一些有限的更改。让我们尝试更改第二个变量，而不用重写整个文件。

打开文件：

整型 h=FileOpen("test.bin",FILE_READ|FILE_WRITE|FILE_BIN);

打开后，将指针移到指定位置。建议使用sizeof（）函数进行位置计算。它返回指定数据类型的大小。熟悉 资料类型 及其大小。将指针移到第二个变量的开头：

FileSeek(h,sizeof(双)*1,0);

为了更清楚，我们实现了sizeof（double）* 1乘法，因此很明显这是第一个变量的结尾。如果需要更改第三个变量，则需要乘以2。

写下新值： 

FileWriteDouble(h,12345.6789);

可以在随附的sTestFileChangeBin脚本中找到该代码。执行脚本后，启动sTestFileReadBin脚本并接收： 1.20000000 12345.67890000 6.78900000。

您可以用相同的方式读取某个变量（而不是整个文件）。让我们阅读一下从test.bin中读取第三个double变量的代码。

打开文件：

整型 h=FileOpen("test.bin",FILE_READ|FILE_BIN);

移动指针，读取值并将其显示在消息框中：

FileSeek(h,sizeof(双)*2,SEEK_SET);
双 v=FileReadDouble(h);
Alert(DoubleToString(v));

可以在下面附带的sTestFileReadBin2脚本中找到此示例。结果，我们收到以下消息：6.78900000-第三个变量。更改代码以读取第二个变量。

您可以以相同的方式保存和读取其他类型的变量及其组合。重要的是要知道文件结构，以正确计算指针设置位置。 

二进制文件，结构

力量uct STest{
   长 ValLong;
   双 VarDouble;
   整型 ArrInt[3];
   bool VarBool;
};

STest s1;
STest s2;
   
s1.ArrInt[0]=1;
s1.ArrInt[1]=2; 
s1.ArrInt[2]=3;
s1.ValLong=12345;
s1.VarDouble=12.34;
s1.VarBool=真正;
         
s2.ArrInt[0]=11;
s2.ArrInt[1]=22; 
s2.ArrInt[2]=33;
s2.ValLong=6789;
s2.VarDouble=56.78;
s2.VarBool=假;  

整型 h=FileOpen("test.bin",FILE_WRITE|FILE_BIN);

FileWriteStruct(h,s1);
FileWriteStruct(h,s2); 

整型 h=FileOpen("test.bin",FILE_READ|FILE_BIN);

FileSeek(h,sizeof(STest)*1,SEEK_SET);

STest s;
FileReadStruct(h,s);

Alert(s.ArrInt[0]," ",s.ArrInt[1]," ",s.ArrInt[2]," ",s.ValLong," ",s.VarBool," ",s.VarDouble);   

FileSeek(h,sizeof(STest)+sizeof(长),SEEK_SET);

的 FileWriteString（） 函数用于将字符串写入二进制文件。两个强制性参数传递给该函数：文件句柄和写入文件的一行。第一个参数是可选的：如果只应写一行的一部分，则可以设置写符号的数量。 

该行由 FileReadString（） 功能。在此函数中，第一个参数是一个句柄，而第二个（可选）参数用于设置读取字符的数量。

通常，写入/读取行与使用数组非常相似：一行与整个数组相似，而一个行字符与单个数组元素有很多共同之处，因此我们将不显示单个示例线写作/阅读。相反，我们将考虑更复杂的示例：写入和读取字符串数组。首先，让我们将 整型 具有数组大小的变量，然后在循环中编写单独的元素，并添加 整型 变量的大小在每个变量的开头： 

void OnStart(){
   整型 h=FileOpen("test.bin",FILE_WRITE|FILE_BIN);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }   
   
   力量ing a[]={"Line-1","Line-2","Line-3"}; // written array 

   FileWriteInteger(h,ArraySize(a),INT_VALUE); // write the array size
   
   for(整型 i=0;i<ArraySize(a);i++){
      FileWriteInteger(h,StringLen(a[i]),INT_VALUE); // write the line size (a single array element)
      FileWriteString(h,a[i]);
   }

   FileClose(h);
   Alert("File written");
}

可以在随附的sTestFileWriteStringArray脚本中找到该代码。

读取时，请先读取数组大小，然后更改其大小并读取单独的元素以读取其大小：

void OnStart(){
   整型 h=FileOpen("test.bin",FILE_READ|FILE_BIN);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }   
   
   力量ing a[]; // read the file to this array
   
   整型 s=FileReadInteger(h,INT_VALUE); // read the array size
   ArrayResize(a,s); // change the array size
   
   for(整型 i=0;i<s;i++){ // by all array elements
      整型 ss=FileReadInteger(h,INT_VALUE); // read the line size
      a[i]=FileReadString(h,ss); // read the line
   }

   FileClose(h);

   // display the read array
   Alert("=== Start ===");
   for(整型 i=0;i<ArraySize(a);i++){
      Alert(a[i]);
   }

}

可以在随附的sTestFileReadStringArray脚本中找到该代码。 

到目前为止，我们的文件处理仅与在帐户（在图表上启动）上运行的MQL5程序（脚本，EA，指标）有关。但是，在测试器中启动EA时，一切都不同。 MetaTrader 5测试人员可以使用远程代理执行分布式（云）测试。粗略地说，在一台PC上执行优化运行1-10（编号是有条件的），而在另一台PC上执行优化11-20，等等。这可能会造成困难并影响文件的使用。让我们考虑这些功能，并形成在测试仪中使用文件时应遵循的原则。

处理文件时，FileOpen（）函数访问位于终端数据文件夹内MQL5 / Files目录中的文件。在测试时，该函数访问测试代理文件夹中的MQL5 / Files目录文件。例如，如果在单次优化运行（或单次测试）过程中需要这些文件，以存储头寸或挂单上的数据，那么您要做的就是在下一次运行之前（初始化EA时）清除文件。如果该文件是手动生成的，并且也将用于确定任何EA操作参数，则它将位于终端数据文件夹的MQL5 / Files目录中。这意味着测试人员将无法看到它。为了让EA访问文件，应将其传递给代理。这是通过设置“ #property tester_file”属性在EA中完成的。因此，可以发送任意数量的文件：

#property tester_file "file1.txt"
#property tester_file "file2.txt"
#property tester_file "file3.txt"

但是，即使使用“ #property tester_file”指定了文件，EA仍会写入位于测试代理目录中的文件副本。终端数据文件夹中的文件保持不变。 EA从代理文件夹中进一步读取文件。换句话说，读取更改的文件。因此，如果您需要保存一些数据以在EA测试和优化过程中进行进一步分析，则将数据保存到文件不适用。你应该用 镜框 代替。

如果不使用远程代理，请使用共享文件夹中的文件（打开文件时设置FILE_COMMON标志）。在这种情况下，无需在EA属性中指定文件名，并且EA能够写入文件。简而言之，使用公用数据文件夹时，除了不应该使用远程代理外，使用测试仪中的文件要简单得多。另外，请注意文件名，以使经过测试的EA不会破坏实际工作的EA使用的文件。可以通过编程定义在测试器中的工作：

MQLInfoInteger(MQL5_TESTER)

测试时，请使用其他文件名。

我们已经考虑了几乎所有用于处理文件的功能，除了一些很少使用的功能： 文件大小（）, FileTell（） 和 FileFlush（）。 FileSize（）函数返回打开的文件的大小（以字节为单位）：

void OnStart(){
   整型 h=FileOpen("test.txt",FILE_READ|FILE_ANSI|FILE_TXT);
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }
   ulong size=FileSize(h);
   FileClose(h);
   Alert("File size "+IntegerToString(size)+" (bytes)");
}

可以在随附的sTestFileSize脚本中找到该代码。执行脚本时，将打开文件大小的消息窗口。 

FileTell（）函数返回打开的文件的文件指针的位置。该函数很少使用，因此很难想到任何合适的示例。只需指出其存在并记住它，以备不时之需。

FileFlush（）函数更有用。如文档中所述，该函数将文件输入/输出缓冲区中剩余的所有数据发送到磁盘。函数调用的效果类似于关闭和重新打开文件（尽管它更节省资源，并且文件指针保持在其初始位置）。众所周知，文件作为条目存储在磁盘上。但是，直到打开文件后，才写入缓冲区而不是磁盘。关闭文件后，将执行磁盘写操作。因此，在紧急程序终止的情况下不会保存数据。如果在每次写入文件后调用FileFlush（），则数据将保存在磁盘上，并且程序崩溃不会引起任何问题。

除了使用文件之外，MQL5还具有许多用于处理文件夹的功能： FolderCreate（）, FolderDelete（） 和 FolderClean（）。 FolderCreate函数用于创建文件夹。所有功能都有两个参数。第一个对于文件夹名称是必需的。第二个是除 FILE_COMMON标志（用于处理公共数据文件夹中的文件夹）。 

FolderDelete（）删除指定的文件夹。只能删除一个空文件夹。但是，清除文件夹的内容不是问题，因为为此使用FolderClean（）函数。包括子文件夹和文件在内的所有内容都将被删除。 

有时，您不记得确切的文件名。您可能还记得开头而不是数字结尾，例如file1.txt，file2.txt等。在这种情况下，可以使用掩码和 FileFindFirst（）, FileFindNext（）, FileFindClose（） 职能。这些功能搜索文件和文件夹。文件夹名称可以通过在末尾加反斜杠来与文件名区分开。

让我们编写一个有用的函数来获取文件和文件夹列表。让我们在一个数组中收集文件名，而在另一个数组中收集文件夹名：

void GetFiles(力量ing folder, 力量ing & files[],力量ing & folders[],整型 common_flag=0){

   整型 files_cnt=0; // files counter
   整型 folders_cnt=0; // folders counter   
   
   力量ing name; // variable for receiving a file 要么 folder name 

   长 h=FileFindFirst(folder,name,common_flag); // receive a search handle 和 a name 
                                      // of the first file/folder (if present)
   if(h!=INVALID_HANDLE){ // at least a single file 要么 folder is present
      do{
         if(StringSubstr(name,StringLen(name)-1,1)=="\\"){ // folder
            if(folders_cnt>=ArraySize(folders)){ // check the array size, 
                                                 // increase it if necessary
               ArrayResize(folders,ArraySize(folders)+64);
            }
            folders[folders_cnt]=name; // send the folder name to the array
            folders_cnt++; // count the folders        
         }
         else{ // file
            if(files_cnt>=ArraySize(files)){ // check the array size, 
                                             // increase it if necessary
               ArrayResize(files,ArraySize(files)+64);
            }
            files[files_cnt]=name; // send the file name to the array
            files_cnt++; // count the files
         }
      }
      while(FileFindNext(h,name)); // receive the name of the next file 要么 folder
      FileFindClose(h); // end search
   }
   ArrayResize(files,files_cnt); // change the array size according to 
                                 // the actual number of files
   ArrayResize(folders,folders_cnt); // change the array size according to 
                                        // the actual number of folders
}

尝试使用此功能。让我们通过以下方式从脚本中调用它： 

void OnStart(){

   力量ing files[],folders[];

   GetFiles("*",files,folders);
   
   Alert("=== Start ===");
   
   for(整型 i=0;i<ArraySize(folders);i++){
      Alert("Folder: "+folders[i]);
   }      
   
   for(整型 i=0;i<ArraySize(files);i++){
      Alert("File: "+files[i]);
   }

} 

 sTestFileGetFiles脚本如下所示。注意“ *”搜索掩码：

GetFiles("*",files,folders);

该掩码允许在MQL5 / Files目录中搜索所有文件和文件夹。

为了找到所有以“ test”开头的文件和文件夹，可以使用“ test *”掩码。如果仅需要txt文件，则将需要“ * .txt”掩码，等等。创建包含多个文件的文件夹（例如，“ folder1”）。您可以使用“ folder1 \\ *”掩码来接收其包含的文件列表。 

Сode页面

在本文中，FileOpen（）函数通常应用于示例代码。让我们考虑一下我们尚未描述的参数之一- 代码页。代码页是文本符号及其数值的转换表。让我们看一下ANSI编码以更清楚。编码字符表仅包含256个字符，这意味着每种语言都使用操作系统设置中定义的单独代码页。 CP_ACP常数对应于代码页，从中默认调用FileOpen（）函数。某个人不太可能需要使用其他代码页，因此，对该主题进行详细介绍是没有意义的。一般知识就足够了。 

不受限制地处理文件

#import "kernel32.dll"
   整型 CopyFileW(力量ing,力量ing,整型);
#import

void OnStart(){
   
   力量ing src=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Scripts\\"+MQLInfoString(MQL_PROGRAM_NAME)+".mq5";
   力量ing dst=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files\\"+MQLInfoString(MQL_PROGRAM_NAME)+".mq5";
   
   if(CopyFileW(src,dst,0)==1){
      Alert("File copied");
   }
   else{
      Alert("Failed to copy the file");   
   }
}

#property 脚本_show_inputs

input bool     UseDateFrom = 假; // Set the start date
input datetime DateFrom=0; // Start date
input bool     UseDateTo=假; // Set the end date
input datetime DateTo=0; // End date

   datetime from,to;
   
   if(UseDateFrom){
      from=DateFrom;
   }
   else{
      整型 bars=Bars(Symbol(),Period());
      if(bars>0){
         datetime tm[];
         if(CopyTime(Symbol(),Period(),bars-1,1,tm)==-1){
            Alert("Error defining data start, please try again later");
            return;
         }
         else{
            from=tm[0];
         }
         
      }
      else{
         Alert("Timeframe is under construction, please try again later");
         return;
      }
   }
   
   if(UseDateTo){
      to=DateTo;
   }
   else{
      to=TimeCurrent();
   }   

   MqlRates rates[];
   
   if(CopyRates(Symbol(),Period(),from,to,rates)==-1){
      Alert("Error copying quotes, please try again later");
   }

   力量ing FileName=Symbol()+" "+IntegerToString(PeriodSeconds()/60)+".csv";
   
   整型 h=FileOpen(FileName,FILE_WRITE|FILE_ANSI|FILE_CSV,";");
   
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }
   
   // write data to the file in the format: Time, Open, High, Low, Close, Volume, Ticks
   
   // the first line to know the location
   FileWrite(h,"Time","Open","High","Low","Close","Volume","Ticks");  
   
   for(整型 i=0;i<ArraySize(rates);i++){
      FileWrite(h,rates[i].time,rates[i].open,rates[i].high,rates[i].low,rates[i].close,rates[i].real_volume,rates[i].tick_volume);
   }
   
   FileClose(h);

   Alert("Save complete, see the file "+FileName);   

   datetime from,to;
   
   if(UseDateFrom){
      from=DateFrom;
   }
   else{
      from=0;
   }
   
   if(UseDateTo){
      to=DateTo;
   }
   else{
      to=TimeCurrent();
   }  

   if(!HistorySelect(from,to)){
      Alert("Error allocating history");
      return;
   }

   力量ing FileName="history.csv";
   
   整型 h=FileOpen(FileName,FILE_WRITE|FILE_ANSI|FILE_CSV,";");
   
   if(h==INVALID_HANDLE){
      Alert("Error opening file");
      return;
   }

   FileWrite(h,"Time","Deal","Order","Symbol","Type","Direction","Volume","Price","Comission","Swap","Profit","Comment");     

   for(整型 i=0;i<HistoryDealsTotal();i++){
      ulong ticket=HistoryDealGetTicket(i);
      if(ticket!=0){         
         长 type=HistoryDealGetInteger(ticket,DEAL_TYPE);         
         if(type==DEAL_TYPE_BUY || type==DEAL_TYPE_SELL){      
            长 entry=HistoryDealGetInteger(ticket,DEAL_ENTRY);      
            FileWrite(h,(datetime)HistoryDealGetInteger(ticket,DEAL_TIME),
                        ticket,
                        HistoryDealGetInteger(ticket,DEAL_ORDER),
                        HistoryDealGetString(ticket,DEAL_SYMBOL),
                        (type==DEAL_TYPE_BUY?"buy":"sell"),
                        (entry==DEAL_ENTRY_IN?"in":(entry==DEAL_ENTRY_OUT?"out":"in/out")),
                        DoubleToString(HistoryDealGetDouble(ticket,DEAL_VOLUME),2),
                        HistoryDealGetDouble(ticket,DEAL_PRICE),
                        DoubleToString(HistoryDealGetDouble(ticket,DEAL_COMMISSION),2),
                        DoubleToString(HistoryDealGetDouble(ticket,DEAL_SWAP),2),
                        DoubleToString(HistoryDealGetDouble(ticket,DEAL_PROFIT),2),
                        HistoryDealGetString(ticket,DEAL_COMMENT)                     
            );
         }
      }
      else{
         Alert("Error allocating a trade, please try again");
         FileClose(h);
         return;
      }
   }

   FileClose(h);
   Alert("Save complete, see the file "+FileName); 

在本文中，我们考虑了在MQL5中处理文件的所有功能。 尽管主题看似狭窄，但文章的篇幅却很大。 但是，一些与主题相关的问题已被粗略地检查过，并且没有足够的实际例子。无论如何，都会详细讨论最常见的任务，包括在测试仪中处理文件。此外，我们开发了许多有用的功能，所有示例都是实用且逻辑上完整的。所有代码都作为脚本附在下面。