学习如何基于斐波那契（Fibonacci）设计交易系统

MetaTrader 5 — 交易 | 17 八月 2023, 13:25

3 453

Mohamed Abdelmaaboud

概述

在我们关于学习如何设计基于最流行的技术分析工具和指标创建交易系统的系列新文章中，我们将学习如何创建基于斐波那契回撤技术工具的交易系统，这是交易中最流行和广泛使用的工具之一。之后，我们就能够在我们的 MetaTrader 5 交易终端上使用此交易系统。我们将使用 MQL5（MetaQuotes 语言 5），它是 MetaTrader 5 的内置 IDE，如果您想学习如何下载和使用 MetaTrader 5 和 MQL5 IDE，您可以阅读上一篇文章中的主题在 MetaEditor 中编写 MQL5 代码。

为了涵盖这一些，主题内容编排如下相同：

值得一提的是，使用斐波那契时最好配合其它技术工具，如趋势分析、支撑、阻力,..等等，因为这将提供更好的见解和结果。在现实世界中使用之前，您还必须测试本文或任何地方学到的任何策略或工具，并确保它对您的交易有用，且有利可图。作为编程技能开发人员，最好应用并尝试自己编写代码，因为此步骤对您非常有益。

免责声明：所有信息“按原样”提供仅用于教学目的，并非出于交易目的或建议。这些信息不能保证任何结果。如果您选择在您的任何交易账户上使用这些材料，您将自行承担风险，您是唯一的责任人。

斐波那契（Fibonacci）定义

在本节中，我们将确定斐波那契回撤工具，并将学习如何在图表上使用它。斐波那契是一种技术工具，可用于在图表上找到支撑或阻力区域，我们预计价格达到这些区域会反弹。它基于斐波那契级数，斐波那契级数是一串符合数学规律的数字序列。该系列的每个数字都是前两个数字的合计。我们可以在图表上找到它，在特定水平（如 23.6%、38.2%、50% 和 61.8%）绘制为水平线，这些水平线是最受欢迎的。

如果您问自己如何在图表上找到它，答案是您需要做的就是从 MetaTrader 5 中的可用技术工具中插入它，以下是其中的步骤：

打开 MetaTrader 5 时，导航“插入”选项卡 --> 对象 --> 斐波那契回撤

Fibo 插入

之后，如果我们在上升趋势之后有回撤，我们将其从低点绘制到高点，反之亦然；如果我们在下降趋势之后有回撤，我们将它从高点绘制到低点，与以下示例相同。

上行趋势之后的斐波那契:

Fibo 插入牛势

下行趋势之后的斐波那契:

Fibo 插入熊势

正如我们在前面的例子中所见，我们在两点之间绘制了一条趋势线，除了具有特定水平 23.6、38.2、50 和 61.8 的水平线之外，还有最高值和最低值，这些水平是最受欢迎的水平。在这些水平附近以及上升趋势或下降趋势之后，我们经历了调整或回撤，我们可能会预期在调整后从这些水平反弹。因此，斐波那契水平可以作为支撑位或阻力位。

我们还可以通过此工具的窗口控制这些级别，方法是右键单击绘图工具或右键单击图表，然后从菜单中选择对象列表，然后选择 Fibo 对象，窗口将打开，如下所示：

Fibo1

我们可以从前面的通用选项卡中控制对象的名称和样式，例如颜色、线条类型和粗细。

Fibo 2

正如我们在上图中所见，我们可以控制和确定所需的级别设置，也可以设置样式。

Fibo 3

正如我们在参数选项卡中所见，除了斐波那契对象的日期、时间和数值之外，我们还可以确定从开始到结束的日期、时间和数值。

斐波那契策略

在这一部分中，我们将学习如何基于两种不同方式的简单策略运用斐波那契回撤。其中之一是根据每日最后一根蜡烛确定 FIBO 水平，第二种是确定任何时间帧内的蜡烛数量，并基于它们确定 FIBO 水平。然后，我们将使用另一种策略，基于每种方法的特定预定 FIBO 水平得到特定的买入或卖出信号，以下是有关这些策略的更多详细信息。

