String Là Gì? Chi Tiết Các Hàm Trong String. - Lập Trình Arduino

Trang này đã ngừng hoạt động. Các bạn hãy truy cập trang ngoinhaiot.com để xem các bài viết mới nha !!!

Trong bài viết này mình gọi String có nghĩa là đối tượng String, còn chuỗi nghĩa là c_str – mảng ký tự.

String là gì?

Để trả lời câu hỏi này ta cùng tìm hiểu một khái niệm cũ hơn, đó là chuỗi, chuỗi đơn giản chỉ là một mảng ký tự được kết thúc bằng null (ký tự ‘\0’, hay cụ thể hơn là giá trị 0), ký tự null này cho biết việc kết thúc một chuỗi.  Ví dụ bạn muốn khai bào một chuỗi là “Viet Nam” thì bạn sẽ làm như sau:

1. char ch[] = “Viet Nam”;

hoặc:

2. char ch[9] = “Viet Nam”;

hoặc:

3. char ch[] = {‘V’,’i’,’e’,’t’,’ ‘,’N’,’a’,’m’,’\0′};

hoặc:

4. char ch[9] = {‘V’,’i’,’e’,’t’,’ ‘,’N’,’a’,’m’,’\0′};

và một cách bá đạo hơn là:

5. char ch[9] = {86, 105, 101, 116, 32, 78, 97, 109, 0};

Tất cả các cách khai báo trên đều có chung một kết quả là tạo một chuỗi ký tự “Viet Nam”. Ở cách 1 và 2 việc tạo chuỗi bằng cặp đấu (“”) sẽ tự chèn một null ở cuối. Còn những cách dưới thì ta phải thêm thủ công.

Chuỗi chỉ đơn giản là vậy thôi, nó không có nhiều chức năng (ví dụ chức năng cơ bản nhất mà nó không có là lấy độ dài chuỗi và còn nhiều chức năng khác nữa) nên người ta mới tạo ra một kiểu dữ liệu (đối tượng) mới đó là String. String chỉ có một nhược điểm duy nhất so với chuỗi là tốn nhiều tài nguyên (CPU) hơn ở hầu hết các chức năng.

Để tạo một string là làm như sau:

String str; // Tạo một string không có nội dung (nội dung có thể thêm sau). String str(“Viet Nam”); // Tạo một string với nội dung “Viet Nam”.

Với số nguyên: String str(123); // Tạo string với nội dung (“123”). String str(123,HEX); // Chuyển số 123 sang hệ hex rồi tạo string với nội dung đó (“7b”). String str(123,BIN); // Chuyển số 123 sang hệ bin rồi tạo string với nội dung đó (“1111011”).

Với số thực: String str(123.456789,4); // Tạo string từ số 123.456789 và chỉ lấy 4 chữ số sau dấu phảy (“123.4568”).

Lưu ý là bạn không thể “lấy 4 chữ số sau dấu phảy” của số nguyên được mặc dù bạn viết String str(123,4); vẫn biên dịch được nhưng kết quả không kiểm soát được. Tương tự với số thực, bạn không thể chuyển số thực sang hệ khác được, số thực chỉ được hiển thị ở dạng thập phân.

Một số thao tác trên string.

charAt();

Cú pháp:

string.charAt(n);

Tham số:

string: một biến kiểu String. n: chỉ số của ký tự muốn lấy.

Trả về:

char – ký tự thứ n (nếu n > chiều dài chuỗi hoặc string rỗng thì trả về giá trị 0).

Ví dụ:

String(“Viet Nam”).charAt(3); // Trả về ký tự ‘t’.

compareTo();

Cú pháp:

string1.compareTo(string2);

Tham số:

string1: string thứ nhất. string2: string thứ hai.

Trả về:

int – hiệu giá trị tại vị trí khác nhau đầu tiên của 2 chuỗi, nếu 2 chuỗi giống nhau thì trả về 0.

Ví dụ:

String(“Viet Nam”).compareTo(“Viet Nam”); // Trả về giá trị 0. Lưu ý là chuỗi “Viet Nam” thứ 2 được tự động ép sang String. String(“Viet Nam”).compareTo(“VietaNam”); // Trả về giá trị -65, vị trí khác nhau đầu tiên là 4 (ký tự ‘ ‘ và ‘a’ khác nhau), ‘a’=97 ; ‘ ‘=32. 32 – 97 = -65. Kết quả là 65.

concat(); // Bạn nào có thể Việt hóa được hàm này…. ahihi.

Cú pháp:

string.concat(parameter);

Tham số:

parameter: tất cả các kiểu sau String, string, char, byte, int, unsigned int, long, unsigned long, float, double, __FlashStringHelper(F() macro) đây là một kiểu chuỗi được lưu trong Flash.

Trả về:

true: nối thành công. false: nối thất bại, khi đó chuỗi gốc được giữ nguyên.

