简介

很多交易者经常会遇到夜间交易的概念，遇到这个概念给我们的第一印象就是在夜间进行交易。然而，一切都更简单：因为在不同的时区中，世界上不同部分的夜晚是在不同时间到来的。美洲和欧洲交易市场的开市时间，相对于协和标准时间(UTC World Coordinated Time), 在时区上分别是-4和+1。

它们之后是亚太交易市场，它们的时区是和对应的美洲和欧洲时区相反的。在这里，交易开始的时候美国交易者回家了，而欧洲交易者睡觉了。这就是我们现在理解的夜间交易。交易市场的时间段可以按照下面的方法显示 (图 1, 时间是从右向左的):

图 1. 世界地图上的交易市场

很明显，夜间交易在货币对 EURUSD, GBPUSD, USDCHF, USDCAD 和 EURGBP 显示出平缓的变化, 而对于 USDJPY, GBPJPY 和 AUDJPY　则非常活跃。当然，不一定每天都是这样。所以，针对不同的货币对可能有不同的夜间交易策略。

夜间交易策略

一般来说，所有的外汇交易策略可以被大致分为趋势型和振荡型。前者会搜索市场反转信号，在大部分情况下，它们搜索水平通道的突破或者从“牛市”和“熊市”通道的回撤。后者则专注于在水平通到边界内部的回撤。振荡型和趋势型市场都可能显示出不同的波动，这些波动经常在重要宏观经济新闻发布的时候会增大。在实际情况下，大的波动经常在趋势变化的时候发生，尽管也会有意外。分析趋势和振荡信号可以使用相同的指标，只是它们被不同解读。

让我们以常见的 EURUSD 货币对为例，在亚洲市场，它的动荡性通常会减小而开始转向平盘，在这个阶段的回撤通常比较小而呈现水平方向的变化。

图 2. 在亚洲市场 EURUSD 的平盘变化

图 2 黄色长方形指示了 EURUSD 在亚洲市场 H1 时段上的变化。第一个(从左起) 展示出小范围的通道内振荡。在时段的开始，价格追随了之前创建的趋势，然后发生了一个小的修正(在时段的中间)，最终又转为快速回滚。第二个长方形显示出一个缓慢的上涨，在这种情况下它是重复了这一天结束时的变化。第三个长方形展示了小的改变，和之前的时段不同，最初夜间时段的变化修正了日间的趋势。

在所有描述的例子中，我们可以看到在亚洲市场时段价格只在小范围内变化，看起来市场显示出“不确定性”。这样的变化可以认为是平盘。

我们可以看到在黄色长方形上的上下边界，它们在其中限制了价格波动的通道，很容易在已经形成的图表上画出一个通道，但是在实时中，我们不知道价格将会如何变化，而动荡性还是个问题。所以，我们应当怎样做呢?

我想可以通过使用布林带趋势指标来解决这个问题，因为它在平盘市场上可以显示出好的信号。

图 3. 在 EURUSD M30 上使用布林带

图 3 显示了附加上布林带的 EURUSD М30 图表。选择的周期数是尽可能的低 (10), 其他设置使用的是默认值。在此，我们可以看到价格如何在这个由指标创建的被称为 "动态通道" 的范围内变化的，但是，通道的信号不是足够准确。例如，在第一个长方形中，价格下跌，而通道是跟随它的。同时，价格并没有在通道的底部边界处反弹，尽管一切在亚洲市场结束前都变了，市场开始从通道的限制处反弹。在第二个长方形上，指标的行为只在最后才能看到。第三个长方形显示的情况和第一个类似。

我们可以看到，准确的信号只在这三个时段的最后才生成。因为我们可以看到一些共性，我们就可以用它来构建一个策略。

现在，让我们转向另一个基于较强波动的策略，对于亚洲市场，它们是 JPY 相关的货币对。这个策略在网上广为传播，它的思路是，在可能在任何方向上有大的波动时，在最动荡的时候进入市场。同时在相反方向上使用相同的距离同时设置两个挂单 (高于当前价格 - 买入挂单, 低于它 - 卖出挂单)。挂单通常在亚洲市场的后半段设置 (也可能有例外)。

图四显示的是 USDJPY H1:

图 4. 亚洲市场上的 USDJPY H1

让我们仔细观察亚洲市场部分:

图 5. 亚洲市场部分, USDJPY H1

在图5上, 红色价格标签表示进入市场的机会，它们全都设置在烛形开启的水平。这些就是当描述的策略提出的设置挂单的时刻，

现在，让我们单独分析每个片段。所有这四个片段，开启时间都是 8.00 MSK (5.00 UTC).

1. 在左上方的片段上，烛形的开盘价格是位于 113.521，最低价是 113.341, 而最高价是 113.553。总的说来，从开盘价算起上涨过32个点，而有180个点的下跌。
   
2. 在右上方的片段，烛形开盘于 114.152，最低价是 114.109, 最高价 (在下一个小时) 是 114.308。总的说来，从开盘价算起上涨过156个点，而有43个点的下跌。 
   
3. 左下方的片段开盘于 113.601，最低价是 113.587, 最高价 (在三个小时之后) 是 113.747，总的来说，从开盘价算起上涨过146个点，而有14个点的下跌。
   
4. 最后，右下方的片段: 开盘价是 113.192, 最低价是 112.957 而最高价是 is 113.193，总共: 上涨 - 1 个点, 下跌 - 235 个点.

让我们把它们显示在表格中，这样看得更清楚:

表 1

片段 #	开盘价	最高价	最低价	最大点数	最小点数
1	113.521	113.553	113.341	180	32
2	114.152	114.308	114.109	156	43
3	113.601	113.747	113.587	146	14
4	113.192	113.193	112.957	235	1
总结	---	---	---	最小值 146	最大值 43

就像我们在表1中看到的，在四个时段中，在一个方向上的最大变化有146个点，而最小值中最强的是43个点。让我们把下跌最大值近似到140个点而把上涨最小值近似为对应的45个点。 

在我们所有这四种情况都设置两个相反方向50个点的挂单，把止损设为 100 到 110 个点, 而获利 — 设为 50 到 80 个点。相应的利润为200到320个点。换句话说，在所有四个例子中，获利都被触发了。

这样，我们就有了一个完全可以工作并有效的交易策略。现在，我们只需要把它转换为代码，在历史上加以测试来看它是否能够获利。 

写策略的代码

基于布林带的策略 

首先，包含 CTrade 类，这样可以更方便地管理交易。然后，我们处理输入参数。

• div_work 变量是用于突然价格波动的: 它限制了信号可以产生的范围。
  
• div_signal 变量是用于信号扭转的，指标上下边界的交叉点不当成是信号，而是作为一定程度的反转。换句话说，当价格超过了边界超过了这个变量设置的距离，信号才被触发。这可以排除掉一些假信号。
• work_alt 变量是一个标志，它可以设置在出现一个相反信号时关闭当前的仓位而建立一个新的仓位。

//+------------------------------------------------------------------+
//|                                        BollingerBandsForFlat.mq5 |
//|                                                          Aktiniy |
//|                                                             BBFF |
//+------------------------------------------------------------------+
#property copyright "Aktiniy"
#property link      "BBFF"
#property version   "1.01"
#include<Trade\Trade.mqh>
//--- 输入参数
input char     time_h_start=22;       // 交易开始时间
input char     time_h_stop=3;         // 交易停止时间
input int      bands_period=12;       // 布林带的周期数
input int      bands_shift=0;         // 布林带的平移
input double   bands_diviation=2;     // 布林带的偏移
input double   div_work=3;            // 信号的偏移
input double   div_signal=5;          // 主信号的减弱
input bool     work_alt=true;         // 如果有相反信号对仓位的操作
input int      take_profit=50;        // 获利
input int      stop_loss=100;         // 止损
//---
input bool     mon=true;              // 星期一工作
input bool     tue=false;             // 星期二工作
input bool     wen=true;              // 星期三工作
input bool     thu=true;              // 星期四工作
input bool     fri=true;              // 星期五工作
//---
input long magic_number=65758473787389; // 幻数
input double order_volume=0.01;         // 手数大小
input int order_deviation=100;          // 仓位开启的偏移
//--- 变量
MqlDateTime time_now_str;
datetime time_now_var;
CTrade trade;
int bb_handle;
double bb_base_line[3];
double bb_upper_line[3];
double bb_lower_line[3];
bool work_day=true;

剩余的输入变量在代码中的注释已经足够了，

