Flutter-2: Dart语法、flutter变量

1: flutter_dart download

2: flutter_dart: 主函数(main)

main(List<String> args) {
    print('hello world dart!');
}

# 1: main 是作为dart的入口函数
# 2: 每行代码结尾都需要冒号;作为代码结束语句
# 3: List是Dart的一个集合、每一个String都是传递给main函数的一个参数
# 4: 定义字符串的时候、可以使用单引号''或者双引号""

3: flutter_dart: 定义变量(define variable)

变量类型 名称 = 赋值;

# 例如：
String name = 'Joe';
print('name=${name}');

Int age = 29;
print('age=${age}');

Double height = 1.75;
print('height=${height}');

@注意⚠️：
    - 定义的变量可以修改值、但是不能赋值其他类型；
    
    # 例如：
    String content = 'hello';
    content = 'world'; ✅
    content = 29; ❌
    

4: flutter_dart: 类型推导(type inference)

    - 类型推导的变量的方式， 格式如下：
    var/dynamic/const/final 变量名称 = 赋值;
    
    ****** var的使用
        runtimeType 用户获取变量当前的类型
    {
        # var 正确的使用
    var name = 'wike';
    name = 'bobo';
    print(name.runtimeType); // String
    
        # var 的错误使用
    var age = 18;
    age = 'bobo'; // 不可以将String赋值给一个int类型
    }
    
    
    ****** dynamic的使用
        在开发中、通常情况下不使用dynamic、因为类型的变量会带来潜在的危险。
    {
        dynamic name = 'wike';
        print(name.runtimeType); // String
        name = 18;
        print(name.runtimeType); // Int
    }
    
    
    ****** final&const的使用
        final 和 const都是用来定义变量的、也就是定义之后都不可以修改。
    {
        final name = 'wike';
        name = 'bobo'; // 错误写法、不可以修改❌
        
        const age = 18;
        age = 20; // 错误写法、不可以修改❌
    }
    
            # final 和 const区别？
            const 在赋值时、赋值的内容必须是在编译期间就确定下来的。
            final在赋值时、可以动态获取、比如赋值一个函数。
            {
                String getName() = {
                    return 'wike';
                }
                
                main(List<String> args) {
                    const name = getName(); // 错误写法、不可以赋值函数❌
                    final name = getName(); // 正确的写法、可以赋值函数✅
                }
            }
            
            # final与 const小案例
                - 首先、const是不可以赋值为DateTime.now()
                - 其次、final一旦被赋值后就有确定的结果、不会再次赋值
            {
                // const time = DateTime.now() // ❌错误写法
                final time = DateTime.now();
                print(time); // 2020-07-03 14:00:41.052626
                
                sleep(Duration(second: 2));
                print(time); // // 2020-07-03 14:00:41.052626
                结论： 从上面时间来看出、一旦final的变量被赋值以后就不会再变化、哪怕时间睡眠2秒以后、time依然是第一次赋值的那个值。
                
            }
            
            # const 放在赋值语句的右边👉、可以共享对象、提高性能
            {
                class Person {
                    const Person();
                }
                
                main(List<String> args) {
                    final a = const Person();
                    final b = const Person();
                    print(identical(a, b)); // true
                    
                    final m = Person();
                    final n = Person();
                    print(identical(m, n)); // false
                }
            }
            

5: flutter_dart: 数据类型 DateType

****** 数字类型
         - 整数用int
         - 浮点数用double
        
    # 要说明一下、Dart中的int和double可表示的范围不是固定的、取决于运行dart的平台。
    {
        // 1: 整数类型int
        int age = 18;
        int hexAge = 0x12;
        print(age);
        print(hexAge);
        
        // 2: 浮点类型double
        double height = 1.88;
        print(height);
    }


    # 字符串 和 数字 之间的转化
    
    {
        // 1: 字符串 转 数据 (String -> Int)
        var one = int.parse('111');
        var two = double.parse('12.12');
        print('one=${one} type=${one.runtimeType}'); // one=111
        
        
        // 2: 数字 转 字符串(int -> String)
        var num1 = 123;
        var num2 = 123.456;
        var num1String = num1.toString();
        var num2String = num2.toString();
        var num2StringFixed = num2.toStringAsFixed(2);// 保留两位小数
        print('${num1String} ${num1String.runtimeType}'); // 123 String
        print('${num2String} ${num2String.runtimeType}'); // 123.456 String
        print('${num2StringFixed} ${num2StringFixed.runtimeType}'); // 123.45 String
    }
    
