【dart】dart基础学习使用（一）：变量、操作符、注释和库操作

前言

学习dart语言。

注释

Dart 支持单行注释、多行注释和文档注释。

单行注释

单行注释以 // 开头。Dart 编译器将忽略从 // 到行尾之间的所有内容。

void main() {
  // 这是单行注释
  print('Welcome to my Llama farm!');
}

多行注释

多行注释以 /* 开始，以 / 结束。Dart 编译器会忽略 / 和 */ 之间的所有内容（除非该注释是文档注释；请参阅下一节）。多行注释可以嵌套。

void main() {
  /*
	这是多行注释
	这是多行注释
	*/
  print('Welcome to my Llama farm!');
}

文档注释

文档注释是以 /// 或 /** 开头的多行或单行注释。在连续行中使用 /// 与多行文档注释的效果相同。

在文档注释中，分析器会忽略所有文本，除非这些文本是用括号括起来的。使用括号可以引用类、方法、字段、顶层变量、函数和参数。括号中的名称在文档程序元素的词法范围内解析。

下面是一个文档注释示例，其中引用了其他类和参数：

/// A domesticated South American camelid (Lama glama).
///
/// Andean cultures have used llamas as meat and pack
/// animals since pre-Hispanic times.
///
/// Just like any other animal, llamas need to eat,
/// so don't forget to [feed] them some [Food].
class Llama {
  String? name;

  /// Feeds your llama [food].
  ///
  /// The typical llama eats one bale of hay per week.
  void feed(Food food) {
    // ...
  }

  /// Exercises your llama with an [activity] for
  /// [timeLimit] minutes.
  void exercise(Activity activity, int timeLimit) {
    // ...
  }
}

变量

dart 可以使用 var、final、const和变量基本类型声明变量和常量。
dart语言比较严格，每句表达式后面必须带分号（;）。

变量基本类型声明

基本类型可以直接声明和赋值。

void main() {
  int number = 2; //  整数
  double floatN = 2.0; //  小数
  String str = 'zsk666'; //  字符串
  bool flag = true; //  布尔型
  List arr = [1, 2, 3]; //  数组
  Set setObj = {'a', 'b', 'c'}; //  集合
  Map mapObj = {name: 'zsk', 18: 18, 'hh': 'hh'}; //  键值对、映射
  Null nullV = null; //  null
  print({number, floatN, str, flag, arr, setObj, mapObj, nullV});
}

如果用基本类型来声明，使用前要赋值。如果不赋值，运行会报错。
或者使用避空符？。

String? name;
print(name);

var声明

var 声明一个变量。
若声明时并赋值，这个变量将会根据值类型定义为相应类型。
若没有赋值，则默认值为null，且类型为object。

  var str = 'string的值'; //  字符串
  var numberV = 18; //  整形
  Object flag = "2";
  flag = '23'; //  重新赋值
  flag = false; //  Object可以跨类型赋值
  var oV; //  默认值 null
  var oA;
  oA = 1;
  oA = 'zsk666';  //  和 Object 声明一样
  print({str, numberV, flag, oV, oA});

结果：

final 声明

final声明的变量只能赋值一次，赋值后成为常量，不可更改。

void finalSet() {
  final oneV;
  oneV = '哈哈哈';
  final twoV = '123';
  twoV = '1'; //  报错，不能再次赋值
  print({oneV, twoV});
}

const 声明

const 声明的是常量。声明时必须赋值。

/**
 * const 声明
 */
void constSet() {
  const cV1 = [];
  // cV1 = 1; //  报错，常量不能赋值
  const cV2; //  报错，声明时未赋值
  cV2 = '123';
  print({cV1});
}

late 声明的变量

后期修饰符有两种用途：

• 声明一个非空变量，并在声明后初始化该变量。
• 懒散地初始化一个变量。
  通常情况下，Dart 的控制流分析可以检测到非空变量在使用前被设置为非空值，但有时分析会失败。两种常见的情况是顶层变量和实例变量：Dart 通常无法确定它们是否被设置，因此不会尝试。
  作用1：
  顶层变量未初始化时，在函数中赋值并使用，会报错，此时可以使用避空符（?）或者late。
  要注意的是 使用late 的变量要确定后面使用前已经正确赋值。

late String aaV;
int? aaV3;
void lateSet() {
  aaV = '123';
  String aaV2;
  aaV2 = '2';
  print({aaV, aaV2, aaV3});
}

作用2：
当作延迟变量使用。类似于懒加载。
例如 ：
temperature没有使用，就不会调用readThermometer。使用才会调用。

late String temperature = readThermometer(); // Lazily initialized.

操作符

