Dart基础

Dart变量与类型(官方文档)

var,静态类型,null

var
使用var定义变量，类型由编译器推断
静态类型
用静态类型定义变量，编辑器能够使用这些静态类型，提供编译警告
null
未初始化的变量的值是null
所有皆对象
Dart所有类型都是对象类型

基本数据类型

num、bool、String、List、Map

num

1 int和double

int x = 1;
int hex = 0xEEADBEEF;
double y = 1.1;
double exponents = 1.13e5;
int roundY = y.round();

2 运算符

num类的文档说明
 math API文档说明

bool

String

1 字符串内嵌表达式

使用${express}

var s = 'cat';
var s1 = 'this is a uppercased string: ${s.toUpperCase()}';

2 字符串拼接

用+

3 多行字符串

用三个"

var s3 = """This is a
multi-line string.""";

List和Map

List数组，Map字典

var arr1 = ["Tom", "Andy", "Jack"];
var arr2 = List.of([1,2,3]);
arr2.add(499);
arr2.forEach((v) => print('${v}'));
  
var map1 = {"name": "Tom", 'sex': 'male'}; 
var map2 = new Map();
map2['name'] = 'Tom';
map2['sex'] = 'male';
map2.forEach((k,v) => print('${k}: ${v}'));

容器类型

容器里的元素需要有类型的，Dart判断好类型后，后续像容器加入的元素要满足该类型，否则编译失败

初始化时添加约束

var arr1 =<String>['Tom', 'Andy', 'Jack'];
var arr2 = new List<int>.of([1,2,3]);

var map1 = <String,String>{'name': 'Tom','sex': 'male',};

可以拿到runtimeType
sth.runtimeType为变量运行时的类型

常量定义

const final

const是指编译期间确定的值，final是可以在运行时确定的，确定后不能变

流程控制语法

if-else、for、while、do-while、break/continue、switch-case、assert

Dart函数、类和运算符

函数

可以作为参数传递，支持箭头函数，可命名参数和可选参数(完成重载的功能)

可命名参数和可选参数(Flutter会大量使用)

可选命名参数：加上{},可忽略参数，加上[]

意思是，少传了这两个参数，不会报错。

//要达到可选命名参数的用法，那就在定义函数的时候给参数加上 {}
void enable1Flags({bool bold, bool hidden}) => print("$bold , $hidden");

//定义可选命名参数时增加默认值
void enable2Flags({bool bold = true, bool hidden = false}) => print("$bold ,$hidden");

//可忽略的参数在函数定义时用[]符号指定
void enable3Flags(bool bold, [bool hidden]) => print("$bold ,$hidden");

//定义可忽略参数时增加默认值
void enable4Flags(bool bold, [bool hidden = false]) => print("$bold ,$hidden");

//可选命名参数函数调用
enable1Flags(bold: true, hidden: false); //true, false
enable1Flags(bold: true); //true, null
enable2Flags(bold: false); //false, false

//可忽略参数函数调用
enable3Flags(true, false); //true, false
enable3Flags(true,); //true, null
enable4Flags(true); //true, false
enable4Flags(true,true); // true, true

类

类似Java的声明，类似C++的初始化列表，构造函数重定向（对比其和Javascript的不同），类的复用

初始化列表
在构造函数后,用一个: 后面对变量进行操作
重定向构造函数
写一个函数，带有构造的作用，这个函数的初始化列表调用原构造函数

class Point {
  num x, y, z;
  Point(this.x, this.y) : z = 0; // 初始化变量z
  Point.bottom(num x) : this(x, 0); // 重定向构造函数
  void printInfo() => print('($x,$y,$z)');
}

var p = Point.bottom(100);
p.printInfo(); // 输出(100,0,0)

类的复用

其他类变量在本类中复用，继承、接口和混入(Mixin)

继承(extends)
子类由父类派生，会自动获取父类的成员变量和方法实现，子类可以根据需要覆写构造函数及父类方法；
接口实现(implements)
子类获取到的仅仅是接口的成员变量符号和方法符号，需要重新实现成员变量，以及方法的声明和初始化，否则编译器会报错
混入(with)

