Dart常用核心知识

Dart,常用,核心,知识 · 浏览次数 : 139

小编点评

dart中，一个文件就是一个模块或一个库注意： 1.as关键字可以给库起别名 2.默认情况下，导入一个库时会导入库中的所有内容，此时可以使用修饰词声明部分导入 show: 声明要导入的部分 hide: 声明要隐藏的部分 import '08_dart_自定义库_utils/math_utils.dart' as MathUtils; import '08_dart_自定义库_utils/math_utils.dart' show sum; import '08_dart_自定义库_utils/math_utils.dart' hide sub ; 3.export统一导出一类库文件，当一个目下有多个工具库时，可以统一放到一个文件中，集中导入防止每个都导入一次 export 'io_utils.dart'; export 'math_utils.dart'; 4.库文件中的私有方法是_开头的方法。 5.flutter项目第三方库管理文件pubspec.yaml, 然后执行pub get进行更新。 name: zhoufei description: a dart lib dependencies: http: ^0.12.0 系统库 dart中的Core核心库无需导入，默认导入。如使用的Map 如果使用其他专门功能，就导入专门的库,如： import 'dart:async'; import 'dart:io'; import 'dart:库的名称'; 自定义库导入方式 import '08_dart_自定义库_utils/math_utils.dart' 如果自定义库和当前模块或系统库方法名重复，可以是as重命名来区分 import '08_dart_自定义库_utils/math_utils.dart' as MathUtils; 第三方库导入方式 import 'package:http/http.dart' as http;*/ 。归纳总结以上内容，生成内容时需要带简单的排版

正文

Dart简述

Dart 是一个为全平台构建快速应用的客户端优化的编程语言，免费且开源。

Dart是面向对象的、类定义的、单继承的语言。它的语法涵盖了多种语言的语法特性，如C，JavaScirpt, Java, Swift等语言，可以转译为JavaScript，支持接口(interfaces)、混入(mixins)、抽象类(abstract classes)、具体化泛型(reified generics)、可选类型(optional typing)和sound type system。

下面整理了Dart这门语言的核心知识点。

1.变量声明

2.字符串

3.集合

4.函数

5.赋值运算符

6.面向对象

7.枚举

8.库的使用

1.变量的声明

dart变量的声明有两种，常量和变量。使用常量可以保证在定义一个变量后，如果后面赋值了不同的类型的值，会在编译期报错，提高安全性。

常量

1.const编译时常量，这种常量值要在编译前确定。

2.final运行时常量，这种常量值可以在运行时再确定。

变量

1.显示声明，如使用String name定义变量。

2.var类型推导，有编译器自动推导。虽然使用的var定义变量，此时的变量依然是确定的类型。

void main(List<String> args) {
  print("Hello Dart");

// 显示声明
String name = 'jack';
// 类型推断:类型推断的，也是有类型的。不同类型之间不能赋值。

// 类型推断变量
var age = 20;
age = 30;
// age = 30.3;

// 编译期常量
const school = '北京大学';
// 运行时常量
final local = DateTime.now();


const p1 = const Person('Tom');
const p2 = const Person('Tom');
const p3 = const Person('LiLei');

print(identical(p1, p2));
print(identical(p1, p3));

}


class Person {
  final String name;
  // 构造函数传参直接赋值到name属性上。
  const Person(this.name);
}

2.字符串

定义字符串有三种方式：单引号，双引号，三引号。

字符串的拼接规则和shell语法一样，$变量名后面没有其他符号时使用$变量名，后面紧跟其他符号产生歧义时，使用${变量名}

void main(List<String> args) {
  // 定义字符串三种方式：单引号，双引号，三引号
  var str1 = 'abc';
  var str2 = "def";
  var str3 = """
      ghi
      jkl
      mn
  """;
  print(str3);

  // 字符串拼接: 拼接规则和shell很相似
  var name = 'jack';
  var age = 30;
  var height = 190.3;

  var msg1 = "name is $name, age is ${age}, height is ${height}, height Type is ${height.runtimeType}";
  print(msg1);

}

