Dart语言简要

入口函数

所有方法从入口main开始；

void main(){}; // 表示没有返回值
// 或者
main() {};

注释

// 反斜杠的注释
/// 三个斜杠的注释
/*
	多行注释
*/

变量

Dart可以预先定义，自动推断类型；也可以直接定义类型；

var str = "Hello"; // 会自动推断类型
// 通过类型定义,这个时候不需要var关键字， 使用类型定义的变量类型不同时会报错，比如int不能定义字符串类型
String str2 = "Hello World"; // 字符串
int num = 123; // 数字

常量

• const定义；
• final定义；
• 常量都不允许修改；
• 两者都不允许修改；
• const和final的区别：
  • finnal可以先定义在赋值(在类中的使用除外)，但是const必须定义+赋值；
  • const 修饰的变量是在编译期，程序运行前就有确定值。比如new DateTime.now() 这种需要等到编译才能获取到值的是不行的；但是final可以；
  • final出了一般的常量，就是可以定义编译时候获取的常量值；
  • final 只可用来修饰变量，const 关键字即可修饰变量也可用来修饰 常量构造函数

命名规则

• 变量名必须由字母，数字，下划线或者$组成；
• 开头不能是数字；
• 标识符不能是关键字或者保留字；
• 变量名称区分大小写；

数据类型

字符串类型

字符串的定义

String关键词指定变量类型，也可以使用var定义；

除了单引号和双引号，也可以使用三个单引号或者三个双引号，后者使用三个能保留换行等格式,可以书写多行的字符串；

var str = "345";
String str = "123";
String str2 = """123
	456
""";
String str3 = '''123
	456
''';

字符串的拼接

// 使用 $ 符号
String str1 = "Hello";
String str2 = "World";
print("$str1 $str2");
// 使用 + 号
print(str1 + str2);

数值类型

数值的定义

// int类型不能赋值浮点型，例如：int c = 12.3;这样子会报错，但是double类型可以赋值整型的数值；
int a = 123;
double b = 23.5;
double d = 45;

布偶类型

布偶的定义

// 布偶值只有两个值 
bool flag1 = true;
bool flag2 = false;

⚠️：在Dart中数值类型使用（==）不会进行转换，比如：

int a = 12;
int b = "12";
if (a == b) {
  print("真");
}else {
  print("假"); // 会打印出假，因为a为数值类型，b为字符串类型，不会像Js一样转换；
}

数组类型

数组的定义

// 1.普通定义
var list1 = ['1', 20, true];
print(list1);
print(list1.length); // 获取长度
print(list1[0]); // 访问元素通过下标开始获取
list1.length = 0; // 可以清空数组
// 2.定义数组元素类型
var list2 = <String>["1", "2", "3"];
// 使用add增加数据
var list3 = [];
list3.add("123");
print(list3);
// 3.创建固定长度的数组
// 创建长度为2，""填充的数组，不能使用add添加数据,该方法同样不能修改长度；
var list4 = List.filled(2, ""); 
// 创建指定类型的固定长度数组
var list5 = List<String>.filled(2, "");

Maps类型

Maps的定义

// 1.普通定义
// 与JS不同在定义Maps的key时候必须写上引号
var person = {
  "name": "mack",
  "age": 12,
}
// 当我们需要访问Maps的属性时候，不能使用Js中点语法,必须使用中括号
print(person["name"]);

// 2.使用new定义
var p = new Map();
p["name"] = "mack";
p["age"] = 123;
p["work"] = ["12", '3'];

判断数据类型

使用 is 关键词判断

var str = "123";
if (str is String) {
  	print("是字符串类型");
}else {
  print("是其他类型");
}

运算符

算数运算符

void main() {
  	int a = 10;
  	int b = 5;
		print(a+b); // 加
  	print(a-b); // 减
  	print(a*b); // 乘
  	print(a/b);	// 除
  	print(a%b); // 求余
  	print(a~/b); // 取整
}

关系运算符

void main() {
  int a = 10;
  int b = 5;
  print(a == b); // 判断是否相等
  print(a != b); // 判断是否不等
  print(a > b); // 判断是否大于
  print(a < b); // 判断是否小于
  print(a <= b); // 判断是否小于等于
  print(a >= b); // 判断是否大于等于
}

逻辑运算符

void main() {
  bool flag = true;
  bool other = false;
  // ! 取反
  print(!flag); // false
  // && 并且, 全部为true则返回true， 否则返回false
  print(flag && other); // false
  // || 或者， 全部为false返回false， 否则返回true
  print(flag || other); // true
}

赋值运算符

void main() {
  // = 普通赋值;
  int a = 10;
  // 如果为空赋值；如下， 如果b为空那么久赋值为23
 	int b = 20;
  b ??= 23;
  // 当我们直接定义一个空的值int会报错，按照官方写法必须这样写
  int? c;
  c ??= 23;
  // 复合加 +=
  c += a; // c = c + a;
  // 复合减 -=
  c -= a; // c = c - a;
  // 复合乘法
  c *= a; // c = c * a;
  // 复合除法 /=
  c /= a; // c = c / a; 
  // 复合取余
  c %= a; // c = c % a;
  // 复合取整
  c ~/= a; // c = c ~/ a;
}

