MQL5 简介（第 5 部分）：MQL5 数组函数入门指南

概述

我们系列的第 5 部分将向您介绍 MQL5 的迷人世界，该部分专为希望了解复杂数组函数的完全新手而设计。本节旨在消除经常与数组函数相关的误解，确保每一行代码不仅能被看懂，而且能被透彻地理解。无论之前编码经验如何，我都真诚地相信，每个人都应该有机会学习 MQL5 语言，这就是为什么我将始终致力于创造一个包容的环境。

在这篇文章中，简单明了是首要目标。我想为那些对编码和未知领域充满好奇的人提供一个渠道。虽然它们一开始可能会让人感到困惑，但我还是打算一行一行地教你学习每个数组函数，让你有一个寓教于乐的学习体验。我们将一起解决围绕数组函数的难题，让您掌握必要的知识，成功应对复杂的算法交易世界。这不仅仅是一篇文章，而是一份请您踏上编码转型的奇妙之旅的邀请。 

但事情并没有到此为止。除了代码之外，我们还希望创建一个社区，让新手和经验丰富的程序员都能聚集在一起，交流想法、提出问题并促进团队合作。这是一次改变人生的编码探险邀请，而不仅仅是一篇文章。来自第 5 部分的问候，在这里，知识和可访问性碰撞在一起，每个编码的人都应会得到赞赏。享受编码的乐趣吧！

本文将介绍以下数组函数：

• ArrayBsearch
  
• ArrayResize
  
• ArrayCopy
  
• ArrayCompare
  
• ArrayFree
• ArraySetAsSeries
• ArrayGetAsSeries
  
• ArrayIsSeries
  
• ArrayInitialize
  
• ArrayFill
  
• ArrayIsDynamic
  
• ArrayMaximum
  
• ArrayMinimum

在进入第五部分之前，我想与大家分享一段视频，这段视频总结了我们在第四部分学到的经验教训。这是一份摘要，以确保每个人都了解情况。让我们继续使 MQL5 数组更易于新手理解，同时建立一个相互支持和知识共享的社区。和我一起踏上编码之旅吧！

1.ArrayBsearch

对于升序排列的数组，可以使用 "ArrayBsearch()" 函数。这表明要将数组中的值按从小到大的升序排序。该函数采用二分查找技术，可以可靠地为排序数组生成结果，但对于未排序或随机排序的数组可能效果不佳。因此，要执行有效而准确的搜索，必须在使用 "ArrayBsearch()" 之前确保数组已正确排序。

类比

假设您有一组按特定顺序从小到大排序的数字。想象一下，你正试图在这个分类列表中搜索一个特定的数字，比如 30。ArrayBsearch() 函数是一个智能顾问，而不是手动挨个查看每个数字。它会通知您 30 位于列表中的位置 2（索引 2），并迅速将您引导到相应的位置。这就像有一位热心的朋友，有条不紊地加速你的搜索！

语法：

int ArrayBsearch(array[],value);

解释：

• "int"： 这是函数返回的数据类型。在本例中，它是一个整数，表示数组中找到的值的索引或建议值的位置。
• "ArrayBsearch"： 这是函数名称
• “array[]”: 要搜索的数组。
• “value”: 这是要在数组中搜索的值。

示例：

void OnStart()
  {

// Declare an array of sorted numbers
   double sortedArray[] = {10, 20, 30, 40, 50};

// Value to search for
   double searchValue = 30;

// Call ArrayBsearch function
   int resultIndex = ArrayBsearch(sortedArray, searchValue);

// Print out the index of 30 in the array
   Print("Found the resultIndex at index ", resultIndex); // The output will be index 2

  }

解释：

“double sortedArray[] = {10, 20, 30, 40, 50};”:

• 这一行声明了一个名为 "sortedArray" 的数组，其中包含已排序的数字 {10、20、30、40、50}。

“double searchValue = 30;”:

• 这一行将 "searchValue" 设置为 30，即我们要在数组中查找的数字。

  "int resultIndex = ArrayBsearch(sortedArray, searchValue);"：

• 这一行调用 "ArrayBsearch()" 函数，将 "sortedArray" 和 "searchValue" 作为参数传递。它会返回找到 "searchValue" 的索引，如果没有该值，则返回建议的插入点。

“Print("Found the resultIndex at index ", resultIndex);”:

• 这一行打印搜索结果。如果找到 "searchValue"，则打印索引；否则打印建议的插入点。

在本例中，"sortedArray" 是我们要搜索的数组，"searchValue" 是我们要在数组中查找的值。函数返回找到值的索引并打印结果。

2. ArrayResize

通过 MQL5 函数 "ArrayResize()"，您可以在程序运行时修改动态数组的大小。动态数组允许在程序执行过程中调整大小，而静态数组的大小是预先确定的。换句话说，"ArrayResize()" 是一种工具，当程序运行时，它可以让你根据当时的需要调整或扩展动态数组的大小。它提高了在运行期间更有效地处理数据的灵活性。

编程中的静态数组有固定的大小，在程序编译阶段就已设定。其中元素数量保持不变，因为大小是固定的，运行时无法更改。分配给这些数组的内存取决于它们的声明大小。例如，一个有五个元素的数组总是有五个元素的空间。

示例：

// Static array declaration
int staticArray[5] = {1, 2, 3, 4, 5};

相反，动态数组则具有灵活性，因为它可以在程序运行时调整或确定大小。这些数组在开始定义的时候没有设置大小，而在 MQL5 中，可以使用 "ArrayResize()" 等函数来更改内存分配。当数据结构的大小需要灵活调整，以便在程序执行过程中根据需要容纳不同数量的元素时，动态数组尤其有用。

示例：

// Dynamic array declaration
int dynamicArray[];

类比

比方说，你有一个神奇的背包（数组），里面有一大堆玩具（元素）。在开始探险时，您可以选择静态背包可容纳的玩具数量，而且一路上都不会改变。如果你想携带的玩具超过它的容纳能力，那就麻烦了。

动态背包可以被看作是一种特殊的东西，它可以成长，以容纳更多的玩具或您希望与朋友分享的玩具。要改变背包的大小并携带尽可能多的玩具进行魔法探险，请像使用咒语一样使用 "ArrayResize()"。

您可以在外出时改变动态背包的大小，因此不会受限于此。这种适应性有助于确保您的神奇旅程始终充满惊喜和刺激，无论您是发现新玩具还是决定与他人分享！这就好比对数组说："嘿，准备好更多元素吧！" 或 "好吧，让我们腾出点空间"。这种在程序运行过程中进行的动态调整具有多功能性和灵活性，因此对于初始大小未知的数组来说，它是一种非常宝贵的工具。

语法：

ArrayResize
(
    array[],          // Reference to the array to be resized
    new_size,         // New size for the array
    reserve_size = 0  // Optional space reserved for future elements
);

参数：