class Coordinate with Point {
}

var yyy = Coordinate();
print (yyy is Point); //true
print(yyy is Coordinate); //true

运算符

?. ??= ?? 三种运算符

?. 运算符
p?.printInfo() ，表示 p 为 null 的时候跳过，避免抛出异常。
??= 运算符
默认值兜底，如果 a 为 null，则给 a 赋值 value，否则跳过. a??=value
?? 运算符
如果 a 不为 null，返回 a 的值，否则返回 b，a ?? b

自行定义运算符

operator关键字

class Vector {
  num x, y;
  Vector(this.x, this.y);
  // 自定义相加运算符，实现向量相加
  Vector operator +(Vector v) =>  Vector(x + v.x, y + v.y);
  // 覆写相等运算符，判断向量相等
  bool operator == (dynamic v) => x == v.x && y == v.y;
}

final x = Vector(3, 3);
final y = Vector(2, 2);
final z = Vector(1, 1);
print(x == (y + z)); //  输出true

Dart的核心特性

类抽象改造

构造函数体、公共类和super

利用语法糖和初始化列表省去构造函数函数体

//修改前
//定义商品Item类
class Item {
  double price;
  String name;
  Item(name, price) {
    this.name = name;
    this.price = price;
  }
}
//定义购物车类
class ShoppingCart {
  String name;
  DateTime date;
  String code;
  List<Item> bookings;
  ShoppingCart(name, code) {
    this.name = name;
    this.code = code;
    this.date = DateTime.now();
  }
}
//修改后
class Item {
  double price;
  String name;
  Item(this.name, this.price);
}
class ShoppingCart {
  String name;
  DateTime date;
  String code;
  List<Item> bookings;
  //删掉了构造函数函数体
  ShoppingCart(this.name, this.code) : date = DateTime.now();
...
}

抽出公共类

//公共类
class Meta {
  double price;
  String name;
  Meta(this.name, this.price);
}
class Item extends Meta{
  Item(name, price) : super(name, price);
}
//super函数这里作为初始化所用，用于写构造函数时初始化父类的属性
class ShoppingCart extends Meta{
  DateTime date;
  String code;
  List<Item> bookings;
  
  double get price {...}
  ShoppingCart(name, this.code) : date = DateTime.now(),super(name,0);
  getInfo() {...}
}

运算符重载

Dart的数组形式非常发达，所以尽量少用遍历。

多行字符串、字符串插入表达式

getInfo () => '''
购物车信息:
-----------------------------
  用户名: $name
  优惠码: $code
  总价: $price
  Date: $date
-----------------------------
''';

初始化函数调用方式

可以以 key:value的形式写初始化函数的参数

声明函数时,给参数加{}，使用的时候，直接出键值对

//
class ShoppingCart{
 String name;
 String code;
 ShoppingCart({this.name,this.code})
}
ShoppingCart sc = ShoppingCart(name:'张三',code:'123456')

允许无参数(这里和js有对比，js对于null比较松散)

class ShoppingCart extends Meta{
  ...
  //默认初始化方法，转发到withCode里,这里注意参数有{}，是对于键值对的设计
  ShoppingCart({name}) : this.withCode(name:name, code:null);
  //withCode初始化方法，使用语法糖和初始化列表进行赋值，并调用父类初始化方法
  ShoppingCart.withCode({name, this.code}) : date = DateTime.now(), super(name,0);

级联运算符

在同一个对象上连续调用多个函数，访问成员变量

void main() {
  ShoppingCart.withCode(name:'张三', code:'123456')
  ..bookings = [Item('苹果',10.0), Item('鸭梨',20.0)]
  ..printInfo();

  ShoppingCart(name:'李四')
  ..bookings = [Item('香蕉',15.0), Item('西瓜',40.0)]
  ..printInfo();
}

混入

混入常常作为公共方法的加入方式。
官方文档地址

posted @ 2021-08-09 23:45 LeonardoDiCaprio 阅读(49) 评论(0) 收藏举报

刷新页面返回顶部

LeonardoDiCaprio