3.集合

dart中有三种集合， dart在集合中广泛使用泛型来表示集合中存放的是什么类型。

1.列表List：使用[‘ABC’]进行定义

2.集合Set: 使用{'abc'}, 可以对列表List去重

3.哈希Map: 使用{'name': value}，使用的键值对进行定义

void main(List<String> args) {
  // dart中没有关键字定义接口，默认情况下，所有的class都是隐式接口
  // dart在集合中广泛使用泛型来表示集合中存放的是什么类型。

  // 1.列表List
  var names = ['abc', 'cba', 'nba', 'cba', 'abc'];
  names.add('hhh');
  print(names);
  print(names.runtimeType);

  // 2.集合Set
  var movies = {'星际穿越', '大话西游', '盗梦空间'};
  names = Set<String>.from(names).toList();
  print(names);
  print(movies);


  // 3.映射Map
  // 映射的Key应该是可以求出hash值的。
  var info = {
    'name': 'jack',
    'age': 30
  };
  Map;
  print(info);
  print(info.runtimeType);
  
}

4.函数

函数的定义

dart 函数的形式和 C 语言相似，形式为：返回值函数名(参数) {函数体}

其中返回值部分可以省略有编译器自动推导，但是推荐写上，方便开发人员理解。

dart 中没有函数的重载。

函数的可选参数

可选参数类型有：位置可选参数、命名可选参数两种。

位置可选参数形式为：[int age, double height]，实参和形参在进行匹配时，是根据位置匹配的。

命名可选参数：{int age, double height}，实参和形参在进行匹配时，需要根据名称进行设置。

可选参数可以有默认值，必传参数不能设置默认值。

函数是一等公民

一等公民是很灵活的，可以作为参数和返回值。

OC 中使用 Block 实现这一特性。

匿名函数

因为 dart 中函数为一等公民，所以在函数作为参数进行传参时，可以将函数写成匿名函数的形式。

参数中的匿名函数有两种形式：

匿名函数体是单条语句时，可以用是箭头函数表示

testFunc(() => print('箭头匿名函数，只能有一条语句') );

当匿名函数体中的语句多行时，使用下面的形式

// 多条语句
testFunc(() {
    print('匿名函数被调用');
});

匿名传参，参数需要定义为完整的函数签名，也可以使用下面类型定义的方式。

typedef Calculate = int Function(int num1, int num2);
void testFoo2(Calculate cal) {
  cal(10, 10);
}

void main(List<String> args) {
  print(sayHi(10, 20));

  // 顺序可选参数，传参的顺序必须和定义顺序相同
  sayHello1('jack', 30);
  // 命名可选参数，传参需要带定义的名称
  sayHello2('jack', age: 30);
  testFunc(foo);
}

// 1.函数的定义
// 返回值类型int 可以省略，但是推荐保留
int sayHi(int height, int age) {
  return age + height;
}


// 2.函数的可选参数
/*
   dart中没有函数的重载
   可选参数：位置可选参数 - 命名可选参数
   可选参数可以默认值，必传参数不需要默认值
*/
// 位置可选参数
void sayHello1(String name, [int age, double height]) {

}

// 命名可选参数
void sayHello2(String name, {int age, double height}) {

}
// 命名可选参数带默认值
void sayHello3(String name, {int age, double height = 12}) {

}

// 3.函数是一等公民
/*
   一等公民是很灵活的，可以作为参数和返回值。
   OC中使用Block实现这一特性
*/

void testFunc(Function foo) {
  foo();
}
void foo() {
  print('foo 函数被调用');
}

// 4.匿名函数
void testFunc2() {
  // 多条语句
  testFunc(() {
    print('匿名函数被调用');
  });

  // 单条语句
  testFunc(() => print('箭头匿名函数，只能有一条语句') );

  // 匿名函数传参
  /*
    匿名传参，参数需要定义为完整的函数签名：void testFoo(int foo(int num1, int num2)) {}
  */
  testFoo((num1, num2) => num1 + num2);
  testFoo2((num1, num2) => num1 + num2);

  // 匿名返回值
  var foo3 = testFoo3();
  foo3(3, 3);
}