• “Array[]”: 这是您要调整大小的玩具盒（数组）。
• “new_size”: 这是您现在希望盒子容纳的玩具（元素）数量。如果你有 5 个玩具，而你想要的空间是 10 个，那么 "new_size" 就是 10。
•  "reserve_size = 0"： 有时，您可能想在不重新调整大小的情况下，为将来更多的玩具腾出空间。"reserve_size" 就像是在说："嘿，准备好更多的玩具吧！"

示例：

void OnStart()
  {

// Dynamic array declaration
   int dynamicArray[];

// Resizing the dynamic array to have 5 elements
   ArrayResize(dynamicArray, 5);

// Assigning values to dynamic array elements
   dynamicArray[0] = 10;
   dynamicArray[1] = 20;
   dynamicArray[2] = 30;
   dynamicArray[3] = 40;
   dynamicArray[4] = 50; 

// Accessing elements in a dynamic array
   Print("Element at index 2: ", dynamicArray[2]); // Output: 30

// Resizing the dynamic array to have 8 elements
   ArrayResize(dynamicArray, 8);

// Assigning values to the additional elements
   dynamicArray[5] = 60;
   dynamicArray[6] = 70;
   dynamicArray[7] = 80;

// Accessing elements after resizing
   Print("Element at index 6: ", dynamicArray[6]); // Output: 70

  }

解释：

动态数组声明：

int dynamicArray[];

• 在这里，我们声明了一个名为 "dynamicArray()" 的动态数组，但没有指定其初始大小。

将动态数组的大小调整为 5 个元素：

ArrayResize(dynamicArray, 5);

• "ArrayResize()" 函数用于将动态数组的大小设置为 5 个元素。

为动态数组元素赋值：

dynamicArray[0] = 10;
dynamicArray[1] = 20;
dynamicArray[2] = 30;
dynamicArray[3] = 40;
dynamicArray[4] = 50;

• 数值被分配给动态数组的各个元素。

访问动态数组中的元素：

Print("Element at index 2: ", dynamicArray[2]); // Output: 30

• "Print" 函数用于显示动态数组索引 2 的值。在本例中，将打印 "30"。

将动态数组的大小调整为 8 个元素：

ArrayResize(dynamicArray, 8);

• 动态数组的大小再次调整为 8 个元素，并保留了上次调整的值。

为附加元素赋值：

dynamicArray[5] = 60;
dynamicArray[6] = 70;
dynamicArray[7] = 80;

• 调整大小后，会为新添加的元素分配附加值。

调整大小后访问元素：

Print("Element at index 6: ", dynamicArray[6]); // Output: 70

• Print 函数用于显示第二次调整大小后动态数组索引 6 处的值。在这种情况下，将打印 70

3. ArrayCopy

在 MQL5 中，函数 "ArrayCopy()" 用于在数组之间复制元素。它能让你有选择性地将一个数组中特定范围定义的部分复制到另一个数组中。该函数使数组内的数据管理和排列变得更容易，从而使提取和在数组间移动特定元素变得更容易。

类比

假设您有两个项目列表，您希望将第一个列表中的某些项目完全复制到第二个列表中。这就是 MQL5 的 "ArrayCopy()" 函数的用武之地。它具有复制助手的功能，可以让你从数组中选择特定项目，并将其整齐地复制到另一个列表中。

下面是一个更具体的例子：假设你有一个包含五个不同商品价格的数组，你想创建第二个数组，其中只包含三个特定商品的价格。您可以使用 "ArrayCopy()" 函数将这三个价格提取并复制到一个新数组中，同时保留原始数组。这就好比有了一个有用的工具，可以让从一个集合复制和选择项目到另一个集合变得更容易，从而提高数组操作任务的效率和组织性。

语法：

ArrayCopy( 
          dst_array[],         // The destination array to receive copied elements 
          src_array[],         // The source array from which elements will be copied
          dst_start=0,         // The index in the destination array to start writing from  
          src_start=0,         // The index in the source array from which to start copying 
          count                // The number of elements to copy; default is to copy the entire array
);

这一功能强大的命令使您能够精确、可控地巧妙合并数组。在这个迷人的过程中，"dst_array" 是复制元素的目的地，而 "src_array" 则是绘制元素的源。附加参数，如 "dst_start"、"src_start" 和 "count"，可灵活调整合并操作。在 MQL5 编程的迷人领域中，可以将其视为精心制作的命令，该命令可协调数组的完美融合！

示例：

void OnStart()
  {

// Declare two dynamic arrays
   int sourceArray[];
   int destinationArray[];

// Resizing the dynamic arrays to have 5 elements each
   ArrayResize(sourceArray,5);
   ArrayResize(destinationArray,5);

// Assigning values to dynamic array elements
   sourceArray[0] = 1;
   sourceArray[1] = 2;
   sourceArray[2] = 3;
   sourceArray[3] = 4;
   sourceArray[4] = 5;

   destinationArray[0] = 10;
   destinationArray[1] = 20;
   destinationArray[2] = 30;
   destinationArray[3] = 40;
   destinationArray[4] = 50;

// Copy elements from sourceArray to destinationArray starting from index 1
   ArrayCopy(destinationArray, sourceArray, 5, 0, WHOLE_ARRAY);

// Print the value of the element at index 7 in destinationArray
   Comment("Value at index 7 in destinationArray: ", destinationArray[7]);

  }

解释：

数组声明：

int sourceArray[];
int destinationArray[];

• 在这里，我们声明了两个动态数组，分别命名为 "sourceArray" 和 "destinationArray"。
  

调整数组大小：

ArrayResize(sourceArray, 5);
ArrayResize(destinationArray, 5);

• "ArrayResize()" 函数用于设置动态数组的大小。在这种情况下，两个数组的大小都被调整为各有 5 个元素。
  

赋值：

sourceArray[0] = 1;
sourceArray[1] = 2;
sourceArray[2] = 3;
sourceArray[3] = 4;
sourceArray[4] = 5;

destinationArray[0] = 10;
destinationArray[1] = 20;
destinationArray[2] = 30;
destinationArray[3] = 40;
destinationArray[4] = 50;

• 值会分配给 "sourceArray" 和 "destinationArray" 中的单个元素。
  

数组的复制：

ArrayCopy(destinationArray, sourceArray, 5, 0, WHOLE_ARRAY);

• ArrayCopy() 函数用于将元素从 "sourceArray" 复制到 "destinationArray"。它指定从索引 0 开始复制 5 个元素。
  

打印值：

Comment("Value at index 7 in destinationArray: ", destinationArray[7]);

• 将打印一条注释，显示 "destinationArray" 中索引 7 的值。
  

该代码的总体目的是演示 "ArrayCopy()" 函数，从特定索引开始将元素从 "sourceArray" 复制到 "destinationArray"。最后一行打印 "destinationArray" 中元素的值，以确认复制成功。

4. ArrayCompare

MQL5 中的 "ArrayCompare()" 函数是比较两个数组并系统地评估其元素的工具。它从两个数组的开头（索引 0）开始比较，检查相应索引处的元素是否相等。如果所有元素都匹配，则认为这两个数组相等。不过，如果在任何索引处出现差异，函数会评估哪个数组持有数值较大的元素，从而为确定它们之间的关系提供依据。这个函数对于衡量数组之间内容的相似性或差异性特别有用。

