榆树 - 快速指南

---

榆树 - 简介

Elm 是一种函数式编程语言。它由 Evan Czaplicki 于 2012 年设计。

Elm 专门用于设计 Web 应用程序的前端。

Elm 编译为 JavaScript 并在浏览器中运行。它快速、可测试、可维护，并且没有运行时异常。

Elm 编程平台的一些实际应用包括 -

• 游戏
• 图形
• 单页应用程序

为什么选择榆树

Elm 消除了前端开发人员面临的大部分常见问题。这包括 -

无运行时异常

Elm 是一种静态类型语言。所有可能的错误都会在编译时得到验证和纠正。这使得没有运行时异常成为可能。

开发人员友好的错误消息

与其他编程语言不同，Elm 的编译器旨在在编译时提供非常具体且开发人员友好的错误消息。错误消息还包括提示，例如推荐设计文档的链接。

易于测试

每个 Elm 函数都可以独立于所有其他函数进行测试。这使得用 Elm 编写的程序易于测试。

自动语义版本控制

Elm 强制执行包的自动语义版本控制。这可确保补丁更改不会使已运行的应用程序崩溃。

可重用的代码

与 JavaScript、Python 或 TypeScript 中的函数相比，Elm 函数本质上易于重用。

Elm - 环境设置

本章讨论在 Windows、Mac 和 Linux 平台上安装 Elm 的步骤。

本地环境设置

请考虑按照下面所示的步骤在本地环境中安装 Elm。

步骤 1 - 安装节点

由于 elm 被编译为 JavaScript，因此目标机器应该安装Node。请参阅TutorialsPoint NodeJS 课程，了解设置Node和npm的步骤

节点设置。

步骤 2 - 安装 elm

在终端执行以下命令安装elm。请注意，在编写本课程时，elm 的稳定版本是 0.18。

npm install -g elm@0.18

安装完成后，执行以下命令验证Elm的版本。

C:\Users\dell>elm --version
0.18.0

第 2 步 - 安装编辑器

这里使用的开发环境是Visual Studio Code（Windows平台）。

Visual Studio Code 是 Visual Studio 的开源 IDE。它适用于 Mac OS X、Linux 和 Windows 平台。VSCode 位于

https://code.visualstudio.com/。

在 Windows 上安装

在本节中，我们将讨论在 Windows 上安装 Elm 的步骤。

下载https://code.visualstudio.com/。对于 Windows。

双击 VSCodeSetup.exe 以启动安装过程。这只需要一分钟。

您可以通过右键单击“文件”→“在命令提示符中打开”来直接遍历到文件的路径。同样，“在资源管理器中显示”选项会在文件资源管理器中显示文件。

在 Mac OS X 上安装

Visual Studio Code 的 Mac OS X 特定安装指南可以在VSCode Installation-MAC中找到。

在 Linux 上安装

Visual Studio Code 的 Linux 特定安装指南可以在VSCode Installation-Linux中找到。

步骤 4 - 安装 elm 扩展

在 VSCode 中安装 elm 扩展，如下所示。

榆树REPL

REPL 代表读取评估打印循环。它代表一个计算机环境，如 Windows 控制台或 Unix/Linux shell，其中输入命令，系统以交互模式响应输出。

Elm 与 REPL 环境捆绑在一起。它执行以下任务 -

• 读取 - 读取用户的输入，将输入解析为 elm 数据结构，并存储在内存中。

• Eval - 获取并评估数据结构。

• 打印 - 打印结果。

• Loop - 循环上述命令直到用户退出。使用命令 :exit 退出 REPL 并返回到终端。

下面显示了在 REPL 中添加两个数字的简单示例 -

打开 VSCode 终端并输入命令 elm REPL。

REPL 终端等待用户输入一些内容。输入以下表达式 10 + 20。REPL 环境处理输入，如下所示 -

• 从用户读取数字 10 和 20。

• 使用 + 运算符进行计算。

• 打印结果为 30。

• 循环下一个用户输入。这里我们退出循环。

Elm - 基本语法

本章讨论如何用 elm 编写一个简单的程序。

步骤 1 - 在 VSCode 中创建一个目录 HelloApp

现在，在此目录中创建一个文件 - Hello.elm。

上图显示了在 VSCode 中打开的项目文件夹HelloApp和终端。

步骤 2 - 安装必要的 elm 软件包

elm 中的包管理器是elm-package。安装elm-lang/html包。这个包将帮助我们在浏览器中显示 elm 代码的输出。

