อธิบายฟังก์ชัน ArraySort ของ MQL4 | วิธีใช้และตัวอย่าง

1 1. แนะนำ
- 1.1 ความสำคัญของ MQL4 และการจัดการอาร์เรย์
- 1.2 วัตถุประสงค์ของบทความนี้
2 2. ฟังก์ชัน ArraySort คืออะไร?
3 3. วิธีการใช้งานพื้นฐาน
- 3.1 เรียงลำดับอาร์เรย์แบบง่าย
  - 3.1.1 เรียงลำดับจากน้อยไปมาก
  - 3.1.2 เรียงลำดับจากมากไปน้อย
- 3.2 กำหนดตำแหน่งเริ่มต้นของการเรียง
4 4. การประยุกต์ใช้ฟังก์ชัน ArraySort
5 5. ข้อจำกัดและข้อควรระวังของฟังก์ชัน ArraySort
6 6. ตัวอย่างการใช้งานจริง
- 6.1 การจัดเรียงข้อมูลประวัติการเทรด
  - 6.1.1 ตัวอย่างโค้ดจริง
- 6.2 การใช้งานในตัวบ่งชี้แบบกำหนดเอง
7 7. คำถามที่พบบ่อย (FAQ)
8 8. สรุปและขั้นตอนต่อไป
- 8.1 ArraySort ฟังก์ชันสรุปประเด็นสำคัญ
- 8.2 ขั้นตอนต่อไป
9 เว็บไซต์อ้างอิง

1. แนะนำ

ความสำคัญของ MQL4 และการจัดการอาร์เรย์

MQL4 เป็นภาษาโปรแกรมสำหรับสร้างโปรแกรมการซื้อขายอัตโนมัติ (EA) และตัวบ่งชี้กำหนดเองบนแพลตฟอร์ม MetaTrader 4 (MT4) การวิเคราะห์ข้อมูลและการทำให้กลยุทธ์การเทรดเป็นอัตโนมัติในตลาดการเงิน MQL4 ทำให้ทักษะการจัดการอาร์เรย์เป็นสิ่งสำคัญมาก เพราะอาร์เรย์เป็นโครงสร้างข้อมูลพื้นฐานที่ใช้จัดการข้อมูลราคาและค่าตัวบ่งชี้อย่างมีประสิทธิภาพ

ในนั้น ฟังก์ชัน ArraySort เป็นเครื่องมือที่สะดวกในการจัดเรียงสมาชิกของอาร์เรย์ การเข้าใจและใช้ฟังก์ชันนี้อย่างถูกต้องจะช่วยเพิ่มประสิทธิภาพกลยุทธ์การเทรดและการวิเคราะห์ข้อมูล

วัตถุประสงค์ของบทความนี้

บทความนี้จะอธิบายอย่างละเอียดเกี่ยวกับฟังก์ชัน ArraySort ของ MQL4 ตั้งแต่วิธีใช้พื้นฐานจนถึงการประยุกต์ใช้ขั้นสูง ทำให้ผู้เริ่มต้นเข้าใจง่าย พร้อมตัวอย่างปฏิบัติจริง

2. ฟังก์ชัน ArraySort คืออะไร?

ภาพรวมของฟังก์ชัน ArraySort

ฟังก์ชัน ArraySort เป็นฟังก์ชันในตัวที่ใช้ใน MQL4 เพื่อจัดเรียงอาร์เรย์ในลำดับเพิ่มหรือลด การจัดเรียงนี้สามารถใช้กับข้อมูลราคาและข้อมูลเวลา รวมถึงการจัดเรียงตามเงื่อนไขกำหนดเองได้

ด้านล่างเป็นไวยากรณ์ของฟังก์ชันนี้

int ArraySort(
    void &array[],
    int count=WHOLE_ARRAY,
    int start=0,
    int direction=MODE_ASCEND
);

คำอธิบายพารามิเตอร์หลัก

array[]:
กำหนดอาร์เรย์ที่เป็นเป้าหมายของการจัดเรียง อาร์เรย์นี้ต้องเป็นมิติเดียว
count:
กำหนดจำนวนสมาชิกที่ต้องการจัดเรียง โดยค่าเริ่มต้นคืออาร์เรย์ทั้งหมด (WHOLE_ARRAY)
start:
กำหนดดัชนีเริ่มต้นของการจัดเรียง ค่าเริ่มต้นคือ 0 (ตำแหน่งแรกของอาร์เรย์)
direction:
กำหนดทิศทางการจัดเรียง

