Dart基础二方法，类，异常

最新推荐文章于 2024-04-17 11:51:48 发布
最新推荐文章于 2024-04-17 11:51:48 发布
阅读量729 收藏
点赞数 1
分类专栏： Dart
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Piston_zg/article/details/88319066
版权

官方网站：https://www.dartlang.org/guides/language/language-tour

细节中文教程：https://www.jianshu.com/p/9e5f4c81cc7d

# Dart基础

## 类

 

​ Dart 是一个面向对象编程语言。 每个对象都是一个类的实例，所有的类都继承于 `Object`。

 

```dart

//每个实例变量都会自动生成一个 getter 方法（隐含的）。 非final 实例变量还会自动生成一个 setter 方法。

class Point {

  num x;

  num y;

}

```

 

### 构造函数

 

​ 由于把构造函数参数赋值给实例变量的场景太常见了， Dart 提供了一个语法糖来简化这个操作：

 

```dart

class Point {

  num x;

  num y;

 

  Point(this.x, this.y);

}

```

 

### 命名构造函数

 

​ Dart 并不支持构造函数的重载，而采用了命名构造函数为一个类实现多个构造函数：

 

```dart

class Point {

  num x;

  num y;

  Point(this.x, this.y);

  Point(this.y);///错误，不允许重载

  //命名构造函数

  Point.y(this.y) {

    x = 0;

  }

}

 

//使用

var p = Point.y(0);

```

 

 

 

### 初始化列表

 

​ 在构造函数函数体执行之前会首先执行初始化列表，非常适合用来设置 final 变量的值。 

 

```dart

class Point {

  num x;

  num y;

  Point(this.x, this.y);

  //命名构造函数

  Point.y(this.y) {

    x = 0;

  }

 

  Point.fromMap(Map map)

      : x = map['x'], // : 和c++一样，初始化列表

        y = map['y'];

  

  Point.x(int i)

      : x = i, 

        y = 0;

}

```

 

 

 

### 重定向构造函数

 

​ 有时候一个构造函数会调动类中的其他构造函数(在Java中就是 `this(...)`)。 一个重定向构造函数是没有代码的，在构造函数声明后，使用 冒号调用其他构造函数。

 

```dart

class Point {

  num x;

  num y;

 

  Point(this.x, this.y);

  Point.xy(int x,int y):this(x,y); ///调用上面的构造函数

}

```

 

 

 

### 常量构造函数

 

​ 如果你的类提供一个状态不变的对象，你可以把这些对象 定义为编译时常量。要实现这个功能，需要定义一个 `const` 构造函数， 并且声明所有类的变量为 `final`。

 

```dart

class ImmutablePoint {

  final num x;

  final num y;

  //常量构造函数

  const ImmutablePoint(this.x, this.y);

}

 

void main(){

    //编译器常量

    var p1 = const ImmutablePoint(0,0);

    var p2 = const ImmutablePoint(0,0);

    print(p1 == p2); // true

}

```

 

 

 

### 工厂构造函数

 

​   当实现一个使用` factory` 关键词修饰的构造函数时，这个构造函数不必创建类的新实例。例如，一个工厂构造函数 可能从缓存中获取一个实例并返回，或者 返回一个子类型的实例。（工厂构造函数无法访问 `this`）

 

```dart

class Logger {

  final String name;

  //从缓存获取对象

  static final Map _cache = {};

  //工厂构造函数，无法使用this变量

  factory Logger(String name) {

    if (_cache.containsKey(name)) {

      //工厂构造函数需要返回 Logger 实例对象

      return _cache[name];

    } else {

      final logger = Logger._internal(name);

      _cache[name] = logger;

      return logger;

    }

  }

  //以 _ 开头的函数、变量无法在库外使用

  Logger._internal(this.name);

}

```

 

​ 借助工厂构造函数能够实现单例:

 

