Arduino 中关于字符串的处理

发表于 | 更新于 | 分类于 | 阅读次数：
本文字数： 9.9k | 阅读时长 ≈ 9 分钟

这篇文章汇总一下 Arduino 中字符串处理的操作。

分析字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
isAlphaNumeric()  // 判断是否为字母数字

isAlpha()        // 判断是否为字母

isAscii()        // 判断是否为 ASCII 码

isWhitespace()    // 判断是否为空格符

isControl()          // 判断是否为控制字符

isDigit()              // 判断是否为数字

isGraph()            // 判断是否为可打印的字符，不是空格

isLowerCase()       // 判断是否为小写

isPrintable()        // 判断是否为可打印的字符

isPunct()            // 判断是否为标点符号

isSpace()            // 判断是否为空格

isUpperCase()     // 判断是否为大写

isHexadecimalDigit()  // 判断是否为十六进制数字(i.e. 0 - 9, a - F, or A - F)

代码示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/*
 * Arduino 中的字符处理
 */
void setup() {
  // 打开串口通信
  Serial.begin(9600);
  while(!Serial){
    ; // 等待串口连接
    }
   Serial.println("send any byte and i'll tell you everything I can about it");
   Serial.println();
}

void loop() {
  // 获取输入的数据
  if (Serial.available() > 0){
    int thisChar = Serial.read();
    
    // 查看发送的内容
    Serial.print("You sent me: \'");
    Serial.print(thisChar);
    Serial.print("\'  ASCII Value: ");
    Serial.println(thisChar);
    
    // 分析发送的内容
    if(isAlphaNumeric(thisChar)){
      Serial.println("it's alphanumeric");
      }
     if(isAlpha(thisChar)){
      Serial.println("it's a alphabetic");
      }
     if(isAscii(thisChar)){
      Serial.println("it's ASCII");
       }
     if(isWhitespace(thisChar)){
      Serial.println("it's whitespace");
       }
     if(isControl(thisChar)){
       Serial.println("it's a control character");
       }
     if(isDigit(thisChar)){
       Serial.println("it's a numeric digit");
       }
      if(isGraph(thisChar)){
       Serial.println("it's a printable charcater that's not whitespace");
       }
      if(isLowerCase(thisChar)){
       Serial.println("it's  lower case");
       }
    if (isPrintable(thisChar)) {
      Serial.println("it's printable");
    }
    if (isPunct(thisChar)) {
      Serial.println("it's punctuation");
    }
    if (isSpace(thisChar)) {
      Serial.println("it's a space character");
    }
    if (isUpperCase(thisChar)) {
      Serial.println("it's upper case");
    }
    if (isHexadecimalDigit(thisChar)) {
      Serial.println("it's a valid hexadecimaldigit (i.e. 0 - 9, a - F, or A - F)");
    }

    // 添加一些空格并要求另外的字符
    Serial.println();
    Serial.println("Give me anther byte");
    Serial.println();
      }
}

字符串相加

字符串可以和（长）整数常量，（长）整数变量，字符，字符串相加，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*
 * 字符相加
 */

String stringOne = String("You added ");
String stringTwo = String("this string");
String stringThree = String();

void setup() {
  Serial.begin(9600);

  Serial.println("\n\nAdding Strings together (concatenation):");
  Serial.println();
}

void loop() {
  // 字符串与整数常量相加
  stringThree = stringOne + 123;
  Serial.println(stringThree);

  // 字符串与长整数常量相加
  stringThree = stringOne + 123456789;
  Serial.println(stringThree);

  // 字符串与字符常量相加
  stringThree = stringOne + 'A';
  Serial.println(stringThree);

  // 字符串与字符串相加
  stringThree = stringOne + "abc";
  Serial.println(stringThree);

  stringThree = stringOne + stringTwo;
  Serial.println(stringThree);

  // 字符串与整数变量相加
  stringOne = "Sensor value: ";
  stringThree = stringOne + analogRead(A0);
  Serial.println(stringThree);

  // 字符串与长整数变量相加
  stringOne = "millis() value: ";
  stringThree = stringOne + millis();
  Serial.println(stringThree);

  while(true);
}

