Dart学习笔记Dart 笔记数据类型 int double bool 关键字小写 var 关键字自动推导数据类型 d

Dart 笔记

数据类型

int double bool 关键字小写
var 关键字自动推导数据类型
dynamic 定义的变量不受数据类型限制，可以随意赋值不同类型的数据（js）

void main() {
  String str = "Hello, Dart!";
  int num = 100;
  double pi = 3.14;
  bool isTrue = true;
  List<String> list = ["apple", "banana", "orange"];
  Map<String, int> map = {"one": 1, "two": 2, "three": 3};
  Set<String> set = {"apple", "banana", "orange"};

  var str1 = "hello world"; // String

  // dynamic
  dynamic dynamicVar = 'I can be anything!';
  dynamicVar = 10;
  dynamicVar = true;
}

常量

const final 都是用来定义常量
都可以显式指定类型，也可以自动推导类型
const 在编译时已经固定值，不可更改
final 等第一次运行后取到值，之后不可更改

void main() {
  const PI = 3.14;
  const double PI2 = 3.14159265358979323846;
  final TIME = DateTime.now();
}

数据类型转换

数据类型获取

.runtimeType 获取数据类型

void main() {
  String str = '123';
  print(str.runtimeType); // String

  int num = 10;
  print(num.runtimeType); // int

  dynamic dynamicVar = 'Hello';
  print(dynamicVar.runtimeType); // String

  dynamicVar = true;
  print(dynamicVar.runtimeType); // bool
}

数据类型判断

is 判断数据类型

void main() {
  var str = 'Hello';
  print(str is String); // true
  print(str is int); // false
}

数据类型转换

.toDouble() int 转 double
.toInt() double 转 int，会忽略小数点后
.round() double 转 int，四舍五入
.toString() 数字转 string
string 转数字
- int.parse([string]) 如果 string 带有小数，转换会报错
- int.tryParse([string]) 如果 string 带有小数，返回 null
- double.parse([string]) string 转 double

void main() {
  // int to double
  int intVar = 10;
  print(intVar.toDouble()); // 10.0

  // double to int
  double doubleVar2 = 11.5;
  print(doubleVar2.toInt()); // 11
  print(doubleVar2.round()); // 12

  // 数字 to string
  int intVar2 = 111;
  print(intVar2.toString()); // 111

  // string to 数字
  String strNum = '123.45';
  // print(int.parse(strNum)); // Error: FormatException: Invalid radix-10 number (at character 1)
  print(int.tryParse(strNum)); // null
  print(double.parse(strNum)); // 123.45
}

字符串扩展

void main() {
  String str = 'Dart';
  int num = 2;

  // 字符串拼接
  var msg = '当前语言是${str}，今天是第${num}天学习';
  print(msg);

  // 字符串是否为空
  String str1 = '';
  print(str1.isEmpty); // true
  print(str1.isNotEmpty); // false

  // 浮点数精度，会四舍五入
  double pi = 3.1415926535897932;
  String piStr = pi.toStringAsFixed(3);
  print(piStr); // 3.142
}

List(数组)

修改值不能超出 list 长度

.length 获取 list 长度

void main() {
  List<String> names = ['hello'];
  var ages = [25, 30, 35];

  // names[3] = 'dart'; // Error: Index out of range
  // ages[3] = 40; // Error: Index out of range
  print('names: $names, length: ${names.length}'); // 获取list长度
  print(ages);
}

.add(值) 新增

names.add('dart');
print(names);

.insert(索引, 值) 指定索引处插入元素

names.insert(1, '100');
print(names);

.insertAll(索引, 数组) 指定索引处插入数组

names.insertAll(1, ['101', '102']);
print(names);

.removeAt(索引) 删除指定索引的元素

names.removeAt(3);
print(names);

.clear() 清空 list

names.clear();
print(names);

for() {} 遍历 list

for (int i = 0; i < names.length; i++) {
  print('names[$i]: ${names[i]}');
}

for...in 遍历 list

for (String name in names) {
  print('name1: $name');
}

.forEach(func) 遍历 list

names.forEach((name) {
  print('name2: $name');
});

.isEmpty list 是否为空
.isNotEmpty list 是否不为空

void main() {
  print(names.isEmpty); // false
  print(names.isNotEmpty); // true
}

.contains(值) 是否包含指定元素

void main() {
  List<String> names = ['hello'];
  print(names.contains('world')); // false
}

.join(连接字符) 将 list 的所有元素使用指定字符拼接

void main() {
  List<String> names = ['hello', 'world'];
  var joinStr = names.join(', ');
  print('joinStr: $joinStr'); // hello, world
}

.split(字符) 将 list 的使用指定字符分割

void main() {
  var string = '1,2,3,4,5';
  var list = string.split(',');
  print('list: $list'); // list: [1, 2, 3, 4, 5]
}

将 list 所有元素统一处理后，获取新的 list
使用 .map(func) 统一处理后，使用 .toList() 转换成 list

void main() {
  var list = [1, 2, 3, 4, 5];
  var newList = list.map((item) {
    return item * 10;
  }).toList();
  print(newList);
}

