1. Dart 中的基本类型

名称	说明	备注
num	数字类型	同时表示int和double
int	整型	Dart中整型只有int类型
double	浮点型	Dart中浮点型只有double类型
bool	布尔类型
String	字符串
StringBuffer	字符串Buffer
DateTime	时间日期
Duration	时间区间
List	列表
Set	Hash表
Map	kv容器
enum	枚举
dynamic	动态类型	可以表示所有类型，类似 Go 中的any/interface

2. 变量

2.1 变量的声明方式

2.1.1 弱类型

Dart 会自动推导变量类型

void main(List<String> args) {
  var a = 10;
  print(a.runtimeType); // int
  var b = "Sakrua";
  print(b.runtimeType); // String
}

2.1.2 强类型

void main(List<String> args) {
  // int 类型
  int a = 10;
  // String 类型
  // a = "Sakura"; // 报错
  String b = "Sakura";
  // dynamic 类型
  dynamic c = 10;
  c = "Sakura";
}

2.2 默认值

void main(List<String> args) {
  var a;
  String? b;
  bool? c;
  assert(a == null);
  assert(b == null);
  assert(c == false);

  print(a);
  print(b);
  print(c);

}

assert 检查点函数，如果不符合条件自己抛出错误并且终止程序运行

所有变量声明后都是 null , 强类型变量需要加 ? ，表示可以为空

2.3 使用场景

2.3.1 简化定义变量

void main(List<String> args) {
  var map = <String, dynamic>{};
  map["image"] = 1;
  map["title"] = "sakura";
  map["desc"] = true;
}

不用var就要写成Map<String，dynamic>

2.3.2 查询参数定义

使用动态类型封装请求参数

Future<Response<T>> get<T>(
  String path, {
  Map<String, dynamic> queryParameters,
  ...
});

Map<String, dynamic>? queryParameters ，查询参数值是动态

3. 常量

3.1 声明方式和异同点

Dart 中常量有两种什么方式final 和const

相同点

void main(List<String> args) {
  // 1.类型都可以省略
  final String a = 'ducafecat';
  final a1 = 'ducafecat';

  const String b = 'ducafecat';
  const b1 = 'ducafecat';

  // 2.初始后不能再赋值
  final a3 = 'ducafecat';
  a3 = 'abc'; // 报错

  const b3 = 'ducafecat';
  b3 = 'abc'; // 报错

}

不同点

const需要编译时就确定的值，而final 不需要确定的值

void main(List<String> args) {

  final now = DateTime.now();

  const now = DateTime.now(); // 报错
  // DateTime.now()需要运行时才能确定
}

如果 final变量是可变对象（列表），这个对象本身是可以修改的，只是不能指向新的对象。

void main(List<String> args) {
  final List ls = [11, 22, 33];
  ls[1] = 44;

  const List ls1 = [11, 22, 33];
  ls1[1] = 44; //报错
}

内存中重复创建，const 会把相同的内容引用同一片内存空间。而final 不会

void main(List<String> args) {
  final a1 = [11 , 22];
  final a2 = [11 , 22];
  print(identical(a1, a2)); // fale

  const b1 = [11 , 22];
  const b2 = [11 , 22];
  print(identical(b1, b2)); // true
}

identical 通过比较两个引用是否都是同一个对象判断是否相等

3.2 使用场景

3.2.1 const 全局变量

项目一开始就确定的常亮，不会变

// 本地存储key
  static const storageFirstOpen = 'first_open';
  static const storageLanguageCode = 'language_code';
  static const storageThemeCode = 'theme_code';
  static const storageToken = 'token';
  static const storageProfile = 'profile';

3.2.2 final 定义成员变量

好处是初始化的时候值不会遗漏

class PlaceholdWidget extends StatelessWidget {

  final String? assetImagePath;