通过右键单击“文件”→“在 VSCode 的命令提示符中打开”，遍历到HelloApp项目文件夹。

在终端窗口中执行以下命令 -

C:\Users\dell\Elm\HelloApp> elm-package install elm-lang/html

安装包时，以下文件/文件夹将添加到项目目录中。

• elm-package.json（文件），存储项目元数据
• elm-stuff（文件夹），存放外部包

软件包安装成功后，将出现以下消息。

步骤 3 - 将以下代码添加到 Hello.elm 文件中

-- importing Html module and the function text
import Html exposing (text)

-- create main method
main =
-- invoke text function
text "Hello Elm from TutorialsPoint"

上面的程序将在浏览器中显示来自TutorialsPoint的字符串消息Hello Elm 。

为此，我们需要在Html模块中导入功能文本。text 函数用于打印浏览器中的任何字符串值。main 方法是程序的入口点。main方法调用文本函数并向其传递一个字符串值。

第 4 步 - 编译项目

在 VSCode 终端窗口中执行以下命令。

elm make Hello.elm

上述命令的输出如下所示 -

//update path to the proj folder in the command elm make
C:\Users\dell\elm\HelloApp>elm make Hello.elm
Success! Compiled 38 modules.
Successfully generated index.html

上面的命令将生成一个index.html文件。elm 编译器将 .elm 文件转换为 JavaScript 并将其嵌入到index.html文件中。

步骤 5 - 在浏览器中打开index.html

在任何浏览器中打开index.html文件。输出如下所示 -

榆树中的评论

注释是提高程序可读性的一种方法。注释可用于包含有关程序的附加信息，例如代码作者、有关函数构造的提示等。编译器会忽略注释。

Elm 支持以下类型的评论 -

• 单行注释 (--) - -- 和行尾之间的任何文本都被视为注释。

• 多行注释 ({- -}) - 这些注释可能跨越多行。

插图

-- this is single line comment

{- This is a
   Multi-line comment
-}

线条和缩进

Elm 不提供大括号来指示函数定义或流程控制的代码块。代码块由严格执行的行缩进表示。块中的所有语句必须缩进相同的量。例如 -

module ModuleIf exposing (..)
x = 0

function1 =
   if x > 5 then
      "x is greater"
   else
      "x is small"

但是，以下块会生成错误 -

-- Create file ModuleIf.elm
module ModuleIf exposing (..)
x = 0

function1 =
   if x > 5 then
      "x is greater"
         else --Error:else indentation not at same level of if statement
      "x is small"

因此，在 Elm 中，所有缩进相同数量空格的连续行将形成一个块。

C:\Users\admin>elm repl
---- elm-repl 0.18.0 -----------------------------------------------------------
   :help for help, :exit to exit, more at 
   <https://github.com/elm-lang/elm-repl>
   ---------------------------------------
   -----------------------------------------

> import ModuleIf exposing(..) -- importing module from ModuleIf.elm file
>function1 -- executing function from module
-- SYNTAX PROBLEM ---------------------------------------------------

I need whitespace, but got stuck on what looks like a new declaration. 
You are either missing some stuff in the declaration above or just need to add some spaces here:
7| else
   ^
I am looking for one of the following things:

   whitespace

Elm - 数据类型

类型系统表示该语言支持的不同类型的值。在程序存储或操作所提供的值之前，类型系统会检查它们的有效性。这确保了代码的Behave符合预期。类型系统还允许更丰富的代码提示和自动化文档。

Elm 是一种静态类型语言。Elm 的类型与其他语言的类型相似。

数字

数字数据类型表示数值。Elm 类型系统支持以下数字类型 -

类型号可以容纳小数和非小数值。打开 elm REPL 并尝试下面给出的示例 -

C:\Users\admin>elm repl
---- elm-repl 0.18.0 
---------------------------------------------
--------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
------------------------------------------
--------------------------------------
> 7
7 : number
> 7/2
3.5 : Float
> 7//2
3 : Int
>

字符串和字符

字符串数据类型用于表示字符序列。Char数据类型用于表示单个字符。字符串值用双引号 " 定义，而Char值用单引号 ' 括起来。

打开 elm REPL 并尝试下面给出的示例 -

C:\Users\admin>elm repl
---- elm-repl 0.18.0 ---------------------------------------
--------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
--------------------------------------
------------------------------------------
> "TutorialsPoint"
"TutorialsPoint" : String
> 'T'
'T' : Char

布尔

