Dart基础语法入门

Hello, Dart
Hello World
void main(List<String> args) {
  print('hello, flutter');
}

Dart语言的入口也是main函数, 并且必须显式进行定义
Dart的入口函数main也是没有返回值的
传递给main的命令行参数, 是通过List完成的
从字面值就可以理解List是Dart中的集合类型
其中的每一个String都表示传递给main的一个参数;
定义字符串的时候, 可以使用单引号或双引号
每行语句必须使用分号结尾, 很多语言并不需要分号, 比如swift
定义变量
明确声明(Explicit)
明确声明变量的方式, 格式如下:

变量类型 变量名称 = 赋值;
示例代码

String name = 'coderwhy';
int age = 18;
double height = 1.88;
print('${name}, ${age}, ${height}');

注意事项: 定义的变量可以修改值, 但是不能赋值其他类型

String content = 'Hello Dart';
content = 'Hello world';
content = 111; // 错误的, 将一个int值赋值给一个String变量

类型推导(Type Inference)
类型推导声明变量的方式, 格式如下:

var/dynamic/const/final 变量名称 = 赋值;
var的使用
var的使用示例:
runtimeType用于获取变量当前的类型
var name = 'coderwhy';
name = 'lilei';
print(name.runtimeType); // String

var的错误用法:

var age = 18;
age = 'why'; // 不可以将String赋值给一个int类型

dynamic的使用
如果确实希望这样做, 可以使用dynamic来声明变量:
但是在开发中, 通常情况下不使用dynamic, 因为类型的变化会带来潜在的危险

dynamic name = 'coderwhy';
print(name.runtimeType); // String
name = 18;
print(name.runtimeType); // int

final&const的使用
final和const都是用于定义常量的, 也就是定义之后值都不可以修改

final name = 'coderwhy';
name = `lilei`; // 错误做法
const age = 18;
age = 20; // 错误做法

final和const有什么区别呢?

const在赋值时, 赋值的内容必须是在编译期间就确定下来的
final在赋值时, 可以动态获取, 比如赋值一个函数

String getName() {
  return `coderwhy`;
}

main(List<String> args) {
  const name = getName(); // 错误的做法, 因为要执行函数才能获取到值
  final name = getName(): // 正确的做法
}

final和const小案例:

首先, const是不可以赋值为DateTime.now()
其次, final一旦被赋值后就有确定的结果, 不会再次赋值

// const time = DateTime.now(); // 错误的赋值方式
final time = DateTime.now();
print(time); // 2020-9-23 09:15:56.027546

sleep(Duration(seconds: 2));
print(time); // 2020-9-23 09:15:56.027546

数据类型
数字类型
对于数值来说, 我们也不用关心它是否有符号, 以及数据宽度和精度的问题. 只要记着整数用int, 浮点数用double就行了.
不过, 要说明一下的是Dart中的int和double可表示的范围并不是固定的, 它取决于运行Dart的平台.

// 1. 整数类型int

int age = 18;
int hexAge = 0x12;
print(age);
print(hexAge);

// 2.浮点类型double

double height = 1.88;
print(height);
字符串和数字之间的转化:

// 字符串和数字转化
// 1. 字符串转数字

var one = int.parse('111');
var two = double.parse('12.22');
print('${one} ${one.runtimeType}'); // 111 int
print('${two}${two.runtimeType}'); // 12.22 double

// 2. 数字转字符串

var num1 = 123;
var num2 = 123.456;
var num1Str = num1.toString();
var num2Str = num2.toString();
var num2StrD = num2.toStringAsFixed(2); // 保留两位小数
print('${num1Str} ${num1Str.runtimeType}'); // 123 String
print('${num2Str} ${num2Str.runtimeType}'); // 123.456 String
print('${num2StrD} ${num2Str.runtimeType}'); // 123.45 String

布尔类型
布尔类型中, Dart提供了一个bool类型, 取值为true和false

// 布尔类型

var isFlag = true;
print('$isFlag ${isFlag.runtimeType}');

注意: Dart中不能判断非0即真, 或者非空即真
Dart的类型安全性意味着不能使用if(非boolean value)或asset(非boolean value)之类的代码.

var message = 'Hello Dart';
// 错误的写法
if (message) {
  print(message);
}

字符串类型
Dart字符串是UTF-16编码单元的序列. 可以使用单引号或双引号创建一个字符串:

// 1. 定义字符串的方式

var s1 = 'Hello World';
var s2 = 'Hello Dart';
var s3 = 'Hello\'Dart'; // 'Hello'Dart'
var s4 = "Hello'Flutter"; // 'Hello'Dart'

