Dart 基本语法（一）

一、 Dart 基本语法

1、 Hello Dart

/*
1.Dart语言的入口是main函数，并且必须显示的进行定义
2.打印是使用print
3.每行语句必须适应分号结尾
*/
void main(List<String> args) {
  // List<String> args -> 列表<String> - 泛型
  print('Hello World!!!!');
}
  • 1.Dart语言的入口也是main函数，并且必须显示的进行定义；
  • 2.Dart的入口函数main是没有返回值的；
  • 3.传递给main的命令行参数，是通过List<String>完成的。
    从字面值就可以理解List是Dart中的集合类型。
    其中的每一个String都表示传递给main的一个参数；
  • 4.定义字符串的时候，可以使用单引号或双引号；
  • 5.每行语句必须使用分号结尾，很多语言并不需要分号，比如Swift、JavaScript；

2、 声明变量

2.1 明确声明

变量类型 变量名称 = 赋值;

  String name = "why";
  int age = 18;
  double height = 1.88;

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

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

2.2 类型推导(var/final/const/dynamic)

var/dynamic/const/final 变量名称 = 赋值;

类型推导的方式虽然没有明确的指定变量的类型，但是变量是有自己的明确的类型的

2.2.1 var的使用

var的使用示例:

  • runtimeType用于获取变量当前的类型
  var age = 10;
  age = 30;
  print(age.runtimeType);

var的错误用法:

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

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

dynamic name = 'coderwhy';
print(name.runtimeType); // String
name = 18;
print(name.runtimeType); // int
2.2.3 final & const

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

final name = 'coderwhy';
name = 'kobe'; // 错误做法

const age = 18;
age = 20; // 错误做法

final 和 const的区别

  • const 必须赋值 常量值（编译期间需要一个明确的值）
  • final 可以通过计算/函数来获取一个值（运行期间来确定一个值）
String getName() {
  return 'coderwhy';
}

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

const date1 = DateTime.now(); // 写法错误 const 编译期间需要一个明确的值
final date2 = DateTime.now(); // 写法正确
  • const放在赋值语句的右边，可以共享对象，提高性能:
void main(List<String> args) {
  // 在Dart2.0之后，const 可以省略
  const p1 = Person("why1");
  const p2 = Person("why1");
  const p3 = const Person("why2");

  print(identical(p1, p2)); // p1 和 p2 是同一个对象
  print(identical(p1, p3)); // p1 和 p3 不是同一个对象
}

class Person {
  final String? name; // 此处必须使用final，否则会报错。不能在一个没有final声明变量的类中定义一个常量函数
  const Person(this.name); // 常量构造函数
}

3. 数据类型

3.1 数字类型

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

  // 1.整数类型
  var age = 18;
  int hexage = 0x12;
  print(age);
  print(hexage);

  // 2.浮点类型
  double height = 1.88;
  print(height);

字符串和数字之间的转化:

  // 1.字符串和数字之间的转换
  var one = int.parse('111');
  var two = double.parse('12.22');
  print('${one} ${one.runtimeType}');
  print('${two} ${two.runtimeType}');

  // 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}');
  print('$num2Str ${num2Str.runtimeType}');
  print('${num2StrD} ${num2StrD.runtimeType}');

3.2 布尔类型 (true / false)

  var isflag = true;
  bool isflag2 = false;

  print('$isflag ${isflag.runtimeType}');
  print('$isflag2 ${isflag2.runtimeType}');

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

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

3.3 字符串类型

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

  String s1 = 'Hello World';
  var s2 = "Hello World";
  var s3 = 'Hello\'Flutter';
  var s4 = "Hello'Flutter";
  var msg = '''
  哈哈哈哈
  呵呵呵呵 
  啦啦啦啦''';

  print('$s1');
  print('$s2');
  print('$s3');
  print('$s4');
  print('$msg');

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

  var myname = 'why';
  var myage = 18;
  var myheight = 1.88;
  print("my name is $myname, age is $myage, height is $myheight");

3.4 集合类型

集合类型 List / Set / Map

  • List 定义
  // 使用类型推导
  var letters = ['a', 'b', 'c', 'd', 'a'];
  print('$letters, ${letters.runtimeType}');
  // 明确指定类型
  List<int> numbers = [1, 2, 3, 5];
  print('$numbers, ${numbers.runtimeType}');
  • Set 定义
    其中，set可以这样来定义：其实，也就是把[]换成{}就好了。
    Set和List最大的两个不同就是：Set是无序的，并且元素是不重复的
  // 1.使用类型推导
  var letterSet = {'a', 'b', 'c', 'd'};
  print("$letterSet, ${letterSet.runtimeType}");

  // 2.明确指定类型
  Set<int> numberSet = {1, 2, 3, 4};
  print('$numberSet, ${numberSet.runtimeType}');
  • Map定义 （字典类型）
  // 1.使用类型推导
  var infoMap1 = {'name': 'why', 'age': 18};
  print('$infoMap1 ${infoMap1.runtimeType}');

  // 2.明确指定类型
  Map<String, Object> infoMap2 = {'height': 1.88, 'address': 'beijing'};
  print('$infoMap2, ${infoMap2.runtimeType}');