Hàm này sẽ nối parameter vào string.

Ví dụ:

String ch(“Viet Nam”); ch.concat(” vo dich”); // ch lúc này có nội dung “Viet Nam vo dich”.

c_str();

Cú pháp:

string.c_str();

Tham số:

không.

Trả về:

Mảng ký tự kiểu chuỗi (cụ thể hơn và khó hiểu hơn là buffer của string).

Hàm này có nhiệm vụ chuyển string thành chuỗi (tức là mảng ký tự). Nó được dùng để tương thích với một số hàm không hổ trợ string, hoặc đơn giản hơn là người ta không cần những chức năng rờm rà của string…

Lưu ý là hàm này không tạo ra bất cứ dữ liệu gì mới, nó chỉ trả về địa chỉ buffer của string. Chính vì thế nên sẽ có một số tác động phụ.

Ví dụ:

String str(“Viet Nam”); char * ch; ch = str.c_str(); // lúc này buffer của str bị 2 “đối tượng” điều khiển là str và ch. ch[4] = ‘a’; // lệnh này sẽ tác động đến cả str, khi này nội dung str là (“VietaNam”).

startsWith();

Cú pháp:

1. string1.startsWith(string2); 2. string1.startsWith(string2, offset);

Tham số:

string1: chuỗi thứ nhất. string2: chuỗi thứ hai. offset: vị trí bắt đầu xét.

Trả về:

true: nếu bắt đầu tại của offset string1 giống với string2. false: ngược lại.

Hàm này sẽ xét xem đầu string1 có phải là string2 hay không, nếu có thì trả về true, ngược lại là false. Ở cú pháp thứ 2, vị trí đầu được thay bằng vị trí offset.

Ví dụ:

String(“Viet Nam”).startsWith(“Vie”); // Kết quả là true. String(“Viet Nam”).startsWith(“iet”); // Kết quả là false. String(“Viet Nam”).startsWith(“iet”,1); // Kết quả là true.

endsWith();

Cú pháp:

string1.endsWith(string2);

Tham số:

string1: chuỗi thứ nhất. string2: chuỗi thứ hai.

Trả về:

true: nếu kết thúc của string1 giống với string2. false: ngược lại.

Hàm này sẽ xét xem cuối string1 có phải là string2 hay không, nếu có thì trả về true, ngược lại là false.

Ví dụ:

String(“Viet Nam”).endsWith(“Nam”); // Kết quả là true. String(“Viet Nam”).endsWith(“Na”); // Kết quả là false. String(“Viet Nam”).endsWith(“Nama”); // Kết quả là false.

equals();

Cú pháp:

string1.equals(string2);

Tham số:

string1, string2: hai string cần so sánh.

Trả về:

true: nếu cả hai giống nhau (phân biệt HOA, thường). false: ngược lại.

Hàm này có chức năng so sánh hai chuỗi có giống nhau hay không.

Ví dụ: String(“Viet Nam”).equals(“viet nam”); // Kết quả là false. String(“Viet Nam”).equals(“Viet Nam”); // Kết quả là true. String(“Viet Nam”).equals(“Viet Nam vo dich”); // Kết quả là false.

equalsIgnoreCase();

Cú pháp:

string1.equalsIgnoreCase(string2);

Tham số:

string1, string2: hai string cần so sánh.

Trả về:

true: nếu cả hai giống nhau (không phân biệt HOA, thường). false: ngược lại.

Hàm này có chức năng so sánh hai chuỗi có giống nhau hay không.

Ví dụ: String(“Viet Nam”).equals(“viet nam”); // Kết quả là true. String(“Viet Nam”).equals(“Viet Nam”); // Kết quả là true. String(“Viet Nam”).equals(“Viet Nam vo dich”); // Kết quả là false.

getBytes();

Cú pháp:

string.getBytes(buf, len);

Tham số:

string: string nguồn.

buf: mảng mà dữ liệu sẽ được copy vào.

len: lượng dữ liệu muốn copy (lưu ý là len phải nhỏ hơn hoặc bằng kích thước mảng để tránh những lỗi không kiểm soát được).

Trả về.

Không.

Hàm này sẽ tạo một bản sao dữ liệu của string vào buf với kích thước là len. Vì dữ liệu sẽ được sao chép nên cho dù ta tác động vào buf như thế nào thì string sẽ không thay đổi (khác với c_str()). Lưu ý là lượng dữ liệu này đã bao gồm null. Ví dụ:

char ch[100]; String str(“Viet Nam”); str.getBytes(ch,3); // lúc này ch = {‘V’,’i’,’\0′,…..}; ch[1]=’N’; // Ngay cả khi thay đổi ch thì str vẫn như cũ.

indexOf();

Cú pháp:

1. string.indexOf(val); 2. string.indexOf(val, from);

