dart(1)看视频学习版

前面的也不是很难,所以就不详细写了,从list开始写一下吧
有些比较简单的,比如运算符什么的,我就不详细写了
这次看的还是coderwhy老师的视频,没想到他也出了这个视频，遂放弃了前面看的视频，那个老师讲的有点枯燥。
也可以直接看老师写的文章: https://juejin.cn/post/6844903938697773063
一些之前遗漏的内容
尽可能使用final
打印变量
如果想要打印多个变量,是不能像js一样直接用逗号分隔,而是使用${},${}有时候可以省略,但如果是表达式的话,不可省略
void main(List args) {
var a = 1;
var b = ‘hahaha’;
print(“a b”);
}
// 或者

void main(List args) {
var a = 1;
var b = ‘hahaha’;
print(“${a} ${b}”);
}

runtimeType 获取变量的类型的方法
void main(List args) {
var a = 1;
print(a.runtimeType);
// int
}
dart没有非空即真
在js里,我们判断一个变量是否有值,可以直接这么写
const message = ‘hello’;
if(message){
…
}
但是在dart中,这样写是不行的,他表示必须要有明确的bool类型
只能这么写
void main(List args) {
var message = ‘hello’;
if (message != null) {
print(‘执行’);
}
}
List
下面介绍一些list的常用操作方法
遍历数组
main() {
List list1 = [‘y’, ‘f’, ‘t’];
for (String item in list1) {
print(item);
}
}
add
追加一个元素
main() {
// int是泛型,指定列表内元素的类型
List list1 = [];
// 添加元素
list1.add(123);
print(list1); // [123]
// 判断长度
print(list1.length); // 1
}
上面是指定了泛型,指定元素类型为int,如果添加String类型的元素就会报错。
哈哈,梦回Typescript
也可以不指定,可以用var来定义,var可以自动推断类型
var l1 = [];
此时,我们的数组类型为动态类型
我们就可以随意添加元素
// 现在l1类型为dynamic,因为右边是空的
l1.add(1);
l1.add(‘1’);
l1.add(true);
print(l1); // [1, 1, true]
var l2 = [1,2,3]
// 但是这个时候l2的类型就会被自动推断为int类型
addAll
追加多个元素
var a1 = [1, 2, 3];
a1.addAll([1, 2, 3]);
print(a1); //[1, 2, 3, 1, 2, 3]
// 因为a1的类型已经被推断为整型,因此不能将字符串给整型,会报错
a1.addAll([‘4’]); // 报错
如果我现在将a1中的数组的其中一个改为字符的,那么a1就是Object类型的了,可以添加其他类型的数组了
insert
在index处插入element
var a2 = [1, 2, 3, 4, 5];
a2.insert(1, 999);
print(a2); // [1, 999, 2, 3, 4, 5]
insertAll
和addAll差不多的用法,批量插入元素
var a2 = [1, 2, 3, 4, 5];
a2.insertAll(1, [111, 222, 333]);
print(a2); //[1, 111, 222, 333, 2, 3, 4, 5]
remove
删除指定的元素
var a3 = [1, 2, 2, 3, 4, 5, 7];
a3.remove(2);
print(a3); // [1, 2, 3, 4, 5, 6]
能删,但是只删第一个出现的,所以上面的还是有2这个元素在
removeRange
该方法无返回值，第一个参数 start 为开始删除元素的索引，第二个参数 end 为结束删除元素的索引，取值范围为 [ start，end )，即含头不含尾
void main(List args) {
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
a1.removeRange(1, 3);
print(a1); // [1, 4, 5, 6, 7, 8]
}
removeLast
删除最后一个
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
a1.removeLast();
print(a1); // [1, 2, 3, 4, 5, 6, 7, ]
isEmpty/isNotEmpty
判断是否为空/是否
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
var a2 = [];
print(a1.isEmpty); // false
print(a1.isNotEmpty); // true
print(a2.isEmpty); // true
print(a2.isNotEmpty); // false
reversed
倒序迭代操作 这个稍微有点麻烦
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
print(a1.reversed);
// (8, 7, 6, 5, 4, 3, 2, 1)
可以看到打印出来的是一个小括号包裹着的,将鼠标移上去可以看到是一个结果是一个迭代操作
如果想要将它变成数组,需要使用到方法toList()
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
print(a1.reversed.toList());
// [8, 7, 6, 5, 4, 3, 2, 1]
map
映射操作 这是我们比较熟悉的了,但还是有点不一样的,他会返回一个迭代操作
// 这里是匿名函数: (参数) {return 操作体}
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
var a2 = a1.map((int e) {
return e + 1;
}).toList();
print(a2); //[2, 3, 4, 5, 6, 7, 8, 9]

