Dart 语言速查备忘单

精选 Dart 语言常用指令与核心速查备忘单，涵盖高频用法、配置参数与实用技巧。精选 Dart 常用指令与核心速查备忘单，涵盖高频用法、配置参数与实用技巧。Dart 语言完整快速参考指南，适合初学者掌握最重要的概念、函数与方法。

#入门指南

#hello.dart

// 应用执行入口的顶层函数
void main(){
    print("Hello World!"); // 输出到控制台
}

每个应用都有一个 main() 函数

#变量声明 (Variables)

int x = 2; // 显式类型声明
var p = 5; // 类型推断 - 泛型 var 自动推断类型

dynamic z = 8; // 变量可以接受任何类型
z = "cool"; // 没问题

// 如果你不打算改变变量的值，使用 final 或 const。像这样：

final email = "temid@gmail.com"; // 与 var 相同但不可重新赋值
final String email = "temid@gmail.com"; // 你不能改变这个值

const qty = 5; // 编译时常量

#数据类型


int age = 20; // 整数，范围 -2^63 到 2^63 - 1
double height = 1.85; // 浮点数

// 你也可以将变量声明为 num
num x = 1;  // x 可以同时拥有 int 和 double 值
x += 2.5;
print(x); // 输出: 3.5

String name = "Nicola";

bool isFavourite = true;
bool isLoaded = false;

#字符串插值 (String interpolation)

// 对于 String 类型可以使用单引号或双引号
var firstName = 'Nicola';
var lastName = "Tesla";

// 可以使用 $ 将变量嵌入字符串
String fullName = "$firstName $lastName";

// 使用 + 连接
var name = "Albert " + "Einstein";

String upperCase = '${firstName.toUpperCase()}';
print(upperCase); // 输出: NICOLA

#代码注释

// 这是一个普通的单行注释。

/// 这是文档注释，用于记录库、
/// 类及其成员。IDE 和 dartdoc 等工具会
/// 特殊对待文档注释。

/* 也支持这样的注释。 */

#多行字符串 (multiline String)

对于多行字符串，我们必须使用 ''' 你的文本 '''
例如
print('''My long string''');
// 这会显示长字符串
// 这只对长字符串有帮助

#导入模块 (Imports)

// 导入核心库
import 'dart:math';

// 从外部包导入库
import 'package:test/test.dart';

// 导入文件
import 'path/to/my_other_file.dart';

#运算符

#算术运算符 (Arithmatic Operators)

print(2 + 3); // 输出: 5
print(2 - 3); // 输出: -1
print(2 * 3); // 输出: 6
print(5 / 2);  // 输出: 2.5 - 结果是 double
print(5 ~/ 2); // 输出: 2 - 结果是 int
print(5 % 2); // 输出: 1 - 余数

int a = 1, b;
// 自增
b = ++a; // 前置自增 - 在 b 获取值之前先增加 a
b = a++; // 后置自增 - 在 b 获取值之后再增加 a

// 自减
b = --a; // 前置自减 - 在 b 获取值之前先减少 a
b = a--; // 后置自减 - 在 b 获取值之后再减少 a

#相等与关系运算符 (Equality and relational operators)

print(2 == 2);  // 输出: true - 等于
print(2 != 3); // 输出: true - 不等于
print(3 > 2); // 输出: true - 大于
print(2 < 3); // 输出: true - 小于
print(3 >= 3); // 输出: true - 大于或等于
print(2 <= 3); // 输出: true - 小于或等于

#逻辑运算符 (Logical operators)

// !expr 反转表达式（将 false 变为 true，反之亦然）
// ||	逻辑或
// &&	逻辑与
bool isOutOfStock = false;
int quantity = 3;
if (!isOutOfStock && (quantity == 2 || quantity == 3)) {
  // ...下单购买产品...
}

#控制流：条件分支

#if 与 else if

if(age < 18){
    print("Teen");
} else if( age > 18 && age <60){
    print("Adult");
} else {
    print("Old");
}

#switch case 语句