过滤 list 所有元素

void main() {
  var list = [1, 2, 3, 4, 5];
  var newList2 = list.where((item) {
    return item > 2;
  }).toList();
  print(newList2);
}

遍历 list 元素是否有符合要求的

void main() {
  var list = [1, 2, 3, 4, 5];
  var isBool = list1.any((item) {
    return item > 2;
  });
  print(isBool); // true
}

遍历 list 元素是否都符合要求

void main() {
  var list = [1, 2, 3, 4, 5];
  var isBool = list1.every((item) {
    return item > 2;
  });
  print(isBool); // false
}

Set(集合)

Set是一种不允许重复元素的容器类型，而且Set是无序的

.length 获取 list 长度

void main() {
  Set<int> set = {1, 2, 3};
  // var set2 = {1, 2, 3};
  print(set); // {1, 2, 3}
  print(set.length);
}

.add(值) 添加元素

void main() {
  var set = {1, 2, 3};
  set.add(10);
  print(set);
}

.remove(第几个元素) 删除元素

void main() {
  var set = {1, 2, 3};
  set.remove(1);
  print(set);
}

.clear() 清空集合

void main() {
  var set = {1, 2, 3};
  set.clear();
  print(set);
}

.toList() set转list

void main() {
  var set = {1, 2, 3};
  List<int> list = set.toList();
  print(list); // [2, 3, 10]
}

for 遍历set

void main() {
  var set = {1, 2, 3};
  List<int> list = set.toList();
  for (var i = 0; i < list.length; i++) {
    print(list[i]); // 2 3 10
  }
}

for...in 遍历set

void main() {
  var set = {1, 2, 3};
  for (var item in set) {
    print(item); // 2 3 10
  }
}

.forEach(func) 遍历set

void main() {
  var set = {1, 2, 3};
  set.forEach((item) {
    print(item); // 2 3 10
  });
}

.isEmpty 判断set是否为空
.isNotEmpty 判断set是否不为空

void main() {
  var set = {1, 2, 3};
  print(set.isEmpty); // false
  print(set.isNotEmpty); // true
}

.contains(值) 判断set是否包含某个值

void main() {
  var set = {1, 2, 3};
  var contains = set.contains(2);
  print(contains); // true
}

.join(分隔符) 将set通过指定字符串拼接

void main() {
  var set = {1, 2, 3};
  var join = set.join(', ');
  print(join); // 2, 3, 10
}

.map(func) 遍历set并返回一个新的set

void main() {
  var set = {1, 2, 3};
  var map = set.map((item) {
    return item * 10;
  }).toSet();
  print(map); // {20, 30, 100}
}

.union() 合并两个set(并集)

void main() {
  var set1 = {1, 2, 4};
  var set2 = {4, 5, 6};
  var union = set1.union(set2);
  print(union); // {1, 2, 4, 5, 6}
}

.intersection() 求两个set的交集

void main() {
  var set1 = {1, 2, 4};
  var set2 = {4, 5, 6};
  var intersection = set1.intersection(set2);
  print(intersection); // {4}
}

.difference() 求两个set的差集

void main() {
  var set1 = {1, 2, 4};
  var set2 = {4, 5, 6};
  var difference = set1.difference(set2);
  print(difference); // {1, 2}
}

Map(key: value)

void main() {
  Map<String, int> map = {'a': 1, 'b': 2, 'c': 3};
  // var map2 = Map<String, int>();
  print(map);
  print(map.length); // 3
}

添加元素

void main() {
  map['d'] = 4;
  print(map);
  print(map['a']); // 1
}

.remove([key]) 删除元素

void main() {
  map.remove('d');
  print(map); // {a: 1, b: 2, c: 3}
}

.clear() 清空元素

void main() {
  map.clear();
  print(map); // {}
}

for...in 遍历元素

void main() {
  for (var entry in map.entries) {
    var key = entry.key;
    var value = entry.value;
    print('key: ${key}  value: ${value}');
  }
}

.forEach(func) 遍历元素

void main() {
  map.forEach((key, value) {
    print('key: ${key}  value: ${value}');
  });
}

.keys .values 获取map所有的key和value

void main() {
  for (var key in map.keys) {
    print('key: ${key}');
  }
  for (var value in map.values) {
    print('value: ${value}');
  }
}

.isEmpty 判断map是否为空
.isNotEmpty 判断map是否不为空

void main() {
  print(map.isEmpty); // false
  print(map.isNotEmpty); // true
}

.containsKey([key]) 判断map是否包含key
.containsValue([value]) 判断map是否包含value

void main() {
  var containsKey = map.containsKey('e');
  var containsValue = map.containsValue(2);
  print(containsKey); // false
  print(containsValue); // true
}

.keys.toList() 将map的key转换为list
.values.toList() 将map的value转换为list

void main() {
  var keysList = map.keys.toList();
  var valuesList = map.values.toList();
  print(keysList); // [a, b, c]
  print(valuesList); // [1, 2, 3]
}

.entries.map(func) 将map的key和value转换为list