类比

想象一下，您有两个数字列表：列表 A 和列表 B。"ArrayCompare()" 就像一个专门的调查员，分析这些列表并告知我们它们之间的关系。调查员从两份列表开头的数字开始，对它们进行比较。当检测到数字有差异时，它就会立即确定哪个列表 "更大" 或 "更小"。如果它能审查这两份名单，并且没有发现异常，它就会判定这两份名单 "相等"。

 

现在，侦探有了一种独特的方式来报告其调查结果：

• 如果认为列表 A 小于列表 B，则报告-1。
• 如果两个列表被视为相同，则报告为 0。
• 如果认为列表 A 大于列表 B，则报告为 1。
• 如果在调查过程中出现任何混乱或问题，它就会报告 -2。

因此，"ArrayCompare()" 可以帮助我们理解两个数字列表之间的关系，就像侦探在案件中找出谁是谁一样。

语法：

int ArrayCompare(const void& array1[], const void& array2[], int start1 = 0, int start2 = 0, int count = WHOLE_ARRAY);

参数：

• array1[]：第一个数组。
•  array2[]：第二个数组。
• start1：开始比较的第一个数组中的初始元素索引。默认起始索引为 0。
• start2:开始比较的第二个数组中的初始元素索引。默认起始索引为 0。
• count:要比较的元素个数。默认情况下，两个数组的所有元素都参与比较（count = WHOLE_ARRAY）。

示例：

void OnStart()
  {

// Declare two arrays
   int ListA[] = {1, 2, 3, 4, 5};
   int ListB[] = {1, 2, 3, 4, 6};
// Use ArrayCompare to compare the arrays
   int result = ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY);  
// Print the result
   if(result == -1)
      {
      Print("ListA is less than ListB");
      }
   else if(result == 0)
      {
      Print("ListA is equal to ListB");
      }
   else if(result == 1)
      {
      Print("ListA is greater than ListB");
      }
    else if(result == -2)
      {
       Print("Error: Incompatible arrays or invalid parameters");
      }

  }

解释：

"int ListA[] = {1, 2, 3, 4, 5};"：

• 声明一个名为 "ListA" 的整数数组，并用 1、2、3、4 和 5 对其进行初始化。

"int ListB[] = {1, 2, 3, 4, 6};"：

• 声明一个名为 "ListB" 的整数数组，并用 1、2、3、4 和 6 对其进行初始化。

"int result = ArrayCompare(ListA, ListB, 0, 0, WHOLE_ARRAY);"：

• 使用 "ArrayCompare()" 函数比较数组 "ListA" 和 "ListB"。比较从两个数组的索引 0 开始，对整个数组进行比较。

条件语句（"if"、"else if"）检查结果变量的值，并根据比较结果打印信息：

• 如果 "result" 为"-1"，则表示 "ListA" 被认为小于 "ListB"。
• 如果 "result" 为 "0"，则表示 "ListA" 等于 "ListB"。
• 如果 "result" 为 "1"，则表示 "ListA" 被认为大于 "ListB"。
• 如果 "result" 为"-2"，则表示由于数组不兼容或参数无效而出错。

给定数组：

int ListA[] = {1, 2, 3, 4, 5};
int ListB[] = {1, 2, 3, 4, 6};

"ArrayCompare(ListA,ListB,0,0,WHOLE_ARRAY)" 的结果将是 -1。

解释：

• 比较从两个数组的第一个元素（索引 0）开始。
• 两个数组中位于索引 0 至 3 的元素是相同的。
• 在索引 4 中，ListA 是 5，而 ListB 是 6。
• 由于 5 < 6，因此认为 ListA 小于 ListB。

因此，结果将是-1。请随意修改 ListA 和 ListB 中的值，看看比较结果有什么变化！

5. ArrayFree

在 MQL5 中，调用 "ArrayFree()" 类似于按下动态数组的重置按钮。将数组视为一个容器，可容纳不同的项目。这类似于在使用 "ArrayFree()" 时清空容器并准备容纳新项目。这是一种通过删除过时信息为新数据腾出空间的方法。换一种说法，就把它看作是为接下来的事情清理桌面。通过使用此函数，您可以确保数组为空，并为新的 MQL5 编程体验做好准备。

类比

想象一下，您有一个神奇的袋子 - 您的数组。有时，您想用它来做不同的事情，比如收集玩具。但是，在买新玩具之前，您需要确保袋子是空的。这就是 "ArrayFree()" 的作用 - 它挥一挥魔杖，清空您的包，这样您就可以放进新的玩具或数字了。就好像在说："好了，包包，准备好接受更有趣的东西吧！"这样，您就可以带着您的魔法袋在 MQL5 的世界里开始新的冒险了。

语法：

