从Flutter到原生开发-基础语法_Dart

Dart 数据类型

内置基础数据类型

变量和常量

Dart中定义变量有两种方式，一种是静态类型语言常用的方式，显式指定变量类型，另一种则是动态语言的常用方式，不指定类型，由vm自动推断。

定义变量

dart

// 1.通过显式指定类型来定义变量
String name = "张三";
num age = 18;

// 2.使用关键字var，不指定类型
var address = "大道";
var id = 100;

/* 使用var定义变量，即使未显式指定类型，一旦赋值后类型就被固定
 * 因此使用var定义的变量不能改变数据类型
 */
var number = 20;
// 以下代码错误，无法运行，number变量已确定为int类型
number = "2020";

如想动态改变变量的数据类型，应当使用dynamic或Object来定义变量。

dart

// dynamic声明变量
dynamic var1 = "hello";
var1 = 19;
print(var1);    // 19

// Object声明变量
Object var2 = 20;
var2 = "ce";
print(var2);    // ce

定义常量

Dart中定义常量也有两种方式，一种使用final关键字， 一个 final 变量只能赋值一次；另一种是使用const关键字定义。

dart

// 1.使用final关键字定义常量
final height = 10;

// 2.使用const关键字定义常量
const pi = 3.14;

final time = new DateTime.now(); // 正确
const time1 = new DateTime.now(); // 错误

需要注意，final定义的常量是运行时常量，而const常量则是编译时常量，也就是说final定义常量时，其值可以是一个变量，而const定义的常量，其值必须是一个字面常量值

内置类型的常用操作

数值类型

dart

// String 转 int
var one = int.parse('1');

// String 转 double
var onePointOne = double.parse('1.1');

// int 转 String
String oneAsStr = 1.toString();

// double 转 String
String piAsStr = 3.14159.toStringAsFixed(2); // 保留两位 '3.14'

//判断数字是不是NaN

var as1=0/0;
if(as1.isNaN){
  print('是Nan');
}else{
  print('不是Nan');

}

字符串类型

dart

// 1.Dart可以使用单引号或双引号来创建字符串
var s1 = "hello";
var s2 = 'world';

// 2.Dart可以使用三引号来创建包含多行的字符串
var multiLine1 = """你可以像这样，创建一个
包含了多行的字符串内容
""";

var multiLine2 = '''你也可以使用三个单引号，创建一个
包含了多行的字符串内容
''';


// 3.还可以在字符串字面值的前面加上`r`来创建原始字符串，则该字符串中特殊字符可以不用转义
var path = r'D:\workspace\code';

// 4.Dart支持使用"+"操作符拼接字符串
var greet = "hello" + " world";

// 5.Dart提供了插值表达式"${}"，也可以用于拼接字符串
var name = "王五";
var aStr = "hello,${name}";
print(aStr);    // hello,王五

// 当仅取变量值时，可以省略花括号
var aStr2 = "hello,$name"; // hello,王五

// 当拼接的是一个表达式时，则不能省略花括号
var str1 = "to";
var str2 = "click ${str1.toUpperCase()}";
print(str2);   // click TO

// 字符串类型判断是不是空字符串
var str = "";
if(str.isEmpty){
  print("为空");
}else{
  print("不为空");
}

布尔类型

Dart中的布尔类型仅有false、true两个值，不能使用0、非0或者null、非null来表达false和true。布尔类型的默认值为null

dart

bool s;
print(s); //null

列表类型

Dart中列表操作与JavaScript中的数组相似。

• 常用的属性

  属性	作用
  length	长度
  isEmpty	判断是否为空列表
  isNotEmpty	判断不是为空列表
  reversed	列表反转

• 常用的方法

