Dart基础知识

2019-03-31 本文已影响0人 JeromeWang

Dart重要的概念

所有的东西都是对象，无论是变量、数字、函数都是对象。所有的对象都是类的实例。所有的对象都继承自内置的Object类
程序中指定数据类型使得程序合理地分配内存空间，并帮助编译器进行语法检查，但是指定类型不是必须的。Dart是弱数据类型。
Dart代码在运行前解析，指定数据类型和编译时的常量，可以提高运行速度。
Dart程序有唯一的程序入口：main()。
Dart没有public、protected、private的概念。私有特性通过变量或函数加上下划线来表示。
Dart支持anync/await异步处理。

变量和基本数据类型

变量的声明，可以使用 var、Object 或 dynamic 关键字,如果没有将变量初始化，那么它的默认值是null。
创建变量并初始化变量实例：

    var name = '张三' ;
    //如果对象不限于单一类型（没有明确的类型），请使用Object或dynamic关键字
    Object name = '张三';
    dynamic name = '李四';

如果定义的变量不会变化，可以使用 final 或 const。final 的值只能被设置一次;const 是一个编译时常量。final的顶级或类变量在第一次使用时被初始化。

被final或者const修饰的变量，变量类型可以省略。

//可以省略String这个类型声明
final name1 = "张三";
//final String name1  = "张三";

被 final 或 const 修饰的变量无法再去修改其值。

  final name1 = "张三";
    // 这样写，编译器提示：a final variable, can only be set once
    // 一个final变量，只能被设置一次。
    //name1 = "zhangsan";

注意：flnal 或者 const 不能和 var 同时使用
常量如果是类级别的，请使用 static const

基本数据类型

Dart语言常用的基本数据类型包括：Number、String、Boolean、List、Map。

（1）Number类型

Number是数字类型的父类，包含如下两个类。

int整形。取值范围：-2^53 ~ 2^53。
double浮点型。64位长度的双精度浮点型。

（2）String字符串类型

可以使用相邻字符串文字或+ 运算符连接字符串：

 // 直接把相邻字符串写在一起，就可以连接字符串了。
  String connectionStr1 =  '字符串''连接''字符串。';
  print(connectionStr1);// 字符串连接字符串。
 // 用+把相邻字符串连接起来。
  String connectionStr2 =  '字符串'+ '连接'+ '字符串。';
  print(connectionStr2);// 字符串连接字符串。

使用三个单引号或双引号定义多行字符串，多用来表示大文本块

String multiLineStr = ''' 
  这是用单引号创建的
  多行字符串。
  ''' ;

（3）Boolean类型

Dart是强bool类型检查，只有bool类型的值是true才被认为是true。有的语言里0是false，大于0是true。

//下面的代码编译错误，因为name是个字符串
    var name = '张三' ;
    if(name){
     print("你的姓名是："+name);
    }

（4）List类型

在Dart语言中，具有一系列相同类型的数据称为List对象。可以直接打印list的元素，list也是一个对象。list里面的元素必须保持类型一致，不一致就会报错。list的角标从0开始。

List list = [1, 3, 5];
print(list);// 输出结果  [1, 3, 5]

（5）Map类型

Dart中的map是将键和值相关联的对象。键和值都可以是任何类型的对象。key必须是唯一的。

创建方式：直接声明，用{}表示，里面写key和value，每组键值对中间用逗号隔开。

Map week = {'Monday': '星期一', 'Tuseday': '星期二', 'Wednesday': '星期三'，
'Thursday': '星期四', 'Friday': '星期五', 'Saturday': '星期六', 'Sunday': '星期日'};
print(week);

使用Map对象的构造函数Map()来创建对象。

  Map week = new Map();
  week['Monday'] = '星期一';
  week['Tuseday'] = '星期二';
  week['Wednesday'] = '星期三';
  week['Thursday'] = '星期四';
  week['Friday'] = '星期五';
  week['Saturday'] = '星期六';
  week['Sunday'] = '星期日';
  print(week);

要创建一个编译时常量const的map，请在map文字之前添加const：

final fruitConstantMap = const {2: 'apple',10: 'orange',18: 'banana'};
// 打印结果{second: 腾讯, fifth: 百度, 5: 华为}

函数

1.可选参数

将参数使用中括号[]括起来，用来表明是可选位置参数。

2.参数默认值

如果参数指定了默认值，当不传入值时，函授里会使用这个默认值。通常参数的默认值是null。

3.函授返回值特点

所有的函数都会有返回值
如果没有指定函数返回值，则默认的返回值是null
没有返回值的函数，系统会在最后添加隐式的return语句

运算符

1.算术运算符