  const PlaceholdWidget({
    Key? key,
    this.assetImagePath,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    ...
  }
}

3.2.3 const 定义组件

视图层面，因为const相同的组件属性只会创建一次，所以组件用const定义可以进行复用

const PlaceholdWidget({
  Key? key,
  this.assetImagePath,
}) : super(key: key);

4. 数字类型

void main(List<String> args) {
  // 十进制
  int a = 1001;

  // 十六进制
  int b = 0xF;
  print([a, b]);// [1001.15]

  // 二进制:Dart中二进制只能通过String Parse 获得
  var binaryStr = "1001";
  print(int.parse(binaryStr,radix: 2)); // 9

  // 科学计数法
  var bingint = 3e10;
  print(bingint); // 30000000000.0
}

4.1 数字和字符串互转

String → double/int

void main(List<String> args) {
  // String -> int
  var a =  int.parse("1122");

  // String -> Double
  var b =  double.parse("11.22");

  // String -> Double/int
  var c = num.parse("11.22");
  print(c.runtimeType); // double

  var d = num.parse("11");
  print(d.runtimeType); // int
}

int/double → String

void main(List<String> args) {
  // num -> String
  num Age = 1111;
  print(Age.toString().runtimeType);
}

5. 布尔类型

void main(List<String> args) {
  bool flag = true;
  assert(flag == false); // 断言,调试的时候用
}

6. 字符串类型

6.1 单双引号

void main(List<String> args) {
  var str = "Sakura";
  var str2 = 'Sakura';
}

Dart 中单双引号定义字符串都是一样的

6.2 字符串模版

void main(List<String> args) {
  var str = "Hello";

  var newStr = "Start $str"; // 如果有子集需要加{}
  print(newStr); // Start Hello
}

6.3 字符串拼接

void main(List<String> args) {
  // Dart 有多种方式拼接字符串
  var a = "hello" "Sakura";
  print(a); // helloSakura

  // 中间加空格
  a = "hello" " "  "Sakura";
  print(a); //hello Sakura
}

6.4 转义与取消转义

转义

void main(List<String> args) {

  var a = 'hello \\nSakura';
  print(a);
  // hello
  // Sakura
}

取消转义

void main(List<String> args) {
  // 在字符串前面加 r 表示取消转义
  var a = r'hello \\nSakura';
  print(a); // hello \\nSakura
}

6.5 常用的字符串方法

查找相关

void main(List<String> args) {
  var s = "It's My Time";
  // 1. 是否以 Time 开头
  print(s.startsWith("Time")); // false

  // 2.是否以Time结束
  print(s.endsWith("Time")); // true

  // 3.是否包含指定字符串
  print(s.contains("My")); // True

  // 4.指定字符串开始的索隐
  print(s.indexOf("My")); // 5
  print(s.indexOf("W")); // -1
}

提取数据

void main(List<String> args) {
  var s = "It's My Time";
  // 1. 截取字符串
  print(s.substring(3,8)); // s My

  // 2.分割字符串
  print(s.split(" ")); // 按照空格分割,返回一个列表
  // [It's, My, Time]
}

大小写转换

void main(List<String> args) {
  var s = "It's My Time";
  // 1.全部转大写
  print(s.toUpperCase()); // IT'S MY TIME

  // 2.全部转小写
  print(s.toLowerCase()); // it's my time
}

判断空字符串

void main(List<String> args) {
  var s = "   It's My Time   ";
  // 1.去除前后空格
  print(s.trim()); // It's My Time

  // 2.判断字符串是否为空
  print(s.isEmpty); // false

}

替换部分字符

void main(List<String> args) {
  var s = "It's My Time";
  // 1.去除前后空格
  print(s.replaceAll("My", "Your")); // It's My Time

  print(s.replaceAllMapped("My", Function))

}

字符串创建

var sb = StringBuffer();
sb..write('hello word!')
..write('my')
..write(' ')
..writeAll(['web', 'site', '<https://ducafecat.tech>']);
print(sb.toString());

hello word!my websitehttps://ducafecat.tech

7. 日期时间

7.1 日期基本使用

void main() {
  // 获取当前时间
  var time= DateTime.now();
  print(time);

  // 自定义时间
  var time2 = DateTime(2024,1,1,1,1,1,1,1);
  print(time2); // 2024-01-01 01:01:01.001001

  // 获取当前UTC格式时间
  var time3 =  DateTime.now().toUtc();
  print(time3);

  // 定义一个UTC 时间
  var time4 = DateTime.utc(2024,1,1,1,1,1,1,1);
  print(time4); // 2024-01-01 01:01:01.001001Z
}

7.2 日期相关方法

时间增减

void main() {
  // 获取当前时间
  var time= DateTime.now();

  // 增加时间
  time = time.add(Duration(hours: 1));
  print(time);

  // 减小时间
  time = time.subtract(Duration(hours: 4));
  print(time);
}

时间差

void main() {
  // 获取当前时间
  var time = DateTime.now();
  var time2 = time.add(Duration(hours: 1));

  // time2和time的时间差
  print(time.difference(time2)); // -1:00:00.000000
}

时间比较

void main() {
  // 获取当前时间
  var time= DateTime.now();
  var time2 = time.add(Duration(hours: 1));

  // time 是否在 time2 之后
  print(time.isAfter(time2)); // false
  // time 是否在 time2 之前
  print(time.isBefore(time2)); // true

  // 是否在同一时刻
  print(time.isAtSameMomentAs(time2)); // false
}

时间戳

void main() {
  // 获取当前时间
  var time = DateTime.now().millisecondsSinceEpoch;

  // Dart 中的时间戳是毫秒数
  print(time);
  // 想要描述需要除1000
  int  time2 = (time/1000).floor();
  time2 = (time/1000).truncate();
  time2 = time ~/1000; // 使用整数出发,等同于truncate
  print(time2);
}

目录CONTENT

Dart 基本类型