void testFoo(int foo(int num1, int num2)) {
  print(foo(10, 20));
}
typedef Calculate = int Function(int num1, int num2);
void testFoo2(Calculate cal) {
  cal(10, 10);
}

Calculate testFoo3() {
  return (int num1, int num2) => num1 * num2;
}

5.赋值运算符

Dart中比较特别的运算符有： ??=， ??, 级联运算符

??=

如果运算符 ??=前面的变量为null就执行后面的=赋值操作，如果pro有值就不执行后面的操作。

特点：可能有赋值操作。

使用场景如：pro ??= name;

??是?:三目运算符号的简写，如果前面的变量有值则取前面的值，如果前面的值为空就取后面的值。

特点：一定有赋值操作。

使用场景如：school = pro ?? '没人上学';

级联运算符..

级联运算符可以连续对实例对象调用方法或属性

void main(List<String> args) {

  // ??=: 如果前面的pro为null就执行后面的=赋值操作，如果pro有值就不执行后面的操作。
  // 可能有赋值操作
  var name = 'jim';
  var pro = null;
  pro ??= name;
  print(pro);

  // ??: 是?:三目运算符号的简写， 如果前面的变量有值则取前面的值，如果前面的值为空就取后面的值。
  // 一定有赋值操作
  var school = '小学';
  school = pro ?? '没人上学';
  print(school);


  // 级联运算符：可以连续调用..方法
  var p = Person()
      ..name = 'jim'
      ..eat()
      ..run();
  p.eat();

}

class Person {
  var name;
  void eat() {

  }

  void run() {

  }
}

6.面向对象

1.类的基本定义

dart中的类默认继承在Object类，创建的实例对象可以调用Object中的方法。

如果不自定义结构函数，系统会给类自动创建一个空参数的构造函数。

// 类默认是继承自Object的，应用创建的对象是可以使用Object中的方法的。
class Person {
  String name;
  int age;
}

2.类的构造函数

dart中类的构造函数有三种：

a.用户没有自定义构造函数时，系统会默认实现一个空参数的构造函数

b.普通构造函数，通过便捷赋值，直接初始化属性值

Student(this.name, this.age);

c.命名构造函数，因为Dart中不支持函数重载，所以出现了命名构造函数来作为构造函数

Student.withNameAgeHeight(this.name, this.age, this.height);

Student.withMap(Map<String, dynamic> map) {
    this.name = map['name'];
    this.age = map['age'];
    this.height = map['height'];
};

dynamic、var、Object的区别？

var是类型推断。

dynamic是类型声明，相当于Swift中的Any，它是一个具体类型的声明，如String。

Object可以父类指向子类对象。

dynamic是运行时报错， Object是编译时报错。

3.类的初始化列表

dart的构造函数的结构体执行时，是在构造函数执行后，所以对于final属性，它必须在构造函数执行时进行执行。所以此时的执行时间需要在结构体执行，故：它的执行时间是在():后面的初始化列表里执行。

初始化列表:里面执行不仅可以包含编辑期静态返回值，还可以包含动态调用返回值。如：Color.blue

可选命名表达式: 只能有编译器静态赋值表达式，如：int age = temp ?? 20

// 3.类的初始化列表
class Teacher {
  final String name;
  final int age;

  // Teacher(this.name, {int age = 10, String color}): this.color = color ?? '' {
  // }
  Teacher():this.name = 'jc', this.age = 10 {
  }
}

4.构造函数重定向

当一个类中定义多个构造函数时，可以在普通构造函数的初始化列表中调用其他命名构造函数。

class Doctor {
  int age;
  String name;