/ 除法，结果为浮点型
~/ 除法，返回一个整数值的除法。
% 取余，除法剩下的余数。

  var result = 7/2;
  print(result); // 结果是：3.5
  var result1 = 15~/7;
  print(result1); // 结果是：2
  var result2 = 15%7;
  print(result2); // 结果是：1

Dart还支持前缀和后缀递增和递减运算符

操作符	含义
++var	var = var+1 表达式的值为var+1
var++	var = var+1 表达式的值为var
--var	var = var-1 表达式的值为var-1
var--	var = var-1 表达式的值为var

var a , b;
a = 0;
b = ++a; //在b获得其值之前自增a
assert(a == b); // 1==1

a = 0;
b = a++; //在b获得其值之后自增a
assert(a != b); // 1!=0

a = 0;
b = --a; //在b获得其值之前自减a
assert(a == b); // -1==-1

a = 0;
b = a--; //在b获得其值之后自减a
assert(a != b); // -1!=0

2.类型操作符

as、is与is!操作符在运行时用于检测类型。

操作符	含义
as	类型转换
is	当对象是相应的类型时返回true
is!	当对象不是相应的类型时返回true

if(user is User){
   user.name = "zhangsan";
}
//如果确认user是User的实例，可以通过as直接简化上面的代码
(user as User).name = "zhangsan";

3.赋值操作符

可以使用= 运算符赋值。要仅在变量为null时赋值，使用??==运算符。

//如果b为空，则将值赋给b,否则，b保持不变
b ??==value;

3.级联符号..

级联符号用两个点(..)表示，可以对同一个对象上进行一系列操作。除了函数调用之外，还可以访问同一对象上的字段。其实相当于java的链式调用。

String s = (new StringBuffer()
        ..write('test1 ')
        ..write('test2 ')
        ..write('test3 ')
        ..write('test4 ')
        ..write('test5'))
      .toString();
print(s); // test1 test2 test3 test4 test5

异常处理

Dart代码可以抛出并捕获异常。与Java相比，Dart的所有异常都是未经检查的异常。方法不声明它们可能引发哪些异常，也不需要捕获任何异常。
Dart提供了Exception和Error 类型，以及许多预定义的子类型。当然，您可以定义自己的Exception。但是，Dart程序可以抛出任何非空对象。
1. throw抛出异常

throw FormatException('抛出一个FormatException异常');
//你也可以抛出任意对象
throw '格式不正确!';

2. 捕获异常try catch
要处理可能抛出多种类型异常的代码，可以指定多个catch子句。与抛出对象的类型匹配的第一个catch子句处理异常。如果catch子句未指定类型，则该子句可以处理任何类型的抛出对象。可以使用on或catch或两者兼而有之。使用on时需要指定异常类型。使用catch时，你的异常处理程序需要异常对象。

try {
     //...
} on OutOfLlamasException {
  // A specific exception
    // ...
} on Exception catch (e) {
  // Anything else that is an exception
  print('Unknown exception: $e');
} catch (e) {
  // No specified type, handles all
  print('Something really unknown: $e');
}

可以指定一个或两个参数来捕获异常。第一个是抛出的异常，第二个是堆栈跟踪（StackTrace对象）。

try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
}

要部分处理异常，同时允许它传递，请使用rethrow关键字。

  try {
    dynamic foo = true;
    print(foo++); // 运行时异常
  } catch (e) {
    rethrow; // 允许调用者查看exception.
  }

3.finally
无论是否抛出异常，要确保某些代码运行，请使用finally子句。如果没有catch子句匹配该异常，则在finally子句运行后传递异常。

try {
  // ···
} on Exception catch (e) {
  print('Exception details:\n $e');
} catch (e, s) {
  print('Exception details:\n $e');
  print('Stack trace:\n $s');
} finally {
  print('Do some thing:\n');
}

库的使用

1.引用库
通过import语句在一个库中引用另一个库的文件，注意以下事项：

在import语句后面需要接上库文件的路径
对Dart语句提供的库文件使用dart:xxx格式
第三方的库文件使用package:xxx格式

2.指定一个库的前缀
当引用的库拥有相互冲突的名字，可以为其中一个或几个指定不一样的前缀。

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

Element element = new Element();//使用lib1中的Element
lib2.Element element2 = new lib2.Element();//使用lib2中的Element

3.引用库的一部分
如果只需要使用库的一部分内容，可以有选择的引用，使用如下关键字

show : 只引用一点
hide : 除此之外都引用

//导入foo
import 'package:lib1/lib1.dart' show foo;
//处理foo导入其他所有内容
import 'package:lib2/lib2.dart' hide foo;