EDUCBA-Dart-初学者笔记-全-

EDUCBA Dart 初学者笔记（全）

001：课程介绍

在本课程中，我们将从零开始学习Dart编程语言的基础知识。本课程专为初学者设计，旨在帮助你建立坚实的编程基础，为后续学习更高级的Dart应用开发铺平道路。

课程难度与先决条件

本课程的难度级别为初学者。学习本课程没有硬性的技能要求，但如果你具备任何编程语言的基础知识，将有助于你更快地理解和掌握课程内容。这并非强制要求，只是一个有益的建议。

课程内容概览

接下来，让我们了解一下在这个Dart初学者课程中，我们将具体学习哪些内容。

以下是本课程的核心模块：

1. Dart概述：我们将探讨什么是Dart编程语言，为什么使用它，以及使用Dart可以完成哪些任务。
2. 语法与关键字：我们将学习Dart语言特有的语法规则和关键字，了解它们的用途和用法。
3. 变量与数据类型：我们将学习如何创建变量，理解变量的概念，学习如何在变量中存储值，并了解Dart中可用的不同数据类型。
4. 运算符与常量：我们将学习什么是运算符及其使用方法，了解Dart中可用的各类运算符。同时，我们将理解常量的概念，学习如何使用常量，以及如何结合运算符和常量来创建程序。

目标受众

本课程适合所有希望学习Dart编程的人士。无论你是希望学习一门新编程语言的职场人士，还是希望提升自我、学习Dart编程的学生，都可以从本课程开始。

学习成果

在完成本课程后，你将获得以下技能：

• 你将能够编写涉及各种变量和常量的程序。
• 你将能够创建使用运算符和数据类型的程序。

总而言之，完成本课程后，你将具备足够的能力来创建涉及变量、常量、运算符或数据类型的任何基础程序。

本节课中，我们一起了解了Dart初学者课程的概览、目标与学习路径。从下一节开始，我们将正式进入Dart编程的世界，首先从Dart语言的概述学起。

002：Dart语言基础入门 🚀

在本节课中，我们将要学习Dart编程语言的基础知识，包括它的起源、特点、应用场景，并通过编写第一个简单的Dart程序来实践。

概述

Dart是一种由Google开发的开源编程语言。其最新稳定版本发布于2020年8月。我们将使用这个稳定版本进行学习。编程语言用于根据语言规范创建特定程序。Dart本质上是一种开源编程语言。

Dart语言简介

Dart最初是为开发移动应用程序而创建的。你也可以用它来构建Web服务器、桌面应用、移动应用或物联网设备。这是创建Dart语言的基本意图。

它也是一种面向对象的编程语言。因此，Dart编程也包含了类、继承、重写、重载等所有面向对象编程的特性。它基本上融合了所有面向对象编程的特性，并且其语法看起来与Java语法相似。如果你有相关知识会更好，但即使没有，你也可以从初级课程开始。你将非常透彻地了解每一个语法，所以这没有问题。

为什么使用Dart？

现在，我们来谈谈为什么使用Dart编程语言。它的一个基本优点是它是一种跨平台语言。它基本上支持当前所有主流操作系统，无论是Windows、Mac还是你正在使用的任何其他操作系统，甚至在移动应用平台如Android、Apple或其他任何平台上，它都能运行。

第二个重要点是它是开源的。你可以在线获取它，只需下载Dart SDK，使用你的记事本创建程序，在Dart中运行。你还可以通过各种IDE来使用它，甚至可以使用Flutter通过Dart语言创建移动应用程序。所有这些之所以可能，是因为它是开源的，并且非常稳定，你也可以将其用于实时应用程序。

另一个优点是它支持面向对象编程特性。因此，如果你具备这种编程概念的知识，使用Dart语言开发程序对你来说会非常容易。

安装与准备

正如我们已经讨论过的，我们需要安装Dart SDK。它基本上包含了编译器，或者你也可以称之为软件开发工具包，其中包含了所有的虚拟机、独立机器、命令行接口环境等。你只需要下载、安装它，然后就可以开始创建你的程序了。

现在，我们已经非常清楚地了解了这门语言是什么，它是如何被开发的，由谁开发的，以及我们将在代码中使用的当前稳定版本是什么。

第一个Dart程序

现在，让我们快速创建一个关于它的基本示例，我们将在命令行上简单地打印“欢迎来到Dart编程语言”。

我们将从这里的主方法开始。告诉你，如果你没有任何编程语言背景，主方法基本上是程序的入口点，程序将从此处开始执行。就像我们在所有其他语言中也有这个一样，我们将其作为启动Dart程序的入口点。因此，当你编译并运行当前的Dart程序时，只有你写在这个主方法开闭括号内的内容才会执行。

在这个方法内部，我们简单地使用一个名为print的方法，并写上“欢迎来到Dart编程语言”。理解这个语法：print基本上是Dart的一个内置方法，它将在命令行上打印一些内容。它会打印你放在这对双引号内的任何内容。

你写的这个语法不必和我们写的一模一样，它可以是任何你需要给用户的信息，这些信息应该只打印在你的Dart命令行上。把那条信息放在这对双引号里，并用分号结束这一行，这意味着这个特定语句在这里结束。这基本上是行的结束，就像我们按回车键换到新一行一样，这里我们告诉编译器这是行的结束。我们想做的只是为用户打印一条消息，说“欢迎来到Dart编程语言”。

我们还可以写下这样的内容，例如，说“这是我们的第一个Dart程序，我们正在写一个注释”。现在，你如何理解这句话？“这是我们的第一个Dart程序，我们正在写一个注释。”当你执行和运行程序时，这个语句实际上不会执行，因为你在这里放了两个斜杠，这意味着这是一个注释。注释仅供程序员理解他写的是什么。

现在，这只是我们写的一行程序，但假设一下，如果你正在编写一个使用Dart编程创建的完整应用程序，你应该知道这些方法基本上是做什么用的，以供你参考。在那里，你可以使用这个注释，你可以放任何你想让未来理解某个特定方法是关于什么的内容。所以，你可以在那里使用这个注释点。

程序解析

我们已经完成了第一个程序。main是我们程序的入口点，程序将从此处开始执行，所以它必须存在。print函数是一个内置函数，我们没有创建它，它是默认存在的，它只会显示或打印你写在双引号内的任何内容。

现在我们将保存这个程序。我们将把它保存在D盘，我们有一个“dart_program_beginners”文件夹，在这里我们将其保存为“first.dart”。.dart必须是扩展名。现在我们已经保存了它，并且如前所述，我们也安装了Dart SDK。

现在我们要做的是，让我们打开命令提示符。我们在D盘的“dart_program_beginners”文件夹中。现在我们将执行dart first.dart。这个dart意味着我们想使用Dart SDK进行编译，我们的文件名是“first.dart”。你按回车，它会打印消息“欢迎来到Dart编程语言”，与你给print命令的内容相同。所以它不会打印main、开闭括号、print、然后圆括号、双引号和文本，它只执行你写在print特定方法内部的内容。

这是一个非常简单的程序，我们只是打印一条特定的消息。

第二个程序示例

现在我们要做的是，让我们回到这里，创建一个新文件，我们将再次通过创建主方法来开始。让我们给你的print语句写上“这是我们的第二个程序”。

总结

本节课中，我们一起学习了Dart编程语言的基础知识。我们了解了Dart的起源、跨平台和面向对象的特性，以及为什么选择使用它。我们实践了如何编写、保存和运行一个简单的Dart程序，理解了main函数作为程序入口点的重要性，以及如何使用print函数输出信息和添加注释。这为后续更深入的Dart学习打下了坚实的基础。

003：Dart语言基础续篇 🚀

在本节课中，我们将继续学习Dart语言的基础知识，重点探索print函数的多种用法、代码注释的写法以及Dart语法中的基本规则。通过实际编写和运行多个示例程序，你将掌握如何有效地输出信息和管理代码。

---

上一节我们介绍了Dart程序的基本结构。本节中，我们来看看如何使用print函数输出多行信息。

以下是使用多个print函数输出多行消息的示例。

print('This is using');
print('Multiple');
print('Print Functions');

我们使用了三个print命令，分别打印了三行文本。将此代码保存为second.dart并运行，将在控制台看到三行输出。

---

除了使用多个print函数，还有一种更简洁的方法可以在一个print函数中输出多行文本。

以下是在单个print函数中使用换行符\n的示例。

print('This is using\nMultiple\nPrint Functions');

这里，我们只使用了一个print函数。\n字符代表换行，它的作用等同于结束一个print语句后，在新的一行开始另一个print语句。这种方法将多个输出行合并到了一个函数调用中。

---

除了换行，我们还可以在输出中使用制表符来创建间隔。

以下是使用制表符\t的示例。

print('This is using\tMultiple\tPrint Functions');

\t代表制表符，它在输出中产生的空格比普通空格键更大，常用于对齐文本或创建视觉上的分隔。

---

在编程中，我们经常需要编写注释来解释代码，但又不希望它们被执行。Dart支持单行注释和多行注释。

以下是单行注释的示例，使用双斜杠//。

// 这是一个单行注释
print('Hello World');

双斜杠//之后直到行尾的内容都会被编译器忽略。

---

当注释内容较多时，为每一行都添加//会很繁琐。此时，可以使用多行注释。

以下是多行注释的示例，使用/*和*/包裹。

/*
这个程序解释了
如何在单个print函数中
使用换行符和制表符。
*/
print('Hello World');

被/*和*/包围的所有内容都会被视为注释，不会参与程序执行。如果尝试执行未注释的普通文本，编译器会因为无法识别语法而报错。

---

在Dart中，每一个可执行语句都必须以分号;结尾，这是语法强制要求的。

以下是一个缺少分号的错误示例。

print('Hello World') // 错误：这里缺少分号
print('Another line');

如果省略分号，编译器会明确指出错误发生的行号和位置，例如“第2行第37个位置期望一个分号”。因此，确保每条语句以分号结束至关重要。

---

本节课中我们一起学习了Dart基础知识的延续部分。我们掌握了print函数的几种变化用法，包括输出多行文本、使用换行符\n和制表符\t。同时，我们也了解了如何使用//进行单行注释以及使用/* */进行多行注释。最后，我们强调了以分号结束每条可执行语句的重要性，这是避免编译错误的关键。在下一节中，我们将进一步学习Dart的语法规则和关键字。

004：Dart语法 🧩

在本节课中，我们将要学习Dart编程语言的基础语法。我们将从变量和标识符开始，了解如何为程序中的元素命名，并遵循Dart的命名规则。这是编写任何Dart程序的第一步。

---

现在，让我们开始Dart初学者课程的下一节。首先，我们将了解Dart程序的一些基础和语法。

我们知道，当学习任何编程语言时，都需要遵循为该语言创建的一套特定规则来编写语法或代码。每种语言在编写语法的方式上可能有相似之处，也可能有差异。

接下来，我们将探讨Dart的基本语法。首先，我们将探索变量。我们将了解不同类型的变量、变量的用途、如何创建和使用它们。之后，我们将学习运算符部分。在接下来的课程中，我们将逐步学习类、函数、编程结构、循环结构（如编程语言中的各种循环）以及决策语句。我们已经了解了什么是注释，包括单行注释和多行注释。我们还将学习库、包以及泛型集合。

---

