前言
dart语言中数据类型都是结构体格式，num类型是一个结构体，int类型是结构体，double也是结构体，这样子的好处就是封装一些属性和方法，这样子基本数据类型也可以调用方法和属性，使得代码更加简洁，可读性高。有些跟Swift语言有相似之处，有些跟shell脚本语言有相似之处。
一、变量常量
变量
- 使用
var声明一个变量，可以赋值不同的类型 -
var声明的变量如果没有初始化，那么它的值是null - 使用
final声明的变量只能赋值一次 -
const常量，声明的时候就得初始化
示例
var a;
print(a); // 输出null
a = 10; // 赋值给int类型
print(a); // 输出 10
a = "Hello World"; // 赋值给字符串类型
print(a);
final b;
b = 100;
print(b); // 输出 100
// b = 99; // 再赋值99就报错，只能赋值一次
const c = "psy"; // 声明的时候就初始化
//const c ;
//c = "psy"; // 这样是不允许的
print(c);
二、数据类型
1、数值型number类型
这其中示例只是演示了其中的一部分方法可以按住command + 单击数据类型进入源码看看其包含的属性和方法，都有注释说明：
1.1 int类型，继承自num类型
1.2 double类型，继承自num类型
示例
void numDemo(){
int a = 10;
print(a);
print(a.isEven?"偶数":"奇数"); // 偶数
print(a.isOdd?"奇数":"偶数"); // 奇数
double b;
b = 11;
// 转换类型
print(b.toInt().isEven?"偶数":"奇数");
print(b.toInt().isOdd?"奇数":"偶数");
// 算数运算符：+ ，- ，* ， / ，%（取模），~/（取整）
print(a ~/ b);
print(a >> 1);
}
输出结果：
10
偶数
偶数
奇数
奇数
0
5
2、字符串类型
字符串可以使用单引号也可以使用双引号，字符串片接可用+拼接。
字符串可以多行放置，以分号为一个语句的结束。
字符串输出结果可以使用美元符号加一对花括号
三引号引起的字符串会原样输出（包含特殊字符换行符）
.......
具体看示例后面对应的注释
示例
void stringDemo(){
var a = "panshuyan"; // 字符串可用双引号
var b = 'psy'; // 字符串可用单引号
print(a + b); // 字符串拼接，可直接加，会直接拼到后面
String str = "这是字"
""
"符串"; // 字符串可换行放，以分号为一个语句，与"这是字符串"等价
print("str = ${str}"); // 美元符号加一对花括号，可输出值
String str1 = "66";
String str2 = ''' 这是
个什么
能？ '''; // 三个单引号，字符串会原样输出
print(str2);
print(str1.length); // 不能计算str2的长度，str2.length否则抛出异常
print(a[0]); // 可以通过下标取出一个一个字符
print(a[1]);
print(b * 2); // 乘以2，表示在后面拼接一份一样的字符串，乘以3，三份，以此类推
int inta = 10;
int intb = 20;
print('inta + intb = ${inta + intb}'); // 美元符+花括号，里面是运算表达式
int c = inta + intb;
print("inta + intb =$c");
String str3 = "字符串\n转义字符"; // 转义字符 \n 换行符
print(str3);
print(r"字符串\n转义字符"); // 如果不想让字符串的转义字符起作用，可在前面加一个 r
print(str3.length); // 转义字符有作用的时候，\n代表一个字符长度 输出 8
}
输出结果：
panshuyanpsy
str = 这是字符串
这是
个什么
能？
2
p
a
psypsy
inta + intb = 30
inta + intb =30
字符串
转义字符
字符串\n转义字符
8
3、布尔bool类型
布尔值，在dart中取值是true和false
4、列表list类型
list与数组有点类似，分可变list和不可变list，不可变list表示list数量和元素都不可以增删改，可变list可增删改
示例
/* Dart中的列表
* 可变list和不可变list
* 可变： var list1 = [1,2,3];
* 不可变：var list1 = const [1,2,3]; 元素不可变
* */
void listDemo(){
var list1 = [1,2,3,"psy"];
print(list1);
print(list1[2]);
list1[3] = "足球";
print(list1[3]);
var list2 = const [1,2,3,"psy"];
//list2[3] = "足球"; // 运行就会报错
var list3 = ["中国","俄罗斯","巴基斯坦"];
print(list3);
print(list3.length); // 计算元素个数
list3.add("添加的"); // 添加元素
print(list3);
list3.insert(1, "插入的"); // 根据下标插入元素
print(list3);
list3.remove("插入的"); // 删除指定元素
print(list3);
//list3.removeAt(2); // 根据下标删除
list3.removeLast(); // 删除最后一个
print(list3);
list3.clear() ; // 清空list
print(list3);
//排序
List <int> list4 = [3,5,1,2,9,8,3];
list4.sort(); // 默认等于list4.sort((a,b) => a.compareTo(b)); 从小到大排序
print(list4);
list4.sort((a,b) => b.compareTo(a));
print(list4);
var list5 = ["three","one","four","two"];
list5.sort((a,b) => a.length.compareTo(b.length));
print(list5);
list5.sort((a,b) => b.length.compareTo(a.length));
print(list5);
print(list4.sublist(3,6)); // 截取list，从index = 3开始（包含3），到index=6（不包含6）
}
输出结果为：
[1, 2, 3, psy]
3
足球
[中国, 俄罗斯, 巴基斯坦]
3
[中国, 俄罗斯, 巴基斯坦, 添加的]
[中国, 插入的, 俄罗斯, 巴基斯坦, 添加的]
[中国, 俄罗斯, 巴基斯坦, 添加的]
[中国, 俄罗斯, 巴基斯坦]
[]
[1, 2, 3, 3, 5, 8, 9]
[9, 8, 5, 3, 3, 2, 1]
[one, two, four, three]
[three, four, one, two]
[3, 3, 2]
5、键值对（字段）-Map 类型
Map就像Dictionary字典一样，是键值对存在的，也分可变和不可变Map，不可变Map就是无法增删改。
示例
void mapDemo(){
// 键值对
// 可变键值对Map：
Map json1 = {"food":"apple","trunk":"water"};
print(json1); // 打印整个amp
print(json1["food"]); // 根据key，取值
json1["food"] = "orange"; // 根据key，修改对应的值
print(json1);
json1["ok"] = "finish"; // 增加键值对
print(json1);
print(json1.values); // 打印所有的值
print(json1.keys); // 打印所有的key
print(json1.containsKey("key")); // 判断是否包含某一个key
print(json1.containsValue("finish"));// 判断是否包含某一个值
json1.remove("ok"); // 根据key删除键值对
print(json1);
var list = ["中国","俄罗斯","巴基斯坦"];
var json2 = list.asMap(); // list转成map,自动以index作为key，从0开始
print(json2);
// 不可变的Map，不可增删改
var json3 = const {"man":"男","female":"女"};
}
输出结果为：
{food: apple, trunk: water}
apple
{food: orange, trunk: water}
{food: orange, trunk: water, ok: finish}
(orange, water, finish)
(food, trunk, ok)
false
true
{food: orange, trunk: water}
{0: 中国, 1: 俄罗斯, 2: 巴基斯坦}
{man: 男, female: 女}
三、运算符
??= 和 ??运算符，具体的使用示例如下：
示例
void operatorDemo(){
// ??= 运算符
var a;
a ??= 10; // 如果a为null，就执行赋值，不为null就不赋值
a ??= 3; // 所以这里无法赋值
print(a);
a = 6; // 这里还是可以赋值成功
print(a);
// ?? 操作符
var b;
b = 2;
// 判断顺序左至右，1:b有值，a为null，返回b 2:b为null，a有值，返回a 3:b、a都有值，返回右边的a
var c = b ?? a;
print(c);
}
输出结果为：
10
6
2
四、函数
方法也是一个对象，其返回值类型和参数类型可以忽略（但是不建议这么干，可读性差）。如果方法中只有一条语句，可以使用 => 表达式
示例
/* Dart 中函数
* 方法也是一个对象，其返回值类型和参数类型可以忽略（但是不建议这么干，可读性差）
* 如果方法中只有一条语句，可以使用 => 表达式
* 匿名方法：没有方法名称的方法
*
* */
void functionDemo(){
print(addTest(1, 5));
print(sum(2, b: 5));
print(sum(2, c: 5));
print(sum(2, b: 5, c:5));
// 立即执行方法/函数
((){
print("打印");
});
// 匿名方法作为参数
sum2(2, (bb){
print(bb);
},b: 6,c:3);
}
addTest(a , b) => a + b;
// 可选参数，可无序：传递参数的时候必须带上形参名
sum(int a , { b, c }){
b ??= 0;
c ??= 0;
return a + b - c;
}
// 可选参数，有序：传递参数的时候按顺序对应的，如果传2个值，就一定是a和b
sum0(int a , [ b, c ]){
b ??= 0;
c ??= 0;
return a + b - c;
}
// 可以添加类型，可无序，但是要是可为null值，加？
sum1(int a , {int? b, int? c }){
b ??= 0;
c ??= 0;
return a + b - c;
}
// 可以添加类型，可以不要？，但是要有初始值
sum2(int a , func(var bb), {int b = 0, int c = 0 }){
func(a + b - c);
}
输出结果
6
7
-3
2
5
五、闭包
- 定义在函数里面的函数就是闭包，闭包也是一个对象
- 闭包的作用：可以访问外部函数的局部变量，就是匿名函数被外部持有，导致函数局部变量内存不释放的原理实现的。
示例
/*
* 闭包：closure
* ：定义在函数里面的函数就是闭包，闭包也是一个对象
* ：闭包的作用：可以访问外部函数的局部变量，就是利用block的循环引用实现函数局部变量不释放的原理实现的
*/
void closureDemo(){
var func = funcA();
func();
func();
func();
func();
print("*************************");
var func1 = funcA();
func1();
func1();
func1();
func1();
}
funcA(){
int count = 0;
return () => print(count++); // 将函数内部的匿名函数传到外面，由外面持有，
// 就保证了其内部函数的局部参数不被释放
}
输出结果为：
0
1
2
3
*************************
0
1
2
3
网友评论