输出的结果：

添加字符串

使用 += 运算符和 concat() 方法将（长）整数常量，（长）整数变量，字符，字符串添加到字符串中去，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/*
 * 添加字符串
 */
 
String stringOne = String("Sensor ");
String stringTwo = String("value");

void setup() {
  Serial.begin(9600);
  Serial.println("\n\nAppending to a String:");
  Serial.println();
}

void loop() {
  Serial.println(stringOne);

  // 添加一个字符串
  stringOne += stringTwo;
  Serial.println(stringOne);

  stringOne += " for input ";
  Serial.println(stringOne);

  // 添加一个字符
  stringOne += 'A';
  Serial.println(stringOne);

  // 添加一个整数常量
  stringOne += 0;
  Serial.println(stringOne);

  // 添加一个整数变量
  stringOne += analogRead(A0);
  Serial.println(stringOne);


  Serial.println("\n\nchanging the Strings' values");
  stringOne = "A long integer: ";
  stringTwo = "The millis(): ";

  // 使用 concat() 来为子妇产添加一个长变量
  stringTwo.concat(millis());
  Serial.println(stringTwo);
  
  while(true);

}

输出结果：

改变字符串的大小写

可以使用 toUpperCase 和 toLowerCase 来分别改变字符串的大写和小写。只有字符 A-Z 或 a-z 受到影响，代码示例如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*
 * 改变字符串的大小写
 */

void setup() {
  Serial.begin(9600);
  Serial.println("\n\nString case changes:");
  Serial.println();
}

void loop() {
  // 将所有字母更改为大写
  String stringOne = "<html><head><body>";
  Serial.println(stringOne);
  stringOne.toUpperCase();
  Serial.println(stringOne);

  // 将所有字母更改为小写
  String stringTwo = "</BODY></HTML>";
  Serial.println(stringTwo);
  stringTwo.toLowerCase();
  Serial.println(stringTwo);

  while (true);
}

输出结果：

设定字符串中的值

字符串函数 charAt() 用于获取字符串中给定位置的字符值， setCharAt() 用于设置字符串中给定位置的字符值。代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/*
 * 设定字符串中的值
 */

void setup() {
  Serial.begin(9600);
  Serial.println("\n\nString charAt() and setCharAt():");
}

void loop() {
  // 打印传感器读数
  String reportString = "SensorReading: 456";
  Serial.println(reportString);

  // 读数的最高位数位于 reportString 中的第15位 
  char mostSignificantDigit = reportString.charAt(15);

  String message = "Most significant digit of the sensor reading is: ";
  Serial.println(message + mostSignificantDigit);
  Serial.println();

  // 将位置13 的“：” 改成 “=”
  reportString.setCharAt(13, '=');
  Serial.println(reportString);

  while(true);
}

输出结果：

比较字符串

字符串的中比较运算符有：==，!=，>，<，>=，<= 以及 equals() 方法和 equalsIgnoreCase()方法。这些运算允许在字符串之间进行字母比较。它们对于排序和按字母顺序排序很有用。

其中 == 和 equals() 执行相同的操作：

1
if(stringOne.equals(stringTwo)){}
1
if (stringOne == stringTwo) {}

>（大于）和 <（小于）运算符按字母顺序在两者不同的第一个字符上比较字符串。因此，有 “a”<“b” 和 “1”<“2”，但 “999”>“1000” 因为 9 比 1 大。

所以，需要注意的是，在比较数字字符串时，字符串比较运算符可能会造成混淆，因为数字被视为字符串而不是数字。如果需要比较数字，请将它们转换为整数，浮点数或长整数，而不是字符串。

获取字符的索引

indexOf() 用来获取字符串中指定字符的索引； lastIndexOf()用来倒序获取指定字符的索引。如何想要获得当前字符第二个索引，可以使用第一个结束位置的索引，并从进行 + 1搜索作为偏移量；倒序的话，进行 -1 操作。需要注意的是，得到的结果都是正向排序的结果，代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
 * 获取字符串的索引
 */
 
String stringOne = String("Hello Hello");
String stringTwo = String();
String stringThree = String();

