三. Dart语法学习2
2020-07-20 本文已影响0人
StrivEver
- Dart基本类型常用Api介绍
- 布尔类型
Dart中布尔类型很简单。如C语言中用bool声明，对应true & false
- 数字类型
intdouble都继承num抽象类，他两也是抽象类
//抽象类 num定义
abstract class num implements Comparable<num> {
}
- 字符类型String
字面量表示两种方法:
- 单行使用单引号或者双引号包裹
- 多行使用三个单引号或者三个双引号包裹
String textA = '字符串A';
String textB = "字符串A";
String textC = '''
字符串C,
字符串C,
字符串C,
字符串C,
''';
String textD = """
字符串D,
字符串D
""";
字符串常用Api：
//获取字符长度
var length = text.length;
//方法删除所有前导和尾随空格返回一个新字符串。 但是，此方法不会丢弃两个字符串之间的空格。
var text1 = text.trim();
print(text1); //'我热爱编程，喜欢D a r t'
var text2 = text.trimRight();
print(text2); //' 我热爱编程，喜欢D a r t'
var text3 = text.trimLeft();
print(text3); //'我热爱编程，喜欢D a r t '
//判断是否包含某个字符串；两个参数1.包含的字符串，2从字符第几位开始查找包含，有默认参数startIndex =0
bool contained1 = text.contains('D a r t');
print(contained1); //true
bool contained2 = text.contains('D a r t', 14);
print(contained2); //false
//查找字符串在text字符中的起始索引，返回-1未找到；有默认参数startIndex =0
int index = text.indexOf("编程");
print(index); //5
//字符以某个字符串结尾，类型OC hasSuffix
bool isEnd = text.endsWith(' ');
print(isEnd); //true
//字符以某个字符串结尾，类型OC hasPrefix；有默认参数startIndex =0
bool isStart = text.startsWith('我', 2);
print(isStart); //true
//字符串替换 from - 要被替换的字符串。replace - 替换字符串
String text4 = text.replaceAll(' ', '*');
print(text4); //**我热爱编程，喜欢D*a*r*t*
//字符串分割，类似oc的componentsSeparatedByString
List<String> strList = text.split(' ');
print(strList); //[, , 我热爱编程，喜欢D, a, r, t, ]
//字符串字母大小写转换
var test = "Dart";
var test1 = test.toLowerCase();
print(test1);//dart
var test2 = test.toUpperCase();
print(test2);//DART
- 数组类型List
List声明：
List list = List(3);
List list1 = [1, 2, 3];
print(list);//[null, null, null]
print(list1);//[1, 2, 3]
List常用属性和函数
var text = ' 我热爱编程，喜欢D a r t ';
List list = [2, 4, 8, 16, 32, 64, 'Dart'];
//length 数组长度，set get 都可,这里要注意
int length = list.length;
print(length); //6
print(list); //[2, 4, 8, 16, 32, 64]
list.length = 10;
print(list); //[2, 4, 8, 16, 32, 64, null, null, null, null]
//数组是否为空，很简单
bool result = list.isEmpty;
print(result); //false
//数组是否包含某个元素
bool isContained = list.contains('Dart');
print(isContained); //true
//数组遍历
list.forEach((element) {
print(element);
});
//依次访问数组元素，根据指定函数计算一个结果
int total = list.reduce((value, element) {
if (value is num == false) {
value = 0;
}
if (element is num == false) {
element = 0;
}
return value + element;
});
print(total); //126
//数组转换成字符串
var joinStr = list.join("*");
print(joinStr); //2*4*8*16*32*64*Dart*null*null*null
//增
list.add(100);
print(list); //[2, 4, 8, 16, 32, 64, Dart, null, null, null, 100]
//删
list.removeAt(1);
print(list); //[2,8, 16, 32, 64, Dart, null, null, null, 100]
//将数组全部追加进数组
list.addAll([001, 002, 004]);
print(list); //[2, 8, 16, 32, 64, Dart, null, null, null, 100, 1, 2, 4]
//修改
list.fillRange(1, 2, 200);
print(list);
//insert(index,value); 指定位置插入
//insertAll(index,list) 指定位置插入List
//toList() 其他类型转换成List
//清空
list.clear();
print(list);//[]
- Map类型
Map声明
var map = {};
Map map1 = Map();
常用Api跟数组差不多，简单介绍一下：
var map = {};
Map map1 = Map();
//插入键值对
map["name"] = "Dart";
print(map);
bool re1 = map.containsKey("name");
bool re2 = map.containsValue("Dart");
print(re1);
print(re2);
//跟OC 类似，注意map取entries
map.addEntries({"age": "18", "gender": "男"}.entries);
print(map);
//将Map全部添加进来，注意addEntries区别
map.addAll({"age": "22"});
print(map);
//遍历
map.forEach((key, value) {});
//删除
map.remove("name");
//清空
map.clear();
//length获取长度,注意read only，跟数组区别
int length = map.length;
print(length);
//判空
map.isEmpty;
- 函数
在dart中函数的也是对象，支持闭包和高阶函数，而且dart中的函数也会比OC要灵活的多，比如支持默认值参数、可选参数、命名参数等
- 函数基本用法
void main() {
print(getInfo("小明", 18, "未知"));
}
String getInfo(String name, int age, String gender) {
return name + age.toString() + '岁了性别' + gender;
}
- 函数参数传参
函数参数构成图：Dart函数.png
- 位置参数
//1.无返回值 无参数函数
printInfo() {
print("我是 无参数 无返回值 函数");
}
//2. 无参数有返回值函数
String getInfo() {
return "无信息";
}
//3.有参数且参数个数，顺序固定（均为必需参数）
String getInfo1(String name, int age, String gender) {
return name + age.toString() + '岁了性别' + gender;
}
//4.dart 中声明可选参数，需要在参数列表声明 List 格式的参数列表，表明是可选的。并且List格式参数列表需要在必需参数列表后边,多个可选参数也是按照顺序的
String getPersonInfo(String name, int age, String gender, [String address]) {
if (address == null) {
return name + age.toString() + gender;
}
return name + age.toString() + gender + address;
}
//5.位置参数，可选参数带默认值函数(必需放在可选参数列表中[])
String getPersonInfo1(String name, int age, String gender,
[String address = 'Google']) {
return name + age.toString() + gender + address;
}
- 命名参数（命名参数始终是可选参数，可以设置默认值）
//1. 命名参数（参数列表中由map 构成{}，其位置在必须放在位置参数后）
//使用resutl1 = sum1(b: 2, c: 3);
int sum({int a, int b, int c}) {
return a + b + c;
}
//2. 命名参数 含默认值参数
//使用resutl2 = sum1(b: 2, c: 3););
int sum1({int a = 10, int b, int c}) {
return a + b + c;
}
//2. 命名参数 含默认值参数，必需位置参数(@required 修饰，只有在命名参数中可以使用)
//使用 int result2 = sum2(b: 10);
int sum2({int a = 10, @required int b, int c}) {
return a + b + c;
}
//3.位置参数，命名参数 混合使用（注意 位置参数只能使用必需位置参数）
//使用 int result3 = sum3(1, c: 3);
int sum3(int a,{int b,@required int c,int d = 100}) {
return a + b + c + d;
}
//4.错误使用报错，命名参数 混合
//不可使用
// int sum4([int a], {int b,@required int c,int d = 100}) {
// return a + b + c + d;
// }
- 箭头函数(箭头函数只能有一行，可以省略大括号.只是省略写法)
int sum5(int a, int b) => a + b;
4.匿名函数（没有名字的函数）
//带参数的匿名函数
(a,b){
}
//匿名方法赋值给一个变量，然后可以使用这个方法
var sum = (a,b){
return a + b;
}
//定义参数带函数的函数
test(int a, int b, add(c, d)) {
return add(a, b);
}
int blockTest(List<int> list, block(int a, int b)) {
int value = 1;
for (int item in list) {
value = block(item, value);
}
return value;
}
//调用：
void main() {
int value = add(100, 200);
print(value.toString());
//将add函数当成变量传进函数
test(100, 200,add);//输出300；
//函数当做参数传参
int value = blockTest([1, 2, 3, 4, 5], (a, b) {
return a * b;
});
print(value);//value 120；
}
- 闭包 （即一个函数对象，即使函数对象的调用在它原始作用域之外，依然能够访问在它词法作用域内的变量,能够捕捉变量）；
- 闭包在函数体内部实现
blockTest01(int a) {
int value = 0;
test() {
value++;
//捕获外部变量value
print((a + value).toString());
}
return test;
}
//调用：
void main() {
var block01 = blockTest01(100000);
//blockTest01 函数体内局部变量 value 在函数执行完成后 不会被释放，多执行几次 可以发现
block01();//100001
block01();//100002
block01();//100003
}
- 闭包在函数体外部实现（函数当做参数传递，类似iOS block）
int blockTest(List<int> list, block(int a, int b)) {
int value = 1;
for (int item in list) {
value = block(item, value);
}
return value;
}
//调用：
void main() {
int value = blockTest([1, 2, 3, 4, 5], (a, b) {
return a * b;
});//120
}
闭包在Flutter 使用很多 比如常见的builder 模式 就是使用闭包 ，返回我们自定义的组件
ListView.builder({
Key key,
Axis scrollDirection = Axis.vertical,
bool reverse = false,
ScrollController controller,
bool primary,
ScrollPhysics physics,
bool shrinkWrap = false,
EdgeInsetsGeometry padding,
this.itemExtent,
@required IndexedWidgetBuilder itemBuilder,
int itemCount,
bool addAutomaticKeepAlives = true,
bool addRepaintBoundaries = true,
bool addSemanticIndexes = true,
double cacheExtent,
int semanticChildCount,
DragStartBehavior dragStartBehavior = DragStartBehavior.start,
})
我们看一下IndexedWidgetBuilder定义typedef IndexedWidgetBuilder = Widget Function(BuildContext context, int index);原来是一个返回值为Widget类型的函数，我们在调用的时候 在闭包中 根据需要返回不同的自定义的widet即可；
ListView.builder(itemBuilder: (BuildContext context, int inx) {
return Text('闭包');
});
我们可以思考一下 这种做法的好处？
还记得List的 reduce函数也是闭包的用法，我们可以根据我们自己定义的算法获取相应的结果，配合泛型等使用，使我们的代码很优雅，复用性也很高.
[].reduce((value, element) {
return value * element;
});
[].reduce((value, element) {
return value + element;
});