MODE_ASCEND: ลำดับเพิ่ม (จากน้อยไปหามาก)
MODE_DESCEND: ลำดับลด (จากมากไปหาน้อย)

ตัวอย่างการใช้งาน: การจัดเรียงพื้นฐาน

ด้านล่างเป็นตัวอย่างการจัดเรียงลำดับเพิ่มพื้นฐาน

double prices[] = {1.2345, 1.1234, 1.5678, 1.3456};
ArraySort(prices);

// หลังจัดเรียง: {1.1234, 1.2345, 1.3456, 1.5678}

ในโค้ดนี้ เราใช้ฟังก์ชัน ArraySort เพื่อจัดเรียงข้อมูลราคาในลำดับเพิ่ม

3. วิธีการใช้งานพื้นฐาน

เรียงลำดับอาร์เรย์แบบง่าย

วิธีการพื้นฐานที่สุดคือการเรียงลำดับอาร์เรย์เดียวในลำดับจากน้อยไปมากหรือมากไปน้อย ตัวอย่างด้านล่างแสดงให้เห็น。

เรียงลำดับจากน้อยไปมาก

double values[] = {5.5, 2.2, 8.8, 1.1};
ArraySort(values);

// หลังจากเรียง: {1.1, 2.2, 5.5, 8.8}

เรียงลำดับจากมากไปน้อย

double values[] = {5.5, 2.2, 8.8, 1.1};
ArraySort(values, WHOLE_ARRAY, 0, MODE_DESCEND);

// หลังจากเรียง: {8.8, 5.5, 2.2, 1.1}

กำหนดตำแหน่งเริ่มต้นของการเรียง

โค้ดด้านล่างแสดงตัวอย่างการเรียงเฉพาะส่วนที่กำหนด。

double data[] = {9.9, 7.7, 3.3, 5.5};
ArraySort(data, 2, 1); // เรียง 2 องค์ประกอบจากดัชนี 1

// หลังจากเรียง: {9.9, 3.3, 7.7, 5.5}

ในโค้ดนี้ จะเริ่มจากดัชนี 1 (7.7) แล้วเรียง 2 องค์ประกอบ (7.7 และ 3.3) ในลำดับจากน้อยไปมาก。

4. การประยุกต์ใช้ฟังก์ชัน ArraySort

ตัวอย่างเงื่อนไขการเรียงลำดับที่ซับซ้อน

ArraySortฟังก์ชันมีประโยชน์มากเมื่อทำการเรียงลำดับตามเงื่อนไขเฉพาะ นอกจากการเรียงลำดับแบบเพิ่มขึ้นและลดลงพื้นฐาน เช่น การเรียงลำดับโดยผสมผสานราคาและเวลา

ตัวอย่างการเรียงลำดับด้วยหลายเงื่อนไข

โค้ดด้านล่างเป็นตัวอย่างการเรียงลำดับข้อมูลวันที่และราคา

// ข้อมูลวันที่และราคา
datetime dates[] = {20221101, 20221103, 20221102};
double prices[] = {1.2345, 1.1234, 1.3456};

// เรียงลำดับวันที่แบบเพิ่มขึ้นและทำให้ข้อมูลราคาติดตามกัน
ArraySort(dates); // เรียงลำดับวันที่

// ทำการจัดเรียงข้อมูลราคาโดยอ้างอิงวันที่ด้วยตนเอง
double sorted_prices[ArraySize(prices)];
for (int i = 0; i < ArraySize(prices); i++)
{
    int index = ArrayBsearch(dates, dates[i], 0, WHOLE_ARRAY);
    sorted_prices[i] = prices[index];
}

// หลังจากเรียงลำดับ:
// dates: {20221101, 20221102, 20221103}
// sorted_prices: {1.2345, 1.3456, 1.1234}

ในตัวอย่างนี้ เราใช้ ArraySort และ ArrayBsearch ร่วมกันเพื่อทำการเรียงลำดับโดยรักษาการเชื่อมโยงของข้อมูล