条件运算符

if ... else 和 switch ... case 参照JavaScript;

void main() {
  // 三目运算符
  bool flag = true;
  String str = flag ? "true" : "false";
  // ?? 运算符
  var a = 10;
  var b = a ?? 10; // 如果 a 为空那么就把 10 赋值给 b；
}

类型转换

int 与 String的转换

void main() {
   int a = 10;
   String str = '124';
   String str_2 = "123.5";
  // int  => String: toString()
 	var myStr = a.toString();
  
  // String => int/double: int.parse() / double.parse()
  var myNum = int.parse(str);
  var myDoubleNum = double.parse(str_2);
}

其他类型转换成布偶类型

// 通过isEmpty判断字符串是否为空
var str = "";
if (str.isEmpty) {
  print("空");
}else {
  print("不为空");
}
// 当数值等定义未赋值可以使用 vara == null 判断是否有值；
// 判断是是NaN
var myNum = 0/0;
if (myNum.isNaN) {
  print("是NaN");
}else {
  print("不是NaN");
}

List基本方法

长度 – 返回长度

listVarlength;

判断是否为空 – 返回布偶值

listVar.isEmpty; 判断是否为空

listVar.isNotEmpty; 判断是否不为空

反转 – 返回反转后的数据

listVar.revered; 反转后的数据不是数组，需要使用 toList() 进行转换成数组；

添加数据 – 没有返回值，但是修改原数组

listVar.add(""); 固定长度的数组不能增加数据

拼接数组 – 返回拼接后的数据，也可用批量添加数组元素

listVar.addAll(['a', 'b']); 返回拼接后的数组

查找 – 返回索引

listVar.indexOf("a"); 找到返回下标，找不到返回 -1；

删除 – 返回布偶值 / 返回删除的元素

listVar.remove("a"); 传入具体值

listVar.removeAr(1) 传入下标

修改 – 没有返回值，修改原数组

listVar.fillRange(startIndex, endIndex, item);

插入 – 没有返回值，修改原数组

listVar.insert(index, item);

listVar.insertAll(index, []);

转换成字符串 – 返回转换后的数据

listVar.join(',') 参数是需要转换分割的标识

字符串转换成数组 – 返回转换后的数据

listVar.split(",") 参数是需要转换分割的标识

Set类型

Set主要是去除数组中重复的类型

Set是没有顺序且不能重复的所以不能使用index访问

var a = new Set();
a.add("1");
a.add("2");
// 无法添加相同的数据;
// Set返回不是标准的数组格式，需要使用 toList() 转换成标准的数组
a.toList(); // ["1", "2"]
// 标准数组的去重
var list = [1,2,3,4,5,4,3,2,1];
a.addAll(list); // {1,2,3,4,5}
a.toList(); // 再通过toList转换成数组；

Map类型

// 两种定义
var person = {
  "name": "mack",
  "age": 2,
}
var copyPerson = new Map();
copyPerson["name"] = "jack"

key – 返回map的keys的类数组

// keys 返回key的类数组，使用toList转换成数组
print(person.keys); 

values – 返回map的value的类数组

// values 返回values的类数组，使用toList转换成数组
print(person.values); 

判断是否为空

print(person.isEmpty); // 判断是否为空
print(person.isNotEmpty); // 判断是否不为空

addAll – 增加多个数据

person.addAll({
  "gender": "男",
  "ad": "none"
})

remove – 删除属性

person.remove("name");

containsValue – 判断map中是否包含一个值

person.containsValue(2); // 包含的话返回true

containsKey – 判断map中是否包含一个key

person.containsKey("name"); // 包含的话返回true

循环

for循环

for (var i = 0; i < 100; i++) {}

for…in 循环

for (var item in list) {}

forEach

list.forEach((item) { // forEach中只有一个值传入 Map数据有两个值的传入
  	print(item)
})

map循环

var newList = list.map((item) {
  	return item * 2;
})
newList.toList(); // map直接返回的需要转换才能成数组

where – 循环判断（过滤）

var newList = list.where((item) {
  	return item > 5; // 返回大于 5 的值
})
newList.toList(); // map直接返回的需要转换才能成数组

any – 只要集合有满足的返回true

对比js的循环中的some

var newList = list.any((item) {
  	return item > 5; // 只要有大于5的返回true否则是false
})

every – 集合每一个满足条件返回true

对比js的every

var newList = list.every((item) {
  	return item > 5; // 每个大于5的返回true否则是false
})

除了List可以满足实现使用循环，Map或者Set也可以使用循环

函数

自定义方法:

/*
	返回类型 方法名称(参数1， 参数2 ....) {
		方法体
		return 返回数据
	}
*/