而对于全局变量，这里有:

• 为了更方便而使用的两个对等的时间变量　(time_now_str, time_now_var),
• 随后是用于操作订单的类对象，
  
• 指标的句柄,
• 三个用于读取在当前时间指标数据的小数组 (bb_base_line[], bb_upper_line[], bb_lower_line[]).
• work_day 变量是用于记录订单的星期几的，

下面，是一小段代码来初始化一些用于类操作的参数的:

//+------------------------------------------------------------------+
//| EA交易初始化函数                                                    |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   trade.SetExpertMagicNumber(magic_number);
   trade.SetDeviationInPoints(order_deviation);
   trade.SetTypeFilling(ORDER_FILLING_FOK);
   trade.SetAsyncMode(false);
//---
   return(INIT_SUCCEEDED);
  }

现在开始探讨交互的主要代码和信号的接收。

首先，我们从服务器取得当前时间，然后使用 switch 操作符来检查今天是否允许建立订单，并且把数据输入给 work_day 变量。

我假定 EA 会在所有的时间都工作　(不仅在亚洲市场)。另外，也有可能终端的时间在不同的服务器上也是不同的，所以，我们需要检查工作时间。这里有两个选项: 或者在某个时间段工作，或者在转换后在整个日期分隔之内工作。这要在 'work' 标志中输入数据。

如果工作时间和选择的日期匹配上了，就把计算所得的句柄和它的数据复制到之前声明的数组中。下面，我们就应该要知道买入和卖出价格，因为它们是用于计算买入和卖出信号的，如果没有开启的仓位，如果有信号出现，就设置相应的订单。

//+------------------------------------------------------------------+
//| EA交易订单分时函数                                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   time_now_var=TimeCurrent(time_now_str);// 当前时间
   bool work=false;
   
      switch(time_now_str.day_of_week)
     {
      case 1: if(mon==false){work_day=false;}
      else {work_day=true;}
      break;
      case 2: if(tue==false){work_day=false;}
      else {work_day=true;}
      break;
      case 3: if(wen==false){work_day=false;}
      else {work_day=true;}
      break;
      case 4: if(thu==false){work_day=false;}
      else {work_day=true;}
      break;
      case 5: if(fri==false){work_day=false;}
      else {work_day=true;}
      break;
     }

//--- 检查工作时间     
   if(time_h_start>time_h_stop)             // 工作直到第二天
     {
      if(time_now_str.hour>=time_h_start || time_now_str.hour<=time_h_stop)
        {
         work=true;
        }                                   // 传入标志以启用工作
     }
   else                                     // 在一天之内工作
     {
      if(time_now_str.hour>=time_h_start && time_now_str.hour<=time_h_stop)
        {
         work=true;
        }
     }                                     // 传入标志以启用工作

   int pos=PositionsTotal();

   if(work==true && work_day==true)        // 工作已启用
     {
      bb_handle=iBands(_Symbol,_Period,bands_period,bands_shift,bands_diviation,PRICE_CLOSE);         // 得到布林带指标句柄
      int i_bl=CopyBuffer(bb_handle,0,0,3,bb_base_line);
      int i_ul=CopyBuffer(bb_handle,1,0,3,bb_upper_line);
      int i_ll=CopyBuffer(bb_handle,2,0,3,bb_lower_line);
      if(i_bl==-1 || i_ul==-1 || i_ll==-1)
        {Alert("从 iBands 复制数据错误: base line=",i_bl,", upper band=",i_ul,", lower band=",i_ll);}   // 检查复制的数据

      double price_ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      double price_bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

      if(pos<1)
        {
         if((price_ask-(div_signal*_Point))>=bb_upper_line[2]-(div_work*_Point) && (price_ask-(div_signal*_Point))<=bb_upper_line[2]+(div_work*_Point))// 卖出信号 
           {
            trade.Sell(order_volume,_Symbol,price_bid,(price_bid+(stop_loss*_Point)),(price_bid-(take_profit*_Point)),"pos<1_sell");
           }
         if((price_bid+(div_signal*_Point))<=bb_lower_line[2]+(div_work*_Point) && (price_bid+(div_signal*_Point))>=bb_lower_line[2]-(div_work*_Point))// 买入信号
           {
            trade.Buy(order_volume,_Symbol,price_ask,(price_ask-(stop_loss*_Point)),(price_ask+(take_profit*_Point)),"pos<1_buy");
           }
        }
      if(pos>0 && work_alt==true)
        {
         if(trade.RequestType()==ORDER_TYPE_BUY)                     // 如果在那之前有买入订单
            if((price_ask-(div_signal*_Point))>=bb_upper_line[2]-(div_work*_Point) && (price_ask-(div_signal*_Point))<=bb_upper_line[2]+(div_work*_Point))// 卖出信号 
              {
               trade.PositionClose(_Symbol,order_deviation);
               trade.Sell(order_volume,_Symbol,price_bid,(price_bid+(stop_loss*_Point)),(price_bid-(take_profit*_Point)),"pos>0_sell");
              }
         if(trade.RequestType()==ORDER_TYPE_SELL)                   // 如果在那之前有卖出订单
            if((price_bid+(div_signal*_Point))<=bb_lower_line[2]+(div_work*_Point) && (price_bid+(div_signal*_Point))>=bb_lower_line[2]-(div_work*_Point))// 买入信号
              {
               trade.PositionClose(_Symbol,order_deviation);
               trade.Buy(order_volume,_Symbol,price_ask,(price_ask-(stop_loss*_Point)),(price_ask+(take_profit*_Point)),"pos>0_buy");
              }
        }
     }
   else
     {
      if(pos>0)
        {
         trade.PositionClose(_Symbol,order_deviation);
        }
     }
  }
