Dart知识点汇总

一、dart语法
1.开发工具
    Vscode，安装插件：dart、Code Runner
2.入口方法
    main(){
        print('你好，dart');
    }
    // 表示main方法没有返回值
    void main(){
        print('你好，dart');
    }
3.Dart变量
    dart是一个强大的脚本类语言，可以不预先定义类型，自动会类型推断
    dart中定义变量可以通过var关键字来声明变量
    dart中存在类型校验
    如：
        var str = 'this is var';
        String str = 'this is string';
        int str = 123;
4.Dart变量
    final const 都可定义常量
    final可以开始不赋值，只能赋值一次；而final不仅有const的编译时常量的特性，最重要的是它是运行时常量，并且final是惰性初始化，即在运行时第一次使用前才初始化
    如：    
        const NUM = 123;
        final Time = new DateTime.now();
5.Dart数据类型
    Numbers(数值)：int double
    Strings(字符串)：String
        如：var str = 'this is a string';
            String str = 'this is a string';
            // 定义多行字符串
            String str = '''
                my name is wq;
                my age is 23;
            ''';
            // 字符串拼接
            String name = 'wq';
            int age = 23;
            String myInfo = '我的名字叫$name,我今年$age岁';

            // 注意：如果使用+实现字符串拼接，那么必须要是同类型的数据
            String firstName = '王';
            String lastName = '清';
            String myInfo = lastName + ':' + firstName;
    Booleans(布尔)：bool
        bool flag = true;
    List(列表)：就是js中的数组
        // 第一种定义List的方式
        var list1 = [1,2,3];
        print(list1.length);

        // 第二种定义List的方式
        var list = new List();
        list.add(1);
        list.add(2);

        // 定义List指定元素类型
        var list = new List<String>();
        list.add('王清');
    Maps(字典)：Map是一个键值对相关的对象
        // 第一种定义Map
        var person = {
            "name": "王清",
            "age": 23
        };
        print(person['name']);

        // 第二种定义Map
        var p = new Map();
        p['name'] = '王清';
        print(p);

        问：如何判断类型？(关键字 is)
        var str = '123';
        if (str is String) {
            print('字符串类型');
        } else if (str is int) {
            print('数值类型');
        }
        
        注意：
            取整运算符 
                如：print(12~/5); // 2
            为空赋值  
                如：int b; b??=23; print(b);  // 23
                解释：如果b为空的话就赋值23
                    int a;  int b = a??10;  print(b); // 10
6.类型转换
    1) Number与String类型之间的转换
        ①Number转换为String类型 toString()
            int num = 12;
            print(num.toString());
        ②String转换为Number类型 parse
            String str = '123';
            print(int.parse(str));
            print(double.parse(str));

    2) 其他类型转换成Booleans类型
        ①isEmpty：判断当前字符串是否为空
            String str = '';
            print(str.isEmpty);
        ②未赋值 var myNum; print(myNum == null); // true
        ③为0 var myNum=0; print(myNum ==0);  // true
        ④为NaN var myNum = 0/0; print(myNum.isNaN); // true

7.List
    常用属性：
        length：长度
        reversed：翻转
            var list = [1,2,3];
            print(list.reversed.toList());
        isEmpty：是否为空
        isNotEmpty：是否不为空

    常用的方法：
        add()：增加元素，只能增加一个元素
        addAll()：拼接列表  list.addAll([1,2,3])
        indexOf()：查找数据，查找到返回元素下标，查找不到返回-1
        remove()：删除指定元素
        removeAt()：删除指定索引值的元素
        fillRange()：修改指定区间元素为新的元素 list.fillRange(2, 4, 1); // 修改下标2~3之间的元素为1
        insert(index,value)：在指定下标处插入元素
        insertAll(index,list)：在指定下标处插入列表  list.insertAll(2, [100,1]);
        toList()：其他类型转化为列表
        join()：List转换成字符串  String strList =  list.join('-');
        split()：字符串转换成List

