江湖小栈

Do Better

0%

Dart String、List、Map、Date 常用方法小结

发表于 分类于 Hot°C：  精品文章
本文字数： 12k 阅读时长 ≈ 11 分钟
dart常用方法小结

  今日心情很低落 T.T，所以参考官方文档，略微整理了一下 Dart String、List、Map、Date的常用方法。

String

substring

1
2
3
4
5
6
7
// 裁剪字符串，尾部开区间 [start, end)。
var string = 'Dart ' + 'is ' + 'fun!'; // 'Dart is fun!'
string.substring(0, 5); // 'Dart '
string.substring(5); // 'is fun!'
string.substring(string.length - 4); // 'fun!'
print('$string 的长度是：${string.length}');
string[0]; // 'D'

codeUnitAt/codeUnits

1
2
3
string = 'Dart';
string.codeUnitAt(0); // 68
string.codeUnits; // [68, 97, 114, 116]

isEmpty/isNotEmpty

字符串是否为空，return bool。

contains

1
2
'doubleam'.contains('am'); // true
'doubleam'.contains('o', 2); // false

indexOf/lastIndexOf

1
2
'doubleam'.indexOf('d'); // 0
'doubleam'.lastIndexOf('x'); // -1

padLeft/padRight

1
2
'hxb'.padLeft(6, 'x'); // 'xxxhxb'
'hxb'.padRight(6, 'x'); // 'hxbxxx'

startsWith/endsWith

1
2
3
'hxb love oqm'.startsWith('hxb'); // true
'hxb love oqm'.startsWith('love', 4); // true
'hxb love oqm'.endsWith('oqm'); // true

replaceAll

1
2
3
4
// replaceAll(Pattern from, String replace)
"Hello World".replaceAll('World', 'Dart'); // 'Hello Dart'
RegExp testReg = new RegExp(r"^\w{5}$");
"Hello World".replaceAll(testReg, '*******'); // '******* World'

compareTo

1
2
3
4
5
// 比较字符串，等于返回 0，小于返回 -1，大于返回 1。
"C".compareTo('C'); // 0
"C".compareTo('CC'); // -1
"C".compareTo('BBB'); // 1
"C".compareTo('B'); // 1

toLowerCase/toUpperCase

1
2
'aBc'.toLowerCase(); // 'abc'
'aBc'.toUpperCase(); // 'ABC'

trim

1
' abc '.trim(); // 'a'

trimLeft/trimRight

1
2
' abc '.trimLeft(); // 'abc '
' abc '.trimRight(); // ' abc'

split

1
'a,b,c,d,e'.split(','); // [a, b, c, d, e]

List

isEmpty/isNotEmpty

List 是否为空，return bool。

first/last

1
2
3
[1, 2, 3, 4].first; // 1
[1, 2, 3, 4].last; // 4
[1, 2, 3].reversed.toList(); // [3, 2, 1]

add

1
2
3
List testList = [1, 2, 3];
testList.add(4); 
print(testList); // [1, 2, 3, 4]

addAll

1
2
3
List testList = [1, 2, 3];
testList.addAll([1, 2, 3]); 
print(testList); // [1, 2, 3, 1, 2, 3]

any

1
2
List testList = [1, 2, 3];
testList.any((item) => item > 1); // 任意一项 ＞ 1 则返回 true。

every

1
2
[1, 2, 1].every((item) => item == 1); // false
[1, 1, 1].every((item) => item == 1); // true

where

1
[1, 2, 3].where((item) => item > 1).toList(); // [2, 3]

asMap

1
2
List testList = [1, 2, 3];
testList.asMap(); // {0: 1, 1: 2, 2: 3}

clear

1
2
3
List testList = [1, 2, 3];
testList.clear(); 
print(testList); // []

contains

1
[1, 2, 3].contains(1); // true

firstWhere

1
[1, '2020', 1].firstWhere((item) => item == '2020'); // '2020'

indexWhere/lastIndexWhere

1
2
[1, 2, 3].indexWhere((item) => item == 3, 2); // = 2 // 从 List 索引为 2 开始向后查找等于 3 的索引位置。
[1, 2, 1].lastIndexWhere((item) => item == 1); // = 2

