代码练习：DartPad
对比语言：JavaScript
1、程序入口
JavaScript：没有入口函数。
Dart：必须有一个main()函数作为程序入口。
2、控制台输出
JavaScript：console.log("hello,world!");
Dart：print('hello,world!');
3、dart数据类型
//int （一般占8个字节）
var count = 1; or int count = 1；
//double （一般占8个字节）
var a = 0.1; or double a =0.1;
//num（int和double的父类型，一般占8个字节）
//String
var s = "dart"; or String s = 'dart';
//bool
var find = true; or bool find = true;
//List
var arr = [1,2,3,4,5];
List<String> arr2 = ['hello','world',"123","456"];
List flybyObjects = ['Jupiter', 'Saturn', 'Uranus', 'Neptune'];
//Map
var image = new Map();
var image = { 'tags': ['saturn'], 'url': '//path/to/xxx.jpg'};
var map={"a":"1","b":2,"c":3,4:5};
Map image = { 'tags': ['saturn'], 'url': '//path/to/xxx.jpg'};
注意：dart没有long和float类型
4、变量
JavaScript：无法定义变量类型，js没有这种声明方式：int count = 1。
Dart：是类型安全的，你可以明确指定某个变量的类型，如int bool String，也可以用var或 dynamic来声明一个变量。尽管类型是必须的，但是dart的某些类型注释是可选的，因为dart会执行类型推断。Dart 没有 public、private、protected 这些关键字，变量名以"_"开头意味着对它的 lib 是私有的。
例如：
//JavaScript
var name = "JavaScript";
//Dart
String name1 = 'Dart'; 或者 var name2 = 'dart';都是可以接受的，其中name2进行了类型推断。
5、默认值
JavaScript：未初始化的变量默认值是undefined。
Dart：未初始化的变量默认值是null。
注意，数字在dart语言中也被当成对象，所以即使是带有数字类型的对象没有给出初始化默认值，那么该对象值就是“null”。
//JavaScript
var name; // ==undefined
//Dart
String name; // ==null
int a; // ==null
6、检查null或零
JavaScript：1或者任何非null对象的值被视为true。
Dart：只有布尔值为true才被视为true。
// is运算符用于判断一个变量是不是某个类型的数据
// is!则是判断变量不是某个类型的数据
var s ="hello";
print(s is String);// true
var num =6;
print(num is! String);// true
// ~/是取整运算符，如果使用/则是除法运算，不取整
int k =1; int j =2;
print(k / j);// 0.5
print(k ~/ j);// 0
// as运算符类似于Java中的cast操作，将一个对象强制类型转换
(empasPerson).teach();
// ??=运算符 如果 ??= 运算符前面的变量为null，则赋值，否则不赋值
var param1 ="hello", param2 =null;
param1 ??="world";
param2 ??="world";
print("param1 = $param1");// param1 = hello
print("param2 = $param2");// param2 = world
// ?.运算符在左边为null的情况下会阻断右边函数的调用
var str1 ="hello world";
var str2 =null;
print(str1?.length);// 11
print(str2?.length);// null
print(str2.length);// 报错
//??运算符在左侧表达式为null的时候为其设置右边为默认值
print(null??false);//false
print(false??11);//false
print(true??false);//true
7、final和const
如果你绝不想改变一个变量，使用final或const，不要使用var或其他类型，一个被final修饰的变量只能被赋值一次，一个被const修饰的变量是一个编译时常量（const常量毫无疑问也是final常量）。可以这么理解：final修饰的变量是不可改变的，而const修饰的表示一个常量。
注意：实例变量可以是final的但不能是const的
说明：
var count =10;
final Num = count;// final 只能赋值一次
const Num1 =10;// const赋值必须是编译时常量
final和const的区别：
区别一：final 要求变量只能初始化一次，并不要求赋的值一定是编译时常量，可以是常量也可以不是。而 const 要求在声明时初始化，并且赋值必需为编译时常量。
区别二：final 是惰性初始化，即在运行时第一次使用前才初始化。而 const 是在编译时就确定值了。
8、function
//JavaScript
function fn(){
return true;
}
//Dart
// 声明返回值
int add(int a,int b){
return a + b;
}
// 不声明返回值
add2(int a,int b) {
return a + b;
}
// =>是return语句的简写
add3(a, b) => a + b;
main() {
print(add(1,2));// 3
print(add2(2,3));// 5
print(add3(1,2));// 3
}
9、命名参数、位置参数、参数默认值
命名参数
定义命名参数时，你可以以 {type paramName} 或者 {paramName: type} 两种方式声明参数，而调用命名参数时，需要以 funcName(paramName: paramValue) 的形式调用
注意：命名参数被{ }括了起来，类似于map的形式，调用的时候需要 参数名：参数值
sayHello({String name}) {
print("hello, my name is $name");
}
sayHello2({name: String}) {
print("hello, my name is $name");
}
main() {
// 打印 hello, my name is zhangsan
sayHello(name:'zhangsan');
// 打印 hello, my name is wangwu
sayHello2(name:'wangwu');}
位置参数
使用中括号[]括起来的参数是函数的位置参数，代表该参数可传可不传，位置参数只能放在函数的参数列表的最后面，如下代码所示：
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());
}
main() {
// 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");
}
参数默认值
// 命名参数的默认值
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;
}
10、类
类的定义与构造方法
Dart中的类没有访问控制，所以你不需要用private, protected, public等修饰成员变量或成员函数，一个简单的类如下代码所示：
class Person{
String name;
int age;
String gender;
Person(this.name,this.age,this.gender);
sayHello() {
print("hello, this is $name, I am $age years old, I am a $gender");
}
}
上面的Person类中有3个成员变量，一个构造方法和一个成员方法，看起来比较奇怪的是Person的构造方法，里面传入的3个参数都是this.xxx，而且是没有大括号{}包裹的方法体，这种语法是Dart比较独特而简洁的构造方法声明方式，它等同于下面的代码：
Person(String name, int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
要调用Person类的成员变量或成员方法，可以用下面的代码：
var p =new Person("zhangsan",20,"male");
p.sayHello();// hello, this is zhangsan, I am 20 years old, I am a male
p.age =50;
p.gender ="female";
p.sayHello();// hello, this is zhangsan, I am 50 years old, I am a female
类除了有跟类名相同的构造方法外，还可以添加命名的构造方法，如下代码所示：
class Point{
num x, y;
Point(this.x,this.y);
// 类的命名构造方法
Point.origin() {
x =0;
y =0;
}
}
main() {
// 调用Point类的命名构造方法origin()
var p =new Point.origin();
var p2 =new Point(1,2);
}
Dart中使用extends关键字做类的继承，如果一个类只有命名的构造方法，在继承时需要注意，如下代码：
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");
}
}
由于Human类没有默认构造方法，只有一个命名构造方法fromJson，所以在Man类继承Human类时，需要调用父类的fromJson方法做初始化，而且必须使用Man.fromJson(Map data) : super.fromJson(data)这种写法，而不是像Java那样将super写到花括号中。
有时候你仅仅只是在某个类的构造方法中，调用这个类的另一个构造方法，你可以这么写：
class Point{
num x, y;
Point(this.x,this.y);
// 命名构造方法调用了默认的构造方法
Point.alongXAxis(num x) :this(x,0);}
类的成员方法
一个类的成员方法是一个函数，为这个类提供某些行为。上面的代码中已经有了一些类的成员方法的定义，这些定义方式跟Java很类似，你可以为某个类的成员变量提供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...");
}}
运算符重载
Dart中有类似于C++中的运算符重载语法，比如下面的代码定义了一个向量类，重载了向量的+ -运算：
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 =newVector(1,2);
Vector v2 =new Vector(3,4);
(v1 - v2).printVec(); // -2, -2
(v1 + v2).printVec(); // 4, 6
}
枚举类
使用enum关键字定义一个枚举类，这个语法跟Java类似，如下代码：
enum Color { red, green, blue }
mixins
mixins是一个重复使用类中代码的方式，比如下面的代码：
classA{
a() {
print("A's a()");
}
}
classB{
b() {
print("B's b()");
}
}
// 使用with关键字，表示类C是由类A和类B混合而构成
classC= A with B;
main() {
C c =new C();
c.a(); // A's a()
c.b(); // B's b()
}
静态成员变量和静态成员方法
// 类的静态成员变量和静态成员方法
class Cons{
static const name ="zhangsan";
static sayHello() {
print("hello, this is ${Cons.name}");
}
}
main() {
Cons.sayHello(); // hello, this is zhangsan
print(Cons.name); // zhangsan
}
11、异步编程
Dart和JavaScript一样，都支持单线程执行
JavaScript：promise对象表示异步操作的最终完成（或失败）及其结果值
Dart：future来表示异步操作
12、async和await
async函数声明定义了一个异步函数。
JavaScript：async函数返回一个promise，await运算符用来等待promise。
async _getIPAdress(){
const url = "https://httpbin.org/ip";
const response = await fetch(url);
const json = await respons.json();
const data = await json.origin;
console.log(data);
}
Dart：async函数返回一个future，函数的主体是稍后执行，await运算符用来等待future。
_getIPAdress() async{
final url = "https://httpbin.org/ip";
var request = await HttpRequest.request(url);
String ip = json.decode(request.response.responseText)['origin'];
print(ip);
}