  // 构造函数重定向
  Doctor(String name): this._internal(name, 10);
  // 命名构造函数
  Doctor._internal(String name, int age);
}

5.常量构造函数

使用常量构造函数创建的常量对象，如果对象的属性值一样时，返回的实例对象内存地址是一样的，返回的是同一个对象。

// 5.常量构造函数，相同的属性只有一个内存对象。
class Apple {
  final String name;
  final int age;

  const Apple(this.name, this.age);
}

6.工厂构造函数

工厂构造函数最大的特点是可以手动返回对象。

普通构造函数与工厂构造函数的区别：

普通构造函数不需要写return 会自动返回实例对象。

工厂构造函数需要写return 手动返回实例对象。

// 6.工厂构造函数：最大的特点可以手动返回一个对象。

class Orange {
  String name;
  String color;
  static final Map<String, Orange> _nameCache = {};
  static final Map<String, Orange> _colorCache = {};
  
  factory Orange.withName(String name) {
    if (_nameCache.containsKey(name)) {
      return _nameCache[name];
    } else {
      final p = Orange(name, 'red');
      _nameCache[name] = p;
      return p;
    }
  }
  Orange(this.name, this.color);
}

7.Setter, Getter

在Dart中没有private public等修饰符，当对属性_开头时，表示这个属性是私有属性，只能在当前文件模块内访问。

// 7.Setter, Getter进行属性监听
// 使用方式是: var e = Elephone(); e.setName('jim'); e.getName
class Elephone {
  String name;
  // 在Dart中没有private public等修饰符，当对属性_开头时，表示这个属性是私有属性，只能在当前文件模块内访问。
  String _age;

  // setter
  set setName(String name) {
    this.name = name;
  }
  // getter
  String get getName {
    return name;
  }

}

8.继承

子类继承父类时，父类有构造函数时，需要在子类的参数列表中进行调用，进行初始化。

// 8.继承：父类的构造函数要在子类的初始化列表中进行调用。
class Animal{
  String name;
  Animal(this.name);

  void eat() {
    print('eatting');
  }
}

class Dog extends Animal {
  int age;
  // 父类有构造函数时，需要在参数列表中进行调用，初始化。
  Dog(this.age, String name): super(name);
}

9.抽象类

抽象类在使用时有以下特点：

a.子类继承抽象父类，父类的接口方法必须实现，它们都是必选项。因为dart中没有option可选项。

b.抽象类不能被实例化。

c.系统调用抽象类Map进行实例化的过程分析

　　Map是一个抽象类，而可以调用Map()产生实例对象的原因是因为调用的Map()是Map抽象类的工厂方法 external factory Map();

　　external关键字是一个方法存在的声明，表示此方法已经存在，但不在这里实现。这样实现和声明分离

　　的好处是，可以在实现的地方使用runtimeType集中处理不同平台逻辑，而通过方法接口声明在不同的平台调用。

　　在方法具体实现的地方使用@patch修饰。

// 9.抽象类
abstract class Shape {
  int getArea();
  String getInfo() {
    return '形状';
  }

  void testMap() {
    final m = Map();
    print(m.runtimeType);
  }
}

class Rectangle extends Shape {
  @override
  int getArea() {
    return 20;
  }
}

10.dart隐式接口

dart中定义的class同时也可以当接口使用，可以说class定义的即是类，也是接口。当它做为类使用时，里面定义的方法不必须让子类实现。当它做接口时，里面定义的方法都需要被重新实现。

dart是单继承语言。

// 10.dart隐式接口：dart中定义的class同时也可以当接口使用。
class Runner {
  void run() {
    print('running');
  }
}

class Fly {
  void fly() {
    print('fly');
  }
}

class SuperMan extends Animal implements Runner, Fly {
  SuperMan(String name):super(name);

  // 1.接口实现
  @override
  void run() {
    // TODO: implement run
  }

  @override
  void fly() {
    // TODO: implement fly
  }

  // 2.方法重写
  @override
  void eat() {
    // TODO: implement eat
    super.eat();
  }
}