```dart

//使用工厂构造实现单例

class Manager {

  static Manager _instance;

  //和static是一样的, 区别是factory毕竟是构造函数，需要返回一个实例，而static是静态方法。

  factory Manager.getInstance() {

    if (_instance == null) {

      _instance =  new Manager._internal();

    }

    return _instance;

  }

 

//  static Manager getInstance() {

//    if (_instance == null) {

//      _instance = new Manager._internal();

//    }

//    return _instance;

//  }

  Manager._internal();

}

 

```

 

 

 

### Getters 和 Setters

 

​ Dart中每个实例变量都隐含的具有一个 getter， 如果变量不是 final 的则还有一个 setter。可以通过实现 getter 和 setter 来创建新的属性， 使用 `get` 和 `set` 关键字定义 getter 和 setter：

 

```dart

class Rect {

  num left;

  num top;

  num width;

  num height;

 

  Rect(this.left, this.top, this.width, this.height);

 

  //使用 get定义了一个 right 属性

  num get right             => left + width;

  set right(num value)  => left = value - width;

}

 

void main() {

  var rect = Rect(0, 0, 10, 10);

  print(rect.right); //10

  rect.right = 15;

  print(rect.left);  //5

}

```

 

> 需要注意的是，在get与set中使用自身会导致Stack Overflow

 

### 可覆写的操作符

 

​ 把已经定义的、有一定功能的操作符进行重新定义。可以重新定义的操作符有：

 

| `<`  | `+`  | `|`  | `[]`  |

| ---- | ---- | ---- | ----- |

| `>`  | `/`  | `^`  | `[]=` |

| `<=` | `~/` | `&`  | `~`   |

| `>=` | `*`  | `<<` | `==`  |

| `–`  | `%`  | `>>` |       |

 

​ 比如：List就重写了 `[]`。

 

```dart

class Point {

  int x;

  int y;

  //返回值 参数随你定义

  Point operator +(Point point) {

    return Point(x + point.x, y + point.y);

  }

 

  Point(this.x, this.y);

}

 

var p1 = Point(1, 1);

var p2 = p1 + Point(2, 2);

print(p2.x); ///3

print(p2.y); ///3

```

 

 

 

### 抽象类

 

​ 使用 `abstract` 修饰符定义一个抽象类。抽象类中允许出现无方法体的方法

 

```dart

abstract class Parent {

  String name;

  void printName(); //抽象方法，不需要在方法前声明 abstract

}

```

 

​ 抽象类不能被实例化，除非定义工厂方法并返回子类。

 

```dart

abstract class Parent {

  String name;

  //默认构造方法

  Parent(this.name);

  //工厂方法返回Child实例

  factory Parent.test(String name){

    return new Child(name);

  }

  void printName();

}

// extends 继承抽象类

class Child extends Parent{

  Child(String name) : super(name);

 

  @override

  void printName() {

    print(name);

  }

}

 

void main() {

  var p = Parent.test("Lance");

  print(p.runtimeType); //输出实际类型 Child

  p.printName();

}

 

```

 

### 接口

 

​ 与Java不同，Dart中没有`interface`关键字，**Dart中每个类都隐式的定义了一个包含所有实例成员的接口**， 并且这个类实现了这个接口。如果你想 创建类 A 来支持 类 B 的 方法，而不想继承 B 的实现， 则类 A 应该实现 B 的接口。

 

```dart

class Listener{

  void onComplete(){}

  void onFailure(){}

}

 

class MyListsner implements Listener{

  MyListsner(){

 

  }

  @override

  void onComplete() {

  }

 

  @override

  void onFailure() {

  }

}

```

 

与继承的区别在于：

 

1、单继承，多实现。

 

2、继承可以有选择的重写父类方法并且可以使用`super`，实现强制重新定义接口所有成员。

 

 

 

### 可调用的类

 

​ 如果 Dart 类实现了 `call()` 函数则 可以当做方法来调用。

 

