Chuyển đổi số sang chuỗi và ngược lại

Số sang chuỗi và ngược lại, chuỗi sang số, có thể được chuyển đổi bằng toán tử ép kiểu rõ ràng. Ví dụ, đối với các kiểu double và string, nó có thể trông như sau:

double number = (double)text;
string text = (string)number;

Chuỗi có thể được chuyển đổi sang các kiểu số khác, chẳng hạn như float, long, int, v.v.

Lưu ý rằng việc ép kiểu sang kiểu thực (float) cung cấp ít chữ số có nghĩa hơn, điều này trong một số ứng dụng có thể được coi là lợi thế vì nó mang lại biểu diễn ngắn gọn và dễ đọc hơn.

Nói một cách nghiêm ngặt, việc ép kiểu này không bắt buộc, vì ngay cả khi không có toán tử ép kiểu rõ ràng, trình biên dịch sẽ tự động thực hiện ép kiểu ngầm định. Tuy nhiên, trong trường hợp này, bạn sẽ nhận được cảnh báo từ trình biên dịch, do đó khuyến nghị luôn thực hiện ép kiểu một cách rõ ràng.

MQL5 API cung cấp một số hàm hữu ích khác, được mô tả dưới đây. Sau các mô tả là một ví dụ tổng quát.

double StringToDouble(string text)

Hàm StringToDouble chuyển đổi một chuỗi thành số kiểu double.

Nó là một bản sao hoàn toàn của việc ép kiểu sang (double). Mục đích thực tế của nó thực sự bị giới hạn ở việc duy trì khả năng tương thích ngược với các mã nguồn cũ. Phương pháp được ưu tiên là ép kiểu, vì nó ngắn gọn hơn và được triển khai trong cú pháp của ngôn ngữ.

Theo quá trình chuyển đổi, một chuỗi nên chứa một chuỗi ký tự đáp ứng các quy tắc ghi giá trị số (cả số thực và số nguyên). Cụ thể, chuỗi có thể bắt đầu bằng dấu '+' hoặc '-', tiếp theo là một chữ số, và có thể tiếp tục là một chuỗi các chữ số.

Số thực có thể chứa một ký tự chấm duy nhất '.' để phân tách phần thập phân và một lũy thừa tùy chọn theo định dạng sau: ký tự 'e' hoặc 'E' theo sau là một chuỗi chữ số cho bậc (nó cũng có thể được đặt trước bằng '+' hoặc '-').

Đối với số nguyên, ký hiệu thập lục phân được hỗ trợ, tức là tiền tố "0x" có thể được theo sau không chỉ bởi các chữ số thập phân mà còn bởi 'A', 'B', 'C', 'D', 'E', 'F' (ở bất kỳ vị trí nào).

Khi gặp bất kỳ ký tự không mong đợi nào (như chữ cái, dấu câu, chấm thứ hai hoặc khoảng trắng giữa chừng) trong chuỗi, quá trình chuyển đổi sẽ kết thúc. Trong trường hợp này, nếu có các ký tự được phép trước vị trí này, chúng sẽ được hiểu là một số, còn nếu không, kết quả sẽ là 0.

Các ký tự trống ban đầu (khoảng trắng, tab, dòng mới) sẽ bị bỏ qua và không ảnh hưởng đến quá trình chuyển đổi. Nếu sau đó là các số và ký tự khác đáp ứng quy tắc, số sẽ được nhận chính xác.

Bảng sau cung cấp một số ví dụ về các chuyển đổi hợp lệ kèm theo giải thích.

Chuỗi	Double	Kết quả
"123.45"	123.45	Một chấm thập phân
"\t 123"	123.0	Ký tự khoảng trắng đầu bị bỏ qua
"-12345"	-12345.0	Số có dấu
"123e-5"	0.00123	Ký hiệu khoa học với lũy thừa
"0x12345"	74565.0	Ký hiệu thập lục phân

Bảng sau cho thấy các ví dụ về chuyển đổi không chính xác.

Chuỗi	Double	Kết quả
"x12345"	0.0	Bắt đầu bằng ký tự không giải quyết được (chữ cái)
"123x45"	123.0	Chữ cái sau 123 làm gián đoạn chuyển đổi
" 12 3"	12.0	Khoảng trắng sau 12 làm gián đoạn chuyển đổi
"123.4.5"	123.4	Chấm thập phân thứ hai sau 123.4 làm gián đoạn chuyển đổi
"1,234.50"	1.0	Dấu phẩy sau 1 làm gián đoạn chuyển đổi
"-+12345"	0.0	Quá nhiều dấu (hai dấu)

string DoubleToString(double number, int digits = 8)

Hàm DoubleToString chuyển đổi một số thành chuỗi với độ chính xác được chỉ định (số chữ số từ -16 đến 16).

Nó thực hiện công việc tương tự như ép kiểu số sang (string) nhưng cho phép bạn chọn, bằng tham số thứ hai, độ chính xác của số trong chuỗi kết quả.

Toán tử (string) áp dụng cho double hiển thị 16 chữ số có nghĩa (tổng cộng, bao gồm phần nguyên và phần thập phân). Tương đương hoàn toàn của điều này không thể đạt được bằng hàm.

