GlobalTradeCraft

【無料登録】収益を目指すためのFX自動売買ノウハウをあなたに！

Giải Thích Chi Tiết Hàm ArraySort Trong MQL4 | Từ Cách Dùng Đến Ví Dụ Nâng Cao

Phát triển MQL (MQL4/MQL5)
目次

1. Giới thiệu

Tầm quan trọng của MQL4 và thao tác mảng

MQL4 là ngôn ngữ lập trình dùng để tạo chương trình giao dịch tự động (EA) và chỉ báo tùy chỉnh trên nền tảng MetaTrader 4 (MT4). Trong MQL4, vốn thực hiện phân tích dữ liệu thị trường tài chính và tự động hóa chiến lược giao dịch, kỹ năng thao tác mảng rất quan trọng. Vì mảng là cấu trúc dữ liệu cơ bản để quản lý hiệu quả dữ liệu giá và giá trị chỉ báo.

Trong số đó, hàm ArraySort là công cụ tiện lợi để sắp xếp các phần tử của mảng. Bằng cách hiểu và sử dụng đúng hàm này, bạn có thể hiệu quả hóa chiến lược giao dịch và phân tích dữ liệu.

Mục đích của bài viết này

Trong bài viết này, chúng tôi sẽ giải thích chi tiết về hàm ArraySort của MQL4, từ cách sử dụng cơ bản đến các phương pháp ứng dụng nâng cao. Chúng tôi sẽ tiến hành một cách dễ hiểu cho người mới bắt đầu, kết hợp với các ví dụ thực tế.

2. Hàm ArraySort là gì?

Tổng quan về hàm ArraySort

ArraySort là một hàm tích hợp trong MQL4 dùng để sắp xếp mảng theo thứ tự tăng dần hoặc giảm dần. Quá trình sắp xếp có thể được sử dụng để sắp xếp dữ liệu giá cả hoặc dữ liệu thời gian, cũng như sắp xếp theo các điều kiện tùy chỉnh.

Dưới đây là cú pháp của hàm này.

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

Giải thích các tham số chính

  1. array[]:
    Chỉ định mảng là đối tượng sắp xếp. Mảng này phải là mảng một chiều.
  2. count:
    Chỉ định số lượng phần tử để sắp xếp. Mặc định là toàn bộ mảng (WHOLE_ARRAY).
  3. start:
    Chỉ định chỉ số bắt đầu sắp xếp. Mặc định là 0 (phần đầu mảng).
  4. direction:
    Chỉ định hướng sắp xếp.
  • MODE_ASCEND: Tăng dần (từ nhỏ đến lớn)
  • MODE_DESCEND: Giảm dần (từ lớn đến nhỏ)

Ví dụ sử dụng: Sắp xếp cơ bản

Dưới đây là ví dụ về sắp xếp tăng dần cơ bản.

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

// Sau khi sắp xếp: {1.1234, 1.2345, 1.3456, 1.5678}

Trong mã này, hàm ArraySort được sử dụng để sắp xếp dữ liệu giá theo thứ tự tăng dần.

{“translated_html”: “

3. Cách sử dụng cơ bản

Sắp xếp mảng đơn giản

Cách sử dụng cơ bản nhất là sắp xếp một mảng đơn lẻ theo thứ tự tăng dần hoặc giảm dần. Dưới đây là ví dụ về điều đó.

Sắp xếp tăng dần

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

// Sau khi sắp xếp: {1.1, 2.2, 5.5, 8.8}

Sắp xếp giảm dần

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

// Sau khi sắp xếp: {8.8, 5.5, 2.2, 1.1}

Chỉ định vị trí bắt đầu sắp xếp

Mã code dưới đây cho thấy ví dụ sắp xếp chỉ một phần cụ thể.

double data[] = {9.9, 7.7, 3.3, 5.5};
ArraySort(data, 2, 1); // Sắp xếp 2 phần tử từ chỉ số 1

// Sau khi sắp xếp: {9.9, 3.3, 7.7, 5.5}

Trong mã code này, bắt đầu từ chỉ số 1 (7.7), 2 phần tử (7.7 và 3.3) được sắp xếp theo thứ tự tăng dần.

“}

4. Ứng dụng của hàm ArraySort

Ví dụ về điều kiện sắp xếp phức tạp