第一种方式：使用日线数据：

简单斐波那契系统：

基于该策略，我们需要根据日线蜡烛数据和状态得到 FIBO 回撤的价格水平。如果最后的日线蜡烛看涨，我们需要依据蜡烛的低点到高点，以及每个水平的价格值得到看涨 FIBO。如果最后的日线蜡烛看跌，我们需要依据蜡烛的高点到低点，以及每个水平的价格值得到看跌 FIBO。

简而言之，

最后一根日线收盘价 > 开盘价 ==> 看涨蜡烛

得到绿色斐波那契水平和这些水平的价格。

最后一根日线收盘价 < 开盘价 ==> 看跌蜡烛

得到红色斐波那契水平和这些水平的价格。

FIBO 信号:

基于该策略，我们需要根据我们判定的看涨或看跌斐波那契水平得到买入和卖出入场信号。如果我们判定看涨 FIBO 的 38.2 水平，我们需要得到该水平的价位作为买入入场信号，如果我们判定看跌 FIBO 的相同水平，我们需要得到该水平的价位作为卖出入场信号。

第二种方式：使用特定蜡烛数组：

简单斐波那契系统 2：

基于该策略，我们需要依据蜡烛数组得到 FIBO 价格水平，如果我们依据数组的方向得到看涨斐波那契，我们需要得到斐波那契水平的价位，如果我们基于数组方向得到看跌斐波那契，我们需要得到斐波那契水平的价位。

简而言之，

如果数组中第一根蜡烛的开盘价 < 同一数组的最后一根蜡烛的收盘价 ==> 看涨斐波那契，我们需要得到这个看涨斐波那契的价格水平。

如果数组中第一根蜡烛开盘价 > 同一数组的最后一根蜡烛收盘价 ==> 看跌斐波那契，我们需要获得这个看跌斐波那契的价格水平。

FIBO 信号 2:

基于该策略，我们需要根据用户输入的所需 FIBO 水平作为入场级别，获取买入或卖出的入场信号。如果根据我们之前讲述的基于该方式的看涨斐波那契，我们需要获取特定斐波那契水平的买入入场水平。如果我们有一个看跌斐波那契，我们需要获取特定斐波那契水平的卖出入场水平。

斐波那契策略蓝图

在这一部分中，我们将看到上述两种方式中所提每个策略的蓝图，从而了解我们需要在可视化方法中做什么。

第一种方式：使用日线数据：

正如我们在这里提到的，我们将取用日线最后一根蜡烛，并确定其开盘价、收盘价、最高价和最低价。通过比较开盘价和收盘价，我们可以检测得到的是看涨亦或看跌蜡烛。根据最后一根日线蜡烛的走势类型，我们将绘制斐波那契对象，并获得所需的信号。

简单斐波那契系统：

简单 Fibo 系统蓝图

FIBO 信号:

Fibo 信号蓝图

第二种方式：使用特定蜡烛数组：

正如我们在这里提到的，我们将在数组中使用特定数量的蜡烛，并确定第一根蜡烛的开盘价、最后一根蜡烛的收盘价、最高值和最低值。通过比较开盘价和收盘价，我们可以检测得到的是看涨亦或看跌蜡烛。根据该数组的走势类型，我们将绘制斐波那契对象，并获得所需的信号。

简单斐波那契系统 2：

简单 Fibo 系统 2

FIBO 信号 2:

Fibo 信号 2 蓝图

斐波那契交易系统

在这一部分中，我们将学习如何基于前面提到的内容创建交易系统。我们将创建一个程序，该程序可以在图表上返回斐波那契水平作为注释。我们将采用两种方法，第一种是取最后的日线数据来绘制我们的斐波那契水平，另一种是取预定数量的蜡烛作为数组以备它用。我们还将学习如何依据这两种方式返回基于斐波那契的买入和卖出信号，我们来详细查看。

第一种方式：使用日线数据：

简单斐波那契系统：

根据此策略，我们将取日线数据用于斐波那契系统，以下是执行此操作的步骤：

在编译之前，在源代码使用宏替换（#define）预处理语句来定义所需的对象名称。