8.Set
    Set是无序且不能重复的集合，所以不能通过下标去获取数据；它最主要的功能就是列表去重
    常用属性：
        isEmpty：是否为空
        isNotEmpty：是否不为空
        first：返回第一个元素
        last：返回最后一个元素
        length：长度
    常用方法：
        addAll：添加list转换为Set
        contains：查询是否包含单个元素 set.contains(1)
        containsAll：查询是否包含多个元素 set.containsAll([1,2])
        difference：返回两个set不同的元素 set1.difference(set2).toList()
        intersection：返回两个元素相同的元素
        union：包含两个set的所有元素
            Set set1 = [1,2,3].toSet();
            Set set2 = [2,3,4].toSet();
            print(set1.union(set2).toList()); // [1,2,3,4]
        clear：清空
        firstWhere: 按条件正向查询第一个符合条件的值
            Set set1 = [1,2,100,200,300,3].toSet();
            var list = set1.firstWhere((value){
                return value > 100;
            });
            print(list); // 200
        lastWhere：按条件逆向查询第一个符合条件的值
            Set set1 = [1,2,100,200,300,3].toSet();
            var list = set1.firstWhere((value){
                return value > 100;
            });
            print(list); // 300
        removeWhere：删除符合条件的元素
            Set set1 = [1,2,100,200,300,3].toSet();
            set1.removeWhere((value){
                return value > 100;
            });
            print(set1);  // {1, 2, 100, 3}
        retainWhere：保留符合条件的
            Set set1 = [1,2,100,200,300,3].toSet();
            set1.retainWhere((value){
                return value > 100;
            });
            print(set1);  // {200，300}
        retainAll：只保留当前的值
            Set set1 = [1,2,100,200,300,3].toSet();
            set1.retainAll([1,2]);
            print(set1); // {1，2}
        removeAll：删除当前的值
            Set set1 = [1,2,100,200,300,3].toSet();
            set1.removeAll([1,2]);
            print(set1); // {100,200,300,3}
    如：
        var s = new Set();
        s.add(1);
        s.add(2);
        s.add(1);
        print(s); // {1, 2}
        print(s.toList()); // [1,2]
    去重：
        // 方法一
        List list = [1,2,3,4,1,2];
        Set s = new Set();
        s.addAll(list);
        print(s.toList());

        // 方法二
        List list = [1,2,3,4,1,2];
        print(list.toSet().toList());

9. Map(映射)是无序的键值对
    常用属性：
        keys：获取所有的key值
        values：获取所有的value值
        isEmpty：是否为空
        isNotEmpty：是否不为空
    常用属性：
        addAll()：添加多个键值对
            如：
                Map m = {
                    "name": "wq",
                    "age": 23
                };
                m.addAll({
                    "love":["游戏","coding"],
                    "work":["外卖员"]
                });
        remove(key)：删除键为key的键值对
            如： m.remove('name');
        containsValue(value)：Map中是否存在该value的键值对
            如： m.containsValue(23);
        containsKey(key)：是否存在该key的键值对
            如： m.containsKey("name")

10. forEach map where any every(List、Set、Map通用)
    一般循环：
        List list = [100,200,300,400];
        for(var i in list){
            print(i); // 100 200 300 400
        }
    forEach循环：
        List list = [100,200,300,400];
        list.forEach((value) => print(value));
        list.forEach((value){
            print(value);  // 100 200 300 400
        });

    map循环：
        List list = [100,200,300,400];
        var newList = list.map((value){
            return value * 2;
        });
        print(newList.toList()); // [200,400,600,800]

    where循环：
        List list = [100,200,300,400];
        var newList = list.where((value){
            return value > 200;
        });
        print(newList.toList()); // [300,400]

    any循环：
        含义：判断是否存在符合条件的元素，如果存在返回true
        List list = [100,200,300,400];
        var flag = list.any((value){
            return value > 200;
        });
        print(flag);

    every循环：
        含义：判断是否所有元素符合条件，如果所有元素符合则返回true
        List list = [100,200,300,400];
        var flag = list.every((value){
            return value > 0;
        });
        print(flag); // true

11.函数、参数、闭包等
    1) 函数基本格式
        返回类型 方法名称(参数1,参数2...){
            方法体
            return 返回值;
        }
       ①定义参数类型为int，如果为其他类型报错 
            int getNum(int n){
                return n;
            }
            var n = getNum(60);
            print(n); // 60
       ②可选参数
            String printUserInfo(String name,[int age,String sex]){
                if (age != null && sex != null) {
                return '$name $age $sex';
                } else {
                return '$name';
                }
            }
            print(printUserInfo('王清', 20));
        ③默认参数
            String printUserInfo(String name, [int age=10]){
                if (age != null) {
                return '$name $age';
                } else {
                return '$name';
                }
            }
            print(printUserInfo('王清'));
        ④命名参数
            String printUserInfo(String name, {String sex, int age=10}){
                if (age != null) {
                return '$name $sex $age';
                } else {
                return '$name';
                }
            }
            print(printUserInfo('王清',sex: '男',age: 20));
        ⑤匿名方法
            Function fn = (){
                return '我是一个匿名函数';
            };
            print(fn());
        ⑥箭头函数：注意箭头函数不支持多行语句
            list.forEach((value)=>print(value));
        小知识点：
            判断一个数值是偶数还是奇数？
                isEven 是否为偶数
                isOdd 是否是奇数
        ⑦自执行函数
            ((String str){
                print(str);
            })('IIFE');
            
    2) 闭包
          全局变量特点：全局变量常驻内存、全局变量会污染全局
          局部变量特点：不常驻内存会被垃圾回收机制回收、不会污染全局

          想要实现功能：常驻内存，不污染全局