void setup() {
  Serial.begin(9600);
}

void loop() {
  // 获取第一个“e”的索引
  int e = stringOne.indexOf('e');
  stringTwo = " the first e's index is: ";
  stringThree = stringTwo + e;
  Serial.println(stringThree);
  
  // 获取第二个“e”的索引
  int second_e = stringOne.indexOf('e', e + 1);
  stringTwo = " the second e's index is: ";
  stringThree = stringTwo + second_e;
  Serial.println(stringThree);

  // 倒序获得倒数第一个“o”的索引
  int last_o = stringOne.lastIndexOf('o');
  stringTwo = " the last o's index is: ";
  stringThree = stringTwo + last_o;
  Serial.println(stringThree);

  // 倒序获得倒数第二个 “o”的索引
  int last_second_o = stringOne.lastIndexOf('o', last_o -1);
  stringTwo = " the last second o's index is: ";
  stringThree = stringTwo + last_second_o;
  Serial.println(stringThree);
  
  while(true);
}

输出结果：

获取字符串的长度及消除额外元素

使用 length() 可以获得字符串的长度，使用 trim() 可以消除多余的空白格，代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * 获取字符串的长度
 */
 
void setup() {
  Serial.begin(9600);
}

void loop() {
  String stringOne = String("  Hello World!   ");
  Serial.println(stringOne);
  
  // 获取字符串的长度
  Serial.print("Length: ");
  Serial.println(stringOne.length());
  
  // 消除空格后，打印响度
  stringOne.trim();
  Serial.println(stringOne);
  Serial.print("Length: ");
  Serial.println(stringOne.length());

  // 避免无限打印
  while(true);

}

输出结果：

替换字符串中的字符

使用 replace() 可以替换字符串中的字符，代码示例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*
 * 替换字符串中的字符
 */

void setup() {
  Serial.begin(9600);
}

void loop() {
  String stringOne = String("Hello world");
  Serial.println(stringOne);

  // 将“world”替换成 “arduino”
  String stringTwo = stringOne;
  stringTwo.replace("world", "arduino");
  Serial.println(stringTwo);

  // 避免无限打印
  while(true);
}

输出结果：

检查首尾字符

可以用 startsWith() 和 endWith() 来检查一个字符串是否符合要求，代码示例如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
 * 检查字符串的首尾字符
 */

void setup() {
  Serial.begin(9600);
}

void loop() {
  String stringOne = String("Hello World");
  Serial.println(stringOne);

  // 确认首字符
  if(stringOne.startsWith("Hello")){
    Serial.println("Yes");
    }

  // 确认尾字符
  if(stringOne.endsWith("World")){
    Serial.println("Yes");
    }  

   while(true);
}

输出结果：

查找子字符串

substring()与 charAt()，startsWith() 和endsWith() 密切相关。它允许查找给定字符串中特定子字符串的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
void setup() {
  Serial.begin(9600);
}

void loop() {
  String stringOne = "Content-Type: text/html";
  Serial.println(stringOne);

  // substring（index）查找从索引位置到结尾的子字符串
  if (stringOne.substring(19) == "html") {
    Serial.println("It's an html file");
  }
  // 在字符串中间查找子字符串
  if (stringOne.substring(14, 18) == "text") {
    Serial.println("It's a text-based file");
  }

  while (true);
}

输出结果：

字符串转换成整数

使用 toInt() 可以将字符串转换成整数。下面代码是将接受到的字符串中的整数字符转换成整数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/*
 * 字符串转换为整数
 */
String inString = "";

void setup() {
  Serial.begin(9600);
}

void loop() {
  // 读取串口的输入：
  while(Serial.available() > 0){
    int inChar = Serial.read();
    // 判断输入的是否为数字
    if(isDigit(inChar)){
      // 将传入的字节转换为字符并将其添加到字符串
      inString += (char)inChar;
      }
    // 如果有新的一行的话，打印字符串和字符串的值
    if(inChar == '\n'){
      Serial.print("Value: ");
      Serial.println(inString.toInt());
      Serial.print("String: ");
      Serial.println(inString);
      // 清空字符串
      inString = "";
      }
    }
}