การเรียงลำดับบางส่วนของอาร์เรย์หลายมิติ

ใน MQL4 ไม่สามารถเรียงลำดับอาร์เรย์หลายมิติได้โดยตรง แต่โดยทั่วไปจะทำการดึงคอลัมน์หรือแถวที่ต้องการออกเป็นอาร์เรย์ 1 มิติแล้วทำการเรียงลำดับและสร้างใหม่

ตัวอย่างการเรียงลำดับอาร์เรย์หลายมิติ

// อาร์เรย์หลายมิติ (แถว: วันที่, คอลัมน์: ราคา)
double data[][2] = {{20221101, 1.2345}, {20221103, 1.1234}, {20221102, 1.3456}};

// เรียงลำดับโดยอ้างอิงวันที่
double temp[3]; // อาร์เรย์ 1 มิติชั่วคราว
for (int i = 0; i < ArraySize(data); i++)
    temp[i] = data[i][0]; // ดึงวันที่ออกมา

ArraySort(temp); // เรียงลำดับวันที่แบบเพิ่มขึ้น

// สร้างอาร์เรย์หลายมิติใหม่ตามผลการเรียงลำดับ
double sorted_data[3][2];
for (int i = 0; i < ArraySize(temp); i++)
{
    for (int j = 0; j < ArraySize(data); j++)
    {
        if (temp[i] == data[j][0])
        {
            sorted_data[i][0] = data[j][0];
            sorted_data[i][1] = data[j][1];
            break;
        }
    }
}

// หลังจากเรียงลำดับ: {{20221101, 1.2345}, {20221102, 1.3456}, {20221103, 1.1234}}

การเรียงลำดับที่ใส่ใจประสิทธิภาพ

เมื่อจัดการกับข้อมูลจำนวนมาก ประสิทธิภาพของการเรียงลำดับจึงสำคัญ ด้านล่างนี้เป็นเคล็ดลับในการใช้ฟังก์ชัน ArraySort อย่างมีประสิทธิภาพ

กรองข้อมูลที่ไม่จำเป็นล่วงหน้า:
โดยการลบองค์ประกอบที่ไม่จำเป็นในอาร์เรย์ จะทำให้ขนาดของข้อมูลที่ต้องเรียงลดลง。

   ArrayResize(array, count); // ปรับขนาดเป็นขนาดที่จำเป็น

จำกัดขอบเขตการเรียงลำดับ:
โดยไม่เรียงลำดับทั้งอาร์เรย์ แต่เฉพาะส่วนที่จำเป็นเท่านั้น จะลดจำนวนการคำนวณ。

   ArraySort(array, 50, 10); // เรียงลำดับจากตำแหน่งที่ 10 ถึง 50 เท่านั้น

ใช้ชนิดข้อมูลที่เหมาะสม:
การเลือกชนิดข้อมูลอย่างเหมาะสมจะช่วยเพิ่มประสิทธิภาพการใช้หน่วยความจำ (เช่น ใช้ float แทน double)

5. ข้อจำกัดและข้อควรระวังของฟังก์ชัน ArraySort

ข้อจำกัดเกี่ยวกับประเภทของอาร์เรย์

ArraySort ฟังก์ชันสามารถใช้ได้กับประเภทข้อมูลเฉพาะเท่านั้น กรุณาใส่ใจในข้อดังต่อไปนี้。

ประเภทข้อมูลที่รองรับ:

ประเภทตัวเลข（int, double, float）: สามารถจัดเรียงได้
ประเภทข้อความ（string）: สามารถจัดเรียงได้
ประเภทอื่น ๆ (ตัวอย่าง: bool, datetime) : สามารถจัดเรียงได้ แต่ต้องระวังความหมายของลำดับ

กรณีที่การจัดเรียงไม่สามารถทำได้:
ไม่สามารถใช้ ArraySort โดยตรงกับอาร์เรย์หลายมิติได้ ต้องดึงคอลัมน์หรือแถวเฉพาะของอาร์เรย์หลายมิติออกเป็นอาร์เรย์หนึ่งมิติแล้วจัดเรียงและสร้างใหม่。

ตัวอย่าง: อาร์เรย์หลายมิติที่ไม่รองรับ