#define FIB_OBJ "Fibonacci Retracement"

为 barsTotal 创建一个整数型变量。

int barsTotal;

之后在 onTick 中，我们将创建一个整数型变量，保存 iBar 函数返回的交易品种的可用历史柱线数量。其参数为:

symbol: 为了确定所需的交易品种，我们将采用当前交易品种 _Symbol。
timeframe: 为了确定周期，我们将采用 D1 日线图。

int bars = iBars(_Symbol, PERIOD_D1);

释放一个条件来检测我们需要将其用于斐波那契的日线蜡烛，因为我们需要通过 (!=) 运算符来检查 barsTotal 不等于已处理柱线数量，同时我们需要当前时间将大于此根日线蜡烛的结束时间。如此，我们将使用 TimeCurrent 函数和 StringToTime 函数将包含时间的字符串转换为日期时间类型的数字。

if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))

一旦满足此条件，我们需要程序执行以下操作：

将 bars 赋值给 barsTotal。

barsTotal=bars;

调用 ObjectDelete 函数删除图表上的任何 FIB_OBJ，其参数为：

chart_id: 为了确定图表标识符，我们将使用（0）表示当前图表。
name: 确定对象类型名称为（FIB_OBJ）。

ObjectDelete(0,FIB_OBJ);

通过调用 iOpen、iClose、iHigh 和 iLow 函数创建四个价格变量（开盘价、收盘价、最高价和最低价），以便返回日线柱线的价格。它们的参数为:

symbol: 为了确定所需的交易品种，我们将采用 _Symbol 对应当前交易品种。
timeframe: 为了确定所需的时间帧，我们将擦用（PERIOD_D1）对应日线时间帧。
shift: 为了确定从时间序列中接收到的数值索引，我们在这里不会用到它。

      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);

确定开始时间和结束时间，以便稍后绘制斐波那契对象。我们将调用 iTime 函数返回柱线的开立时间。其参数为:

symbol: 为了确定所需的交易品种，我们将采用 _Symbol 对应当前交易品种。
timeframe: 为了确定所需的时间帧，我们将擦用（PERIOD_D1）对应日线时间帧。
shift: 为了确定从时间序列接收的数值索引，我们将采用 1 作为开始时间，并采用 0 作为结束时间。

对于结束时间，我们将从返回值中减去 1，因为最后一个时间单位是计算该日线的时间，它实际上是新的一根日线的开始，故此，我们这样做是意味着检测之前的柱线。

      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;

之后，我们将设置两个条件，并通过 if-else 条件运算符绘制斐波那契对象：

如果收盘价大于开盘价，因此，它是看涨蜡烛，将发生以下情况。

通过调用 ObjectCreate 函数创建对象，并遵照指定特征来绘制对象。其参数为:

chart_id: 为了确定图表，我们将采用 0 对应当前图表。
name: 为了确定所需对象的名称，我们将采用 FIB_OBJ。
type: 为了确定对象类型，我们将采用 OBJ_FIBO 对应斐波那契回撤。
nwin: 为了确定窗口索引，我们将采用 0 对应主窗口
time1: 为了确定第一个锚点的时间，我们将采用开始时间。
price1: 为了确定第一个锚点的价格，我们将采用低点价格。
timeN=0: 为了确定最后一个锚点的时间，我们将采用结束时间。
priceN=0: 为了确定最后一个锚点的价格，我们将采用高点价格。

调用 ObjectSetInteger，并在 for 循环里更新对象的颜色，令其与柱线的方向相符。 ObjectSetInteger 的参数为：

chart_id: 为了确定图表，我们将采用 0 对应当前图表。
name: 为了确定对象的名称，我们将采用 FIB_OBJ。
prop_id: 为了确定属性 ID（颜色），我们将采用 OBJPROP_COLOR。
prop_value: 为了确定属性值，我们将采用 clrGreen。
通过 for 循环不断更新对象颜色。

定义斐波那契水平，23.6、38.2、50、61.8、100。在图表上的注释里是最后一天，开盘价和收盘价。

      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",high,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }

在看跌日的情况下，同样会发生，但不同之处将如下所示：

