Dart 学习记录(-)

参考文章
hello world
1
2
3
4
//dart 语言的入口是main函数,并且没有返回值
main(List<String> args) {
print('Hello World');
}
定义变量
1
var /dynamic /const /final  变量名=变量值
var 的使用
1
2
3
4
5
6
7
var name = 'coderwhy';
name = 'kobe';
print(name.runtimeType); // String runtimeType用于获取当前变量的类型

//错误用法
var age = 18;
age = 'why'; // 不可以将String赋值给一个int类型
dynamic 的使用
1
2
3
4
5
6
//dynamic 动态的意思 上面var赋值的那种错误做法,可以用dynamic来解决,但在开发中,通常情况下不会使用dynamic,因为类型的变量会带来潜在的危险。

dynamic name = 'coderwhy';
print(name.runtimeType); // String
name = 18;
print(name.runtimeType); // int
final 和 const 的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//final 和 const 都是用于定义常量的,也就是定义之后值都不可以修改

final name = 'coderwhy';
name = 'kobe'; // 错误做法

const age = 18;
age = 20; // 错误做法

//final和const的区别
//const在赋值时, 赋值的内容必须是在编译期间就确定下来的
//final在赋值时, 可以动态获取, 比如赋值一个函数

String getName() {
return 'coderwhy';
}

main(List<String> args) {
const name = getName(); // 错误的做法, 因为要执行函数才能获取到值
final name = getName(); // 正确的做法
}
数据类型
数字类型
1
整数用 int , 浮点数用 double
布尔类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//dart中提供了一个bool的类型,取值为 true或false

// 布尔类型
var isFlag = true;
print('$isFlag ${isFlag.runtimeType}');
//控制台输出结果: true bool

//注意:dart中不能判断非0即真,或者非空即真,Dart的类型安全性意味着您不能使用if(非booleanvalue)或assert(非booleanvalue)之类的代码。

var message = 'Hello Dart';
// 错误的写法
if (message) {
print(message)
}
字符串类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//dart字符串是UTF-16编码单元的序列,可以使用单引号或双引号创建一个字符串
// 1.定义字符串的方式
var s1 = 'Hello World';
var s2 = "Hello Dart";
var s3 = 'Hello\'Fullter';
var s4 = "Hello'Fullter";

//可以使用三个单引号或者双引号表示多行字符串
// 2.表示多行字符串的方式
var message1 = '''
哈哈哈
呵呵呵
嘿嘿嘿''';

//控制台输出会保持原格式

//字符串和其他变量或表达式拼接,使用 ${expression},如果表达式是一个标识符,那么{}可以省略
// 3.拼接其他变量
var name = 'coderwhy';
var age = 18;
var height = 1.88;
print('my name is ${name}, age is $age, height is $height');
集合类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//对于集合类型,dart则内置了最常用的三种: List / Set /Map ,用法类比Java啥的即可

// List定义 用 []
// 1.使用类型推导定义
var letters = ['a', 'b', 'c', 'd'];
print('$letters ${letters.runtimeType}');

// 2.明确指定类型
List<int> numbers = [1, 2, 3, 4];
print('$numbers ${numbers.runtimeType}');

// Set的定义 用 {}
// 1.使用类型推导定义
var lettersSet = {'a', 'b', 'c', 'd'};
print('$lettersSet ${lettersSet.runtimeType}');

// 2.明确指定类型
Set<int> numbersSet = {1, 2, 3, 4};
print('$numbersSet ${numbersSet.runtimeType}');

//Set是无序的,并且元素是不重复的,这都知道

// Map的定义
// 1.使用类型推导定义
var infoMap1 = {'name': 'why', 'age': 18};
print('$infoMap1 ${infoMap1.runtimeType}');

// 2.明确指定类型
Map<String, Object> infoMap2 = {'height': 1.88, 'address': '北京市'};
print('$infoMap2 ${infoMap2.runtimeType}');
集合常见操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
//1.所有集合都支持的获取长度的属性 length
// 获取集合的长度
print(letters.length);
print(lettersSet.length);
print(infoMap1.length);

//2.添加/删除/包含 操作
// 添加/删除/包含元素
numbers.add(5);
numbersSet.add(5);
print('$numbers $numbersSet');

numbers.remove(1);
numbersSet.remove(1);
print('$numbers $numbersSet');

print(numbers.contains(2));
print(numbersSet.contains(2));

// List根据index删除元素
numbers.removeAt(3);
print('$numbers');

//3.Map的操作
//由于它有key和value,因此无论是读取值,还是操作,都要明确是基于key的,还是基于value的,或者是基于key/value键值对的。

// Map的操作
// 1.根据key获取value
print(infoMap1['name']); // why

