Dart是面向对象的、类定义的、单继承的语言。
环境搭建
brew tap dart-lang/dart
brew install dart
dart --version测试
touch test.dart
dart test.darttest.dart
main(List<String> args) {
print("test");
}另：vs code 安装 Dart&Code Runner运行
标识符/关键字
- 标识符包括字符和数字，但标识符不能以数字开头
- 除下划线（_）或美元符号（$）外，标识符不能包含特殊符号
- 标识符不能是关键字
- 标识符区分大小写
- 标识符不能包含空格
dart区分大小写
dart语句以（;）结尾
数据类型
数字 字符串 布尔 列表(类似于数组) 集合set 映射map 符文 符号
数字类型
整数 双精度数
var a = 0;
int b = 1;
double c = 0.1;字符串
${}插入表达式的值 和 $变量
var s1 = 'hello';
int n = 2;
String str = "the n is ${n+1} $n";布尔
与Js不同，布尔类型仅将文字true识别为true，其他都视为false(在未检查模式下运行时)
var real = true;
bool isReal = false;列表
var list = [val1, val2, val3];
// 或
var list = new List();
List list = [val1, val2, val3];集合
var names = {'xiaoming', 'lilei'};
// 或
var names = <String>{};
Set<String> names = {};枚举类型
enums ， 是一种特殊的类，用于表示数量固定的常量值
enum Color { red, green, blue };映射
var gifts = {
'first': 'partridge',
'second': 'turtledoves'
}
// 或
var gifts = Map();
gifts['first'] = 'partridge';变量
var后就不要写类型 ，写了类型不要var ，两者都写会报错
final & const
final和const关键字都是用于声明常量
运算符
// 通用操作
int a = 1;
++a;
a++;
var b = 1;
print(a == b); // false
print(a * b); // 3
bool real = false;
real ? print('real') : print('not real'); // not real
print(real && a == b); // false
print(real || a == 3); // true
print(a != 2); // true
print(a <= b); // false
var c = 9;
c += 10;
print("c = $c"); // c = 19
print(1<<2); // 4
// 注意特别操作
// ~/ 取整除法 / 除法运算
int k = 1;
int j = 2;
print(k / j); // 0.5
print(k ~/ j); // 0
// is is! 判断一个变量是不是某个类型
var s = "hello";
print(s is String); // true
var num = 6;
print(num is! String); // true
// as强制转换为特定类型
(emp as Person).firstName = 'Bob';
// ??= 运算符前面为null则赋值
var param1 = "hello", param2 = null;
param1 ??= "world";
param2 ??= "world";
print("param1 = $param1"); // param1 = hello
print("param2 = $param2"); // param2 = world
// ?? 若前面为null则返回后值
String playerName(String name) => name ?? 'Guest';
// ?. 有值则返回，无值则返回null
var str1 = "hello world";
var str2 = null;
print(str1?.length); // 11
print(str2?.length); // null
print(str2.length); // 报错执行语句
顺序 条件 循环
if / else switch for / while
for...in 用于循环对象的属性
try / catch 可用on捕获指定类型的错误
try {
breedMoreLlamas();
} on OutOfLlamasException {
// 一个特殊的异常
buyMoreLlamas();
} on Exception catch (e) {
// 其他任何异常
print('Unknown exception: $e');
} catch (e) {
// 没有指定的类型，处理所有异常
print('Something really unknown: $e');
}函数
可选参数
箭头函数
printMsg() => print("hello");
匿名函数
test(Function callback) {
callback("hello");
}
main() {
test((param) {
// 打印 hello
print(param);
});
}没有public protected private
如果变量或函数以下划线(_)开始，函数或变量属于包私有(private)的方法
接口
dart没有声明接口的语法，类声明本身就是dart中的接口
class Person {
void printMsg() {
print('Person');
}
}
class Teacher implements Person {
void printMsg() {
print('Teacher');
}
}可支持多个接口，用逗号隔开
class Teacher implements Person1, Person2...类
在 Dart 2 中 new 关键字变成了可选的
构造函数 & this
class Person {
String name;
Person(String name) {
this.name = name;
print('this name is: $name');
}
}
// 或
class Person {
String name;
Person(this.name) {
print('this name is: $name');
}
}setter & getter
关键字set get
extends
dart单层多级继承，最多从一个父类继承
class Person {
void printMsg() {
print('printMsg test');
}
}
class Child extends Person {}方法重写
class Person {
void printMsg() {
print('printMsg test');
}
}
class Child extends Person {
@override
void printMsg() {
print('printMsg override');
}
}static
// 调用
Person.age = 18;
Person.printMsg();
class Person {
static int age;
static printMsg() {
print('printMsg ${Person.age}');
}
}super
super关键字用于引用类的直接父级
class Person {
String msg = 'test';
void printMsg(int a) {
print('parent a $a');
}
}
class Child extends Person {
@override
void printMsg(int b) {
print('child b $b');
super.printMsg(10);
print('${super.msg}');
}
}抽象类和抽象方法
使用abstract修饰一个类，则这个类是抽象类，抽象类中可以有抽象方法和非抽象方法，抽象方法没有方法体，需要子类去实现
abstract class Doer {
// 抽象方法，没有方法体，需要子类去实现
void doSomething();
// 普通的方法
void greet() {
print("hello world!");
}
}
class EffectiveDoer extends Doer {
// 实现了父类的抽象方法
void doSomething() {
print("I'm doing something...");
}
}对象
(..)级联运算符
new Person()
..printMsg()
..printMsg1();toString()
返回对象字符串表达形式
Mixin
mixins是一个重复使用类中代码的方式
如果 Mixin 不希望作为常规类被使用，使用关键字 mixin 替换 class
如： mixin A
class A {
a() {
print("A's a()");
}
}
class B {
b() {
print("B's b()");
}
}
// 使用with关键字，表示类C是由类A和类B混合而构成
class C = A with B;
main() {
C c = new C();
c.a(); // A's a()
c.b(); // B's b()
}泛型（略）
Dart库
pub get
pub update引入
import 'dart:html';
import './util.dart';
import 'package:lib2/lib2.dart' as lib2;
import 'package:greetings/hello.dart' deferred as hello; // 懒加载网络请求
import 'package:rubbish_guard/utils/net_utils.dart';
import 'package:rubbish_guard/api/api.dart';
// 获取当前用户信息
static Future getUserInfo(context, Map<String, dynamic> params) async {
var response = await NetUtils.request(context, Api.GET_USER_INFO, params);
try {
return response['data']['userInfo'];
} catch (err) {
return null;
}
}