indexOf/lastIndexOf

1
2
[1, 2, 3].indexOf(9); // -1
[1, 2, 1].lastIndexOf(1); // 2

insert

1
2
3
List testList = [1, 3, 4];
testList.insert(1, 2);
print(testList); // [1, 2, 3, 4]

insertAll

1
2
3
List testList = [1, 4, 5];
testList.insertAll(1, [2, 3]);
print(testList); // [1, 2, 3, 4, 5]

elementAt

1
2
List testList = [1, 2, 3];
testList.elementAt(0) == testList[0]; // true

expand

1
2
3
4
5
6
7
List testList1 = [[1, 2], [3], [4, 5]];
List flatList= testList1.expand((item) => item).toList();
print(flatList); // [[1, 2, 3, 4, 5]

List testList2 = [1, 2, 3];
List computed = testList2.expand((item) => [item * 10]).toList();
print(computed); // [10, 20, 30]

fillRange

1
2
3
List testList = [1, 2, 3];
testList.fillRange(0, 3, 10); // 修改 List 元素，尾部开区间。
print(testList); // [10, 10, 10]

from

1
2
3
List testList = [1, 2, 3];
var clonedList = List.from(testList);
print(clonedList); // [1, 2, 3]

forEach

1
[1, 2, 3].forEach((item) => print(item)); // 1, 2, 3

map

