基本类型
num
数值类型，有两个子类型：
- int：根据不同的平台有不同的长度，最长不超过 64 位。
- double：64 位双精度浮点数
int x = 1;
int hex = 0xDEADBEEF;
double y = 1.1;
double exponents = 1.42e5;
数字字面量是编译时常量。许多算术表达式也是编译时常量，只要它们的操作数是编译时常量，可以对数字求值。
const msPerSecond = 1000;
const secondsUntilRetry = 5;
const msUntilRetry = secondsUntilRetry * msPerSecond;
String
Dart 字符串是 UTF-16 编码单元的序列。可以使用单引号或双引号创建一个字符串。
字面量都是编译时常量。
var s = 'Bicycle: $speed mph'
var s2 = '${s.toUpperCase()}'
使用 ${expression} 的方式来实现字符串模板的效果，如果该表达式仅仅是一个标识符，可以去掉花括号 $variableName
== 判断两个字符串是否相等，+ 拼接字符串。
''' 或 """ 表示多行字符串，r 前缀表示原生字符串，忽略转义，和 Python 一样。
var s1 = '''
You can create
multi-line strings like this one.
''';
var s2 = """This is also a
multi-line string.""";
var s3 = r'In a raw string, not even \n gets special treatment.';
在字符串中搜索：
assert('Never odd or even'.contains('odd'));
assert('Never odd or even'.startsWith('Never'));
assert('Never odd or even'.endsWith('even'));
assert('Never odd or even'.indexOf('odd') == 6);
提取数据：
// 子串，含头不含尾
assert('Never odd or even'.substring(6, 9) == 'odd');
// 分割
var parts = 'structured web apps'.split(' ');
assert(parts.length == 3);
assert(parts[0] == 'structured');
// 获取索引获取 UTF-16 字符
assert('Never odd or even'[0] == 'N');
// split 参数是空字符串，返回所有字符组成的列表
for (var char in 'hello'.split('')) {
print(char);
}
// 获取所有字符的 UTF-16 编码值组成的数组
var codeUnitList =
'Never odd or even'.codeUnits.toList();
assert(codeUnitList[0] == 78);
大小写转换
// Convert to uppercase.
assert('structured web apps'.toUpperCase() ==
'STRUCTURED WEB APPS');
// Convert to lowercase.
assert('STRUCTURED WEB APPS'.toLowerCase() ==
'structured web apps');
去除空格和空判断
// 去除左右两端空格
assert(' hello '.trim() == 'hello');
assert(''.isEmpty);
assert(' '.isNotEmpty);
bool
字面量 true、false，都是编译时常量。
// Check for an empty string.
var fullName = '';
assert(fullName.isEmpty);
// Check for zero.
var hitPoints = 0;
assert(hitPoints <= 0);
// Check for null.
var unicorn;
assert(unicorn == null);
// Check for NaN.
var iMeantToDoThis = 0 / 0;
assert(iMeantToDoThis.isNaN);
num 和 String 转换
dart:core 中的功能。
String 转为 num：
assert(int.parse('42') == 42);
assert(int.parse('0x42') == 66);
assert(double.parse('0.50') == 0.5);
// num 的方法，可能的情况下创建一个整数，否则创建一个 double
assert(num.parse('42') is int);
assert(num.parse('0x42') is int);
assert(num.parse('0.50') is double);
// 指定基数
assert(int.parse('42', radix: 16) == 66);
num 转为 String：
assert(42.toString() == '42');
assert(123.456.toString() == '123.456');
// 指定小数点后面有几位
assert(123.456.toStringAsFixed(2) == '123.46');
// 指定有效位
assert(123.456.toStringAsPrecision(2) == '1.2e+2');
assert(double.parse('1.2e+2') == 120.0);
Runes
字符是字符串的 UTF-32 编码点。因为字符串是 UTF-16 代码单元的序列，所以在字符串中表示 32 位的 Unicode 值需要特殊的语法。
表示 Unicode 码点的常用方法是 \uXXXX，其中 XXXX 是 4 位数的十六进制值。例如，心型字符(♥)的编码为 \u2665。要指定大于或小于 4 位的十六进制数字，要将值放在花括号中。例如笑脸表情(😆)的编码 \u{1f600}。
String 类有几个属性可以用来获取 Runes 信息。codeUnitAt 和 codeUnit 属性返回 16 位代码单元。使用字符属性获取字符串的字符。
var clapping = '\u{1f600}';
print(clapping); // 😀
print(clapping.codeUnits); // [55357, 56832]
print(clapping.runes.toList()); // [128512]
Runes input = new Runes(
'\u2665 \u{1f605} \u{1f60e} \u{1f47b} \u{1f596} \u{1f44d}');
// ♥ 😅 😎 👻 🖖 👍
print(new String.fromCharCodes(input));
Symbol
符号对象表示在 Dart 程序中声明的操作符或标识符。可能永远不需要使用符号，但是对于按名称引用标识符的 api 来说，它们是非常重要的，因为缩小改变了标识符名称而不是标识符符号。
要获取标识符的符号，使用 #，后面跟着标识符:
#radix
#bar
集合类型
List
var list = [1, 2, 3];
assert(list.length == 3);
assert(list[1] == 2);
list[1] = 1;
assert(list[1] == 1);
var constantList = const [1, 2, 3];
// 添加，和 Java 一样
fruits.add('kiwis');
fruits.addAll(['grapes', 'bananas']);
// 长度
assert(fruits.length == 5);
// 索引
var appleIndex = fruits.indexOf('apples');
// 根据索引删除
fruits.removeAt(appleIndex);
// 清空
fruits.clear();
排序，可以提供一个排序函数，该函数返回值表示大小关系：
-
<0表示a<b -
=0表示a=b -
>0表示a>b
var fruits = ['bananas', 'apples', 'oranges'];
fruits.sort((a, b) => a.compareTo(b));
assert(fruits[0] == 'apples');
Set
无序，不重复。必须通过构造方法创建对象。
var ingredients = Set<String>();
ingredients.addAll(['gold', 'titanium', 'xenon']);
assert(ingredients.length == 3);
// 添加重复元素不生效
ingredients.add('gold');
assert(ingredients.length == 3);
// 删除
ingredients.remove('gold');
assert(ingredients.length == 2);
// 是否存在
assert(ingredients.contains('titanium'));
// 检查是否都在 Set 里
assert(ingredients.containsAll(['titanium', 'xenon']));
取交集
var ingredients = Set();
ingredients.addAll(['gold', 'titanium', 'xenon']);
var nobleGases = Set.from(['xenon', 'argon']);
// 取两个集合的交集
var intersection = ingredients.intersection(nobleGases);
assert(intersection.length == 1);
assert(intersection.contains('xenon'));
Map
var gifts = {
// Key: Value
'first': 'partridge',
'second': 'turtledoves',
'fifth': 'golden rings'
};
var nobleGases = {
2: 'helium',
10: 'neon',
18: 'argon',
};
使用 Map 的构造函数创建对象
var gifts = Map();
gifts['first'] = 'partridge';
gifts['second'] = 'turtledoves';
gifts['fifth'] = 'golden rings';
var nobleGases = Map<int, String>();
nobleGases[2] = 'helium';
nobleGases[10] = 'neon';
nobleGases[18] = 'argon';
key 不存在时，返回的 value 是 null，.length 获取长度。
var gifts = {'first': 'partridge'};
assert(gifts['fifth'] == null);
assert(gifts.length == 2);
加 const 关键字表示编译时常量
final constantMap = const {
2: 'helium',
10: 'neon',
18: 'argon',
};
var nobleGases = {54: 'xenon'};
// 查找
assert(nobleGases[54] == 'xenon');
// key 是否存在
assert(nobleGases.containsKey(54));
// 根据 key 删除
nobleGases.remove(54);
assert(!nobleGases.containsKey(54));
获取所有 key-value
var hawaiianBeaches = {
'Oahu': ['Waikiki', 'Kailua', 'Waimanalo'],
'Big Island': ['Wailea Bay', 'Pololu Beach'],
'Kauai': ['Hanalei', 'Poipu']
};
// 获取所有 key
var keys = hawaiianBeaches.keys;
assert(keys.length == 3);
assert(Set.from(keys).contains('Oahu'));
// 获取所有 value
var values = hawaiianBeaches.values;
assert(values.length == 3);
assert(values.any((v) => v.contains('Waikiki')));
集合类型的共有方法
空判断
var coffees = [];
var teas = ['green', 'black', 'chamomile', 'earl grey'];
assert(coffees.isEmpty);
assert(teas.isNotEmpty);
迭代执行某个函数。Map 上调用时函数必须有两个参数，对应 key-value。
var teas = ['green', 'black', 'chamomile', 'earl grey'];
teas.forEach((tea) => print('I drink $tea'));
hawaiianBeaches.forEach((k, v) {
print('I want to visit $k and swim at $v');
// I want to visit Oahu and swim at
// [Waikiki, Kailua, Waimanalo], etc.
});
类似 Kotlin 的 map，对每个值执行函数，将结果封装成可迭代对象返回。
var teas = ['green', 'black', 'chamomile', 'earl grey'];
var loudTeas = teas.map((tea) => tea.toUpperCase());
loudTeas.forEach(print);
map() 返回的对象是延迟求值的对象，直到从返回的对象请求项时才调用函数。若要在每项立即调用函数，执行 map().toList() 或 map().toSet()：
var loudTeas =
teas.map((tea) => tea.toUpperCase()).toList();
where() 方法获得所有与条件匹配的项。any() 和 every() 方法检查某些或所有项是否匹配一个条件。
var teas = ['green', 'black', 'chamomile', 'earl grey'];
bool isDecaffeinated(String teaName) =>
teaName == 'chamomile';
// 每项执行函数，过滤出返回 true 的所有项
var decaffeinatedTeas =
teas.where(isDecaffeinated)
// 是否有一项满足条件
assert(teas.any(isDecaffeinated));
// 是否每一项都满足条件
assert(!teas.every(isDecaffeinated));
网友评论