方法	作用
add(“xxx”)	添加一个
addAll([‘xxx’,’xx’])	添加多个
indexOf(‘xxx’)	从列表查找，找到返回列表的索引，找不到返回-1
remove(‘xxx’)	删除 传入具体值
removeAt(index)	删除 传入索引值
fillRange(start，end,value)	修改
insert(index,value)	指定位置插入
insertAll(index,list)	指定位置插入list
toList()	其他类型 转换为List
join(‘x’)	list 转换为字符串,以什么分割
split(‘x’)	字符串转list，以什么分割
forEach	循环
map	List的循环
where	满足条件的返回一个集合，不符合返回()
any	list中有一个满足条件的返回true否则返回false
every	list中全部满足条件的返回true否则返回false

dart

// 创建列表
var list = [1, 2, 3];
// 下标从0开始。使用length可以访问list的长度
print(list[0]);
print(list.length);

// 可以使用add添加元素
list.add(5);

// 列表去重
list myList = [1,2,3,4,5,1,2,3];
var s = new Set();
s.addAll(myList);
var setList = s.toList();
print(setList)//输出去重后的数据

// 可在list字面量前添加const关键字，定义一个不可改变的 列表（编译时常量）
var constantList = const [1, 2, 3];
constantList[1] = 1;     // 报错

映射类型

Dart中映射操作与JavaScript中的对象相似。

dart

// 1.通过字面量创建Map
var gifts = {
  'first' : 'partridge',
  'second': 'turtledoves',
  'fifth' : 'golden rings'
};

// 2.使用Map类的构造函数创建对象
var pic = new Map();
// 往Map中添加键值对
pic['first'] = 'partridge';
pic['second'] = 'turtledoves';
pic['fifth'] = 'golden rings';

// 3.获取Map的长度
print(pic.length);

// 4.查找Map
pirnt(pic["first"]);
print(pic["four"]);    // 键不存在则返回 null

函数

在Dart中，函数（或方法） 也是对象，它的类型是 Function。 这意味着，函数可以赋值给变量，也可以当做其他函数的参数。

定义函数

dart

//方式一
String greet(String name){
    return "hello,$name";
}
// 方式二
greet(name){
    return "hello,$name";
}

要注意，函数也是对象，所有函数都有返回值。当没有指定返回值的时候，函数会返回null。当然，如果你强行使用void来修饰函数，则函数真的没有返回值

函数的参数

Dart中支持两种可选参数

1. 命名参数位置
2. 参数位置不可变

dart

  // 定义一个函数，参数列表用花括号包裹