ArrayFree(array[] // dynamic array to be freed);

示例：

void OnStart()
  {

// Declare a dynamic array
   int dynamicArray[];
// Resize the dynamic array and assign values
   ArrayResize(dynamicArray, 5);
   dynamicArray[0] = 10;
   dynamicArray[1] = 20;
   dynamicArray[2] = 30;
   dynamicArray[3] = 40;
   dynamicArray[4] = 50;
   
// Print elements before freeing the array
   Print("Index 0 before freeing: ", dynamicArray[0]); // Output will be 10
   
// Free the dynamic array using ArrayFree
   ArrayFree(dynamicArray);
   
// Attempting to access elements after freeing (should result in an error)
//   Print("Index 0 after freeing: ", dynamicArray[0]);

// Reassign new values to the array
   ArrayResize(dynamicArray, 3);
   dynamicArray[0] = 100;
   dynamicArray[1] = 200;
   dynamicArray[2] = 300;
   
// Print elements after reassigning values
   Print("Index 0 after reassigning: ", dynamicArray[0]); // Output will be 100

  }

解释：

声明动态数组：

int dynamicArray[];

• 初始化一个空的动态数组。
  

调整大小并赋值：

ArrayResize(dynamicArray, 5);
dynamicArray[0] = 10;
dynamicArray[1] = 20;
dynamicArray[2] = 30;
dynamicArray[3] = 40;
dynamicArray[4] = 50;

• 将动态数组的大小调整为 5 个元素，并为每个元素赋值。
  

在释放前打印元素：

Print("Elements before freeing: ", dynamicArray[0]); // Output will be 10

• 打印数组第一个索引处的值，即 10。
  

释放动态数组：

ArrayFree(dynamicArray);

• 释放动态数组占用的内存。
  

释放后尝试访问元素：

// Print("Elements after freeing: ", dynamicArray[0]);

• 注释掉这一行是为了避免运行时出错，因为数组已被释放。
  

分配新值：

ArrayResize(dynamicArray, 3);
dynamicArray[0] = 100;
dynamicArray[1] = 200;
dynamicArray[2] = 300;

• 将数组的大小调整为 3 个元素，并分配新值。
  

重新赋值后打印元素：

Print("Elements after reassigning: ", dynamicArray[0]); // Output will be 100

• 打印重赋值后数组第一个索引处的值，即 100。
  

在本例中，使用 "ArrayFree()" 释放动态数组后，我们再次调整了数组的大小，使其包含 3 个元素，并为这些元素赋值。这演示了如何在释放动态数组后重复使用它。

当我们研究 MQL5 数组函数的复杂性时，还会发现更多神奇之处。请继续关注我们对更多功能的深入探讨，这些功能将提高你对代码的熟练程度。无论你的开发经验有多丰富，这条路都还远未走完。在接下来的章节中，随着我们对这些奇迹的深入研究，将会有令人兴奋的发现。在保持好奇心的同时，让我们一起继续编码之旅！

6. ArraySetAsSeries

在 MQL5 编程中，"ArraySetAsSeries()" 是一个允许您修改数组索引方向的函数。通过使用该函数，可以将数组的访问方向设置为从尾部到起始部，改变默认的前进方向。这在处理金融数据或其他数组时特别有用，因为在这些数组中，按时间倒序访问元素是有益的。

请注意：值得注意的是，这个神奇的功能特别适用于动态数组，即在运行时可以优雅地调整大小的数组。

类比

想象一下，你的书架上整齐地摆放着一摞魔法故事书。每本书都像一个特别的数字，等待着你去探索它的精彩故事。通常情况下，您会按照书架上的顺序阅读这些故事，从第一本开始读到最后一本。

想象一下，您想在不把所有书籍从书架上取下来的情况下，开始探索您收藏的最新故事。这就是 "ArraySetAsSeries()" 的魅力所在！当你在书架（数组）上施展这个咒语时，就好像在说："让我们重新排列故事，让你添加的最新故事神奇地先出现"。当你的故事（数字）随着时间的推移而变化时，比如记录你每天收集了多少本新书，这一点尤其有用。有了 "ArraySetAsSeries()"，你可以先打开最新的故事书，然后在你的神奇图书馆中回溯，看看你的收藏是如何增长的。这就像为你的非凡文学探险设置了一个反向阅读咒语！

语法：

ArraySetAsSeries(
   array[],    // array to be set as series
   bool   flag // true denotes reverse order of indexing
);

参数：

• “array[]”: 这是您要为其添加时间序列属性的数组。这就好比选择一件你想赋予特殊力量的魔法器物。
• “bool flag”: 这是一个布尔值。当设置为 "true" 时，它会激活索引的神秘反转，将数组变成一个时间序列奇观，最后一个元素变成第一个元素。如果设置为 "false"，数组将以常规的非魔法方式运行。

示例：

void OnStart()
  {

// Declare a dynamic array
   int magicalArray[];

// Assign values to the array
   ArrayResize(magicalArray, 5);
   magicalArray[0] = 10;
   magicalArray[1] = 20;
   magicalArray[2] = 30;
   magicalArray[3] = 40;
   magicalArray[4] = 50;

// Print elements before setting as series
   Print("Elements before setting as series:");
   Print("Index 0: ", magicalArray[0]);
   Print("Index 1: ", magicalArray[1]);
   Print("Index 2: ", magicalArray[2]);
   Print("Index 3: ", magicalArray[3]);
   Print("Index 4: ", magicalArray[4]);

// Set the array as a series
   ArraySetAsSeries(magicalArray, true);

// Print elements after setting as series
   Print("Elements after setting as series:");
   Print("Index 0: ", magicalArray[0]);
   Print("Index 1: ", magicalArray[1]);
   Print("Index 2: ", magicalArray[2]);
   Print("Index 3: ", magicalArray[3]);
   Print("Index 4: ", magicalArray[4]);

  }

解释：

动态数组声明：

double magicalArray[];

• 声明一个名为 "magicalArray" 的动态数组，但未指定其大小。
  

为数组赋值：

ArrayResize(magicalArray, 5);
magicalArray[0] = 10;
magicalArray[1] = 20;
magicalArray[2] = 30;
magicalArray[3] = 40;
magicalArray[4] = 50;

• 我们将数组的大小调整为 5 个元素。
  
• 然后，我们为数组中的每个元素分配特定的值。
  

在设置为系列之前打印元素：

Print("Elements before setting as series:");
Print("Index 0: ", magicalArray[0]); // output will be 10
Print("Index 1: ", magicalArray[1]); // output will be 20
Print("Index 2: ", magicalArray[2]); // output will be 30
Print("Index 3: ", magicalArray[3]); // output will be 40
Print("Index 4: ", magicalArray[4]); // output will be 50

• 在将数组设置为序列之前，本节将打印数组中每个元素的值。
  

将数组设置为序列：

ArraySetAsSeries(magicalArray, true);

• 我们使用 "ArraySetAsSeries()" 将数组设置为序列。第二个参数 "true" 表示索引顺序相反。
  

设置为序列后打印元素：

Print("Elements after setting as series:");
Print("Index 0: ", magicalArray[0]); // output will be 50
Print("Index 1: ", magicalArray[1]); // output will be 40
Print("Index 2: ", magicalArray[2]); // output will be 30
Print("Index 3: ", magicalArray[3]); // output will be 20
Print("Index 4: ", magicalArray[4]); // output will be 10

• 最后，我们将数组设置为序列后，打印每个元素的值。打印顺序反映了由于将其设置为系列而造成的索引顺序颠倒。
  

总之，代码演示了如何为动态数组赋值，在将其设置为序列前后打印其元素，并观察索引顺序的变化。

在 MQL5 编程的迷人旅程中，我们探索了神奇的函数 "ArraySetAsSeries()"。这就好比挥动一根魔杖，就能扭转数组时空旅行能力的顺序！在本章结束时，请记住熟能生巧。尝试新事物，慢慢阅读，随时提问。您可以在神奇的编码探险中得到社区的帮助。为更多的编码工作干杯！"

7. ArrayGetAsSeries

MQL5 中的 "ArrayGetAsSeries()" 函数用于确定数组是否设置了 AS_SERIES 标志。该标记会影响访问数组元素的顺序。如果函数返回 true，则表示以相反顺序访问元素；否则，如果函数返回 false，则数组保持默认顺序。在处理数据访问顺序至关重要的数组时，该函数非常方便，它提供了一种根据数组配置检查和调整数据访问模式的方法。

类比

想象一下，你有一个神奇的数字列表，有时这个列表喜欢玩一种叫做 "时间旅行" 的特殊游戏。当你询问这个神奇的工具 "ArrayGetAsSeries()" 时，它会告诉你你的列表是否在玩游戏。如果显示 "true"，说明列表正在玩，你可以倒着读数字，就像倒数一样。如果显示的是 "false"，那么列表就是正常的，你可以从头到尾读取数字，就像往上数一样。因此，它可以帮助你了解神奇列表的规则！

语法：

bool ArrayGetAsSeries(
array[]    // // The array that is being examined for its time series configuration.
);

示例：

void OnStart()
  {

// Declare two dynamic arrays
   int timeSeriesArray[];
   int regularArray[];
// Resize the arrays to have 5 elements
   ArrayResize(timeSeriesArray, 5);
   ArrayResize(regularArray, 5);
// Assign values to the arrays
   timeSeriesArray[0] = 1;
   timeSeriesArray[1] = 2;
   timeSeriesArray[2] = 3;
   timeSeriesArray[3] = 4;
   timeSeriesArray[4] = 5;

   regularArray[0] = 5;
   regularArray[1] = 4;
   regularArray[2] = 3;
   regularArray[3] = 2;
   regularArray[4] = 1;
// Set the time series flag for the first array
   ArraySetAsSeries(timeSeriesArray, true);
// Check if the dynamic arrays follow the time series convention using if statements
   if(ArrayGetAsSeries(timeSeriesArray))
     {
      Print("timeSeriesArray is a time series. Elements are accessed from end to beginning.");
     }
   else
     {
      Print("timeSeriesArray maintains its original order. Elements are accessed from beginning to end.");
     }

   if(ArrayGetAsSeries(regularArray))
     {
      Print("regularArray is a time series. Elements are accessed from end to beginning.");
     }
   else
     {
      Print("regularArray maintains its original order. Elements are accessed from beginning to end.");
     }

  }

解释：

// Declare two dynamic arrays
int timeSeriesArray[];
int regularArray[];

• 这两行分别声明了名为 "timeSeriesArray" 和 "regularArray" 的两个动态数组。MQL5 中的动态数组可以在运行期间改变大小。
  

// Resize the arrays to have 5 elements
ArrayResize(timeSeriesArray, 5);
ArrayResize(regularArray, 5);

• 这几行使用 "ArrayResize()" 函数将两个数组的大小都设置为 5 个元素。这一步骤可确保数组有足够的空间来存储元素。
  

// Assign values to the arrays
timeSeriesArray[0] = 1;
timeSeriesArray[1] = 2;
timeSeriesArray[2] = 3;
timeSeriesArray[3] = 4;
timeSeriesArray[4] = 5;

regularArray[0] = 5;
regularArray[1] = 4;
regularArray[2] = 3;
regularArray[3] = 2;
regularArray[4] = 1;

• 这些行将为两个数组的元素分配特定值。"timeSeriesArray" 按升序赋值，而 "regularArray" 按降序赋值。
  

// Set the time series flag for the first array
ArraySetAsSeries(timeSeriesArray, true);

• 这一行使用 "ArraySetAsSeries()" 函数将 "timeSeriesArray" 的时间序列标志设置为 "true"。这意味着 "timeSeriesArray" 中的元素将从头到尾被访问。
  

// Check if the dynamic arrays follow the time series convention using if statements
    if(ArrayGetAsSeries(timeSeriesArray))
    {
        Print("timeSeriesArray is a time series. Elements are accessed from end to beginning.");
    }
    else
    {
        Print("timeSeriesArray maintains its original order. Elements are accessed from beginning to end.");
    }

    if(ArrayGetAsSeries(regularArray))
    {
        Print("regularArray is a time series. Elements are accessed from end to beginning.");
    }
    else
    {
        Print("regularArray maintains its original order. Elements are accessed from beginning to end.");
    }

• 提供的代码片段使用条件语句检查动态数组 "timeSeriesArray" 和 "regularArray" 是否遵守时间序列约定。它利用 "ArrayGetAsSeries()" 函数来确定每个数组是否设置了时间序列标志。第一个 "if" 语句检查 "timeSeriesArray"，如果确定它是一个时间序列，就会打印出相应的信息，表明从头到尾访问了它的元素。如果没有，"else" 代码块将打印一条信息，说明 "timeSeriesArray" 保持原来的顺序，元素将从头到尾被访问。对 "regularArray" 重复上述过程。这种条件检查对于了解这些动态数组中的元素是如何进行索引的至关重要，为了解数组的访问方向提供了宝贵的见解。
  

了解 "ArrayGetAsSeries()" 的复杂性是 MQL5 的一项宝贵技能。无论您是浏览时间序列数据，还是按原始顺序处理数组，这些函数都能让您在算法交易之旅中如虎添翼。作为初学者，您应该提出问题，这样我们就能共同建设社区。 编码快乐！

8. ArrayIsSeries

在 MQL5 中要确定一个数组是否代表一个时间序列时，"ArrayIsSeries()" 函数是必不可少的。在金融编程中，包含时间相关数据的数组称为时间序列，常用于存储开盘价、最高价、最低价和收盘价等价格值。检测到时间序列时，函数会分析所提供的数组并返回 "true"，否则返回 "false"。在图表中处理金融数据时，了解数据的时间性质至关重要，因此这种判断至关重要。

在 MQL5 中创建自定义指标时，尤其是在技术分析中，必须区分常规数组和时间序列数组。"ArrayIsSeries()" 函数简化了这一过程，允许开发人员根据数组是否包含随时间变化的信息来定制代码。该功能有助于提高使用 MQL5 语言开发的算法交易策略、技术分析工具和其他金融应用程序的效率和准确性。

ArrayGetAsSeries 与 ArrayIsSeries 的区别

"ArrayGetAsSeries()" 和 "ArrayIsSeries()" 都是与数组行为有关的函数，但它们的作用各不相同。"ArrayGetAsSeries()" 用于检查数组的索引是否设置为从后向前检索元素，即通常所说的逆序。该函数在处理数组时非常有用，可以让开发人员确定数据是按时间顺序还是反向访问的。如果数组设置为序列（按相反顺序访问），则返回 "true"，否则返回 "false"。

另一方面，"ArrayIsSeries()" 侧重于识别数组是否是时间序列。时间序列数组在金融编程中非常普遍，代表了开盘价、最高价、最低价和收盘价等随时间变化的数据。与 "ArrayGetAsSeries()" 不同，"ArrayIsSeries()" 并不关心数组索引的方向。相反，它会检查数组是否包含与时间相关的信息。如果数组是时间序列，则返回 "true"；否则返回 "false"。这些功能相辅相成，为处理数组行为提供了全面的工具包，在算法交易系统和技术分析工具中处理各类金融数据时提供了灵活性。

类比

想象一下，你每天都会有一份事物清单，比如你最喜欢的玩具的价格。现在，如果我们想知道这个列表是否特殊，是否与时间有关，就像一个故事一样，我们可以使用名为 "ArrayIsSeries()" 的魔咒。这个咒语会检查我们的列表是否具有时间旅行特性，使其成为一个 "时间序列"。它并不关心列表是向后读还是向前读，它更想知道这是否像一场时间旅行的冒险。

因此，如果咒语说 "true"，那就意味着我们的清单就像一个穿越时空的故事，也许会显示玩具在几天内的价格。但如果显示 "false"，我们的列表可能只是一个普通的数字集合，没有任何与时间相关的魔法。这就像在问："这份清单是一个特殊的穿越故事吗？"咒语给了我们一个简单的答案 - 是或否！

语法：

bool ArrayIsSeries(
array[] //the array you want to check if it's a timeseries.
)

示例：

void OnStart()
  {

// Declare an array
   double priceSeries[];
// Resize the array and assign values (considering it as a time series)
   ArrayResize(priceSeries, 5);
   priceSeries[0] = 1.1;
   priceSeries[1] = 1.2;
   priceSeries[2] = 1.3;
   priceSeries[3] = 1.4;
   priceSeries[4] = 1.5;
// Check if the array is a time series
   bool isSeries = ArrayIsSeries(priceSeries);
// Print the result
   if(isSeries)
     {
      Print("This array is a time series!");
     }
   else
     {
      Print("This array is not a time series.");
     }

  }

解释：

// Declare an array
double priceSeries[];

• 这一行声明了一个名为 "priceSeries" 的空动态数组，用于存储 double 型数值。
  

// Resize the array and assign values (considering it as a time series)
ArrayResize(priceSeries, 5);
priceSeries[0] = 1.1;
priceSeries[1] = 1.2;
priceSeries[2] = 1.3;
priceSeries[3] = 1.4;
priceSeries[4] = 1.5;

• 这里，数组的大小调整为 5 个元素，并为每个元素分配了特定值。这些数值代表一个假设的时间序列。
  

// Check if the array is a time series
bool isSeries = ArrayIsSeries(priceSeries);

• 这一行使用 "ArrayIsSeries()" 函数检查数组 "priceSeries" 是否被视为时间序列。结果（"true "或 "false"）存储在布尔变量 "isSeries" 中。
  

// Print the result
if (isSeries) {
    Print("This array is a time series!");
} else {
    Print("This array is not a time series.");
}

• 最后，代码会打印一条信息，说明根据 "ArrayIsSeries()" 得到的结果，数组是否被视为时间序列。如果是时间序列，则打印一条信息；否则打印另一条信息。
  

这种情况下的输出结果是 "此数组不是时间序列"。为什么呢？由于我们的数组在赋值后并不代表一个时间序列，我意识到一开始，尤其是对于新手来说，可能会有些困惑。但现在，我们将保持简单。欢迎大家在我们共同研究和学习的过程中进行提问。

9.ArrayInitialize

"ArrayInitialize()" 是 MQL5 中的一个函数，用于将数字数组中所有元素的初始值设置为指定的预设值。"ArrayInitialize()" 可将所选的值一次性应用到所有元素，从而简化流程，而不是逐个手动为每个元素分配相同的值。该函数有助于为数组准备一个一致的起始点，尤其是在处理需要统一初始化的数值数据时。请记住，它只会设置初始值，不会影响任何保留元素或将来使用 "ArrayResize()" 进行的扩展。

类比

想象一下，你有一组神奇的容器，叫做数组，每个容器内部都有一些特殊的空间来存放值。现在，当你想从所有这些空格中的一个特定值开始时，你可以使用一个名为 "ArrayInitialize()" 的特殊命令。这条命令可以神奇地一次性设置所有空间的初始值，省去了逐个空间设置的麻烦。

不过，有趣的地方在于：如果以后你决定使用另一个神奇的命令（ArrayResize）将这些容器变大并添加更多空间，那么新空间就会出现，但它们的神奇数值将与原来的空间不同。 您必须分别选择要输入的数值，因为它们会略有不同。这就好比扩建城堡的内部空间，你不一定会用和旧房间一样的家具来装饰新房间。

语法：

int ArrayInitialize(
   array[],   // initialized array
   value       // value that will be set
);

示例：

void OnStart()
  {

// Declare a dynamic array
   int myArray[];

// Resize the array to have an initial size (let's use 3 elements)
   ArrayResize(myArray, 3);

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

// Initialize the array with a value (let's use 0.0)
   ArrayInitialize(myArray, 0);

// Print the values of all elements after initialization
   Print("Values after initialization:");
   Print("myArray[0] = ", myArray[0]); // outpot wil be 0
   Print("myArray[1] = ", myArray[1]); // outpot wil be 0
   Print("myArray[2] = ", myArray[2]); // outpot wil be 0
// Resize the array to have 5 elements
   ArrayResize(myArray, 5);

// Assign values to the additional elements after resizing
   myArray[3] = 40;
   myArray[4] = 50;

// Print the values of all elements after resizing
   Print("Values after resizing:");
   Print("myArray[3] = ", myArray[3]); // outpot wil be 40
   Print("myArray[4] = ", myArray[4]); // outpot wil be 50


  }

解释：

// Declare a dynamic array
   int myArray[];

• 在这里，我们声明一个名为 "myArray" 的动态整数数组。它没有预定的大小。
  

// Resize the array to have an initial size (let's use 3 elements)
   ArrayResize(myArray, 3);

• 我们调整了 "myArray" 的大小，使其初始大小为 3 个元素。这意味着我们要为数组中的三个整数分配内存。
  

// Assign values to all elements before initialization
   myArray[0] = 10;
   myArray[1] = 20;
   myArray[2] = 30;

• 在初始化数组之前，我们先手动为其元素赋值。在本例中，我们将 "myArray[0]"设为 10，将 "myArray[1]" 设为 20，将 "myArray[2]" 设为 30。
  

// Initialize the array with a value (let's use 0.0)
   ArrayInitialize(myArray, 0);

• 现在，我们使用 "ArrayInitialize()" 函数将 "myArray" 的所有元素设置为指定值，在本例中为 0。
  

// Print the values of all elements after initialization
Print("Values after initialization:");
Print("myArray[0] = ", myArray[0]); // Output will be 0
Print("myArray[1] = ", myArray[1]); // Output will be 0
Print("myArray[2] = ", myArray[2]); // Output will be 0

• 初始化后，我们将打印 "myArray" 中所有元素的值。不出所料，现在所有元素都设置为 0。
  

// Resize the array to have 5 elements
ArrayResize(myArray, 5);

• 接下来，我们调整 "myArray" 的大小，使其总共包含 5 个元素。这意味着数组现在可以多容纳两个元素。
  

// Assign values to the additional elements after resizing
myArray[3] = 40;
myArray[4] = 50;

• 调整大小后，我们为附加元素（"myArray[3]" 和 "myArray[4]"）赋值。
  

// Print the values of all elements after resizing
Print("Values after resizing:");
Print("myArray[3] = ", myArray[3]); // Output will be 40
Print("myArray[4] = ", myArray[4]); // Output will be 50

• 最后，我们打印出调整大小后 "myArray" 中所有元素的值，包括新添加的元素。
  

MQL5 中的 "ArrayInitialize()" 函数是一个功能强大的工具，允许程序员将数组中每个元素的值设置为指定值。这确保了每个数组元素的起点一致，并使数组的初始状态更加清晰可控。请记住，函数会将每个元素初始化为相同的指定数字。这看似简单，却是为不同应用设置数组的重要步骤。在以后的文章中，我们将深入探讨算法交易领域，这将突出 "ArrayInitialize()" 的重要性。保持专注，享受编码吧！

10. ArrayFill

"ArrayFill() "是 MQL5 中的一个函数，在简化数组操作任务方面发挥着重要作用。该函数允许开发人员用指定值有效地填充一系列数组元素，无需手动迭代和赋值。与编写多行代码单独设置每个元素相比，"ArrayFill()" 提供了一个简洁有效的解决方案。这种功能提高了代码的可读性，减少了出错的机会，尤其是在处理大型数组或重复赋值时。该函数能够用一个通用值快速填充数组元素，从而简化了编码过程，使其成为处理需要批量初始化的各种情况的重要工具。

类比

比方说，您有一个有多个插槽的盒子，您想用其中的一些插槽来装同一个玩具，而不必逐个检查。"ArrayFill()" 就像一个魔咒，让你可以选择一个玩具，并指示它 "用这个玩具填满这些插槽"。这样，您就可以一次性摆放所有玩具，而不是逐个摆放！这就好比对一个有一堆玩具车的人说："把前五个空格填上红色的车，后面五个填上蓝色的车。"这个省时魔术能帮你维持玩具箱的秩序！

语法：

ArrayFill(
    array[], // array to be filled
    start,   // Starting slot (index) for filling
    count,   // Number of slots to fill
    value    // The value to fill the slots with
);

参数

• “array[]”:这就是你的货架数组。
• “start”:这就好比指定让您开始放置物品的第一个货架。由您提供索引或位置。
•  “count”:这就类似于说："我想把这件商品放在下一个 X 个货架上"。由您决定要填充的货架数量。
• “value”:这就是您要放在货架上的物品。它可以是任何物品 - 一个数字、一种颜色或任何适合摆放在货架上的东西。

示例：

void OnStart()
  {

// Declare an array of shelves
   int roomShelves[];

// Set the size of the array (number of shelves)
   ArrayResize(roomShelves, 10);

// Fill the first 5 shelves with books (value 42)
   ArrayFill(roomShelves, 0, 5, 42);

// Fill the next 5 shelves with toys (value 99)
   ArrayFill(roomShelves, 5, 5, 99);

// Display the contents of the shelves after filling
   Print("Contents of the shelves after filling:");
   Print("Shelf 0: ", roomShelves[0]); // output will be 42
   Print("Shelf 1: ", roomShelves[1]); // output will be 42
   Print("Shelf 2: ", roomShelves[2]); // output will be 42
   Print("Shelf 3: ", roomShelves[3]); // output will be 42
   Print("Shelf 4: ", roomShelves[4]); // output will be 42
   Print("Shelf 5: ", roomShelves[5]); // output will be 99
   Print("Shelf 6: ", roomShelves[6]); // output will be 99
   Print("Shelf 7: ", roomShelves[7]); // output will be 99
   Print("Shelf 8: ", roomShelves[8]); // output will be 99
   Print("Shelf 9: ", roomShelves[9]); // output will be 99

  }

解释：

"int roomShelves[];"：

• 声明一个名为 "roomShelves" 的整数数组，用于表示房间里的书架。

"ArrayResize(roomShelves,10);"：

• 调整 "roomShelves" 数组的大小，使其包含 10 个元素，代表房间里的 10 个书架。

"ArrayFill(roomShelves,0,5,42);"：

• 用 42 填充前 5 个书架（索引 0 至 4），代表这些书架上的图书。

"ArrayFill(roomShelves,5,5,99);"：

• 用数值 99 填充接下来的 5 个货架（索引 5 至 9），代表这些货架上的玩具。

"Print("Contents of the shelves after filling:");"：

• 打印一条信息，说明下面几行将显示货架的内容。

将 "Print("Shelf 0: ", roomShelves[0]); "改为 "Print("Shelf 9: ", roomShelves[9]);"：

• 打印每个货架的内容，显示货架的索引及其相应的值

这段 MQL5 代码说明了如何使用 "ArrayFill()" 函数填充名为 "roomShelves" 的动态数组。最初，数组的大小调整为 10 个货架。下一步是使用 "ArrayFill()" 将 42 填入前五个货架，将 99 填入后五个货架。填充过程结束后，数组中每个元素的赋值最终会在打印每个架子的内容时显示出来。该代码演示了 "ArrayFill()" 如何提供一种灵活的方法，通过有效地用预定义值初始化动态数组的指定段，在数组结构内设置预定义值。

请注意："ArrayFill()" 和 "ArrayInitialize()" 都是 MQL5 中的数组操作函数，但它们的用途不同。"ArrayFill()" 设计用于用给定值填充数组中特定范围的元素。它允许对数组的一个子集进行高效的批量赋值，因此在有选择地修改或初始化数组的一部分时非常有用。相比之下，"ArrayInitialize()" 是一个更通用的函数，可以统一设置整个数组中所有元素的值。它可以确保整个数组的起始状态保持一致，提供了一种将所有元素初始化为相同值的快速方法。因此，"ArrayFill()" 专门用于有针对性的赋值，而 "ArrayInitialize()" 则是一种更广泛的工具，用于对整个数组进行统一的初始化。

11. ArrayIsDynamic

要确定数组是动态的还是静态的，MQL5 中的一个有用工具是 "ArrayIsDynamic()" 函数。静态数组的大小在编译时是固定的，而动态数组的大小可以在运行时改变。"ArrayIsDynamic()" 可确定数组是动态的还是静态的，并根据数组的性质返回简单的 "true" 或 "false" 响应。有了这些数据，程序就可以根据数组的灵活性修改自己的行为，确定程序运行时是否可以改变数组的大小。

类比

数组类似于编程世界中一个神奇的盒子，可以容纳多个对象。现在，有些箱子有一种特殊的魔力，可以在必要时调整大小，以容纳更多的物品或占用更少的空间。这些被称为动态箱。相反，有些箱子的尺寸是固定的，在任何情况下都不会变化。这些被称为静态箱。

现在，要确定一个方框是动态的还是静态的，可以使用类似向导的 "ArrayIsDynamic()" 函数。这个咒语的结果表明盒子是静态的 - 大小保持不变，还是动态的 - 可以改变大小。程序员需要了解这些知识，因为在决定如何在神奇的代码中操作方框时，这些知识是有意义的。如果是静态的，他们必须注意不要超过设定的大小；如果是动态的，他们可以根据需要使其增大或缩小。

语法：

bool ArrayIsDynamic(array[]   // array to be checked);

示例：

void OnStart()
  {

// Declare a static array
   int staticArray[5];

// Declare a dynamic array
   int dynamicArray[];

// Check if the static array is dynamic
   bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);

   if(isStaticArrayDynamic)
     {
      Print("The staticArray is dynamic.");  // This message won't be printed.
     }
   else
     {
      Print("The staticArray is static, meaning its size is fixed.");
     }

// Check if the dynamic array is dynamic
   bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);

   if(isDynamicArrayDynamic)
     {
      Print("The dynamicArray is dynamic, meaning its size can be changed.");
     }
   else
     {
      Print("The dynamicArray is static.");  // This message won't be printed.
     }
     
  }