Dart 支持下表所示的操作符。表中从高到低显示了 Dart 的操作符关联性和操作符优先级，它们是 Dart 操作符关系的近似值。

描述	操作符	关联性
一元后缀	expr++, expr- -, () , [], ?[], . , ?. , !	无
一元前缀缀	++expr, --expr, -expr , !expr , ~expr , await expr	无
乘除	*, / , %, ~/	左
加减	+ , -	左
左移	<< , >>, >>>	左
位操作 并	&	左
位操作 异或	^	左
位操作 或	|	左
关系符	>=, > , <=, < , as , is , is!	无
比较符	== , !=	无
逻辑 并	&&	左
逻辑 或	||	左
若空符	??	左
条件符	expr1 ? expr2 : expr3	右
连接调用（级联）符	… , ?..	左
计算符	= , *=, /=, +=, -=, &=, ^=	右

在运算符表中，每个运算符的优先级都高于其后各行的运算符。例如，乘法运算符 % 的优先级高于相等运算符 ==（因此先于相等运算符 == 执行），而相等运算符 == 的优先级高于逻辑 AND 运算符 &&。这种优先级意味着下面两行代码的执行方式相同：

// Parentheses improve readability.
if ((n % i == 0) && (d % i == 0)) ...

// Harder to read, but equivalent.
if (n % i == 0 && d % i == 0) ...

void main() {
  //  算数运算
  assert(2 + 3 == 5);
  assert(2 - 3 == -1);
  assert(2 * 3 == 6);
  assert(5 / 2 == 2.5); // Result is a double
  assert(5 ~/ 2 == 2); // Result is an int
  assert(5 % 2 == 1); // Remainder

  assert('5/2 = ${5 ~/ 2} r ${5 % 2}' == '5/2 = 2 r 1');

  //  自操作
  int a;
  int b;

  a = 0;
  b = ++a; // 赋值给b之前 自加1.
  assert(a == b); // 1 == 1

  a = 0;
  b = a++; // 赋值给b之后 自加1.
  assert(a != b); // 1 != 0

  a = 0;
  b = --a; // 赋值给b之前 自减1.
  assert(a == b); // -1 == -1

  a = 0;
  b = a--; // 赋值给b之后 自减1.
  assert(a != b); // -1 != 0

  print({a, b});

  //  比较
  assert(2 == 2);
  assert(2 != 3);
  assert(3 > 2);
  assert(2 < 3);
  assert(3 >= 3);
  assert(2 <= 3);

  //  级联 调用后返回实例，而不是调用后的返回值
  // var paint = Paint()
  //   ..color = Colors.black
  //   ..strokeCap = StrokeCap.round
  //   ..strokeWidth = 5.0;
}

库和导入

导入和库指令可帮助您创建模块化和可共享的代码库。库不仅提供应用程序接口（API），而且还是一个隐私单位：以下划线 (_) 开头的标识符只能在库内可见。即使没有使用库指令，每个 Dart 文件（及其部分）都是一个库。

库可以使用包来发布。

如果您对 Dart 为什么使用下划线而不是 public 或 private 等访问修饰关键字感到好奇，请参阅 SDK 问题 33383。

使用库

使用 import 来指定如何在另一个库的作用域中使用一个库中的命名空间。

例如，Dart Web 应用程序通常使用 dart:html 库，它们可以这样导入：

import 'dart:html';

导入所需的唯一参数是指定库的 URI。

• 对于内置库，URI 采用特殊的 dart: 方案。

• 对于其他库，可以使用文件系统路径或 package: 方案。
  package: 方案指定由包管理器（如 pub 工具）提供的库。例如

  import 'package:test/test.dart';
  

库别名

如果要导入的库的内容名称有冲突，可以另起一个别名。
例如，如果 library1 和 library2 都有一个 Element 类，那么代码可能如下：

import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;

// Uses Element from lib1.
Element element1 = Element();

// Uses Element from lib2.
lib2.Element element2 = lib2.Element();

使用库的部分内容

如果只想使用程序库的一部分，可以选择性地导入程序库。例如

// Import only foo.
import 'package:lib1/lib1.dart' show foo;

// Import all names EXCEPT foo.
import 'package:lib2/lib2.dart' hide foo;

实操

创建 two.dart

/// 这是 two.dart
// library;

class Two {
  void start() {
    print('two ,start');
  }
}```

创建 one.dart,导入two.dart并使用。

```dart
import './two.dart';
import './two.dart' as TwoL;

void main() {
  print("Hello,world!");
  Object name = 2;
  Two()..start();
  TwoL.Two()..start();
}

结果：

结语

结束了。 Dart官网.