// 2.获取所有的entries
print('${infoMap1.entries} ${infoMap1.entries.runtimeType}'); // (MapEntry(name: why), MapEntry(age: 18)) MappedIterable<String, MapEntry<String, Object>>

// 3.获取所有的keys
print('${infoMap1.keys} ${infoMap1.keys.runtimeType}'); // (name, age) _CompactIterable<String>

// 4.获取所有的values
print('${infoMap1.values} ${infoMap1.values.runtimeType}'); // (why, 18) _CompactIterable<Object>

// 5.判断是否包含某个key或者value
print('${infoMap1.containsKey('age')} ${infoMap1.containsValue(18)}'); // true true

// 6.根据key删除元素
infoMap1.remove('age');
print('${infoMap1}'); // {name: why}
函数
1
2
Dart是一种真正的面向对象语言,所以即使函数也是对象,所有也有类型, 类型就是Function
这也就意味着函数可以作为变量定义或者作为其他函数的参数或者返回值.
函数的定义方式
1
2
3
4
5
6
7
8
9
10
11
12
13
//1.函数的定义方式
返回值 函数的名称(参数列表) {
函数体
return 返回值
}

//eg: 定义一个求和函数
int sum(num num1, num num2) {
return num1 + num2;
}

//另外, 如果函数中只有一个表达式, 那么可以使用箭头语法(arrow syntax)
sum(num1, num2) => num1 + num2;
函数的参数问题
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//
//可选参数可以分为 命名可选参数 和 位置可选参数
//定义方式
命名可选参数: {param1, param2, ...}
位置可选参数: [param1, param2, ...]

//命名可选参数的演示
// 定义命名可选参数
printInfo1(String name, {int age, double height}) {
print('name=$name age=$age height=$height');
}
// 调用printInfo1函数
printInfo1('why'); // name=why age=null height=null
printInfo1('why', age: 18); // name=why age=18 height=null
printInfo1('why', age: 18, height: 1.88); // name=why age=18 height=1.88
printInfo1('why', height: 1.88); // name=why age=null height=1.88

//位置可选参数的演示
// 定义位置可选参数
printInfo2(String name, [int age, double height]) {
print('name=$name age=$age height=$height');
}

// 调用printInfo2函数
printInfo2('why'); // name=why age=null height=null
printInfo2('why', 18); // name=why age=18 height=null
printInfo2('why', 18, 1.88); // name=why age=18 height=1.88

//参数的默认值,可选参数才能设置默认值,必选参数不可以
printInfo4(String name, {int age = 18, double height=1.88}) {
print('name=$name age=$age height=$height');
}
函数是一等公民
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//这就意味着你可以将函数赋值给一个变量, 也可以将函数作为另外一个函数的参数或者返回值来使用.

main(List<String> args) {
// 1.将函数赋值给一个变量
var bar = foo;
print(bar);

// 2.将函数作为另一个函数的参数
test(foo);

// 3.将函数作为另一个函数的返回值
var func =getFunc();
func('kobe');
}

// 1.定义一个函数
foo(String name) {
print('传入的name:$name');
}

// 2.将函数作为另外一个函数的参数
test(Function func) {
func('coderwhy');
}

// 3.将函数作为另一个函数的返回值
getFunc() {
return foo;
}
匿名函数的使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//匿名函数( anonymous function),也可以叫lambda或者closure。
main(List<String> args) {
// 1.定义数组
var movies = ['盗梦空间', '星际穿越', '少年派', '大话西游'];

// 2.使用forEach遍历: 有名字的函数
printElement(item) {
print(item);
}
movies.forEach(printElement);

// 3.使用forEach遍历: 匿名函数
movies.forEach((item) {
print(item);
});
movies.forEach((item) => print(item));
}
词法的作用域
1
2
3
4
5
6
7
8
9
10
11
12
//dart中的词法有自己明确的作用域范围,它是根据代码的结构({})来决定作用域范围的,优先使用自己作用域中的变量,如果没有找到,则一层层向外查找。

var name = 'global';
main(List<String> args) {
// var name = 'main';
void foo() {
// var name = 'foo';
print(name);
}

foo();
}
词法闭包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//闭包可以访问其词法范围内的变量,即使函数在其他地方被使用,也可以正常的访问。
main(List<String> args) {
makeAdder(num addBy) {
return (num i) {
return i + addBy;
};
}

var adder2 = makeAdder(2);
print(adder2(10)); // 12
print(adder2(6)); // 8

var adder5 = makeAdder(5);
print(adder5(10)); // 15
print(adder5(6)); // 11
}
返回值问题
1
2
3
4
5
6
7
8
//所有函数都返回一个值。如果没有指定返回值,则语句返回null;隐式附加到函数体。
main(List<String> args) {
print(foo()); // null
}

foo() {
print('foo function');
}
0%