```dart

class Closure {

  call(String a, String b) => '$a $b!';

}

 

main() {

  var c = new Closure();

  var out = c("Hello","Dart");

  print(out);

}

```

 

 

 

### 混合mixins

 

​ Mixins 是一种在多类继承中重用 一个类代码的方法。它的基本形式如下：

 

```dart

//被mixin(混入)的类不能有构造函数

class A  {

  void a(){}

}

class B{

  void b(){}

}

class C with A,B{

  void c(){}

}

```

 

`with`后面跟着需要混入的类，被`mixin`(混入)的类不能有构造函数。现在的 `C`拥有了三个方法（a、b与c）。假设A与B 存在相同的方法，以最右侧的混入类为主，比如：

 

```dart

class A {

  String getMessage() => 'A';

}

 

class B {

  String getMessage() => 'B';

}

//

class AB with A, B {}

 

class BA  with B, A {}

 

void printMessage(obj) => print(obj.getMessage());

 

void main() {

  printMessage(AB()); //输出 B

  printMessage(BA()); //输出 A

}

```

 

继承与mixins是兼容的

 

```dart

class A {

  String getMessage() => 'A';

}

 

class B {

  String getMessage() => 'B';

}

class P{

  String getMessage() => 'P';

}

class AB extends P with A, B {}

 

class BA extends P with B, A {}

//可以简写成：

//class AB = P with A, B;

//class BA = P with B, A;

void printMessage(obj) => print(obj.getMessage());

 

void main() {

  printMessage(AB()); //输出 B

  printMessage(BA()); //输出 A

}

```

 

​ mixins弥补了接口和继承的不足，继承只能单继承，而接口无法复用实现，mixins却可以多混入并且能利用到混入类的具体实现：

 

```dart

abstract class Swimming{

    void swimming(){

        print("游泳");

    }

}

 

abstract class Jump{

    void jump(){

        print("跳跃");

    }

}

 

//只能单继承，如果需要Jump，只能以implements的形式

class Lance extends Swimming implements Jump{

  //实现接口

    void jump(){

        print("跳跃");

    }

}

 

//但是实际上，我们经常不需要重新实现Jump方法，复用Jump所实现的jump方法就可以了

//这时使用混合能够更加方便

class Lance1 with Swimming, Jump {}

```

 

 

 

## 异步编程

 

### ioslate机制

 

​ Dart是基于单线程模型的语言。但是在开发当中我们经常会进行耗时操作比如网络请求，这种耗时操作会堵塞我们的代码，所以在Dart也有并发机制，名叫**isolate**。APP的启动入口`main`函数就是一个类似Android主线程的一个主isolate。和Java的Thread不同的是，Dart中的isolate无法共享内存。

 

```dart

import 'dart:isolate';

 

int i;

 

void main() {

  i = 10;

  //创建一个消息接收器

  ReceivePort receivePort = new ReceivePort();

  //创建ioslate

  Isolate.spawn(isolateMain, receivePort.sendPort);

 

  //接收其他isolate发过来的消息

  receivePort.listen((message) {

    //发过来sendPort,则主isolate也可以向创建的isolate发送消息

    if (message is SendPort) {

      message.send("好呀好呀!");

    } else {

      print("接到子isolate消息:" + message);

    }

  });

}

 

/// 新isolate的入口函数

void isolateMain(SendPort sendPort) {

  // isolate是内存隔离的，i的值是在主isolate定义的所以这里获得null

  print(i);

 

  ReceivePort receivePort = new ReceivePort();

  sendPort.send(receivePort.sendPort);

 

 

  // 向主isolate发送消息

  sendPort.send("去大保健吗？");

 

 

  receivePort.listen((message) {

    print("接到主isolate消息:" + message);

  });

}

```

 

 

 

### event-loop

 

​ 可以看到代码中，我们接收消息使用了`listene`函数来监听消息。假设我们现在在main方法最后加入`sleep`休眠，会不会影响`listene`回调的时机？

 