12.类 对象
    Dart所有的东西都是对象，所有的对象都继承自Object类；
    Dart是一门使用类和单继承的面向对象语言，所有的对象都是类的实例，并且所有的类都是Object的子类

    如：
        class Person{
            String name;
            int age;
            // 构造函数
            Person(String name,int age){
                this.name = name;
                this.age = age;
            }
            // 命名构造函数：命名构造函数可以写多个，但是构造函数只能有一个
            Person.now(String name,int age){
                this.name = name;
                this.age = age;
            }
            // 构造函数可以简写成以下方式
            Person(this.name,this.age);
            void getInfo(){
                print("${this.name}---${this.age}");
            }
        }

        void main(){
            Person p = new Person('王清',23);
            p.getInfo();
            Person p2 = new Person.now('王思聪', 30);
            p2.getInfo();
        }

    问：如何抽离类在另一个文件中调用
        1.新建Person.dart 文件内容为上面的类
        2.引用
            import 'Person.dart';
            void main(){
                Person p = new Person.now('王清',23);
                p.getInfo();
            }
    私有属性：
        Dart和其他面向对象语言不一样，没有private、public、protected这些访问修饰符
        但是我们可以使用_把一个属性或者方法定义为私有
        私有属性或方法不能被实例化直接调用，只能通过内部新方法或属性去使用
        如：
            class Person{
                String _name;
                int age;
                // 构造函数可以简写成以下方式
                Person(this._name,this.age);
                    // 命名构造函数
                    Person.now(String name,int age){
                    this._name = name;
                    this.age = age;
                }
                void getInfo(){
                    print("${this._name}---${this.age}");
                }
            }
        注意：要想私有属性生效，必须单独抽离成文件

    1)类中的getter和setter修饰符：
        class Rect{
            num height;
            num width;
            Rect(this.height,this.width);
            set areaWidth(value){
                this.height = value;
            }
            get area{
                return this.height * this.width;
            }
        }

        void main(){
            Rect r = new Rect(10, 10);
            // 通过访问属性的方式来调用get修饰的方法
            print(r.area);
            // 通过赋值的方式来调用set给属性赋值
            r.areaWidth = 20;
            print(r.area);
        }
    2) Dart中可以在构造函数体运行之前初始化实例变量
        class Rect{
            num height;
            num width;
            Rect():height=10,width=10{

            }
            get area{
                return this.height * this.width;
            }
        }

        void main(){
            Rect r = new Rect();
            print(r.area);
        }

    3)静态成员
        ①使用static关键字来实现类级别的变量和函数
        ②静态方法不能访问非静态成员，非静态方法可以访问静态成员
            class Person{
                static String name = '王清';
                static void show(){
                    print(name);
                }
            }
            void main(){
                Person.show();
            }

    4)Dart中的对象操作符：
        ? 条件运算符
        as 类型转换
        is 类型判断
        .. 级联操作
        如：
            class Person{
                String name;
                num age;
                Person(this.name,this.age);
                void show(){
                    print('${this.name}--${this.age}');
                }
            }

            void main(){
                Person p;
                // 判断p是否是空，如果为空就不执行方法或属性
                p?.show();
                print(p?.name);

                //判断对象是否是类的实例化
                if (p is Person) {
                    print('p是Person的实例');
                }

                var p1;
                p1 ='';
                p1 = new Person('王清', 20);
                // 对象类型转换
                (p1 as Person).show();

                // 级联操作
                p1..name = '张宇'
                    ..age = 25
                    ..show();
            }

    5)继承
        ①子类使用extends关键字来继承父类
        ②子类会继承父类里面可见的属性和方法，但是不会继承构造函数
        ③子类能复写父类的方法 getter和setter
        如：
            class Person {
                String name;
                num age;
                String height = '170cm';
                Person(this.name,this.age);
                Person.other(this.name,this.age);
                void printInfo(){
                    print('${this.name}--${this.age}');
                }
                work(){
                    print('工作吧...');
                }
            }

            class Web extends Person{
                String sex;
                Web(String name,num age,String sex):super(name,age){
                    this.sex = sex;
                }
                Web.other(String name,num age):super.other(name,age);

                void run(){
                    print('跑步');
                }

                void work(){
                    // 子类中通过super调用父类的方法
                    super.work();
                    // 子类中通过this调用父类的属性
                    print(this.height);
                }

                // 覆写父类中的方法
                @override  // 可以写也可以不写，建议写上
                void printInfo(){
                    print('子类的printInfo');
                }
            }
            void main(){
                Web w = new Web('张三',12,'男');
                w.printInfo();
                w.work();
            }

    6)抽象类
        Dart中抽象类：Dart抽象类主要用于定义标准，子类可以继承抽象类，也可以实现抽象类接口
            ①抽象类通过abstract关键字定义
            ②Dart中的抽象方法不能用abstract声明，Dart中没有方法体的方法我们成为抽象方法
            ③如果子类继承抽象类必须实现里面的抽象方法
            ④如果把抽象类当作接口实现的话必须要实现抽象类里面定义所有的方法和属性
            ⑤抽象类不能被实例化，只有继承它的子类可以
        extends和implements的区别：
            ①如果要复用抽象类里面的方法，并且要用抽象方法约束自类的画我们就用extends继承抽象类
            ②如果只是把抽象类当作标准的话我们就用implements实现抽象类

        抽象类：
            abstract class Animal{
                void eat();  // 抽象方法
                void drink(){
                    print('我要喝水');
                }
            }

            class Dog extends Animal{
                @override
                void eat(){
                    print('小狗在吃骨头');
                }
                @override
                void drink(){
                    print('狗要喝水');
                }
                void run(){
                    print('跑步吧~');
                }
            }

            void main(){
                Dog d = new Dog();
                d.drink();

                // 如果使用Animal类定义，就不能调用Dog类中自己的方法
                Animal a = new Dog();
                // a.run();  错误
            }

        抽象接口：
            abstract class DB{
                String URL;
                add();
                remove();
            }
            class MySQL implements DB{
                @override
                String URL;
            
                @override
                add() {
                    return null;
                }

                @override
                remove() {
                    return null;
                }
            }
            void main(){
            
            }
        一个类实现多个接口:
            abstract class A{
                printA();
            }

            abstract class B{
                printB();
            }

            class C implements A,B{
                @override
                printA() {
                    return null;
                }

                @override
                printB() {
                    return null;
                }
            }