double matrix[][2] = {{1.2, 2.3}, {3.4, 4.5}};
// ArraySort(matrix); // จะเกิดข้อผิดพลาด

ความน่าเชื่อถือของผลลัพธ์การจัดเรียง

ArraySort หากใช้กับค่าที่ซ้ำกันหลายค่า ลำดับจะไม่รับประกัน เราเรียกว่าการจัดเรียงที่ไม่เสถียร (หลังจากจัดเรียงลำดับของค่าที่เหมือนกันจะไม่ถูกเก็บรักษา)

ตัวอย่าง: กรณีที่ไม่ใช่การจัดเรียงที่เสถียร

double array[] = {2.2, 1.1, 2.2, 3.3};
ArraySort(array);
// ผลลัพธ์การจัดเรียง: {1.1, 2.2, 2.2, 3.3} (ลำดับจะไม่ถูกเก็บรักษา)

หากจำเป็น คุณต้องเพิ่มเงื่อนไขของคุณเองเพื่อทำให้มีพฤติกรรมคล้ายกับการจัดเรียงที่เสถียร

การจัดการข้อผิดพลาด

ArraySort ฟังก์ชันมักจะไม่ล้มเหลว แต่สถานะของอาร์เรย์หรือข้อผิดพลาดในการตั้งค่าพารามิเตอร์อาจทำให้เกิดข้อผิดพลาดได้ ด้านล่างเป็นตัวอย่างข้อผิดพลาดและสาเหตุ

กรณีที่อาร์เรย์ว่างเปล่า:
ถ้าอาร์เรย์ว่างเปล่า (ArraySize(array) == 0) การจัดเรียงจะไม่ทำ。

   double emptyArray[];
   ArraySort(emptyArray); // ไม่ได้จัดเรียง

การระบุดัชนีที่ไม่ถูกต้อง:
หากช่วงการจัดเรียง ( start และ count ) เกินขนาดของอาร์เรย์ จะเกิดพฤติกรรมที่ไม่คาดคิด。

   double array[] = {5.0, 3.0, 1.0};
   ArraySort(array, 5, 2); // เป็นสาเหตุของข้อผิดพลาดหรือพฤติกรรมที่ไม่ถูกต้อง

ตัวอย่างโค้ดเพื่อป้องกันข้อผิดพลาด

double array[] = {1.0, 2.0, 3.0};
int size = ArraySize(array);

if (size > 0) {
   ArraySort(array, size, 0, MODE_ASCEND);
} else {
   Print("อาร์เรย์ว่างเปล่า");
}

ปัญหาด้านประสิทธิภาพ

เมื่อจัดเรียงข้อมูลจำนวนมาก ต้องใส่ใจในความซับซ้อนของอัลกอริทึมการจัดเรียง (O(n log n)) วิธีต่อไปนี้สามารถปรับปรุงประสิทธิภาพได้

การจัดเรียงบางส่วน:
การจัดเรียงเฉพาะส่วนที่จำเป็นเพื่อลดความซับซ้อน。

   ArraySort(array, 50); // จัดเรียง 50 รายการแรกเท่านั้น

กรองข้อมูลล่วงหน้า:
ลบข้อมูลที่ไม่จำเป็นออกก่อนการจัดเรียง。

   ArrayResize(array, newSize);

ใช้ประเภทข้อมูลที่เหมาะสม:
การเลือกประเภทข้อมูลอย่างเหมาะสมจะช่วยเพิ่มประสิทธิภาพการใช้หน่วยความจำ (เช่น ใช้ float แทน double)

6. ตัวอย่างการใช้งานจริง

การจัดเรียงข้อมูลประวัติการเทรด

ด้านล่างเป็นตัวอย่างการจัดเรียงข้อมูลประวัติการเทรดโดยใช้ ArraySort

ตัวอย่างโค้ดจริง

// ข้อมูลประวัติการเทรด (วันที่และจำนวนกำไร)
datetime tradeDates[] = {20221102, 20221101, 20221103};
double profits[] = {100.0, 50.0, 150.0};

// จัดเรียงวันที่ตามลำดับเพิ่มขึ้นและเชื่อมโยงจำนวนกำไร
ArraySort(tradeDates);