enum Pet {dog, cat}
Pet myPet = Pet.dog;
switch(myPet){
    case Pet.dog:
        print('My Pet is Dog.');
        break;
    case Pet.cat:
        print('My Pet is Cat.');
        break;
    default:
        print('I don\'t have a Pet');
}
// 输出: My Pet is Dog.

#控制流：循环语句

#while 循环

while (!dreamsAchieved) {
  workHard();
}

while 循环在循环迭代前检查条件

#do-while 循环

do {
  workHard();
} while (!dreamsAchieved);

do-while 循环在执行循环内的语句后验证条件

#for 循环

for(int i=0; i< 10; i++){
    print(i);
}

var numbers = [1,2,3];
// 用于列表的 for-in 循环
for(var number in numbers){
    print(number);
}

#for in 循环

  // 定义一个数字列表
  var numbers = [1, 2, 3, 4, 5];

  // 使用 for-in 循环遍历列表
  for (var number in numbers) {
    print(number);
  }

  // 定义一个字符串列表
  var fruits = ['Apple', 'Banana', 'Cherry'];

  // 使用 for-in 循环遍历列表
  for (var fruit in fruits) {
    print(fruit);
  }

#集合类型

#列表 (Lists)

// 有序的对象组
var list = [1, 2, 3];

print(list.length); // 输出: 3
print(list[1]); // 输出: 2

// 列表声明和初始化的其他方式

List<String> cities = <String>["New York", "Mumbai", "Tokyo"];

// 创建一个编译时常量列表
const constantCities = const ["New York", "Mumbai", "Tokyo"];

#集合 (Sets)

// Dart 中的集合是无序的唯一元素集合。
var halogens = {'fluorine', 'chlorine', 'bromine', 'iodine', 'astatine'};

// 创建一个空集合
var names = <String>{};
Set<String> names = {}; // 这也可以。
//var names = {}; // 这会创建一个映射，而不是集合。

#映射 (Maps)

// 映射是一个关联键和值的对象
var person = Map<String, String>();
// 要初始化映射，这样做：

person['lastName'] = 'Tesla';

print(person); // 输出: {firstName: Nicola, lastName: Tesla}
print(person['lastName']); // 输出: Tesla


var nobleGases = {
  // 键: 值
  2: 'helium',
  10: 'neon',
  18: 'argon',
};

#函数定义

#函数 (Functions)

// Dart 中的函数是对象并且有类型
int add(int a, int b){
    return a+b;
}

// 函数可以赋值给变量
int sum = add(2,3); // 返回: 5

// 可以作为参数传递给其他函数
int totalSum = add(2, add(2,3)); // 返回: 7

#箭头语法 (Arrow Syntax =>)

// 对于只包含一个表达式的函数，可以使用简写语法
bool isFav(Product product) => favProductsList.contains(product);

#匿名函数（lambda）(Anonymous lambda functions)

// 没有名称的单行小函数
int add(a,b) => a+b;

// lambda 函数通常作为参数传递给其他函数
const list = ['apples', 'bananas', 'oranges'];
list.forEach(
(item) => print('${list.indexOf(item)}: $item'));
// 输出: 0: apples 1: bananas 2: oranges

#类与对象

#类 (Class)

class Cat {
    String name;

    // 方法
    void voice(){
        print("Meow");
    }
}

#对象 (Object)

// 类的实例
// 下面的 myCat 是 Cat 类的对象

void main(){
    Cat myCat = Cat();
    myCat.name = "Kitty";
    myCat.voice(); // 输出: Meow
}

#构造函数 (Constructors)

class Cat {
    String name;
    Cat(this.name);
}
void main(){
    Cat myCat = Cat("Kitty");
    print(myCat.name); // 输出: Kitty
}

#抽象类 (Abstract Classes)

// 抽象类——不能被实例化的类
// 这个类被声明为抽象的，因此不能被实例化。
abstract class AbstractContainer {
  // 定义构造函数、字段、方法...

  void updateChildren(); // 抽象方法。
}

#Getters 与 Setters