Elm 中的 Bool 数据类型仅支持两个值 - True 和 False。关键字 Bool 用于表示布尔值。

打开 elm REPL 并尝试下面给出的示例 -

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 -----------------------------------
------------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
----------------------------------------
----------------------------------------
> True
True : Bool
> False
False : Bool
> 1==1
True : Bool
> 1==2
False : Bool
> 1 /= 2 -- not equal
True : Bool
> not True
False : Bool
> not False
True : Bool

自定义类型

Elm 支持创建用户定义类型。例如，考虑一个支付应用程序。该应用程序需要存储不同的支付方式——信用卡、借记卡和网上银行。这可以通过定义自定义类型并将其值限制为三种可接受的支付方式来实现。

以下示例展示了如何创建自定义类型。

> type PaymentMode = CreditCard|NetBanking|DebitCard
> payment1 = CreditCard
CreditCard : Repl.PaymentMode
> payment2 = DebitCard
DebitCard : Repl.PaymentMode
> payment3 = UPI
-- NAMING ERROR ---------------------------------------------- repl-temp-000.elm

Cannot find variable `UPI`

7| payment3 = UPI

在上面的示例中，我们创建了一个 PaymentMode 自定义类型。变量 payment1 和 payment2 被分配给 PaymentMode 值。如果分配给变量的值与 PaymentMode 类型定义的任何值都不匹配，应用程序将引发语法错误。

结构化数据类型

结构化数据类型可用于以结构化格式存储多个值。Elm 支持以下结构化数据类型 -

• 元组
• 列表
• 记录
• 记录

这些将在接下来的章节中详细讨论。

Elm - 变量

根据定义，变量是“内存中存储值的命名空间”。换句话说，它充当程序中值的容器。变量帮助程序存储和操作值。

Elm 中的变量与特定的数据类型相关联。数据类型决定变量内存的大小和布局、可以存储在该内存中的值的范围以及可以对变量执行的操作集。

变量命名规则

在本节中，我们将了解变量命名规则。

• 变量名可以由字母、数字和下划线字符组成。
• 变量名不能以数字开头。它必须以字母或下划线开头。
• 大写和小写字母是不同的，因为 Elm 区分大小写。

Elm 中的变量声明

在 Elm 中声明变量的类型语法如下 -

语法1

variable_name:data_type = value

“:”语法（称为类型注释）用于将变量与数据类型关联起来。

语法2

variable_name = value-- no type specified

在 Elm 中声明变量时，数据类型是可选的。在这种情况下，变量的数据类型是根据分配给它的值推断出来的。

插图

本示例使用 VSCode 编辑器编写 elm 程序并使用 elm repl 执行它。

步骤 1 - 创建一个项目文件夹 - VariablesApp。在项目文件夹中创建 Variables.elm 文件。

将以下内容添加到文件中。

module Variables exposing (..) //Define a module and expose all contents in the module
message:String -- type annotation
message = "Variables can have types in Elm"

该程序定义了一个模块变量。模块的名称必须与 elm 程序文件的名称相同。(..) 语法用于公开模块中的所有组件。

该程序声明了一个String类型的变量 message 。

步骤 2 - 执行程序。

• 在 VSCode 终端中键入以下命令以打开 elm REPL。

elm repl

• 在 REPL 终端中执行以下 elm 语句。

> import Variables exposing (..) --imports all components from the Variables module
> message --Reads value in the message varaible and prints it to the REPL 
"Variables can have types in Elm":String
>

插图

使用 Elm REPL 尝试以下示例。

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 ---------------------------------------
--------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
-------------------------------------
------------------------------------------
> company = "TutorialsPoint"
"TutorialsPoint" : String
> location = "Hyderabad"
"Hyderabad" : String
> rating = 4.5
4.5 : Float

这里，变量 company 和 location 是 String 变量， rating 是 Fl​​oat 变量。

elm REPL 不支持变量的类型注释。如果声明变量时包含数据类型，以下示例将引发错误。

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 -----------------------------------------
------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
----------------------------------------
----------------------------------------
> message:String
-- SYNTAX PROBLEM -------------------------------------------- repl-temp-000.elm

A single colon is for type annotations. Maybe you want :: instead? Or maybe you
are defining a type annotation, but there is whitespace before it?

3| message:String
^

Maybe <http://elm-lang.org/docs/syntax> can help you figure it out.

要在使用 elm REPL 时插入换行符，请使用 \ 语法，如下所示 -