Hàm ArraySort rất hữu ích không chỉ cho việc sắp xếp tăng dần hoặc giảm dần cơ bản mà còn khi thực hiện sắp xếp theo các điều kiện cụ thể. Ví dụ, có thể nghĩ đến tình huống sắp xếp kết hợp giá cả và thời gian.

Ví dụ sắp xếp theo nhiều điều kiện

Mã code sau là ví dụ sắp xếp dữ liệu ngày tháng và giá cả.

// Dữ liệu ngày tháng và dữ liệu giá cả
datetime dates[] = {20221101, 20221103, 20221102};
double prices[] = {1.2345, 1.1234, 1.3456};

// Sắp xếp ngày tháng tăng dần và liên kết dữ liệu giá cả
ArraySort(dates); // Sắp xếp ngày tháng

// Cấu trúc lại dữ liệu giá cả thủ công dựa trên ngày tháng
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];
}

// Sau khi sắp xếp:
// dates: {20221101, 20221102, 20221103}
// sorted_prices: {1.2345, 1.3456, 1.1234}

Trong ví dụ này, kết hợp ArraySort và ArrayBsearch để thực hiện sắp xếp trong khi duy trì sự liên kết của dữ liệu.

Sắp xếp một phần mảng đa chiều

Trong MQL4, không thể sắp xếp trực tiếp mảng đa chiều. Tuy nhiên, phương pháp phổ biến là trích xuất các cột hoặc hàng cần thiết vào mảng một chiều, sắp xếp và sau đó tái cấu trúc.

Ví dụ sắp xếp mảng đa chiều

// Mảng đa chiều (hàng: ngày tháng, cột: giá cả)
double data[][2] = {{20221101, 1.2345}, {20221103, 1.1234}, {20221102, 1.3456}};

// Sắp xếp dựa trên ngày tháng
double temp[3]; // Mảng một chiều tạm thời
for (int i = 0; i < ArraySize(data); i++)
    temp[i] = data[i][0]; // Trích xuất ngày tháng

ArraySort(temp); // Sắp xếp ngày tháng tăng dần

// Tái cấu trúc mảng đa chiều dựa trên kết quả sắp xếp
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;
        }
    }
}

// Sau khi sắp xếp: {{20221101, 1.2345}, {20221102, 1.3456}, {20221103, 1.1234}}

Sắp xếp chú ý đến hiệu suất

Khi xử lý lượng dữ liệu lớn, hiệu suất sắp xếp rất quan trọng. Dưới đây là các mẹo để sử dụng hàm ArraySort một cách hiệu quả.

  1. Lọc dữ liệu không cần thiết trước:
    Bằng cách xóa các phần tử không cần thiết trong mảng, giảm thiểu đối tượng sắp xếp.
   ArrayResize(array, count); // Thay đổi kích thước theo kích thước cần thiết
  1. Giới hạn phạm vi sắp xếp:
    Thay vì sắp xếp toàn bộ mảng, chỉ sắp xếp phần cần thiết để giảm lượng tính toán.
   ArraySort(array, 50, 10); // Chỉ sắp xếp 50 phần tử từ vị trí 10
  1. Sử dụng kiểu dữ liệu phù hợp:
    Bằng cách chọn kiểu dữ liệu phù hợp, tối ưu hóa sử dụng bộ nhớ (ví dụ: sử dụng float thay vì double).

5. Giới hạn và lưu ý của hàm ArraySort

Ràng buộc liên quan đến kiểu dữ liệu của mảng

Hàm ArraySort chỉ có thể sử dụng với các kiểu dữ liệu cụ thể. Vui lòng chú ý các điểm sau.

  1. Các kiểu dữ liệu được hỗ trợ:
  • Kiểu số (int, double, float): Có thể sắp xếp
  • Kiểu chuỗi (string): Có thể sắp xếp
  • Các kiểu khác (ví dụ: bool, datetime): Có thể sắp xếp nhưng cần chú ý đến ý nghĩa của thứ tự
  1. Trường hợp sắp xếp không hợp lệ:
    Không thể áp dụng trực tiếp ArraySort cho mảng đa chiều. Cần trích xuất các cột hoặc hàng cụ thể của mảng đa chiều thành mảng một chiều để sắp xếp và tái cấu trúc.

Ví dụ: Mảng đa chiều không được hỗ trợ

double matrix[][2] = {{1.2, 2.3}, {3.4, 4.5}};
// ArraySort(matrix); // Sẽ gây lỗi

Độ tin cậy của kết quả sắp xếp

