- dart中的运算符
除法、整除、取模运算
var num = 7; print(num / 3); // 除法操作, 结果2.3333.. print(num ~/ 3); // 整除操作, 结果2; print(num % 3); // 取模操作, 结果1;
- 流程控制
??=赋值操作
dart有一个很多语言都不具备的赋值运算符：
- 当变量为null时，使用后面的内容进行赋值。
- 当变量有值时，使用自己原来的值。
main(List<String> args) {
var name1 = 'coderwhy';
print(name1);
// var name2 = 'kobe';
var name2 = null;
name2 ??= 'james';
print(name2); // 当name2初始化为kobe时，结果为kobe，当初始化为null时，赋值了james
}
条件运算符
Dart中包含一直比较特殊的条件运算符：expr1 ?? expr2
- 如果expr1是null，则返回expr2的结果;
- 如果expr1不是null，直接使用expr1的结果。
var temp = 'why'; var temp = null; var name = temp ?? 'kobe'; print(name);
级联语法
某些时候，我们希望对一个对象进行连续的操作，这个时候可以使用级联语法
class Person {
String name;
void run() {
print("$name is running");
}
void eat() {
print("$name is eating");
}
void swim() {
print("$name is swimming");
}
}
main(List<String> args) {
final p1 = Person();
p1.name = 'why';
p1.run();
p1.eat();
p1.swim();
final p2 = Person()
..name = "why"
..run()
..eat()
..swim();
}
循环操作
基本的for循环
for (var i = 0; i < 5; i++) {
print(i);
}
for in遍历List和Set类型
var names = ['why', 'kobe', 'curry'];
for (var name in names) {
print(name);
}
while和do-while和其他语言一致
break和continue用法也是一致
switch-case
普通的switch使用
注意：每一个case语句，默认情况下必须以一个break结尾
main(List<String> args) {
var direction = 'east';
switch (direction) {
case 'east':
print('东面');
break;
case 'south':
print('南面');
break;
case 'west':
print('西面');
break;
case 'north':
print('北面');
break;
default:
print('其他方向');
}
}
- 类和对象
Dart是一个面向对象的语言，面向对象中非常重要的概念就是类，类产生了对象，Dart对类进行了很多其他语言没有的特性 。
类的定义
在Dart中，定义类用class关键字。
类通常有两部分组成：成员（member）和方法（method）。
定义类的伪代码如下：
class 类名 {
类型 成员名;
返回值类型 方法名(参数列表) {
方法体
}
}
编写一个简单的Person类：
这里有一个注意点: 我们在方法中使用属性(成员/实例变量)时，并没有加this；
Dart的开发风格中，在方法中通常使用属性时，会省略this，但是有命名冲突时，this不能省略；
class Person {
String name;
eat() {
print('$name在吃东西');
}
}
我们来使用这个类，创建对应的对象：
注意：从Dart2开始，new关键字可以省略。
main(List<String> args) {
// 1.创建类的对象
var p = new Person(); // 直接使用Person()也可以创建
// 2.给对象的属性赋值
p.name = 'why';
// 3.调用对象的方法
p.eat();
}
构造方法
普通构造方法
我们知道, 当通过类创建一个对象时，会调用这个类的构造方法。
当类中没有明确指定构造方法时，将默认拥有一个无参的构造方法。
前面的Person中我们就是在调用这个构造方法.
我们也可以根据自己的需求，定义自己的构造方法:
**注意一：**当有了自己的构造方法时，默认的构造方法将会失效，不能使用
当然，你可能希望明确的写一个默认的构造方法，但是会和我们自定义的构造方法冲突；
这是因为Dart本身不支持函数的重载（名称相同, 参数不同的方式）。
class Person {
String name;
int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
@override
String toString() {
return 'name=$name age=$age';
}
}
另外，在实现构造方法时，通常做的事情就是通过**参数给属性**赋值
为了简化这一过程, Dart提供了一种更加简洁的语法糖形式.
上面的构造方法可以优化成下面的写法：
Person(String name, int age) {
this.name = name;
this.age = age;
}
// 等同于
Person(this.name, this.age);
命名构造方法
但是在开发中, 我们确实希望实现更多的构造方法，怎么办呢？
因为不支持方法（函数）的重载，所以我们没办法创建相同名称的构造方法。
我们需要使用命名构造方法:
class Person {
String name;
int age;
Person() {
name = '';
age = 0;
}
// 命名构造方法
Person.withArgments(String name, int age) {
this.name = name;
this.age = age;
}
@override
String toString() {
return 'name=$name age=$age';
}
}
// 创建对象
var p1 = new Person();
print(p1);
var p2 = new Person.withArgments('why', 18);
print(p2);
在之后的开发中, 我们也可以利用命名构造方法，提供更加便捷的创建对象方式:
比如开发中，我们需要经常将一个Map转成对象，可以提供如下的构造方法
// 新的构造方法
Person.fromMap(Map<String, Object> map) {
this.name = map['name'];
this.age = map['age'];
}
// 通过上面的构造方法创建对象
var p3 = new Person.fromMap({'name': 'kobe', 'age': 30});
print(p3);
初始化列表
我们来重新定义一个类Point, 传入x/y，可以得到它们的距离distance:
class Point {
final num x;
final num y;
final num distance;
// 错误写法
// Point(this.x, this.y) {
// distance = sqrt(x * x + y * y);
// }
// 正确的写法
Point(this.x, this.y) : distance = sqrt(x * x + y * y);
}
上面这种初始化变量的方法, 我们称之为初始化列表(Initializer list)
常量构造方法
在某些情况下，传入相同值时，我们希望返回同一个对象，这个时候，可以使用常量构造方法.
默认情况下，创建对象时，即使传入相同的参数，创建出来的也不是同一个对象，看下面代码:
这里我们使用identical(对象1, 对象2)函数来判断两个对象是否是同一个对象:
main(List<String> args) {
var p1 = Person('why');
var p2 = Person('why');
print(identical(p1, p2)); // false
}
class Person {
String name;
Person(this.name);
}
但是, 如果将构造方法前加const进行修饰，那么可以保证同一个参数，创建出来的对象是相同的
这样的构造方法就称之为常量构造方法。
main(List<String> args) {
var p1 = const Person('why');
var p2 = const Person('why');
print(identical(p1, p2)); // true
}
class Person {
final String name;
const Person(this.name);
}
常量构造方法有一些注意点:
- 拥有常量构造方法的类中，所有的成员变量必须是final修饰的.
- 为了可以通过常量构造方法，创建出相同的对象，不再使用 new关键字，而是使用const关键字
如果是将结果赋值给const修饰的标识符时，const可以省略.
- 库的引用
在Dart中，你可以导入一个库来使用它所提供的功能。
库的使用可以使代码的重用性得到提高，并且可以更好的组合代码。
Dart中任何一个dart文件都是一个库，即使你没有用关键字library声明
import语句用来导入一个库，后面跟一个字符串形式的Uri来指定表示要引用的库，语法如下：
import '库所在的uri';
常见的库URI有三种不同的形式
来自dart标准版，比如dart:io、dart:html、dart:math、dart:core(但是这个可以省略)
//dart:前缀表示Dart的标准库，如dart:io、dart:html、dart:math
import 'dart:io';
使用相对路径导入的库，通常指自己项目中定义的其他dart文件
//当然，你也可以用相对路径或绝对路径的dart文件来引用 import 'lib/student/student.dart';
Pub包管理工具管理的一些库，包括自己的配置以及一些第三方的库，通常使用前缀package
//Pub包管理系统中有很多功能强大、实用的库，可以使用前缀 package:
import 'package:flutter/material.dart';
库文件中内容的显示和隐藏
如果希望只导入库中某些内容，或者刻意隐藏库里面某些内容，可以使用show和hide关键字
**show关键字：**可以显示某个成员（屏蔽其他）
**hide关键字：**可以隐藏某个成员（显示其他）
import 'lib/student/student.dart' show Student, Person; import 'lib/student/student.dart' hide Person;
库中内容和当前文件中的名字冲突
当各个库有命名冲突的时候，可以使用as关键字来使用命名空间
import 'lib/student/student.dart' as Stu; Stu.Student s = new Stu.Student();
库的定义
library关键字
通常在定义库时，我们可以使用library关键字给库起一个名字。
但目前我发现，库的名字并不影响导入，因为import语句用的是字符串URI
library math;
part关键字
在之前我们使用student.dart作为演练的时候，只是将该文件作为一个库。
在开发中，如果一个库文件太大，将所有内容保存到一个文件夹是不太合理的，我们有可能希望将这个库进行拆分，这个时候就可以使用part关键字了
不过官方已经不建议使用这种方式了：
https://dart.dev/guides/libraries/create-library-packages
mathUtils.dart文件
part of "utils.dart";
int sum(int num1, int num2) {
return num1 + num2;
}
dateUtils.dart文件
part of "utils.dart";
String dateFormat(DateTime date) {
return "2020-12-12";
}
utils.dart文件
part "mathUtils.dart"; part "dateUtils.dart";
test_libary.dart文件
import "lib/utils.dart";
main(List<String> args) {
print(sum(10, 20));
print(dateFormat(DateTime.now()));
}
export关键字
官方不推荐使用part关键字，那如果库非常大，如何进行管理呢？
将每一个dart文件作为库文件，使用export关键字在某个库文件中单独导入
mathUtils.dart文件
int sum(int num1, int num2) {
return num1 + num2;
}
dateUtils.dart文件
String dateFormat(DateTime date) {
return "2020-12-12";
}
utils.dart文件
library utils;
export "mathUtils.dart";
export "dateUtils.dart";
test_libary.dart文件
import "lib/utils.dart";
main(List<String> args) {
print(sum(10, 20));
print(dateFormat(DateTime.now()));
}