//+------------------------------------------------------------------+ 

最后的代码片段: 如果夜间市场时段关闭，关闭所有订单。然后 EA 的代码就结束了。

基于剧烈市场波动策略的变化

这里一切都很简单: 订单只在某个 order_time 时间设置，订单设置的价格距离当前价格为 order_div，并且有对应的止损 (order_sl) 和获利 (order_tp)。如果没有触发任何一个挂单，这就表示是平盘的波动，而订单会根据 time_to_del 过期而被删除 (单位为秒数)。

其他的输入参数和之前的 EA 交易是一样的。

增加的全局变量为:

• work — 启用只设置一次挂单,
  
• work_del — 启用如果订单被触发，就删除反向的订单,
• work_day — 启用只在当前日内工作.
  

另外，还有两个结果结构用于接收数据和删除挂单。

//+------------------------------------------------------------------+
//|                                                TimeBuyOrSell.mq5 |
//|                                                          Aktiniy |
//|                                                             TBOS |
//+------------------------------------------------------------------+
#property copyright "Aktiniy"
#property link      "TBOS"
#property version   "1.01"
#include<Trade\Trade.mqh>
//--- 输入参数
input int      order_time=0;                        // 订单开启时间
input int      order_sl=200;                        // 止损
input int      order_tp=180;                        // 获利
input int      order_div=120;                       // 设置挂单时与当前价格的偏移
input int      time_to_del=10800;                   // 删除挂单的时间
//---
input bool     mon=true;                            // 在星期一工作
input bool     tue=false;                           // 在星期二工作
input bool     wen=true;                            // 在星期三工作
input bool     thu=true;                            // 在星期四工作
input bool     fri=true;                            // 在星期五工作
//---
input long magic_number=65758473787389;             // 幻数
input double order_volume=0.01;                     // 手数大小
input int order_deviation=100;                      // 开启仓位的偏移
//--- 变量
CTrade trade;
MqlDateTime time_now_str;
datetime time_now_var;
bool work=true;
bool work_del=true;
bool work_day=true;
//---
MqlTradeResult result_buy={0};
MqlTradeResult result_sell={0};

随后是一小段代码，用于初始化一些操作类的参数，和之前的一样。

OnTick 函数的开始和之前描述的 EA 类似，在取得了用于当天操作的标志后，再检查当前的小时数是否与它对应，如果都成功了，就计算用于建立订单的参数 (获利，止损，建仓价格以及没有触发而删除订单的时间). 把相应的交易请求发送到服务器，

在设置了挂单之后，EA 会监控它们中的一个被触发后再根据结果结构中的订单号来删除多余的一个。