解释：

"int staticArray[5];"：

• 这一行声明了一个名为 "staticArray" 的数组，其大小固定为 5 个元素。

"int dynamicArray[];"：

• 这一行声明了一个名为 "dynamicArray" 的动态数组，但没有指定固定大小。

"bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);"：

• 这一行使用 "ArrayIsDynamic()" 函数检查 "staticArray" 是否为动态数组，并将结果赋值给 "isStaticArrayDynamic"。

"bool isStaticArrayDynamic = ArrayIsDynamic(staticArray);"：

• 这一行使用 "ArrayIsDynamic()" 函数检查 "staticArray" 是否为动态数组，并将结果赋值给 "isStaticArrayDynamic"。

打印静态数组的结果：

• 随后的 "if-else" 代码块会根据上一步的结果打印一条信息，说明 "staticArray" 是动态的还是静态的。

"bool isDynamicArrayDynamic = ArrayIsDynamic(dynamicArray);"：

• 这一行使用 "ArrayIsDynamic()" 函数检查 "dynamicArray" 是否为动态数组，并将结果赋值给 "isDynamicArrayDynamic"。

打印动态数组的结果：

• 随后的 "if-else" 代码块会根据上一步的结果打印一条信息，说明 "dynamicArray" 是动态的还是静态的。