Nếu tham số digits lớn hơn hoặc bằng 0, nó biểu thị số chữ số thập phân. Trong trường hợp này, số ký tự trước dấu thập phân được xác định bởi chính số đó (nó lớn đến mức nào), và nếu tổng số ký tự trong phần nguyên và số được chỉ định trong digits vượt quá 16, thì các chữ số ít ý nghĩa nhất sẽ chứa "rác" (do cách lưu trữ số thực). 16 ký tự đại diện cho độ chính xác tối đa trung bình cho kiểu double, tức là đặt digits thành 16 (tối đa) sẽ chỉ cung cấp biểu diễn chính xác cho các giá trị nhỏ hơn 10.

Nếu tham số digits nhỏ hơn 0, nó chỉ định số chữ số có nghĩa, và số này sẽ được xuất ra ở định dạng khoa học với lũy thừa. Về độ chính xác (nhưng không phải định dạng ghi), đặt digits=-16 trong hàm tạo ra kết quả gần với ép kiểu (string).

Hàm này thường được sử dụng để định dạng đồng nhất các tập dữ liệu (bao gồm căn chỉnh phải của một cột trong bảng nhất định), trong đó các giá trị có cùng độ chính xác thập phân (ví dụ, số chữ số thập phân trong giá của công cụ tài chính hoặc kích thước lô).

Lưu ý rằng lỗi có thể xảy ra trong quá trình tính toán toán học, khiến kết quả không phải là số hợp lệ mặc dù nó có kiểu double (hoặc float). Ví dụ, một biến có thể chứa kết quả của việc tính căn bậc hai của một số âm.

Các giá trị như vậy được gọi là "Không phải số" (NaN) và được hiển thị khi ép kiểu sang (string) dưới dạng gợi ý ngắn về loại lỗi, ví dụ, -nan(ind) (ind - không xác định), nan(inf) (inf - vô cực). Khi sử dụng hàm DoubleToString, bạn sẽ nhận được một số lớn không có ý nghĩa.

Điều đặc biệt quan trọng là tất cả các tính toán tiếp theo với NaN cũng sẽ cho ra NaN. Để kiểm tra các giá trị như vậy, có hàm MathIsValidNumber.

long StringToInteger(string text)

Hàm này chuyển đổi một chuỗi thành số kiểu long. Lưu ý rằng kiểu kết quả chắc chắn là long, chứ không phải int (mặc dù tên hàm là vậy) và không phải ulong.

Một cách thay thế là ép kiểu bằng toán tử (long). Hơn nữa, bất kỳ kiểu số nguyên nào khác theo ý bạn chọn cũng có thể được sử dụng để ép kiểu: (int), (uint), (ulong), v.v.

Quy tắc chuyển đổi tương tự như kiểu double, nhưng loại trừ ký tự chấm và lũy thừa khỏi các ký tự được phép.

string IntegerToString(long number, int length = 0, ushort filling = ' ')

Hàm IntegerToString chuyển đổi một số nguyên kiểu long thành chuỗi có độ dài được chỉ định. Nếu biểu diễn số chiếm ít hơn một ký tự, nó sẽ được đệm bên trái bằng ký tự filling (mặc định là khoảng trắng). Ngược lại, số sẽ được hiển thị đầy đủ, không bị giới hạn. Gọi hàm với các tham số mặc định tương đương với ép kiểu sang (string).

Tất nhiên, các kiểu số nguyên nhỏ hơn (ví dụ, int, short) sẽ được hàm xử lý mà không có vấn đề gì.

Ví dụ về việc sử dụng tất cả các hàm trên được đưa ra trong script ConversionNumbers.mq5.

void OnStart()
{
   const string text = "123.4567890123456789";
   const string message = "-123e-5 buckazoid";
   const double number = 123.4567890123456789;
   const double exponent = 1.234567890123456789e-5;
   
   // ép kiểu
   Print((double)text);    // 123.4567890123457
   Print((double)message); // -0.00123
   Print((string)number);  // 123.4567890123457
   Print((string)exponent);// 1.234567890123457e-05
   Print((long)text);      // 123
   Print((long)message);   // -123
   
   // chuyển đổi bằng hàm
   Print(StringToDouble(text));    // 123.4567890123457
   Print(StringToDouble(message)); // -0.00123
   
   // mặc định, 8 chữ số thập phân
   Print(DoubleToString(number)); // 123.45678901
   
   // độ chính xác tùy chỉnh
   Print(DoubleToString(number, 5));  // 123.45679
   Print(DoubleToString(number, -5)); // 1.23457e+02
   Print(DoubleToString(number, -16));// 1.2345678901234568e+02
   Print(DoubleToString(number, 16)); // 123.4567890123456807
   // hai chữ số cuối không chính xác!
   Print(MathSqrt(-1.0));             // -nan(ind)
   Print(DoubleToString(MathSqrt(-1.0))); // 9223372129088496176.54775808
   
   Print(StringToInteger(text));    // 123
   Print(StringToInteger(message)); // -123
   
   Print(IntegerToString(INT_MAX));         // '2147483647'
   Print(IntegerToString(INT_MAX, 5));      // '2147483647'
   Print(IntegerToString(INT_MAX, 16));     // '      2147483647'
   Print(IntegerToString(INT_MAX, 16, '0'));// '0000002147483647'
}