【Dart】30分钟学会Dart语言

た入场券 2021-10-01 04:46 416阅读 0赞

Dart语言是google开发的语言，目前对外主要用于flutter开发，Google内部使用Dart开发大型应用。Dart语言还是很受欢迎且很有发展潜力。它是一个纯面向对象的语言，其语法比较灵活，也比较简单。Dart语法跟java相似度比较高，但是又有很多不同。

Dart官方教程：[http://dart.goodev.org/guides/language/language-tour][http_dart.goodev.org_guides_language_language-tour]  
或[https://dart.dev/guides/language/language-tour][https_dart.dev_guides_language_language-tour]

##### 搭建Dart开发环境 #####

安装Dart SDK：[https://dart.dev/get-dart][https_dart.dev_get-dart]  
安装IDE：推荐使用Visual Studio Code：[ https://code.visualstudio.com/][https_code.visualstudio.com]

#### 一、数据类型 ####

*  int （一般占8个字节）
 *  double （一般占8个字节）
 *  num（int和double的父类型，一般占8个字节）
 *  String
 *  bool
 *  List
 *  Map

用法示例：

var year = 1977;  //定义int类型,注意dart没有long类型。
    
    int year2=1977; //同上，dart可以显式声明类型也可以自动推导类型。
    
    var antennaDiameter = 3.7;//定义double类型，注意dart没有float类型。
    
    var name = 'Voyager I'; 定义String类型
    
    var flybyObjects = List();或 var flybyObjects = new List();
    
    var flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune'];
    
    var image=new Map();
    
    var image = { 
      'tags': ['saturn'],
      'url': '//path/to/saturn.jpg'
    };
    
     var map={ "a":"1","b":2,"c":3,4:5};
     
     print(map[4]);//打印key=4的元素
      
     map["f"]="aaa"; //添加元素“f”="aaa"
      
     print(map["f"]);//打印key=f的元素
    
     var list=new List();
      
     list.add("a");//添加元素:"a"
      
     list.add(1);//添加元素:1
      
     print(list); //打印所有元素

这里没有显式的指定变量类型。也可以指定变量类型。

int year=1977; 
    
    double antennaDiameter = 3.7;
    
    String name = 'Voyager I'; 
    
    List flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune'];
    
    Map image = { 
      'tags': ['saturn'],
      'url': '//path/to/saturn.jpg'
    };

dart语法跟js和java比较想像，跟js的不同是，js只有隐式类型声明，没有显式类型类型声明。跟java不同的是，java必须显式声明类型。

例如js声明变量：`var year = 1977;` js没有这种声明方式：`int year = 1977;`

dart与python变量声明的不同是，python连var关键字都不需要，即`year=1997`，并且语句后面不需要分号结束。

跟java的不同：

> 1、dart声明没有初始化的变量都会被赋予默认值 null，包括int和double、bool。  
> 2、Dart 没有 public、private、protected 这些关键字，变量名以"\_"开头意味着对其它的 lib 是私有的。

[查看**javascript**数据类型][javascript]  
[查看**python**数据类型][python]

#### 二、流程控制语句 ####

跟js和java几乎一样。

if (year >= 2001) { 
      print('21st century');
    } else if (year >= 1901) { 
      print('20th century');
    }
    
    for (var object in flybyObjects) { 
      print(object);
    }
    
    for (int month = 1; month <= 12; month++) { 
      print(month);
    }
    
    while (year < 2016) { 
      year += 1;
    }

#### 三、普通函数(方法) ####

计算菲波拉契数列第n项：

int fibonacci(int n) { 
      if (n == 0 || n == 1) return n;
      return fibonacci(n - 1) + fibonacci(n - 2);
    }
    
    var result = fibonacci(20);

可以看出定义函数部分跟java比较相似，而js需要添加function关键字修饰。

js声明函数：

function functionname()
    { 
        // 执行代码
    }

Dart 是一个真正的面向对象语言，方法也是对象并且具有一种 类型。 这意味着，方法可以赋值给变量，也可以当做其他方法的参数。 也可以把 Dart 类的实例当做方法来调用。

下面是定义方法的实例

bool isNoble(int atomicNumber) { 
      return _nobleGases[atomicNumber] != null;
    }

也可以忽略类型定义，自动推导类型。没有返回值时为void类型，void关键字可省。

isNoble(atomicNumber) { 
      return _nobleGases[atomicNumber] != null;
    }

对于只有一个表达式的方法，你可以选择 使用缩写语法来定义。

bool isNoble(int atomicNumber) => _nobleGases[atomicNumber] != null;

这个 => expr 语法是 \{ return expr; \} 形式的缩写。=> 形式 有时候也称之为 胖箭头 语法。

> 注意： 在箭头 (=>) 和冒号; 之间只能使用一个 表达式 – 不能使用 语句。 例如：你不能使用 if statement，但是可以 使用条件表达式 conditional expression。

方法可以有两种类型的参数：必需的和可选的。 必需的参数在参数列表前面， 后面是可选参数。

##### (1)可选参数 #####

可选参数就是调用方法时实参是可选的，调用时可传可不传。可选参数分为两种，一种是是命名参数，一种是位置参数。

命名参数就是一对花括号\{\}括起来的参数，调用时实参必须指定参数的名字，必须以“name:value”这种形式传递。非命名参数就不能使用name:value形式传递。

位置参数就是中括号\[\]括起来的参数，里面的参数可传可不传，但是传的时候必须按照位置(顺序)来传。

但是这两种参数不能同时当做可选参数，也就是一个方法不能同时有位置参数和命名参数。

没有中括号或花括号的参数列表，就必须按参数位置(顺序)传递并且是一个都不能少地传递。

Dart为什么定义这种可选参数呢？因为Dart跟Java不同的是，Java可以使用多个同名的函数不同的参数来实现方法重载，而Dart就不允许一个类中有同名的函数，因此可选参数就类似于Java中的方法重载，最终的目的都是同一个方法，实现多种传参。相对Java而言，Dart这种可选参数灵活度更高。

##### (1.1)命名参数 #####

调用方法的时候，你必须使用这种形式 paramName: value 来指定命名参数。例如：

enableFlags("red",bold: true, hidden: false);

或

enableFlags("red"); //bold是null,hidden是null

在定义方法的时候，使用`{param1, param2, …}`的形式来指定命名参数：

/// Sets the [bold] and [hidden] flags to the values
    /// you specify.
    enableFlags(String color,{ bool bold, bool hidden}) { 
      // ...
    }

##### (1.2)位置参数 #####

把一些方法的参数放到 \[\] 中就变成可选 位置参数了：

String say(String from, String msg, [String device,String day]) { 
      var result = '$from says $msg';
      if (device != null) { 
        result = '$result with a $device on $day';
      }
      return result;
    }

下面是不使用可选参数调用上面方法 的示例

assert(say('Bob', 'Howdy') == 'Bob says Howdy');

下面是使用可选参数调用上面方法的示例：

assert(say('Bob', 'Howdy', 'smoke signal',"2019/10/1") == 'Bob says Howdy with a smoke signal on 2019/10/1');

##### (1.3)可选参数默认值 #####

在定义方法的可选参数时，可以使用 = 来指定可选参数的默认值。 默认值只能是编译时常量。 如果没有提供默认值，则默认值为 null。

下面是设置命名参数默认值的示例：

/// Sets the [bold] and [hidden] flags to the values you
    /// specify, defaulting to false.
    void enableFlags({ bool bold = false, bool hidden = false}) { 
      // ...
    }
    
    // bold will be true; hidden will be false.
    enableFlags(bold: true);

下面的示例显示了如何设置位置参数的默认值：

String say(String from, String msg,[String device = 'carrier pigeon', String mood]) { 
      var result = '$from says $msg';
      if (device != null) { 
        result = '$result with a $device';
      }
      if (mood != null) { 
        result = '$result (in a $mood mood)';
      }
      return result;
    }
    
    assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');

还可以使用 list 或者 map 作为默认值。 下面的示例定义了一个方法 doStuff()， 并分别为 list 和 gifts 参数指定了 默认值。

void doStuff(
        { List<int> list = const [1, 2, 3],
        Map<String, String> gifts = const { 
          'first': 'paper',
          'second': 'cotton',
          'third': 'leather'
        }}) { 
      print('list: $list');
      print('gifts: $gifts');
    }

##### (2)入口函数 #####

每个应用都需要有个顶级的 main() 入口方法才能执行。 main() 方法的返回值为 void 并且有个可选的 List 参数。

下面是一个 web 应用的 main() 方法：

void main() { 
      querySelector("#sample_text_id")
        ..text = "Click me!"
        ..onClick.listen(reverseText);
    }

> 注意： 前面代码中的 … 语法为 级联调用（cascade）。 使用级联调用语法， 你可以在一个对象上执行多个操作。

下面是一个命令行应用的 main() 方法，并且使用了 方法参数作为输入参数：

// Run the app like this: dart args.dart 1 test
    void main(List<String> arguments) { 
      print(arguments);
    
      assert(arguments.length == 2);
      assert(int.parse(arguments[0]) == 1);
      assert(arguments[1] == 'test');
    }

##### (3)方法作为参数调用另一个方法 #####

可以把方法当做参数调用另外一个方法。例如：

printElement(element) { 
      print(element);
    }
    
    var list = [1, 2, 3];
    
    // Pass printElement as a parameter.
    list.forEach(printElement);

方法也可以赋值给一个变量

var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
    assert(loudify('hello') == '!!! HELLO !!!');

上面的方法为 下面即将介绍的匿名方法。

##### (4)匿名方法 #####

大部分方法都带有名字，例如 main() 或者 printElement()。 你有可以创建没有名字的方法，称之为 匿名方法，有时候也被称为 lambda 或者 closure 闭包。 你可以把匿名方法赋值给一个变量， 然后你可以使用这个方法，比如添加到集合或者从集合中删除。匿名方法的使用场景很多，例如List的一些方法常常需要传一个匿名方法作为参数。

匿名函数和命名函数看起来类似— 在括号之间可以定义一些参数，参数使用逗号 分割，也可以是可选参数。 后面大括号中的代码为函数体：

([[Type] param1[, …]]) {  
      codeBlock; 
    };

下面的代码定义了一个参数为i （该参数没有指定类型）的匿名函数。 list 中的每个元素都会调用这个函数来 打印出来，同时来计算了每个元素在 list 中的索引位置。

var list = ['apples', 'oranges', 'grapes', 'bananas', 'plums'];
    list.forEach((i) { 
      print(list.indexOf(i).toString() + ': ' + i);
    });

运行结果:

0: apples
    1: oranges
    2: grapes
    3: bananas
    4: plums

##### (5)静态作用域 #####

Dart 是静态作用域语言，变量的作用域在写代码的时候就确定过了。 基本上大括号里面定义的变量就 只能在大括号里面访问，和 Java 作用域 类似。

下面是作用域的一个 示例：

注意 nestedFunction() 可以访问所有的变量， 包含顶级变量。

##### (6)词法闭包 #####

一个闭包是一个方法对象，不管该对象在何处被调用， 该对象都可以访问其作用域内的变量。

方法可以封闭定义到其作用域内的变量。 下面的示例中，makeAdder() 捕获到了变量 addBy。 不管你在哪里执行 makeAdder() 所返回的函数，都可以使用 addBy 参数。

/// Returns a function that adds [addBy] to the
    /// function's argument.
    Function makeAdder(num addBy) { 
      return (num i) => addBy + i;
    }
    
    main() { 
      // Create a function that adds 2.
      var add2 = makeAdder(2);
    
      // Create a function that adds 4.
      var add4 = makeAdder(4);
    
      assert(add2(3) == 5);
      assert(add4(3) == 7);
    }

##### (7)测试函数是否相等 #####

下面是测试顶级方法、静态函数和实例函数 相等的示例：

foo() { }               // A top-level function
    
    class A { 
      static void bar() { } // A static method
      void baz() { }        // An instance method
    }
    
    main() { 
      var x;
    
      // Comparing top-level functions.
      x = foo;
      assert(foo == x);
    
      // Comparing static methods.
      x = A.bar;
      assert(A.bar == x);
    
      // Comparing instance methods.
      var v = new A(); // Instance #1 of A
      var w = new A(); // Instance #2 of A
      var y = w;
      x = w.baz;
    
      // These closures refer to the same instance (#2),
      // so they're equal.
      assert(y.baz == x);
    
      // These closures refer to different instances,
      // so they're unequal.
      assert(v.baz != w.baz);
    }

##### (8)返回值 #####

所有的函数都返回一个值。如果没有指定返回值，则 默认把语句 return null; 作为函数的最后一个语句执行。

#### 四、类定义 ####

class Spacecraft { 
      String name;
      DateTime launchDate;
      int launchYear;
    
      // Constructor, including syntactic sugar for assignment to members.
      Spacecraft(this.name, this.launchDate) { 
        // Pretend the following is something you'd actually want to run in
        // a constructor.
        launchYear = launchDate?.year;
      }
    
      // Named constructor that forwards to the default one.
      Spacecraft.unlaunched(String name) : this(name, null);
    
      // Method.
      void describe() { 
        print('Spacecraft: $name');
        if (launchDate != null) { 
          int years = new DateTime.now().difference(launchDate).inDays ~/ 365;
          print('Launched: $launchYear ($years years ago)');
        } else { 
          print('Unlaunched');
        }
      }
    }

可以这样使用上面定义的类：

var voyager = new Spacecraft('Voyager I', new DateTime(1977, 9, 5));
    voyager.describe();
    
    var voyager3 = new Spacecraft.unlaunched('Voyager III');
    voyager3.describe();

#### 五、构造函数 ####

###### (1)、默认构造函数 ######

默认构造函数即不需要额外定义的构造函数

main() { 
     Person person= new Person();
    }
    class Person { 
      String name;
      int age;
    }

也可以显示指定构造函数

class Person { 
      String name;
      int age;
    
      Person(String name, int age) { 
        this.name = name;
        this.age = age;
      }
    }

上面这个构造函数可以简单写成下面这样。

class Person { 
      String name;
      int age;
      Person(this.name, this.age);
    }

dart不允许有同名的构造函数，普通函数之间也不能同名。例如下面的代码会编译不通过。

class Person { 
      String name;
      int age;
    
      Person(){ 
       
      }
      Person(String name,int age){ 
    
      }
    }

那么如何实现构造函数重载呢？请往下看。

###### (2)、命名构造函数 ######

main() { 
      Person person1 = new Person("kitty",10);
      Person person2 = new Person.onlyName("Michale");
      Person person3 = new Person.onlyAge(12);
      print("person1: name=${person1.name},age=${person1.age}");
      print("person2: name=${person2.name},age=${person2.age}");
      print("person3: name=${person3.name},age=${person3.age}");
    }
    
    class Person { 
      String name;
      int age;
      Person(this.name, this.age);
      Person.onlyName(this.name);
      Person.onlyAge(this.age);
    }

上面Person.onlyName和Person.onlyAge就是命名构造函数。相当于是构造函数重载。当然还可以使用命名参数和位置参数实现构造函数重载。

运行结果：

person1: name=kitty,age=10
    person2: name=Michale,age=null
    person3: name=null,age=12

###### (3)、重定向构造函数 ######

重定向构造函数，就是将函数的实现委托给另一个构造函数(不是父类的构造函数)，并且自身不允许有实现。

main() { 
      Person person1 = new Person("kitty",10);
      Person person2 = new Person.onlyName("Michale");
      print("person1: name=${person1.name},age=${person1.age}");
      print("person2: name=${person2.name},age=${person2.age}");
    }
    
    class Person { 
      String name;
      int age;
      Person(this.name, this.age);
      Person.onlyName(String _name):this(_name,12); //不允许有函数体，否则编译不通过。
    }

运行结果：

person1: name=kitty,age=10
    person2: name=Michale,age=12

跟java一样，dart语言中，构造函数也是不能被子类继承。  
如果父类没有无参构造函数，那么子类必须显式声明一个构造函数，并且要显式调用父类的构造函数。  
这一点跟java是一样的，语法上不同的是，子类只需要在函数签名后加上":super(…)"。

main() { 
      Employee employee1 = new Employee("kitty",10,8000);
      print("employee1: name=${employee1.name},age=${employee1.age},salary=${employee1.salary}");
    }
    
    class Person { 
      String name;
      int age;
      
      Person(this.name, this.age) { 
        print("super construted");
      }
    
    }
    
    class Employee extends Person { 
      double salary;
      Employee(String name, int age, this.salary) : super(name, age) { 
        print("child construted");
      }
    }

运行结果：

super construted
    child construted
    employee1: name=kitty,age=10,salary=8000.0

下面代码跟上面代码等同。

class Person { 
      String name;
      int age;
      Person(this.name, this.age);
    }
    
    class Employee extends Person { 
      double salary;
      Employee(String name, int age, this.salary) : super(name, age);
    }

###### (4)初始化列表 ######

除了调用超类构造函数外，您还可以在构造函数主体运行之前初始化实例变量。用逗号分隔初始化代码。

// Initializer list sets instance variables before
    // the constructor body runs.
    Point.fromJson(Map<String, num> json)
        : x = json['x'],
          y = json['y'] { 
      print('In Point.fromJson(): ($x, $y)');
    }

在开发过程中，您可以通过assert在初始化列表中使用来验证输入。

Point.withAssert(this.x, this.y) : assert(x >= 0) { 
      print('In Point.withAssert(): ($x, $y)');
    }

初始化final字段时，初始化列表很方便。下面的示例在初始化列表中初始化三个final字段。

import 'dart:math';
    
    class Point { 
      final num x;
      final num y;
      final num distanceFromOrigin;
    
      Point(x, y)
          : x = x,
            y = y,
            distanceFromOrigin = sqrt(x * x + y * y);
    }
    
    main() { 
      var p = new Point(2, 3);
      print(p.distanceFromOrigin);
    }

###### （5）常量构造函数 ######

如果您的类产生了永不改变的对象，则可以使这些对象具有编译时常量。为此，请定义一个const构造函数，并确保所有实例变量均为final。

class ImmutablePoint { 
      static final ImmutablePoint origin =
          const ImmutablePoint(0, 0);
    
      final num x, y;
    
      const ImmutablePoint(this.x, this.y);
    }

flutter中Image.asset源码示例：

Image.asset(
        String name, { 
        Key key,
        AssetBundle bundle,
        this.frameBuilder,
        this.semanticLabel,
        this.excludeFromSemantics = false,
        double scale,
        this.width,
        this.height,
        this.color,
        this.colorBlendMode,
        this.fit,
        this.alignment = Alignment.center,
        this.repeat = ImageRepeat.noRepeat,
        this.centerSlice,
        this.matchTextDirection = false,
        this.gaplessPlayback = false,
        String package,
        this.filterQuality = FilterQuality.low,
      }) : image = scale != null
             ? ExactAssetImage(name, bundle: bundle, scale: scale, package: package)
             : AssetImage(name, bundle: bundle, package: package),
           loadingBuilder = null,
           assert(alignment != null),
           assert(repeat != null),
           assert(matchTextDirection != null),
           super(key: key);

[http_dart.goodev.org_guides_language_language-tour]: http://dart.goodev.org/guides/language/language-tour
[https_dart.dev_guides_language_language-tour]: https://dart.dev/guides/language/language-tour
[https_dart.dev_get-dart]: https://dart.dev/get-dart
[https_code.visualstudio.com]: https://code.visualstudio.com/
[javascript]: https://www.runoob.com/js/js-datatypes.html
[python]: https://www.runoob.com/python3/python3-data-type.html