void main() {
  var entriesList = map.entries.map((entry) {
    var key = entry.key;
    var value = entry.value;
    return '${key}: ${value}';
  }).toList();
  print(entriesList); // [a: 1, b: 2, c: 3]
}

类（class）

class 定义类
构造函数和类名相同

class Student {
  String name;
  int age;
  late String school; // late 关键字表示稍后会初始化

  // 普通构造函数
  // Student(String name, int age) {
  //   this.name = name;
  //   this.age = age;
  // }

  // 构造函数简写
  // Student(String name, int age) : this.name = name, this.age = age + 1;
  Student(this.name, this.age);

  void study() {
    print("${name} is studying, age is ${age}");
  }

  void sayName() {
    print("My name is ${name}");
  }

  void sayAge() {
    print("My age is ${age}");
  }
}

void main() {
  // `..` 是级联操作符，可以在同一个对象上连续调用多个方法或访问多个属性
  Student("张三", 20)
    ..sayName()
    ..sayAge()
    ..study();
}

封装

_ 下划线定义私有属性和私有方法
私有属性和私有方法只能在类内部使用
get 关键字定义getter方法
set 关键字定义setter方法
get 和 set 通过属性方式使用

// Phone.dart
class Phone {
  late String name;
  late int _valtage;

  Phone(this.name, this._valtage);

  // getter
  get getValtage {
    return this._valtage;
  }

  // setter
  set setValtage(int valtage) {
    this._valtage = valtage;
  }

  void call() {
    print('call: ${this.name}');
    print('_valtage: ${this._valtage}');
    this._get_valtage();
  }

  void _get_valtage() {
    print('_valtage: ${this._valtage}%');
  }
}

import 引用自定义的类

// main.dart
import 'utils/Phone.dart'; // 引用自定义的类

void main() {
  Phone phone = Phone('xiaomi', 5);
  phone.call();

  // Error: The getter '_get_valtage' was called on null.
  // 直接使用私有属性报错
  // phone._get_valtage();

  phone.setValtage = 10; // setter
  var valtage = phone.getValtage; // getter
  print('valtage: ${valtage}%');
}

数据和json字符串

json: {"name":1,"age":2}

字典: {name: 1, age: 2}

列表: ["a","b","c"]

jsonEncode(字典) 字典转json
jsonEncode(列表) 列表转json

import 'dart:convert';

void main() {
  // `jsonEncode(字典)` 字典转json
  Map<String, int> map = {'name': 1, 'age': 2};
  String jsonStr = jsonEncode(map);
  print(jsonStr); // {"name":1,"age":2}

  // `jsonEncode(列表)` 列表转json
  List<String> list = ['a', 'b', 'c'];
  String listJson = jsonEncode(list);
  print(listJson); // ["a","b","c"]
}

jsonDecode(json字符串) json转字典
jsonDecode(json字符串) json转列表

import 'dart:convert';

void main() {
  // `jsonDecode(json字符串)` json转字典
  Map<String, dynamic> map2 = jsonDecode(jsonStr);
  print(map2); // {name: 1, age: 2}

  // `jsonDecode(json字符串)` json转列表
  List<dynamic> list2 = jsonDecode(listJson);
  print(list2); // [a, b, c]
}

对象转json
对象中定义一个方法将数据转成字典，再通过 jsonEncode() 将数据转成json

import 'dart:convert';

class Person {
  String name;
  int age;

  Person(this.name, this.age);

  // 将对象转换为JSON字符串
  Map<String, dynamic> toJson() {
    return {'name': this.name, 'age': this.age};
  }
}

void main() {
  // 对象转json
  Person person = Person('xiaomi', 5);
  String personJson = jsonEncode(person.toJson());
  print(personJson); // {"name":"xiaomi","age":5}
}

库

内置库

dart:* 使用内置库

import 'dart:math';

void main() {
  int maxNum = max(10, 5);
  print(maxNum); // 10
}

第三方依赖

新建 pubspec.yaml 文件

name: hello_dart # 项目名称
description: My Dart application # 项目描述
version: 1.0.0  # 项目版本

environment:  # 指定sdk版本约束
  sdk: '>=2.12.0 <3.0.0'

dependencies:
  http: ^0.13.6


dev_dependencies:
  # 添加开发时需要的依赖包，如果有的话

下载依赖

dart pub add 库名

使用库
- import 库 as 别名
- 别名.方法()

import 'package:http/http.dart' as http; // 库 as 别名

void main() async {
  var url = Uri.http('www.doubibiji.com', '/apis/category/allNoteList', {});
  var response = await http.get(url);
  if (response.statusCode == 200) {
    print('success');
  } else {
    print('fail');
  }
}

自定义库管理

// Add.dart

int add(int a, int b) {
  return a + b;
}

// Sub.dart

int sub(int a, int b) {
  return a - b;
}

// my_util.dart

library myMath;

export 'Add.dart';
export 'Sub.dart';

// main.dart

import 'utils/my_math.dart';

void main() async {
  int num1 = add(1, 2);
  int num2 = sub(2, 1);
  print(num1); // 3
  print(num2); // 1
}