```dart

import 'dart:io';

import 'dart:isolate';

 

int i;

 

void main() {

  i = 10;

  //创建一个消息接收器

  ReceivePort receivePort = new ReceivePort();

  //创建ioslate

  Isolate.spawn(isolateMain, receivePort.sendPort);

 

  //接收其他isolate发过来的消息

  receivePort.listen((message) {

    //发过来sendPort,则主isolate也可以向创建的isolate发送消息

    if (message is SendPort) {

      message.send("好呀好呀!");

    } else {

      print("接到子isolate消息:" + message);

    }

  });

 

  //增加休眠，是否会影响listen的时机？

  sleep(Duration(seconds: 2));

  print("休眠完成");

}

 

/// 新isolate的入口函数

void isolateMain(SendPort sendPort) {

  // isolate是内存隔离的，i的值是在主isolate定义的所以这里获得null

  print(i);

 

  ReceivePort receivePort = new ReceivePort();

  sendPort.send(receivePort.sendPort);

  // 向主isolate发送消息

  sendPort.send("去大保健吗？");

 

 

  receivePort.listen((message) {

    print("接到主isolate消息:" + message);

  });

}

```

 

​ 结果是大概2s后，我们的`listene`才打印出其他isolate发过来的消息。同Android Handler类似，在Dart运行环境中也是靠事件驱动的，通过event loop不停的从队列中获取消息或者事件来驱动整个应用的运行，isolate发过来的消息就是通过loop处理。但是不同的是在Android中每个线程只有一个Looper所对应的MessageQueue，而Dart中有两个队列，一个叫做**event queue(事件队列)**，另一个叫做**microtask queue(微任务队列)**。

 

![消息机制](图片/消息机制.png)

 

​ Dart在执行完main函数后，就会由Loop开始执行两个任务队列中的Event。首先Loop检查微服务队列，依次执行Event，当微服务队列执行完后，就检查Event queue队列依次执行，在执行Event queue的过程中，没执行完一个Event就再检查一次微服务队列。所以微服务队列优先级高，可以利用微服务进行插队。

 

 

 

我们先来看个例子:

 

```dart

 

import 'dart:io';

 

void main(){

  new File("/Users/enjoy/a.txt").readAsString().then((content){

      print(content);

  });

  while(true){}

}

```

 

文件内容永远也无法打印出来，因为main函数还没执行完。而then方法是由Loop检查Event queue执行的。

 

如果需要往微服务中插入Event进行插队：

 

```dart

 

import 'dart:async';

import 'dart:io';

//结果是限制性了microtask然后执行then方法。

void main(){

  new File("/Users/enjoy/a.txt").readAsString().then((content){

      print(content);

  });

  //future内部就是调用了 scheduleMicrotask

  Future.microtask((){

    print("future: excute microtask");

 

  });

//  scheduleMicrotask((){

//    print("");

//  });

 

}

```

 

 

 

### Future

 

​ 在 Dart 库中随处可见 Future 对象，通常异步函数返回的对象就是一个 Future。 当一个 future *执行完后*，他里面的值 就可以使用了，可以使用 `then()` 来在 future 完成的时候执行其他代码。

 

#### 异常

 

```dart

//当给到一个不存在的文件地址时会发生异常，这时候可以利用catchError捕获此异常。

//then().catchError() 模式就是异步的 try-catch。

new File("/Users/enjoy/a1.txt").readAsString().then((content) {

    print(content);

  }).catchError((e, s) {

    print(s);

  });

```

 

#### 组合

 

`then()`的返回值同样是一个future对象，可以利用队列的原理进行组合异步任务

 

```dart

  new File("/Users/enjoy/a.txt").readAsString().then((content) {

    print(content);

    return 1; //1被转化为 Future<int>类型 返回

  }).then((i){

    print(i);

  }).catchError((e, s) {

    print(s);

  });

```

 