13.mixins
    在Dart中可以使用mixins实现类似于多继承的功能；
    mixins使用条件：
        ①作为mixins的类只能继承自Object，不能继承其他类
        ②作为mixins的类不能有构造函数
        ③一个类可以mixins多个mixins类
        ④mixins绝不是继承，也不是接口，而是一种全新的特性
    如：
        class A{
            void printA(){
                print('A');
            }
        }
        class B{
            void printB(){
                print('B');
            }
        }

        class C extends A with B{

        }
        class D with A,B{

        }
        void main(){
            C c = new C();
            c.printA();
            c.printB();

            D d = new D();
            d.printA();
            d.printB();
        }
    注意：无论是extends还是with，如果存在同样的方法，谁在后面就调用谁的

14.泛型
    理解：泛型就是解决类、接口、方法的复用性以及对不特定数据类型的支持(类型校验)
    ①泛型方法
        T getData<T>(T value){
            return value;
        }
        void main(){
            print(getData<int>(21));
        }
    ②泛型类
        class MyArray<T>{
            List list = new List<T>();
            void add(T value){
                this.list.add(value);
            }
        }
        void main(){
            MyArray myArray = new MyArray<String>();
            myArray.add('wq');
        }
    ③泛型接口
        abstract class Cache<T>{
            getByKey(String key);
            void setBykey(String key,T value);
        }

        class FileCache<T> extends Cache<T>{
            @override
            getByKey(String key) {
                return null;
            }

            @override
            void setBykey(String key, T value) {
                print('$key --- $value');
            }
        }

        void main(){
            FileCache fc = new FileCache<String>();
            fc.setBykey('wq', '我是文件缓存');
        }
15.Dart中的库
    ①我们自定义的库
        import 'lib/XXX.dart';
    ②系统内置库
        import 'dart:io';
        import 'dart:convert';
        void main() async{
            var result = await getDataFromZhihuAPI();
            print(result);
        }

        //api接口： http://news-at.zhihu.com/api/3/stories/latest
        getDataFromZhihuAPI() async{
            //1、创建HttpClient对象
            var httpClient = new HttpClient();  
            //2、创建Uri对象
            var uri = new Uri.http('news-at.zhihu.com','/api/3/stories/latest');
            //3、发起请求，等待请求
            var request = await httpClient.getUrl(uri);
            //4、关闭请求，等待响应
            var response = await request.close();
            //5、解码响应的内容
            return await response.transform(utf8.decoder).join();
        }
    ③Pub管理系统中的库
        第一步:从下面网址找到要用的库
            https://pub.dev/packages
            https://pub.flutter-io.cn/packages
            https://pub.dartlang.org/flutter/
        第二步: 创建一个pubspec.yaml文件，内容如下:
            name: xxx
            description: A new flutter module project.
            dependencies:  
                http: ^0.12.1
        第四步：在文件所在目录执行 pub get
        第五步：写代码
            import 'package:http/http.dart' as http;
            import 'dart:convert' as convert;

            void getData() async {
                var url = 'http://www.phonegap100.com/appapi.php?a=getPortalList&catid=20&page=1';
                var response = await http.get(url);
                if (response.statusCode == 200) {
                    print(convert.jsonDecode(response.body));
                } else{
                    print('请求失败');
                }
            }
            void main(){
                getData();
            }

        小知识点：  
            ①部分导入
                import 'lib/myMath.dart' show getName; // 只引入getName方法
                import 'lib/myMath.dart' hide getName; // 只隐藏getName方法
            ②延时加载(deferred as)
                也成为懒加载，可以在需要的时候进行加载，减少App的启动时间
                如：
                    import 'XXX.dart' deferred as XXX;
                    getData() async {
                        await XXX.load();
                    }