创建对象并且起点从最高价到最低价。
对象的颜色将为红色。

      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",low,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }

以下是该策略的完整代码：

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {

   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double closeCandle = iClose(_Symbol,_Period,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
           {
            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);
           }
        }
     }
  }
//+------------------------------------------------------------------+

以下是该交易系统的完整代码：

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#1.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {
   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",high,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",low,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }
     }
  }
//+------------------------------------------------------------------+

在编译此段代码，且没有错误，并执行它之后，我们可以从看涨和看跌测试中找到与以下示例相同的信号。

日线蜡烛看涨：

简单 Fibo 系统 - 看涨 - 日线

故此，我们应该发现 FIBO 是从最低价到最高价绘制的，它的颜色是绿色的，FIBO 水平和日线开盘价和收盘价与我们在日线上发现的相同。下图就是其示意。

简单 Fibo 系统 - 看涨

正如我们在上一张图片中所见，根据日线看涨柱线，FIBO 从最低价到最高价绘制，其颜色为绿色，此外，我们还需要在图表上取以下数值作为注释：

最后一天的开盘价 ==> 与日线图数据窗口中相同。
最后一天的收盘价 ==> 与日线图相同。
五个斐波那契回撤价位。

日线蜡烛看跌：

简单 Fibo 系统 - 看跌 - 日线

故此，我们应该发现 FIBO 是从最低价到最高价绘制的，它的颜色是红色的，FIBO 水平和日线开盘价和收盘价与我们在日线上发现的相同。下图就是其示意。

简单 Fibo 系统 - 看跌

正如我们在上一张图片中所见，根据日线看跌柱线，FIBO 从最低价到最高价绘制，其颜色为红色，此外，我们还需要在图表上取以下数值作为注释：

最后一天的开盘价 ==> 与日线图数据窗口中相同。
最后一天的收盘价 ==> 与日线图相同。
五个斐波那契回撤价位。

FIBO 信号:

根据这种方式，我们需要创建一个交易系统，该系统可以根据用户输入的入场水平基于 FIBO 水平返回买入和卖出信号。以下是执行此操作的完整代码：

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {

   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double closeCandle = iClose(_Symbol,_Period,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl);
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
           {
            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl);
           }
        }
     }
  }
//+------------------------------------------------------------------+

此代码中的区别：

添加 #property script_show_inputs 预编译指令，显示用户属性输入窗口。

#property script_show_inputs

输入变量 fibRetracLvl 为双精度数据类型，创建时默认值为 38.2。

input double fibRetracLvl = 38.2;

基于用户输入定义看涨情况下的入场水平。

double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);

基于用户输入定义看跌情况下的入场水平。

double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);

在看涨的情况下图表上的注释。

         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");

在看跌的情况下图表上的注释。

            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);

编译并执行此段代码后，我们就准备好接收信号，我们将看到看涨和看跌测试情况的示例。

日线蜡烛看涨：

Fibo 信号 - 看涨 - 日线

故此，我们料定会看到在 15 分钟起点从最低价到最高价以绿色绘制的 FIBO，最后一天开盘价和收盘价与日线图相同，入场价位与 38.2 旁边的价格水平相同。以下是 15 分钟图表：

Fibo 信号 - 看涨

正如我们在之前的 15 分钟图表中所见，我们得到以下与我们所确定数值相同的值：

最后一天的收盘价 ==> 与日线图相同。
最后一天的收盘价 ==> 也相同。
买入入场价 ==> 是 38.2 FIBO 水平旁边的相同价位。

日线蜡烛看跌：

Fibo 信号 - 看跌 - 日线

因此，现在我们将查看 15 分钟图表，以便获取基于交易策略的信号，它料定显示基于 FIBO 水平 38.2 的卖出入场水平。我们通过下图来验证一下：

Fibo 信号 - 看跌

如我们所见，我们在 15 分钟图表上得到以下数值作为信号：

最后一天的收盘价 ==> 与日线图相同。
最后一天的收盘价 ==> 也相同。
卖出入场价 ==> 与 38.2 临近的 FIBO 水平相同。

第二种方式：使用特定蜡烛数组：