double sorted_profits[ArraySize(profits)];
for (int i = 0; i < ArraySize(tradeDates); i++) {
   int index = ArrayBsearch(tradeDates, tradeDates[i], 0, WHOLE_ARRAY);
   sorted_profits[i] = profits[index];
}

// หลังจากจัดเรียง:
// tradeDates: {20221101, 20221102, 20221103}
// sorted_profits: {50.0, 100.0, 150.0}

การใช้งานในตัวบ่งชี้แบบกำหนดเอง

ตัวอย่างเช่น คุณสามารถใช้ ArraySort เพื่อจัดเรียงค่าเฉลี่ยเคลื่อนที่ตามเงื่อนไขที่กำหนด

7. คำถามที่พบบ่อย (FAQ)

วิธีการจัดเรียงเฉพาะบางส่วนของอาร์เรย์คืออะไร?

โดยใช้พารามิเตอร์ start และ count ของฟังก์ชัน ArraySort คุณสามารถจัดเรียงเฉพาะบางส่วนของอาร์เรย์ได้.

ตัวอย่าง: จัดเรียงบางส่วนของอาร์เรย์

double data[] = {9.0, 3.0, 7.0, 1.0, 5.0};
ArraySort(data, 3, 1); // จัดเรียง 3 องค์ประกอบจากดัชนี 1 เป็นลำดับเพิ่ม

// หลังการจัดเรียง: {9.0, 1.0, 3.0, 7.0, 5.0}

ในตัวอย่างนี้ จะเริ่มจากดัชนี 1 (3.0) และจัดเรียงเฉพาะ 3 องค์ประกอบ.

การจัดเรียงแบบลดลงทำงานไม่ถูกต้อง ทำอย่างไร?

เมื่อทำการจัดเรียงแบบลดลง คุณต้องระบุพารามิเตอร์ direction เป็น MODE_DESCEND หากไม่ได้ระบุ จะใช้ค่าเริ่มต้นเป็นลำดับเพิ่ม.

ตัวอย่างการจัดเรียงแบบลดลงที่ถูกต้อง

double data[] = {2.2, 3.3, 1.1};
ArraySort(data, WHOLE_ARRAY, 0, MODE_DESCEND);

// หลังการจัดเรียง: {3.3, 2.2, 1.1}

หมายเหตุ: หากไม่ได้ระบุ MODE_DESCEND ผลลัพธ์อาจเป็นลำดับที่ไม่คาดคิด.

มีวิธีประมวลผลอาร์เรย์หลายมิติอย่างมีประสิทธิภาพไหม?

ใน MQL4 ฟังก์ชัน ArraySort ไม่รองรับอาร์เรย์หลายมิติโดยตรง ดังนั้นเราขอแนะนำวิธีต่อไปนี้เพื่อประมวลผลอย่างมีประสิทธิภาพ.

วิธีที่ 1: แปลงเป็นอาร์เรย์ 1 มิติแล้วจัดเรียง

เลือกคอลัมน์หรือแถวเฉพาะของอาร์เรย์หลายมิติเป็นอาร์เรย์ 1 มิติแล้วจัดเรียง.

วิธีที่ 2: สร้างใหม่คอลัมน์ที่จัดเรียงตามดัชนี

ตัวอย่างต่อไปนี้จัดเรียงอาร์เรย์หลายมิติโดยใช้คอลัมน์ที่ 2 (ข้อมูลราคา) เป็นเกณฑ์.

double data[][2] = {{1.0, 3.3}, {2.0, 1.1}, {3.0, 2.2}};
double temp[ArraySize(data)];

// ดึงคอลัมน์ที่ 2 (ข้อมูลราคา) แล้วจัดเรียง
for (int i = 0; i < ArraySize(data); i++) {
   temp[i] = data[i][1];
}
ArraySort(temp); // จัดเรียงราคาเป็นลำดับเพิ่ม

// สร้างอาร์เรย์หลายมิติใหม่ตามผลลัพธ์การจัดเรียง
double sorted_data[ArraySize(data)][2];
for (int i = 0; i < ArraySize(temp); i++) {
   for (int j = 0; j < ArraySize(data); j++) {
       if (temp[i] == data[j][1]) {
           sorted_data[i][0] = data[j][0];
           sorted_data[i][1] = data[j][1];
           break;
       }
   }
}