在进一步学习之前，我们首先需要理解什么是Dart标识符。它本质上是我们赋予任何元素的名称。例如，变量。变量是用于存储特定值的容器。该容器就是变量，它在内存中被创建，每个创建的变量都会被分配一个内存地址。在这个变量中，你可以存储任何希望存储的值。

除了变量，我们还有数组、类和函数。你为这些元素指定的任何名称，就像我们日常用语中的名字一样，都是为了识别它们。在这里，我们将标识符定义为分配给任何变量、数组、类或函数等的名称。

当你定义这些名称或标识符时，每种编程语言都有特定的规则。对于Dart编程语言，第一条规则是：你分配的名称的第一个字符必须是字母。它可以是大写字母、小写字母，也可以是下划线，但不能以数字或任何其他特殊字符开头。

这是设定的第一条规则。类似地，第二条规则是：名称不能以数字开头。除了第一个字符外，所有其他字符可以是任何字母或数字，对此没有限制，但第一个字符不能是数字。

此外，标识符名称中不能包含任何特殊字符或标点符号，只有下划线或美元符号是可接受的。除此之外，不能有任何其他字符或标点符号。

同样，不能有两个连续的下划线。例如，不能有像 __name 这样的名称。你可以有 _name，这是可以的，但不能有两个连续的下划线。

同样，有一些预定义的关键字。关键字是每种编程语言中预定义的、具有特定含义的词汇。例如，我们之前看到的 print 或 main。这些都是关键字，main 表示程序的入口点，print 是一个在命令行打印内容的方法。像这样，我们有许多定义好的关键字，你不能将这些关键字用作标识符。

另外，请记住一点：编程语言是区分大小写的。如果你创建一个变量，比如大写的 AB 和小写的 ab，这是有区别的，因为它们是两个不同的变量。由于这个是大写A，而那个是小写a，所以它们之间存在差异。

---

以下是标识符命名规则的总结：

• 规则一：第一个字符必须是字母（A-Z 或 a-z）或下划线（_）。
• 规则二：标识符不能以数字开头。
• 规则三：后续字符可以是字母、数字、下划线（_）或美元符号（$）。
• 规则四：标识符中不能包含空格或特殊字符（如 @、#、% 等），除了 _ 和 $。
• 规则五：不能使用Dart的保留关键字（如 if、for、class 等）作为标识符。
• 规则六：Dart是区分大小写的，因此 myVar 和 myvar 是两个不同的标识符。

---

现在，如果我们来看一个例子，假设我们想创建一个变量来存储员工的名字。在这种情况下，我们可以将变量名设为 firstName，这是一个有效的变量名。或者，你也可以使用 first_name，这也是有效的。或者，你可以使用 empName，这也是有效的。像这样，你可以创建任何你希望用来将员工姓名存储到变量中的标识符名称。

但是，如果你尝试创建像 1empName 这样的名称，这是无效的。或者，如果我们在这里使用 emp-name，我们不能有这个短横线，你只能使用下划线或美元符号。或者，你尝试创建像 emp@name 这样的名称，这也是无效的。

任何超出设定规则的尝试都会导致错误，因为Dart编程语言不接受这些。如果发现任何语法错误，解释器或编译器将引发错误。

---

接下来，我们将创建一个简单的Dart程序。在这个程序中，我们将创建两个变量，为它们赋值，然后尝试在命令行打印这些值。

void main() {
  // 声明并初始化变量
  String firstName = 'John';
  int age = 25;

  // 打印变量的值
  print('Employee Name: $firstName');
  print('Employee Age: $age');
}

---

本节课中，我们一起学习了Dart编程语言的基础语法，重点了解了标识符的命名规则。我们明确了标识符是变量、函数、类等程序元素的名称，并掌握了创建有效标识符必须遵循的六条核心规则。通过一个简单的示例程序，我们实践了如何声明变量、赋值并使用它们。理解并正确应用这些语法规则是编写任何Dart程序的基石。

005：变量与输出 📝

概述

在本节课中，我们将学习Dart编程语言中变量的创建与使用，以及如何通过print语句将变量值与文本结合输出到控制台。我们将通过多个示例程序来演示这些基础概念。

变量创建与命名规则

上一节我们介绍了Dart程序的基本结构。本节中，我们来看看如何创建和使用变量。

变量用于存储数据。在Dart中，我们使用var关键字来声明一个变量。变量名必须遵循特定的命名规则（标识符规则），并且不能使用Dart的保留关键字（如var）作为变量名。

以下是创建变量的基本语法：

var variableName = value;

第一个程序：打印姓名

现在，我们创建一个简单的程序来演示变量的使用。首先，我们创建main方法。

在main方法内部，我们创建变量。我们使用var关键字来创建变量。这里我们创建一个存储名字的变量。

我们创建名为firstName的变量。我们为这个变量赋值“Richa”。每个语句必须以分号结束。

我们创建另一个名为lastName的变量，并为其赋值“Sherma”。

我们想要使用print方法输出结果。我们希望输出“welcome”以及变量firstName和lastName的值。

我们使用美元符号$和花括号{}来在字符串中插入变量值。我们输出“welcome Richa Sherma to dart programming”。这个程序的目标是组合文本与我们创建的变量值，并将其打印到命令提示符。

现在保存这个文件。我们将其保存为P1.dart。

然后我们转到命令提示符，运行P1.dart。它输出“welcome Richa Sherma to dart programming”。

存储在firstName中的名字被打印在这里。存储在lastName中的姓氏被打印在这里。因为我们在这里给出了一个空格，所以空格出现了。如果你不放置空格，空格就不会出现。

假设我们不在这里放置空格，保存并再次执行。现在，它再次出现。即使你没有在这里给出空格，但在拼接值时你给出了一个空格，然后你结束了双引号。但这不是正确的做法。所以最好像这样放置。输出结果相同。

如果你想在这里打印多个语句并单独打印值呢？例如，让我们创建一个新的程序。

第二个程序：分别打印姓名

我们创建一个新文件。我们创建main方法。在内部，我们再次使用var创建fName变量并赋值“Richa”。我们创建lName变量并赋值“Sherma”。

我们使用print命令。我们说“Welcome to dart programming.”。然后我们说“Your first name is”，并在这里打印$fName的值。然后我们再次输出“Your last name is”，并在这里打印$lName的值。

我们将其保存为P2.dart。现在尝试执行P2.dart。它打印“Welcome to dart programming. Your first name is Richa. Your last name is Sherma.”。这是另一种打印输出的方式，完全取决于你希望如何向最终用户呈现输出。

第三个程序：员工信息

现在，让我们创建另一个程序。在这里，我们将创建一个包含更多变量的程序。

除了名字和姓氏，我们还将创建变量来存储年龄和部门名称。我们以员工为例，存储员工姓名、员工年龄和员工部门，然后打印这些值并显示给最终用户。

我们以main方法开始。我们创建变量empName并赋值“John Carter”。我们创建变量empAge并赋值一个数字，例如35。你创建的变量可以存储字符串或数字类型的值。类似地，我们再创建一个变量salary并赋值35000。然后我们创建变量departmentName并赋值“Accounts”。

现在我们使用print命令。我们说“Welcome to ABC Corporation.”。然后我们打印“Your name is $empName, you are $empAge years old.”。然后我们说“Your salary is $salary”。然后我们说“Your department is $departmentName”。这就是我们想要在打印语句中输出的内容。

我们将其保存为P3.dart。让我们尝试执行P3.dart。它输出“Welcome to ABC Corporation. Your name is John Carter, you are 35 years old, your salary is 35000 and department is accounts.”。

这非常简单。你创建你希望创建的变量，根据适用于标识符的命名规则给予恰当的名称，然后在变量中存储适当的值，你可以按你希望的顺序打印它们，可以全部打印在一行，也可以分开打印。

你也可以使用这些值。假设我们说“Your name is $empName and you are $empAge years old.”。现在我们想在这里结束。我们想换行，然后在这里开始说“Your salary is $salary”。让我们执行它看看。

输出为：“Your name is John Carter you are 35 years old.” 句号。然后换行。“Your salary 35000 and department is accounts department.”。所以这完全取决于你如何创建打印语句，使用你学到的命令，或者在那种情况下创建多个打印语句。

总结

本节课中，我们一起学习了Dart中变量的声明、赋值及基本命名规则。我们掌握了使用print语句结合字符串插值（$variableName或${expression}）来输出变量值的方法，并通过多个示例程序实践了如何组织代码以清晰地向用户展示信息。记住，良好的变量命名和清晰的输出格式对于编写可读性强的代码至关重要。

006：Dart变量与数据类型 📚

在本节课中，我们将要学习Dart编程语言中的两个核心概念：关键字和变量数据类型。我们将首先了解哪些是Dart中的保留关键字，然后深入探讨如何使用不同的数据类型来声明和存储变量。

关键字列表 🚫

上一节我们介绍了标识符的命名规则，本节中我们来看看在Dart中哪些词是保留关键字，不能用作标识符名称。

以下是Dart中的关键字列表，应避免使用它们作为变量名、函数名等标识符：

• abstract
• as
• assert
• async
• await
• break
• case
• catch
• class
• const
• continue
• covariant
• default
• deferred
• do
• dynamic
• else
• enum
• export
• extends
• extension
• external
• factory
• false
• final
• finally
• for
• Function
• get
• hide
• if
• implements
• import
• in
• interface
• is
• library
• mixin
• new
• null
• on
• operator
• part
• required
• rethrow
• return
• set
• show
• static
• super
• switch
• sync
• this
• throw
• true
• try
• typedef
• var
• void
• while
• with
• yield

此外，还有一些上下文关键字和内置标识符，它们只在特定位置有特殊含义，同样不建议用作普通标识符。

变量与数据类型 🔢

现在，让我们继续学习Dart中的各种变量及其数据类型。之前我们已经使用 var 创建过变量，但Dart也支持明确指定数据类型的变量声明，这可以存储特定类型的值。

以下是Dart中主要的数据类型：

• 数字：用于存储数值。
• 字符串：用于存储一系列字符。
• 布尔值：用于存储 true 或 false。
• 列表：用于存储一组有序的值。
• 映射：用于存储键值对。
• 符文：用于表示字符串中的Unicode代码点。
• 符号：一种不常用的数据类型。

接下来，我们将逐一详细了解这些数据类型。

数字类型

顾名思义，数字类型用于存储任何数值或整数数据。数值可以是整数，也可以是浮点数。

创建数字变量：

• 整数：使用 int 关键字声明一个存储整数的变量。

  int age = 25;
  

• 浮点数：使用 double 关键字声明一个存储双精度浮点数的变量。

  double salary = 50000.75;
  

字符串类型

字符串类型用于存储一系列字符序列，可以包含字母、数字或特殊字符。任何你想以文本格式存储的内容都可以使用字符串变量。

创建字符串变量：

通常使用 String 关键字或 var 进行声明。

String address = ‘123 Main Street, City’;

布尔类型

布尔类型用于存储逻辑值，只能是 true 或 false。在计算机内部，它们通常用 1 表示 true，0 表示 false。

创建布尔变量：

使用 bool 关键字进行声明。

bool isEmployeeActive = true;

列表类型

列表类型变量用于存储一组对象的集合，是一个有序的值组。

创建列表变量：

使用 List 关键字声明，并将值放在方括号 [] 中，值之间用逗号分隔。

List<int> oddNumbers = [1, 3, 5, 7, 9];

映射类型