简单斐波那契系统 2：

根据这种方式，我们将采用预定数量的蜡烛创建斐波那契，以下是以不同方式执行此操作的步骤：

使用 #define 定义 FIB_OBJ。

#define FIB_OBJ "Fibonacci Retracement"

创建两个整数型变量保存最高蜡烛和最低蜡烛。

int highestCandle, lowestCandle;

创建两个数组保存最高价和最低价。

double high[],low[];

调用 “ArraySetAsSeries” 函数设置最高价和最低价数组中的数据排序方向。其参数:

array[]: 确定创建的最高价和最低价数组。
flag: 数组索引方向，其为 true。

ArraySetAsSeries(high,true);
ArraySetAsSeries(low,true);

调用 CopyHigh 和 CopyLow 获取最高价和最低价的历史数据。 CopyHigh 参数是:

symbol_name: 我们将采用（_Symbol）对应当前交易品种。
timeframe: 我们将采用（_Period）对应当前时间帧。
start_pos: 确定起始位置，我们将采用 0 对应当前蜡烛。
count: 确定要复制的数据计数，我们将采用 100。
high_array[]: 确定目标数组，我们将采用创建的最高价数组。

对于 CopyLow 参数是相同的，但目标数组将被创建为最低价数组。

CopyHigh(_Symbol,_Period,0,100,high);
CopyLow(_Symbol,_Period,0,100,low);

调用 iOpen 和 iClose 函数定义数组中第一根蜡烛的开盘价，以及数组中最后一根蜡烛的收盘价。

double openCandle = iOpen(_Symbol,_Period,100);
double closeCandle = iClose(_Symbol,_Period,1);

调用 ArrayMaximum 和 ArrayMinimum 定义所创建最高价和最低价数组里最大值和最小值蜡烛。

array[]: 我们将采用最高价作为最大值，以及最低价作为最小值。
start=0: 确定要开始检查的索引，我们将采用 0。
count: 确定要检查的元素数量，我们将采用 100，或者我们也可以采用 WHOLE_ARRAY。

highestCandle=ArrayMaximum(high,0,100);
lowestCandle=ArrayMinimum(low,0,100);

创建一个数组保存价格，调用 MqlRates 函数，以便存储有关价格的信息，并调用 ArraySetAsSeries 函数设置此数组中的数据排序方向。

MqlRates pArray[];
ArraySetAsSeries(pArray,true);

调用 CopyRates 函数获取 MqlRates 结构的历史数据，其参数为：

symbol_name: 确定交易品种名称，我们采用（_Symbol）应用当前品种。
timeframe: 确定时间帧，我们采用（_Period）应用当前时间帧。
start_pos: 确定起点位置，我们取（0）从当前位置开始。
count: 确定要复制的计数，我们将采用（Bars）。
rates_array[]: 确定要复制的目标数组，我们采用（pArray）。

int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);

调用 ObjectGetInteger 和 ObjectGetDouble 定义 0 和 100 级别的 dateTime 以及价格。

datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);

遵循 if-else 运算符设置看涨和看跌情况的条件。

在看涨的情况下（CloseCandle 大于 openCandle），我们需要执行以下步骤：

调用 ObjectDelete 删除先前绘制的 FIBO 对象。
调用 ObjectCreate 创建一个新的 FIBO 对象，起点从数组的低点到高点。
调用 ObjectSetInteger 将 FIBO 对象的颜色更新为绿色，并在 for 循环里根据情况继续更新。
通过获取最高价和最低价之间的差值来定义价格范围。
定义 FIBO 水平，23.6、38.2、50、61.8。
在图表上的注释里显示数组的开盘价、收盘价、和斐波那契水平。

   if(closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }

在看跌的情况下（蜡烛收盘价低于开盘价），我们需要执行以下步骤：

调用 ObjectDelete 删除先前绘制的 FIBO 对象。
调用 ObjectCreate 创建一个新 FIBO 对象，起点从数组的高点到低点。
调用 ObjectSetInteger 将 FIBO 对象的颜色更新为红色，并在 for 循环里根据情况继续更新。
通过获取最低价和最高价之间的差值来定义价格范围。
定义 FIBO 水平，23.6、38.2、50、61.8。
在图表上的注释里显示数组的开盘价、收盘价、和斐波那契水平。

   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }

以下是完整代码：

//+------------------------------------------------------------------+
//|                                         Simple Fibo System 2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
//+------------------------------------------------------------------+
void OnTick()
  {
   int highestCandle, lowestCandle;
   double high[],low[];
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   CopyHigh(_Symbol,_Period,0,100,high);
   CopyLow(_Symbol,_Period,0,100,low);
   double openCandle = iOpen(_Symbol,_Period,100);
   double closeCandle = iClose(_Symbol,_Period,1);
   highestCandle=ArrayMaximum(high,0,100);
   lowestCandle=ArrayMinimum(low,0,100);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
   datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
   double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
   datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
   double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
   if(closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }
  }
//+------------------------------------------------------------------+

编译并执行此段代码后，我们可以根据 EA 找到以下信号。以下是来自测试的信号示例。

如果数组看涨：

简单 Fibo 系统 2 - 看涨

正如我们所见，我们在图表上有一个绿色的 FIBO 对象，并在图表左上角的注释里，根据此 EA 填充以下数值：

数组开盘价 ==> 为数组第一根蜡烛的开盘价。
数组收盘价 ==> 为数组最后一根蜡烛的收盘价。
FIBO 水平 0, 23.6, 38.2, 50, 61.8, 100。

如果数组看跌：

简单 Fibo 系统 2 - 看跌

正如我们所见，我们在图表上有一个红色的 FIBO 对象，并在图表左上角的注释里，根据此 EA 填充以下数值：

数组开盘价 ==> 为数组第一根蜡烛的开盘价。
数组收盘价 ==> 为数组最后一根蜡烛的收盘价。
FIBO 水平 0, 23.6, 38.2, 50, 61.8, 100。

FIBO 信号 2:

现在，我们将基于第二种方式创建一款交易系统，从而根据用户输入的 FIBO 水平返回买入和卖出信号。以下是创建该交易系统的完整代码：

//+------------------------------------------------------------------+
//|                                               Fibo Signals 2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
//+------------------------------------------------------------------+
void OnTick()
  {
   int highestCandle, lowestCandle;
   double high[],low[];
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   CopyHigh(_Symbol,_Period,0,100,high);
   CopyLow(_Symbol,_Period,0,100,low);
   double openCandle = iOpen(_Symbol,_Period,100);
   double closeCandle = iClose(_Symbol,_Period,1);
   highestCandle=ArrayMaximum(high,0,100);
   lowestCandle=ArrayMinimum(low,0,100);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
   datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
   double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
   datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
   double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
   if
   (closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);
     }
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 + pRange * 61.8/100,_Digits);
      double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);
     }
  }
//+------------------------------------------------------------------+

此代码中的区别：

添加一个属性时，使用 #property script_show_inputs 预编译指令显示包含属性的窗口，并创建一个双精度数据类型的输入变量 fibRetracLvl，默认值为 38.2。

#property script_show_inputs
input double fibRetracLvl = 38.2;

基于用户输入定义看涨情况下的入场水平。

double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);

基于用户输入定义看跌情况下的入场水平。

double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);

基于看涨情况的注释。

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);

基于看跌情况的注释。

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);

编译并执行此段代码后，我们可以得到与以下看涨和看跌数组测试示例中相同的信号。

数组为看涨：

Fibo 信号 2 - 看涨

如我们所见，我们得到一个绿色的 FIBO 对象，从数组的最低值到最高值，并将以下值作为图表上的注释：

数组开盘价 ==> 与数组第一根蜡烛的开盘价数值相当。
数组收盘价 ==> 与数组最后一根蜡烛的收盘价数值相当。
买入入场价 ==> 是 61.8 FIBO 水平的相同价位。

数组为看跌：

Fibo 信号 2 - 看跌

如我们所见，我们得到一个红色的 FIBO 对象，从数组的最低值到最高值，并将以下值作为图表上的注释：