//+------------------------------------------------------------------+
//| EA交易订单分时函数                                                  |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   time_now_var=TimeCurrent(time_now_str);// 当前时间

   switch(time_now_str.day_of_week)
     {
      case 1: if(mon==false){work_day=false;}
      else {work_day=true;}
      break;
      case 2: if(tue==false){work_day=false;}
      else {work_day=true;}
      break;
      case 3: if(wen==false){work_day=false;}
      else {work_day=true;}
      break;
      case 4: if(thu==false){work_day=false;}
      else {work_day=true;}
      break;
      case 5: if(fri==false){work_day=false;}
      else {work_day=true;}
      break;
     }

   if(time_now_str.hour==order_time && work==true && work_day==true)
     {
      double price_ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      double price_bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

      double div=order_div*_Point;
      double sl=order_sl*_Point;
      double tp=order_tp*_Point;

      double price_buy=price_ask+div;
      double price_sell=price_bid-div;

      double buy_sl=price_buy-sl;
      double buy_tp=price_buy+tp;
      double sell_sl=price_sell+sl;
      double sell_tp=price_sell-tp;

      datetime time_end=time_now_var+time_to_del;     //3600 秒, 一个小时

      trade.BuyStop(order_volume,price_buy,_Symbol,buy_sl,buy_tp,ORDER_TIME_SPECIFIED,time_end,"BuyLimit");
      trade.Result(result_buy);

      trade.SellStop(order_volume,price_sell,_Symbol,sell_sl,sell_tp,ORDER_TIME_SPECIFIED,time_end,"SellLimit");
      trade.Result(result_sell);

      work=false;
     }

   if(PositionsTotal()>0 && work_del==true)
     {
      PositionSelect(_Symbol);
      long position_type=PositionGetInteger(POSITION_TYPE);
      if(position_type==POSITION_TYPE_SELL)
         trade.OrderDelete(result_buy.order);
      if(position_type==POSITION_TYPE_BUY)
         trade.OrderDelete(result_sell.order);

      work_del=false;
     }
   if(PositionsTotal()==0)
      work_del=true;

   if(time_now_str.hour!=order_time)
     {
      work=true;
     }

  }
//+------------------------------------------------------------------+

代码的最后是启用了挂单标志，因为超过了开启订单的时间。

测试和获利

基于布林带的策略 

• 交易品种: EURUSD
• 时间段: М30 (2017.01.01 - 2017.11.03)
• 经纪商: Halifax Investment Services Pty Ltd
• 币别: AUD
• 初始存款: 100.00
• 杠杆: 1:100

在优化中发现了下面的参数:

让我们简要描述一下它们: 工作是在夜间进行的，从 1:00 直到 11:00 (MSK), 指标周期数是 11, 从信号的偏移是 12, 主信号的预留空间是 13, 止损=140 而 获利=120, 一周中每天都工作，星期二除外。

首先，让我们看一下在 "M1 上的 OHLC" 上的测试结果, Fig. 6 and 7:

图 6. 基于布林带的策略以 M1 上的 OHLC 模式的测试结果

图 7. 图表上的测试结果 (布林带根据 M1 上的 OHLC)

相同参数使用 "基于真实分时的每一分时" 模式的测试结果, 图 8 和 9:

图 8. 以“基于真实分时的每一分时”模式进行的基于布林带策略的测试结果

图 9. 图表上的测试结果 (布林带以"基于真实分时的每一分时"模式)

我们可以看到，在两种情况下都取得了利润: 第一种情况, 获利达到了 152%, 而第二种 — 48%, (有历史质量的原因)。在两个测试中，回撤都小于 25%。我相信，这是非常有趣和值得关注的结果。

之前，我们已经检验了三个交易时间段 (图 3) 并且描述了策略，现在，让我们看一下 EA 交易在前面两个时段段上的效果 (图 10 和 11):

图 10. 在之前讨论的第一个时间段上 EA 的结果

图 10 (从图 3上看到的第一个时间段) 显示了 EA 交易有三次入场，第一个没有成功而最终止损，但是后面两个 (在亚洲市场结束和欧洲市场开始的两个)达到获利而关闭了。

图 11. 在之前讨论的第二个时间段上EA的运行结果

图 11 (图3种的第二个时间段) 显示了EA进行了两次入场 — 在亚洲市场的结束和欧洲市场的开始，它们中的一个获利了，而第二个则造成了亏损。在图3中的第三个时间段，EA交易没有进入市场，它是在星期二，而根据设置，EA不在这一天进行交易。