C:\Users\dell\elm>elm repl
---- elm-repl 0.18.0 --------------------------------------
---------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
------------------------------------------
--------------------------------------
> company \ -- firstLine
| = "TutorialsPoint" -- secondLine
"TutorialsPoint" : String

Elm - 操作员

运算符定义将对数据执行的某些函数。运算符所作用的值称为操作数。考虑以下表达式

7 + 5 = 12

这里，值 7、5 和 12 是操作数，而 + 和 = 是运算符。

Elm 的主要运营商可分为 -

• 算术
• 关系型
• 逻辑性

算术运算符

假设变量a和b的值分别为7和2。

显示示例

关系运算符

关系运算符测试或定义两个实体之间的关系类型。这些运算符用于比较两个或多个值。关系运算符返回一个布尔值，即 true 或 false。

假设a的值为10，b的值为20。

显示示例

类似类型

>= 或 < 等比较运算符适用于可比较类型。它们被定义为数字、字符、字符串、列表、元组。运算符两侧的可比较类型必须相同。

打开 elm REPL 并尝试下面所示的示例 -

C:\Users\admin>elm repl
---- elm-repl 0.18.0 -----------------------------------------------------------
:help for help, :exit to exit, more at <https://github.com/elm-lang/elm-repl>
--------------------------------------------------------------------------------
> 7>2
True : Bool
> 7.0>2
True : Bool
> 7.0<2.0
False : Bool
> 'a' > 'b'
False : Bool
> 'a' < 'b'
True : Bool
> "a" < "b"
True : Bool
> (1,2) > (2,3)
False : Bool
> ['1','3'] < ['2','1']
True : Bool
>

逻辑运算符

逻辑运算符用于组合两个或多个条件。逻辑运算符也返回布尔值。

显示示例

榆树 - 决策

决策结构要求程序员指定要由程序评估或测试的一个或多个条件，以及如果条件被确定为真则要执行的一个或多个语句，以及可选的如果确定为真则要执行的其他语句条件被确定为假。

下面显示的是大多数编程语言中典型决策结构的一般形式

决策结构在执行指令之前评估条件。Elm 中的决策结构分类如下 -

if...then...else 语句

if ...then结构在执行代码块之前评估条件。如果布尔表达式的计算结果为 true，则将执行 then 语句内的代码块。如果布尔表达式的计算结果为 false，则将执行 else 语句内的代码块。

与其他编程语言不同，在 Elm 中我们必须提供 else 分支。否则，Elm 会抛出错误。

句法

if boolean_expression then statement1_ifTrue else statement2_ifFalse

插图

在 REPL 终端中尝试以下示例。

> if 10>5 then "10 is bigger" else "10 is small"
"10 is bigger" : String

嵌套如果

嵌套的 if 语句对于测试多个条件很有用。嵌套 if 语句的语法如下 -

if boolean_expression1 then statement1_ifTrue else if boolean_expression2 then statement2_ifTrue else statement3_ifFalse

插图

在 Elm REPL 中尝试以下示例 -

> score=80
80 : number
> if score>=80 then "Outstanding" else if score > = 70 then "good" else "average"
"Outstanding" : String

案例陈述

case 语句可用于简化 if then else 语句。case 语句的语法如下所示 -

case variable_name of
   constant1 -> Return_some_value
   constant2 -> Return_some_value
   _ -> Return_some_value if none of the above values match

case 语句检查变量的值是否与预定义的常量集匹配并返回相应的值。请注意，每种情况返回的值必须具有相同的类型。如果变量值与任何给定常量都不匹配，则控制权将传递给 *default *（用 //_ 表示）并返回相应的值。

插图

在 Elm REPL 中尝试以下示例 -

> n = 10
10 : number
> case n of \
| 0 -> "n is Zero" \
| _ -> "n is not Zero"
"n is not Zero" : String

上面的代码片段检查 n 的值是否为零。控制权被传递给默认值，它返回字符串“n is not Zero”。

榆树 - 循环

Elm 是一种函数式编程语言。Elm 使用递归概念作为传统循环结构的替代方案。

本章讨论递归的概念。

递归

一些计算机编程语言允许模块或函数调用自身。这种技术称为递归。

插图

在这个程序中，我们将看到如何使用递归来显示 hello 五次。

步骤 1 - 创建文件 Loop.elm

创建一个模块 Loop 并定义一个函数sayHello。函数 sayHello 接受一个整数值作为输入并返回一个字符串值。