映射类型用于存储键值对。每个键都映射到一个特定的值。

创建映射变量：

使用 Map 关键字声明，并将键值对放在花括号 {} 中。键和值之间用冒号 : 分隔，不同的键值对用逗号分隔。

Map<String, String> department = {
  ‘department1’: ‘Accounts’,
  ‘department2’: ‘Sales’
};

总结 📝

本节课中我们一起学习了Dart编程基础中关于变量声明的重要知识。我们首先明确了Dart语言中的保留关键字列表，这些词不能用作标识符。接着，我们深入探讨了Dart的各种数据类型，包括用于存储数值的int和double，用于存储文本的String，用于存储真假的bool，用于存储集合的List，以及用于存储键值对的Map，并学习了它们的基本声明语法。理解这些基础概念是编写正确、高效Dart代码的关键第一步。

007：变量详解（续）📘

概述

在本节课中，我们将继续深入学习Dart编程语言中的变量类型。我们将探讨如何声明和使用Map、Rune和Symbol类型的变量，并通过一个完整的示例程序来演示如何存储和打印这些变量的值。

---

创建Map类型变量

上一节我们介绍了基本数据类型，本节中我们来看看如何存储键值对数据。

Map类型用于存储键值对数据。以下是创建和初始化Map变量的方法：

• 首先创建department1键，并为其赋值Accounts。
• 接着创建department2键，并为其赋值IT。
• 然后创建department3键，并为其赋值Administration。

通过这种方式，我们可以创建一个存储多个键值对的Map。

---

Rune与Symbol类型变量

接下来，我们介绍两种用于存储特殊字符和标识符引用的变量类型。

Rune类型用于存储Unicode码点，例如一个32位的Unicode值。例如，我们可以创建一个Rune变量来存储表情符号：

var emoji = '\u{1f600}'; // 存储一个笑脸表情

Symbol类型用于通过标识符名称来引用对象。你可以使用#符号后跟标识符名称来创建：

var sym = #someIdentifier; // 创建一个Symbol类型的值

当你需要使用那些通过名称来引用标识符的API时，就可以使用Symbol数据类型。

---

综合示例程序

为了巩固理解，我们将创建一个程序，使用所有已学的变量类型。

以下是创建并打印各种类型变量值的完整程序：

void main() {
  // 声明并初始化各种类型的变量
  int empAge = 39;
  double empSalary = 40000.00;
  String empAddress = "B-12, Apartment, Xing, XP Road, Mumbai";
  bool empFlag = false;
  List empList = [1, 2, 3, 4, 5];
  Map empDepartment = {
    'department1': 'Accounts',
    'department2': 'IT',
    'department3': 'Administration'
  };
  var emoji = '\u{1f600}';

  // 打印所有变量的值
  print('Age is: $empAge');
  print('Salary is: $empSalary');
  print('Address is: $empAddress');
  print('Flag is: $empFlag');
  print('List is: $empList');
  print('Department is: $empDepartment');
  print('Emoji is: $emoji');
}

将上述代码保存为.dart文件并执行。在命令行中，表情符号可能无法正确显示，但在独立的集成开发环境（IDE）中运行，你将能看到完整的输出结果，包括年龄、薪水、地址、布尔值、列表、映射以及表情符号。

---

总结

本节课中我们一起学习了Dart中Map、Rune和Symbol变量的用法。我们创建了一个综合示例，演示了如何声明、赋值并打印这些不同类型的变量值。通过实践，你应能掌握使用Dart变量存储和操作各种数据的基础方法。

008：使用IDE创建第一个Dart项目 🚀

在本节课中，我们将学习如何使用集成开发环境（IDE）来创建和运行Dart项目。我们将从之前使用的记事本和命令提示符方式，过渡到更高效的WebStorm IDE，并创建一个能接收用户输入并打印欢迎信息的简单程序。

从命令行到IDE

上一节我们介绍了在记事本中编写代码并通过命令提示符执行的方法。本节中，我们来看看如何使用WebStorm IDE来简化这一流程。使用IDE可以避免在多个软件间切换，提高开发效率。

以下是两种主要的Dart开发方式：

• 使用IDE（如WebStorm）直接创建和管理项目，并在集成的终端中运行。
• 使用记事本编写代码，然后通过命令提示符手动执行Dart文件。

创建新项目

现在，我们开始使用WebStorm创建第一个Dart项目。首先，启动WebStorm并选择创建新项目。

以下是创建项目的步骤：

1. 如果Dart SDK未自动配置，需在设置中手动指定其安装路径。
2. 选择项目类型为“控制台应用程序”。
3. 设置项目名称（例如 first_project）和保存位置。
4. 点击“创建”按钮，IDE会自动生成项目结构和默认文件。

项目创建完成后，你可以在 bin 目录下看到一个与项目同名的 .dart 主文件。

编写第一个交互程序

接下来，我们将编写一个简单的交互式程序。这个程序会要求用户输入姓名，然后输出一条包含该姓名的欢迎信息。

为了实现从控制台读取输入，我们需要导入Dart的 io 库。核心代码如下：

import 'dart:io';

void main() {
  print('Please, enter your name:');
  String userName = stdin.readLineSync()!;
  print('Welcome $userName. This is our first Dart project.');
}

代码解析：

• import 'dart:io';：这行代码导入了输入/输出库，使我们能够使用 stdin 来读取用户输入。
• stdin.readLineSync()：这个方法会等待用户在控制台输入一行文本并按下回车键，然后将输入的文本作为字符串返回。
• String userName = ...：我们将用户输入的值存储在一个名为 userName 的字符串变量中。
• print('Welcome $userName...')：使用字符串插值（$变量名）将变量的值嵌入到输出信息中。

运行与测试程序

在WebStorm中运行程序非常简单。你可以点击“运行”按钮或使用快捷键 Shift + F10。IDE会自动编译并执行当前文件。

程序运行后，控制台会显示提示信息“Please, enter your name:”。输入一个名字（例如“John”）并按下回车，你将看到输出：“Welcome John. This is our first Dart project.”。

每次运行程序，它都会动态地等待新的输入，这证明了我们的程序是交互式的，并且变量 userName 的值是在运行时由用户决定的。

理解导入的重要性

为了加深理解，我们可以尝试注释掉导入语句 import 'dart:io';。你会发现，代码 stdin.readLineSync() 下方会出现错误提示“Undefined name ‘stdin’”。这是因为没有导入 dart:io 库，编译器就无法识别 stdin 这个对象。

这个实验清楚地表明：任何涉及从用户获取输入或进行复杂输出（超出简单的 print）的操作，通常都需要导入 dart:io 库。恢复导入后，错误便会消失。

总结

本节课中我们一起学习了如何使用WebStorm IDE创建和管理Dart项目。我们编写了一个简单的交互式控制台程序，它通过 dart:io 库中的 stdin.readLineSync() 方法接收用户输入，并使用字符串插值功能将结果输出。使用IDE的优势在于它集成了代码编辑、错误提示和程序运行环境，让开发过程更加流畅高效。

009：Dart示例续篇 🚀

在本节课中，我们将学习如何创建一个新的Dart文件，并编写一个程序来接收用户的输入，然后将输入的值打印出来。我们将重点学习如何处理不同类型的变量，特别是如何将字符串输入转换为整数和浮点数。

创建新文件

上一节我们介绍了基本的Dart程序结构。本节中我们来看看如何创建一个新的Dart文件来编写另一个程序。

以下是创建新文件的步骤：

1. 在项目资源管理器中，右键点击 bin 目录。
2. 选择 New Dart File。
3. 将新文件命名为 second_file.dart，然后按回车键。

系统会自动为我们创建并打开这个新文件。

编写程序代码

现在，我们开始在新文件中编写代码。首先，我们需要导入Dart的输入输出库，并定义主函数。

以下是程序代码的编写步骤：

import 'dart:io';

void main() {
  // 变量声明
  String fName, lName, eAge;
  int ageInt;
  double salaryDouble;
  String eSalary;

  // 接收用户输入
  print('Please enter your First Name:');
  fName = stdin.readLineSync();

  print('Please enter your Last Name:');
  lName = stdin.readLineSync();

  print('Please enter your Age:');
  eAge = stdin.readLineSync();
  ageInt = int.parse(eAge); // 将字符串转换为整数

  print('Please enter your Salary:');
  eSalary = stdin.readLineSync();
  salaryDouble = double.parse(eSalary); // 将字符串转换为浮点数

  // 打印用户输入的信息
  print('Your First Name is: $fName');
  print('Your Last Name is: $lName');
  print('Your Age is: $ageInt');
  print('Your Salary is: $salaryDouble');
}

代码执行与结果

编写完代码后，我们需要运行这个新文件来查看效果。

以下是运行程序的步骤：

1. 确保当前编辑的是 second_file.dart 文件。
2. 点击运行按钮或使用快捷键执行程序。
3. 程序会在控制台中依次提示输入信息。

例如，当程序运行时：

• 提示 Please enter your First Name:，输入 Rume。
• 提示 Please enter your Last Name:，输入 Shaha。
• 提示 Please enter your Age:，输入 40。
• 提示 Please enter your Salary:，输入 45000。

程序将输出以下结果：

Your First Name is: Rume
Your Last Name is: Shaha
Your Age is: 40
Your Salary is: 45000.0

请注意，薪水 45000 被输出为 45000.0，这是因为 salaryDouble 是双精度浮点数类型。

核心概念总结

本节课中我们一起学习了如何创建新文件、接收用户输入以及进行类型转换。

以下是本课的核心要点：

• 创建文件：在 bin 目录下右键可以创建新的Dart文件。
• 接收输入：使用 stdin.readLineSync() 从控制台获取字符串输入。
• 类型转换：使用 int.parse() 和 double.parse() 方法将字符串转换为整数和浮点数。这是处理非字符串输入的关键技巧。
• 输出变量：使用字符串插值（如 $variableName）在 print 语句中输出变量的值。

通过本课的学习，我们掌握了如何编写一个交互式的Dart程序，它不再使用固定的静态值，而是可以动态接收并处理用户输入的任何数据。这比我们之前课程中编写的程序更加灵活和实用。

010：Dart运算符与算术运算入门 🧮

在本节课中，我们将要学习Dart编程语言中的运算符，特别是算术运算符。我们将通过创建简单的示例来演示如何使用这些运算符进行基本的数学计算，并理解它们之间的区别。

算术运算符概述

上一节我们介绍了Dart的基础知识，本节中我们来看看Dart中的运算符。首先，我们将重点学习算术运算符。

算术运算符用于执行基本的数学运算。以下是Dart中主要的算术运算符类型：

• 加法运算符 (+)：用于将两个数值相加。
• 减法运算符 (-)：用于从一个数值中减去另一个数值。
• 一元负号运算符 (-expr)：也称为取反运算符，用于反转表达式的符号。例如，正数变为负数，负数变为正数。
• 乘法运算符 (*)：用于将两个数值相乘。
• 除法运算符 (/)：用于执行除法运算，结果返回一个双精度浮点数 (double)。
• 整除运算符 (~/)：用于执行除法运算，但结果返回一个整数 (int)，即舍弃小数部分。
• 取模运算符 (%)：用于获取除法运算后的余数。

创建示例程序

为了理解这些运算符的用法，让我们创建一个简单的Dart程序。我们将定义两个变量，对它们应用所有算术运算符，并将结果输出给用户。