可以使用三个单引号或者双引号表示多行字符串:

// 2. 表示多行字符串的方式

var message1 = '''
哈哈哈
呵呵呵
嘿嘿嘿
''';

字符串和其他变量或表达式拼接: 使用${expression},如果表达式是一个标识符, 那么{}可以省略

// 3.拼接其他变量

var name = 'coderwhy';
var age = 18;
var height = 1.88;
print('my name is ${name}, age is $age, height is $height');

集合类型
集合类型的定义
对于集合类型, Dart则内置了最常用的三种: List/ Set / Map.
其中,List可以这样来定义:

// List定义
// 1. 使用类型推导定义

var letters = ['a', 'b', 'c', 'd'];
print('$letters ${letters.runtimeType}'); // [a, b, c, d] List<String>

// 2. 明确指定类型

 List<int> numbers = [1, 2, 3, 4];
  print('$numbers ${numbers.runtimeType}'); // [1, 2, 3, 4] List<int>

其中, Set可以这样来定义:

其实, 也就是把[]换成{}就好了
Set和List最大的两个不同就是: Set是无序的, 并且元素是不重复的.
// Set的定义
// 1. 使用类型推导定义

  var lettersSet = {'a', 'b', 'c', 'd'};
  print('$lettersSet ${lettersSet.runtimeType}'); // {a, b, c, d} _CompactLinkedHashSet<String>

// 2. 明确指定类型

  Set<int> numbersSet = {1, 2, 3, 4};
  print('$numbersSet ${numbersSet.runtimeType}'); // {1, 2, 3, 4} _CompactLinkedHashSet<int>

最后, Map是我们常说的字典类型, 它的定义是这样的:

// Map的定义
// 1. 使用类型推导定义

  var infoMap1 = {'name' : 'why', "age" : 18};
  print('$infoMap1 ${infoMap1.runtimeType}'); // {name: why, age: 18} _InternalLinkedHashMap<String, Object>

// 2. 明确指定类型

  Map<String, Object> infoMap2 = {'height' : 1.88, 'address' : '北京市'};
  print('$infoMap2 ${infoMap2.runtimeType}'); // {height: 1.88, address: 北京市} _InternalLinkedHashMap<String, Object>

集合的常见操作
了解了这三个集合的定义方式之后, 我们来看一些最基础的公共操作
第一类, 是所有集合都支持的获取长度的属性length:

// 获取集合的长度

print(letters.length);
print(lettersSet.length);
print(infoMap1.length);

第二类, 是添加/删除/包含操作

并且, 对List来说, 由于元素是有序的, 它还提供了一个删除指定索引位置上元素的方法
// 添加/删除/包含元素

numbers.add(5);
numbersSet.add(5);
print('$numbers $numbersSet');

numbers.remove(1);
numbersSet.remove(1);
print('$numbers $numbersSet');

print(numbers.contains(2));
print(numbersSet.contains(2));

// List根据index删除元素

numbers.removeAt(3);
print('$numbers');

第三类, 是Map的操作

由于它有key和value, 因此无论是读取值, 还是操作, 都要明确是基于key的, 还是基于value的, 或者是基于key/value对的.
// Map的操作
// 1. 根据key获取value

print(infoMap1['name']); // why

// 2. 获取所有的entries

print('${infoMap1.entries} ${infoMap1.entries.runtimeType}'); // (MapEntry(name: why), MapEntry(age: 18)) MappedIterable<String, MapEntry<String, Object>>

// 3. 获取所有的keys

print('${infoMap1.keys} ${infoMap1.keys.runtimeType}');  // (name, age) _CompactIterable<String>

// 4. 获取所有的values

print('${infoMap1.values} ${infoMap1.values.runtimeType}'); // (why, 18) _CompactIterable<Object>

// 5. 判断是否包含某个key或者value

print('${infoMap1.containsKey('age')} ${infoMap1.containsValue(18)}'); // true true

// 6. 根据key删除元素

infoMap1.remove('age');
print(${infoMap1}); // {name : why}

函数
函数的基本定义
Dart是一种真正的面向对象语言, 所以即使函数也是对象, 所以也有类型, 类型就是Function.
这也就意味着函数可以作为变量定义或者作为其他函数的参数或者返回值
函数的定义方式:

返回值 函数的名称(参数列表) {
函数体
return 返回值
}
按照上面的定义方式, 我们定义一个完整的函数:

int sum(int num1, int num2) {
  return num1 + num2;
}

Effective Dart建议对公共的API, 使用类型注解, 但是如果我们省略掉了类型, 依然是可以正常工作的