module Loop exposing(..)
//function signature
sayHello:Int ->String
//function implementation
sayHello n =
   case n of
   1 -> "Hello:1 "
   _ -> "Hello:" ++ toString (n) ++ " " ++ sayHello(n-1)

函数 sayHello 检查传递的参数是否为 1。如果参数为 1，则函数将返回，否则将创建一个字符串 Hello 并调用相同的函数。

步骤 2 - 从 REPL 调用 sayHello

从当前项目文件夹（Loop.elm 文件的位置）打开 elm REPL。

//import the module Loop
> import Loop exposing(..)
//invoke the sayHello function with parameter value as 5
> sayHello 5
"Hello:5 Hello:4 Hello:3 Hello:2 Hello:1 Hello:0 " : String
>

插图

以下示例使用递归打印 n 个数字的总和。

> sumOfNos n =\
| if n==0 then 0 \
| else (n) + sumOfNos (n-1)
<function> : number -> number1

在 elm REPL 中，我们创建了一个函数 sumOfNos，它接受输入数字并对从 0 到该数字的所有数字求和。

例如，如果我们将输入传递为 5 ，则将1+2+3+4+5相加，即15。

> ssumOfNos 5
15 : number

程序的输出如上所示。

Elm - 功能

函数是 Elm 程序的构建块。函数是执行特定任务的一组语句。

函数将程序组织成逻辑代码块。一旦定义，就可以调用函数来访问代码。这使得代码可以重用。此外，函数使程序代码的阅读和维护变得容易。

使用函数的步骤

使用函数分为三个步骤 -

函数声明

函数声明告诉编译器函数的名称、返回类型和参数。声明函数的语法如下 -

fn_name:data_type_of_the_parameters ->return_type

函数声明指定以下内容 -

• 函数的名称。

• 参数的数据类型。这是可选的，因为函数可能有参数，也可能没有参数。

• 函数将返回的值的数据类型。Elm 中的函数必须始终返回一个值，因为 Elm 是一种函数式编程语言。与其他编程语言中的函数不同，Elm 函数不使用 return 关键字返回值。

函数定义或函数实现

函数定义提供了函数的实际主体。函数定义指定如何完成特定任务。定义函数的语法如下 -

fn_name parameter1 parameter2 = statements

调用或调用函数

必须调用函数才能执行它。调用函数的语法如下 -

fn_name parameter1 parameter2

插图

以下代码定义了一个函数greet。该函数返回一个字符串“Hello”。

> greet = \
| if True then \
| "Hello" \
| else \
| "GoodBye"
"Hello" : String
> greet
"Hello" : String

参数化函数

参数是一种将值传递给函数的机制。参数的值在函数调用时传递给函数。

图1

以下示例定义了函数fn_add。该函数接受两个数字作为参数并返回它们的总和。在 elm REPL 中尝试以下操作 -

> fn_add x y = x+y
<function> : number -> number -> number
> fn_add 10 20
30 : number

图2

以下示例定义了一个函数 sayHello。sayHello 函数接受并返回一个 String 值作为参数，并返回一个 String。

> sayHello name = "Hello "++ name
<function> : String -> String
> sayHello "Tutorialspoint"
"Hello Tutorialspoint" : String
>

管道操作员

为了理解管道运算符 |>，让我们考虑一个示例，其中我们有一个不同字符串的列表["a","b","c"]。现在我们需要一个字符串，用 - 分隔

以下示例展示了如何使用String.join来做到这一点

> String.join "-" ["a","b","c","d","e","f"]
"a-b-c-d-e-f" : String

使用管道运算符 |> 可以执行相同的操作。管道运算符可用于链接多个函数调用。

> ["a","b","c","d","e","f"] |> String.join "-"
"a-b-c-d-e-f" : String
> ["a","b","c","d","e","f"] |> List.reverse |> String.join "-"
"f-e-d-c-b-a" : String

在第一个示例中，我们将列表链接到 join 方法。在第二种情况下，相同的列表通过管道传送到反向函数，然后通过管道传送到连接。因此，列表以反向和连接的方式显示。

榆木 - 弦

Unicode 字符序列称为字符串。在 Elm 中，字符串用 ""双引号括起来。字符串是一段文本，如下所示。

> "TutorialsPoint"
"TutorialsPoint" : String
> location = "Hyderabad" --variable
"Hyderabad" : String
> location
"Hyderabad" : String
>

字符串函数

下面给出了一些可用于查询或操作字符串值的常用函数。使用 REPL 尝试下面给出的示例。

是空的