该代码演示了如何使用 "ArrayIsDynamic()" 来确定数组是动态的还是静态的。

12. ArrayMaximum

MQL5 中的 "ArrayMaximum()" 函数是一个功能强大的工具，用于识别数字数组中最大元素的索引。在确定最高值对决策至关重要的情况下，该功能尤其有用。通过在数组中有效搜索，该函数返回最大元素的索引，同时考虑到数组序列。在数组代表金融或技术数据的情况下，找到最大值是提取有意义的见解或做出明智交易决策的基本步骤。

类比

想象一下，你有一串数字，比如你玩过的不同游戏的得分。"ArrayMaximum()" 函数就像一个小帮手，它可以查看你的列表，并告诉你哪款游戏你做得最好。因此，如果你想知道哪个游戏得分最高，这个助手就会检查每个得分，当它找到最高分时，就会指向那个游戏，并说："这个是你玩得最好的游戏！"这就像让朋友快速找到你玩得最棒的游戏，而不用你自己去查看整个列表。在计算机程序中，这个助手可以方便地找出一堆数字中最大的数字。

语法：

int ArrayMaximum(
    array[],       // Array for search
    start,          // Index to start checking with
    count = WHOLE_ARRAY    // Number of checked elements (default: search in the entire array)
);

参数：