sum(num1, num2) {
  return num1 + num2;
}

另外, 如果函数中只有一个表达式, 那么可以使用箭头语法(arrow syntax)

注意, 这里面只能是一个表达式, 不能是一个语句
sum(num1 ,num2) => num1 + num2;
函数的参数问题
函数的参数可以分为两类: 必须参数和可选参数
前面使用的参数都是必须参数

可选参数
可选参数可以分为命名可选参数和位置可选参数
定义方式:
命名可选参数: {param1, param2, …}
位置可选参数: [param1, param2, …]
命名可选参数的演示:

// 命名可选参数

printInfo1(String name, {int age, double height}) {
  print('name=$name age=$age height=$height');
}

// 调用printInfo1函数

printInfo1('why'); // name=why age=null height=null
printInfo1('why', age: 18); // name=why age=18 height=null
printInfo1('why', age: 18, height: 1.88); // name=why age=18 height=1.88
printInfo1('why', height: 1.88); // name=why age=null height=1.88

位置可选参数的演示:

// 定义位置可选参数

printInfo2(String name, [int age, double height]) {
  print('name=$name age=$age height=$height');
}

// 调用printInfo2函数

printInfo2('why'); // name=why age=null height=null
printInfo2('why', 18); // name=why age=18 height=null
printInfo2('why', 18, 1.88); // name=why age=18 height=1.88

参数默认值
参数是可以有默认值, 在不传入的情况下, 使用默认值

注意: 只有可选参数才可以有默认值, 必选参数不能有默认值
// 参数的默认值

printInfo4(String name, {int age = 18, double height = 1.88}) {
  print('name=$name age=$age height=$height');
}

Dart中的main函数就是一个接受可选的列表参数的, 所以在使用main函数时, 我们可以传入参数, 也可以不传入

函数是一等公民
在很多语言中, 函数并不能作为一等公民来使用, 比如Java/OC, 这种限制让编程不够灵活, 所以现代的编程语言基本都支持函数作为一等公民来使用, Dart也支持. 这就意味着你可以将函数赋值给一个变量, 也可以将函数作为另一个函数的参数或者返回值来使用

main(List<String> args) {
  // 1.将函数赋值给一个变量
  var bar = foo;
  print(bar);

  // 2.将函数作为另一个函数的参数
  test(foo);

  // 3.将函数作为另一个函数的返回值
  var func =getFunc();
  func('lilei');
}

// 1.定义一个函数

foo(String name) {
  print('传入的name:$name');
}

// 2.将函数作为另外一个函数的参数

test(Function func) {
  func('coderwhy');
}

// 3.将函数作为另一个函数的返回值

getFunc() {
  return foo;
}

匿名函数的使用
大部分我们定义的函数都会有自己的名字, 比如前面定义的foo, test函数等等.
但是某些情况下, 给函数命名太麻烦了, 我们可以使用没有名字的函数, 这种函数可以被称之为匿名函数(anonymous function), 也可以叫lambda或者closure.

main(List<String> args) {
  // 1.定义数组
  var movies = ['盗梦空间', '星际穿越', '少年派', '大话西游'];

  // 2.使用forEach遍历: 有名字的函数
  printElement(item) {
    print(item);
  }
  movies.forEach(printElement);

// 3.使用forEach遍历: 匿名函数

  movies.forEach((item) {
    print(item);
  });
  movies.forEach((item) => print(item));
}

词法作用域
Dart中的词法有明确的作用域范围, 它是根据代码的结构({})来决定作用域范围的
优先使用自己作用域中的变量, 如果没有找到, 则一层层向外查找

var name = 'global';
main(List<String> args) {
  // var name = 'main';
  void foo() {
    // var name = 'foo';
    print(name);
  }

  foo();
}

词法闭包
闭包可以访问其词法范围内的变量, 即使函数在其他地方被使用, 也可以正常访问.

main(List<String> args) {
  makeAdder(num addBy) {
    return (num i) {
      return i + addBy;
    };
  }

  var adder2 = makeAdder(2);
  print(adder2(10)); // 12
  print(adder2(6)); // 8

  var adder5 = makeAdder(5);
  print(adder5(10)); // 15
  print(adder5(6)); // 11
}

函数返回值问题
所有函数都返回一个值, 如果没有指定返回值, 则语句返回null; 隐式附加到函数体

main(List<String> args) {
  print(foo()); // null
}

foo() {
  print('foo function');
}

作者：小冰山口
链接：https://www.jianshu.com/p/72b1123db556
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。