Tham số:

string: string gốc. val: ký tự hoặc string cần tìm. from: vị trí bắt đầu tìm.

Trả về:

Trả về vị trí đầu tiên của ký tự hoặc string cần tìm, nếu không tìm thấy thì trả về -1.

Hàm này sẽ tìm vị trí đầu tiên của val trong chuỗi string (với cú pháp 1, bắt đầu tìm từ đầu string; với cú pháp 2, tìm từ vị trí from). Ví dụ: String(“Vietm Nam”).indexOf(‘m’); // Trả về số 4. String(“Vietm Nam”).indexOf(‘m’,4); // Trả về số 4. String(“Vietm Nam”).indexOf(‘m’,5); // Trả về số 8. String(“Vietm Nam”).indexOf(“etm”); // Trả về số 2.

lastIndexOf();

Cú pháp:

1. string.lastIndexOf(val); 2. string.lastIndexOf(val, from);

Tham số:

string: string gốc. val: ký tự hoặc string cần tìm. from: vị trí bắt đầu tìm (tìm từ vị trí này sáng trái).

Trả về:

Trả về vị trí cuối cùng của ký tự hoặc string cần tìm, nếu không tìm thấy thì trả về -1.

Hàm này sẽ tìm vị trí cuối cùng của val trong chuỗi string (với cú pháp 1, bắt đầu tìm ở cuối string; với cú pháp 2, tìm từ vị trí from trở về bên trái).

Ví dụ: String(“Vietm Nam”).lastIndexOf(‘m’); // Trả về số 8. String(“Vietm Nam”).lastIndexOf(‘m’,3); // Trả về số -1. String(“Vietm Nam”).lastIndexOf(‘m’,5); // Trả về số 4. String(“Vietm Nam”).lastIndexOf(“etm”); // Trả về số 2.

length();

Cú pháp:

string.length();

Tham số:

string: string cần xét.

Trả về:

Chiều dài của string.

Hàm này sẽ trả về chiều dài của string. Ví dụ: String(“Viet Nam”).length(); // Trả về số 8.

remove()

Cú pháp:

1. string.remove(index);

2. string.remove(index, count);

Tham số:

index: vị trí bắt đầu cắt bỏ.

count: số lượng ký tự sẽ bỏ.

Trả về:

Không

Hàm này sẽ bỏ đi những ký tự bắt đâu từ index (bỏ luôn ký tự ở vị trí index) với số lượng là count. Ở cú pháp 1 sẽ bỏ đi toàn bộ những ký tự sau vị trí index (kể cả vị trí index).

Ví dụ:

String tmp(“Viet Nam”); tmp.remove(2); // Lúc này nội dung của tmp là “Vi”.

String tmp2(“Viet Nam”); tmp2.remove(2,3); // Lúc này nội dung của tmp là “ViNam”.

replace();

Cú pháp:

string.replace(val1, val2);

Tham số:

string: string gốc. val1: ký tự hoặc string cần thay. val2: ký tự hoặc string mới.

Trả về:

Không.

Hàm này sẽ tìm tất cả val1 trong string rồi thay chúng bằng val2. Lưu ý là val1 và val2 phải cùng kiểu dữ liệu với nhau; tức là nếu val1 là ký tự thì val2 phải là ký tự, val1 là chuỗi thì val2 cũng là chuỗi.

Ví dụ: String tmp(“Viet Nam”); tmp.replace(“iet”,”IET”); // Lúc này nội dung của tmp là “VIET Nam”.

Mẹo: để cho thuận tiện ta nên dùng chuỗi cho cả ký tự. Ví dụ String tmp(“Viet Nam”); tmp.replace(“i”,’a’); // bị lỗi biên dịch. tmp.replace(“i”,”a”); // không bị lỗi.

Cách này sẽ tốn tài nguyên hơn một chút. Bạn nên cân nhắc khi dùng.

reserve();

Cú pháp:

string.reserve(size);

Tham số:

size: số byte được cấp trước.

Trả về:

Không.

Hàm này sẽ cấp sẵn một vùng nhớ có kích thước là size cho string. Việc cấp trước một vùng nhớ cho string đảm bảo được việc nối chuỗi hay bất cứ thao tác nào làm thay đổi kích thước chuỗi luôn thành công trong kích thước đó, nhưng bù lại nếu kích thước này không dùng hết sẽ gây lẵng phí. Hàm này không quan trọng với những ứng dụng cơ bản.

setCharAt();

Cú pháp:

string.setCharAt(index, ch);

Tham số:

string: string gốc. index: vị trí muốn gán. ch: ký tự muốn gán.

Trả về:

Không.

Hàm này sẽ gán ký tự ch vào vị trí index của string. Nếu index lớn hơn chiều dài chuỗi thì hàm này không làm gì cả.