上面的方式是等待执行完成读取文件之后，再执行一个新的future。如果我们需要等待一组任务都执行完成再统一处理一些事情，可以通过`wait()`完成。

 

```dart

 Future readDone = new File("/Users/enjoy/a.txt").readAsString();

  //延迟3s

  Future delayedDone = Future.delayed(Duration(seconds: 3));

 

  Future.wait([readDone, delayedDone]).then((values) {

     print(values[0]);//第一个future的结果

     print(values[1]);//第二个future的结果

  });

```

 

 

 

### Stream

 

​ Stream(流) 在 Dart API 中也经常出现，表示发出的一系列的异步数据。 Stream 是一个异步数据源，它是 Dart 中处理异步事件流的统一 API。

 

​ Future 表示稍后获得的一个数据，所有异步的操作的返回值都用 Future 来表示。但是 Future 只能表示一次异步获得的数据。而 Stream 表示多次异步获得的数据。比如 IO 处理的时候，每次只会读取一部分数据和一次性读取整个文件的内容相比，Stream 的好处是处理过程中内存占用较小。而 File 的 `readAsString()`是一次性读取整个文件的内容进来，虽然获得完整内容处理起来比较方便，但是如果文件很大的话就会导致内存占用过大的问题。

 

```dart

 new File("/Users/enjoy/app-release.apk").openRead().listen((List<int> bytes) {

    print("stream执行"); //执行多次

  });

 

  new File("/Users/enjoy/app-release.apk").readAsBytes().then((_){

    print("future执行"); //执行1次

  });

```

 

`listen()`其实就是订阅这个Stream，它会返回一个`StreamSubscription`订阅者。订阅者肯定就提供了取消订阅的`cancel()`，去掉后我们的listen中就接不到任何信息了。除了`cancel()`取消方法之外，我们还可以使用`onData()`重置listene方法，`onDone`监听完成等等操作。

 

```dart

  StreamSubscription<List<int>> listen = new File("/Users/enjoy/app-release.apk").openRead().listen((List<int> bytes) {

    print("stream执行");

  });

  listen.onData((_){

    print("替代listene");

  });

  listen.onDone((){

    print("结束");

  });

  listen.onError((e,s){

    print("异常");

  });

  //暂停，如果没有继续则会退出程序

  listen.pause();

  //继续

  listen.resume();

```

 

 

 

#### 广播模式

 

​ Stream有两种订阅模式：单订阅和多订阅。单订阅就是只能有一个订阅者，上面的使用我们都是单订阅模式，而广播是可以有多个订阅者。通过 Stream.asBroadcastStream() 可以将一个单订阅模式的 Stream 转换成一个多订阅模式的 Stream，isBroadcast 属性可以判断当前 Stream 所处的模式。

 

```dart

var stream = new File("/Users/enjoy/app-release.apk").openRead();

  stream.listen((List<int> bytes) {

  });

  //错误 单订阅只能有一个订阅者

//  stream.listen((_){

//    print("stream执行");

//  });

 

  var broadcastStream = new File("/Users/enjoy/app-release.apk").openRead().asBroadcastStream();

  broadcastStream.listen((_){

    print("订阅者1");

  });

  broadcastStream.listen((_){

    print("订阅者2");

  });

```

 

需要注意的是，多订阅模式如果没有及时添加订阅者则可能丢数据。

 

```dart

//默认是单订阅

  var stream = Stream.fromIterable([1, 2, 3]);

  //3s后添加订阅者 不会丢失数据

  new Timer(new Duration(seconds: 3), () => stream.listen(print));

 

  //创建一个流管理器 对一个stream进行管理

  var streamController = StreamController.broadcast();

  //添加

  streamController.add(1);

  //先发出事件再订阅 无法接到通知

  streamController.stream.listen((i){

    print("broadcast:$i");

  });

  //记得关闭

  streamController.close();

 

 

  //这里没有丢失，因为stream通过asBroadcastStream转为了多订阅，但是本质是单订阅流，并不改变原始 stream 的实现特性

  var broadcastStream = Stream.fromIterable([1, 2, 3]).asBroadcastStream();

  new Timer(new Duration(seconds: 3), () => broadcastStream.listen(print));

```

 

 

 