11.混入mixin

dart是单继承语言。

当出现需求想要同时拥有多个类中的方法和属性时，可以通过混入mixin来间接实现多继承。

可以同时引入多个mixin类中的方法。

dart是单继承, 如果要想同时引入多个mixin类中的方法，则可以定义多个mixin类来引入。

定义用mixin，使用用with。

// 11.混入mixin
mixin Play {
  void play() {
    print('play');
  }
}

mixin Jump {
  void jump() {
    print('jump');
  }
}

class Robbit extends Animal with Play, Jump {
  Robbit(String name):super(name);

  @override
  void eat() {
    // TODO: implement eat
    super.eat();
  }
}

12.static 类属性，类方法

可以通过static静态声明来定义类属性和类方法/*

  12.static 类属性，类方法
*/

class SuperWoman {
  // 成员变量，成员方法
  var name;
  void fly() {

  }

  // 静态/类变量，静态/类方法
  static var flyYear;
  static void run() {

  }
}

void main(List<String> args) {
  // 虽然dart支持函数式开发，但是大部分使用的是面向对象开发。

  var p0 = Person('jim', 22);
  print(p0.toString());

  var s0 = Student.withMap({
    'name': 'jack',
    'age': 18,
    'height': 33.3
  });
  print(s0);

}

// 1.类的基本定义
// 类默认是继承自Object的，应用创建的对象是可以使用Object中的方法的。
class Person {
  String name;
  int age;

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

  // 语法糖
  Person(this.name, this.age); 

}

// 2.类的构造函数
class Student {
  String name;
  int age;
  double height;

  // a.普通的构造方法
  Student(this.name, this.age);
  // b.命名构造函数：因为Dart中不支持函数重载，所以出现了命名构造函数来作为构造函数

  Student.withNameAgeHeight(this.name, this.age, this.height);

  /*
    dynamic和Object的区别
    dynamic是类型声明，var是类型推断，它是一个具体类型的声明，如String。
    dynamic是运行时报错
    Object是编译时报错
    Object可以父类指向子类对象。

    Object obj = 'hello';
    print(obj.toString(1));

  */
  Student.withMap(Map<String, dynamic> map) {
    this.name = map['name'];
    this.age = map['age'];
    this.height = map['height'];
  }


  // c.重新类的描述方法
  @override
  String toString() {
    // TODO: implement toString
    return "$age, $name, $height";
  }
}


// 3.类的初始化列表
class Teacher {
  final String name;
  final int age;

  /*
    构造函数的结构体执行时，是在构造函数执行后，所以对于final属性，它必须在构造函数执行时进行执行
    所以此时的执行时间就是在结构体执行时，故：它的执行是在():后面的初始化列表里执行。

    初始化列表:里面执行不仅包含编辑期静态返回值，还可以包含动态调用返回值。如：Color.blue
    可选命名表达式: 只能有赋值表达式，如：int age = temp ?? 20
  */
  // Teacher(this.name, {int age = 10, String color}): this.color = color ?? '' {

  // }

  Teacher():this.name = 'jc', this.age = 10 {

  }
}


// 4.构造函数重定向
class Doctor {
  int age;
  String name;

  // 构造函数重定向
  Doctor(String name): this._internal(name, 10);
  // 命名构造函数
  Doctor._internal(String name, int age);
}

// 5.常量构造函数，相同的属性只有一个内存对象。
class Apple {
  final String name;
  final int age;

  const Apple(this.name, this.age);
}

// 6.工厂构造函数：最大的特点可以手动返回一个对象。
/*
  普通构造函数不需要写return 会自动返回实例对象。
  工厂构造函数需要写return 手动返回实例对象。
  static：全局静态方法，类方法。
*/

class Orange {
  String name;
  String color;
  static final Map<String, Orange> _nameCache = {};
  static final Map<String, Orange> _colorCache = {};
  