Ví dụ: String tmp(“Viet N m”); tmp.setCharAt(6, ‘a’); // Lúc này nội dung của tmp là “Viet Nam”.

String tmp2(“Viet N m”); tmp2.setCharAt(10, ‘a’); // Lúc này nội dung của tmp vẫn là là “Viet N m”.

substring();

Cú pháp:

1. string.substring(from); 2. string.substring(from, to);

Tham số:

string: string gốc. from: vị trí bắt đầu lấy. to: lấy đến vị trí này.

Trả về:

String – nằm giữa from và to.

Hàm này sẽ tạo ra một String mới được trích từ string gốc, lấy từ vị trí from đến to (bao gồm ký tự tại from nhưng không bao gồm ký tự tại to). Ở cú pháp 1, String trả về được trích từ vị trí from đến hết. Lưu ý là String mới tạo ra hoàn toàn độc lập với string gốc.

Ví dụ: String tmp(“Viet Nam”); String sub; sub=tmp.substring(1,3); // Lúc này nội dung sub là “ie”. tmp=”tao lao”; // Nội dung sub không đổi.

toCharArray();

Cú pháp:

string.toCharArray(buf, len);

Tham số:

string: string nguồn.

buf: mảng mà dữ liệu sẽ được copy vào.

len: lượng dữ liệu muốn copy (lưu ý là phải nhỏ hơn hoặc bằng kích thước mảng để tránh những lỗi không kiểm soát được).

Trả về.

Không.

Hàm này rất giống với hàm getBytes(), chỉ khác ở tham số truyền vào một bên là mảng char[], một bên là mảng byte[]. Nhưng điều này không quan trọng vì trình biên dịch đã tự chuyển kiểu cho ta. Hơn thế nữa, việc đối xử với mảng sau khi gọi hàm chỉ phụ thuộc vào cách ta khai báo, tức là bản chất của biến. Chính vì thế nên có thể nói 2 hàm này hoàn toàn có chứ năng giống nhau.

Hàm này sẽ tạo một bản sao dữ liệu của string vào buf với kích thước là len. Vì dữ liệu sẽ được sao chép nên cho dù ta tác động vào buf như thế nào thì string sẽ không thay đổi (khác với c_str()). Lưu ý là lượng dữ liệu này đã bao gồm null.

Ví dụ:

char ch[100]; String str(“Viet Nam”); str.toCharArray(ch,3); // Lúc này ch = {‘V’,’i’,’\0′,…..}. ch[1]=’N’; // Ngay cả khi thay đổi ch thì str vẫn như cũ.

toInt();

Cú pháp:

string.toInt();

Tham số:

string: string gốc.

Trả về:

long – số nguyên.

Hàm này sẽ duyệt từ trái qua phải string và chuyến nó thành số nguyên cho đến khi nào ký tự mà nó duyệt không phải là số. Lưu ý là nếu ký tự đầu tiên không phải là số thì nó sẽ trả về 0.

Ví dụ:

String str(“+123-2Viet Nam123”); str.toInt(); // Trả về số 123. String str2(“-123-2Viet Nam123”); str2.toInt(); // Trả về số -123. String str3(“Viet Nam123”); str3.toInt(); // Trả về số 0.

toFloat();

Cú pháp:

string.toFloat();

Tham số:

string: string gốc.

Trả về:

float – số thực.

Hàm này sẽ duyệt từ trái qua phải string và chuyến nó thành số thực cho đến khi nào ký tự mà nó duyệt không phải là số. Số thực trả về chỉ có 2 chữ số sau dấu phẩy và được làm tròn luôn. Lưu ý là nếu ký tự đầu tiên không phải là số thì nó sẽ trả về 0.00.

Ví dụ: String str(“+123.456789-2Viet Nam123”); str.toFloat(); // Trả về số 123.46. String str2(“-123.456789-2Viet Nam123”); str2.toFloat)); // Trả về số -123.46. String str3(“Viet Nam123.456789”); str3.toFloat)); // Trả về số 0.00.

toLowerCase();

Cú pháp:

string.toLowerCase();

Tham số:

string: chuỗi gốc.

Trả về:

Không.

Hàm này biến toàn bộ các ký tự của string thành chữ thường.

toUpperCase();

Cú pháp:

string.toUpperCase();

Tham số:

string: chuỗi gốc.

Trả về:

Không.

Hàm này biến toàn bộ các ký tự của string thành chữ HOA.

trim();

Cú pháp:

string.trim();

Tham số:

string: string gốc.

Trả về:

Không

Hàm này sẽ bỏ tất cả khoảng trắng ở hai bên string.

Ví dụ

String tmp(”    Viet Nam     “); tmp.trim(); // Lúc này nội dung tmp là “Viet Nam”

Chia sẻ:

• Twitter
• Facebook

Thích Đang tải...

Có liên quan

• Aruino cơ bản