****** 布尔类型bool
        # 布尔类型bool
        布尔类型中、dart中提供一个bool的类型、值为true/false
        注意：Dart中不能判断非0即真、非空即真
        Dart的类型安全意味着你不能使用if(非bool) 或者 assert(非bool)之类的代码
        {
            // 布尔类型 ✅
            var isFlag = true;
            print('isFlag=${isFlag} ${isFlag.runtimeType}'); // isFlag=true bool
            
            // 布尔类型错误用法❌: 不能判断非0即真、非空即真。
            var message = 'hello dart';
            if (message) {
                print(message);
            }
        }
        
****** 字符串类型
        # Dart 字符串hiUTF-16编码单元的序列、你可以使用单引号'' 或者 双引号 “”
    
        '{
            // 1: 定义常规字符串
            var s1 = 's1';
            var s2 = "s2";
            var s3 = 's1\'flutter';
            var s4 = "s2'flutter";
        }'
        
        # 可以使用三个单引号 ''' 或者双引号表示多行字符串
        {
            // 2: 表示多行字符串的方式
            var message = '''
            哈哈哈
            嘿嘿嘿
            哟哟哟
            一一一
            ''';
        }
        '
        
        # 字符串拼接
        var name = 'bobo';
        var age = 18;
        var height = 1.88;
        // 拼接表达式：
        'my name is ${name}, age is $age, height is ${height}'
        print('my name is ${name}, age is $age, height is ${height}');
        
        
******* 集合类型
    
      - 对于集合类型、dart则内置了最常用的三种：List / Set / Map
     --------------------------------------------  
    ##### List 定义：
      // 使用类型推导定义
      {
          var letters = ['a', 'b', 'c', 'd'];
          print(${letters} ${letters.runtimetype});
      }
      
      // 明确指定类型定义
      {
          List<int> numbers = [1, 2, 3, 4];
          print($numbers ${numbers.runtimeType})
      }
    --------------------------------------------  
    ##### Set 定义：
        - 其实Set就是将 [] 换成 {} 
        - Set 和 List最大的不同就是： Set是无序的、并且元素是不重复的。
        
        // 1: 使用类型推导定义
        {
            var lettersSet = {'a', 'b', 'c', 'd'};
            print($lettersSet ${lettersSet.runtimeType});
        }
        
        // 2: 明确指定类型定义
        {
            Set<int> numbersSet = {1, 2, 3, 4};
            print($numbersSet ${numbersSet.runtimeType});
        }
    --------------------------------------------     
    ##### Map(字典) 定义：
        
        // 1: 使用类型推导定义
        {
            var infoMap = {'name': 'bobo', 'age': 18};
            print($infoMap ${infoMap.runtimeType});
        }
        
        // 2: 明确指定类型定义
        {
            Map<String, Object> infoMap = {'name': 'bobo', 'height': 1.88};
            print($infoMap ${infoMap.runtimeType});
        }
    -------------------------------------------- 
    
     
     
    #####  集合的常见操作
    
    // 1: 所有集合都支持获取长度 length
    {
        print(letters.length);
        print(lettersSet.length);
        print(infoMap.length);
    }
    
    // 2: 对于List、Set集合具有添加、删除、包含的操作
    并且对于List来说、因为元素是有序的、所以还提供了一个删除指定索引位置上的元素。
    {
        // 1: 添加 add
        numbers.add(5);
        numbersSet.add(6);
        print('$numbers ${numbersSet}'); // [1, 2, 3, 4, 5] {1, 2, 3, 4, 6}
        
        // 2: 删除 remove
        numbers.remove(1);
        numbersSet.remove(6);
        print('${numbers} ${numbersSet}'); // [2, 3, 4, 5] {1, 2, 3, 4}
        
        // 3: 包含 contains
        print(numbers.contains(2)); // true
        print(numbersSet.contains(1)); // true
        
        // 4: List 根据index删除元素
        numbers.removeAt(3);
        print('$numbers'); // [2, 4, 5]
    }
    
    
    // 3: Map 的操作
        - 由于它有key 和 value、因此无论是读取值还是操作、都要明确是基于key的、还是基于value的、还是基于key/value的。
        {
            // 1: 根据key 获取value
            final value = infoMap['name'];
            print($value); // bobo
            
            // 2: 获取所有的entries
            final entries = 
        }
    

6: flutter 函数

flutter 函数定义-参数-默认参数

7: flutter 运算符、类和对象、类的构造方法

flutter 运算符、类和对象、类的构造方法

8: