Dart基础语法
数据类型
Dart是强类型语言，与JavaScript有所区别，类型不匹配无法编译。
int、double、bool
int year = 27;
double percent = 0.333;
int stringInt = int.parse('27');
double stringDouble = double.parse('0.333');
var var_year = 27;
const const_percent = 0.333;
bool isNeed = false;String
String name = 'Lucy,lily,petter';
print('length: ' + name.length.toString() + '\n');
print('isEmpty: ' + name.isEmpty.toString() + '\n');
print('isNotEmpty: ' + name.isNotEmpty.toString() + '\n');
print('toLowerCase: ' + name.toLowerCase() + '\n');
print('toUpperCase: ' + name.toUpperCase() + '\n');
// String 转换 List，以','为分割
var split = name.split(',');
print("list: ${split}\n");
// length<2向左补'0'
int day = 8;
print('padLeft: ' + day.toString().padLeft(2, '0')+ '\n');List
List arr = ['a', 'b', 'c'];
/// 移除
arr.removeAt(0);
print("arr: ${arr.toString()}\n");
/// 添加
arr.add('d');
arr.insert(0, 'a'); /* arr[0] = 'a'; */
print("arr: ${arr.toString()}\n");
arr.addAll(['e', 'f', 'g']);
print("arr: ${arr.toString()}\n");
/// 索引
String element = arr.elementAt(0);
print("object index 0: ${element}\n");
print('arr isEmpty: ' + arr.isEmpty.toString() + '\n');
print('arr isNotEmpty: ' + arr.isNotEmpty.toString() + '\n');
print('arr contains: ' + arr.contains('z').toString() + '\n');
/// List 转换 String，以','为分割
String joinStr = arr.join(',');
print('arr join: ' + joinStr + '\n');Map
var map = {
'tags': ['l', 'i', 'y'],
'url': '//path/tosaturn.jpg'
};
// 赋值
map['name'] = 'Lily';
var tempMap = {
'age': '18岁'
};
// 添加元素
map.addEntries(tempMap.entries);
Map gifts = new Map(); /* new Map(); */
gifts['day'] = '07-17';
// 添加Map
map.addAll(gifts);
// 删除key value
map.remove('age');
// 更新key value
map.update('day', (val) => '01-18'); /* map['day'] = '01-18'; */
print('map:' + map.toString() + '\n'); 为空判断
String value = '';
// 判断对象是否为空
if (value != null) {
bool isEmpty = value.isEmpty;
bool isNotEmpty = value.isNotEmpty;
}DateTime
DateTime date = new DateTime.now();
// DateTime 转 毫秒时间戳
int timeInterval = date.millisecondsSinceEpoch;
print('millisecondsSinceEpoch: ' + timeInterval.toString() + '\n');
// 毫秒时间戳 转 DateTime
DateTime secondDate = new DateTime.fromMillisecondsSinceEpoch(timeInterval);
print('DateTime: ' + secondDate.toString() + '\n');
// DateTime 转 FormatDateString
String dateString = "${date.year}-${secondDate.month.toString().padLeft(2, '0')}-${secondDate.day.toString().padLeft(2, '0')}";
print('dateString: ' + dateString + '\n');
// FormatString 装 DateTime
DateTime formatDateTime = DateTime.parse(dateString);
print('formatDateTime: ' + formatDateTime.toString() + '\n');
// 初始化时间：2019-07-08 18:09
var constDate = new DateTime.utc(2019, 07, 18, 18, 09);
print('constDate: ' + constDate.toString() + '\n');Final 和 Const
使用过程中从来不会被修改的变量， 可以使用 final 或 const, 而不是 var 或者其他类型， Final 变量的值只能被设置一次； Const 变量在编译时就已经固定 (Const 变量 是隐式 Final 的类型.) 最高级 final 变量或类变量在第一次使用时被初始化。
final name = 'Bob';
final String nickname = 'Bobby';
const bar = 1000000;
const double atm = 1.01325 * bar; 提示： 实例变量可以是 final 类型但不能是 const 类型。 必须在构造函数体执行之前初始化 final 实例变量 ；如果需要在编译时就固定变量的值，可以使用 const 类型变量。 如果 Const 变量是类级别的，需要标记为 static const。
Librarie-库和可见性
使用库
使用 import 来指定一个库如何使用另外 一个库。
import 'dart:html';import 必须参数为库 的 URI。 对于内置的库，URI 使用特殊的 dart: scheme。 对于其他的库，你可以使用文件系统路径或者 package: scheme。 package: scheme 指定的库通过包管理器来提供。
import 'dart:io';
import 'package:mylib/mylib.dart';
import 'package:utils/utils.dart';指定库前缀
如果你导入的两个库具有冲突的标识符， 则你可以使用库的前缀来区分。
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;
Element element1 = new Element(); // Uses Element from lib1.
lib2.Element element2 = new lib2.Element(); // Uses Element from lib2.导入库的一部分
// Import only foo.
import 'package:lib1/lib1.dart' show foo;
// Import all names EXCEPT foo.
import 'package:lib2/lib2.dart' hide foo;延迟载入库
要延迟加载一个库，需要先使用 deferred as 来 导入：
import 'package:deferred/hello.dart' deferred as hello;当需要使用的时候，使用库标识符调用 loadLibrary() 函数来加载库：
/* 用await的方法必须带有async */
void _greet() async {
await hello.loadLibrary(); // 只调用一次
hello.greet();
}Function-函数
下面是定义方法的示例：
bool isNoble(int count) {
return _nobles[count] != null;
}使用缩写语法来定义：
bool isNoble(int count) => _nobles[count] != null;可选命名参数
void normalTest({bool needUpdate, bool isShowed}) {
// do something
}
void requiredTest({@required bool needUpdate, bool isShowed}) {
// do something
}
void test {
this.normalTest(needUpdate: false, isShowed: true);
this.normalTest(isShowed: true);
this.normalTest(needUpdate: false);
this.requiredTest(needUpdate: false, isShowed: true);
/*错误：needUpdate是必要参数
this.requiredTest(isShowed: true);
*/
}可选位置参数
String say(String from, String msg, [String device]) {
if (device != null) {
result = from + msg + device;
}
return from + msg;
}
void test() {
say('a', 'b', 'c'); /* say('a', 'b'); */
}默认参数值
void enableFlags({bool bold = false, bool hidden = false}) {
// do something
}
void test() {
enableFlags(bold: true);
}
位置参数的默认值
String say(String from, String msg,
[String device = 'carrier pigeon', String mood]) {
var result = '$from says $msg';
if (device != null) {
result = '$result with a $device';
}
if (mood != null) {
result = '$result (in a $mood mood)';
}
return result;
}
void test() {
assert(say('Bob', 'Howdy') == 'Bob says Howdy with a carrier pigeon');
}方法赋值成给变量
void test() {
var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
loudify('hello');
}静态作用域
var topLevel = true;
main() {
var insideMain = true;
myFunction() {
var insideFunction = true;
nestedFunction() {
var insideNestedFunction = true;
// 可以访问所有变量，包括topLevel
}
}
}异常捕获
try {
// 执行代码
} catch (e) {
// 异常回调
} finally {
// 结果处理
}Asynchrony-异步支持
在一个方法上添加 async 关键字，则这个方法返回值为 Future，虽然异步方法的执行可能需要一定时间，但是异步方法立刻返回 -在方法体还没执行前。
import 'dart:async'; //引入库
static Future checkVersion() async {
// 示例
Bool needUpdate = await checkUpdate('2.1.0');
return needUpdate;
}
void test() {
checkVersion.then((needUpdate) => {
print(needUpdate);
}).catchError((err) => {
print(err);
});
}
await实现阻塞，直到需要的对象返回为止，要使用 await，其方法必须带有 async 关键字：
checkVersion() async {
var version = await lookUpVersion();
if (version == expectedVersion) {
// Do something.
} else {
// Do something else.
}
}可以使用 try, catch, 和 finally 来处理使用 await 的异常：
/* 不同的调用方式，获取同样的实例 */
Future httpClient() async {
var server = await HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 4044);
return server;
}
/* Future */
void httpClent_then() {
HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 4044).then((server) {
print(server.toString);
});
} 异步 for 循环具有如下的形式：
main() async {
/* request必须是Stream类型 */
await for (var request in requestServer) {
handleRequest(request);
}
}Method-方法
方法是为对象提供行为的函数。
实例方法串行调用
void test() {
LCDataBaseStorage.sharedInstance()
..creatDB('db/db_base.db')
..createTable('dbTable', {'name':'TEXT', 'age':'INTEGER', 'enjoy':'TEXT'}, true)
..rawInsert('dbTable', {'name': 'lilylin', 'age': 27, 'enjoy': '踢足球'});
}Getter 和 Setter
class Rectangle {
num left, top, width, height;
Rectangle(this.left, this.top, this.width, this.height);
// 定义两个计算属性： right（简洁写法）和 bottom（常规写法）
num get right => left + width;
set right(num value) => left = value - width;
num get bottom {
return top + height;
}
set bottom(num value) {
top = value - height;
}
}Class-类与构造函数
Dart 是一种基于类和 mixin 继承机制的面向对象的语言。 每个对象都是一个类的实例，所有的类都继承于Object ；一个类中的代码可以在其他多个继承类中重复使用。
使用类的成员变量
使用 . 来引用实例对象的变量和方法：
var p = Point(x: 2, y: 2);
p.y = 3;
使用 ?. 来代替 . ， 可以避免因为左边对象可能为 null ， 导致的异常：
// 如果 p 为 non-null。
p?.y = 4;获取对象的类型
使用对象的 runtimeType 属性， 可以在运行时获取对象的类型， runtimeType 属性回返回一个Type对象。
int num = 9;
Type type = num.runtimeType;构造函数
通过创建一个与其类同名的函数来声明构造函数
class Point {
int x, y;
String w, v, z;
/* Point(this.x, this.y); => 完整写法
Point(int x, int y) {
this.x = x;
this.y = y;
}
*/
/* 常规命名 */
Point(this.x, this.y);
/* 可选命名参数 */
Point({this.w, this.v});
/* 可选命名参数(@required：必须) */
Point({@required this.z, this.x});
}
void test() {
/* 常规命名 */
var point = Point(1, 2);
/* 可选命名参数 */
var point1 = Point();
/* 可选命名参数(z：必须) */
var point2 = Point(z: 'z');
}构造函数不被继承
子类不会继承父类的构造函数。 子类不声明构造函数，那么它就只有默认构造函数 (匿名，没有参数) 。
调用父类非默认构造函数
在当前构造函数冒号 : 之后，函数体之前，声明调用父类构造函数。
class Person {
String firstName;
Person.fromJson(Map data) {
print('in Person');
}
}
class Employee extends Person {
Employee.fromJson(Map data) : super.fromJson(data) {
print('in Employee');
}
}
main() {
var emp = new Employee.fromJson({});
// 依次输出 in Person 和 in Employee
}工厂构造函数
当执行构造函数并不总是创建这个类的一个新实例时，则使用 factory 关键字。
class Logger {
num x, y;
// 类的主构造函数。
Point(this.x, this.y);
// 工程构造函数
factory PonitInit(orign_x, orign_y) {
return Point(orign_x, orign_y);
}
}备注：工厂构造函数无法访问 this。
本文参考于Dart中文网，链接：https://www.dartcn.com/guides/language/language-tour