### async/await

 

​ 使用`async`和`await`的代码是异步的，但是看起来很像同步代码。当我们需要获得A的结果，再执行B，时，你需要`then()->then()`,但是利用`async`与`await`能够非常好的解决回调地狱的问题：

 

```dart

//async 表示这是一个异步方法,await必须再async方法中使用

//异步方法只能返回 void和Future

Future<String> readFile() async {

  //await 等待future执行完成再执行后续代码

  String content = await new File("/Users/xiang/enjoy/a.txt").readAsString();

  String content2 = await new File("/Users/xiang/enjoy/a.txt").readAsString();

  //自动转换为 future

  return content;

}

Piston_zg
关注
专栏目录
-Dart基础
02-12
【Dart基础】是本文的核心话题，这门编程语言由Google开发，主要用于构建高性能的Web、移动和服务器应用程序。Dart是一种面向对象的、强类型的、现代的编程语言，其设计目标是提供高效的开发工具、流畅的代码编写...
Dart基础——Dart语法
JackWu blog
01-14 1765
本文主要介绍Dart开发常用的一些语法 基础语法 两种定义常量的方式 使用过程中从来不会被修改的变量， 可以使用 final 或 const, Final 变量的值只能被设置一次； Const 变量在编译时就已经固定 (Const 变量 是隐式 Final 的类型.) final 变量或类变量在第一次使用时被初始化，懒加载 。 Const不能定义对象 Final能定义对象 例： //可以省略String这个类型声明 final str = "hi world"; //final String str =
Flutter学习笔记02：Dart语言简介
haoyuegongzi的博客
06-06 733
一、Dart语言概述 Dart是谷歌开发的计算机编程语言，被用于web、服务器、移动应用和物联网等领域的开发。Dart是面向对象的、类定义的、单继承的语言。它的语法类似C语言，可以转译为JavaScript，支持接口(interfaces)、混入(mixins)、抽象类(abstract classes)、具体化泛型(reified generics)、可选类型(optional typing)和sound type system。其语法风格借鉴了Java、JavaScript、Kotlin编程语言的风格。
flutter的Text内容自动换行导致留白问题
周末
01-19 5554
flutter的文本内容在中英文混排，或中文与数字或特殊符号或英文字母时，文本会被自动换行，这样会导致，换行后上一行末尾留出很大的空白区域。 解决思路： 1、把每个字符插入一个0宽的字符， \u{200B} import 'package:characters/characters.dart'; class Strings { ///防止文字自动换行 static String autoLineString(String str){ if(checkStrNoEmpty(str)){
Dart 编程语言中的字符串操作详解
最新发布
苏打水解渴的博客
04-17 560
Dart 提供了多种方式来定义字符串。下面将通过几个示例，展示字符串定义的几种常见方式。''';""";当需要定义包含多行文本的字符串时，可以使用三个单引号(''')或三个双引号("""这将允许您在字符串中直接嵌入换行符，而不需要使用\n。通过上述介绍，我们了解到了 Dart 中字符串定义和拼接的基本方式。Dart 提供的这些灵活的字符串操作方式，使得处理字符串变得更加简单高效。在实际开发中，可以根据需要选择合适的方式来操作字符串，以达到最佳的开发效果。
Dart 语言 不换行输出
Leove的专栏
01-09 2590
import 'dart:io'; main() { //产生长度为5的数组，默认值为0 var myList = List<int>.filled(5, 0); myList[0] = 100; myList[1] = 200; myList[2] = 300; //1 第一种方式，通过for循环输出 for (int element in myList) { stdout.write('$element '); } print('one'); //.
Dart基础语法.pdf
10-29
### Dart基础语法知识点详解 #### 一、Dart语言概览 Dart是一种现代的、高性能的编程语言，主要用于构建Web、服务器端以及移动应用程序。它由Google开发，并且是Flutter框架的主要编程语言之一。Dart语言的一个核心...
Dart基础教学
06-14
**Dart基础教学** Dart是一种由Google开发的开放源代码、面向对象的编程语言，设计用于构建高性能的Web、移动以及服务器应用。本教学旨在深入浅出地介绍Dart语言的基本概念、语法特性和实战技巧，帮助学员快速上手...
Dart.7z的基础语法练习
03-20
以上就是Dart基础语法的一些关键点。在压缩包中的"Dart"文件中，你可能会找到关于这些特性的更详细解释，包括示例代码和实践指导，帮助你更好地理解和掌握Dart编程。通过深入学习并实践这些语法，你将能够编写出高效...
Dart基础教程PDF，免费下载，给个好评，谢谢！
08-12
在实际开发中，Dart还有类、接口、枚举、泛型等面向对象特性，以及异步编程支持（如async/await关键字）。 此外，Dart的库系统使得代码组织和重用变得简单，你可以导入库（如`dart:io`或`dart:convert`）来使用特定...
Dart入门（2）
A Lucky Boy的博客
04-21 129
Dart入门（2）
学习Dart语言，看这一篇文章就够了！（详细介绍）
热门推荐
码龙-的博客
10-22 2万+
Dart语言的详细介绍...........
Dart-字符串
qq_30450549的博客
07-20 1663
dart 字符串
Dart字符串基本方法String
Henry_moneyBag的博客
10-23 4440
num 分int double 整数 浮点 string 'str' == "str" 跟OC 不同的是 这种标识string :'''可以跨行还蛮有意思的''' string 如果直接写\n 会进行换行操作 想打印出来\n 就需要 String str = r'这是个string \n不会换行的那种。' string比较相同是 直接 == string重复几遍...
Dart | Dart 语言基础知识梳理
分享技术类相关知识点、技巧，和大家一起成长。
06-04 625
Dart 基础语法知识梳理
Dart学习之基础语法
System.o的博客
05-31 1万+
原文地址：https://www.jianshu.com/p/3d927a7bf020 承接上一篇我们搭建了Dart环境，这一篇我们将学习Dart的基础语法。 Dart的所有东西都是对象，包括数字，函数等。 它们都继承自Object，默认是都是null（包括数字），所以数字，字符串都可以调用各种方法。...
Dart笔记（5）：字符串String
汉堡怪兽
03-10 8041
定义 单引号或者双引号 String a = 'abc'; String b = "abc"; 字符串模板 var a = 123; String b = 'abc: ${a}'; print(b);//abc：123 字符串连接 下面几种方式都可以拼接 var a = 'hello' + ' ' + 'world'; var a = 'hello'' ''world'; v...
Dart之字符串(String)的相关方法总结
qq_27494201的博客
05-31 1075
更多请参考原文 字符串定义 使用单引号或双引号 String a = “abcdefg”; String b = ‘12345’; 创建多行字符串,保留内在格式 使用三个单引号或三个双引号 创建多行字符串,保留内在格式，如换行和缩进等，里面写什么输出就是什么。 三个单引号 String e = ‘’'asd fdsd fff '''; 三个双引号　 String f = “”" 1 2 3 4 “”"; ...
Dart 入门教程
大灰狼的小绵羊哥哥的博客
05-08 3539
[TOC] 一、开篇 dart 语言具有如下特性 一切变量皆是对象，每个对象都是类的实例。int、double、函数、 null 等都是对象，所有对象都继承自 Object 类 dart 是强类型语言，但由于具备类型推导功能所以类型声明是可选的 dart 支持顶级函数、静态函数、实例函数，也允许在函数中嵌套函数，即局部函数。类似的，dart 也支持顶级变量、静态变量和实例变量 dart...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值