首先，我们创建一个新的Dart文件，例如 arithmetic_operators.dart。在这个简单的示例中，我们不需要导入任何额外的库，因为我们将直接为变量赋值。

以下是示例代码：

void main() {
  // 定义两个整型变量并赋值
  int var1 = 50;
  int var2 = 10;

  // 使用不同的算术运算符进行计算
  int varSum = var1 + var2;      // 加法
  int varSub = var1 - var2;      // 减法
  int varMul = var1 * var2;      // 乘法
  double varDiv = var1 / var2;   // 除法，结果为double
  int varDiv2 = var1 ~/ var2;    // 整除，结果为int
  int varMod = var1 % var2;      // 取模

  // 打印所有运算结果
  print('The sum is: $varSum');
  print('The subtraction is: $varSub');
  print('The multiplication is: $varMul');
  print('The division is: $varDiv');
  print('The second division (integer result) is: $varDiv2');
  print('The modular is: $varMod');
}

运行此程序，你将看到如下输出：

The sum is: 60
The subtraction is: 40
The multiplication is: 500
The division is: 5.0
The second division (integer result) is: 5
The modular is: 0

运算符使用要点

从输出结果中，我们可以观察到以下几点：

1. 加法、减法、乘法的结果都是整数。
2. 使用普通除法运算符 (/) 得到的结果是双精度浮点数 5.0。
3. 使用整除运算符 (~/) 得到的结果是整数 5，它直接舍弃了小数部分。
4. 取模运算符 (%) 计算了 50 除以 10 的余数，结果为 0。

这个简单的例子展示了如何声明变量、使用运算符进行计算以及输出结果。

进阶应用思路

除了将计算结果存储在变量中再打印，我们还可以直接在 print 语句中进行运算。例如：

print('Direct calculation - Sum: ${var1 + var2}');

在后续的示例中，我们还可以学习如何从用户那里接收输入值，然后进行运算并将结果反馈给用户，这将使程序更具交互性。

课程总结

本节课中我们一起学习了Dart语言中的算术运算符。我们了解了加法 (+)、减法 (-)、取反 (-expr)、乘法 (*)、除法 (/)、整除 (~/) 和取模 (%) 运算符的用途和区别，并通过一个完整的代码示例实践了它们的用法。理解这些基础运算符是进行更复杂Dart编程的第一步。

011：使用算术运算符进行计算 🧮

在本节课中，我们将要学习如何在Dart程序中使用算术运算符进行计算。我们将从编写一个简单的静态计算程序开始，然后逐步过渡到创建一个能够从用户那里接收输入并进行计算的交互式程序。

静态计算程序

上一节我们介绍了算术运算符的基本概念，本节中我们来看看如何在一个简单的Dart程序中使用它们。我们将创建一个名为fourth_file.dart的文件，在其中直接使用运算符进行计算，而无需将中间结果存储在额外的变量中。

以下是fourth_file.dart的代码示例：

void main() {
  var var1 = 10;
  var var2 = 5;

  print('Addition is: ${var1 + var2}');
  print('Subtraction is: ${var1 - var2}');
  print('Multiplication is: ${var1 * var2}');
  print('Division is: ${var1 / var2}');
  print('Second Division is: ${var1 ~/ var2}');
  print('Modulo is: ${var1 % var2}');
}

运行此程序，输出结果将与之前使用多个变量的程序完全相同。唯一的区别在于，我们节省了创建额外变量的时间，使程序更加简洁。

交互式计算程序

静态程序虽然简单，但缺乏灵活性。接下来，我们将创建一个能够从用户那里接收输入的程序，使其更具交互性。我们将创建一个名为fifth_file.dart的新文件。

为了实现用户输入，我们需要导入dart:io库。以下是创建交互式程序的步骤：

1. 导入必要的库。
2. 提示用户输入两个数字。
3. 将输入的字符串转换为整数。
4. 使用算术运算符进行计算并输出结果。

以下是fifth_file.dart的完整代码：

import 'dart:io';

void main() {
  print('Please enter first number:');
  var input1 = stdin.readLineSync();
  var var3 = int.parse(input1!);

  print('Please enter second number:');
  var input2 = stdin.readLineSync();
  var var4 = int.parse(input2!);

  print('Addition is: ${var3 + var4}');
  print('Subtraction is: ${var3 - var4}');
  print('Multiplication is: ${var3 * var4}');
  print('Division is: ${var3 / var4}');
  print('Second Division is: ${var3 ~/ var4}');
  print('Modulo is: ${var3 % var4}');
}

运行此程序时，它会提示用户输入第一个和第二个数字。例如，输入70和20，程序将计算并输出以下结果：

• 加法结果为 90
• 减法结果为 50
• 乘法结果为 1400
• 除法结果为 3.5
• 整除结果为 3
• 取模结果为 10

这种方法比静态程序更有意义，因为它允许用户动态地输入他们想要计算的值，从而使程序变得真正有用。

总结

本节课中我们一起学习了Dart中算术运算符的两种应用方式。我们首先编写了一个直接使用固定值进行计算的简洁程序，然后创建了一个能够从用户获取输入并进行计算的交互式程序。理解如何接收和处理用户输入是构建实用应用程序的基础。通过本节的学习，你应该已经掌握了使用基本算术运算符执行计算的方法。

012：使用关系运算符比较数值

在本节课中，我们将学习如何在Dart程序中对双精度浮点数（double类型）使用算术运算符。我们将创建一个程序，从用户那里接收两个浮点数，然后执行并打印所有基本算术运算的结果。

上一节我们介绍了如何在整数变量上使用算术运算符。本节中我们来看看如何对double类型的变量执行相同的操作。

创建程序文件

首先，我们需要创建一个新的Dart文件。我们将其命名为 p_file_4.dart。

在文件的开头，我们必须导入 dart:io 命名空间，以便从控制台读取用户输入。然后，在 main 函数中，我们将声明变量并编写逻辑。

以下是创建文件并设置基本结构的步骤：

1. 导入 dart:io 库。
2. 定义 main 函数。
3. 在 main 函数内声明两个 String 类型的变量（var1 和 var2）来接收用户输入。
4. 使用 print 函数提示用户输入。
5. 使用 stdin.readLineSync() 方法获取用户输入。

接收并转换用户输入

程序需要接收两个数字。由于从控制台读取的输入是字符串格式，我们需要将其转换为 double 类型才能进行数学运算。

以下是处理输入的具体步骤：

1. 提示用户输入第一个数字，并将输入存储在 var1 中。
2. 提示用户输入第二个数字，并将输入存储在 var2 中。
3. 使用 double.parse() 方法将 var1 和 var2 的字符串值转换为双精度浮点数，并分别存储在新的 double 类型变量 d_var1 和 d_var2 中。

关键转换代码如下：

d_var1 = double.parse(var1);
d_var2 = double.parse(var2);

执行算术运算并输出结果

转换完成后，我们可以直接对 d_var1 和 d_var2 使用算术运算符，并使用字符串插值将结果打印出来，而无需创建额外的结果变量。

我们将依次执行以下运算：

• 加法：d_var1 + d_var2
• 减法：d_var1 - d_var2
• 乘法：d_var1 * d_var2
• 除法：我们将演示两种除法：
  • 普通除法：d_var1 / d_var2 (结果是 double)
  • 整除：d_var1 ~/ d_var2 (结果是 int，丢弃小数部分)
• 取模：d_var1 % d_var2 (求余数)

以下是输出这些运算结果的代码示例：

print('Addition is: ${d_var1 + d_var2}');
print('Subtraction is: ${d_var1 - d_var2}');
print('Multiplication is: ${d_var1 * d_var2}');
print('Division is: ${d_var1 / d_var2}'); // 普通除法
print('Second division is: ${d_var1 ~/ d_var2}'); // 整除
print('Modulo is: ${d_var1 % d_var2}');

运行与测试

保存文件后，我们可以在终端中运行它来测试功能。

运行命令：

dart p_file_4.dart

程序会等待用户输入。例如，输入 52.8 作为第一个数，12.6 作为第二个数。程序将计算并显示所有运算结果。即使结果是整数（如整除运算），由于原始变量是 double 类型，输出也可能显示为 10.0 这样的格式，这是正常的。

通过这个练习，我们可以看到，算术运算符不仅适用于整数（int），也同样适用于浮点数（double）。处理流程是相似的：获取输入、进行类型转换、执行运算、输出结果。

本节课中我们一起学习了如何为 double 类型的变量应用算术运算符。我们创建了一个完整的程序，从接收用户输入、转换数据类型，到执行加、减、乘、除、整除和取模运算，并直接输出结果。这巩固了我们对Dart基本运算和输入处理的理解。

013：运用赋值运算符

在本节课中，我们将要学习Dart语言中的赋值运算符。赋值运算符用于为变量赋值，除了基础的等号（=）外，Dart还提供了一系列复合赋值运算符，它们能更简洁地执行运算和赋值操作。

上一节我们介绍了逻辑运算符，本节中我们来看看赋值运算符。

理解赋值运算符

赋值运算符的核心功能是为变量分配值。最基本的赋值运算符是等号 =。

例如，在 void main() 方法中创建一个变量并赋值：

void main() {
  var num1 = 50;
}

在这个例子中，= 就是一个简单的赋值运算符。

然而，Dart还提供了其他类型的赋值运算符，它们结合了算术运算和赋值。例如：

num2 = num2 + 50;

这行代码可以简写为：

num2 += 50;

这里的 += 就是一个算术赋值运算符，它表示“先加后赋值”。

以下是Dart中主要的赋值运算符类型：

• 简单赋值运算符：=。
• 空感知赋值运算符：??=。仅当变量为 null 时才进行赋值。
• 加法赋值运算符：+=。
• 减法赋值运算符：-=。
• 乘法赋值运算符：*=。
• 除法赋值运算符：/=。
• 取模赋值运算符：%=。

实践：使用赋值运算符

为了理解这些运算符如何工作，我们将创建一个程序来演示它们的用法。这个程序不接收用户输入，而是直接定义变量、赋值，然后使用各种赋值运算符进行计算并打印结果。

以下是完整的程序代码：

void main() {
  // 初始化变量
  int number1 = 50;
  int number2 = 40;

  // 使用 += 运算符
  print('初始值: number1 = $number1, number2 = $number2');
  number1 += number2; // 等价于 number1 = number1 + number2
  print('执行 number1 += number2 后，number1 的值为: $number1');

  // 使用 -= 运算符
  print('当前值: number1 = $number1, number2 = $number2');
  number1 -= number2; // 等价于 number1 = number1 - number2
  print('执行 number1 -= number2 后，number1 的值为: $number1');

  // 使用 *= 运算符
  print('当前值: number1 = $number1, number2 = $number2');
  number1 *= number2; // 等价于 number1 = number1 * number2
  print('执行 number1 *= number2 后，number1 的值为: $number1');

  // 使用 /= 运算符 (注意结果会变为 double 类型)
  print('当前值: number1 = $number1, number2 = $number2');
  number1 /= number2; // 等价于 number1 = number1 / number2
  print('执行 number1 /= number2 后，number1 的值为: $number1');

  // 使用 %= 运算符
  print('当前值: number1 = $number1, number2 = $number2');
  number1 %= number2; // 等价于 number1 = number1 % number2
  print('执行 number1 %= number2 后，number1 的值为: $number1');
}