• “array[]”:这是要查找最大值的数组。
• “start":通过该参数可以指定数组中的索引，从该索引开始搜索最大值。
• "count = WHOLE_ARRAY"：它表示搜索时要考虑的元素数量。默认值 "WHOLE_ARRAY" 表示函数将搜索整个数组。

现在，当你调用 "ArrayMaximum(array, start, count)" 时，函数将找到数组指定范围内最大的元素，并返回其索引。如果找不到最大值，则返回-1。

示例：

void OnStart()
  {
  
// Declare an array with integer values
   int myArray[] = {42, 18, 56, 31, 75, 23};

// Find the maximum value and its index
   int maxIndex = ArrayMaximum(myArray);

// Check if a maximum was found
   if(maxIndex != -1)
     {
      Print("The maximum value in the array is: ", myArray[maxIndex]);
      Print("Index of the maximum value: ", maxIndex);
     }
   else
     {
      Print("No maximum value found in the array.");
     }

  }

解释：

"int myArray[] = {42, 18, 56, 31, 75, 23};"：

• 这一行声明了一个名为 "myArray" 的整数数组，并用六个整数值对其进行了初始化。

"int maxIndex = ArrayMaximum(myArray);"：

• 在 "myArray" 中调用 "ArrayMaximum()" 函数来查找数组中最大值的索引。结果存储在变量 "maxIndex" 中。

