示例:
main(List<String> args) {
print('Hello World');
}
明确声明变量的方式：变量类型 变量名称 = 赋值;
示例代码:
String name = 'coderwhy';
int age = 18;
double height = 1.88;
print('${name}, ${age}, ${height}');
在dart中如果插入字符只有变量 比如name 而不是 person.name 可以省略{}；
'$name, $age, $height'；
注意事项: 定义的变量可以修改值, 但是不能赋值其他类型
String content = 'Hello Dart'; content = 'Hello World'; // 正确的 content = 111; // 错误的, 将一个int值赋值给一个String变量
类型推导声明变量的方式, 格式如下:
var/dynamic/const/final 变量名称 = 赋值;
var的使用
var name = 'coderwhy'; name = 'kobe'; print(name.runtimeType); // 结果为 String runtimeType用于获取变量当前的类型
var的错误用法:
var age = 18; age = 'why'; // 不可以将String赋值给一个int类型
dynamic的使用
如果确实希望这样做,可以使用dynamic来声明变量:
dynamic name = 'coderwhy'; print(name.runtimeType); // String name = 18; print(name.runtimeType); // int
但是在开发中, 通常情况下不使用dynamic, 因为类型的变量会带来潜在的危险；
final&const的使用
final和const都是用于定义常量的, 也就是定义之后值都不可以修改
final name = 'coderwhy'; name = 'kobe'; // 错误做法 const age = 18; age = 20; // 错误做法
String getName() {
return 'coderwhy';
}
main(List<String> args) {
const name = getName(); // 错误的做法, 因为要执行函数才能获取到值
final name = getName(); // 正确的做法
}
final和const小案例:
// const time = DateTime.now(); // 错误的赋值方式 final time = DateTime.now(); print(time); // 2019-04-05 09:02:54.052626 sleep(Duration(seconds: 2)); print(time); // 2019-04-05 09:02:54.052626
const放在赋值语句的右边，可以共享对象，提高性能:
class Person {
const Person();
}
main(List<String> args) {
final a = const Person();
final b = const Person();
print(identical(a, b)); // true
final m = Person();
final n = Person();
print(identical(m, n)); // false
}
数字类型
// 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} ${num2StrD.runtimeType}'); // 123.46 String
布尔类型
布尔类型中,Dart提供了一个bool的类型, 取值为true和false
ar isFlag = true;
print('$isFlag ${isFlag.runtimeType}');
//注意: Dart中不能判断非0即真, 或者非空即真
//Dart的类型安全性意味着您不能使用if(非booleanvalue)或assert(非booleanvalue)之类的代码。
var message = 'Hello Dart';
// 错误的写法
if (message) {
print(message)
}
字符串类型
Dart字符串是UTF-16编码单元的序列。您可以使用单引号或双引号创建一个字符串，可以使用三个单引号或者双引号表示多行字符串:
// 1.定义字符串的方式 var s1 = 'Hello World'; var s2 = "Hello Dart"; var s3 = 'Hello\'Fullter'; var s4 = "Hello'Fullter"; // 2.表示多行字符串的方式 var message1 = ''' 哈哈哈 呵呵呵 嘿嘿嘿''';
集合类型
对于集合类型，Dart则内置了最常用的三种：List / Set / Map。
其中，List可以这样来定义：
// List定义
// 1.使用类型推导定义
var letters = ['a', 'b', 'c', 'd'];
print('$letters ${letters.runtimeType}');
// 2.明确指定类型
List<int> numbers = [1, 2, 3, 4];
print('$numbers ${numbers.runtimeType}');
其中，set可以这样来定义：
其实，也就是把[]换成{}就好了。
Set和List最大的两个不同就是：Set是无序的，并且元素是不重复的。
// Set的定义
// 1.使用类型推导定义
var lettersSet = {'a', 'b', 'c', 'd'};
print('$lettersSet ${lettersSet.runtimeType}');
// 2.明确指定类型
Set<int> numbersSet = {1, 2, 3, 4};
print('$numbersSet ${numbersSet.runtimeType}');
最后，Map是我们常说的字典类型，它的定义是这样的：
// Map的定义
// 1.使用类型推导定义
var infoMap1 = {'name': 'why', 'age': 18};
print('$infoMap1 ${infoMap1.runtimeType}');
// 2.明确指定类型
Map<String, Object> infoMap2 = {'height': 1.88, 'address': '北京市'};
print('$infoMap2 ${infoMap2.runtimeType}');
集合的常见操作
了解了这三个集合的定义方式之后，我们来看一些最基础的公共操作
第一类，是所有集合都支持的获取长度的属性length：
// 获取集合的长度 print(letters.length); print(lettersSet.length); print(infoMap1.length);
第二类, 是添加/删除/包含操作
并且，对List来说，由于元素是有序的，它还提供了一个删除指定索引位置上元素的方法
List<int> numbers = [1, 2, 3, 4];
Set<int> numbersSet = {1, 2, 3, 4};
// 添加/删除/包含元素
numbers.add(5);
numbersSet.add(5);
print('$numbers $numbersSet');//[1, 2, 3, 4, 5] {1, 2, 3, 4, 5}
numbers.remove(1);
numbersSet.remove(1);
print('$numbers $numbersSet');//[2, 3, 4, 5] {2, 3, 4, 5}
print(numbers.contains(2));//true
print(numbersSet.contains(2));//true
// List根据index删除元素
numbers.removeAt(3);
print('$numbers');//[2, 3, 4]
第三类，是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}
函数的参数可以分成两类: 必须参数和可选参数
前面使用的参数都是必须参数.
命名可选参数: {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
命名可选参数, 可以指定某个参数是必传的(使用@required, 有问题)
// 命名可选参数的必须
printInfo3(String name, {int age, double height, @required String address}) {
print('name=$name age=$age height=$height address=$address');
}
参数默认值
参数可以有默认值, 在不传入的情况下, 使用默认值
注意, 只有可选参数才可以有默认值, 必须参数不能有默认值
// 参数的默认值
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('kobe');
}
// 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');
}