Dart 语法总结

变量

Hello World

/**
 * 1.main函数是dart入口
 * 2. 参数args， 类型为List - 泛型
*/
void main(List args) {
  print("hello world");
}
1
2
3
4
5
6
7

变量声明

void main(List args) {
  // 和swift类似
  // 1. 明确的声明
  String name = "why";
  // 2. 类型推导 （var/final/const）

  //虽然没有指定类型，但是是有自己的明确类型的
  var name1 = "fishycx";
 // name1 = 1；  这样写会报错的， 和swift类似， 和 python/js 不一样。

  //final 用来声明一个常量， 类似于swift中的let，运行时得到的常量值
  final height = 1.99;
  //height = 2.0; 这样写会报错

  //const 也是用来声明常量的， 编译时赋值的常量值。就是做=后边必须时一个常量值，而final=后面可以表达式。
  const address =  "xxxxxx";
  // address = “yyyyy”；会报错

  final date = DateTime.now();

  const p1 = Person("xx");
  const p2 = Person("xx");
  print(identical(p1, p2));

}

class Person {
  final String name;
  const Person(this.name);
}
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

数据类型

数值类型，布尔值， 字符串
条件判断必须是布尔值， 不是和python，js 一样的非0既真。

 //1.数组List
  var names = ["abd", "cbd", "fishycx"];
  
  //2.集合Set
  var words = {"lovers", "lonely", "only one"};

  //3.映射Map
  var word1s = {"name": "why", "age": "xxx"};
1
2
3
4
5
6
7
8

函数使用

void main(List<String> args) {
  sayHello("json");
  // 位置可选参数是指， 中括号里面的参数是可选的， 如果传的话是按照位置匹配的，没有传递 参数名
  sayHello2("json");
  sayHello2("json", 10);
  sayHello2("json", 10, 100);

 //命名可选参数是指， 打括号括起来的参数是可选的， 如果要传值的话， 使用 参数命名来匹配。 
  sayHello3("json");
  sayHello3("json", age: 10);
  sayHello3("json", height: 10.0, age: 22);
  
}

// 必选参数： 必须传的参数
// 可选参数： 1.位置可选参数  2.命名可选参数
// 可选参数才有默认值
// 位置可选参数：[int age, double height]
// 实参或形参进行匹配时， 根据位置进行匹配
void sayHello(String name) {
  print("hello $name");
}

// 可选参数必须提供默认值，或者使用？标记可以为空
void sayHello2(String name, [int? age, double? height]) {
  print("hello $name $age $height");
}

// 命名可选参数使用{}
void sayHello3(String name, {int? age, double? height}) {
  print("hello $name $age $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
31
32

匿名函数：

void main(List<String> args) {

  // swift， pyton， dart， 函数是一等公民， java， oc 并不是。 
  // 函数可以赋值给一个变量， 可以做为另外一个函数的参数或返回值。

  test(bar);
  //匿名函数
  test((){
    print("匿名函数");
  });
  //和ES6差不多.
  test((){
    print("箭头函数");
  });

  test1((num1, num2) {
    return num1 + num2;
  });

  var demo1 = demo();
  print(demo1(10, 20));
}


void test(Function foo) {
  foo();
}

void bar() {
  print("bar 函数被调用");
}

//开发中，使用typedef 给函数一个别名，  

typedef Caculate = int Function(int num1, int  num2);

void test1(Caculate calc) {
  print(calc(20, 30));
}

//函数做为返回值
Caculate demo() {
  return  (int num1, int num2){
    return 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46

面向对象

命名构造函数

class Person {
  String age;
  String name;
  double height;

  Person(this.age, this.name, this.height);

  //命名构造函数
  Person.withAgeNameHeight(this.age, this.name, this.height);
}
1
2
3
4
5
6
7
8
9
10

Dart 特殊运算符

void main(List<String> args) {
  // ??= ： 当原来的变量有值时， 不执行赋值操作。
  var name = null;
  name ??= "lelei";
  print(name);

  // ??  如果变量为null， 可取 ??后面的值赋值给变量， 这和swift一直

  var name1 = null;
  print(name1 ?? "fishycx");
}
1
2
3
4
5
6
7
8
9
10
11

void main(List<String> args) {
  var p = Person();
  p.name = "Why";
  print(p.name);
  p.run();
  p.eat();

  var p1 = Person()
            ..name = "xxx"
            ..run()
            ..eat();
}

class Person {
  late String name;

  void run() {
    print("running");
  }

  void eat() {
    print("eating");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

for 循环

void main(List<String> args) {
  //1.基础for循环
  for(var i = 0; i<10; i++) {
    print(i);
  }

  //2.遍历数组

  for(var i in [1, 3, 5, 10]) {
    print(i);
  }
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13

\