Dart语言

2019年7月18日

1.https://www.kancloud.cn/marswill/dark2_document/709087

2019年10月9日

1.必选参数

其实可以这样写 [不加中括号就是必选参数]

Tick(this.duration);

//老的写法

final int duration;
Tick({@required this.duration}) : super([duration]);

1.1新的语法糖写法

class Point {
  var x, y;
  //实例方法
  Point(this.x, this.y);
// 类的命名构造方法
  Point.origin() {
    x = 0;
    y = 0;
  }
  scale(factor) => new Point(x * factor, y * factor);
  operator +(p) => new Point(x + p.x, y + p.y);
  //静态方法
  static distance(p1, p2) {
    var dx = p1.x - p2.x;
    var dy = p1.y - p2.y;
    return sqrt(dx * dx + dy * dy);
  }
}

老的写法

class Point2 {
  var x, y;
  Point(a, b) {
    x = a;
    y = b;
  }
}

2.函数等价写法

twice(x) => x * 2;
twice2(x) {
  return x * 2;
}

3.符号(Symbol)

Dart中的符号(Symbol)是不透明的动态字符串名称，用于反映库中的元数据。简而言之，符号是一种存储人类可读字符串与优化供计算机使用的字符串之间关系的方法。 (flutter可能把反射禁止了)

反射机制。

2019年9月11日

一.变量

注意：

1.没有赋初值的变量都会有默认值null

2.字符串单引号和双引号都是可以的。

var a = 1;
int b = 10;
String s = 'hello';
dynamic c = 0.5;

3.数据类型