运行此程序，你将看到类似以下的输出：

初始值: number1 = 50, number2 = 40
执行 number1 += number2 后，number1 的值为: 90
当前值: number1 = 90, number2 = 40
执行 number1 -= number2 后，number1 的值为: 50
当前值: number1 = 50, number2 = 40
执行 number1 *= number2 后，number1 的值为: 2000
当前值: number1 = 2000, number2 = 40
执行 number1 /= number2 后，number1 的值为: 50.0
当前值: number1 = 50, number2 = 40
执行 number1 %= number2 后，number1 的值为: 10

通过每一步打印变量的当前值，我们可以清晰地跟踪 number1 是如何被每个赋值运算符改变的：

1. 50 + 40 = 90
2. 90 - 40 = 50
3. 50 * 40 = 2000
4. 2000 / 40 = 50.0
5. 50 % 40 = 10 (50除以40的余数)

总结

本节课中我们一起学习了Dart的赋值运算符。我们了解到，除了基础的 =，Dart还提供了 +=、-=、*=、/= 和 %= 等复合赋值运算符，它们能够用更简洁的语法实现运算和赋值的结合。通过实际编程练习，我们观察了这些运算符如何逐步改变变量的值。掌握这些运算符能让你的代码更加简洁高效。

014：理解相等与比较运算符

在本节课中，我们将学习如何创建一个接受用户输入的程序，并使用各种赋值运算符对输入的数据进行操作。我们将从整数运算开始，然后扩展到浮点数运算，以全面理解赋值运算符的应用。

创建整数运算程序

上一节我们介绍了赋值运算符的基本概念，本节中我们来看看如何结合用户输入来使用它们。我们将创建一个程序，从用户处获取两个整数，并对它们执行一系列赋值运算。

首先，我们需要导入 dart:io 库以支持输入输出操作，并定义主函数 main。

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/489025cbf8e7cf7a6a6b2b49cc76aee1_4.png)

void main() {
  // 变量声明
  String num1, num2;
  int varNum1, varNum2;

  // 获取用户输入
  print('Please enter first number:');
  num1 = stdin.readLineSync()!;
  print('Please enter second number:');
  num2 = stdin.readLineSync()!;

  // 将字符串转换为整数
  varNum1 = int.parse(num1);
  varNum2 = int.parse(num2);

  // 使用赋值运算符进行计算
}

以下是程序的核心计算步骤，我们将对两个变量依次使用 +=、-=、*=、/= 和 %= 运算符，并在每次运算后打印结果。

1. 加法赋值 (+=)

   varNum1 += varNum2;
   print('The value of varNum1 is $varNum1 and the value of varNum2 is $varNum2');
   

2. 减法赋值 (-=)

   varNum1 -= varNum2;
   print('The value of varNum1 is $varNum1 and the value of varNum2 is $varNum2');
   

3. 乘法赋值 (*=)

   varNum1 *= varNum2;
   print('The value of varNum1 is $varNum1 and the value of varNum2 is $varNum2');
   

4. 除法赋值 (/=)

   varNum1 ~/= varNum2; // 注意：整数除法使用 `~/=`
   print('The value of varNum1 is $varNum1 and the value of varNum2 is $varNum2');
   

5. 取模赋值 (%=)

   varNum1 %= varNum2;
   print('The value of varNum1 is $varNum1 and the value of varNum2 is $varNum2');
   

运行此程序，例如输入 90 和 5，控制台将逐步输出每次运算后的结果。

创建浮点数运算程序

理解了整数运算后，我们进一步探索赋值运算符在浮点数（double 类型）上的应用。其逻辑与整数程序类似，主要区别在于变量的数据类型和解析方法。

以下是浮点数运算程序的核心代码结构：

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/489025cbf8e7cf7a6a6b2b49cc76aee1_14.png)

void main() {
  // 声明字符串和双精度浮点数变量
  String str1, str2;
  double dVar1, dVar2;

  // 获取用户输入
  print('Please enter first number:');
  str1 = stdin.readLineSync()!;
  print('Please enter second number:');
  str2 = stdin.readLineSync()!;

  // 将字符串转换为双精度浮点数
  dVar1 = double.parse(str1);
  dVar2 = double.parse(str2);

  // 使用赋值运算符进行计算
}

以下是针对双精度浮点数的运算步骤列表：

1. 加法赋值 (+=)

   dVar1 += dVar2;
   print('The value of dVar1 is $dVar1 and the value of dVar2 is $dVar2');
   

2. 减法赋值 (-=)

   dVar1 -= dVar2;
   print('The value of dVar1 is $dVar1 and the value of dVar2 is $dVar2');
   

3. 乘法赋值 (*=)

   dVar1 *= dVar2;
   print('The value of dVar1 is $dVar1 and the value of dVar2 is $dVar2');
   

4. 除法赋值 (/=)

   dVar1 /= dVar2; // 对于 double 类型，使用标准的 `/=` 运算符
   print('The value of dVar1 is $dVar1 and the value of dVar2 is $dVar2');
   

运行此程序，输入如 5.5 和 6.5，程序将演示浮点数上的赋值运算过程。需要注意的是，取模运算符 %= 通常用于整数，对浮点数的支持取决于具体语言规范，在此示例中我们主要展示前四种运算。

本节课中我们一起学习了如何利用 Dart 的赋值运算符结合用户输入进行动态计算。我们创建了两个程序：一个处理整数运算，另一个处理浮点数运算。通过实践，你应已掌握 +=、-=、*=、/= 和 %= 等运算符的使用方法，并理解了如何通过 int.parse() 和 double.parse() 转换用户输入的数据类型。这些是构建交互式控制台应用程序的基础。

015：使用逻辑运算符

在本节课中，我们将要学习Dart编程语言中的逻辑运算符。逻辑运算符用于组合多个布尔表达式，以构建更复杂的条件判断。我们将通过具体的代码示例来理解 &&（与）、||（或）和 !（非）这三个运算符的工作原理。

逻辑运算符概述

逻辑运算符用于连接两个或多个布尔表达式，并返回一个布尔结果。它们是基于布尔逻辑（真/假）进行运算的。

以下是三种主要的逻辑运算符：

• &&（与运算符）：只有当所有连接的表达式都为 true 时，整个表达式的结果才为 true。
• ||（或运算符）：只要任意一个连接的表达式为 true，整个表达式的结果就为 true。
• !（非运算符）：这是一个一元运算符，用于反转其后表达式的布尔值。如果表达式为 true，则变为 false；如果为 false，则变为 true。

逻辑运算符详解

上一节我们介绍了逻辑运算符的基本概念，本节中我们来看看它们的具体工作方式。

&&（与）运算符

&& 运算符要求其两边的表达式同时为真，结果才为真。

例如，假设我们有两个变量：

int n1 = 10;
int n2 = 30;

现在考虑表达式：

(n1 > 5) && (n2 > 20)

• n1 > 5 为 true。
• n2 > 20 为 true。
• 由于两个条件都为 true，因此整个 (n1 > 5) && (n2 > 20) 表达式的结果为 true。

如果其中任何一个条件为假，例如 (n1 > 5) && (n2 > 40)，因为 n2 > 40 为 false，所以整个表达式的结果为 false。

||（或）运算符

|| 运算符要求其两边的表达式至少有一个为真，结果就为真。

使用相同的变量，考虑表达式：

(n1 > 5) || (n2 > 40)

• n1 > 5 为 true。
• n2 > 40 为 false。
• 由于第一个条件为 true，满足“至少一个为真”的条件，因此整个 (n1 > 5) || (n2 > 40) 表达式的结果为 true。

只有当所有条件都为假时，例如 (n1 > 15) || (n2 > 40)，整个表达式的结果才为 false。

!（非）运算符

! 运算符对其后的布尔表达式进行取反操作。

例如：

!(n1 > 5)

• n1 > 5 本身是 true。
• 应用 ! 运算符后，表达式 !(n1 > 5) 的结果变为 false。

同理，如果表达式为 false，应用 ! 后结果会变为 true。

实践练习：编写逻辑运算符程序

理解了每个运算符的规则后，让我们通过一个实际的Dart程序来验证它们的行为。

我们将创建两个布尔变量，并应用不同的逻辑运算符来观察输出结果。

以下是程序代码：

void main() {
  // 定义两个布尔变量并赋值
  bool variable1 = true;
  bool variable2 = false;

  // 使用 && 运算符
  bool result = variable1 && variable2;
  print('当 variable1 = $variable1 且 variable2 = $variable2 时，variable1 && variable2 的结果是：$result');

  // 使用 || 运算符
  result = variable1 || variable2;
  print('当 variable1 = $variable1 且 variable2 = $variable2 时，variable1 || variable2 的结果是：$result');

  // 使用 ! 运算符
  result = !(variable1 && variable2);
  print('当 variable1 = $variable1 且 variable2 = $variable2 时，!(variable1 && variable2) 的结果是：$result');
}

运行此程序，你将看到类似以下的输出：

当 variable1 = true 且 variable2 = false 时，variable1 && variable2 的结果是：false
当 variable1 = true 且 variable2 = false 时，variable1 || variable2 的结果是：true
当 variable1 = true 且 variable2 = false 时，!(variable1 && variable2) 的结果是：true

输出结果验证了我们之前的解释：

1. true && false 结果为 false（与运算要求两者皆真）。
2. true || false 结果为 true（或运算要求至少一个为真）。
3. !(true && false) 即 !false，结果为 true（非运算对结果取反）。

总结

本节课中我们一起学习了Dart语言中的逻辑运算符。我们明确了 &&（与）运算符需要所有条件为真才返回真，||（或）运算符在至少一个条件为真时即返回真，而 !（非）运算符则用于对布尔值进行取反。通过实际的代码示例，我们验证了这些运算符的行为，这是构建复杂程序逻辑和条件判断的基础。

016：使用逻辑与和或组合条件

在本节课中，我们将学习如何从用户处接收输入，并利用这些输入值来组合逻辑条件。我们将创建一个程序，让用户输入两个值，然后程序会计算并展示这些值在不同逻辑运算符（与、或、非）下的结果。

上一节我们介绍了布尔变量的基本概念，本节中我们来看看如何让程序与用户交互，动态地获取数据并进行逻辑判断。

创建新文件与基础结构

首先，我们需要创建一个新的Dart文件，并导入必要的库来支持用户输入。

import 'dart:io';

void main() {
  // 程序主体将在这里编写
}

声明变量

在main函数内部，我们需要声明几个变量来存储用户输入和计算结果。

  var variable1;
  var variable2;
  bool result;

接收用户输入

以下是接收用户输入并存储到变量中的步骤。

首先，提示用户输入第一个值，并读取它。

  print('请输入第一个布尔值（true/false）:');
  variable1 = stdin.readLineSync();

接着，提示用户输入第二个值，并同样读取。

  print('请输入第二个布尔值（true/false）:');
  variable2 = stdin.readLineSync();

执行逻辑运算并输出结果

获取输入后，我们将使用逻辑运算符进行计算，并打印结果。

首先，使用逻辑与运算符（&&）进行计算。

  result = (variable1 == 'true') && (variable2 == 'true');
  print('当 variable1 = $variable1 且 variable2 = $variable2 时，逻辑与的结果是: ${result.toString()}');

然后，使用逻辑或运算符（||）进行计算。

  result = (variable1 == 'true') || (variable2 == 'true');
  print('当 variable1 = $variable1 或 variable2 = $variable2 时，逻辑或的结果是: ${result.toString()}');