“if (maxIndex != -1) {“: 

• 该条件语句检查是否找到最大值。如果 "maxIndex" 不等于 "-1"，则表示数组中存在最大值。

“Print("The maximum value in the array is: ", myArray[maxIndex]);”:

• 如果找到最大值，该行将使用从 "maxIndex" 中获得的索引打印最大值。

“Print("Index of the maximum value: ", maxIndex);”:

• 这一行打印最大值的索引。

"} else { Print("No maximum value found in the array."); }"：

• 当 maxIndex 为 -1 时，即未找到最大值时，将执行该代码块，并打印一条说明未找到最大值的信息。

要确定数组中的最大值及其索引，可使用 "ArrayMaximum()"，如本代码所示。

13. ArrayMinimum

MQL5 中有一个名为 "ArrayMinimum()" 的有用函数，可以让您确定数值数组第一维中最小元素的索引。该函数可以处理不同大小的数组，非常灵活。它通过考虑数组的序列顺序来确保结果的准确性。

"ArrayMinimum()" 主要用于查找数组中最小元素的索引。它给出了最低值的索引，同时考虑了数组元素的顺序。如果搜索没有找到最小值，函数将返回 -1。当您需要确定数组中最小元素的确切位置时，这一功能就会派上用场。

语法：

int ArrayMinimum(array[],start,count = WHOLE_ARRAY);

示例：

void OnStart()
  {

// Declare an integer array
   int myArray[] = {10, 5, 8, 3, 12};

// Find the index of the minimum element in the entire array
   int minIndex = ArrayMinimum(myArray, 0, WHOLE_ARRAY);

// Print the result
   Print("Index of the minimum element: ", minIndex);

  }

就像在 "ArrayMaximum()" 中一样，这段代码将找出整个 "myArray" 中最小元素的索引，并打印结果。

结论

在本文中，我们讨论了 MQL5 中的数组函数世界，揭示了它们的功能和应用。从搜索和复制到调整时间序列数组的大小和处理，我们探索了各种函数，包括 ArrayBsearch、ArrayCopy、ArrayCompare、ArrayResize、ArrayFree、ArraySetAsSeries、ArrayGetAsSeries、ArrayInitialize、ArrayFill、ArrayIsDynamic、ArrayIsSeries、ArrayMaximum 和 ArrayMinimum。每个函数在操作数组和增强交易算法功能方面都发挥着至关重要的作用。

在结束本文时，需要注意的是，我故意没有涵盖所有数组函数，以确保学习重点突出，易于消化。接下来的文章将扩展我们的其他数组函数，如 ArrayPrint、ArrayRange、ArrayInsert、ArrayRemove、ArrayReverse、ArraySize、ArraySort、ArraySwap、ArrayToFP16、ArrayToFP8、ArrayFromFP16 和 ArrayFromFP8。这种循序渐进的方法旨在促进更平滑的学习曲线。下一期，我们将继续探索 MQL5 数组函数！