// 方式一命名参数位置
add({int x, int y=1, int z=0}){
    print(x + y + z;
}
// 调用
add(x:1);              // 2
add(x:12, y:2, z:10);   // 24
//方式二 参数位置不可变
// 定义add函数 设置z的默认参数
 add1(int x, [int y, int z = 2]) {
    int result = x + z;
    if (y != null) {
      result = result + y;
    }

    print(result);
  }


  add1(0); // 2
  add1(0, 2); // 4
  add1(0, 2, 3); // 5

匿名函数

dart

var func = (x,y){
    return x + y;
};
print(func(1,12));

箭头函数

与JavaScript 的相同

dart

add2(num x, num y) => x + y;

运算符

算术运算符

+、-、*、/、% ~/

和其他语言一样 多一个 ~/ 作用相除后的结果取整返回

类型判定运算符

操作符	作用
as	类型转换
is	数据类型判断
is!	数据类型判断取反

dart

if (emp is Person) { // Type check
  emp.firstName = 'Bob';
}

// 上面代码可简化为
(emp as Person).firstName = 'Bob';

赋值操作符

dart

// 给 a 变量赋值
a = value;  

// 复合赋值操作符
a += b;  // 等价于a = a + b;

// 如果 b 是 null，则赋值给 b；
// 如果不是 null，则 b 的值保持不变
b ??= value; 
     
// 如下所示:     
  var s;
  print(s);  // null
  print(s ?? 'str');  // str
  s ??= 'string';
  print(s);  // string

级联操作符

假如类Person有三个方法，setName、setAge、getName则可如下调用

dart

new Person()..setName("Bob")..setAge(20)..getName();

循环语句

支持 for in 、forEach 用法和JavaScript 相同

类和对象

dart

class Person {
  String name;
  int age;

  Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
}

// 简写

class  Person {
    String name;
    int age;
    Person(this.name, this.age);
}

Dart中没有private、public这些成员访问修饰符。如果是类私有的成员，不希望外面访问，只需要在成员变量之前加上一个下划线_变为私有即可

Getters 和 Setters方法

dart

class  Person {
    String userName;

    Person(this.userName);

    // 方法名前加get关键字
    String get name{
        return  "user:"  +  this.userName;
    }

    // 方法名前加set关键字
    set name(String name){
        // do something
        this.userName = name;
    }
}

void  main() {
    var p = new Person("zhangsan");
    print(p.name);   // user:zhangsan
    p.name = "lisi";
    print(p.name);   // user:lisi
}

类的继承 关键字（extends）

Dart中的继承可以使用关键字extends继承父类，使用关键字super引用父类

dart

class Father {
    myFunction(){
        // do something
    }
}

class Son extends Father {

    @override
    myFunction(){
        super.myFunction();
    }
}

类的多继承 关键字(with)

dart

// 首先定义三个父类
class Father1 {
    a(){
      print("this is a func");
    }

    Father(){
        print("Father1");
    }
}

class Father2 {
    b(){
      print("this is b func");
    }

    Father(){
        print("Father2");
    }
}

class Father3 {
    c(){
      print("this is c func");
    }

    Father(){
        print("Father3");
    }
}

//定义子类
class Son  with Father1 Father2,Father3{

}

void main() {
  var obj = new Son();
  obj.Father(); //Father3
  obj.a();      //this is a func
  obj.b();      //this is b func
  obj.c();      //this is c func
}

接口抽象

抽象类 关键字(abstract)

抽象类是不能被实例化的，子类继承抽象类时，必须实现全部抽象方法。

dart

abstract class DataBase {
    func1();
    func2();
}

隐式接口 关键字(implements)

实际上在Dart中，每个类都隐式的定义了一个包含所有实例成员的接口， 并且该类实现了这个接口。
如果我们想实现某个接口，但有又不想继承，则可以使用这种隐式接口机制。我们需要用到关键字implements

dart

class People {
  void greet(){
    print("Hello");
  }
}

class Student implements People{
  @override
  void greet(){
    print("Hi,I'm wangwu.");
  }
}

greet(People p){
  p.greet();
}

void main() {
  greet(new Student());
}

泛型

dart

// 泛型
var names = new List<String>();
names.add("zhangsan")

var maps = new Map<int, String>();
maps[1]="lisi";

// 字面量写法
var infos = <String>['zhangsan', 'lisi', 'wangwu'];

库的使用

dart

// 指定dart:前缀，表示导入标准库，如dart:io
import 'dart:math';

// 也可以用相对路径或绝对路径来引用dart文件
import 'lib/student/student.dart';

// 指定package:前缀，表示导入包管理系统中的库
import 'package:utils/utils.dart';

导入库时，可以使用as关键字来给库起别名，避免命名空间冲突。

dart

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

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

使用show和hide关键字控制库中成员的可见性

dart

// 仅导入foo，屏蔽库中其他成员
import 'package:lib1/lib1.dart' show foo;

// 屏蔽foo，库中其他成员都可见
import 'package:lib2/lib2.dart' hide foo;

为了减少 APP 的启动时间，加载很少使用的功能，我们还可以延迟导入库。使用 deferred as关键字延迟导入

dart

import 'package:deferred/hello.dart' deferred as hello;

// 当需要使用时，再通过库标识符调用 loadLibrary函数加载
hello.loadLibrary();

异步编程

使用 async 和 await关键字

dart

// 导入io库，调用sleep函数
import 'dart:io';

// 模拟耗时操作，调用sleep函数睡眠2秒
doTask() async{
  await sleep(const Duration(seconds:2));
  return 'xx';
}

// 定义一个函数用于包装
test() async {
  var r = await doTask();
  print(r);
}

void main(){
  print("main start");
  test();
  print("main end");

  // main start
  // main end
  // xx
}