  factory Orange.withName(String name) {
    if (_nameCache.containsKey(name)) {
      return _nameCache[name];
    } else {
      final p = Orange(name, 'red');
      _nameCache[name] = p;
      return p;
    }
  }

  Orange(this.name, this.color);


}


// 7.Setter, Getter进行属性监听
// 使用方式是: var e = Elephone(); e.setName('jim'); e.getName
class Elephone {
  String name;
  // 在Dart中没有private public等修饰符，当对属性_开头时，表示这个属性是私有属性，只能在当前文件模块内访问。
  String _age;

  // setter
  set setName(String name) {
    this.name = name;
  }
  // getter
  String get getName {
    return name;
  }

}


// 8.继承：父类的构造函数要在子类的初始化列表中进行调用。
class Animal{
  String name;
  Animal(this.name);

  void eat() {
    print('eatting');
  }
}

class Dog extends Animal {
  int age;
  // 父类有构造函数时，需要在参数列表中进行调用，初始化。
  Dog(this.age, String name): super(name);
}


// 9.抽象类
// a.子类继承抽象父类，父类的接口方法必须实现，没有option可选项。
// b.抽象类不能实例化
/*
  c.系统抽象类Map实例化分析
  Map是一个抽象类，而可以调用Map()产生实例对象的原因是因为
  调用的Map()是Map抽象类的工厂方法external factory Map();

  external 是一个方法存在声明，表示此方法已经存在，但不在这里实现。这样实现和声明分离
  的好处是，可以在实现的地方使用runtimeType集中处理不同平台逻辑，而通过方法接口声明在不同的平台
  调用。 
  实现的地方使用@patch修饰。
*/
abstract class Shape {
  int getArea();
  String getInfo() {
    return '形状';
  }

  void testMap() {



    final m = Map();
    print(m.runtimeType);
  }
}

class Rectangle extends Shape {
  @override
  int getArea() {
    return 20;
  }
}



// 10.dart隐式接口：dart中定义的class同时也可以当接口使用。
/*
  dart中没有interface/ protocal这样专门定义接口的关键字
  dart中定义的class 同时也具有接口的功能，把class当接口使用时，class中定义的方法必须要全部实现。
  dart是单继承
*/

class Runner {
  void run() {
    print('running');
  }
}

class Fly {
  void fly() {
    print('fly');
  }
}

class SuperMan extends Animal implements Runner, Fly {
  SuperMan(String name):super(name);

  // 1.接口实现
  @override
  void run() {
    // TODO: implement run
  }

  @override
  void fly() {
    // TODO: implement fly
  }

  // 2.方法重写
  @override
  void eat() {
    // TODO: implement eat
    super.eat();
  }
}

// 11.混入mixin
/*
  混入mixin间接实现多继承，可以同时引入多个mixin类中的方法
  dart是单继承, 如果要想同时引入多个mixin类中的方法，则可以定义多个mixin类来引入
  定义用mixin
  使用用with
*/
mixin Play {
  void play() {
    print('play');
  }
}

mixin Jump {
  void jump() {
    print('jump');
  }
}

class Robbit extends Animal with Play, Jump {
  Robbit(String name):super(name);

  @override
  void eat() {
    // TODO: implement eat
    super.eat();
  }
}


/*
  12.static 类属性，类方法
*/

class SuperWoman {
  // 成员变量，成员方法
  var name;
  void fly() {

  }

  // 静态/类变量，静态/类方法
  static var flyYear;
  static void run() {

  }
}

7.枚举

Dart相比JavaScript增加了枚举类型。

void main(List<String> args) {
  var color = Colors.red;

  switch (color) {
    case Colors.blue:
      print('蓝色');
      break;
    case Colors.red:
      print('红色');
      break;
    case Colors.yellow:
      print('黄色');
      break;
    default:
  };

  print(Colors.values);    
}

enum Colors {
  red,
  blue,
  yellow
}

8.库的使用

dart中，一个文件就是一个模块或一个库。

dart中的库有三种：系统库，自定义库，第三方库。