该函数可用于判断字符串是否为空。如果提供的字符串为空，则此函数返回 True。

句法

String.isEmpty String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.isEmpty
<function> : String -> Bool

函数的签名显示 Bool 作为返回类型，输入类型为 String -

插图

> String.isEmpty ""
True : Bool
> String.isEmpty "Tutorialspoint"
False : Bool
> location = "Hyderabad"
"Hyderabad" : String
> String.isEmpty location
False : Bool

撤销

该函数反转字符串。

句法

String.reverse String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.reverse
<function> : String -> String

函数的签名显示 String 作为返回类型，输入类型为 String -

插图

> String.reverse "TutorialsPoint"
"tnioPslairotuT" : String

长度

该函数返回字符串的长度。

句法

String.length String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.length
<function-> : String -> Int

该函数的签名显示 Int 作为返回类型，输入类型为 String。

插图

> String.length "Mohtashim"
9 : Int

附加

该函数通过附加两个字符串来返回一个新字符串。

句法

String.append String_value1 String_value2

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.append
<function-> : String -> String -> String

的签名显示两个字符串输入参数和一个字符串输出参数

插图

> String.append "Tutorials" "Point"
TutorialsPoint : String

连接

该函数通过将多个字符串连接成一个来返回一个新字符串。

句法

String.concat [String1,String2,String3]

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.concat
<function> : List String -> String

的签名显示了字符串输入参数和字符串返回类型的列表

插图

> String.concat ["Hello","Tutorials","Point"]
HelloTutorialsPoint : String

分裂

该函数使用给定的分隔符分割字符串。

句法

String.split string_seperator String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.split
<function> : String -> String -> List String

的签名显示两个输入字符串参数和作为字符串类型列表的输出。

插图

> String.split "," "Hello,Tutorials,Point"
["Hello","Tutorials","Point"] : List String

片

该函数返回给定开始和结束索引的子字符串。负索引是从列表末尾开始获取的。索引的值从零开始。

句法

String.slice start_index end_index String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.slice
<function> : Int -> Int -> String -> String

的签名显示了三个输入参数和一个返回类型。

插图

> String.slice 0 13 "TutorialsPoint"
"TutorialsPoin" : String

包含

如果第二个字符串包含第一个字符串，则此函数返回 True。

句法

String.contains string1 string2

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.contains
<function> : String -> String -> Bool

的签名显示了 bool 返回类型和两个输入参数

插图

> String.contains "Point" "TutorialsPoint"
True : Bool

至整数

该函数将字符串转换为 int。

句法

String.toInt string_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.toInt
<function> : String -> Result.Result String Int

由于toInt可以返回错误，因此返回类型为Result，即String或Int。

插图

> String.toInt "20"
Ok 20 : Result.Result String Int
> String.toInt "abc"
Err "could not convert string 'abc' to an Int" : Result.Result String Int

浮

该函数将字符串转换为浮点数。

句法

String.toFloat string_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.toFloat
<function> : String -> Result.Result String Float

由于toFloat可以返回错误，因此返回类型为Result，即String或Float。

插图

> String.toFloat "20.50"
Ok 20.5 : Result.Result String Float
> String.toFloat "abc"
Err "could not convert string 'abc' to a Float" : Result.Result String Float

来自查尔

该函数根据给定字符创建一个字符串。

句法

String.fromChar character_value

检查 elm REPL 中函数类型的签名 -

> String.fromChar
<function> : Char -> String

签名显示 String 作为返回类型，输入为 Char 类型

插图

> String.fromChar 'c'
"c" : String

列表

该函数将字符串转换为字符列表。

句法

String.toList string_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.toList
<function> : String -> List Char

签名显示函数返回字符列表并接受输入字符串。

插图

> String.toList "tutorialspoint"
['t','u','t','o','r','i','a','l','s','p','o','i','n','t'] : List Char

来自列表

该函数将字符列表转换为字符串。

句法

String.fromList list_of_characters

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.fromList
<function> : List Char -> String

签名显示函数返回字符列表并接受输入字符串。

插图

> String.fromList ['h','e','l','l','o']
"hello" : String

到上层

该函数将字符串转换为全部大写。

句法

String.toUpper String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.toUpper
<function> : String -> String

插图

> String.toUpper "hello"
"HELLO" : String

降低

该函数将字符串转换为全部小写。

句法

String.toLower String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.toLower
<function> : String -> String

插图

> String.toLower "AbCd"
"abcd" : String

修剪

此函数消除字符串两侧的空格。

句法