数组开盘价 ==> 与数组第一根蜡烛的开盘价数值相当。
数组收盘价 ==> 与数组最后一根蜡烛的收盘价数值相当。
卖出入场价 ==> 是 61.8 FIBO 水平的相同价位。

结束语

现在，假设您通过斐波那契定义主题详细学习了斐波那契技术工具，并且您已明白了在将斐波那契插入 MetaTrader 5 后如何使用它，您还学会了如何通过 MQL5 创建一个简单的斐波那契交易系统，能用于 MetaTrader 5 交易终端。

此外，我们在这里分享了两种创建斐波那契的方式，一种是利用日线数据，另一种是在任何时间帧内利用一组特定的蜡烛来返回斐波那契水平，并根据这些水平获得买入或卖出的入场水平。我再次确认将此工具与其它技术工具结合使用，以便获得更好的结果，您必须在实盘账户上使用它们之前测试提及的策略或概念，并确保它们对您的交易有利可图，没有任何事物可以适合所有人，且这里的主要意图只是教学，您可以找到上述策略的一些改进或优化。

我希望您通过学习新东西，或开阔眼界去了解可以改善您的交易结果的新思路，从中发现这篇文章颇有见地，并对您有用。如果您需要阅读更多有关基于最流行的技术指标和工具设计交易系统的类似文章，您可以阅读我在本系列中的其它文章，因为我们已分享了大多数流行技术的文章，如移动平均线、MACD、布林带、随机振荡器......等等，我希望您发现它们也很有用。

本文由MetaQuotes Ltd译自英文
原文地址： https://www.mql5.com/en/articles/12301

附加的文件 |

下载ZIP

Simple_Fibo_System.mq5 (3.56 KB)

Fibo_Signals.mq5 (3.37 KB)

Simple_Fibo_System_2.mq5 (4.06 KB)

Fibo_Signals_2.mq5 (3.79 KB)

注意: MetaQuotes Ltd.将保留所有关于这些材料的权利。全部或部分复制或者转载这些材料将被禁止。

This article was written by a user of the site and reflects their personal views. MetaQuotes Ltd is not responsible for the accuracy of the information presented, nor for any consequences resulting from the use of the solutions, strategies or recommendations described.

该作者的其他文章

最近评论 | 前往讨论 (4)

olaniyitaiye | 14 4月 2023 在 08:57

你是最棒的，谢谢你的分享🙏🙏。

Mohamed Abdelmaaboud | 14 4月 2023 在 14:12

olaniyitaiye #:
你是最棒的，谢谢你的分享🙏🙏。

谢谢您的评论。

BriarK | 13 9月 2023 在 13:02

这太棒了，非常感谢

Cuneyt Ates | 17 9月 2023 在 22:40

Rene Balke 在本帖发布前一个月制作了纤维 ea 视频。

您可以在以下网址观看：https://youtu.be/QmxlptpUdNE?si=bWiOXuJQjcUFr5QT

开发回放系统 — 市场模拟（第 03 部分）：调整设置（I）

我们从梳理当前状况开始，因为我们尚未以最好的方式开始。如果我们现在不这样做，我们很快就会遇到麻烦。

种群优化算法：树苗播种和成长（SSG）算法

树苗播种和成长（SSG）算法的灵感来自星球上最具韧性的生物之一，在各种条件下都表现出杰出的生存能力。

基于画布的指标：为通道填充透明度

在本文中，我将介绍一种创建自定义指标的方法，该方法利用标准库中的类 CCanvas 来完成绘图，并可查看图表属性以便坐标转换。我将着手处理特殊的指标，其需要用透明度填充两条线之间的区域。

数据科学和机器学习（第 13 部分）：配合主成分分析（PCA）改善您的金融市场分析

运用主成分分析（PCA）彻底革新您的金融市场分析！发现这种强大的技术如何解锁数据中隐藏的形态，揭示潜在的市场趋势，并优化您的投资策略。在本文中，我们将探讨 PCA 如何为分析复杂的金融数据提供新的视角，揭示传统方法会错过的见解。发掘 PCA 应用于金融市场数据如何为您带来竞争优势，并帮助您保持领先地位。