基础数据类型与正则
数字与布尔值
数字类型与布尔类型与其他语言是一样一样的
部分属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| 1 int figureA = -93;
2 // figureA是否为负数
3 print(figureA.isNegative);
4 // figureA是否是有限的
5 print(figureA.isFinite);
6 // figureA是否正无穷大或负无穷大
7 print(figureA.isInfinite);
8
9 double figureB = 64.742;
10 // 返回figureB的符号，-1.0:值小于0、+1.0:值大于0、-0.0/0.0/NaN:值是其本身
11 print(figureB.sign);
12 // 返回figureB运行时的类型
13 print(figureB.runtimeType);
14 // 返回figureB的哈希码
15 print(figureB.hashCode);
16
17 int figureC = 13;
18 // figureC是否为奇数
19 print(figureC.isOdd);
20 // figureC是否为偶数
21 print(figureC.isEven);
22 // 返回figureC所占存储位
23 print(figureC.bitLength);
24 |
常用方法
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
| 1 int figureA = -93;
2 // 返回figureA的绝对值
3 print(figureA.abs());
4 // 返回figureA的字符串
5 print(figureA.toString());
6
7 double figureB = 64.742;
8 // 返回figureB的整数值
9 print(figureB.toInt());
10 // 返回figureB的双精度值
11 print(figureB.toDouble());
12 // 返回大于figureB的双精度值
13 print(figureB.ceilToDouble());
14 // 返回小于figureB的双精度值
15 print(figureB.floorToDouble());
16 // 返回figureB四舍五入的双精度值
17 print(figureB.roundToDouble());
18 // 返回figureB保留几位小数的字符串
19 print(figureB.toStringAsFixed(2));
20 // 返回figureB保留几位小数后精确结果的字符串
21 print(figureB.toStringAsPrecision(3));
22
23 int figureC = 31;
24 // figureC对比其他整数，0:相同、1:大于、-1:小于
25 print(figureC.compareTo(20));
26 // 将figureC控制在指定区间的整数
27 print(figureC.clamp(20, 25));
28 // 返回figureC转换成指定基数(进制)的字符串
29 print(figureC.toRadixString(16));
30
31 int figureD = 12;
32 // 返回figureD与其他整数的最大公约数
33 print(figureD.gcd(18));
34 // 返回figureDg与其他整数的截取余数
35 print(figureD.remainder(18));
36 // 返回figureD几次幂值的字符串
37 print(figureD.toStringAsExponential(2));
38 |
字符串常量与变量
字符串常量
String是一成不变的，一旦定义就不能改变
1
2
3
4
5
6
7
8
| 1String name = "XiaoMing say : \n";
2String say = """
3Keep on going ...
4never give up ...
5never say die ...
6""";
7print(name + say);
8 |
部分属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| 1 String str = "Hello world!";
2 // 返回字符串的UTF-16代码单元列表
3 print(str.codeUnits);
4 // 返回根据代码单元生成的哈希码
5 print(str.hashCode);
6 // 字符串是否为空
7 print(str.isEmpty);
8 // 字符串是否不为空
9 print(str.isNotEmpty);
10 // 字符串的长度
11 print(str.length);
12 // 返回字符串Unicode代码的可迭代对象
13 print(str.runes);
14 // 返回对象运行时的类型
15 print(str.runtimeType);
16 |
常用方法
返回对象的字符串表示
1
2
3
| 1String str = "Hello world!";
2print(str.toString());
3 |
截取字符串
1
2
3
4
| 1String str = 'Dart is fun';
2String newStr = str.substring(0, 4);
3print(newStr);
4 |
在字符串中插入字符串
1
2
3
| 1String name = "XiaoMing";
2print("My name is ${name}");
3 |
输出字符串的Unicode编码
1
2
3
4
| 1String str = "Dart";
2print(str.codeUnitAt(0));
3print(str.codeUnits);
4 |
去掉字符串前后空格
1
2
3
4
5
| 1String str = "\tDart is fun\n";
2print(str.trimLeft());
3print(str.trimRight());
4print(str.trim());
5 |
字符串的大小写转换
1
2
3
4
| 1String str = "ABCdef";
2print(str.toLowerCase());
3print(str.toUpperCase());
4 |
拆分字符串
1
2
3
4
5
6
| 1String strA = "Hello world!";
2print(strA.split(" "));
3
4String strB = "abba";
5print(strB.split(new RegExp(r"b*")));
6 |
是否包含其他字符串
1
2
3
4
5
6
| 1String str = 'Dart strings';
2print(str.contains('D'));
3print(str.contains(new RegExp(r'[A-Z]')));
4print(str.contains('D', 0));
5print(str.contains(new RegExp(r'[A-Z]'), 0));
6 |
在字符串前后补占位符
1
2
3
4
| 1String str = "86";
2print(str.padLeft(4, '0'));
3print(str.padRight(4, '0'));
4 |
获取指定字符出现的位置
1
2
3
4
5
6
7
8
| 1String str = 'Dartisans';
2
3print(str.indexOf('art'));
4print(str.indexOf(new RegExp(r'[A-Z][a-z]')));
5
6print(str.lastIndexOf('a'));
7print(str.lastIndexOf(new RegExp(r'a(r|n)')));
8 |
替换字符串中所有匹配字符
1
2
3
| 1String str = "resume";
2print(str.replaceAll(new RegExp(r'e'), 'é'));
3 |
字符串变量
StringBuffer是可改变的，定义后还可以再修改
1
2
3
4
5
| 1StringBuffer xiaomingSaid = new StringBuffer();
2xiaomingSaid.write("All the world's a stage ... ");
3xiaomingSaid.write("And all the men and women merely players ...");
4print(xiaomingSaid);
5 |
部分属性
1
2
3
4
5
6
7
8
9
10
11
12
13
| 1 StringBuffer strBuf = new StringBuffer();
2 strBuf.write("Sow nothing, reap nothing.");
3 // 返回字符串缓冲区的哈希码
4 print(strBuf.hashCode);
5 // 字符串缓冲区是否为空
6 print(strBuf.isEmpty);
7 // 字符串缓冲区是否不为空
8 print(strBuf.isNotEmpty);
9 // 返回字符串缓冲区累积内容的长度
10 print(strBuf.length);
11 // 返回对象运行时的类型
12 print(runtimeType);
13 |
常用方法
1
2
3
4
5
6
7
8
| 1 StringBuffer strBuf = new StringBuffer();
2 // 添加字符串到字符串缓冲区内
3 strBuf.write("Do one thing at a time, and do well.");
4 // 返回字符串缓冲区的所有内容
5 print(strBuf.toString());
6 // 清除字符串缓冲区
7 strBuf.clear();
8 |
正则表达式
部分属性
1
2
3
4
5
6
7
8
9
10
11
12
| 1 RegExp exp = new RegExp(r"(\w+)");
2 // 返回正则表达式的哈希码
3 print(exp.hashCode);
4 // 正则表达式是否区分大小写
5 print(exp.isCaseSensitive);
6 // 正则表达式是否匹配多行
7 print(exp.isMultiLine);
8 // 返回源正则表达式字符串
9 print(exp.pattern);
10 // 返回对象运行时的类型
11 print(exp.runtimeType);
12 |
常用方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| 1 RegExp exp = new RegExp(r"(\w+)");
2 // 返回正则表达式匹配项的可迭代对象
3 print(exp.allMatches("abc def ghi"));
4 // 搜索并返回第一个匹配项，没有则返回null
5 print(exp.firstMatch(""));
6 // 正则表达式是否找到匹配项
7 print(exp.hasMatch("as"));
8 // 从第几个字符开始匹配正则表达式
9 print(exp.matchAsPrefix("ab cd", 3));
10 // 返回正则表达式的第一个匹配字符串
11 print(exp.stringMatch("abc de"));
12 // 返回正则表达式的字符串表示
13 print(exp.toString());
14 |
实用案例
验证邮政编码的正则，返回是否匹配的布尔值
1
2
3
| 1RegExp postalcode = new RegExp(r'(\d{6})');
2print(postalcode.hasMatch("518000"));
3 |
验证手机号码的正则，以Iterable< Match >返回所有匹配项
1
2
3
4
5
6
7
| 1RegExp mobile = new RegExp(r"(0|86|17951)?(13[0-9]|15[0-35-9]|17[0678]|18[0-9]|14[57])[0-9]{8}");
2Iterable<Match> mobiles = mobile.allMatches("13812345678 12345678901 17012345678");
3for (Match m in mobiles) {
4 String match = m.group(0);
5 print(match);
6}
7 |
验证网址URL的正则，如果匹配成功以Match返回匹配项，否则返回null
1
2
3
| 1RegExp url = new RegExp(r"^((https|http|ftp|rtsp|mms)?:\/\/)[^\s]+");
2print(url.firstMatch("http://www.google.com"));
3 |
验证身份证号码的正则，返回第一个匹配的字符串
1
2
3
| 1RegExp identity = new RegExp(r"\d{17}[\d|x]|\d{15}");
2print(identity.stringMatch("My id number is 35082419931023527x"));
3 |
