Dart 语法学习（一）

发表于

这是一篇学习笔记

  • 首先，Dart 和众多语言有相似之处， 可以转译为 JavaScript
  • Dart 中定义的所有变量都是对象，不管是数字，方法还是null都是对象，所有的对象都继承自Object类
  • Dart 是强类型的，但是可以不指定类型，Dart 可以自行推断类型，此时可以用 dynamic修饰
  • Dart 没有 Java 中的 public、protected 和 private，如果要表示私有方法，用_开头命名方法即可

    变量

以下三种定义变量的方式效果是一样的

1
2
3
var name = 'Bob';
dynamic name = 'Bob';
String name = 'Bob';

如果变量没有初始化，其默认值都是 null

1
2
int lineCount;
print(lineCount); // 输出 null

常量

可以用 final 或者 const 关键字来修饰不可修改的变量，相当于常量。此时必须在定义的时候初始化，否则会报错，而且只可以被赋值一次。

1
2
final name = 'Bob'; // Without a type annotation
final String nickname = 'Bobby';

or

1
2
const bar = 1000000; // Unit of pressure (dynes/cm2)
const double atm = 1.01325 * bar; // Standard atmosphere

final 和 const 的区别：const 是编译时常量

内置类型

  • Numbers

    • int
    • double

  • Strings

    单引号或者双引号皆可

  • Booleans

    • bool

  • Lists (also known as arrays)

    1
    2
    3
    4
    5
    6
    7
    //可变
    var list = [1, 2, 3]
    list[1] = 1

    //不可变
    var constantList = const [1, 2, 3];
    // constantList[1] = 1; // Uncommenting this causes an error.

  • Maps

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    var gifts = {
      // Key:    Value
      'first': 'partridge',
      'second': 'turtledoves',
      'fifth': 'golden rings'
    };

    //或者这样
    var gifts = Map();
    gifts['first'] = 'partridge';
    gifts['second'] = 'turtledoves';
    gifts['fifth'] = 'golden rings';

  • Runes (for expressing Unicode characters in a string)

    1
    2
    3
    4
    5
    6
    7
    8
    var clapping = '\u{1f44f}';
    print(clapping);
    print(clapping.codeUnits);
    print(clapping.runes.toList());
      
    Runes input = new Runes(
        '\u2665  \u{1f605}  \u{1f60e}  \u{1f47b}  \u{1f596}  \u{1f44d}');
    print(new String.fromCharCodes(input));

  • Symbols

函数

Dart 是面向对象的语言，所以所有的函数方法皆为对象，它们有着共同的类型 Function，这就意味着函数不仅可以用于定义变量，也可以用于函数参数的传递。Dart 的函数与 JavaScript 类似

1
2
3
bool isOdd(int number){
  return number?.isOdd;
}

上面如果参数为 null ，则返回值也为 null。也可以这样写省略类型：

1
2
3
isOdd(number){
  return number?.isOdd;
}

如果函数体只有一个表达式，还可以这样写

1
isOdd(number) => number?.isOdd;

=> expr; 语法是 { return expr;} 的简写

可选参数

可选参数名
1
2
3
4
//定义函数
void enableFlags({bool bold, bool hidden}) {}
//调用的时候
enableFlags(bold: true, hidden: false);

可以用 @required 表示必须传入的参数

1
2
3
4
//定义函数
void enableFlags({bool bold,@required bool hidden}) {}
//调用的时候
enableFlags(hidden: false);
可选参数项
1
2
3
4
5
6
7
8
9
10
11
//定义
String say(String from, String msg, [String device]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  return result;
}

//调用
say('Bob', 'Howdy');
默认参数值
1
2
3
4
5
//定义
void enableFlags({bool bold = false, bool hidden = false}) {...}

// 调用
enableFlags(bold: true);

可选参数默认值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//定义
String say(String from, String msg,
    [String device = 'carrier pigeon', String mood]) {
  var result = '$from says $msg';
  if (device != null) {
    result = '$result with a $device';
  }
  if (mood != null) {
    result = '$result (in a $mood mood)';
  }
  return result;
}
// 调用
say('Bob', 'Howdy');

函数作为参数传递

1
2
3
4
5
6
7
8
void printElement(int element) {
  print(element);
}

var list = [1, 2, 3];

// Pass printElement as a parameter.
list.forEach(printElement);

匿名函数

1
2
3
4
var list = ['apples', 'bananas', 'oranges'];
 list.forEach((item) {
   print('${list.indexOf(item)}: $item');
 });

可以简写成

1
2
3
var list = ['apples', 'bananas', 'oranges'];
list.forEach(
   (item) => print('${list.indexOf(item)}: $item'));

也可以用于变量

1
2
var loudify = (msg) => '!!! ${msg.toUpperCase()} !!!';
print(loudify('hello'));

函数嵌套函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
bool topLevel = true;

void main() {
  var insideMain = true;

  void myFunction() {
    var insideFunction = true;

    void nestedFunction() {
      var insideNestedFunction = true;

	  print('topLevel = $topLevel');
      print('insideMain = $insideMain');
      print('insideFunction = $insideFunction');
      print('insideNestedFunction = $insideNestedFunction');
    }
    nestedFunction();
  }
    myFunction();
}

闭包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/// Returns a function that adds [addBy] to the
/// function's argument.
Function makeAdder(num addBy) {
  return (num i) => addBy + i;
}

void main() {
  // Create a function that adds 2.
  var add2 = makeAdder(2);

  // Create a function that adds 4.
  var add4 = makeAdder(4);

  print(add2(3));
  print(add4(3));
}

返回值

所有的函数都有返回值，如果没有指定，默认返回 null

1
2
foo(){}
print(foo()); //输出 null

函数至此！Dart 语法未完待续…