最后，使用逻辑非与逻辑与的组合进行计算。

  result = !((variable1 == 'true') && (variable2 == 'true'));
  print('当 variable1 = $variable1 且 variable2 = $variable2 时，逻辑非与逻辑与组合的结果是: ${result.toString()}');

调试与改进：使用数值比较

直接比较字符串’true’可能不够直观且容易出错。一个更稳健的方法是让用户输入数字，然后通过数值比较来生成布尔值。

以下是改进后的代码片段：

  print('请输入第一个数字:');
  var input1 = stdin.readLineSync();
  int num1 = int.parse(input1!);

  print('请输入第二个数字:');
  var input2 = stdin.readLineSync();
  int num2 = int.parse(input2!);

  bool boolResult = num1 > num2;
  print('当 num1 = $num1 且 num2 = $num2 时，(num1 > num2) 的结果是: $boolResult');

在这个改进版本中，布尔变量boolResult存储的是表达式num1 > num2的评估结果，这比直接处理字符串”true”或”false”更符合布尔逻辑的本质。

总结

本节课中我们一起学习了如何构建一个交互式的Dart程序。我们掌握了从标准输入读取用户数据的方法，并运用逻辑与（&&）、逻辑或（||）和逻辑非（!）运算符对输入值进行组合判断。最后，我们还探讨了通过数值比较来生成布尔值的更佳实践，这有助于编写更清晰、更不易出错的逻辑代码。

017：使用位运算符

概述

在本节课中，我们将学习Dart编程语言中的位运算符。位运算符允许我们在二进制位级别上对数据进行操作，这对于处理底层数据、优化性能或执行特定计算非常有用。我们将通过创建示例程序来理解各种位运算符的工作原理。

位运算符简介

上一节我们介绍了三元运算符，本节中我们来看看位运算符。位运算符意味着在操作数的二进制位级别执行计算或操作。例如，数字42的二进制表示为101010，数字12的二进制表示为001100。内存中的每个数字或字母都有其对应的二进制值，位运算符就是对这些二进制值进行操作的。

以下是Dart中主要的位运算符：

• & (按位与)：对两个操作数的每一位执行逻辑与操作。
• | (按位或)：对两个操作数的每一位执行逻辑或操作。
• ^ (按位异或)：对两个操作数的每一位执行逻辑异或操作。
• ~ (按位取反)：对操作数的每一位执行逻辑非操作（即取反）。
• << (左移)：将操作数的所有位向左移动指定的位数，右侧用0填充。
• >> (右移)：将操作数的所有位向右移动指定的位数。

创建位运算符示例

现在，让我们创建一个简单的示例程序来演示这些位运算符的用法。我们将声明两个整数变量，对它们应用各种位运算符，并打印结果。

void main() {
  // 声明变量并赋值
  int var1 = 42;
  int var2 = 12;
  int result;

  // 1. 按位与 (&) 操作
  result = var1 & var2;
  print('var1 的值是：$var1');
  print('var2 的值是：$var2');
  print('var1 & var2 的结果是：$result');

  // 2. 按位或 (|) 操作
  result = var1 | var2;
  print('\nvar1 | var2 的结果是：$result');

  // 3. 按位异或 (^) 操作
  result = var1 ^ var2;
  print('var1 ^ var2 的结果是：$result');

  // 4. 按位取反 (~) 操作
  result = ~var1;
  print('~var1 的结果是：$result');

  // 5. 左移 (<<) 操作
  result = var1 << 3;
  print('var1 << 3 (左移3位) 的结果是：$result');

  // 为了演示右移，我们使用左移后的结果
  var1 = result; // var1 现在变为 336
  // 6. 右移 (>>) 操作
  result = var1 >> 3;
  print('var1 >> 3 (右移3位) 的结果是：$result');
}

代码执行与输出分析

保存并运行上述代码后，你将看到类似以下的输出。让我们分析每个操作的结果：

1. 按位与 (&)：42 & 12 的结果是 8。这是因为在二进制中，只有两个对应位都为1时，结果位才为1。
2. 按位或 (|)：42 | 12 的结果是 46。这是因为只要两个对应位中有一个为1，结果位就为1。
3. 按位异或 (^)：42 ^ 12 的结果是 38。这是因为当两个对应位不同时，结果位为1。
4. 按位取反 (~)：~42 的结果是 -43。这是因为取反操作会翻转所有位（包括符号位），在二进制补码表示中得到了这个负数值。
5. 左移 (<<)：42 << 3 的结果是 336。这相当于将42乘以2的3次方 (42 * 8)。
6. 右移 (>>)：将左移后的结果 336 右移3位，得到 42。这相当于将336除以2的3次方 (336 / 8)，结果取整数部分。

总结

本节课中我们一起学习了Dart中的位运算符。我们了解了&、|、^、~、<<和>>这些运算符的功能，并通过一个完整的示例程序观察了它们在实际运算中的结果。位运算符是进行底层数据处理和特定算法优化的强大工具。在下一节中，我们将探讨如何从用户输入获取值，并在此基础上应用位运算符。

018：使用Dart类型运算符检查数据类型

概述

在本节课中，我们将学习Dart编程语言中的位运算符和条件运算符。我们将通过创建多个示例程序来理解这些运算符的工作原理，包括如何执行位运算以及如何使用条件运算符进行快速的条件判断。

位运算符示例

上一节我们介绍了基本的算术运算符，本节中我们来看看位运算符。位运算符直接对整数的二进制位进行操作。

以下是创建第一个位运算符示例程序的步骤。

1. 创建一个名为 file8.dart 的新文件。
2. 在文件开头导入 dart:io 库。
3. 在 void main() 函数中，声明变量 var1、var2 和 result。
4. 使用 print 和 stdin.readLineSync() 提示用户输入 var1 和 var2 的值。
5. 使用 int.parse() 将输入的字符串转换为整数，并分别赋值给 intVar1 和 intVar2。
6. 执行位与运算：result = intVar1 & intVar2。
7. 使用 print 语句输出 intVar1、intVar2 和 result 的值。
8. 复制上述打印语句，将运算符 & 依次改为 |（位或）、^（位异或）。
9. 对于按位取反运算符 ~，只需对一个操作数进行运算，例如 result = ~intVar1。
10. 对于左移运算符 <<，执行 result = intVar1 << 2（左移2位）。
11. 对于右移运算符 >>，执行 result = intVar1 >> 2（右移2位）。
12. 分别输出这些运算的结果。

运行 file8.dart 程序，输入两个数字（例如4和2），程序将显示所有位运算的结果。理解这些结果需要计算输入数字的二进制表示。

条件运算符

现在，让我们进入下一组运算符：条件运算符。条件运算符有多种类型。

以下是两种主要的条件运算符。

• 三元运算符 (? :)：这是 if 语句的简写形式。它评估一个表达式，如果为真，则返回问号 ? 后面的值；如果为假，则返回冒号 : 后面的值。其基本形式为：condition ? exprIfTrue : exprIfFalse
• 空值合并运算符 (??)：用于处理可能为 null 的值。如果第一个表达式不为 null，则返回其值；如果为 null，则返回第二个表达式的值。其基本形式为：expr1 ?? expr2

三元运算符示例

首先，我们通过示例学习三元运算符。

以下是使用三元运算符比较两个数字的步骤。

1. 创建一个名为 file9.dart 的新文件。
2. 在 void main() 函数中，声明两个整数变量并赋值，例如 number1 = 40， number2 = 30。
3. 使用三元运算符：result = (number1 > number2) ? ‘Higher Number’ : ‘Smaller Number’。
4. 打印结果：print(‘The result is: $result’)。
5. 运行程序。因为 40 > 30 为真，所以输出 “Higher Number”。如果将 number1 改为 20，表达式为假，则输出 “Smaller Number”。

为了使其交互性更强，我们可以创建一个接受用户输入的程序。

以下是创建交互式三元运算符程序的步骤。

1. 创建新文件 file10.dart。
2. 导入 dart:io。
3. 在 main 函数中，声明变量 number1、number2 和 result。
4. 使用 print 和 stdin.readLineSync() 提示用户输入两个数字。
5. 使用 int.parse() 将输入转换为整数。
6. 使用相同的三元运算符逻辑判断并存储结果。
7. 打印结果。
8. 运行程序，输入不同的数字组合（如90和5，或5和90）以验证逻辑。

空值合并运算符示例

接下来，我们看看空值合并运算符 ?? 的用法。

以下是空值合并运算符的基本示例。

1. 创建新文件 file11.dart。
2. 在 main 函数中，声明两个变量：int? number1 = null 和 int number2 = 40。
3. 使用空值合并运算符：result = number1 ?? number2。
4. 打印结果：print(‘The result is: $result’)。
5. 运行程序。因为 number1 为 null，所以输出 number2 的值 40。
6. 将 number1 改为非空值（如 4）并再次运行，此时将输出 number1 的值 4。

我们也可以创建一个接受用户输入的程序来演示。

以下是创建交互式空值合并运算符程序的步骤。

1. 创建新文件 file12.dart。
2. 导入 dart:io。
3. 在 main 函数中，声明 int? number1 = null 和 int number2。
4. 提示用户输入 number2 的值，并使用 int.parse() 进行转换。
5. 使用 result = number1 ?? number2 进行赋值。
6. 打印结果。由于 number1 始终为 null，程序将输出用户输入的 number2 的值。

总结

本节课中我们一起学习了Dart中的位运算符和条件运算符。我们通过实践了解了位与(&)、位或(|)、位异或(^)、取反(~)、左移(<<)和右移(>>)等位运算。同时，我们掌握了三元运算符(? :)用于简化条件判断，以及空值合并运算符(??)用于安全地处理可能为null的变量。这些运算符是构建复杂逻辑和进行底层数据操作的基础工具。

019：Dart常量 🎯

概述

在本节课中，我们将要学习Dart编程语言中的常量。我们将了解什么是常量，如何创建和使用final与const关键字来定义常量变量，以及它们与普通变量的区别。掌握常量对于编写稳定、可预测的代码至关重要。

理解常量

在上一节中，我们学习了变量。本节中，我们来看看常量。在任何编程语言中，常量的字面意思都是“不可改变的值”。这意味着，当你创建一个常量变量并为其赋值后，该值在后续的程序执行中将保持不变，无法被重新赋值。这与普通变量不同，普通变量的值可以被修改。

在Dart编程中，有两种方式可以创建常量：

1. 使用 final 关键字。
2. 使用 const 关键字。

两者的语法和适用场景略有不同，接下来我们将逐一探讨。

创建 final 变量

首先，我们学习如何使用 final 关键字来创建常量。

以下是创建 final 变量的步骤和注意事项：

• 声明并初始化：使用 final 关键字声明变量时，必须同时为其赋值（初始化）。
• 不可重新赋值：一旦 final 变量被赋值，其值就不能再被改变。

让我们通过一个例子来理解。创建一个名为 L_file1.dart 的新文件。

void main() {
  // 正确：声明final变量并立即初始化
  final varFin1 = 50;

  // 错误：仅声明final变量而不初始化会导致错误
  // final varFin2; // 取消注释这行会看到错误提示

  // 正确：声明的同时进行初始化
  final varFin2 = 0;
}