String.trim String_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.trim
<function> : String -> String

插图

> String.trim "tutorialspoint "
"tutorialspoint" : String

筛选

该函数从输入字符串中过滤一组字符。仅保留通过测试的字符。

句法

String.filter test_function string_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.filter
<function> : (Char -> Bool) -> String -> String

签名显示过滤器接受两个输入参数并返回一个字符串。第一个参数是一个函数，输入为 Char，返回 Bool。

插图

在示例中，我们将Char.isUpper作为参数传递给过滤器方法；它返回所有大写字符，如下所示。

> import Char
> String.filter Char.isUpper "abcDEF"
"DEF" : String

地图

该函数接受一个字符串并转换字符串中的每个字符。

句法

String.filter mapping_function string_value

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> String.map
<function> : (Char -> Char) -> String -> String

插图

以下示例将字符 o 替换为 @ -

> String.map (\c -> if c == 'o' then '@' else c) "TutorialsPoint"
"Tut@rialsP@int" : String

榆树 - 列表

列表、元组和记录数据结构可用于存储值的集合。

本章讨论如何在 Elm 中使用 List。

列表是同类值的集合。列表中的值必须全部具有相同的数据类型。

使用变量存储值时请考虑以下限制 -

• 变量本质上是标量。换句话说，在声明时，变量只能保存一个值。这意味着要在程序中存储 n 个值，需要 n 个变量声明。因此，当需要存储更大的值集合时，使用变量是不可行的。

• 程序中的变量以随机顺序分配内存，因此很难按照声明的顺序检索/读取值。

句法

List_name = [value1,value2,value3.....valuen]

插图

以下示例展示了如何在 Elm 中使用列表。在 elm REPL 中尝试这个例子 -

> myList1 = [10,20,30]
[10,20,30] : List number
> myList2 = ["hello","world"]
["hello","world"] : List String

如果我们尝试将不同类型的值添加到列表中，编译器将抛出类型不匹配错误。如下所示。

> myList = [1,"hello"]
-- TYPE MISMATCH 
--------------------------------------------- 
repl-temp-000.elm

The 1st and 2nd entries in this list are different types of values.

4| [1,"hello"]
^^^^^^^
The 1st entry has this type:
   number
But the 2nd is:
   String

列表操作

下表显示了列表上的常见操作 -

是空的

如果列表为空，则此函数返回 true。

句法

List.isEmpty list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.isEmpty
<function> : List a -> Bool

插图

> List.isEmpty
<function> : List a -> Bool

> List.isEmpty [10,20,30]
False : Bool

撤销

该函数反转列表。

句法

List.reverse list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.reverse
<function> : List a -> List a

插图

> List.reverse [10,20,30]
[30,20,10] : List number

长度

该函数返回列表的长度。

句法

List.length list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.length
<function> : List a -> Int

插图

> List.length [10,20,30]
3 : Int

最大限度

该函数返回非空列表中的最大元素。

句法

List.maximum list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.maximum
<function> : List comparable -> Maybe.Maybe comparable

插图

> List.maximum [10,20,30]
Just 30 : Maybe.Maybe number
> List.maximum []
Nothing : Maybe.Maybe comparable

最低限度

该函数返回非空列表中的最小元素。

句法

List.minimum list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.minimum
<function> : List comparable -> Maybe.Maybe comparable

插图

> List.minimum [10,20,30]
Just 10 : Maybe.Maybe number

和

该函数返回列表中所有元素的总和。

句法

List.sum list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.sum
<function> : List number -> number

插图

> List.sum [10,20,30]
60 : number

产品

此函数返回列表中所有元素的乘积。

句法

List.product list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

<function>  : List number ->  number

插图

List.product [10,20,30]
6000 : number

种类

此函数对列表中的值从最低到最高进行排序。

句法

List.sort list_name

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.sort
<function> : List comparable -> List comparable

插图

> List.sort [10,20,30]
[10,20,30] : List number

连接

该函数将一堆列表连接成一个列表。

句法

List.concat [ [list_name1],[list_name2],[list_name3],.....[list_nameN] ]

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.concat
<function> : List (List a) -> List a

插图

> List.concat [[10,20], [30,40],[50,60]]
[10,20,30,40,50,60] : List number

附加

该函数将两个列表放在一起。

句法

List.append [list_name1] [list_name2]

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.append
<function> : List a -> List a -> List a

插图

> List.append [10,20] [30,40]
[10,20,30,40] : List number