// numbers
var a = 0;
int b = 1;
double c = 0.1;
num x;
// strings
var s1 = 'hello';
String s2 = "world";
// booleans
var real = true;
bool isReal = false;
// lists
var arr = [1, 2, 3, 4, 5];
List<String> arr2 = ['hello', 'world', "123", "456"];
List<dynamic> arr3 = [1, true, 'haha', 1.0];
// maps
var map = new Map();
map['name'] = 'zhangsan';
map['age'] = 10;
Map m = new Map();
m['a'] = 'a’;
var gifts = {
  // Key:    Value
  'first': 'partridge',
  'second': 'turtledoves',
  'fifth': 'golden rings'
};
var nobleGases = {
  2: 'helium',
  10: 'neon',
  18: 'argon',
};
//runes，Dart 中 使用runes 来获取UTF-32字符集的字符。String的 codeUnitAt and codeUnit属性可以获取UTF-16字符集的字符
var clapping = '\u{1f44f}';
print(clapping); // 打印的是拍手emoji的表情
// symbols
print(#s == new Symbol("s")); // true

二.常量

var count = 10;
final Num = count;  // final 只能赋值一次
const Num1 = 10; // const赋值必须是编译时常量

final和const的区别：[简单理解final是最后一次的一次]

区别一：final 要求变量只能初始化一次，并不要求赋的值一定是编译时常量，可以是常量也可以不是。而 const 要求在声明时初始化，并且赋值必需为编译时常量。

区别二：final 是惰性初始化，即在运行时第一次使用前才初始化。而 const 是在编译时就确定值了。

2019年9月12日

1.函数

注意 可以有返回值也可以不写返回值

  // 声明返回值
  int add(int a, int b) {
    return a + b;
  }
// 不声明返回值
  add2(int a, int b) {
    return a + b;
  }
// =>是return语句的简写
  add3(a, b) => a + b;

2.命名参数 【命名参数参数】

sayHello({String name}) {
  print("hello, my name is $name");
}
sayHello2({name}) {
  print("hello2, my name is $name");
}
sayHello3({name: String}) {
  print("hello3, my name is $name");
}
sayHello(name: 'zhangsan');
sayHello2(name: 'zhangsan');
sayHello3(name: 'zhangsan');
sayHello();

3.位置参数 ,位置参数只能放在函数的参数列表的最后面【可选可不选】

sayHello(String name, int age, [String hobby]) {
  // 位置参数可以有多个，比如[String a, int b]
  StringBuffer sb = new StringBuffer();
  sb.write("hello, this is $name and I am $age years old");
  if (hobby != null) {
    sb.write(", my hobby is $hobby");
  }
  print(sb.toString());
}
// hello, this is zhangsan and I am 20 years old
sayHello("zhangsan", 20);
// hello, this is zhangsan and I am 20 years old, my hobby is play football
sayHello("zhangsan", 20, "play football");

3.1 总结命名参数{}和位置参数[] 都是可选参数 都可以有多个 【简单点命名参数可读性更好】

如果有多个可选参数用 命名参数会好一点， 位置参数不知道对应哪个

getHttpUrl(String server, String path, {int port: 80, int numRetries: 3}) {
  // ...
}
getHttpUrl('example.com', '/index.html', port: 8080);
getHttpUrl('example.com', '/index.html', port: 8080, numRetries: 5);
getHttpUrl('example.com', '/index.html', numRetries: 5, port: 8080);
//下面这个不太好
getHttpUrl2(String server, String path, [int port = 80, int numRetries = 3]) {
  // ...
}
getHttpUrl2('example.com', '/index.html', 8080);
getHttpUrl2('example.com', '/index.html', 8080, 5);

4.参数默认值 只有在命名参数或位置参数

// 命名参数的默认值
int add({int a, int b = 3}) { // 不能写成：int add({a: int, b: int = 3})
  return a + b;
}
// 位置参数的默认值
int sum(int a, int b, [int c = 3]) {
  return a + b + c;
}

5.命名构造方法

class Point {
  num x, y;
  Point(this.x, this.y);
  // 类的命名构造方法
  Point.origin() {
    x = 0;
    y = 0;
  }
}
void main() {
  var p2 = new Point(1, 2);
  // 调用Point类的命名构造方法origin()
  var p = new Point.origin();
}

5.1如果一个类只有命名的构造方法，在继承时需要注意，如下代码：

class Human {
  String name;
  // 类的命名构造方法
  Human.fromJson(Map data) {
    print("Human's fromJson constructor");
  }
}
class Man extends Human {
  Man.fromJson(Map data) : super.fromJson(data) {
    print("Man's fromJson constructor");
  }
}

6.匿名函数 或闭包（没有函数名称） 类似oc的 block

test(Function callback) {
  callback("hello");
}
test((param) {
  // 打印hello
  print(param);
});

printNum(int a) {
  print("$a");
}
var f1 = printNum;
Function f2 = printNum;
var f3 = (int a) => print("a = $a");
f1(1);
f2(2);
f3(6);

var nums = [1, 2, 3, 4, 5];
//匿名函数写法
sum(List<int> nums) => nums.reduce((a, b) => a + b);
print(sum(nums));

2019年7月18日

一.is 类型判断

// is运算符用于判断一个变量是不是某个类型的数据
// is!则是判断变量不是某个类型的数据
var s = "hello";
print(s is String); // true
var num = 6;
print(num is! String); // true

??= （类似oc的 ？:）

/ ??=运算符 如果 ??= 运算符前面的变量为null，则赋值，否则不赋值
var param1 = "hello", param2 = null;
param1 ??= "world";
param2 ??= "world";
print("param1 = $param1"); // param1 = hello
print("param2 = $param2"); // param2 = world

// ?.运算符

// ?.运算符
var str1 = "hello world";
var str2 = null;
print(str1?.length); // 11
print(str2?.length); // null 
print(str2.length); // 报错

二.级联运算符

class Person {
  eat() {
    print("I am eating...");
  }
  sleep() {
    print("I am sleeping...");
  }
  study() {
    print("I am studying...");
  }
}
main() {
  // 依次打印
  //  I am eating...
  //  I am sleeping...
  //  I am studying...
  new Person()
    ..eat()
    ..sleep()
    ..study();
}

三.for循环

// for语句
List<String> list = ["a", "b", "c"];
for (int i = 0; i < list.length; i++) {
  print(list[i]);
}
for (var i in list) {
  print(i);
}
// 这里的箭头函数参数必须用圆括号扩起来
list.forEach((item) => print(item));

枚举类型

enum Color { red, green, blue }
main() {
  Color aColor = Color.blue;
}

泛型

//list
var names = new List<String>();
names.addAll(['1', '2', '3']);
names = <String>['5', '6'];
//map
var weeks = new Map<String, String>();
weeks.addAll({'M': '一', 'T': '二'});
weeks = <String, String>{'W': '三', 'T': '四'};

四.try catch

// try catch语句
try {
  print(1 ~/ 0);
} catch (e) {
  // IntegerDivisionByZeroException
  print(e);
}
try {
  1 ~/ 0;
} on IntegerDivisionByZeroException {
  // 捕获指定类型的异常
  print("error"); // 打印出error
} finally {
  print("over"); // 打印出over
}

五.类
调用这个类的另一个构造方法 this

class Point {
  num x, y;
  Point(this.x, this.y);
  // 命名构造方法调用了默认的构造方法
  Point.alongXAxis(num x) : this(x, 0);
}

getter/setter方法

class Rectangle {
  num left, top, width, height;
  // 构造方法传入left, top, width, height几个参数
  Rectangle(this.left, this.top, this.width, this.height);
  // right, bottom两个成员变量提供getter/setter方法
  num get right => left + width;
  set right(num value) => left = value - width;
  num get bottom => top + height;
  set bottom(num value) => top = value - height;
}

使用abstract修饰一个类，则这个类是抽象类，抽象类中可以有抽象方法和非抽象方法，抽象方法没有方法体，需要子类去实现

abstract class Doer {
  // 抽象方法，没有方法体，需要子类去实现
  void doSomething();
  // 普通的方法
  void greet() {
    print("hello world!");
  }
}
class EffectiveDoer extends Doer {
  // 实现了父类的抽象方法
  void doSomething() {
    print("I'm doing something...");
  }
}

运算符重载

class Vector {
  num x, y;
  Vector(this.x, this.y);
  Vector operator +(Vector v) => new Vector(x + v.x, y + v.y);
  Vector operator -(Vector v) => new Vector(x - v.x, y - v.y);
  printVec() {
    print("x: $x, y: $y");
  }
}
main() {
  Vector v1 = new Vector(1, 2);
  Vector v2 = new Vector(3, 4);
  (v1 - v2).printVec(); // -2, -2
  (v1 + v2).printVec(); // 4, 6
}

mixins 重复使用类中代码的方式

lass A {
  a() {
    print("A's a()");
  }
}
class B {
  b() {
    print("B's b()");
  }
}
// 使用with关键字，表示类C是由类A和类B混合而构成
class C = A with B;
main() {
  C c = new C();
  c.a(); // A's a()
  c.b(); // B's b()
}

静态成员变量和静态成员方法

// 类的静态成员变量和静态成员方法
class Human {
  static const name = "zhangsan";
  static sayHello() {
    print("hello, this is ${Human.name}");
  }
}
main() {
  Human.sayHello(); // hello, this is zhangsan
  print(Human.name); // zhangsan
}

六.Dart库

dart提供的库

import 'dart:math';

第三方库

//第三方库 使用
import 'package:lib1/lib1.dart';
import 'package:lib2/lib2.dart' as lib2;
// Uses Element from lib1.
Element element1 = Element();
// Uses Element from lib2.
lib2.Element element2 = lib2.Element();

自己写的某个代码导入 ，注意和util.dart是同一个路径

import './util.dart';
main() {
  print(add(1, 2));
}

how hide关键字来导入某个包中的部分功能

// 只导入foo
import 'package:lib1/lib1.dart' show foo;

// 导入除了foo的所有其他部分
import 'package:lib2/lib2.dart' hide foo;

导入包时使用deferred as可以让这个包懒加载，懒加载的包只会在该包被使用时得到加载，而不是一开始就加载

import 'package:greetings/hello.dart' deferred as hello;

七.异步

async和await往往是成对出现的，如果一个方法中有耗时的操作，你需要将这个方法设置成async，并给其中的耗时操作加上await关键字，如果这个方法有返回值，你需要将返回值塞到Future中并返回

Future checkVersion() async {
  var version = await lookUpVersion();
  // Do something with version
}

使用Dart从网络获取数据并打印出来

import 'dart:async';
import 'package:http/http.dart' as http;
Future<String> getNetData() async{
  http.Response res = await http.get("http://www.baidu.com");
  return res.body;
}
main() {
  getNetData().then((str) {
    print(str);
  });
}

八.元数据 （元数据是以@开始的修饰符
@deprecated 被弃用
@override 重写
@proxy 代理