Dart进阶

「已注销」

于 2023-04-21 21:56:48 发布

阅读量429

点赞数

分类专栏：学习文章标签： Dart

本文链接：https://blog.csdn.net/qq_54554848/article/details/130297736

版权

学习专栏收录该内容

21 篇文章 0 订阅

订阅专栏

Dart 是一种用于构建应用程序的编程语言，它具有许多语法糖（Syntactic Sugar）特性，这些特性能够简化代码并提高开发效率。以下是 Dart 中一些常见的语法糖特性：

级联操作符（Cascade Notation）：Dart 允许使用级联操作符 … 连续调用对象的多个方法，而不需要反复引用同一个对象，例如：myObject…method1()…method2()…method3();。

class Dog_kik{
  void take_own_action(){
    print('汪汪汪~~~');
  }
  void take_action(){
    print('汪汪汪');
  }
  void act(){
    print('Animal action');
  }
}

void main(){
  Dog_kik kiki = Dog_kik();
  kiki..take_own_action()..take_action()..act();
}

箭头函数：Dart 支持使用箭头函数 => 定义单行的匿名函数，这样可以简化函数的定义和使用，例如：(int a, int b) => a + b，这个箭头函数实现了两个整数相加的功能，相当于版本的return。

int power(int number) => number * number;
void main() { print("11x11 =  ${power(11)}"); }

扩展方法（Extension Methods）：Dart 允许使用扩展方法为现有的类添加新的方法，而无需修改类的定义，这种方式可以为已有的类添加功能，例如：extension StringPrint on String { void printString() { print(this); } }，这里为 String 类型添加了一个名为 printString 的方法，可以直接在字符串对象上调用该方法。

class Dog {
  void action(){
    print('汪汪汪');
  }
}

// NewAction随便取名字，它更像一个注释，用来阐述你的方法用于干什么
extension NewAction on Dog {
  String getName(String name) => "the dog named $name";
}

main (){
  Dog dog_kiki = Dog();
  dog_kiki.action();
  print(dog_kiki.getName('kiki'));
}

类型别名（Type Alias）：Dart 支持使用 typedef 关键字创建自定义的类型别名，可以将复杂的类型定义简化为一个简洁的名称，例如：typedef void MyCallback(int value);，这里创建了一个名为 MyCallback 的类型别名，表示接受一个 int 类型参数且返回 void 的回调函数类型。

class Dog {
  void action(){
    print('汪汪汪');
  }
}

typedef Dog2 = Dog;

main (){
  Dog2 dog_kiki = Dog2();
  dog_kiki.action();
}

空安全（Null Safety）：Dart 2.12+ 引入了空安全特性，它可以帮助开发者在编译时检测和预防空指针异常，包括强制非空声明、可空类型、空安全运算符（?、!）等，从而减少空指针异常的风险并简化代码。

main(){
  var number; print(number); // null

  // 使用空安全操作符 "?" 来访问可空类型的属性或调用方法
  String ? str;
  print(str);     // null
  int ? len_str = str?.length;
  print(len_str);  // null

  // 使用空安全操作符 "!" 来断言可空类型不为 null，并访问其属性或调用方法
  int another_len = str!.length;
  print(another_len);
}

集合（Collection）相关的语法糖：Dart 提供了丰富的集合相关的语法糖，例如集合初始化列表、集合推导式、扩展操作符（…）等，这些语法糖可以简化集合的创建、操作和转换。

void main(){
  // 用以下方式建立一个列表
  var list1 = [1, 2, 3];
  var list2 = [for (int i=0;i<5;i++) i];  // 很像python的列表语法糖
  var list3 = List.generate(3, (index) => index * 2);  // 生成3个元素,类似Python的生成器写法，请看下面Python的生成器写法
  // 优先备注 ： 这是Dart的匿名函数的一种写法，(int parameter) => parameter * 2;
  // 这种写法更像是Python中的lambda匿名函数
  // Python生成器写法
  // def func():
  //   for i in range(5):
  //     yield i

  // 列表合并
  var list4 = [...list1, ...list2];
  // 注意，列表合并与下面不同
  var list5 = [list1, list2];

  // 列表复制
  var list6 = [...list1];
  print(list1);
  print(list2);
  print(list3);
  print(list4);
  print(list5);
  print(list6);

  // 创建集合、字典的语法糖
  var set1 = { for (var i=0;i<10;i++) if (i % 2 == 0) i};
  var map1 = {for (var i=0;i<5;i++) i : i * 2 };
  print(set1);
  print(map1);
  // 拓展字典项目
  map1 = {...map1, 6 : 12};
  print(map1);
}

forEach遍历功能

void main(){
  var list7 = [1, 2, 3, 0, 1, 2, 3, 4];
    list7.forEach((element) {
    print( element * 2);
    });
// 相当于
for (var i in list7) {print(i * 2);};
}

多继承

class ClassA {
  void methodA() {
    print('methodA');
  }
}

class ClassB {
  void methodB() {
    print('methodB');
  }
}

class ClassC with ClassA, ClassB{
  void methodC() {
    print('methodC');
  }
}

void main() {
  var example = ClassC();
  example.methodA();
  example.methodB();
  example.methodC();
}

紧凑的构造函数语法：Dart 允许在构造函数中通过参数直接对实例字段进行初始化，例如 class MyClass { int x; MyClass(this.x); }，这种方式可以简化构造函数的定义和使用。

class A_List {
  int __len;
  A_List(this.__len);   // 替代了AList(int __len) {__len = __len;}的繁琐
  void getLen() { print("Object len is $__len") ; }
}