++ 运算符还可用于将一个列表附加到另一个列表。如下例所示 -

> [10.1,20.2] ++ [30.3,40.4]
[10.1,20.2,30.3,40.4] : List Float

范围

该函数创建一个数字列表，每个元素加一。列表中应包含的最小和最大数字将传递给该函数。

句法

List.range start_range end_range

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.range
<function> : Int -> Int -> List Int

插图

> List.range 1 10
[1,2,3,4,5,6,7,8,9,10] : List Int

筛选

该函数从输入列表中过滤一组值。仅保留通过测试的值。

句法

List.filter test_function input_list

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.filter
<function> : (a -> Bool) -> List a -> List a

插图

以下示例过滤输入列表中的所有偶数

> List.filter (\n -> n%2==0) [10,20,30,55]
[10,20,30] : List Int

头

该函数返回输入列表中的第一个元素。

句法

List.head input_list

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.head
<function> : List a -> Maybe.Maybe a

插图

> List.head [10,20,30,40]
Just 10 : Maybe.Maybe number
> List.head []
Nothing : Maybe.Maybe a

尾巴

此函数返回列表中第一个之后的所有元素。

句法

List.tail input_list

要检查函数的签名，请在 elm REPL 中输入以下内容 -

> List.tail
<function> : List a -> Maybe.Maybe (List a)

插图

> List.tail [10,20,30,40,50]
Just [20,30,40,50] : Maybe.Maybe (List number)
> List.tail [10]
Just [] : Maybe.Maybe (List number)
> List.tail []
Nothing : Maybe.Maybe (List a)

使用 Cons 运算符

cons 运算符 ( :: ) 将一个元素添加到列表的前面。

插图

> 10::[20,30,40,50]
[10,20,30,40,50] : List number

要添加的新元素和列表中值的数据类型必须匹配。如果数据类型不匹配，编译器会抛出错误。

> [1,2,3,4]::[5,6,7,8]
-- TYPE MISMATCH ---------------------------------
------------ repl-temp-000.elm

The right side of (::) is causing a type mismatch.

3| [1,2,3,4]::[5,6,7,8]
			  ^^^^^^^^^
(::) is expecting the right side to be a:

   List (List number)

But the right side is:

   List number
Hint: With operators like (::) I always check the left side first. If it seems fine, 
I assume it is correct and check the right side. So the 
problem may be in how the left and right arguments interact.

列表是不可变的

让我们检查一下 Elm 中的列表是否是不可变的。第一个列表myList与值 1 连接时创建一个新列表并返回到myListCopy。因此，如果我们显示初始列表，它的值不会改变。

> myList = [10,20,30]
[10,20,30] : List number
> myListCopy = 1::myList
[1,10,20,30] : List number
> myList
[10,20,30] : List number
>myList == myListCopy
False : Bool

Elm - 元组

有时，可能需要存储不同类型的值的集合。Elm 为我们提供了一种称为元组的数据结构来满足此目的。

元组表示异构值的集合。换句话说，元组能够存储不同类型的多个字段。元组存储固定数量的值。当您想要从函数返回多个不同类型的值时，元组非常有用。这些数据结构与 elm 中的其他类型一样是不可变的。

句法

(data1,data2)

一个简单的例子如下所示 -

> ("TuotrialsPoint",5,True,"Hyderabad")
("TuotrialsPoint",5,True,"Hyderabad") : ( String, number, Bool, String )

在后续部分中，我们将了解不同的元组操作。

第一的

此操作从元组中提取第一个值。

句法

Tuple.first tuple_name
> Tuple.first
<function> : ( a1, a2 ) -> a1

插图

> Tuple.first (10,"hello")
10 : number

第二

第二个元组操作从元组中提取第二个值。

句法

Tuple.second tuple_name
> Tuple.second
<function> : ( a1, a2 ) -> a2

插图

> Tuple.second (10,"hello")
"hello" : String

元组列表

列表可以存储元组。如果在列表中使用元组，请确保它们都具有相同的数据类型并且具有相同数量的参数。

插图

> [("hello",20),("world",30)]
[("hello",20),("world",30)] : List ( String, number )

带函数的元组

函数可以返回元组。此外，元组可以作为参数传递给函数。

图1

以下示例定义了函数 fn_checkEven。该函数接受一个整数值作为参数并返回一个元组。

> fn_checkEven no = \
   if no%2 == 0 then \
      (True,"The no is Even")\
   else \
      (False,"No is not even")
<function> : Int -> ( Bool, String )
> fn_che