1
2
List testList = [1, 2, 3];
print(testList.map((item) => item * 100).toList(); // [100, 200, 300]

reduce/fold

1
2
3
// 二者都是累加器，fold 可以设置初始值。
[1, 2, 3].reduce((item, nextItem) => item + nextItem); // 6
[1, 2, 3].fold(10, (item, nextItem) => item + nextItem); // 16

toSet

1
2
// 转换为 Set，常用于去重。
[1, 1, 2, 2, 3].toSet().toList(); // [1, 2, 3]

remove

1
2
3
4
// 删除元素，如果 List 中有多个符合条件的值，只会会删除List 中第一个符合条件的元素，改变原 List。
List testList = [1, 2, 3, 1];
testList.remove(1);
print(testList); // [2, 3, 1]

removeAt

1
2
3
4
// 删除 List 中指定索引位置的元素，返回被删除的内容，改变原 List。
List testList = [1, 2, 3, 1];
print(testList.removeAt(0)); // 1
print(testList); // [2, 3, 1]

removeLast

1
2
3
4
// 字面意思
List testList = [1, 2, 3, 1];
print(testList.removeLast()); // 1
print(testList); // [1, 2, 3]

removeWhere

1
2
3
List testList = [1, 2, 3, 1];
testList.removeWhere((item) => item == 1);
print(testList); // [2, 3]

removeRange

1
2
3
List testList = [1, 2, 3, 1];
testList.removeRange(0, 3); // 尾部开区间
print(testList); // [1]

getRange

1
2
List testList = [1, 2, 3, 1];
print(testList.getRange(0, 3).toList()); // [1, 2, 3] // 尾部开区间

join

1
[1, 2, 3].join(','); // 1,2,3

replaceRange

1
2
3
List testList = [1, 2, 3, 4, 5, 6];
testList.replaceRange(0, 3, [10, 11, 12, 13]);
print(testList); // [10, 11, 12, 13, 4, 5, 6]

shuffle

1
2
3
List testList = [1, 2, 3, 4, 5, 6];
testList.shuffle();
print(testList); // 打乱 List

setAll

1
2
3
List testList = [1, 2, 3, 4, 5, 6];
testList.setAll(1, [0, 0, 0]);
print(testList); // [1, 0, 0, 0, 5, 6]

setRange

1
2
3
List testList = [1, 2, 3, 4, 5, 6];
testList.setRange(0, 3, [0, 0, 0]);
print(testList); // [0, 0, 0, 4, 5, 6]

take/skip

1
2
3
4
5
// take 从 List 里取 n 个元素，skip 跳过 List 中的 n 个元素。
List testList = [1, 2, 3, 4, 5, 6];
print(testList.take(3).toList()); // [1, 2, 3]
print(testList.skip(4).toList()); // [5, 6]
print(testList.take(3).skip(2).take(1).toList()); // [3]

sort

1
2
3
4
5
List testStringList = ['a', 'aaa', 'A', 'BBB', 'C', 'z'];
List testStringList.sort((item, nextItem) => item.compareTo(nextItem));
testList.sort((item, nextItem) => item.compareTo(nextItem));
print(testList); // 1, 2, 3, 4, 5, 6]
print(testStringList); // [A, BBB, C, a, aaa, z]

sublist

1
2
3
List testList = [1, 2, 3, 4, 5, 6];
print(testList.sublist(0, 3)); // [1, 2, 3]
print(testList); // 1, 2, 3, 4, 5, 6]

Map

entries

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
print(testMap.entries.toList());
// [MapEntry(a: 1), MapEntry(b: 2), MapEntry(c: 3)]

keys

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
print(testMap.keys.toList());
// [a, b, c]

values

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
print(testMap.values.toList());
// [1, 2, 3]

isEmpty/isNotEmpty

Map 是否为空，return bool。

addAll

1
2
3
4
5
6
7
8
9
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.addAll({'a':100, 'd':99});
print(testMap); // {a: 100, b: 2, c: 3, d: 99}
testMap = {
  ...testMap,
  'a': 'hello',
  'x': 'world'
};
print(testMap); // {a: 'hello', b: 2, c: 3, d: 99, x: 'world'}

addEntries

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.addEntries({'a':100, 'd':99}.entries);
print(testMap); // {a: 100, b: 2, c: 3, d: 99}

clear

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.clear();
print(testMap); // {}

containsKey

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.containsKey('a'); // true
testMap.containsKey('d'); // false

containsValue

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.containsValue(1); // true
testMap.containsValue('1'); // false

forEach

1
2
3
4
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.forEach((key, value) {
  print('$key => $value'); // 1 => a , 2 => b , 3 => c
});

map

1
2
3
4
5
Map testMap = {'a':1, 'b':2, 'c':3};
Map newMap = testMap.map((key, value){
  return MapEntry(value, key);
});
print(newMap); // {1: a, 2: b, 3: c}

putIfAbsent

1
2
3
4
5
// 向一个 Map 中添加不存在的键值对，如果 key 已经存在，则原 Map 不变。
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.putIfAbsent('a', () => 'hello');
testMap.putIfAbsent('d', () => 'world');
print(testMap); // {a: 1, b: 2, c: 3, d: world}

remove

1
2
3
4
// 接收一个 key 作为参数，从 Map 中删除对应的键值对。
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.remove('a');
print(testMap); // {b: 2, c: 3}

removeWhere

1
2
3
4
// 接收一个 function 作为参数，从 Map 中删除符合条件的键值对。
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.removeWhere((key, value) => value > 1);
print(testMap); // {a: 1}

update

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.update('a', (value) => value + 100);
print(testMap); // {a: 101, b: 2, c: 3}

updateAll

1
2
3
Map testMap = {'a':1, 'b':2, 'c':3};
testMap.updateAll((key, value) => value * 100);
print(testMap); // {a: 100, b: 200, c: 300}

from

1
2
3
4
Map testMap = {'a':1, 'b':2, 'c':3};
Map newMap = Map.from(testMap);
print(testMap); // // {a: 1, b: 2, c: 3}
print(newMap); // {a: 1, b: 2, c: 3}

Date

基础

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
new DateTime.now(); // 获取当前时间 2020-08-13 16:10:13.098
DateTime(2020, 8, 12, 12, 12, 30); // 设置时间 2020-08-12 12:12:30.000
DateTime.parse('2020-01-01 09:30:36'); // 解析时间 2020-01-01 09:30:36.000
DateTime.tryParse('2020-1-01 09:30:36'); // 解析时间 null，格式不对返回 null，parse 会报错。

DateTime time = DateTime.parse('2020-01-11 09:30:36');
print(time.hashCode); // 305754722
print(time.year); // 2020
print(time.month); // 1
print(time.day); // 11
print(time.hour); // 9
print(time.minute); // 30
print(time.second); // 36
print(time.millisecond); // 0
print(time.microsecond); // 0
print(time.weekday); // 6
print(time.isUtc); // false
print(time.millisecondsSinceEpoch); // 毫秒 13 位时间戳
print(time.microsecondsSinceEpoch); // 微秒 16 位时间戳

/// 人性化时间
String timeSince(DateTime date, {bool longago = false, formater = "yyyy-mm-dd hh:ii:ss"}) {
  DateTime now = new DateTime.now();
  if(now.isBefore(date)) {
    return dateFormat(date, format: formater);
  }
  var interval = now.difference(date);
  if (longago) {
    int months = interval.inDays ~/ 30; // 向下取整，Dart 独有运算符。
    if (months >= 4) {
      return dateFormat(date, format: formater);
    }
    if (months >= 1) {
      return "$months 月前";
    }
    int weeks = interval.inDays ~/ 7;
    if (weeks >= 1) {
      return "$weeks 周前";
    }
  }
  if (interval.inDays >= 8) {
    return dateFormat(date, format: formater);
  }
  if (interval.inDays >= 1) {
    return "${interval.inDays} 天前";
  }
  if (interval.inHours >= 1) {
    return "${interval.inHours} 小时前";
  }
  if (interval.inMinutes >= 1) {
    return "${interval.inMinutes} 分钟前";
  }
  return "刚刚";
}

以上代码中，使用正则进行时间转换的方法 dateFormat，可以通过链接前往参考哦…

add

1
2
3
4
// 加 10 分钟
DateTime.now().add(Duration(minutes: 10));
// 减 1 小时
DateTime.now().add(Duration(hours: -1));

subtract

1
2
3
4
// 加 10 分钟
DateTime.now().subtract(Duration(minutes: -10));
// 减 1 小时
DateTime.now().subtract(Duration(hours: 1));

compareTo

1
2
3
4
DateTime now = DateTime.now();
now.compareTo(now.add(Duration(hours: -1))); // 1
now.compareTo(now); // 0
now.compareTo(now.add(Duration(minutes: 10))); // -1

difference

1
2
3
4
5
6
7
// 计算时间差
DateTime now = DateTime.now();
now.difference(now.add(Duration(hours: -1))); // 1:00:00.000000
var differenceObj1 = now.add(Duration(minutes: 10)).difference(now); // 0:10:00.000000
var differenceObj2 = now.difference(now.add(Duration(minutes: 10))); // -0:10:00.000000
print([differenceObj1.inDays, differenceObj1.inHours, differenceObj1.inMinutes]); // [0, 0, 10]
print([differenceObj2.inDays, differenceObj2.inHours, differenceObj2.inMinutes]); // [0, 0, -10]

isAfter

1
2
DateTime now = DateTime.now();
now.isAfter(now.add(Duration(hours: -1))); // true

isBefore

1
2
DateTime now = DateTime.now();
now.isBefore(now.add(Duration(hours: -1))); // false

toIso8601String

1
DateTime.now().toIso8601String(); // 2020-08-13T16:10:13.098

toLocal/toString/toUtc

1
2
3
print(DateTime.now().toLocal()); // 转为本地时间
print(DateTime.now().toString()); // 转字符串
print(DateTime.now().toUtc()); // 转 UTC

is-print-log

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// is 操作符能够判断类型，比如 A is B，能够返回 bool 类型，判断 A 是否属于 B 类型。
var test = 123;
if(test is String) {
  print('${test} is string');
} else if (value is int) {
  print('${test} is int');
} else if (value is double) {
  print('${test} is double');
} else {
  print('${test} is other type');
}

// print 可以打印我们调试的信息，但是数据很长时会打印不全，并且会影响渲染速度。
print('hello world!');

// log 只能打印字符串，在数据很长时可以全部打印出来，并且控制台会高亮，也会影响渲染速度。
log('hello world!');

// 建议设置一个全局变量定义开发环境，只在开发环境打印 log 或者 print。
相关推荐
bulb