系统库：dart中的Core核心库无需导入，默认导入。如使用的Map

如果使用其他专门功能，就导入专门的库,如：

  import 'dart:async';
  import 'dart:io';
  import 'dart:库的名称';

自定义库：导入方式

import '08_dart_自定义库_utils/math_utils.dart'
  如果自定义库和当前模块或系统库方法名重复，可以是as重命名来区分
  import '08_dart_自定义库_utils/math_utils.dart' as MathUtils;

第三方库：导入方式

  import 'package:http/http.dart' as http;

注意

1.as关键字可以给库起别名

2.默认情况下，导入一个库时会导入库中的所有内容，此时可以使用修饰词声明部分导入

show: 声明要导入的部分

hide: 声明要隐藏的部分

  import '08_dart_自定义库_utils/math_utils.dart' as MathUtils;
  import '08_dart_自定义库_utils/math_utils.dart' show sum;
  import '08_dart_自定义库_utils/math_utils.dart' hide sub ;

3.export统一导出一类库文件，当一个目下有多个工具库时，可以统一放到一个文件中，集中导入防止每个都导入一次

export 'io_utils.dart';
export 'math_utils.dart';

4.库文件中的私有方法是_开头的方法。

5.flutter项目第三方库管理文件pubspec.yaml, 然后执行pub get进行更新。

    name: zhoufei
    description: a dart lib
    dependencies:
      http: ^0.12.0

import 'dart:math';
import 'dart:convert' as convert;

import '08_dart_自定义库_utils/math_utils.dart' as MathUtils;
// import '08_dart_自定义库_utils/math_utils.dart' show sum;
// import '08_dart_自定义库_utils/math_utils.dart' hide sub ;

import 'package:http/http.dart' as http;



void main(List<String> args) async {
  final num1 = 10;
  final num2 = 20;
  print(min(num1, num2));

  MathUtils.sub(num1, num2);

   var url =
      Uri.https('www.googleapis.com', '/books/v1/volumes', {'q': '{http}'});

  // Await the http get response, then decode the json-formatted response.
  var response = await http.get(url);
  if (response.statusCode == 200) {
    var jsonResponse =
        convert.jsonDecode(response.body) as Map<String, dynamic>;
    var itemCount = jsonResponse['totalItems'];
    print('Number of books about http: $itemCount.');
  } else {
    print('Request failed with status: ${response.statusCode}.');
  }
  
}

/*
  dart中，一个文件就是一个模块或一个库
  注意：
  1.as关键字可以给库起别名
  2.默认情况下，导入一个库时会导入库中的所有内容，此时可以使用修饰词声明部分导入
    show: 声明要导入的部分
    hide: 声明要隐藏的部分
  import '08_dart_自定义库_utils/math_utils.dart' as MathUtils;
  import '08_dart_自定义库_utils/math_utils.dart' show sum;
  import '08_dart_自定义库_utils/math_utils.dart' hide sub ;
  3.export统一导出一类库文件，当一个目下有多个工具库时，可以统一放到一个文件中，集中导入防止每个都导入一次
    export 'io_utils.dart';
    export 'math_utils.dart'; 
  4.库文件中的私有方法是_开头的方法。  
  5.flutter项目第三方库管理文件pubspec.yaml, 然后执行pub get进行更新。
    name: zhoufei
    description: a dart lib
    dependencies:
      http: ^0.12.0


  系统库
  dart中的Core核心库无需导入，默认导入。如使用的Map
  如果使用其他专门功能，就导入专门的库,如：
  import 'dart:async';
  import 'dart:io';
  import 'dart:库的名称';


  自定义库
  导入方式
  import '08_dart_自定义库_utils/math_utils.dart'
  如果自定义库和当前模块或系统库方法名重复，可以是as重命名来区分
  import '08_dart_自定义库_utils/math_utils.dart' as MathUtils;

  第三方库
  导入方式
  import 'package:http/http.dart' as http;

*/