3.4.1 集合常见操作
  • length 集合长度
  // 1.集合长度length
  print('${letterSet.length}');
  print(letters.length);
  print(infoMap1.length);
  • 添加/删除/包含元素
  // 2.添加/删除/包含元素
  numbers.add(8);
  numberSet.add(8);
  infoMap1["height"] = 1.88;
  print('$numbers,$numberSet');

  numbers.remove(1);
  numberSet.remove(1);
  infoMap1.remove("name");
  print('$numbers $numberSet $infoMap1');

  print(
      '${numbers.contains(8)}, ${numberSet.contains(8)}, ${infoMap1.containsKey("name")}');

  numbers.removeAt(0);
  numbers.removeLast();
  • Map 操作
  // map 操作
  // 1.根据key获取value
  print(infoMap1['name']);
  // 2.获取所有的entries
  print('${infoMap1.entries}');
  // 3.获取所有keys values
  print('${infoMap1.keys}   ${infoMap1.values}');
  // 4.是否包含某个key 或 value
  print(
      '${infoMap1.keys.contains('name')}   ${infoMap1.values.contains('20')}');
  // 5.根据key删除元素
  infoMap1.remove('age');
  print(infoMap1);

二、Dart函数调用

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

1. 函数的基本使用

函数的定义方式:

返回值 函数的名称(参数列表) {
  函数体
  return 返回值
}

按照上面的定义方式, 我们定义一个完整的函数:

// 返回值的类型可以省略（开发中不推荐）
int sum(num num1, num num2) {
  return num1 + num2;
}

返回值的类型可以省略（开发中不推荐）

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

注意, 这里面只能是一个表达式, 不能是一个语句

sum(num1, num2) => num1 + num2;

2. 函数的参数问题

函数的参数可以分成两类: 必须参数和可选参数
前面使用的参数都是必须参数.

// 必选参数：必须传
void sayHello(String name) {
  print(name);
}

2.1 可选参数

可选参数可以分为 命名可选参数 和 位置可选参数

定义方式:
命名可选参数: {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');
}

2.2 参数默认值

参数可以有默认值, 在不传入的情况下, 使用默认值
注意, 只有可选参数才可以有默认值, 必须参数不能有默认值

// 参数的默认值

void sayHello2(String name, [int? age = 29, double? height = 2.0]) {
  print('$name  $age  $height');
}
printInfo4(String name, {int age = 18, double height=1.88}) {
  print('name=$name age=$age height=$height');
}

3、 函数是一等公民

函数是一等公民：可以将函数赋值给一个变量, 也可以将函数作为另外一个函数的参数或者返回值来使用.

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

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

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

void foo() {
  print("foo 调用");
}

void test(Function func) {
  func();
}

Function getFunc() {
  return foo;
}

4、 匿名函数的使用

匿名函数(参数列表){函数体}

void main(List<String> args) {
  test((name) {
    print(name);
  });

  test2((str) {
    print("$str");
    return 10;
  });
}

void test(Function func) {
  func("why");
}

void test2(Function func) {
  int res = func("why");
  print("$res");
}


void main(List<String> args) {
  test1((name, {age, height}) {
    return "$name --- $age -- $height";
  });
}

// 将 函数 String foo(String name,{int age,double height} 作为 test1的参数
test1(String foo(String name, {int? age, double? height})) {
  String res = foo("why", age: 18, height: 2.0);
  print(res);
}

void main(List<String> args) {
  test2((num1, num2) => num1 + num2);
}

typedef Calculate = int Function(int num1, int num2);

test2(Calculate cal) {
  var res = cal(10, 20);
  print(res);
}

void main(List<String> args) {
  var cal = test3();
  print(cal(10, 20));
}

typedef Calculate = int Function(int num1, int num2);
// 函数作返回值
Calculate test3() {
  return (num1, num2) {
    return num1 * num2;
  };
}

5、 词法作用域

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

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

6、 词法闭包

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

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

  var addr2 = makeAddr(2);
  print(addr2(10)); // 12
  print(addr2(6)); // 8

  var addr5 = makeAddr(5);
  print(addr5(10)); // 15
  print(addr5(8)); // 13
}

7、 返回值问题

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

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

foo() {
  print("foo 调用");
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • Dart基本语法
    重要概念 可以放在变量中的都是对象,所有对象都是类的实例,包括数字,函数,null都是对象, 所有对象都是继承自 ...
    哆啦_阅读 13,264评论 1赞 14
  • Flutter（二）Dart基本语法
    一. Dart介绍和安装 1.1. 认识Dart Google为Flutter选择了Dart就已经是既定的事实，无...
    AlanGe阅读 1,525评论 0赞 1
  • Dart 基本语法及使用
    碎语，有android、iOS、前端、小程序、RN基础，所以，以下记录仅为个人理解记录，没必要的就忽略的 dart...
    DaZenD阅读 2,624评论 0赞 1
  • Dart 基本语法
    Dart 语言集合了 Java、JavaScript、C、TypeScript 等语言的优势，可以说是集百家之长的...
    风之化身呀阅读 2,684评论 0赞 2
  • Dart的基本语法
    变量 dart是脚本类语言，可以不预先定义变量类型 ，会自动类型推导。定义变量可以通过var关键字来声明变量var...
    yyggzc521阅读 778评论 0赞 1