Dart语法总结

Dart 语言介绍

  • Dart 是Google发布的一门开源编程语言
  • Dart 目前可用于全平台开发
  • Dart是一门面向对象的编程语言

开发环境

[Dart 环境安装] https://www.dartlang.org/tools/sdk#install

IDE 支持

IntelliJ IDEA Android Studio
VS Code
Sublime Text Atom

基础语法

变量与常量

使用 var 声明变量,可赋予不同类型的值
未初始化时,默认值为 null
使用 final 声明一个不可改变的值
使用const声明编译期常量

1
2
3
4
var a;
a = 10;
a = "aaa";
const b = 10;

内置数据类型

(1)数值型 num (int double)
  • 常用属性:isEven(是否偶数)isOdd isNegative
  • 常用方法:abs() round() toInt() toDouble()
(2)字符串 String
  • 常用方法
    contains(), subString() toLowerCase() toUpperCase()
    startsWith() endsWith()
1
2
3
4
5
6
7
  String s1 = 'aaa\'';
String s2 = "aaa'";
String s3 = """Hello
Dart""";
String s4 = r'aaa\n';
String s5 = "s1 = $s1";
String s6 = "a + b = ${1 + 2}";
(3)布尔值 bool
(4)List
1
2
3
4
5
6
7
8
9
10
11
12
var list = List();
list = [1, 2, 3, 'Flutter', true];
list[2] = 'Dart';
list.add("value");
list.insert(1, 'element');
list.remove("value");
list.removeAt(1);
var typeList = List<String>(); // 只能添加字符串类型的元素
for (var item in list) {
print(item);
}
list.forEach((element) => print(element));
(5)Map
1
2
3
4
5
6
7
8
9
10
var map = {'fisrt': 'Dart', 'second': 'Java'};
print(map.length);
print(map.isEmpty);
print(map.isNotEmpty);
print(map.keys);
print(map.values);
print(map.containsKey("key"));
print(map.containsValue("value"));
map['third'] = 'Python';
map.forEach((key, value) => print("key:${key}, value:${value}"));

运算符

1、算术运算符 + - / ~/(取整) %
2、关系运算符 ==(判断内容是否相同) !=, >, <, >=, <=
3、逻辑运算符 ! && ||
4、赋值运算符 = ??= += -+
= /= %= ~/=
5、条件表达式
三目运算符 condition ? expr1 : expr2
?? 运算符 expr1 ?? expr2

1
2
3
String s = true ? "Male" : "Female";
var s1, s2 = "not null";
s = s1 ?? s2;

控制语句

if for while do…while break continue switch…case

注释

1
2
3
4
// 这是⼀个⾏注释
/* 这是⼀个多⾏的
块注释。 */
/* /* */ */

方法

  • 方法定义
1
2
3
4
返回类型 方法名(参数1, 参数2, ...) {
方法体
return 返回值
}
  • 方法特性

    方法也是对象,并且有具体类型 Function

    返回值类型、参数类型可省略

    箭头语法:=> expr 是 {return expr} 的缩写,只适用于一个表达式

    方法都有返回值,如果没有指定,默认 return null

    方法不能重载

1
2
3
4
5
6
7
String getPerson(String name, int age) {
return "name = $name, age = $age";
}
printPerson(name, age) {
print("name = $name, age = $age");
}
getPerson(name) => "name = $name";
  • 可选参数

    可选命名参数:{param1, param2, …}

    可选位置参数:[param1, param2, …]

    可选参数可以指定默认值

    可选参数只能放在方法的最后

    函数可以使用=为命名参数和位置参数定义默认值。默认值必须是编译时常量。如果没有提供默认值,则默认值为null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void main() {
printPerson("zhangsan");
printPerson("zhangsan", gender: 1);
printPerson("zhangsan", gender: 1, age: 18);

printPerson2("zhangsan", 18, 1);
}

printPerson(name, {age = 18, gender = 0}) {
print("name = $name, age = $age, gender = $gender");
}

printPerson2(name, [age = "18", gender = 1]) {
print("name = $name, age = $age, gender = $gender");
}
  • 方法对象

    方法作为对象可以赋值给变量
    方法可以作为另一个方法的参数

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
void main() {
// 方法作为对象可以赋值给变量
Function fun = times;
print(fun("name"));

// 列表数据*3
List list = ["1", "2", "3"];
listTimes(list, times);
// 匿名方法调用形式
// listTimes(list, (item) => item * 3);

print(list);
}

times(str) {
return str * 3;
}

// 方法可以作为另一个方法的参数
listTimes(List list, f(item)) {
for (int i = 0; i < list.length; i++) {
list[i] = f(list[i]);
}
return list;
}
  • 匿名方法
1
2
3
4
(param1, param2, ...) {
方法体...
return 返回值;
}
1
2
var func = (str) => print(str);
func("test");

面向对象

类及成员可见性

  • Dart中的可见性以library为单位
  • 默认情况下,每一个Dart文件就是一个库
  • 使用_表示库的私有性
  • 使用import导入库

类及对象

(1)属性与方法
  • 属性默认会生成getter和setter方法
  • 使用final声明的属性只有getter方法
  • 方法不能重载
(2)计算属性

计算属性的值是通过计算而来,本身不存储值
计算属性赋值,其实是通过计算转换到其它变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void main() {
var rect = new Rect();
// print(rect.area());
print(rect.area);
rect.area = 400;
print(rect.width);
print(rect.height);
}
class Rect {
num width = 20, height = 10;
num get area => width * height;

set area(area) {
width = 20;
height = area / width;
}
}
(3) 构造方法

含有默认构造方法
如果存在自定义构造方法,则默认构造方法无效
构造方法不能重载,使用命名构造方法,可以实现多个构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Person {
String name;
int age;

// Person(){}
Person(this.name, this.age) {
print(name);
}

Person.withName(name) {
this.name = name;
}

Person.withAge(age) {
this.age = age;
}
}
(4)对象操作符

条件访问 ?.
类型转换 as
类型判断 is is!

1
2
3
4
5
6
7
8
9
10
Person person;
// ? 不为 null 则执行
person?.work();
person = new Person("zahng ", 15);

if (person is Person) {
print(person.name);
}
// .. 级联操作符
person..name = "TOM"..age = 20..work();
(5)抽象类 abstract class、接口
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
// 抽象类使用 abstract 表示,不能被直接实例化
// 抽象类可以没有抽象方法
abstract class Person {
// 抽象方法不用 abstract 修饰
void eat();
String name;
}

class Children extends Person {
@override
void eat() {}
}

abstract class Runnable {
void run();
}

// 类就是接口
// implements 需要重写类的所有成员及方法
class Student implements Person , Runnable {

@override
String name;

@override
void eat() {}

@override
void run() {}
}
(6)Mixins
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Mixin 类似于多继承,是在多类继承中重用一个类代码的方式
// 作为 Mixin 的类不能声明构造方法
// 作为 Mixin 的类只能继承Object
class A {
a() => print("A.a()");
}

class B {
b() => print("B.b()");
}

class C {
c() => print("C.c()");
}

class D extends A with B, C {
void d() {
a(); b(); c();
}
}
(7)操作符覆写

覆写操作符需要在类中定义

1
2
3
4
返回类型 operator 操作符 (参数1, 参数2) {
实现
return 返回值
}

如果覆写 ==,还需要覆写对象的hashCode getter 方法

override_operator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void main() {
Person p1 = Person(20);
Person p2 = Person(18);
print(p1 > p2);
}

class Person {
int age;
Person(this.age);

bool operator >(Person person) {
return this.age > person.age;
}
}

枚举 enum 和 泛型

1
2
3
enum Color { red, green, blue }

var list = new List<String>();

参考

A Tour of the Dart Language

------ 本文结束,欢迎阅读------
欢迎关注公众号,不定期更新