如代码所示，final varFin2; 这行代码会引发错误，提示“Final variable must be initialized”。这说明 final 变量必须在声明时完成初始化。

创建 const 变量

接下来，我们看看如何使用 const 关键字来创建常量。const 用于定义编译时常量，其值必须在编译时就能确定。

一个典型的例子是数学常数π（pi），它的值是固定不变的。

void main() {
  // 使用const关键字定义常量pi
  const pi = 3.14;

  // 定义一个半径变量（非常量）
  int radius = 55;

  // 使用常量pi进行计算
  double result = pi * radius * radius;

  // 打印所有变量的值
  print('Final variable varFin1 value is: $varFin1');
  print('Final variable varFin2 value is: $varFin2');
  print('Constant variable pi value is: $pi');
  print('The result (pi * r * r) is: $result');
}

运行这段代码，输出结果将显示各个变量的值，并计算出圆的面积。尝试在初始化后重新给 pi 赋值（例如 pi = 3.14159;），编译器会报错“Constant variables can‘t be assigned a value”，这验证了常量的不可变性。

常量的核心要点

总结一下关于 final 和 const 的核心概念：

• 共同点：两者声明的变量都只能被赋值一次，之后其值不可更改。
• final：侧重于“运行时常量”。变量在运行时被初始化，且初始化后不可变。
• const：侧重于“编译时常量”。变量的值必须在代码编译时就确定下来，通常是字面量（如数字、字符串）或其它常量表达式。

核心公式：常量变量 = 一次性赋值 + 值不可变

过渡到数字类型

我们已经掌握了如何创建常量来固定不变的值。接下来，让我们把目光转向Dart中的数字类型（整数 int 和浮点数 double），看看它们有哪些内置的属性和方法可供使用。

数字类型的输入与输出

为了演示数字的用法，我们将创建一个新文件 L_file2.dart。这个例子会从控制台读取用户输入的整数和浮点数。

以下是实现用户输入的基本流程：

1. 导入 dart:io 库以使用输入输出功能。
2. 提示用户输入并读取控制台的信息。
3. 使用 int.parse() 和 double.parse() 将字符串转换为数字。

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/74e0c8a4de16875e2c032aaa9467158f_11.png)

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/74e0c8a4de16875e2c032aaa9467158f_12.png)

void main() {
  int varInt;
  double varDouble;

  // 提示用户输入整数
  print('Please enter the value for Integer variable:');
  // 读取一行输入并转换为整数
  varInt = int.parse(stdin.readLineSync()!);

  // 提示用户输入浮点数
  print('Please enter the value for Double variable:');
  // 读取一行输入并转换为浮点数
  varDouble = double.parse(stdin.readLineSync()!);

  // 打印输入的值
  print('Integer value entered was: $varInt');
  print('Double value entered was: $varDouble');
}

这段代码演示了如何与用户交互，获取动态的数值输入，并将其存储在相应类型的变量中。

总结

本节课中我们一起学习了Dart编程中常量的概念和应用。我们深入探讨了：

• 使用 final 关键字创建运行时常量，它必须在声明时初始化。
• 使用 const 关键字创建编译时常量，其值在编译时就必须确定。
• 理解了常量“一经赋值，不可更改”的核心特性。
• 通过计算圆面积的例子实践了常量的使用。
• 最后，我们过渡到了数字类型，学习了如何从控制台接收用户的数字输入。

掌握常量能帮助你定义程序中那些不应改变的值（如配置、数学常数），从而使代码更加健壮和清晰。在下一节中，我们将继续探索Dart的其他数据类型。

020：数字类型属性与方法详解 🔢

在本节课中，我们将学习Dart语言中数字类型（int和double）的常用属性和方法。通过理解这些内置功能，你可以更高效地处理和操作数字数据。

上一节我们介绍了Dart中的常量和变量，本节中我们来看看数字类型本身提供了哪些有用的工具。

数字类型的属性

数字类型提供了一系列属性，用于获取关于该数字的特定信息，例如它是否为负数、是否为偶数等。

以下是数字类型的一些常用属性及其说明：

• hashCode：返回该数字的哈希码。这是一个唯一的整数值，常用于集合（如Set或Map键）中。
  • 代码示例：print(‘hashCode: ${numVar.hashCode}’);
• isFinite：检查数字是否为有限值（非无穷大）。返回布尔值true或false。
  • 代码示例：print(‘isFinite: ${numVar.isFinite}’);
• isInfinite：检查数字是否为无穷大。返回布尔值true或false。
  • 代码示例：print(‘isInfinite: ${numVar.isInfinite}’);
• isNaN：检查数字是否为“非数字”（Not-a-Number）。返回布尔值true或false。
  • 代码示例：print(‘isNaN: ${numVar.isNaN}’);
• isNegative：检查数字是否为负数。返回布尔值true或false。
  • 代码示例：print(‘isNegative: ${numVar.isNegative}’);
• sign：返回数字的符号。如果数字为负数，返回-1；如果为0，返回0；如果为正数，返回1。
  • 代码示例：print(‘sign: ${numVar.sign}’);
• isEven：检查整数是否为偶数。仅适用于int类型，返回布尔值true或false。
  • 代码示例：print(‘isEven: ${intVar.isEven}’);
• isOdd：检查整数是否为奇数。仅适用于int类型，返回布尔值true或false。
  • 代码示例：print(‘isOdd: ${intVar.isOdd}’);

示例运行结果：假设我们有一个整数变量 intVar = -56，上述属性检查的结果可能为：isFinite: true，isNegative: true，sign: -1，isEven: true，isOdd: false。

数字类型的方法

除了属性，数字类型还提供了多种方法，用于执行数学运算和转换。

以下是数字类型的一些常用方法及其说明：

• abs()：返回数字的绝对值（正数）。
  • 代码示例：print(‘abs(): ${numVar.abs()}’);
• ceil()：返回不小于当前数字的最小整数（向上取整）。
  • 代码示例：print(‘ceil(): ${numVar.ceil()}’);
• floor()：返回不大于当前数字的最大整数（向下取整）。
  • 代码示例：print(‘floor(): ${numVar.floor()}’);
• compareTo(other)：将当前数字与另一个数字other进行比较。如果相等返回0，如果当前数字大返回1，如果小返回-1。
  • 代码示例：print(‘compareTo(56.66): ${numVar.compareTo(56.66)}’);
• remainder(other)：返回当前数字除以other后的余数。
  • 代码示例：print(‘remainder(10): ${numVar.remainder(10)}’);
• round()：返回最接近当前数字的整数（四舍五入）。
  • 代码示例：print(‘round(): ${numVar.round()}’);
• toInt()：将数字转换为整数（int类型），直接舍弃小数部分。
  • 代码示例：print(‘toInt(): ${numVar.toInt()}’);
• truncate()：返回舍弃小数部分后的整数。对于正数，效果同floor()；对于负数，效果同ceil()。
  • 代码示例：print(‘truncate(): ${numVar.truncate()}’);

示例运行结果：假设我们有一个双精度浮点数变量 doubleVar = 65.66，上述方法调用的结果可能为：abs(): 65.66，ceil(): 66，floor(): 65，round(): 66，toInt(): 65，truncate(): 65。

---

本节课中我们一起学习了Dart数字类型的核心属性和方法。属性用于查询数字的状态（如正负、奇偶），而方法用于对数字进行运算和转换（如取整、取绝对值）。熟练掌握这些工具，能让你在编写涉及数值计算的Dart程序时更加得心应手。

021：列表与字符串操作

在本节课中，我们将学习Dart中字符串的常用操作方法，包括字符串连接、大小写转换、修剪空格、比较、替换和子字符串提取。最后，我们将初步了解Dart中的列表概念。

字符串连接与用户输入

上一节我们介绍了变量的基本使用，本节中我们来看看如何接收用户输入并进行字符串操作。

首先，我们创建一个程序来接收用户的名字和地址，并使用加号（+）运算符连接字符串。

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/dc3e5f6b83b3f0ed6b5504728d3c5cd7_15.png)

void main() {
  String fName;
  String lName;
  String address;

  print('请输入您的名字：');
  fName = stdin.readLineSync()!;

  print('请输入您的姓氏：');
  lName = stdin.readLineSync()!;

  print('请输入您的地址：');
  address = stdin.readLineSync()!;

  print('您的姓名是：' + fName + lName);
  print('您的地址是：' + address);
}

运行上述代码会发现，输出的姓名中名字和姓氏连在一起，没有空格。这是因为+运算符只是简单地将字符串拼接起来。

为了解决这个问题，我们需要在连接时手动添加一个空格。

print('您的姓名是：' + fName + ' ' + lName);

现在，输出的姓名中名字和姓氏之间就有了空格。

常用的字符串方法

除了连接，Dart还为字符串提供了多种实用的方法。以下是一些核心方法的介绍。

以下是几个关键的字符串方法及其用法：

1. toLowerCase(): 将字符串中的所有字符转换为小写。

   String name = fName + ' ' + lName;
   print(name.toLowerCase()); // 输出小写姓名
   

2. toUpperCase(): 将字符串中的所有字符转换为大写。

   print(name.toUpperCase()); // 输出大写姓名
   

3. trim(): 移除字符串开头和结尾的所有空白字符（如空格、制表符）。

   String nameWithSpaces = '  $name  ';
   print(nameWithSpaces.trim()); // 输出去除首尾空格的姓名
   

4. compareTo(): 比较两个字符串。如果相等返回0，否则返回非零值（通常是1或-1）。

   print(name.compareTo('Prianka')); // 比较姓名与“Prianka”
   

5. replaceAll(): 将字符串中所有匹配指定模式的部分替换为新的子串。

   print(name.replaceAll('ya', 'yaa')); // 将所有的“ya”替换为“yaa”
   

6. substring(): 从字符串中提取指定起始索引（包含）到结束索引（不包含）的子串。如果只提供一个参数，则提取到字符串末尾。

   print(name.substring(4)); // 从索引4（第5个字符）开始提取到末尾
   

综合示例程序

让我们将以上所有方法整合到一个完整的示例程序中。

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/dc3e5f6b83b3f0ed6b5504728d3c5cd7_42.png)

void main() {
  String fName;
  String lName;
  String address;

  print('请输入您的名字：');
  fName = stdin.readLineSync()!;

  print('请输入您的姓氏：');
  lName = stdin.readLineSync()!;

  print('请输入您的地址：');
  address = stdin.readLineSync()!;

  String fullName = fName + ' ' + lName;

  print('您的姓名是：$fullName');
  print('您的地址是：$address');
  print('小写姓名：${fullName.toLowerCase()}');
  print('大写姓名：${fullName.toUpperCase()}');
  print('修剪后姓名：“${fullName.trim()}”');
  print('与“Prianka”比较：${fullName.compareTo(“Prianka”)}');
  print('替换“ya”为“yaa”：${fullName.replaceAll(“ya”, “yaa”)}');
  print('从索引4开始的子串：${fullName.substring(4)}');
}

运行此程序，输入“Prianka”、“Sharma”和一个地址，可以看到各种字符串方法的效果。trim()方法会移除首尾空格，但不会移除中间的空格。compareTo()在完全匹配时返回0。substring(4)会从字符串的第5个字符（索引从0开始）开始截取。

引入列表概念

在学习了数字和字符串的操作后，我们常常需要处理一组相关的数据。Dart中的列表（List） 就是一种用于存储有序元素集合的对象。