Khi sử dụng ArraySort, nếu có nhiều giá trị giống nhau, thứ tự của chúng không được đảm bảo. Điều này được gọi là không phải sắp xếp ổn định (sắp xếp ổn định là thứ tự của các giá trị giống nhau được giữ nguyên sau khi sắp xếp).

Ví dụ: Trường hợp không phải sắp xếp ổn định

double array[] = {2.2, 1.1, 2.2, 3.3};
ArraySort(array);
// Kết quả sắp xếp: {1.1, 2.2, 2.2, 3.3} (thứ tự không được giữ nguyên)

Nếu cần, cần triển khai hành vi giống như sắp xếp ổn định bằng cách thêm điều kiện riêng.

Xử lý lỗi

Hàm ArraySort ít khi thất bại, nhưng lỗi có thể xảy ra do trạng thái mảng hoặc lỗi thiết lập tham số. Dưới đây là các lỗi điển hình và nguyên nhân của chúng.

  1. Trường hợp mảng rỗng:
    Nếu mảng rỗng (ArraySize(array) == 0), sắp xếp sẽ không được thực hiện.
   double emptyArray[];
   ArraySort(emptyArray); // Không được sắp xếp
  1. Chỉ định chỉ số không hợp lệ:
    Nếu phạm vi sắp xếp (start và count) vượt quá kích thước mảng, sẽ xảy ra hành vi không mong muốn.
   double array[] = {5.0, 3.0, 1.0};
   ArraySort(array, 5, 2); // Gây ra lỗi hoặc hành vi không hợp lệ

Ví dụ mã để ngăn ngừa lỗi

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

if (size > 0) {
   ArraySort(array, size, 0, MODE_ASCEND);
} else {
   Print("Mảng rỗng");
}

Vấn đề hiệu suất

Khi sắp xếp lượng dữ liệu lớn, cần chú ý đến độ phức tạp tính toán của thuật toán sắp xếp (O(n log n)). Có thể cải thiện hiệu suất bằng các phương pháp sau.

  1. Sắp xếp một phần:
    Bằng cách chỉ sắp xếp phần cần thiết, giảm độ phức tạp tính toán.
   ArraySort(array, 50); // Chỉ sắp xếp 50 phần tử đầu tiên
  1. Lọc dữ liệu trước:
    Loại bỏ dữ liệu không cần thiết trước khi sắp xếp.
   ArrayResize(array, newSize);
  1. Sử dụng kiểu dữ liệu phù hợp:
    Bằng cách chọn kiểu dữ liệu phù hợp, tối ưu hóa sử dụng bộ nhớ (ví dụ: sử dụng float thay vì double).

6. Các ví dụ sử dụng thực tế

Sắp xếp dữ liệu lịch sử giao dịch

Dưới đây là ví dụ về việc sắp xếp dữ liệu lịch sử giao dịch bằng cách sử dụngArraySort.

Ví dụ mã thực tế

// Dữ liệu lịch sử giao dịch (ngày giờ và số tiền lợi nhuận)
datetime tradeDates[] = {20221102, 20221101, 20221103};
double profits[] = {100.0, 50.0, 150.0};

// Sắp xếp ngày theo thứ tự tăng dần và liên kết số tiền lợi nhuận
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];
}

// Sau khi sắp xếp:
// tradeDates: {20221101, 20221102, 20221103}
// sorted_profits: {50.0, 100.0, 150.0}

Sử dụng trong chỉ báo tùy chỉnh

Ví dụ, bạn cũng có thể sử dụngArraySort khi sắp xếp lại các giá trị trung bình động dựa trên các điều kiện cụ thể.

7. Câu hỏi thường gặp (FAQ)

Làm thế nào để sắp xếp chỉ một phần của mảng?

Bằng cách sử dụng tham số start và tham số count của hàm ArraySort, bạn có thể sắp xếp chỉ một phần của mảng.

Ví dụ: Sắp xếp một phần của mảng

double data[] = {9.0, 3.0, 7.0, 1.0, 5.0};
ArraySort(data, 3, 1); // Sắp xếp tăng dần 3 phần tử từ chỉ số 1

// Sau khi sắp xếp: {9.0, 1.0, 3.0, 7.0, 5.0}

Trong ví dụ này, chỉ 3 phần tử bắt đầu từ chỉ số 1 (3.0) được sắp xếp.

Sắp xếp giảm dần không hoạt động đúng. Làm thế nào?