void main(){
  A_List alist = A_List(11);
  alist.getLen();
}

可选的命名构造函数：Dart 支持在类中定义多个命名构造函数，并通过不同的命名来进行区分，从而方便地创建不同形式的对象实例，例如 class MyClass { MyClass(); MyClass.fromValue(int value); }，这里定义了一个默认构造函数和一个名为 fromValue 的命名构造函数。

class Dog {
  int age = 0;
  Dog(){
    print('这是一条狗');
  }
  Dog.fromValue(this.age) {
    print("这是一条年龄是的$age的狗");
  }
}

main(){
  Dog kiki = Dog();
  Dog poky = Dog.fromValue(5);
}

局部函数：Dart 允许在函数内部定义局部函数，这样可以将一些辅助函数定义在主函数内部，避免了污染全局命名空间，也可以使得辅助函数在主函数内部更加集中和易于访问。

main() {
  int count = 0;
  void help_U_count(){
    ++count;
    print("当前计数$count次");
  }
  help_U_count();
  help_U_count();
  help_U_count()  ;
}

函数递归

// 斐波那契数列
int fib(var n){
  if (!(n > 2)){  // 这里测试一下取反，故意写麻烦
    return n;
  }
  else {
    return fib(n - 1) + fib(n - 2);
  }
}

int main(){
  for (int i=1;i<21;i++){
    print("第$i个斐波那契数为${fib(i)}");
  }
  return 0;
}

闭包

// 闭包
Function outer(){
  int insider(int number){
    return number * number;
  }
  return insider;
}

Function function1(){
  Function function2(int number1) {
    int function3(int number2){
      return number1 * number2;
    }
    return function3;
  }
  return function2;
}

void main(){
  var func = outer();
  print('调用内置函数 : ${func(12)}');
  print('还可以这么使用 : ${outer()(12)}');

  // 试试这个三层嵌套
  // 计算4x6
  print(function1()(4)(6));
}

字符串的多行模式：Dart 允许使用三个单引号 ‘’’ 或三个双引号 “”" 来定义多行字符串，这样可以在字符串中包含换行符和缩进，使得多行字符串的书写更加方便。

var str = """
   字符串的多行模式：Dart 允许使用三个单引号  
   或三个双引号 来定义多行字符串，这样可以在字符串中包含换行符和缩进，
   使得多行字符串的书写更加方便
""";

var str2 = '''
   字符串的多行模式：Dart 允许使用三个单引号   或三个双引号 来定义多行字符串，这样可以在字符串中包含换行符和缩进，使得多行字符串的书写更加方便
''';

Mixins：Dart 支持使用 mixin 关键字创建 Mixin 类，它可以作为多继承的替代方案，用于在多个类之间共享代码，从而避免了传统多继承可能带来的问题，例如钻石继承等。

mixin Record_Message {
  void record(String type){
    print("Message ： $type");
  }
}

void record(String type){
  print("Message ： $type");
}

class A with Record_Message {
  void getId(int id){
    record("id => $id");
  }
}

class B with Record_Message {
  void getCount(int count){
    record('count => $count');
  }
}

void main(){
  A a = A();
  var b = B() ;
  a.getId(11);
  b.getCount(1323);
}

重载运算符

// 复数
class Complex {
  int a, b;
  var li = [];
  Complex(this.a, this.b){
    li.add(this.a);
    li.add(this.b);
  }
  // 重载[]，使得允许索引访问
  int operator[](int index) {
    return li[index];
  }
}

void main(){
  Complex com = Complex(4, 6);
  print(com[1]);
}

dart中异常与报错处理，以及自定义异常或者错误

// 自定义报错类
class MyError{
  String error;
  MyError(this.error){
    print("Error : $error");
  }
}

void main(){
  // 捕捉
  try{
    assert (1 > 11);
  }
  catch (e){
    print("Catch the Error : $e");
  }
  finally{
    print("无论是对是错，都会执行");
  }
  // 自定义
  // 比如说dart中1/0会得到Infinitely，但是我不希望这样，而是报错，0不能作为分母
  if ((1 / 0) == double.infinity) {
    throw MyError("0不能作为分母");
  }
  else {
    print('....');
  }
}

在 Dart 中，implements 关键字用于实现接口。接口是一种描述类应该具有哪些成员（方法、属性等）的约定，类可以通过实现接口来确保自己具有指定的成员。使用 implements 关键字可以在类中实现一个或多个接口。

abstract class Animal {
  void action();
}

class Horse implements Animal{
  void action(){
    print('马会跑');
  }
}

class Bird implements Animal{
  void action(){
    print('鸟会飞');
  }
}

class Fish implements Animal {
  void action(){
    print('鱼在水里游');
  }
}

main()    {
  Horse h = Horse();
  Fish f = Fish();
  Bird b = Bird();
  h.action();
  f.action();
  b.action();
}

生成器,生成器函数提供了一种延迟计算、节省内存、简化代码和支持无限序列等优点，使得在处理大数据集、复杂计算或需要按需生成值的情况下，生成器函数成为一种非常有用的编程工具。

Iterable yieldNumber(int len) sync* {  // Iterable是可迭代的类型，sync*来声明这是一个生成器函数
  for (int i=0;i<len;i++) {
    yield i * 2;
  }
}

void main(){
  for (int i in yieldNumber(12)){
    print(i);
  }
}

源代码下载链接： https://gitee.com/PythonnotJava/NoteBooks/tree/master/dart-tutorial
文章链接：https://www.robot-shadow.cn/src/h5/other/Dart%E9%AB%98%E7%BA%A7%E6%95%99%E7%A8%8B.html