// หลังการจัดเรียง:
// sorted_data: {{2.0, 1.1}, {3.0, 2.2}, {1.0, 3.3}}

มีวิธีป้องกันข้อผิดพลาดเมื่ออาร์เรย์ว่างไหม?

ArraySort ไม่ทำงานกับอาร์เรย์ว่าง ดังนั้นคุณต้องตรวจสอบว่ามันว่างหรือไม่ล่วงหน้า.

ตัวอย่างการตรวจสอบว่ามันว่างหรือไม่

double data[];

if (ArraySize(data) > 0) {
   ArraySort(data);
} else {
   Print("อาร์เรย์ว่าง.");
}

สามารถจัดการค่าซ้ำในอาร์เรย์ได้อย่างถูกต้องไหม?

ArraySort สามารถจัดเรียงค่าซ้ำในอาร์เรย์ได้อย่างถูกต้อง แต่ลำดับของค่าซ้ำหลายตัวไม่รับประกัน (การจัดเรียงไม่เสถียร) หากต้องการการจัดเรียงเสถียร คุณต้องปรับด้วยตนเองตามตัวอย่างต่อไปนี้.

ตัวอย่างการรักษาลำดับด้วยตนเอง

// บันทึกค่าภายในอาร์เรย์และดัชนีต้นฉบับ
double data[] = {2.2, 1.1, 2.2, 3.3};
int indexes[ArraySize(data)];
for (int i = 0; i < ArraySize(data); i++) {
   indexes[i] = i;
}

// สร้างฟังก์ชันช่วยสำหรับการจัดเรียงและดำเนินการจัดเรียงแบบกำหนดเอง
// หลังการจัดเรียง สร้างดัชนีต้นฉบับใหม่

8. สรุปและขั้นตอนต่อไป

ArraySort ฟังก์ชันสรุปประเด็นสำคัญ

บทบาทพื้นฐาน:
ArraySortฟังก์ชันเป็นเครื่องมือที่สะดวกในการจัดเรียงอาร์เรย์ตามลำดับจากน้อยไปมากหรือมากไปน้อย
ฟังก์ชันหลัก:
การจัดเรียงส่วนของอาร์เรย์ การจัดเรียงตามเงื่อนไขเฉพาะ การจัดการอาร์เรย์หลายมิติแบบอ้อม ๆ ฯลฯ สามารถใช้ได้ในหลายกรณี
ข้อจำกัดและข้อควรระวัง:
มีข้อจำกัดบางประการ เช่น ประเภทของอาร์เรย์ การจัดการอาร์เรย์หลายมิติ และการที่การจัดเรียงแบบเสถียรไม่รับประกัน

ขั้นตอนต่อไป

เพื่อเพิ่มความเข้าใจในการจัดการอาร์เรย์ใน MQL4 เราขอแนะนำให้เรียนรู้เนื้อหาต่อไปนี้

ArrayResizeฟังก์ชัน:
ทำความเข้าใจวิธีการเปลี่ยนขนาดอาร์เรย์ เพื่อให้สามารถจัดการข้อมูลแบบไดนามิกได้
ArrayCopyฟังก์ชัน:
คัดลอกอาร์เรย์อย่างมีประสิทธิภาพ เพื่อขยายขอบเขตการจัดการข้อมูล
การดำเนินการตรรกะการจัดเรียงแบบกำหนดเอง:
เทคนิคการประยุกต์ใช้เมื่อจำเป็นต้องใช้เงื่อนไขการจัดเรียงที่ซับซ้อน

ในขั้นตอนต่อไป ลองใช้ ArraySort อย่างปฏิบัติใน EA ของคุณ โดยอ้างอิงบทความอื่น ๆ และเอกสารทางการ

เว็บไซต์อ้างอิง

ArraySort - Array Functions - MQL4 Reference

ArraySort - Array Functions - MQL4 Reference…

EXPO blog 投資の翼

まとめ（配列操作の基本）｜MQL4プログラミング | EXPO blog 投資の翼

配列操作の重要性 MQL4における配列操作は、効率的なプログラム作成の鍵です。配列を使用することで、大量のデータを一元管…