Khi thực hiện sắp xếp giảm dần, bạn cần chỉ định MODE_DESCEND trong tham số direction. Nếu không chỉ định, nó sẽ mặc định là tăng dần.

Ví dụ đúng cho sắp xếp giảm dần

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

// Sau khi sắp xếp: {3.3, 2.2, 1.1}

Lưu ý: Nếu không chỉ định MODE_DESCEND, kết quả có thể ở thứ tự không mong muốn.

Có cách nào để xử lý mảng đa chiều một cách hiệu quả không?

Trong MQL4, hàm ArraySort không hỗ trợ trực tiếp mảng đa chiều, do đó chúng tôi khuyến nghị xử lý hiệu quả bằng các phương pháp như sau.

Phương pháp 1: Chuyển đổi thành mảng 1 chiều và sắp xếp

Trích xuất các cột hoặc hàng cụ thể của mảng đa chiều dưới dạng mảng 1 chiều và sắp xếp nó.

Phương pháp 2: Tái cấu trúc cột mục tiêu sắp xếp dựa trên chỉ số

Trong ví dụ sau, mảng đa chiều được sắp xếp dựa trên cột thứ hai (dữ liệu giá).

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

// Trích xuất cột thứ 2 (dữ liệu giá) và sắp xếp
for (int i = 0; i < ArraySize(data); i++) {
   temp[i] = data[i][1];
}
ArraySort(temp); // Sắp xếp giá theo thứ tự tăng dần

// Dựa trên kết quả sắp xếp để tái cấu trúc mảng đa chiều
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;
       }
   }
}

// Sau khi sắp xếp:
// sorted_data: {{2.0, 1.1}, {3.0, 2.2}, {1.0, 3.3}}

Có cách nào để ngăn lỗi khi mảng rỗng không?

Hàm ArraySort không hoạt động với mảng rỗng. Do đó, bạn cần kiểm tra trước xem mảng có rỗng không.

Ví dụ kiểm tra mảng có rỗng không

double data[];

if (ArraySize(data) > 0) {
   ArraySort(data);
} else {
   Print("Mảng rỗng.");
}

Có thể xử lý đúng các giá trị trùng lặp trong mảng không?

Hàm ArraySort có thể sắp xếp đúng các giá trị trùng lặp trong mảng, nhưng thứ tự của các giá trị giống nhau không được đảm bảo (sắp xếp không ổn định). Nếu cần sắp xếp ổn định, cần điều chỉnh thủ công như sau.

Ví dụ giữ thứ tự thủ công

// Ghi lại giá trị trong mảng và chỉ số gốc
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;
}

// Tạo hàm phụ trợ cho sắp xếp để triển khai sắp xếp tùy chỉnh
// Sau khi sắp xếp, tái cấu trúc chỉ số gốc

8. Tóm tắt và các bước tiếp theo

Ôn lại các điểm chính của hàm ArraySort

  • Vai trò cơ bản:
    ArraySort là một công cụ tiện lợi để sắp xếp mảng theo thứ tự tăng dần hoặc giảm dần.
  • Chức năng chính:
    có thể sử dụng cho nhiều mục đích rộng rãi như sắp xếp một phần mảng, sắp xếp theo điều kiện cụ thể, và các hoạt động gián tiếp trên mảng đa chiều.
  • Những hạn chế và lưu ý:
    có một số hạn chế như xử lý kiểu mảng, xử lý mảng đa chiều, và việc sắp xếp ổn định không được đảm bảo.

Các bước tiếp theo

Để làm sâu sắc hơn các hoạt động mảng trong MQL4, chúng tôi khuyến nghị học các nội dung sau.

  1. ArrayResize hàm:
    hiểu cách thay đổi kích thước mảng và cho phép các hoạt động dữ liệu động.
  2. ArrayCopy hàm:
    sao chép mảng một cách hiệu quả và mở rộng phạm vi hoạt động dữ liệu.
  3. Triển khai logic sắp xếp tùy chỉnh:
    công nghệ ứng dụng cho các trường hợp cần điều kiện sắp xếp phức tạp.
  • Là bước tiếp theo, hãy thử sử dụng ArraySort một cách thực tế trong EA của bạn, tham khảo các bài viết khác và tài liệu chính thức!

Các trang web tham khảo

ArraySort - Array Functions - MQL4 Reference

ArraySort - Array Functions - MQL4 Reference…

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

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

MATRIX　TRADER

Phát triển MQL (MQL4/MQL5)の最新記事8件