// 提供对对象属性的读写访问
class Cat {
    String name;

    // getter
    String get catName {
        return name;
    }

    // setter
    void set catName(String name){
        this.name = name;
    }
}

#隐式接口

#基础接口 (A basic interface)

// 一个人。隐式接口包含 greet()。
class Person {
  // 在接口中，但仅在此库内可见。
  final String _name;

  // 不在接口中，因为这是一个构造函数。
  Person(this._name);

  // 在接口中。
  String greet(String who) => 'Hello, $who. I am $_name.';
}

// Person 接口的实现。
class Impostor implements Person {
  String get _name => '';

  String greet(String who) => 'Hi $who. Do you know who I am?';
}

String greetBob(Person person) => person.greet('Bob');

void main() {
  print(greetBob(Person('Kathy'))); // Hello, Bob. I am Kathy.
  print(greetBob(Impostor())); // Hi Bob. Do you know who I am?
}

#继承类 (Extending a class)

class Phone {

    void use(){
        _call();
        _sendMessage();
    }
}
// 使用 extends 创建子类
class SmartPhone extends Phone {
    void use(){
        // 使用 super 引用超类
        super.use();
        _takePhotos();
        _playGames();
    }
}

#异常处理

#抛出异常 (Throw)

// 抛出或引发一个异常
throw IntegerDivisionByZeroException();

// 你也可以抛出任意对象
throw "Product out of stock!";

#捕获异常 (Catch)


try {
    int c = 3/0;
    print(c);
} on IntegerDivisionByZeroException {
    // 特定的异常
    print('Can not divide integer by 0.')
} on Exception catch (e) {
    // 任何其他异常
    print('Unknown exception: $e');
} catch (e) {
    // 没有指定类型，处理所有
    print('Something really unknown: $e');
}

#Finally 语句

// 确保某些代码无论是否抛出异常都会运行
try {
  cookFood();
} catch (e) {
  print('Error: $e'); // 先处理异常。
} finally {
  cleanKitchen(); // 然后清理。
}

#异步编程

#Async Await 语法

// 异步函数：它们在设置可能耗时的操作后返回
// async 和 await 关键字支持异步编程

Future<String> login() {
 String userName="Temidjoy";
 return
  Future.delayed(
    Duration(seconds: 4), () => userName);
}

// 异步
main() async {
 print('Authenticating please wait...');
 print(await login());
}

#扩展功能

#为什么使用扩展？(Why use extensions?)

// 扩展允许你在不修改现有类的情况下向其添加方法。

// 不定义工具类。
class StringUtil {
  static bool isValidEmail(String str) {
    final emailRegExp = RegExp(r"^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+");
    return emailRegExp.hasMatch(str);
  }
}

print(StringUtil.isValidEmail('someString')); // 输出: false

// 我们可以定义一个扩展，它将应用于某个特定类型。

extension StringExtensions on String {
  bool get isValidEmail {
    final emailRegExp = RegExp(r"^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+");
    return emailRegExp.hasMatch(this);
  }
}

print('test@example.com'.isValidEmail); // 输出: true
print('SomeString'.isValidEmail); // 输出: false

#泛型扩展 (Generic Extensions)

// 允许你将相同的逻辑应用于一系列类型。
extension NumGenericExtensions<T extends num> on T {
  T addTwo() => this + 2 as T;
}

print(7.addTwo()); // 输出: 9

#Flutter 中的 Dart 扩展 (Dart Extensions in Flutter)

extension ContextExtension on BuildContext {
  double get screenHeight => MediaQuery.of(this).size.height;
  double get screenWidth => MediaQuery.of(this).size.width;
}

// 用法
@override
Widget build(BuildContext context) => MaterialApp(
    home: Scaffold(
      body: Container(
        width: context.screenWidth * 0.5,
        height: context.screenHeight * 0.3,
        color: Colors.blue,
        child: Text('Hello World!'),
      ),
    ),
  );

#其他特性

#Null 与 Null 感知 (Null and Null aware)

int x; // 任何对象的初始值都是 null