列表允许我们将多个值（可以是同类型或不同类型）组合到一个变量中，并通过索引来访问它们。这为管理数据集合提供了极大的便利。

本节课中我们一起学习了Dart中字符串的核心操作方法，包括使用+进行连接，以及toLowerCase()、toUpperCase()、trim()、compareTo()、replaceAll()和substring()等内置方法。我们还初步接触了列表（List）的概念，它是组织多个数据元素的强大工具。掌握这些基础知识是进行更复杂Dart编程的关键步骤。

022：列表（第二部分）📚

在本节课中，我们将要学习如何在Dart中创建和使用列表。列表是一种用于存储多个相同类型对象的集合。我们将学习如何创建固定长度和可增长长度的列表，如何向列表中添加值，以及如何访问和打印列表中的元素。此外，我们还将了解列表的一些常用属性和方法。

---

上一节我们介绍了列表的基本概念，本节中我们来看看如何具体创建和操作列表。

列表是对象的集合。如果你想将一些相似类型的值放在一起，例如整数值、双精度浮点数值或字符串值，你可以创建一个列表来存储这些同类型的值。这意味着，如果列表是整数类型，那么所有值都必须是整数；如果是双精度浮点数类型，所有值都必须是双精度浮点数；字符串列表也是如此。

列表可以创建为固定长度，这意味着你需要指定列表的大小，例如创建一个包含五个整数值的列表。列表也可以是可增长的，这意味着当向列表中添加值时，列表会自动在后台扩展。

我们将首先看一个创建列表的简单示例。我们将创建一个字符串类型的列表来存储星期几的值。

让我们快速创建另一个文件，命名为 file4.dart。由于我们不接受外部输入，只是在本例中创建列表，因此我们从 void main 开始。

以下是创建列表的步骤：

1. 使用 List 关键字。
2. 指定列表的类型（例如 String）。
3. 为列表命名。

我们创建一个名为 weekdays 的列表，它是 List<String> 类型，并将包含七个字符串值。这样我们就定义了一个列表。

void main() {
  List<String> weekdays = List<String>(7);
}

这是一个固定长度的列表，我们指定了它将自动包含七个值，不能超过七个值。

那么，如何将值放入这个列表呢？你可以通过索引来赋值。例如，weekdays[0] 表示列表的第一个位置，我们在这里放入值 “Monday”。同样地，weekdays[1] 放入 “Tuesday”。

在继续插入所有值之前，让我们先插入几个值，然后解释索引的概念。

  weekdays[0] = "Monday";
  weekdays[1] = "Tuesday";
  weekdays[2] = "Wednesday";
  weekdays[3] = "Thursday";
  weekdays[4] = "Friday";
  weekdays[5] = "Saturday";
  weekdays[6] = "Sunday";

现在我们已经插入了所有值，让我们理解一下索引编号。我们创建了一个包含七个值的列表。索引总是从 0 开始。第二个值的索引是 1，第三个是 2，依此类推，直到第六个索引 6。索引号 6 对应的是第七个值，因为索引的起始位置是 0（即第一个值）。因此，我们通过索引 0 到 6 存储了七个值。

现在，我们想要打印这个列表。我们将使用 print 命令来输出 weekdays 列表。

  print("Values of weekdays list are:");
  print(weekdays);

如果你执行这个 file4.dart 文件，它会以逗号分隔的形式输出列表中的所有值，因为我们创建的是一个字符串数组。

但是，如果你想从用户那里接收输入，然后将值打印回命令行，该怎么办呢？为此，让我们做另一个练习。

让我们创建另一个文件，命名为 file5.dart。在这里，我们将从导入 dart:io 库开始，以便处理输入/输出操作。

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/9098158414e2c103a8db45d98d03c395_26.png)

void main() {
  // 创建列表的代码将放在这里
}

在 main 函数中，我们将再次创建一个字符串类型的列表，同样命名为 weekdays，它是一个能容纳七个值的 List<String>。

  List<String> weekdays = List<String>(7);

这与之前没有区别，唯一的区别在于，我们不是直接在这里赋值，而是让用户输入值。

首先，我们给出提示，要求用户输入列表的第一个值。然后，我们使用 stdin.readLineSync() 将输入的值存储到 weekdays[0] 中。

以下是获取用户输入并填充列表所有七个位置的步骤：

  print("Enter the first value for the list:");
  weekdays[0] = stdin.readLineSync();

  print("Enter the second value for the list:");
  weekdays[1] = stdin.readLineSync();

  print("Enter the third value for the list:");
  weekdays[2] = stdin.readLineSync();

  print("Enter the fourth value for the list:");
  weekdays[3] = stdin.readLineSync();

  print("Enter the fifth value for the list:");
  weekdays[4] = stdin.readLineSync();

  print("Enter the sixth value for the list:");
  weekdays[5] = stdin.readLineSync();

  print("Enter the seventh value for the list:");
  weekdays[6] = stdin.readLineSync();

现在，我们已经从用户那里接受了所有值。为了将其打印回来，我们可以说“列表的值是”，然后打印 weekdays 列表。

  print("\nValues of weekdays list are:");
  print(weekdays);

此外，列表还有一些我们可以使用的属性和方法。例如，我们想知道列表中添加了多少个元素，可以使用 weekdays.length 属性。

以下是列表的一些有用属性：

• length: 获取列表中元素的数量。

  print("Length of list is: ${weekdays.length}");
  

• first: 获取列表中的第一个元素。

  print("First value in list is: ${weekdays.first}");
  

• last: 获取列表中的最后一个元素。

  print("Last value in list is: ${weekdays.last}");
  

如果你执行 file5.dart，你不需要只输入星期几的值。例如，你可以输入月份：Jan, Feb, March, April, May, June, July。所有输入的值都会在命令行回显打印出来。列表的长度是 7，因为我们输入了七个元素。列表的第一个元素是 Jan，最后一个元素是 July。

在任意编程语言中创建列表的主要优势在于，能够将多个相同类型的值存储在一个列表中。这非常简单易懂。

---

本节课中我们一起学习了Dart列表的创建、赋值、访问以及基本属性。我们创建了固定长度的列表，并通过索引为其赋值。我们还学习了如何从用户输入填充列表，并使用 length、first 和 last 等属性来获取列表信息。列表是组织和管理一组相关数据的强大工具。接下来，我们将通过一个关于列表的练习来巩固所学知识，并结束初学者阶段的课程。

023：Dart列表第三部分 - 员工信息录入程序 📝

在本节课中，我们将完成一个综合性的编程作业。我们将创建一个程序，用于接收并存储5名员工的姓名、年龄和地址信息，然后将其显示出来。通过这个练习，我们将巩固对Dart列表的理解和应用。

概述

我们将创建一个程序，它需要完成以下任务：

1. 创建三个独立的列表，分别用于存储员工的姓名、年龄和地址。
2. 通过控制台依次接收5名员工的上述信息。
3. 将接收到的信息分别存入对应的列表中。
4. 在所有信息录入完毕后，将存储的信息完整地显示出来。

这个练习将综合运用我们之前学到的列表创建、数据输入和输出等知识。

程序设计与实现

首先，我们需要导入dart:io库以支持控制台输入输出操作。然后，在main函数中开始构建我们的程序。

第一步：创建列表

程序的第一步是创建三个列表。根据需求，我们需要一个字符串列表来存储姓名，一个整数列表来存储年龄，以及另一个字符串列表来存储地址。每个列表都需要能够容纳5个值。

以下是创建列表的代码：

import 'dart:io';

![](https://github.com/OpenDocCN/cs-notes-pt1-zh/raw/master/docs/educba-dart-bgn/img/96dc0372395b6dec4e47a586d38434db_20.png)

void main() {
  // 创建存储员工姓名的列表，类型为String，容量为5
  List<String> empName = List.filled(5, '');
  // 创建存储员工年龄的列表，类型为int，容量为5
  List<int> empAge = List.filled(5, 0);
  // 创建存储员工地址的列表，类型为String，容量为5
  List<String> empAddress = List.filled(5, '');
}

第二步：接收用户输入

列表创建完成后，我们需要接收用户输入。由于尚未学习循环结构，我们将为每位员工重复编写输入代码。对于每位员工，我们需要提示用户输入姓名、年龄和地址，并将输入的值存储到列表的相应索引位置。

以下是接收第一位员工信息的代码示例：

  // 接收第一位员工的信息（索引为0）
  print('Enter value for Employee 1:');
  
  print('Enter name:');
  empName[0] = stdin.readLineSync()!;
  
  print('Enter age:');
  empAge[0] = int.parse(stdin.readLineSync()!);
  
  print('Enter address:');
  empAddress[0] = stdin.readLineSync()!;
  
  print('-------------------------'); // 分隔线

关键点说明：

• stdin.readLineSync() 用于从控制台读取一行字符串输入。
• 对于年龄（整数），我们需要使用 int.parse() 将输入的字符串转换为整数类型。
• 代码末尾的 print('-------------------------') 用于在控制台输出中分隔不同员工的信息，使界面更清晰。

按照相同的模式，我们需要为第2到第5位员工编写类似的代码块，只需将列表索引分别改为1、2、3、4。

第三步：显示存储的信息

所有信息录入完毕后，我们需要将存储的数据打印出来，以验证程序是否正确工作。

以下是显示第一位员工信息的代码：

  // 显示第一位员工的信息
  print('Value entered for Employee 1 is:');
  print('Employee name: ${empName[0]}');
  print('Employee age: ${empAge[0]}');
  print('Employee address: ${empAddress[0]}');
  print('========================='); // 分隔线

同样，我们需要为其他四位员工复制并修改这段代码，调整索引值。

程序运行示例

当程序运行时，控制台交互可能如下所示：

Enter value for Employee 1:
Enter name:
张三
Enter age:
30
Enter address:
北京路1号
-------------------------
Enter value for Employee 2:
Enter name:
李四
Enter age:
40
Enter address:
上海路2号
-------------------------
... (依次输入3、4、5号员工信息)

Value entered for Employee 1 is:
Employee name: 张三
Employee age: 30
Employee address: 北京路1号
=========================
Value entered for Employee 2 is:
Employee name: 李四
Employee age: 40
Employee address: 上海路2号
=========================
... (依次显示3、4、5号员工信息)

总结与展望

本节课中，我们一起完成了一个Dart列表的综合应用作业。我们创建了多个列表来存储不同类型的数据，通过标准输入接收用户信息，并最终将数据输出。

这个程序虽然功能完整，但代码存在大量重复。正如视频中所提到的，目前我们通过手动复制代码块来处理5位员工的信息，这使程序显得冗长。在后续的中级课程中，我们将学习循环结构（例如 for 或 while 循环）。使用循环，可以用几行代码替代现在的大量重复代码，让程序变得简洁高效。例如，接收5位员工信息的核心逻辑可以简化为：

for (int i = 0; i < 5; i++) {
  print('Enter value for Employee ${i + 1}:');
  print('Enter name:');
  empName[i] = stdin.readLineSync()!;
  // ... 接收年龄和地址
}

通过本课程的基础部分，我们已经学习了Dart编程的概述、语法、关键字、变量与数据类型、各类运算符（算术、赋值、逻辑、关系、位运算）以及常量的使用，并通过大量示例进行了实践。这个员工信息管理程序为初学者阶段画上了一个圆满的句号，也为学习更高级的编程概念打下了坚实的基础。