//下面是箭头函数: (参数)=>操作体
var a1 = [1, 2, 3, 4, 5, 6, 7, 8];
var a2 = a1.map((e) => e + 1).toList();
print(a2); //[2, 3, 4, 5, 6, 7, 8, 9]
有一点需要注意的是,如果这个map返回的是迭代操作,如果你不使用toList(),他这个map是不会执行的

问了一下gpt,他的解释是:
Dart 的 map 是一种惰性操作，这意味着它不会立即计算结果，而是返回一个新的可迭代对象（Iterable）。这个可迭代对象会在你尝试访问它的元素时计算。
也就是说,我们的toList()这个操作就是尝试访问的操作
运算符拆解
和ES6有点像,…的作用是拆掉一层[],把…后面的数组变成了元素,相当于是把1维数组变成了一堆连续排列的元素
main() {
print([
…[1, 2, 3],
…[4, 5, 6],
[7, 8, 9]
]);
}
// [1, 2, 3, 4, 5, 6, [7, 8, 9]]
Set 集合
Set是集合,标准写法 new Set<泛型>(),注意,Set的元素是不能重复的
初始化:
main() {
var s1 = new Set();
s1.add(1);
s1.add(2);
print(s1);
// {1, 2}
}
可以看到Set是一个花括号包裹着的,和数组不同。另外，Set没有顺序，不能通过下标访问。还有，new和泛型都是可以省略的。
常见使用场景
给数组去重,如果不使用set的话,就使用for循环
void main(List args) {
// 1.指定类型,最好写上泛型
List list1 = [‘a’, ‘b’, ‘c’, ‘b’, ‘a’];
List list2 = [];
for (String item in list1) {
if (!list2.contains(item)) {
list2.add(item);
}
}
print(list2);
}
如果使用Set的话,可以这么写
void main(List args) {
// 1.指定类型,最好写上泛型
List list1 = [‘a’, ‘b’, ‘c’, ‘b’, ‘a’];
List list2 = List.from(Set.from(list1));
print(list2);
}
Map键值对
Map是键值对,其实就和对象差不多的意思,泛型的第一个类型是键,key;第二个是值,value
main() {
var o1 = new Map();
o1 = {‘a’: 123, ‘b’: 456};
}
可以不指定类型,new也可以省略,还有一些下标访问和赋值就不写了
给Map添加键值对
main() {
var o1 = {‘name’: 1} as dynamic;
o1[‘age’] = 10;
o1.addEntries([MapEntry(‘gender’, ‘female’)]);
print(o1);
}
Function
下面开始将函数部分 这是最基础的函数写法:
void add(int a, int b) {
print(‘add()执行, a+b=${a + b}’);
}

main() {
add(1, 2);
//add()执行, a+b=3

// 将函数赋值给变量
Function fn = add;
fn(1, 23);
}
基本的格式就是
类型 FunName (类型 param) {函数体}
我们和js的定义方式做一个对比
js:
function fn(){}
dart:
int fn(int num1, int num2){}
虽然说类型是可以省略的,但是最好还是带上类型
关于必选参数和可选参数
函数中的参数问题，参数分为必传参数和可选参数。其中，可选参数又分为两种：位置可选参数和命名可选参数
我们先来看看必传参数
main() {
void fn(String name, int age) {
print(‘$name $age’);
}

fn(‘yft’); // 报错
fn(‘yft’, 18);
}

现在里面的参数都是可选参数
位置可选参数 []
main() {
void fn(String name, [int? age]) {
print(‘$name $age’);
}

fn(‘yft’); // 不报错
fn(‘yft’, 18);
}
其实这个地方之前是可以直接写[]的,但是后续的版本已经不允许了,要么加上?,要么指定类型为dynamic,下面的命名传参也同理
命名参数 {}
main() {
void fn(String name, {int? age}) {
print(‘$name $age’);
}

fn(‘yft’); // 不报错
fn(‘yft’, age: 18); // 在传参的时候需要形参名
}
参数默认值
main() {
void fn(String name, {int? age = 20}) {
print(‘$name $age’);
}
}
直接写上=xxx就可以了,但是需要注意的是,默认值只能给可选参数
匿名函数
和js类似的
main() {
List list1 = [‘y’, ‘f’, ‘t’];
list1.forEach((item) {
print(item);
});
}
但是如果只有一行简单的代码,可以使用箭头函数,多行的时候只能使用匿名函数
main() {
List list1 = [‘y’, ‘f’, ‘t’];
list1.forEach((item) => print(item));
}
然后注意一下箭头函数的写法:
var func = (e) => e; //可以
var func1 = e => e; // 报错
??
这个其实就很像js中的用法
main() {
var message = null;
var name = message ?? ‘abc’;
print(name);
}
嗯先写到这吧,困了睡觉