// ?? null 感知运算符

x ??=6; // ??= 赋值运算符，仅在变量当前为 null 时才赋值
print(x); // 输出: 6

x ??=3;
print(x); // 输出: 6 - 结果仍然是 6

print(null ?? 10); // 输出: 10. 如果左侧值不为 null 则显示它，否则返回右侧的值

#三元运算符 (Ternary Operator)

// 条件 ? 表达式如果真 : 表达式如果假
bool isAvailable;

isAvailable ? orderproduct() : addToFavourite();

#展开运算符 (Spread Operator ...)

// 将多个值插入集合。
var list = [1, 2, 3];
var list2 = [0, ...list];

print(list2.length); // 输出: 4

#级联表示法 (Cascade notation ..)

// 允许你在同一对象上执行一系列操作

// 不这样做
var user = User();
user.name = "Nicola";
user.email = "nicola@g.c";
user.age = 24;

// 你可以这样做
var user = User()
  ..name = "Nicola"
  ..email = "nicola@g.c"
  ..age = 24;

#条件属性访问 (Conditional Property Access)

userObject?.userName

// 上面的代码片段等价于以下内容：
(userObject != null) ? userObject.userName : null

// 你可以在单个表达式中链式使用多个 ?.
userObject?.userName?.toString()

// 如果 userObject 或 userObject.userName 为 null，前面的代码返回 null 且永远不会调用 toString()

#Dart 中的枚举 (enum in dart)

定义：枚举（"enumeration"的缩写）是一种特殊数据类型，使变量可以是一组预定义常量。枚举用于定义只能取一小组可能值中的一个的变量。它们通过为这些值集提供有意义的名称来使代码更具可读性且不易出错。

// 定义枚举
enum TrafficLight {
  red,
  yellow,
  green
}

// 一个根据交通灯状态打印消息的函数
void printTrafficLightMessage(TrafficLight light) {
  switch (light) {
    case TrafficLight.red:
      print('Stop!');
      break;
    case TrafficLight.yellow:
      print('Get ready...');
      break;
    case TrafficLight.green:
      print('Go!');
      break;
  }
}

void main() {
  // 枚举的示例用法
  TrafficLight currentLight = TrafficLight.green;

  // 打印当前交通灯状态的消息
  printTrafficLightMessage(currentLight);
}

Dart 语言 速查备忘单

#入门指南

#hello.dart

#变量声明 (Variables)

#数据类型

#字符串插值 (String interpolation)

#代码注释

#多行字符串 (multiline String)

#导入模块 (Imports)

#运算符

#算术运算符 (Arithmatic Operators)

#相等与关系运算符 (Equality and relational operators)

#逻辑运算符 (Logical operators)

#控制流：条件分支

#if 与 else if

#switch case 语句

#控制流：循环语句

#while 循环

#do-while 循环

#for 循环

#for in 循环

#集合类型

#列表 (Lists)

#集合 (Sets)

#映射 (Maps)

#函数定义

#函数 (Functions)

#箭头语法 (Arrow Syntax =>)

#匿名函数（lambda）(Anonymous lambda functions)

#类与对象

#类 (Class)

#对象 (Object)

#构造函数 (Constructors)

#抽象类 (Abstract Classes)

#Getters 与 Setters

#隐式接口

#基础接口 (A basic interface)

#继承类 (Extending a class)

#异常处理

#抛出异常 (Throw)

#捕获异常 (Catch)

#Finally 语句

#异步编程

#Async Await 语法

#扩展功能

#为什么使用扩展？(Why use extensions?)

#泛型扩展 (Generic Extensions)

#Flutter 中的 Dart 扩展 (Dart Extensions in Flutter)

#其他特性

#Null 与 Null 感知 (Null and Null aware)

#三元运算符 (Ternary Operator)

#展开运算符 (Spread Operator ...)

#级联表示法 (Cascade notation ..)

#条件属性访问 (Conditional Property Access)

#Dart 中的枚举 (enum in dart)

Dart 语言速查备忘单