现在，让我们看一下这个策略在其他主要货币对上的测试结果:

交易品种: AUDUSD

时间段: M30 (2017.01.01 - 2017.11.07)

输入参数:

图 13. AUDUSD M30 (布林带) 的测试结果

交易品种: GBPUSD

时间段: M30 (2017.01.01 - 2017.11.06)

输入参数:

图 14. GBPUSD M30 (布林带) 测试结果

交易品种: NZDUSD

时间段: M30 (2017.01.01 - 2017.11.07)

输入参数:

图 15. NZDUSD M30 (布林带) 测试结果

Symbol: USDCAD

时间段: M30 (2017.01.01 - 2017.11.07)

输入参数:

图 16. USDCAD M30 (布林带) 测试结果

交易品种: USDCHF

时间段: M30 (2017.01.01 - 2017.11.07)

输入参数:

图 17. USDCHF M30 (布林带) 测试结果

综合所有的测试数据，我们可以得到下面的结论，

• 最适合这个EA工作的货币对是 EURUSD, NZDUSD 和 AUDUSD，根据参数，信号在这几个货币对上，获利和止损相差不超过三倍的时候是最有用的。当然，这里的利润也更加丰厚。
• 一个星期中的某一天会影响利润，不同货币对在这一天上的行为是不同的，尽管没有找到稳定的模式: 一切都依赖于选择的货币对和使用的设置。

基于剧烈市场波动策略的变化

测试参数也有所变化:

• 交易品种: USDJPY
• 时间段: H1 (2017.01.01 - 2017.11.03)

首先，让我们检查上面提到的策略，这里是它的参数: 

• order_time=8;
  
• order_sl=140;
•  order_tp=70;
  
• order_div=50;
  
• time_to_del=18000.
  

在此我们把止损从110提高到140， 会增加策略的获利能力，测试结果对应显示在图18和19中:

图18. 基于剧烈市场波动的策略的测试结果, USDJPY H1

图 19. 在 USDJPY H1 图表上的测试结果

图表显示，策略差不多从测试的中间部分开始有效，但是，在更长的测试时间段上(大约从 2015 年开始), 这个策略基本没有利润。另外，根据这些参数，入场是在 8:00 MSK 进行的, 也就是说它也被欧洲市场影响到，这可以看作是一种晨间交易，

这样的话，结果是负面的。让我们在更长的时间内，并且只在"夜间时间"中进行优化，

测试参数也有所变化:

• 交易品种: USDJPY
• 时间段: H1 (2015.01.01 - 2017.11.03)

测试结果:

这样的话，EA只在星期二 4:00 MSK (亚洲市场) 设置仓位的时候才有效, 止损和获利基本相等，分别为270和220个点，订单设置的距离距离入场价格是130个点。测试结果显示在图20和21中:

图 20. 基于剧烈市场动荡的策略的测试结果, USDJPY H1 (2015-2017)

图 21. 在 USDJPY H1 (2015-2017) 图表上的测试结果

最后的测试是在 "基于真实分时的每一分时" 或者 "M1 上的 OHLC" 模式，在结果中不会有很大差别，所以，就只展示了第一种结果 (图 20 和 21)。

结论

我们可以下结论，非常可能“在夜晚”（亚洲市场）以较小的回撤来取得利润，基于布林带的策略在测试中看起来非常有效，在夜间和整天都是如此 (这篇文章只是展示了亚洲市场和欧洲市场最开始的结果)。我将会继续提高这个策略，因为我发现它很简单也很有效。

对于基于波动性改变的策略，它看起来非常简单，但是效果差了很多。尽管，它可以用作第一个的补充。我们也在白天(包括欧洲市场)进行了测试，显示出中等程度的优秀表现。它非常依赖于星期几而不是基于布林带，。在很长的时间段进行测试后发现了这一点。EA交易已经变得有些冗余，不大可能对它再做修改。

文件:

#	名称	类型	描述
1	BollingerBandsForFlat_v1.01.mq5	EA 交易	本 EA 交易致力于在亚洲市场平缓振荡的时候进行交易，它基于布林带的信号。
2	TimeBuyOrSell_v1.01.mq5	EA 交易	本 EA 交易致力于在市场动荡最剧烈的时候进行交易。