Coffeescript 简明教程

CoffeeScript - Quick Guide

CoffeeScript - Overview

目前,JavaScript 是最快的主流动态语言,它被誉为 Web 的通用语。它是由 Brendan Eich 在 1995 年的 10 天内开发的。

由于其有效的功能,JavaScript 变得流行,并迅速风靡全球。它在实验室中存在的时间非常短暂,不足以对该语言进行完善。也许正是出于这个原因,尽管 JavaScript 有好的部分,但它仍然存在大量的设计错误,并且因其古怪而获得了恶名。

What is CoffeeScript ?

CoffeeScript 是一种基于 Ruby 和 Python 的轻量级语言,它可以 transcompiles (从一种源语言编译到另一种) JavaScript。它提供了更好的语法,避免了 JavaScript 中古怪的部分,同时保留了该语言的灵活性和美感。

Advantages of CoffeeScript

以下是 CoffeeScript 的优势 −

  1. Easily understandable − CoffeeScript 是 JavaScript 的速记形式,其语法与 JavaScript 相比非常简单。使用 CoffeeScript,我们可以编写整洁、清楚且易于理解的代码。

  2. Write less do more − 对于 JavaScript 中的庞大代码,我们需要相对较少的 CoffeeScript 行数。

  3. Reliable − CoffeeScript 是一种安全可靠的编程语言,可用于编写动态程序。

  4. Readable and maintainable − CoffeeScript 为大多数运算符提供了别名,这使代码可读。用 CoffeeScript 编写的程序也易于维护。

  5. Class-based inheritance − JavaScript 没有类。相反,它提供了功能强大但令人困惑的原型。与 JavaScript 不同,我们可以在 CoffeeScript 中创建类并继承它们。此外,它还提供实例和静态属性以及 mixins 。它使用 JavaScript 的原生原型来创建类。

  6. No var keyword − 无需使用 var 关键词在 CoffeeScript 中创建变量,这样我们可以避免意外或不必要的范围声明。

  7. Avoids problematic symbols − 无需在 CoffeeScript 中使用有问题的分号和括号。我们不需要使用大括号,而是可以使用空格来区分代码块,如函数、循环等。

  8. Extensive library support − 在 CoffeeScript 中,我们可以使用 JavaScript 库,反之亦然。因此,我们可以在使用 CoffeeScript 时获得丰富的库集。

History of CoffeeScript

  1. CoffeeScript 由 Jeremy Ashkenas 开发。它于 2009 年 12 月 13 日首次提交到 Git。

  2. 最初,CoffeeScript 的编译器是用 Ruby 语言编写的。

  3. 2010 年 3 月,CoffeeScript 编译器被替换;这次他们使用了 CoffeeScript 本身,而不是 Ruby。

  4. 同年,CoffeeScript 1.0 发布,在发布时,它是 Git hub 最受欢迎的项目之一。

Limitations of CoffeeScript

  1. Sensitive to whitespaces − CoffeeScript 对空格非常敏感,因此编程人员在提供缩进时必须非常小心。如果我们没有保持适当的缩进,整个代码可能会出错。

TutorialsPoint’s CoffeeScript IDE

你可以使用 TutorialsPoint 在我们的编码基础部分提供的 CoffeeScript 编译器来编译 CoffeeScript 文件 https://www.tutorialspoint.com/codingground.htm 。按照以下步骤使用我们的 CoffeeScript 编译器。

Step 1

点击以下链接,访问我们网站的主页 www.tutorialspoint.com

Step 2

在主页右上角单击名为 CODING GROUND 的按钮,如下面给出的快照中所示。

tutorialspoint homepage

Step 3

这将导致我们的 CODING GROUND 部分,该部分为大约 135 种编程语言提供在线终端和 IDE。在在线 IDE 部分中打开 CoffeeScript IDE,这在以下快照中所示。

coding ground

Step 4

如果你在 main.coffee 中粘贴你的 CoffeeScript 代码(你可以更改文件名),然后单击 Preview 按钮,那么你可以在控制台中看到已编译的 JavaScript,如下面的快照所示。

tp coffeescript ide

CoffeeScript - Environment

CoffeeScript 最新版本的编译器是用 CoffeeScript 本身编写的。要在没有浏览器的情况下在你的系统中运行 CoffeeScript 文件,你需要一个 JavaScript 运行时。

Node.js

Node.js 是一个 JavaScript 框架,用于开发网络服务器应用程序。它还充当 JavaScript 和操作系统之间的桥梁。

CoffeeScript 的命令行版本作为 Node.js 包分发。因此,要在你的系统中安装 CoffeeScript(命令行),你需要首先安装 node.js。

Installing Node.js

以下是下载和在你系统中安装 Node.js 的步骤。

Step 1

访问 nodejs homepage ,并通过单击下面快照中标亮的按钮下载其适用于 Windows 的稳定版本。

homepage

Step 2

单击时,一个名为 node-v5.50-x64 的 .msc 文件将下载到你的系统中,运行下载的文件以启动 Node.js 设置。以下为 Node.js 设置向导欢迎页面的快照。

click next

Step 3

单击 Node.js 设置向导欢迎页面中的下一步按钮,它将引导你进入最终用户许可协议页面。接受许可协议,然后单击下一步按钮,如下所示。

license agreement

Step 4

在下一页中,你需要将目标文件夹设置为要安装 Node.js 的路径。将路径更改为所需的文件夹,然后单击下一步按钮。

set destination folder

Step 5

Custom setup 页面中,选择要安装 node.exe 文件的 Node.js 运行时,然后单击下一步。

custom setup

Step 6

最后,单击安装按钮,它将启动 Node.js 安装。

click install

单击 Node.js 设置向导的完成按钮,如下所示,以完成 Node.js 安装。

click finish

Installing CoffeeScript

Node.js 为你提供了一个命令提示符 ( Node.js command prompt )。你可以通过在其中输入以下命令来全局安装 CoffeeScript。

c:\> npm install -g coffeescript

执行上述命令后,CoffeeScript 将通过生成以下输出安装在你的系统中。

install coffeescript

Verification

可以通过键入以下命令来验证 CoffeeScript 的安装。

c:\> coffee -v

成功安装时,此命令会向你提供 CoffeeScript 版本,如下所示。

verification

CoffeeScript - Command-line utility

在 Node.js 上安装 CoffeeScript 后,我们可以访问 coffee-command line utility 。在此, coffee 命令是关键命令。使用此命令的各种选项,我们可以编译并执行 CoffeeScript 文件。

您可以使用 coffee 命令的 -h--help 选项查看 coffee 命令的选项列表。打开 Node.js command prompt 并在此中执行以下命令。

c:\>coffee -help

此命令会给您 coffee 的各种选项列表,以及其中每个选项执行的操作的说明,如下所示。

coffeecommand help

Compiling the CoffeeScript Code

CoffeeScript 文件以扩展名为 .coffee 保存。您可以使用 coffee 命令的 -c or --compile 选项来编译这些文件,如下所示:

c:\>coffee -c filename.coffee

Example

假设您的系统中有一个包含以下 CoffeeScript 代码的文件,该代码会在控制台上打印一条消息。

name = "Raju"
console.log "Hello"+name+" Welcome to Tutorialspoint"

Noteconsole.log() 函数在控制台上打印给定的字符串。

为编译以上代码,请将其保存在名为 sample.coffee 的文件中。打开 Node.js 命令提示符。浏览到您已保存文件的位置,并使用 coffee command-line utility 的 coffee 命令的 -c 选项进行编译,如下所示:

c:\> coffee -c sample.coffee

执行上述命令后,CoffeeScript 编译器会编译给定的文件 (sample.coffee),并将其保存在当前位置,名称为 sample.js,如下所示。

js file

若你打开 sample.js 文件,便可观察到生成的 JavaScript,如下所示。

// Generated by CoffeeScript 1.10.0
(function() {
  var name;
  name = "Raju";
  console.log("Hello " + name + " Welcome to Tutorialspoint");

}).call(this);

Executing the CoffeeScript code

你可以通过在 Node.js 命令提示符中将文件名传递给 coffee 命令,轻松执行 CoffeeScript 文件,如下所示。

c:\> coffee sample.coffee

Example

例如,让我们执行 sample.coffee 文件。为此,打开 Node.js 命令提示符。浏览已保存该文件的路径,并通过将文件名称直接传递给 coffee 命令来执行该文件,如下所示。

execution

Watch and Compile

在某些情况下,我们可能会对脚本进行大量的更改。使用 coffee 命令的 –w 选项,你可以监视你的脚本以进行更改。

你可以使用 -wc 选项同时监视和编译文件,如下所示。当我们使用此选项时,每次你在脚本中进行更改时,文件都会重新编译。

c:\>coffee -wc file_name

Example

假设我们已使用 -wc 选项编译了一个名为 sample.coffee 的文件,并且我们修改了三次脚本。每次更改脚本时, .coffee 文件都会重新编译,并留下 Node.js 命令提示符,如下所示。

watch and compile

Setting the Output Directory

使用 -o 选项,我们可以设置输出目录,以便放置编译后的 JavaScript 文件,如下所示。

c:\>coffee -o "Required path where we want our .js files" file_name

Example

让我们将 sample.coffee 文件的 JavaScript 代码保存在 E 驱动器中名为 data 的文件夹中,使用 -o 选项,在命令提示符中执行以下命令。

c:\>coffee -o E://data sample.coffee

执行上述命令后,以下是给定文件夹的快照。在这里你可以观察到 sample.coffee 的 JavaScript 文件

output directory

Print the Compiled JavaScript

如果我们想将编译后的 javascript 打印在控制台上,我们必须使用 coffee 命令的 -p 选项,如下所示。

c:\>coffee -p file_name

Example

例如,你可以使用 -p 选项在控制台上打印 sample.coffee 文件的编译后的 JavaScript 代码,如下所示。

print javascript

The REPL (Read Evaluate Print Loop)

CoffeeScript 为你提供了 REPL 交互式 shell。此 shell 用于评估 CoffeeScript 表达式。你可以在此 shell 中键入任何 CoffeeScript 代码并立即获得结果。你可以通过不带任何选项执行 coffee 命令来打开 REPL,如下所示。

execute coffee command

使用此 shell,我们可以向变量分配值,创建函数和评估结果。如下面的屏幕截图所示,如果我们在 REPL 中调用函数,它将打印函数的值。如果我们向它提供一个表达式,它会评估并打印表达式的结果。并且如果我们只是在其中键入语句,它将打印最后一条语句的值。

repl usage

在 REPL 中,你可以通过按 ctrl+v 访问多行模式,在多行模式中,你可以使用多行 (如函数) 来评估代码,并且你可以通过再次按 ctrl+v 从中返回到 REPL 模式。下面是多行模式使用的一个示例。

repl multilinefunction

Running CoffeeScript through Browser

我们可以像 JavaScript 一样使用 HTML 的 <script> 标签运行 CoffeeScript,如下所示。

<script src="http://jashkenas.github.com/coffee-script/extras/coffee-script.js"
   type="text/javascript" charset="utf-8"></script>
<script type="text/coffeescript">
  # Some CoffeeScript
</script>

但为此,我们必须在每个应用程序中导入该库,并且在显示输出之前,CoffeeScript 代码会逐行解释。这将减慢你的应用程序的速度,因此不建议使用此方法。

因此,要在应用程序中使用 CoffeeScript,你需要使用 Coffee 命令行实用程序对它们进行预编译,然后你可以在应用程序中使用生成的 JavaScript。

CoffeeScript - Syntax

  • * *在上一个章节中,我们已经看到了如何安装CoffeeScript。在本章中,让我们了解CoffeeScript的语法。

  • * *与JavaScript的语法相比,CoffeeScript的语法更优雅。它避免了像花括号、分号和变量减速这样的麻烦特性。

CoffeeScript Statements

  • * *与C、C++和Java等许多其他编程语言不同,CoffeeScript中的语句并不以分号 (;) 结尾。相反,CoffeeScript编译器将每一行都视为一个单独的语句。

Example

  • * *这里有一个CoffeeScript语句的例子。

name = "Javed"
age = 26
  • * *以同样的方式,我们可以使用分号将两条语句写在单行中,如下所示。

name = "Javed";age = 26

CoffeeScript Variables (No var Keyword)

  • * 在JavaScript中,我们使用 *var 关键字在创建变量之前声明变量,如下所示。

var name = "Javed"
var age = 20
  • * 在CoffeeScript中创建变量时,不需要使用 *var 关键字来声明变量。我们只需通过给它赋值来直接创建变量,如下所示。

name = "Javed"
age = 20

No Parentheses

  • * 通常,我们在声明函数、调用函数以及分隔代码块时使用括号以避免歧义。在CoffeeScript中,不需要使用括号,而在创建函数时,我们使用箭头标记 ( *→ ) 代替括号,如下所示。

myfunction = -> alert "Hello"
  • * *不过,在某些情况下,我们仍然必须使用括号。在调用没有参数的函数时,我们将使用括号。例如,如果我们在CoffeeScript中有一个名为my_function的函数,那么我们必须按照如下所示调用它。

my_function()
  • * *以同样的方式,我们也可以使用括号来分隔模棱两可的代码。如果你观察以下示例,没有大括号,结果是2233,有括号,结果是45。

alert "The result is  "+(22+33)

No Curly Braces

  • * *在JavaScript中,对于诸如函数、循环和条件语句之类的块代码,我们使用大括号。在CoffeeScript中,不需要使用大括号。相反,我们必须在正文中保持适当的缩进(空格)。这是受Python语言启发的特性。

  • * *以下是一个CoffeeScript函数的示例。在这里你可以观察到,我们使用了三个空格作为缩进来分隔函数的主体,而不是大括号。

myfunction = ->
   name = "John"
   alert "Hello"+name

CoffeeScript Comments

  • * *在任何编程语言中,我们使用注释来编写我们编写的代码的描述。这些注释不被认为是程序的一部分。CoffeeScript中的注释类似于Ruby语言的注释。CoffeeScript提供了两种类型的注释,如下所述 −

Single-line Comments

当我们希望在 CoffeeScript 中注释某一行时,我们只需要在它之前放置一个井号标记,如下所示。

# This is the single line comment in CoffeeScript

在 CoffeeScript 编译器中,每个单行标记后 ( # ) 的行都被视为注释,它将编译给定文件中未注释的其余代码。

Multiline Comments

当我们希望在 CoffeeScript 中注释多行(多行)时,我们可以通过将这些行包裹在对三重井号标记中来实现,如下所示。

###
These are the multi line comments in CoffeeScript
We can write as many number of lines as we want
within the pair of triple hash tags.
###

CoffeeScript Reserved keywords

CoffeeScript 中所有保留字的列表在下表中给出。它们不能用作 CoffeeScript 变量、函数、方法、循环标签或任何对象名称。

case default function var void with const let enum export import native _hasProp _extends _slice _bind __indexOf implements

else interface package private protected public static yield true false null this new delete typeof in arguments eval

instanceof return throw break continue debugger if else switch for while do try catch finally class extends super

undefined then unless until loop of by when and or is isnt not yes no on off

CoffeeScript - Data Types

CoffeeScript Data Types

编程语言最重要的特性之一是它支持的数据类型集。这些类型的值可以在编程语言中表示和操纵。

CoffeeScript 逐行编译为 JavaScript,因此 CoffeeScript 提供的数据类型与 JavaScript 相同。除了 CoffeeScript 增加了某种额外精髓的事实。

CoffeeScript 提供了下列数据类型供使用 −

  1. Strings − 字符串数据类型通常表示一组字符,我们用双引号 (“) 括起来表示一个字符串值。 Example : “Raj”、“Rahman”

  2. Number − 数字数据类型表示数值。 Example : 12、212 等。

  3. Boolean − 布尔数据类型表示一位信息。只有两种可能值:true 和 false。

  4. Arrays − 数组对象允许你将多个值存储在一个变量中。它存储一个固定大小、同一类型的元素序列集合。 Example : student = [“Rahman”、“Ramu”、“Ravi”、“Robert”]

  5. Objects − CoffeeScript 中的对象类似于 JavaScript 中的对象,它们是属性的集合。其中一个属性包括一个键和一个冒号 (:) 分隔的值。简而言之,CoffeeScript 对象是由键值对构成的集合。 Example : student = {name: “Mohammed”, age: 24, phone: 9848022338 }

  6. Null − 定义但不包含任何值的变量被认为是 null。这类似于 JavaScript 中的 null 值。

  7. Undefined − 从未赋过值的变量被认为是未定义变量。如果你在代码中使用了这些变量,你将会收到一个未定义错误。

我们将在单独章节中详细介绍数据类型数组和对象。

CoffeeScript - Variables

变量只不过是已命名的容器。您可以将数据放入这些容器中,然后使用其容器的名称引用数据。

CoffeeScript Variables

在 JavaScript 中,在使用变量之前,我们需要声明并对其进行初始化(分配值)。与 JavaScript 不同,在 CoffeeScript 中创建变量时,不需要使用 var 关键字来声明它。正如您在下面看到的那样,我们只需给文字值赋值即可创建变量。

name = variable name

Example

在下面的 CoffeeScript 代码中,我们定义了两个变量 nameage ,其数据类型分别是字符串和数字。将其另存为名为 variable_example.coffee 的文件。

name = "Javed"
age = 25

Compiling the code

通过在命令提示符中执行以下命令来编译上述 CoffeeScript 代码。

c:\> compile -c variable_example.coffee

编译后,将生成一个名为 variable_example.js 的 JavaScript 文件,内容如下。在这里,您可以观察到编译器使用 var 关键字替我们声明了变量(age 和 name)。

// Generated by CoffeeScript 1.10.0
(function() {
  var age, name;
  name = "Javed";
  age = 25;

}).call(this);

Variable Scope

变量的作用域是指程序中定义它的区域。JavaScript 和 CoffeeScript 变量只有两个作用域。

  1. Global Variables − 全局变量具有全局作用域,这意味着可以在您的 JavaScript 代码中的任何位置使用它。

  2. Local Variables − 局部变量只会在其被定义的函数中可见。函数参数始终局部于该函数。

The Problem with Variables in JavaScript

在 JavaScript 中,每当我们在不使用 var 关键字的情况下定义变量时,它就会以全局作用域创建。这会导致许多问题。请考虑以下示例 −

<script type = "text/javascript">
   var i = 10;
   document.write("The value of global variable i is "+ i);
   document.write("<br>");
   test();
   function test() {
      i = 20;
      document.write("The value of local variable i is "+i);
      document.write("<br>");
   }
   document.write("The value of global variable i is "+i);
</script>

执行时,上面这段 JavaScript 代码会给您以下输出 −

The value of global variable i is 10

The value of local variable i is 20

The value of global variable i is 20

在上面的示例中,我们在全局空间中创建了一个名为 i 的变量,并为其分配了值 10。而在函数中,在尝试创建一个同名局部变量时,我们声明为 i=20; 不带 var 关键字。因为我们错过了 var 关键字,全局变量 i 的值被重新赋值为 20。

出于这个原因,建议使用 var 关键字声明变量。

Variable Scope in CoffeeScript

每当我们编译 CoffeeScript 文件时,CoffeeScript 编译器都会创建一个匿名函数,并在该函数中,它将 CoffeeScript 代码逐行反编译成 JavaScript。(如果我们愿意,可以使用编译命令的 -b--bare 选项删除顶层函数包装。) 我们创建的每个变量都在匿名函数中使用 var 关键字声明,因此,默认情况下,CoffeeScript 中的每个变量都是局部变量。

(function() {
  var age, name;
  name = "javed";
  age = 20;
}).call(this);

无论如何,如果我们愿意,我们可以声明一个具有全局名称空间的变量。我们可以像下面显示的那样显式地进行此操作。

obj = this
obj.age = 30

CoffeeScript Variable Names (Literals)

在 CoffeeScript 中为变量命名时,请记住以下规则。

  1. 您不应将任何 CoffeeScript 保留关键字用作变量名称。这些关键字将在下一部分中提及。例如,break 或 Boolean 变量名称无效。

  2. CoffeeScript 变量名称不应以数字 (0-9) 开头。它们必须以字母或下划线字符开头。例如,123test 是一个无效变量名称,但 _123test 是一个有效变量名称。

  3. CoffeeScript 变量名区分大小写。例如, Namename 是两个不同的变量。

CoffeeScript - Operators and Aliases

CoffeeScript Operators

运算符是一个符号,告诉编译器执行特定的数学或逻辑函数。让我们来看一个简单的表达式 4 + 5 is equal to 9 。此处 4 和 5 称为 operands ,而 “+” 称为 operator

CoffeeScript 提供的运算符与 JavaScript 中的运算符相同,但有一些区别。在 JavaScript 中有一些有问题的运算符。CoffeeScript 或者移除了它们,或者修改了它们的功能,并且还引入了一些新的运算符。

以下是 CoffeeScript 支持的运算符列表。

  1. Arithmetic Operators

  2. Comparison Operators

  3. Logical (or Relational) Operators

  4. Assignment Operators

CoffeeScript Aliases

除了运算符外,CoffeeScript 还提供别名。CoffeeScript 为各种运算符和符号提供别名,以便使你的 CoffeeScript 代码具有可读性并且更加用户友好。

让我们逐个了解 CoffeeScript 的所有运算符和别名。

Arithmetic Operators

CoffeeScript 支持以下算术运算符。假设变量 A 保存 10 并且变量 B 保存 20 ,则 −

S.No

Operator and Description

Example

1

+ (Addition) Adds two operands

A + B = 30

2

− (Subtraction) 从第一个操作数中减去第二个操作数

A - B = -10

3

* (Multiplication) Multiply both operands

A * B = 200

4

/ (Division) 用分子除以分母

B / A = 2

5

% (Modulus) 输出整数除法的余数

B % A = 0

6

++ (Increment) 将一个整数值加一

A++ = 11

7

-- (Decrement) 将一个整数值减一

A-- = 9

Comparison Operators

JavaScript 支持以下比较运算符。假设变量 A 保存 10 并且变量 B 保存 20 ,则 −

S.No

Operator and Description

Example

1

= = (Equal) 检查两个操作数的值是否相等,如果相等则条件变为真。

(A == B) 不为真。

2

!= (Not Equal) 检查两个操作数的值是否相等,如果值不相等则条件变为真。

(A != B) 为真。

3

&gt; (Greater than) 检查左操作数的值是否大于右操作数的值,如果大于则条件变为真。

(A > B) 不为真。

4

&lt; (Less than) 检查左操作数的值是否小于右操作数的值,如果小于则条件变为真。

(A < B) 为真。

5

&gt;= (Greater than or Equal to) 检查左操作数是否大于或等于右操作数,如果是,那么该条件为真。

(A >= B) 不为真。

6

&#8656; (Less than or Equal to) 检查左操作数是否小于或等于右操作数,如果是,那么该条件为真。

(A ⇐ B) 为真。

下表显示了少数比较运算符的别名。假设 A 作用 20 ,变量 B 作用 20

Operator

Alias

Example

= = (Equal)

is

A is B 使你得到真。

!= = (Not Equal)

isnt

A isnt B 使你得到假。

Logical Operators

CoffeeScript 支持以下逻辑运算符。假设变量 A 作用 10 ,变量 B 作用 20 ,那么 −

S.No

Operator and Description

Example

1

&amp;&amp; (Logical AND) 如果两个操作数都是非零,那么该条件为真。

(A && B) 为真。

2

*

(逻辑 OR)*如果任意一个操作数是非零,那么该条件为真。

(A

B) is true.

3

! (Logical NOT) 逆转其操作数的逻辑状态。如果某个条件为真,那么逻辑 NOT 运算符将使它变为假。

下表显示了少数逻辑运算符的别名。假设 X 作用 true ,变量 Y 作用 false

Operator

Alias

Example

&& (Logical AND)

and

X and Y 使你得到假

(Logical OR)

or

X or Y 使你得到真

! (not x)

Bitwise Operators

CoffeeScript 支持以下逐位运算符。假设变量 A 作用 2 ,变量 B 作用 3 ,那么 −

S.No

Operator and Description

Example

1

&amp; (Bitwise AND) 它对整数参数中的每个位执行布尔 AND 运算。

(A & B) 为 2。

2

*

(按位 OR)在整数参数的每一个位上执行布尔 OR 运算。

(A

B) is 3.

3

^ (Bitwise XOR) 在整数参数的每一个位上执行布尔异或运算。异或意味着操作数一是真或操作数二是真,但不能两者同时为真。

(A ^ B) 为 1。

4

~ (Bitwise Not) 为一元运算符,通过反转操作数的所有位来运行。

(~B) is -4.

5

&lt;&lt; (Left Shift) 按在第二个操作数中指定的位置将第一个操作数中的全部位左移。新位都填充为零。将值左移一位等效于将其乘以 2,左移两位等效于乘以 4,以此类推。

(A << 1) 为 4。

6

Assignment Operators

Coffeescript 支持以下赋值运算符 -

S.No

Operator and Description

Example

1

= (Simple Assignment ) 将值从右侧操作数分配给左侧操作数

C = A + B 将分配 A + B 的值到 C

2

+= (Add and Assignment) 将右侧操作数加到左侧操作数,并将结果分配给左侧操作数。

C += A 等效于 C = C + A

3

-= (Subtract and Assignment) 将右侧操作数从左侧操作数中减去,并将结果分配给左侧操作数。

C -= A 等效于 C = C - A

4

*= (Multiply and Assignment) 将右侧操作数与左侧操作数相乘,并将结果分配给左侧操作数。

C *= A 等效于 C = C * A

5

/= (Divide and Assignment) 将左侧操作数除以右侧操作数,并将结果分配给左侧操作数。

C /= A 等效于 C = C / A

6

%= (Modules and Assignment) 使用两个操作数获取模,并将结果分配给左侧操作数。

C %= A 等效于 C = C % A

Note − 同样的逻辑适用于按位运算符,所以它们将变成 <⇐, >>=, >>=, &=, |= 和 ^=.

Equality Operator in CoffeeScript

在使用 JavaScript 时,将遇到两种类型的相等运算符 =====

JavaScript 中的 == 运算符为 type coercive ,即如果运算中两个操作数的类型不同,则一个操作数的数据类型将被转换为另一个并进行比较。

CoffeeScript 避免了这种不受欢迎的强制,将 == 运算符编译到 JavaScript 的严格比较操作符 === 中。

如果我们用 === 比较两个操作符,只有当它们的值和数据类型相同时,它才返回 true ,否则它返回 false

Example

考虑以下示例。这里我们有两个变量 aba 持有整数类型的值 21, b 持有相同的值,但它属于 string 类型。在 CoffeeScript 中,当我们比较 ab 时,结果将为 false 。(由于 CoffeeScript 的 == 操作符被转换为 JavaScript 的 === 操作符)

a=21
b="21"
result = 21=='21'
console.log result

编译时,上述 CoffeeScript 产生以下 JavaScript

// Generated by CoffeeScript 1.10.0
(function() {
  var a, b, result;

  a = 21;

  b = "21";

  result = a === b;
  console.log(result);
}).call(this);

执行时,它会产生以下输出。

false

The existential Operator

CoffeeScript 提供了一个称为存在操作符的新操作符来验证变量的存在。它由 ? 表示。除非变量为 null 或 undefined,否则存在操作符返回真。

Example

下面给出了存在操作符的一个示例。这里我们有三个变量,即 name, agesubject ,我们正在使用存在操作符来验证变量 name 和 phone 的存在。

name="Ramu"
age=24
subject="Engineering"
verify_name = name?
verify_phone = phone?
console.log verify_name
console.log verify_phone

编译时,这将生成以下 JavaScript 代码。

// Generated by CoffeeScript 1.10.0
(function() {
  var age, name, subject, verify_name, verify_phone;
  name = "Ramu";
  age = 24;

  subject = "Engineering";
  verify_name = name != null;
  verify_phone = typeof phone !== "undefined" && phone !== null;
  console.log(verify_name);
  console.log(verify_phone);

}).call(this);

如果我们执行上述 CoffeeScript 文件,它将产生以下输出。

true
false

Note − 我们有存在操作符的访问器变体 ? 。我们可以使用它来代替 . 操作符来找出空引用。

Chained Comparisons

像在 Python 中一样,我们可以在 CoffeeScript 中的单个表达式中使用一连串比较操作符。

Example

以下是使用链式比较的一个示例。

score = 70
passed = 100 > score > 40

console.log passed

编译时,示例 CoffeeScript 为您提供以下 JavaScript 代码。

// Generated by CoffeeScript 1.10.0
(function() {
  var passed, score;

  score = 70;

  passed = (100 > score && score > 40);

  console.log(passed);

}).call(this);

如果您执行上述 CoffeeScript 代码,它将产生以下输出。

true

Note − CoffeeScript 移除了三元操作符;相反,我们可以使用 inline if 语句。

CoffeeScript Aliases

通常,CoffeeScript 为各种操作符和符号提供别名,以使您的 CoffeeScript 代码可读且更易于用户使用。以下是 CoffeeScript 提供的别名。

Name

Operator / symbol

Aliases

"equals to" operator

==

is

"not equals to" operator

!==

isnt

"not" operator

!

not

"and" operator

&&

and

"or" operator

or

boolean value true

true

true, yes, on

boolean value false

false

off, no

current object

this

@

新行(或)分号

\n or ;

then

Inverse of if

! if

unless

测试数组是否存在

in

测试对象是否存在

of

Exponentiation

a****b

Integer division

a*//*b

dividend dependent modulo

Example

以下示例显示了如何在 CoffeeScript 中使用别名 -

a=21; b=21

x = true; y = false

console.log a is b

console.log a isnt b

console.log x and y

console.log x or y

console.log yes or no

console.log on or off

console.log a**b

console.log a//b

console.log a%%b

编译上述示例时,它会为您提供以下 JavaScript 代码。

// Generated by CoffeeScript 1.10.0
(function() {
  var a, b, x, y,
    modulo = function(a, b) { return (+a % (b = +b) + b) % b; };

  a = 21;

  b = 21;

  x = true;

  y = false;

  console.log(a === b);

  console.log(a !== b);

  console.log(x && y);

  console.log(x || y);

  console.log(true || false);

  console.log(true || false);

  console.log(Math.pow(a, b));

  console.log(Math.floor(a / b));

  console.log(modulo(a, b));

}).call(this);

如果你执行上面的 CoffeeScript 文件,它会生成以下输出 −

true
false
false
true
true
true
5.842587018385982e+27
1
0

CoffeeScript - Conditionals

在编程时,我们遇到了一些场景,其中我们必须从给定的一组路径中选择一条路径。在此类情况下,我们需要条件语句。条件语句帮助我们做出决策并执行正确操作。

以下是大多数编程语言中发现的典型决策结构的一般形式。

decision making structure

JavaScript 支持 if 语句(包括其变体)和 switch 语句。除了 JavaScript 中提供的条件外,CoffeeScript 还包括 unless 语句、if 的否定,甚至更多。

以下是由 CoffeeScript 提供的条件语句。

S.No.

Statement & Description

1

if statement An if 语句由一个布尔表达式后跟一条或多条语句组成。当给定布尔表达式为 true 时,这些语句执行。

2

if…​else statement An if 语句后可以是可选的 else 语句,当布尔表达式为 false 时,该语句执行。

3

unless statement An unless 语句类似于 if ,带有布尔表达式后跟一条或多条语句,但当给定布尔表达式为 false 时,这些语句执行。

4

unless…​else statement An unless 语句后可以是可选的 else 语句,当布尔表达式为 true 时,该语句执行。

5

switch statement A switch 语句允许使用一组值对变量进行相等性测试。

The then Keyword in CoffeeScript

ifunless 语句是使用多行编写的块语句。CoffeeScript 提供 then 关键字,我们可以使用它在一行中编写 ifunless 语句。

以下是在 CoffeeScript 中使用 then 关键字编写的语句。

S.No.

Statement & Description

1

if-then statement 使用 if-then 语句,我们可以在一行中编写 CoffeeScript 的 if 语句。它由布尔表达式后跟 then 关键字组成,然后是条或多条语句。当给定布尔表达式为 true 时,这些语句执行。

2

if-then&#8230;&#8203;else statement if-then 语句后可以是可选的 else 语句,当布尔表达式为 false 时,该语句执行。使用 if-then…​else 语句,我们可以在一行中编写 if…​else 语句。

3

unless-then statement 使用 unless-then 语句,我们可以在一行中编写 CoffeeScript 的 unless 语句。它由布尔表达式后跟 then 关键字组成,然后是条或多条语句。当给定布尔表达式为 false 时,这些语句执行。

4

unless…​then else statement unless-then 语句后可以是可选的 else 语句,当布尔表达式为 true 时,该语句执行。使用 unless-then…​else 语句,我们可以在一行中编写 unless…​else 语句。

postfix if and postfix unless Statements

在 CoffeeScript 中,你还可以编写 ifunless 语句,首先有一个代码块,然后是 ifunless 关键字,如下所示。这是这些语句的后缀形式。在用 CoffeeScript 编写程序时,非常方便。

#Postfix if
Statements to be executed if expression

#Postfix unless
Statements to be executed unless expression

CoffeeScript - Loops

在编码时,你可能会遇到需要一遍又一遍执行代码块的情况。在这种情况下,你可以使用循环语句。

通常,语句按顺序执行:函数中的第一个语句首先执行,然后是第二个,依此类推。

循环语句允许我们多次执行一个语句或一组语句。以下是大多数编程语言中循环语句的一般形式

loop architecture

JavaScript 提供了 while, forfor..in 循环。CoffeeScript 中的循环类似于 JavaScript 中的循环。

while 循环及其变体是 CoffeeScript 中唯一的循环构造。CoffeeScript 没有采用常用的 for 循环,而是为您提供了 Comprehensions ,这些内容将在后面的章节中详细讨论。

The while loop in CoffeeScript

while 循环是 CoffeeScript 唯一提供的低级循环。它包含一个布尔表达式和一个语句块。只要给定的布尔表达式为真, while 循环就会重复执行指定的语句块。一旦表达式变为假,循环就会终止。

Syntax

以下是在 CoffeeScript 中 while 循环的语法。在此处,无需使用圆括号来指定布尔表达式,并且我们必须使用(一致数量的)空格缩进循环主体,而不是用大括号将其括起来。

while expression
   statements to be executed

Example

以下示例演示了在 CoffeeScript 中使用 while 循环。将此代码保存在名为 while_loop_example.coffee 的文件中

console.log "Starting Loop "
count = 0
while count < 10
   console.log "Current Count : " + count
   count++;

console.log "Set the variable to different value and then try"

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c while_loop_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var count;

  console.log("Starting Loop ");

  count = 0;

  while (count < 10) {
    console.log("Current Count : " + count);
    count++;
  }

  console.log("Set the variable to different value and then try");

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee while_loop_example.coffee

执行后,CoffeeScript 文件产生以下输出。

Starting Loop
Current Count : 0
Current Count : 1
Current Count : 2
Current Count : 3
Current Count : 4
Current Count : 5
Current Count : 6
Current Count : 7
Current Count : 8
Current Count : 9
Set the variable to different value and then try

Variants of while

CoffeeScript 中的 While 循环有两个变体,即 until variantloop variant

S.No.

Loop Type & Description

1

until variant of while while 循环的 until 变体包含布尔表达式和代码块。此循环的代码块在给定的布尔表达式为假时执行。

2

loop variant of while loop 变体等同于值 (while true) 为真的 while 循环。在此循环中的语句将重复执行,直到我们使用 Break 语句退出循环。

CoffeeScript - Comprehensions

在上一个章节中,我们了解了 CoffeeScript 提供的各种循环、 while 及其变体。除此之外,CoffeeScript 还提供了称为 comprehensions 的附加循环结构。

如果我们添加可选的保护子句和当前数组索引的值,这些列表解析会替换其他编程语言中的 for 循环。使用列表解析,我们可以遍历数组和对象,而遍历数组的列表解析是表达式,而且我们可以在函数中返回它们或将它们分配给变量。

S.No.

Statement & Description

1

for..in comprehensions for..in 列表解析是 CoffeeScript 中列表解析的基本形式,使用它,我们可以遍历列表或数组的元素。

2

for..of comprehensions 就像数组一样,CoffeeScript 提供容器来存储键值对,这些容器称为对象。我们可以使用 CoffeeScript 提供的 for..of 列表解析来遍历对象。

3

list comprehensions CoffeeScript 中的 list 列表解析用于将一个对象数组映射到另一个数组。

Index of comprehensions

元素列表/数组有一个索引,可以在列表解析中使用。您可以使用变量在列表解析中使用它,如下所示:

for student,i in [element1, element2, element3]

Example

以下示例演示了在 CoffeeScript 中使用 for…in 理解的索引。将以下代码保存在一个名叫 for_in_index.coffee 的文件中

for student,i in ['Ram', 'Mohammed', 'John']
   console.log "The name of the student with id "+i+" is: "+student

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c for_in_index.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var i, j, len, ref, student;

  ref = ['Ram', 'Mohammed', 'John'];
  for (i = j = 0, len = ref.length; j < len; i = ++j) {
    student = ref[i];
    console.log("The name of the student with id " + i + " is: " + student);
  }
}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee for_in_index.coffee

执行后,CoffeeScript 文件产生以下输出。

The name of the student with id 0 is: Ram
The name of the student with id 1 is: Mohammed
The name of the student with id 2 is: John

Postfix form of comprehensions

与后缀 ifunless 类似,CoffeeScript 提供了理解的后缀形式,在编写代码时非常方便。使用此功能,我们可以在单行中编写 for..in 理解,如下所示。

#Postfix for..in comprehension
console.log student for student in ['Ram', 'Mohammed', 'John']

#postfix for..of comprehension
console.log key+"::"+value for key,value of { name: "Mohammed", age: 24, phone: 9848022338}

Assigning to a variable

我们用于遍历数组的理解可以赋值给变量,也可以由函数返回。

Example

考虑以下示例。在这里,您可以观察到我们使用 for..in 理解检索了数组的元素,并将其赋给名为 names 的变量。我们还拥有一个函数,该函数使用 return 关键字明确返回理解。将以下代码保存在一个名叫 example.coffee 的文件中

my_function =->
   student = ['Ram', 'Mohammed', 'John']

   #Assigning comprehension to a variable
   names = (x for x in student )
   console.log "The contents of the variable names are ::"+names

   #Returning the comprehension
   return x for x in student
console.log "The value returned by the function is "+my_function()

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var my_function;

  my_function = function() {
    var i, len, names, student, x;
    student = ['Ram', 'Mohammed', 'John'];
    names = (function() {
      var i, len, results;
      results = [];
      for (i = 0, len = student.length; i < len; i++) {
        x = student[i];
        results.push(x);
      }
      return results;
    })();
    console.log("The contents of the variable names are ::" + names);
    for (i = 0, len = student.length; i < len; i++) {
      x = student[i];
      return x;
    }
  };

  console.log("The value returned by the function is " + my_function());

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee example.coffee

执行后,CoffeeScript 文件产生以下输出。

The contents of the variable names are ::Ram,Mohammed,John
The value returned by the function is Ram

The by keyword

CoffeeScript 提供范围来定义元素列表。例如,范围 [1..10] 等同于 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],其中的每个元素都会增加 1。我们还可以使用理解的 by 关键字更改此增量。

Example

以下示例演示了 CoffeeScript 提供的 for..in 理解的 by 关键字的使用。将以下代码保存在一个名叫 by_keyword_example.coffee 的文件中

array = (num for num in [1..10] by 2)
console.log array

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c by_keyword_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var array, num;

  array = (function() {
    var i, results;
    results = [];
    for (num = i = 1; i <= 10; num = i += 2) {
      results.push(num);
    }
    return results;
  })();

  console.log(array);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee by_keyword_example.coffee

执行后,CoffeeScript 文件产生以下输出。

[ 1, 3, 5, 7, 9 ]

CoffeeScript - Functions

一个函数是一个可重复使用代码块,可以在程序的任何地方调用。这消除了重复编写相同代码的需要。它可帮助程序员编写模块化代码。

函数允许一个程序员将一个大程序划分为多个小而易于管理的函数。

通常,使用 JavaScript,我们可以定义两种类型的函数 – named functions ,具有函数名称主体的常规函数, Function expressions 。使用函数表达式,我们可以将函数分配给变量。

//named function
function sayHello(){
   return("Hello there");
}

//function expressions
var message = function sayHello(){
   return("Hello there");
}

Functions in CoffeeScript

CoffeeScript 中函数的语法与 JavaScript 相比更简单。在 CoffeeScript 中,我们仅定义函数表达式。

function 关键字在 CoffeeScript 中被取消。若要在此处定义一个函数,我们必须使用一个瘦箭头 ( )。

在后台,CoffeeScript 编译器将箭头转换为 JavaScript 中的函数定义,如下所示。

(function() {});

在 CoffeeScript 中使用 return 关键字是非强制性的。CoffeeScript 中的每个函数都会自动返回函数中的最后一条语句。

  1. 如果我们想要返回调用函数或在函数结束之前返回一个值,则可以使用 return 关键字。

  2. 除了内联函数(单行函数)外,我们还可以在 CoffeeScript 中定义多行函数。由于消除了大括号,我们可以通过维护正确的缩进完成此操作。

Defining a Function

以下是 CoffeeScript 中定义函数的语法。

function_name = -> function_body

Example

下面给出了 CoffeeScript 中的一个函数示例。在这里,我们创建了一个名为 greet 的函数。此函数自动返回其中的语句。以 function_example.coffee 的名称将其保存到一个文件中。

greet = -> "This is an example of a function"

通过在命令提示符中执行以下命令对其执行编译。

c:\>coffee -c function_example.coffee

在编译时,它会生成以下 JavaScript 代码。在这里,你可以观察到 CoffeeScript 编译器自动返回名为 greet() 的函数中的字符串值。

// Generated by CoffeeScript 1.10.0
(function() {
  var greet;

  greet = function() {
    return "This is an example of a function";
  };

}).call(this);

Multi-line Functions

我们还可以通过维护缩进来定义一个具有多行的函数,而不是大括号。但我们必须与我们在整个函数中一个行的缩进保持一致。

greet =  ->
  console.log "Hello how are you"

在编译时,以上 CoffeeScript 为你提供了以下 JavaScript 代码。CoffeeScript 编译器获取了我们使用缩进来分隔且置于大括号内的函数主体。

// Generated by CoffeeScript 1.10.0
(function() {
  var greet;

  greet = function() {
    return console.log("Hello how are you");
  };

}).call(this);

Functions with Arguments

我们还可以使用括号在函数中指定参数,如下所示。

add =(a,b) ->
  c=a+b
  console.log "Sum of the two numbers is: "+c

在编译以上 CoffeeScript 文件时,它会生成以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var add;

  add = function(a, b) {
    var c;
    c = a + b;
    return console.log("Sum of the two numbers is: " + c);
  };

}).call(this);

Invoking a Function

定义一个函数之后,我们需要调用该函数。你只需在函数名后加上圆括号即可调用函数,如以下示例所示。

add = ->
  a=20;b=30
  c=a+b
  console.log "Sum of the two numbers is: "+c
add()

在编译时,上述示例会生成以下 JavaScript

// Generated by CoffeeScript 1.10.0
(function() {
  var add;

  add = function() {
    var a, b, c;
    a = 20;
    b = 30;
    c = a + b;
    return console.log("Sum of the two numbers is: " + c);
  };
  add();
}).call(this);

执行上述 CoffeeScript 代码时,会生成以下输出。

Sum of the two numbers is: 50

Invoking Functions with Arguments

同样地,我们可以通过向函数传递参数来调用它,如下所示。

my_function argument_1,argument_2
or
my_function (argument_1,argument_2)

Note − 在通过向函数传递参数来调用函数时,使用圆括号是可选的。

在以下示例中,我们创建了一个名为 add() 的函数,它接受两个参数,并且我们已经调用了它。

add =(a,b) ->
  c=a+b
  console.log "Sum of the two numbers is: "+c
add 10,20

在编译时,上述示例会生成以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var add;

  add = function(a, b) {
    var c;
    c = a + b;
    return console.log("Sum of the two numbers is: " + c);
  };

  add(10, 20);

}).call(this);

执行时,上述 CoffeeScript 代码会生成以下输出。

Sum of the two numbers is: 30

Default Arguments

CoffeeScript 也支持默认参数。我们可以为函数参数分配默认值,如以下示例所示。

add =(a = 1, b = 2) ->
  c=a+b
  console.log "Sum of the two numbers is: "+c
add 10,20

#Calling the function with default arguments
add()

在编译时,上述 CoffeeScript 会生成以下 JavaScript 文件。

// Generated by CoffeeScript 1.10.0
(function() {
  var add;

  add = function(a, b) {
    var c;
    if (a == null) {
      a = 1;
    }
    if (b == null) {
      b = 2;
    }
    c = a + b;
    return console.log("Sum of the two numbers is: " + c);
  };

  add(10, 20);
  add()

}).call(this);

执行上述 CoffeeScript 代码时,会生成以下输出。

Sum of the two numbers is: 30
Sum of the two numbers is: 3

CoffeeScript - Strings

String 对象允许你使用一系列字符。在大多数编程语言中,在 CoffeeScript 中字符串使用引号声明,如下所示:−

my_string = "Hello how are you"
console.log my_string

在编译时,它会生成以下 JavaScript 代码。

// Generated by CoffeeScript 1.10.0
(function() {
  var my_string;

  my_string = "Hello how are you";

  console.log(my_string);

}).call(this);

String Concatenation

我们可以使用“+”符号连接两个字符串,如下所示。

new_string = "Hello how are you "+"Welcome to Tutorialspoint"
console.log new_String

在编译时,它会生成以下 JavaScript 代码。

// Generated by CoffeeScript 1.10.0
(function() {
  var new_string;

  new_string = "Hello how are you " + "Welcome to Tutorialspoint";

  console.log(new_String);

}).call(this);

如果你执行上述示例,你可以观察到连接后的字符串,如下所示。

Hello how are you Welcome to Tutorialspoint

String Interpolation

CoffeeScript 还提供一个称为 String interpolation 的功能,用于在字符串中包含变量。CoffeeScript 的该功能受 Ruby 语言启发。

字符串内插使用双引号 "" 、一个井号 # 和一对花括号 { } 完成。字符串在双引号中声明,要内插的变量包装在花括号中,花括号之前加上井号,如下所示。

name = "Raju"
age = 26
message ="Hello #{name} your age is #{age}"
console.log message

在编译上述示例时,它会生成以下 JavaScript。此处你可以观察到,字符串内插使用 + 符号转换为正常的连接。

// Generated by CoffeeScript 1.10.0
(function() {
  var age, message, name;

  name = "Raju";

  age = 26;

  message = "Hello " + name + " your age is " + age;

  console.log(message);

}).call(this);

如果你执行上述 CoffeeScript 代码,它会给你以下输出。

Hello Raju your age is 26

只有当字符串用双引号 " " 括起来时,才会内插作为 #{variable} 传递的变量。使用单引号 ' ' (而不是双引号)会产生没有内插的文本行。请考虑以下示例。

name = "Raju"
age = 26
message ='Hello #{name} your age is #{age}'
console.log message

如果我们使用单引号而不是双引号在插值中,你将得到以下输出。

Hello #{name} your age is #{age}

CoffeeScript 允许多行字符串而不连接它们,如下所示。

my_string = "hello how are you
Welcome to tutorialspoint
Have a nice day."
console.log my_string

它生成以下输出。

hello how are you Welcome to tutorialspoint Have a nice day.

JavaScript String Object

JavaScript 的 String 对象允许你处理一系列字符。此对象提供给你许多方法,可在字符串上执行各种操作。

由于我们可以在 CoffeeScript 代码中使用 JavaScript 库,因此我们可以在 CoffeeScript 程序中使用所有这些方法。

String Methods

以下是 JavaScript 的 String 对象方法的列表。点击这些方法的名称来获取展示它们在 CoffeeScript 中的用法示例。

S.No.

Method & Description

1

charAt() 返回指定索引处的字符。

2

charCodeAt() 返回一个数字,指出给定索引处字符的 Unicode 值。

3

concat() 合并两个字符串的文本并返回一个新字符串。

4

indexOf() 返回调用字符串对象中指定值首次出现的索引,如果未找到,则返回 -1。

5

lastIndexOf() 返回调用字符串对象中指定值最后一次出现的索引,如果未找到,则返回 -1。

6

localeCompare() 返回一个数字,指示引用字符串在排序顺序中是否在给定字符串之前或之后,或是否与给定字符串相同。

7

match() 用于匹配字符串和正则表达式。

8

search() 执行正则表达式和指定字符串之间的匹配搜索。

9

slice() 提取字符串的一部分并返回一个新字符串。

10

split() 通过将字符串分成子字符串来将 String 对象拆分为一个字符串数组。

11

substr() 返回从指定位置开始通过指定数量的字符的字符串中的字符。

12

toLocaleLowerCase() 字符串中的字符转换为小写,同时遵守当前区域设置。

13

toLocaleUpperCase() 字符串中的字符转换为大写,同时遵守当前区域设置。

14

toLowerCase() 返回已转换为小写的调用字符串值。

15

toUpperCase() 返回已转换为大写的调用字符串值。

CoffeeScript - Arrays

Array 对象允许您将多个值存储在单个变量中。它存储一个固定大小的元素顺序集合,该元素具有相同的类型。数组用于存储数据集合,但通常将数组视为同一类型的变量集合更有用。

Syntax

要创建数组,我们必须使用 new 运算符进行实例化,如下所示。

array = new (element1, element2,....elementN)

Array() 构造函数接受字符串或整数类型的列表。我们还可以通过向其构造函数传递单个整数来指定数组的长度。

我们还可以在方括号 ( [ ] ) 中仅提供其元素列表来定义数组,如下所示。

array = [element1, element2, ......elementN]

Example

以下是 CoffeeScript 中定义数组的示例。将以下代码保存在一个名叫 array_example.coffee 的文件中

student = ["Rahman","Ramu","Ravi","Robert"]

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c array_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var student;

  student = ["Rahman", "Ramu", "Ravi", "Robert"];

}).call(this);

New line instead of comma

我们还可以通过在每一行中创建新元素并保持适当缩进来删除数组元素之间的逗号 (,),如下所示。

student = [
  "Rahman"
  "Ramu"
  "Ravi"
  "Robert"
  ]

Comprehensions over arrays

我们可以使用理解检索数组的值。

Example

以下示例演示了使用理解检索数组的元素。将以下代码保存在一个名叫 array_comprehensions.coffee 的文件中

students = [ "Rahman", "Ramu", "Ravi", "Robert" ]
console.log student for student in students

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c array_comprehensions.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var i, len, student, students;

  students = ["Rahman", "Ramu", "Ravi", "Robert"];

  for (i = 0, len = students.length; i − len; i++) {
    student = students[i];
    console.log(student);
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee array_comprehensions.coffee

执行后,CoffeeScript 文件产生以下输出。

Rahman
Ramu
Ravi
Robert

与其他编程语言中的数组不同,CoffeeScript 中的数组可以具有多种类型的数据,即字符串和数字。

Example

以下是一个包含多种类型数据的 CoffeeScript 数组示例。

students = [ "Rahman", "Ramu", "Ravi", "Robert",21 ]

CoffeeScript - Objects

CoffeeScript 中的对象与 JavaScript 中的对象类似。这些是属性的集合,其中属性包括由分号分隔的键和值( ; )。简而言之,CoffeeScript 对象是键值对的集合。使用大括号定义对象,一个空对象表示为 {}

Syntax

以下是 CoffeeScript 中对象的语法。在此处,我们将对象的键值对放在大括号中,并使用逗号将其分隔( , )。

object ={key1: value, key2: value,......keyN: value}

Example

以下是 CoffeeScript 中定义对象的示例。将此代码保存在名为 objects_example.coffee 的文件中

student = {name: "Mohammed", age: 24, phone: 9848022338 }

打开 command prompt 并按照以下所示编译 .coffee 文件。

> coffee -c objects_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var student;

  student = {
    name: "Mohammed",
    age: 24,
    phone: 9848022338
  };

}).call(this);

就像在数组中一样,我们可以通过在如下所示的新行中指定键值对来删除逗号。

student = {
  name: "Mohammed"
  age: 24
  phone: 9848022338
  }

Indentations instead of curly braces

就像 CoffeeScript 中的其他块语句一样,我们可以使用缩进代替大括号 {} ,如下例所示。

Example

我们可以将上述示例重写为没有大括号,如下所示。

student =
  name: "Mohammed"
  age: 24
  phone: 9848022338

Nested objects

在 CoffeeScript 中,我们可以在对象中编写对象。

Example

以下示例演示了 CoffeeScript 中的嵌套对象。将此代码保存在名为 nested_objects.coffee 的文件中

contact =
  personal:
    email: "personal@gmail.com"
    phone:  9848022338
  professional:
    email: "professional@gmail.com"
    phone:  9848033228

打开 command prompt 并按照以下所示编译 .coffee 文件。

> coffee -c nested_objects.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var contact;

  contact = {
    personal: {
      email: "personal@gmail.com",
      phone: 9848022338
    },
    professional: {
      email: "professional@gmail.com",
      phone: 9848033228
    }
  };

}).call(this);

Comprehensions over objects

我们可以使用列表解析来遍历对象的元素。遍历对象元素与遍历数组元素相同。在对象中,我们需要检索 key 和值这两个元素,因此我们会使用两个变量。

Example

以下示例演示了如何使用列表解析来遍历对象元素。将以下代码保存至一个名为 object_comprehensions.coffee 的文件中:

student =
  name: "Mohammed"
  age: 24
  phone: 9848022338

console.log key+"::"+value for key,value of student

打开 command prompt 并按照以下所示编译 .coffee 文件。

> coffee -c object_comprehensions.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var key, student, value;

  student = {
    name: "Mohammed",
    age: 24,
    phone: 9848022338
  };

  for (key in student) {
    value = student[key];
    console.log(key(+"::" + value));
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

> coffee object_comprehensions.coffee

执行后,CoffeeScript 文件产生以下输出。

name::Mohammed
age::24
phone::9848022338

Arrays of Objects

在 CoffeeScript 中,数组还可以包含对象,如下所示:

  a = [
     object1_key1: value
     object1_key2: value
     object1_key3: value
  ,
     object2_key1: value
     object2_key2: value
     object2_key3: value
]

以下示例演示如何定义一个对象数组。我们可以仅列出所需对象的关键值对,并使用逗号将其分隔 (,)

students =[
    name: "Mohammed"
    age: 24
    phone: 9848022338
  ,
    name: "Ram"
    age: 25
    phone: 9800000000
  ,
    name: "Ram"
    age: 25
    phone: 9800000000
 ]
console.log student for student in students

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c array_of_objects.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var i, len, student, students;

  students = [
    {
      name: "Mohammed",
      age: 24,
      phone: 9848022338
    }, {
      name: "Ram",
      age: 25,
      phone: 9800000000
    }, {
      name: "Ram",
      age: 25,
      phone: 9800000000
    }
  ];

  for (i = 0, len = students.length; i < len; i++) {
    student = students[i];
    console.log(student);
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee array_of_objects.coffee

执行后,CoffeeScript 文件产生以下输出。

{ name: 'Mohammed', age: 24, phone: 9848022338 }
{ name: 'Ram', age: 25, phone: 9800000000 }
{ name: 'Ram', age: 25, phone: 9800000000 }

Reserved Keywords

JavaScript 不允许将保留关键字用作对象的属性名,如果我们希望使用它们,则需要使用双引号将其包装起来 " "

Example

请考虑以下示例。此处,我们创建了一个名为 class 的属性,它是一个保留关键字。将以下代码保存至一个名为 reserved_keywords.coffee 的文件中:

student ={
  name: "Mohammed"
  age: 24
  phone: 9848022338
  class: "X"
  }
console.log key+"::"+value for key,value of student

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c reserved_keywords.coffee

在编译时,它会给您以下 JavaScript。您可以在此处观察到,CoffeeScript 编译器已代表我们使用双引号包装了关键字 class。

// Generated by CoffeeScript 1.10.0
(function() {
  var key, student, value;

  student = {
    name: "Mohammed",
    age: 24,
    phone: 9848022338,
    "class": "X"
  };

  for (key in student) {
    value = student[key];
    console.log(key + "::" + value);
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee array_of_objects.coffee

执行后,CoffeeScript 文件产生以下输出。

name::Mohammed
age::24
phone::9848022338
class::X

CoffeeScript - Ranges

在上一章中,我们已经看到了 CoffeeScript 中的数组,而在编程过程中,我们会面临一些场景其中,我们必须将一系列数值存储在一个数组中,如下所示。

numbers =[1,2,3,4,5,6,7,8,9,10]

CoffeeScript 提供了一种更简洁的方法来表达包含一系列数值的数组,即 ranges 。CoffeeScript 的此功能源自 Ruby。

Syntax

范围由两个数值创建,范围中的第一个和最后一个位置,它们由 .. 或 …​ 分隔。使用两个点(1..4),范围是包含(1、2、3、4);使用三个点(1…​4),范围不包括结尾(1、2、3)。

下面给出 CoffeeScript 中范围的语法。我们将 square braces [ ] 中的范围内的数值定义,就像数组一样。在范围内,在存储一系列数值时,我们不必提供整个序列的值,我们只要按照下面所示,用两个点 .. 分隔其 beginend 值即可。

range =[Begin..End]

Example

以下是 CoffeeScript 中范围的示例。将此内容保存到名为 ranges_example.coffee 的文件中。

numbers =[0..9]
console.log "The contents of the range are: "+ numbers

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c ranges_example.coffee

在编译过程中,它会提供以下 JavaScript。在这里,你可以观察范围被转换为完整的 CoffeeScript 数组。

// Generated by CoffeeScript 1.10.0
(function() {
  var numbers;

  numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

  console.log("The contents of the range are:: " + numbers);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee ranges_example.coffee

执行后,CoffeeScript 文件产生以下输出。

The contents of the range are:: 0,1,2,3,4,5,6,7,8,9

Excluding the end Value

范围被编译成包含所有数字的完整数组。如果我们想排除 end 值,那么我们必须用三个点 …​ 分隔范围的 startend 元素,如下所示。

range =[Begin...End]

Example

我们可以通过排除 end 值来重写上述示例,如下所示。将以下内容保存到名为 range_excluding_end.coffee 的文件中。

numbers =[0...9]
console.log "The contents of the range are:: "+ numbers

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c ranges_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var numbers;

  numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8];

  console.log("The contents of the range are:: " + numbers);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee ranges_example.coffee

在执行时,CoffeeScript 文件会产生以下输出。在这里,你可以观察到结尾值 9 被排除在外。

The contents of the range are:: 0,1,2,3,4,5,6,7,8

Using Ranges with Variables

我们还可以通过将 start 和 end 值赋值给变量来定义范围。

Example

考虑以下示例。在这里,我们使用变量定义了范围。将此代码保存到名为 range_variables.coffee 的文件中。

start=0
end=9
numbers =[start..end]
console.log "The contents of the range are: "+ numbers

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c range_variables.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var end, i, numbers, results, start;

  start = 0;

  end = 9;

  numbers = (function() {
    results = [];
    for (var i = start; start <= end ? i <= end : i >= end; start <= end ? i++ : i--) {
      results.push(i);
    }
    return results;
  }).apply(this);

  console.log("The contents of the range are:: " + numbers);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee range_variables.coffee

在执行时,CoffeeScript 文件会产生以下输出。在这里,你可以观察到结尾值 9 被排除在外。

The contents of the range are:: 0,1,2,3,4,5,6,7,8,9

Ranges with Arrays

我们可以通过将其与范围结合使用来分割数组。每当我们在数组(变量)之后立即指定范围时,CoffeeScript 编译器会将其转换为 JavaScript 的 slice() 方法调用。

假设我们有一个包含数值的数组(0 到 9),那么我们可以像下面这样检索它的前 4 个元素。

num  = [1, 2, 3, 4, 5, 6, 7, 8, 9]
data = num[0..5]

负值表示从后往前数的元素数量,例如,-1 表示 9。如果我们指定一个负数 3 后面跟着两个冒号,则将提取该数组的最后三个元素。

data = num[-3..]

如果我们只指定数组范围中两个冒号 num[..] ,则将提取完整数组。我们还可以使用范围替换数组片段,如下所示。

num[2..6] = [13,14,15,16,17]

Example

以下示例演示了使用数组范围。将这段代码保存到名为 range_arrays.coffee 的文件中。

#slicing an array using ranges
num  = [1, 2, 3, 4, 5, 6, 7, 8, 9]
data = num[0..5]
console.log "The first four elements of the array : "+data


#Using negative values
data = num[-3..]
console.log "The last 3 elements of the array : "+data

#Extracting the whole array
console.log "Total elements of the array : "+num[..]


#Replacing the elements of an array
num[2..6] = [13,14,15,16,17]
console.log "New array : "+num

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c range_arrays.coffee

编译后,它会输出以下 JavaScript。在这里,你可以看到所有范围都转换为 JavaScript 的 slice() 方法调用。

// Generated by CoffeeScript 1.10.0
(function() {
  var data, num, ref;

  num = [1, 2, 3, 4, 5, 6, 7, 8, 9];

  data = num.slice(0, 6);

  console.log("The first four elements of the array : " + data);

  data = num.slice(-3);

  console.log("The last 3 elements of the array : " + data);

  console.log("Total elements of the array : " + num.slice(0));

  [].splice.apply(num, [2, 5].concat(ref = [13, 14, 15, 16, 17])), ref;

  console.log("New array : " + num);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee range_arrays.coffee

在执行时,CoffeeScript 文件会产生以下输出。在这里,你可以观察到结尾值 9 被排除在外。

The first four elements of the array : 1,2,3,4,5,6
The last 3 elements of the array : 7,8,9
Total elements of the array : 1,2,3,4,5,6,7,8,9
New array : 1,2,13,14,15,16,17,8,9

Ranges with Strings

我们还可以对字符串使用范围。如果我们在字符串后指定范围,则 CoffeeScript 会对它们进行切片并返回一个新的字符子集。

Example

以下示例演示了使用字符串范围。在这里,我们创建了一个字符串,并使用范围从其中提取了一个子字符串。将这段代码保存到名为 ranges_with_strings.coffee 的文件中。

my_string = "Welcome to tutorialspoint"
new_string = my_string[0..10]
console.log new_string

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c ranges_with_strings.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var my_string, new_string;

  my_string = "Welcome to tutorialspoint";

  new_string = my_string.slice(0, 6);

  console.log(new_string);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee ranges_with_strings.coffee

在执行时,CoffeeScript 文件会产生以下输出。在这里,你可以观察到结尾值 9 被排除在外。

Welcome to

Comprehensions over Ranges

像对象和数组一样,我们还可以使用解析器迭代一个范围的元素。

Example

以下是使用解析器对范围进行解析的一个示例。在这里,我们创建了一个范围,并使用解析器检索了其中的元素。将这段代码保存到名为 comprehensions_over_ranges.coffee 的文件中。

numbers =[0..9]
console.log "The elements of the range are: "
console.log num for num in numbers

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c comprehensions_over_ranges.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var i, len, num, numbers;

  numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

  console.log("The elements of the range are: ");

  for (i = 0, len = numbers.length; i < len; i++) {
    num = numbers[i];
    console.log(num);
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee comprehensions_over_ranges.coffee

在执行时,CoffeeScript 文件会产生以下输出。在这里,你可以观察到结尾值 9 被排除在外。

The elements of the range are:
0
1
2
3
4
5
6
7
8

同样,我们还可以使用解析器的 by 关键字更改这个增量。

array = (num for num in [1..10] by 2)
console.log array

CoffeeScript - Splat

在前面的章节中,我们已经看到了如何定义一个函数,调用一个函数和向函数传递参数。一般情况下,我们可以向函数传递固定数量的参数。在编程时,我们可能会遇到需要向这些函数传递可变参数的情况。在 JavaScript 中,我们使用对象来接受函数的可变数量的参数。

CoffeeScript 提供了一个名为 splats 的特性来向函数传递多个参数。我们通过在参数名后放置三个点来在函数中使用星号,表示为 …​

Syntax

下面给出了使用星号在函数中接受多个参数的语法。

my_function = (arguments...)->
   ............
   ............
   ............

Example

以下是使用 splats 接受函数中的多个参数的示例。这里我们使用了 splats 定义了一个名为 indian_team() 的函数。我们调用此函数三次,并且每次调用时分别传递 4 个玩家、6 个玩家和全部阵容。由于我们在函数定义中使用了 splats,因此每次调用它时它都会接受可变数量的参数。将此代码保存为一个名为 splats_definition.coffee 的文件。

indian_team = (first, second, others...) ->
  Captain = first
  WiseCaptain = second
  team  = others
  console.log "Captain: " +Captain
  console.log "Wise captain: " +WiseCaptain
  console.log "Other team members: " +team

#Passing 4 arguments
console.log "############## Four Players ############"
indian_team "Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma"

#Passing 6 arguments
console.log "############## Six Players ############"
indian_team "Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan"

#Passing full squad
console.log "############## Full squad #############"
indian_team "Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan", "Ravindra Jadeja", "Axar Patel", "Jasprit Bumrah", "Umesh Yadav", "Harbhajan Singh", "Ashish Nehra", "Hardik Pandya", "Suresh Raina", "Yuvraj Singh", "Ajinkya Rahane"

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c splats_definition.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var indian_team,
    slice = [].slice;

  indian_team = function() {
    var Captain, WiseCaptain, first, others, second, team;
    first = arguments[0], second = arguments[1], others = 3 <= arguments.length ? slice.call(arguments, 2) : [];
    Captain = first;
    WiseCaptain = second;
    team = others;
    console.log("Captain: " + Captain);
    console.log("Wise captain: " + WiseCaptain);
    return console.log("Other team members: " + team);
  };

  console.log("############## Four Players ############");

  indian_team("Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma");

  console.log("############## Six Players ############");

  indian_team("Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan");

  console.log("############## Full squad #############");

  indian_team("Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan", "Ravindra Jadeja", "Axar Patel", "Jasprit Bumrah", "Umesh Yadav", "Harbhajan Singh", "Ashish Nehra", "Hardik Pandya", "Suresh Raina", "Yuvraj Singh", "Ajinkya Rahane");

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee splats_definition.coffee

执行后,CoffeeScript 文件产生以下输出。

############## Four Players ############
Captain: Mahendra Singh Dhoni
Wise captain: Virat Kohli
Other team members: Shikhar Dhawan,Rohit Sharma
############## Six Players ############
Captain: Mahendra Singh Dhoni
Wise captain: Virat Kohli
Other team members: Shikhar Dhawan,Rohit Sharma,Gurkeerat Singh Mann,Rishi Dhawan
############## Full squad #############
Captain: Mahendra Singh Dhoni
Wise captain: Virat Kohli
Other team members: Shikhar Dhawan,Rohit Sharma,Gurkeerat Singh Mann,Rishi Dhawan,Ravindra Jadeja,Axar Patel,Jasprit Bumrah,Umesh Yadav,Harbhajan Singh,Ashish Nehra,Hardik Pandya,Suresh Raina,Yuvraj Singh,Ajinkya Rahane

Calling Functions using Splats

我们还可以使用 splats 调用函数。为此,我们必须创建一个包含要传递给函数的元素的数组,并且我们必须调用函数,方法是传递点缀有三个点的数组,如下所示。

my_function values...

Example

以下是使用 splats 调用函数的示例。将此代码保存为一个名为 splats_call.coffee 的文件。

indian_team = (first, second, others...) ->
  Captain = first
  WiseCaptain = second
  team  = others
  console.log "Captain: " +Captain
  console.log "Wise captain: " +WiseCaptain
  console.log "Other team members: " +team

squad = [
   "Mahendra Singh Dhoni"
   "Virat Kohli"
   "Shikhar Dhawan"
   "Rohit Sharma"
   "Gurkeerat Singh Mann"
   "Rishi Dhawan"
   "R Ashwin"
   "Ravindra Jadeja"
   "Axar Patel"
   "Jasprit Bumrah"
   "Umesh Yadav"
   "Harbhajan Singh"
   "Ashish Nehra"
   "Hardik Pandya"
   "Suresh Raina"
   "Yuvraj Singh"
   "Ajinkya Rahane"
 ]

indian_team squad...

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c splats_call.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var indian_team, squad,
    slice = [].slice;

  indian_team = function() {
    var Captain, WiseCaptain, first, others, second, team;
    first = arguments[0], second = arguments[1], others = 3 <= arguments.length ? slice.call(arguments, 2) : [];
    Captain = first;
    WiseCaptain = second;
    team = others;
    console.log("Captain: " + Captain);
    console.log("Wise captain: " + WiseCaptain);
    return console.log("Other team members: " + team);
  };

  squad = ["Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan", "R Ashwin", "Ravindra Jadeja", "Axar Patel", "Jasprit Bumrah", "Umesh Yadav", "Harbhajan Singh", "Ashish Nehra", "Hardik Pandya", "Suresh Raina", "Yuvraj Singh", "Ajinkya Rahane"];

  indian_team.apply(null, squad);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee splats_call.coffee

执行后,CoffeeScript 文件产生以下输出。

Captain: Mahendra Singh Dhoni
Wise captain: Virat Kohli
Other team members: Shikhar Dhawan,Rohit Sharma,Gurkeerat Singh Mann,Rishi Dhawan,R Ashwin,Ravindra Jadeja,Axar Patel,Jasprit Bumrah,Umesh Yadav,Harbhajan Singh,Ashish Nehra,Hardik Pandya,Suresh Raina,Yuvraj Singh,Ajinkya Rahane

Splats with a Tailing Argument

我们还可以将尾部参数传递给 splats。在下面给出的示例中,我们在 splat 的后面传递了一个名为 last 的尾部参数。将此示例保存为一个名为 tailing_arguments.coffee 的文件。

indian_team = (first, second, others..., last) ->
  Captain = first
  WiseCaptain = second
  team  = others
  Wicketkeeper =last
  console.log "Captain: " +Captain
  console.log "Wise captain: " +WiseCaptain
  console.log "Wicket keeper is:"+last
  console.log "Other team members: " +team

squad = [
   "Mahendra Singh Dhoni"
   "Virat Kohli"
   "Shikhar Dhawan"
   "Rohit Sharma"
   "Gurkeerat Singh Mann"
   "Rishi Dhawan"
   "R Ashwin"
   "Ravindra Jadeja"
   "Axar Patel"
   "Jasprit Bumrah"
   "Umesh Yadav"
   "Harbhajan Singh"
   "Ashish Nehra"
   "Hardik Pandya"
   "Suresh Raina"
   "Yuvraj Singh"
   "Ajinkya Rahane"
 ]

indian_team squad...

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c tailing_arguments.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var indian_team, squad,
    slice = [].slice;

  indian_team = function() {
    var Captain, Wicketkeeper, WiseCaptain, first, i, last, others, second, team;
    first = arguments[0], second = arguments[1], others = 4 <= arguments.length ? slice.call(arguments, 2, i = arguments.length - 1) : (i = 2, []), last = arguments[i++];
    Captain = first;
    WiseCaptain = second;
    team = others;
    Wicketkeeper = last;
    console.log("Captain: " + Captain);
    console.log("Wise captain: " + WiseCaptain);
    console.log("Wicket keeper is:" + last);
    return console.log("Other team members: " + team);
  };

  squad = ["Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan", "R Ashwin", "Ravindra Jadeja", "Axar Patel", "Jasprit Bumrah", "Umesh Yadav", "Harbhajan Singh", "Ashish Nehra", "Hardik Pandya", "Suresh Raina", "Yuvraj Singh", "Ajinkya Rahane"];

  indian_team.apply(null, squad);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee tailing_arguments.coffee

执行后,CoffeeScript 文件产生以下输出。

Captain: Mahendra Singh Dhoni
Wise captain: Virat Kohli
Wicket keeper is:Ajinkya Rahane
Other team members: Shikhar Dhawan,Rohit Sharma,Gurkeerat Singh Mann,Rishi Dhawan,R Ashwin,Ravindra Jadeja,Axar Patel,Jasprit Bumrah,Umesh Yadav,Harbhajan Singh,Ashish Nehra,Hardik Pandya,Suresh Raina,Yuvraj Singh

Comprehensions with Splats

在函数内,我们还可以使用解析在 splat 的元素,如下面的示例所示。将此代码保存为一个名为 splats_comprehensions.coffee 的文件。

indian_team = (first, second, others...) ->
  Captain = first
  WiseCaptain = second
  team  = others
  console.log "Captain: " +Captain
  console.log "Wise captain: " +WiseCaptain
  console.log "Other team members:: "
  console.log member for member in others

squad = [
   "Mahendra Singh Dhoni"
   "Virat Kohli"
   "Shikhar Dhawan"
   "Rohit Sharma"
   "Gurkeerat Singh Mann"
   "Rishi Dhawan"
   "R Ashwin"
   "Ravindra Jadeja"
   "Axar Patel"
   "Jasprit Bumrah"
   "Umesh Yadav"
   "Harbhajan Singh"
   "Ashish Nehra"
   "Hardik Pandya"
   "Suresh Raina"
   "Yuvraj Singh"
   "Ajinkya Rahane"
 ]

indian_team squad...

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c splats_comprehensions.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var indian_team, squad,
    slice = [].slice;

  indian_team = function() {
    var Captain, WiseCaptain, first, i, len, member, others, results, second, team;
    first = arguments[0], second = arguments[1], others = 3 <= arguments.length ? slice.call(arguments, 2) : [];
    Captain = first;
    WiseCaptain = second;
    team = others;
    console.log("Captain: " + Captain);
    console.log("Wise captain: " + WiseCaptain);
    console.log("Other team members:: ");
    results = [];
    for (i = 0, len = others.length; i < len; i++) {
      member = others[i];
      results.push(console.log(member));
    }
    return results;
  };

  squad = ["Mahendra Singh Dhoni", "Virat Kohli", "Shikhar Dhawan", "Rohit Sharma", "Gurkeerat Singh Mann", "Rishi Dhawan", "R Ashwin", "Ravindra Jadeja", "Axar Patel", "Jasprit Bumrah", "Umesh Yadav", "Harbhajan Singh", "Ashish Nehra", "Hardik Pandya", "Suresh Raina", "Yuvraj Singh", "Ajinkya Rahane"];

  indian_team.apply(null, squad);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee splats_comprehensions.coffee

执行后,CoffeeScript 文件产生以下输出。

Captain: Mahendra Singh Dhoni
Wise captain: Virat Kohli
Other team members::
Shikhar Dhawan
Rohit Sharma
Gurkeerat Singh Mann
Rishi Dhawan
R Ashwin
Ravindra Jadeja
Axar Patel
Jasprit Bumrah
Umesh Yadav
Harbhajan Singh
Ashish Nehra
Hardik Pandya
Suresh Raina
Yuvraj Singh
Ajinkya Rahane

CoffeeScript - Date

Date 对象是 JavaScript 语言中内置的一个数据类型。Date 对象作为 new Date( ) 创建。

创建 Date 对象后, 多个方法允许你对其进行操作。大部分方法仅允许你获取和设置对象的年、月、日、小时、分钟、秒和毫秒字段, 使用本地时间或 UTC (通用或 GMT) 时间。

ECMAScript 标准要求 Date 对象能表示任意日期和时间, 至毫秒精度, 于 1/1/1970 前后 1 亿天内。这是正负 273,785 年的范围, 因此 JavaScript 可以表示到 275755 年的日期和时间。

与其他 JavaScript 对象类似,我们还可以在 CoffeeScript 代码中使用 date 对象。

Date Methods

以下是 JavaScript 的 Date 对象的各个方法的列表。点击这些方法的名称以获取在 CoffeeScript 中演示其用法的示例。

S.No.

Method & Description

1

getDate() 根据当地时间返回指定 date 中的该月的日期。

2

getDay() 根据当地时间返回指定 date 中的星期几。

3

getFullYear() 根据当地时间返回指定 date 中的年份。

4

getHours() 根据当地时间返回指定 date 中的小时。

5

getMilliseconds() 根据当地时间返回指定 date 中的毫秒。

6

getMinutes() 返回特定日期中按本地时间计算的分钟数。

7

getMonth() 返回特定日期中按本地时间计算的月份。

8

getSeconds() 返回特定日期中按本地时间计算的秒数。

9

getTime() 返回自 1970 年 1 月 1 日 00:00:00 UTC 以来特定日期以毫秒数形式的数值。

10

getTimezoneOffset() 返回当前区域设置的时区偏移(以分钟计)。

11

getUTCDate() 返回特定日期中按世界时计算的本月的日数(日期)。

12

getUTCDay() 返回特定日期中按世界时计算的星期几。

13

getUTCFullYear() 返回特定日期中按世界时计算的年数。

14

getUTCHours() 返回特定日期中按世界时计算的小时数。

15

getUTCMinutes() 返回特定日期中按世界时计算的毫秒数。

16

getUTCMilliseconds() 返回特定日期中按世界时计算的分钟数。

17

getUTCMonth() 返回特定日期中按世界时计算的月份。

18

getUTCSeconds() 返回特定日期中按世界时计算的秒数。

19

getYear() 已弃用 - 返回特定日期中按本地时间计算的年数。请改用 getFullYear。

20

setDate() 按本地时间设置特定日期的每月日数。

21

setFullYear() 按本地时间设置特定日期的完整年份。

22

setHours() 按本地时间设置特定日期的小时数。

23

setMilliseconds() 按本地时间设置特定日期的毫秒数。

24

setMinutes() 按本地时间设置特定日期的分钟数。

25

setMonth() 根据本地时间设置指定日期的月份。

26

setSeconds() 根据本地时间设置指定日期的秒。

27

setTime() 将 Date 对象设置为自 1970 年 1 月 1 日、00:00:00 UTC 起的毫秒数所表示的时间。

28

setUTCDate() 根据世界时设置指定日期的月份。

29

setUTCFullYear() 根据世界时设置指定日期的完整年份。

30

setUTCHours() 根据世界时设置指定日期的小时。

31

setUTCMilliseconds() 根据世界时设置指定日期的毫秒。

32

setUTCMinutes() 根据世界时设置指定日期的分钟数。

33

setUTCMonth() 根据世界时设置指定日期的月份。

34

setUTCSeconds() 根据世界时设置指定日期的秒。

35

setYear() 已弃用 - 根据本地时间设置指定日期的年份。请改用 setFullYear。

36

toDateString() 将 Date 的“date”部分作为人类可读的字符串返回。

37

toLocaleDateString() 使用当前语言环境的约定将 Date 的“date”部分作为字符串返回。

38

toLocaleString() 使用当前语言环境的约定将日期转换为字符串。

39

时间的部分作为字符串返回,使用当前语言的惯例。

40

时间的部分作为人类可读的字符串返回。

41

使用通用时间约定,将一个日期转换成一个字符串。

CoffeeScript - Math

JavaScript 的 Math 对象为您提供数学常数和函数的属性和方法。与其他全局对象不同的是, Math 不是一个构造函数。 Math 的所有属性和方法都是静态的,可以用 Math 作为对象来调用,而不用创建它。

因此,你可以将常量 pi 称为 Math.PI ,你可以将正弦函数称为 Math.sin(x) ,其中 x 是该方法的参数。我们可以在 CoffeeScript 代码中使用 JavaScript 的 Math 对象来执行数学运算。

Mathematical constants

如果我们希望使用任何常用的数学常量,例如 pi 或 e,我们可以通过使用 JavaScript 的 Math 对象来使用它们。

以下是 JavaScript 的 Math 对象提供的 Math 常量的列表

S.No.

Property & Description

1

E 欧拉常数和自然对数的底数,大约是 2.718。

2

LN2 自然对数 2,大约是 0.693。

3

LN10 自然对数 10,大约是 2.302。

4

LOG2E E 的 2 底数对数,大约是 1.442。

5

LOG10E E 的 10 底数对数,大约是 0.434。

6

PI 圆的周长与其直径之比,大约是 3.14159。

7

SQRT1_2 1/2 的平方根;等价地,除以 2 的平方根,大约是 0.707。

8

SQRT2 2 的平方根,约为 1.414。

Example

以下示例展示了 CoffeeScript 中 JavaScript 提供的数学常量的用法。将此代码保存在一个名为 math_example.coffee 的文件中

e_value = Math.E
console.log "The value of the constant E is: " + e_value

LN2_value = Math.LN2
console.log "The value of the constant LN2 is: " + LN2_value

LN10_value = Math.LN10
console.log "The value of the constant LN10 is: " + LN10_value

LOG2E_value = Math.LOG2E
console.log "The value of the constant LOG2E is: " + LOG2E_value

LOG10E_value = Math.LOG10E
console.log "The value of the constant LOG10E is: " + LOG10E_value

PI_value = Math.PI
console.log "The value of the constant PI is: " + PI_value

SQRT1_2_value = Math.SQRT1_2
console.log "The value of the constant SQRT1_2 is: " + SQRT1_2_value

SQRT2_value = Math.SQRT2
console.log "The value of the constant SQRT2 is: " + SQRT2_value

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c math_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var LN10_value, LN2_value, LOG10E_value, LOG2E_value, PI_value, SQRT1_2_value, SQRT2_value, e_value;

  e_value = Math.E;

  console.log("The value of the constant E is: " + e_value);

  LN2_value = Math.LN2;

  console.log("The value of the constant LN2 is: " + LN2_value);

  LN10_value = Math.LN10;

  console.log("The value of the constant LN10 is: " + LN10_value);

  LOG2E_value = Math.LOG2E;

  console.log("The value of the constant LOG2E is: " + LOG2E_value);

  LOG10E_value = Math.LOG10E;

  console.log("The value of the constant LOG10E is: " + LOG10E_value);

  PI_value = Math.PI;

  console.log("The value of the constant PI is: " + PI_value);

  SQRT1_2_value = Math.SQRT1_2;

  console.log("The value of the constant SQRT1_2 is: " + SQRT1_2_value);

  SQRT2_value = Math.SQRT2;

  console.log("The value of the constant SQRT2 is: " + SQRT2_value);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee math_example.coffee

执行后,CoffeeScript 文件产生以下输出。

The value of the constant E is: 2.718281828459045
The value of the constant LN2 is: 0.6931471805599453
The value of the constant LN10 is: 2.302585092994046
The value of the constant LOG2E is: 1.4426950408889634
The value of the constant LOG10E is: 0.4342944819032518
The value of the constant PI is: 3.141592653589793
The value of the constant SQRT1_2 is: 0.7071067811865476
The value of the constant SQRT2 is: 1.4142135623730951

Math Methods

除了属性之外,Math 对象还提供方法。以下是 JavaScript 的 Math 对象的方法列表。点击这些方法的名称来获取一个示例,展示它们在 CoffeeScript 中的用法。

S.No.

Method & Description

1

abs() 返回一个数的绝对值。

2

acos() 返回一个数的反余弦(以弧度为单位)。

3

asin() 返回一个数的反正弦(以弧度为单位)。

4

:localyear: 2024:drop-line atan() 返回数字的反正切(以弧度为单位)。

5

:localyear: 2024:drop-line atan2() 返回其自变量商的反切。

6

:localyear: 2024:drop-line ceil() 返回大于或等于数字的最小整数。

7

:localyear: 2024:drop-line cos() 返回一个数字的余弦。

8

:localyear: 2024:drop-line exp() 返回 EN,其中 N 是自变量,而 E 是欧拉常数,自然对数的底数。

9

:localyear: 2024:drop-line floor() 返回小于或等于数字的最大整数。

10

:localyear: 2024:drop-line log() 返回一个数字的自然对数(以 E 为底)。

11

:localyear: 2024:drop-line max() 返回零或多个数字中的最大值。

12

:localyear: 2024:drop-line min() 返回零或多个数字中的最小值。

13

:localyear: 2024:drop-line pow() 返回底数的指数幂,即底数的指数。

14

:localyear: 2024:drop-line random() 返回 0 到 1 之间的伪随机数。

15

:localyear: 2024:drop-line round() 返回最接近整数的数字值。

16

:localyear: 2024:drop-line sin() 返回一个数字的正弦。

17

:localyear: 2024:drop-line sqrt() 返回一个数字的平方根。

18

:localyear: 2024:drop-line tan() 返回一个数字的正切。

CoffeeScript - Exception Handling

当一个程序正在运行时,一个异常(或异常事件)是一个突发问题。当一个异常发生时,程序的正常流程被打断,并且程序/应用程序异常终止,这是不推荐的,因此这些异常应被处理。

一个异常可能由于许多不同的原因发生。以下是一些异常发生的情况。

  1. 用户输入了无效数据。

  2. 找不到需要打开的文件。

Exceptions in CoffeeScript

CoffeeScripts使用 try catch and finally 块支持异常/错误处理。这些块的功能与JavaScript相同, try 块保存异常声明, catch 块在异常发生时需要执行的操作, finally 块用于无条件地执行语句。

以下是CoffeeScript中 try catchfinally 块的语法。

 try
   // Code to run

 catch ( e )
   // Code to run if an exception occurs

 finally
   // Code that is always executed regardless of
   // an exception occurring

try 块必须紧跟一个 catch 块或一个 finally 块(或者两者)。当在 try 块中发生异常时,该异常被置入 e 中,且 catch 块被执行。可选的 finally 块会在 try/catch 之后无条件执行。

Example

以下示例演示了使用CoffeeScript中的try和catch块进行异常处理。在这里,我们试图在CoffeeScript操作中使用一个未定义的符号,我们使用 trycatch 块处理了发生的错误。使用 Exception_handling.coffee 名称将此代码保存在一个文件中

try
  x = y+20
  console.log "The value of x is :" +x
catch e
  console.log "exception/error occurred"
  console.log "The STACKTRACE for the exception/error occurred is ::"
  console.log e.stack

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c Exception_handling.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var e, error, x;

  try {
    x = y + 20;
    console.log("The value of x is :" + x);
  } catch (error) {
    e = error;
    console.log("exception/error occurred");
    console.log("The STACKTRACE for the exception/error occurred is ::");
    console.log(e.stack);
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee Exception_handling.coffee

执行后,CoffeeScript 文件产生以下输出。

exception/error occurred
The STACKTRACE for the exception/error occurred is ::
ReferenceError: y is not defined
  at Object.<anonymous> (C:\Examples\strings_exceptions\Exception_handling.coffee:3:7)
  at Object.<anonymous> (C:\Examples\strings_exceptions\Exception_handling.coffee:2:1)
  at Module._compile (module.js:413:34)
  at Object.exports.run (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\coffee-script.js:134:23)
  at compileScript (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\command.js:224:29)
  at compilePath (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\command.js:174:14)
  at Object.exports.run (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\command.js:98:20)
  at Object.<anonymous> (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\bin\coffee:7:41)
  at Module._compile (module.js:413:34)
  at Object.Module._extensions..js (module.js:422:10)
  at Module.load (module.js:357:32)
  at Function.Module._load (module.js:314:12)
  at Function.Module.runMain (module.js:447:10)
  at startup (node.js:139:18)
  at node.js:999:3

The finally block

我们也可以使用 finally 块重写上面的示例。如果这样做,此块的内容将在 trycatch 之后无条件地执行。使用 Exception_handling_finally.coffee 名称将此代码保存在文件中

try
  x = y+20
  console.log "The value of x is :" +x
catch e
  console.log "exception/error occurred"
  console.log "The STACKTRACE for the exception/error occurred is ::"
  console.log e.stack

finally
  console.log "This is the statement of finally block"

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c Exception_handling_finally.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var e, error, x;

  try {
    x = y + 20;
    console.log("The value of x is :" + x);
  } catch (error) {
    e = error;
    console.log("exception/error occurred");
    console.log("The STACKTRACE for the exception/error occurred is ::");
    console.log(e.stack);
  } finally {
    console.log("This is the statement of finally block");
  }

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee Exception_handling_finally.coffee

执行后,CoffeeScript 文件产生以下输出。

exception/error occurred
The STACKTRACE for the exception/error occurred is ::
ReferenceError: y is not defined
  at Object.<anonymous> (C:\Examples\strings_exceptions\Exception_handling.coffee:3:7)
  at Object.<anonymous> (C:\Examples\strings_exceptions\Exception_handling.coffee:2:1)
  at Module._compile (module.js:413:34)
  at Object.exports.run (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\coffee-script.js:134:23)
  at compileScript (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\command.js:224:29)
  at compilePath (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\command.js:174:14)
  at Object.exports.run (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\lib\coffee-script\command.js:98:20)
  at Object.<anonymous> (C:\Users\Tutorialspoint\AppData\Roaming\npm\node_modules\coffee-script\bin\coffee:7:41)
  at Module._compile (module.js:413:34)
  at Object.Module._extensions..js (module.js:422:10)
  at Module.load (module.js:357:32)
  at Function.Module._load (module.js:314:12)
  at Function.Module.runMain (module.js:447:10)
  at startup (node.js:139:18)
  at node.js:999:3

This is the statement of finally block

The throw Statement

CoffeeScript还支持 throw 语句。您可以使用throw语句引发您的内置异常或自定义异常。稍后可以捕获这些异常,您可以采取适当的措施。

Example

以下示例演示了在CoffeeScript中使用 throw 语句。使用名称 throw_example.coffee 将此代码保存在文件中

myFunc = ->
  a = 100
  b = 0
  try
    if b == 0
      throw ("Divided by zero error.")
    else
      c = a / b
  catch e
    console.log "Error: " + e

myFunc()

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c throw_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var myFunc;

  myFunc = function() {
    var a, b, c, e, error;
    a = 100;
    b = 0;
    try {
      if (b === 0) {
        throw "Divided by zero error.";
      } else {
        return c = a / b;
      }
    } catch (error) {
      e = error;
      return console.log("Error: " + e);
    }
  };

  myFunc();

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee throw_example.coffee

执行后,CoffeeScript 文件产生以下输出。

Divided by zero error.

CoffeeScript - Regular Expressions

正则表达式是描述字符模式的对象,JavaScript 支持。在 JavaScript 中,RegExp 类表示正则表达式,String 和 RegExp 都定义了使用正则表达式对文本执行功能强大的模式匹配和搜索并替换功能的方法。

Regular Expressions in CoffeeScript

CoffeeScript 中的正则表达式与 JavaScript 相同。访问以下链接以查看 JavaScript 中的正则表达式− javascript_regular_expressions

Syntax

通过将 RegExp 模式放在反斜杠之间来定义 CoffeeScript 中的正则表达式,如下所示。

pattern =/pattern/

Example

以下是 CoffeeScript 中正则表达式的示例。此处,我们创建了一个表达式以查找处于粗体中的数据(<b> 和 </b> 标记之间的数据)。将此代码保存在名为 regex_example.coffee 的文件中

input_data ="hello how are you welcome to <b>Tutorials Point.</b>"
regex = /<b>(.*)<\/b>/
result = regex.exec(input_data)
console.log result

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c regex_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var input_data, regex, result;

  input_data = "hello how are you welcome to <b>Tutorials Point.</b>";

  regex = /<b>(.*)<\/b>/;

  result = regex.exec(input_data);

  console.log(result);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee regex_example.coffee

执行后,CoffeeScript 文件产生以下输出。

[ '<b>Tutorials Point.</b>',
  'Tutorials Point.',
  index: 29,
  input: 'hello how are you welcome to <b> Tutorials Point.</b>' ]

heregex

我们使用 JavaScript 提供的语法编写的复杂正则表达式不可读,因此,为了使正则表达式更具可读性,CoffeeScript 为正则表达式提供了一个扩展语法,称为 heregex 。使用此语法,我们可以使用空格打断常规的正则表达式,并且我们还可以在这些扩展的正则表达式中使用注释,从而使它们更加用户友好。

Example

以下示例演示了在 CoffeeScript 中使用高级正则表达式 heregex 。此处,我们使用高级正则表达式重写上述示例。将此代码保存在名为 heregex_example.coffee 的文件中

input_data ="hello how are you welcome to Tutorials Point."
heregex = ///
<b>  #bold opening tag
(.*) #the tag value
</b>  #bold closing tag
///
result = heregex.exec(input_data)
console.log result

打开 command prompt 并按照以下所示编译 .coffee 文件。

c:\> coffee -c heregex_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var heregex, input_data, result;

  input_data = "hello how are you welcome to <b> Tutorials Point.</b>";

  heregex = /<b>(.*) <\/b>/;

  result = heregex.exec(input_data);

  console.log(result);

}).call(this);

现在,再次打开 command prompt 并按照以下所示运行 CoffeeScript 文件。

c:\> coffee heregex_example.coffee

执行后,CoffeeScript 文件产生以下输出。

[ '<b>Tutorials Point.</b>',
  'Tutorials Point.',
  index: 29,
  input: 'hello how are you welcome to <b>Tutorials Point.</b>' ]

CoffeeScript - Classes and Inheritance

JavaScript不提供 class 关键字。我们可以使用对象及其原型在JavaScript中实现继承。每个对象都有自己的原型,并且它们从其原型中继承函数和属性。由于原型也是一个对象,因此它也有自己的原型。

尽管原型继承比经典继承强大得多,但对于新手用户来说,它却很困难且容易混淆。

Classes in CoffeeScript

为了解决此问题,CoffeeScript提供了一种称为 class 的基本结构,它是使用JavaScript的原型构建的。您可以使用class关键字在CoffeeScript中定义一个类,如下所示。

class Class_Name

Example

考虑以下示例,在这里,我们使用关键字 class 创建了一个名为 Student 的类。

class Student

如果您编译上面的代码,它将生成以下JavaScript。

var Student;

Student = (function() {
  function Student() {}

  return Student;

})();

Instantiating a class

我们可以使用new运算符实例化一个类,就像其他面向对象编程语言一样,如下所示。

new Class_Name

您可以使用 new 运算符实例化上述创建的(Student)类,如下所示。

class Student
new  Student

如果您编译上面的代码,它将生成以下JavaScript。

var Student;

Student = (function() {
  function Student() {}

  return Student;

})();

new Student;

Defining a Constructor

构造函数是一个在实例化类时调用的函数,它的主要目的是初始化实例变量。在CoffeeScript中,您可以通过创建一个名为 constructor 的函数来定义一个构造函数,如下所示。

class Student
  constructor: (name)->
  @name = name

在这里,我们定义了一个构造函数并将局部变量名称分配给实例变量。

@ 运算符是 this 关键字的别名,它用于指向类的实例变量。

如果我们在构造函数的参数前面放置 @ ,它将自动设置为实例变量。因此,上面的代码可以简单地写成如下所示:

class Student
  constructor: (@name)->

Example

这是一个CoffeeScript中的构造函数示例。将其另存为名为 constructor_example.coffee 的文件中

#Defining a class
class Student
  constructor: (@name)->

#instantiating a class by passing a string to constructor
student = new Student("Mohammed");
console.log "the name of the student is :"+student.name

Compiling the code

打开命令提示符并编译上述示例,如下所示。

c:\>coffee -c constructor_example.coffee

执行上述命令将生成以下JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var Student, student;

  Student = (function() {
    function Student(name) {
      this.name = name;
    }

    return Student;

  })();

  student = new Student("Mohammed");

  console.log("The name of the student is :"+student.name);

}).call(this);

Executing the Code

在命令提示符上执行以下命令,以运行上述示例。

coffee constructor_example.coffee

运行后,上述示例将给出以下输出。

The name of the student is :Mohammed

Instance Properties

与对象中一样,我们还可以在类中使用属性。这些称作 instance properties

Example

考虑以下示例。在该示例中,我们在类中创建了变量(name、age)和函数(message()),并使用该对象访问了它们。将此示例保存为名为 instance_properties_example.coffee 的文件。

#Defining a class
class Student
  name="Ravi"
  age=24
  message: ->
    "Hello "+name+" how are you"

#instantiating a class by passing a string to constructor
student = new Student();
console.log student.message()

在编译后,上述代码将生成以下输出。

// Generated by CoffeeScript 1.10.0
(function() {
  var Student, student;

  Student = (function() {
    var age, name;

    function Student() {}

    name = "Ravi";

    age = 24;

    Student.prototype.message = function() {
      return "Hello " + name + " how are you";
    };

    return Student;

  })();

  student = new Student();

  console.log(student.message());

}).call(this);

Static Properties

我们可以在类中定义静态属性。静态属性的范围局限在类中,我们使用 this keyword 或其别名 @ 符号创建静态函数,并且我们必须通过类名称 Class_Name.property 访问这些属性。

Example

以下示例中,我们创建了一个名为 message 的静态函数,并对它进行了访问。将其保存在名为 static_properties_example.coffee 的文件中。

#Defining a class
class Student
  @message:(name) ->
    "Hello "+name+" how are you"
console.log Student.message("Raju")

使用以下命令打开命令提示符并编译上面的 CoffeeScript 文件。

c:\>coffee -c  static_properties_example.coffee

编译后,它会给你以下 JavaScript。

// Generated by CoffeeScript 1.10.0
(function() {
  var Student;

  Student = (function() {
    function Student() {}

    Student.message = function(name) {
      return "Hello " + name + " how are you";
    };

    return Student;

  })();

  console.log(Student.message("Raju"));

}).call(this);

在命令提示符中执行上面的 coffeeScript,如下所示。

c:\>coffee static_properties_example.coffee

执行时,上面的示例将输出以下内容。

Hello Raju how are you

Inheritance

在 CoffeeScript 中,我们可以使用 extends 关键字从一个类继承另一个类的属性。

Example

以下是 CoffeeScript 中继承的一个示例。在这里,我们有两个类,即 AddMy_class 。我们继承了名为 Add 的类的属性在 My_class 类中,并使用 extends 关键字访问它们。

#Defining a class
class Add
   a=20;b=30

   addition:->
     console.log "Sum of the two numbers is :"+(a+b)

class My_class extends Add

my_class = new My_class()
my_class.addition()

CoffeeScript 幕后使用原型继承。在 CoffeeScript 中,每当我们创建实例时,都会调用父类的构造函数,直到我们重写它。

我们可以使用 super() 关键字从子类调用父类的构造函数,如下面的示例所示。

#Defining a class
class Add
   constructor:(@a,@b) ->

   addition:=>
     console.log "Sum of the two numbers is :"+(@a+@b)

class Mul extends Add
   constructor:(@a,@b) ->
     super(@a,@b)

   multiplication:->
     console.log "Product of the two numbers is :"+(@a*@b)

mul = new Mul(10,20)
mul.addition()
mul.multiplication()

Dynamic Classes

CoffeeScript 使用原型继承自动继承类的所有实例属性。这确保了类的动态性;即使在创建子类之后向父类添加属性,该属性仍会传播到所有继承的子类。

class Animal
  constructor: (@name) ->

class Parrot extends Animal

Animal::rip = true

parrot = new Parrot("Macaw")
console.log "This parrot is no more" if parrot.rip

执行时,上面的 CoffeeScript 生成以下 JavaScript 代码。

// Generated by CoffeeScript 1.10.0
(function() {
  var Animal, Parrot, parrot,
    extend = function(child, parent) { for (var key in parent) {
      if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() {
      this.constructor = child; } ctor.prototype = parent.prototype;
      child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty;

  Animal = (function() {
    function Animal(name) {
      this.name = name;
    }

    return Animal;

  })();

  Parrot = (function(superClass) {
    extend(Parrot, superClass);

    function Parrot() {
      return Parrot.__super__.constructor.apply(this, arguments);
    }

    return Parrot;

  })(Animal);

  Animal.prototype.rip = true;

  parrot = new Parrot("Macaw");

  if (parrot.rip) {
    console.log("This parrot is no more");
  }

}).call(this);

CoffeeScript - Ajax

AJAX 是创建交互式 Web 应用程序的 Web 开发技术。

  1. * * 异步*爪*瓦*脚*本和*X*ML。这是一种使用XML、HTML、CSS和JavaScript创建一个更好、更快、更具有交互性的Web应用程序的新技术。

  2. Ajax 将 XHTML 用于内容,将 CSS 用于演示,并使用文档对象模型和 JavaScript 用于动态内容显示。

  3. * * *传统的Web应用程序使用同步请求来向服务器传输信息。这意味着你填写一个表单,点击提交,并进入一个新的页面,其中包含服务器的新信息。

  4. 使用 AJAX,当您点击提交时,JavaScript 将向服务器发出请求,解释结果并更新当前屏幕。从最纯粹的意义上来说,用户永远不会知道根本没有把任何东西传输到服务器。

  5. XML 通常用作接收服务器数据的格式,尽管可以使用任何格式,包括纯文本。

  6. AJAX 是独立于 Web 服务器软件的 Web 浏览器技术。

  7. 用户可以在后台的客户端程序向服务器请求信息时继续使用该应用程序。

    • * *一般来说,我们使用jQuery来使用Ajax。以下是Ajax和jQuery的一个例子

<html>

   <head>
      <title>The jQuery Example</title>
      <script type = "text/javascript"
         src = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>

      <script type = "text/javascript" language = "javascript">
         $(document).ready(function() {
            $("#driver").click(function(event){
               $('#stage').load('/jquery/result.html');
            });
         });
      </script>
   </head>

   <body>

      <p>Click on the button to load /jquery/result.html file −</p>

      <div id = "stage" style = "background-color:cc0;">
         STAGE
      </div>

      <input type = "button" id = "driver" value = "Load Data" />

   </body>

</html>
  • * 这里 *load() 初始化了一个Ajax请求到指定的URL /coffeescript/result.html 文件。加载此文件后,所有内容将被填充到带ID舞台的<div>标记中。假设我们的/jquery/result.html文件只有一行HTML −

<h1>THIS IS RESULT...</h1>
  • * *当你点击给定的按钮,result.html文件就会被加载。

CoffeeScript with Ajax

  • * *我们可以使用CoffeeScript重新编写上面的示例,如下所示。

<html>

   <head>
      <title>The jQuery Example</title>
      <script type = "text/javascript"
         src = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
      <script src="http://coffeescript.org/extras/coffee-script.js"></script>

      <script type="text/coffeescript">
        $(document).ready ->
          $('#driver').click (event) ->
            $('#stage').load '/jquery/result.html'
            return
          return
      </script>
   </head>

   <body>

      <p>Click on the button to load /jquery/result.html file -</p>

      <div id = "stage" style = "background-color:cc0;">
         STAGE
      </div>

      <input type = "button" id = "driver" value = "Load Data" />

   </body>

</html>

CoffeeScript - jQuery

Using CoffeeScript with jQuery

使用 CoffeeScript 使用 jQuery 时请牢记以下要点。

$ 符号表示我们的应用程序中的 jQuery 代码。使用此符号将 jQuery 代码与脚本语言分隔开,如下所示。

$(document).ready

在 CoffeeScript 中,除了在使用带有参数调用的函数和处理模棱两可代码时,不需要使用括号,且我们必须使用一个箭头标记(如降所示)替代函数定义 function()

$(document).ready ->

删掉不必要的 return 语句,因为 CoffeeScript 隐式地返回函数的尾部语句。

Example

下面是一个 JavaScript 代码,其中 <div> 元素被插入到所点击元素之前 −

<html>

   <head>
      <title>The jQuery Example</title>
      <script type = "text/javascript"
         src = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>

      <script type = "text/javascript" language = "javascript">
         $(document).ready(function() {
            $("div").click(function () {
               $(this).before('<div class="div"></div>' );
            });
         });
      </script>

      <style>
         .div{ margin:10px;padding:12px; border:2px solid #666; width:60px;}
      </style>
   </head>

   <body>

      <p>Click on any square below:</p>
      <span id = "result"> </span>

      <div class = "div" style = "background-color:blue;"></div>
      <div class = "div" style = "background-color:green;"></div>
      <div class = "div" style = "background-color:red;"></div>

   </body>

</html>

现在,我们可以将上述代码转换为 CoffeeScript 代码,如下所示

 <html>

   <head>
      <title>The jQuery Example</title>
      <script type = "text/javascript"
         src = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
      <script src="http://coffeescript.org/extras/coffee-script.js"></script>

      <script type="text/coffeescript">
        $(document).ready ->
          $('div').click ->
            $(this).before '<div class="div"></div>'
            return
          return
      </script>

      <style>
         .div{ margin:10px;padding:12px; border:2px solid #666; width:60px;}
      </style>
   </head>

   <body>

      <p>Click on any square below:</p>
      <span id = "result"> </span>

      <div class = "div" style = "background-color:blue;"></div>
      <div class = "div" style = "background-color:green;"></div>
      <div class = "div" style = "background-color:red;"></div>

   </body>

</html>

执行此代码会给你以下输出。

What is Callback?

回调是一个函数的异步等价物。一个回调函数在给定任务完成时被调用。Node 大量使用回调。Node 的所有 API 都用支持回调的方式编写。

例如,读取一个文件的函数可能会开始读取该文件,并立即将控制权返回给执行环境,以便可以执行下一条指令。一旦文件 I/O 完成,它将在传递回调函数的同时,将该文件的内容作为参数调用回调函数。因此没有阻塞或等待文件 I/O。这使得 Node.js 具有很高的可扩展性,因为它可以在不等待任何函数返回结果的情况下处理大量的请求。

Blocking Code Example

创建一个名为 input.txt 的文本文件,内容如下

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

创建一个名为 main.js 的 js 文件,其中包含以下代码 −

var fs = require("fs");
var data = fs.readFileSync('input.txt');
console.log(data.toString());
console.log("Program Ended");

现在运行 main.js 来查看结果 −

$ node main.js

验证输出。

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended

Non-Blocking Code Example

创建一个名为 input.txt 的文本文件,内容如下

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

将main.js文件更新为以下代码:

var fs = require("fs");
fs.readFile('input.txt', function (err, data) {
  if (err) return console.error(err);
    console.log(data.toString());
});
console.log("Program Ended");

现在运行 main.js 来查看结果 −

$ node main.js

验证输出。

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

这两个例子解释了 blocking and non-blocking calls 的概念。第一个例子显示程序在读取文件之前会阻塞,然后才结束程序,而在第二个例子中,程序不会等待文件读取,而是继续打印“Program Ended”。

因此,一个阻塞程序会大量按顺序执行。从编程的角度来看,实现逻辑更容易,但非阻塞程序不会按顺序执行。如果一个程序需要使用任何要处理的数据,则应该将其保留在同一个块中以使其顺序执行。

CoffeeScript - MongoDB

MongoDB是一个跨平台、面向文档的数据库,提供高性能、高可用性和易于扩展。MongoDB基于集合和文档的概念。有关更多信息,请阅读我们的 MongoDB Tutorial

在本章中,您将学习如何使用CoffeeScript与MongoDB数据库通信。

Installation

MongoDB数据库可以使用MongoDB的Node.js 2.0驱动与CoffeeScript集成。首先,您需要在系统中安装MongoDB,方法是参考我们的MongoDB教程的 environment 章节。

在成功安装MongoDB后,浏览其 bin 文件夹(如果您没有设置路径),并按照如下所示启动MongoDB服务。

C:\Program Files\MongoDB\Server\3.2\bin> mongod

最后,通过在命令提示符中执行以下NPM命令,安装MongoDB驱动程序及依赖项。

npm install mongodb --save

Connecting to MongoDB

为了连接到MongoDB,首先使用它创建MongoClient,调用 connect() 函数。此函数接受url和回调函数作为参数。

以下CoffeeScript代码显示了如何连接到MongoDB服务器。如果MongoDB服务器在您的系统中正在运行,此程序将建立与服务器的连接。

#Requiring the Mongodb package
mongo = require 'mongodb'

#Creating a MongoClient object
MongoClient = mongo.MongoClient

#Preparing the URL
url = 'mongodb://localhost:27017/testdb'

#Connecting to the server
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url
    #Close connection
    db.close()
  return

将以上代码保存在名为 connect_db.coffee 的文件中,然后按以下所示执行。如果数据库创建成功,将会显示以下消息

c:\> coffee connect_db.coffee
coffee connect_db.collection
Connection established to mongodb://localhost:27017/testdb

Creating a Collection

MongoDB 中的集合容纳我们存储在其中的文档。可以使用 collection() 函数创建集合。该函数接受一个字符串参数,该参数表示我们要创建的集合的名称。

以下 CoffeeScript 代码展示了如何在 MongoDB 中创建集合。如果有任何错误,它们都会在控制台上显示。

#Requiring the Mongodb package
mongo = require 'mongodb'

#Creating a MongoClient object
MongoClient = mongo.MongoClient

#Preparing the URL
url = 'mongodb://localhost:27017/testdb'

#Connecting to the server
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url

    #Create collection
    col = db.collection('My_collection')
    console.log "Collection created successfully."

    #Close connection
    db.close()
  return

将以上代码保存在名为 create_collection.coffee 的文件中,然后按以下所示执行。如果集合创建成功,将会显示以下消息

c:/> coffee create_collection.coffee
Connection established to mongodb://localhost:27017/testdb
Collection created successfully.

Inserting Documents

可以在 MongoDB 中向集合中插入文档,你需要调用名为 insert() 的函数,并按需传入要插入的文档列表,作为参数。

以下 CoffeeScript 代码展示了如何将文档插入名为 My_collection 的集合中。如果有任何错误,将在控制台中显示。

#Sample JSON Documents
doc1 = {name: 'Ram', age: 26, city: 'Hyderabad'}
doc2 = {name: 'Rahim', age: 27, city: 'Banglore'}
doc3 = {name: 'Robert', age: 28, city: 'Mumbai'}

#Requiring the Mongodb package
mongo = require 'mongodb'

#Creating a MongoClient object
MongoClient = mongo.MongoClient

#Preparing the URL
url = 'mongodb://localhost:27017/testdb'

#Connecting to the server
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url
  #Creating collection
  col = db.collection('My_collection')

  #Inserting documents
  col.insert [doc1,doc2,doc3], (err, result) ->
    if err
      console.log err
    else
      console.log "Documents inserted successfully"
    #Close connection
    db.close()
    return
  return

将上面的代码保存在名为 insert_documents.coffee 的文件中,并按照以下方式执行它。如果文档插入成功,则会显示以下消息

c:/> coffee insert_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Documents inserted successfully

Reading Documents

可以使用名为 find() 的函数检索存储在 MongoDB 中的文档。以下 CoffeeScript 代码展示了如何检索存储在 MongoDB 中的记录。

#Requiring the Mongodb package
mongo = require 'mongodb'

#Creating a MongoClient object
MongoClient = mongo.MongoClient

#Preparing the URL
url = 'mongodb://localhost:27017/testdb'

#Connecting to the server
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url
	#Creating collection object
    col = db.collection('My_collection')
    #Inserting Documents
    col.find({name: 'Ram'}).toArray (err, result)->
      if err
        console.log err
      else
      console.log 'Found:', result
      #Closing connection
      db.close()
      return
  return

将上面的代码保存在名为 read_documents.coffee 的文件中,并按照以下方式执行它。此程序按指定集合检索所需的文档并按照以下方式显示它。

C:\> coffee read_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Found: [ { _id: 56e269c10478809c3009ad1e,
    name: 'Ram',
    age: 26,
    city: 'Hyderabad' } ]

你还可以通过按照以下方式执行 find() 函数来读取特定集合中存在的文档,而不向它传递任何参数。

#Requiring the Mongodb package
mongo = require 'mongodb'

#Creating a MongoClient object
MongoClient = mongo.MongoClient

#Preparing the URL
url = 'mongodb://localhost:27017/testdb'

#Connecting to the server
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url
	#Creating collection object
    col = db.collection('My_collection')
    #Reading all Documents
    col.find().toArray (err, result)->
      if err
        console.log err
      else
      console.log 'Found:', result
      #Closing connection
      db.close()
      return
  return

将上面的代码保存在名为 read_all_documents.coffee 的文件中,并按照以下方式执行它。此程序按指定集合检索所有文档并按照以下方式显示它。

C:\> coffee read_all_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Found: [ { _id: 56e2c5e27e0bad741a68c03e,
    name: 'Ram',
    age: 26,
    city: 'Hyderabad' },
  { _id: 56e2c5e27e0bad741a68c03f,
    name: 'Rahim',
    age: 27,
    city: 'Banglore' },
  { _id: 56e2c5e27e0bad741a68c040,
    name: 'Robert',
    age: 28,
    city: 'Mumbai' } ]

Updating Documents

可以使用名为 update() 的函数更新存储在 MongoDB 中的文档。以下 CoffeeScript 代码展示了如何更新存储在 MongoDB 中的记录。

#Get mongo client object
MongoClient = require('mongodb').MongoClient
#Connecting to mongodb
url = 'mongodb://localhost:27017/testdb'
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url
	#Creating collection
    col = db.collection('My_collection')
    #Reading Data
    col.update {name:'Ram'},{$set:{city:'Delhi'}},(err, result)->
      if err
        console.log err
      else
      console.log "Document updated"

      #Closing connection
      db.close()
	  return
  return

此程序将 Ram 名为员工的城市从 Hyderabad 更新为 Delhi。

将上面的代码保存在名为 update_documents.coffee 的文件中,并按照以下方式执行它。此程序按指定集合检索文档并按照以下方式显示它。

C:\> coffee update_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Document updated

更新后,如果你执行 read_documents.coffee 程序,则你会观察到名为 Ram 的人的城市名从 Hyderabad 更新为 Delhi

C:\> coffee Read_all_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Found: [ { _id: 56e2c5e27e0bad741a68c03e,
    name: 'Ram',
    age: 26,
    city: 'Delhi' },
  { _id: 56e2c5e27e0bad741a68c03f,
    name: 'Rahim',
    age: 27,
    city: 'Banglore' },
  { _id: 56e2c5e27e0bad741a68c040,
    name: 'Robert',
    age: 28,
    city: 'Mumbai' } ]

Deleting Documents

可以使用 remove() 函数从集合中删除所有文档。以下 CoffeeScript 代码展示了如何删除存储在 MongoDB 中的所有记录。

#Get mongo client object
MongoClient = require('mongodb').MongoClient
#Connecting to mongodb
url = 'mongodb://localhost:27017/testdb'
MongoClient.connect url, (err, db) ->
  if err
    console.log 'Unable to connect . Error:', err
  else
    console.log 'Connection established to', url
	#Creating collection
    col = db.collection('My_collection')
    #Deleting Data
    col.remove()
    console.log "Document deleted"

    #Closing connection
    db.close()
  return

将上面的代码保存在名为 delete_documents.coffee 的文件中,并按照以下方式执行它。此程序删除指定集合中的所有文档,显示以下消息。

C:\> coffee delete_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Document deleted

删除后,如果你执行 read_documents.coffee 程序,则你会看到一个空集合,如下所示。

C:\> coffee Read_all_documents.coffee
Connection established to mongodb://localhost:27017/testdb
Found: [ ]

CoffeeScript - SQLite

SQLite 是一个轻量级的、基于架构的关系数据库引擎。作为网络浏览器中本地存储的嵌入式数据库软件,它是一个热门选择。

与许多其他数据库管理系统不同,SQLite 不是一个客户端-服务器数据库引擎。有关详细信息,请阅读我们的链接:../sqlite/sqlite_overview.htm [SQLite 教程]

在本章中,你将学习如何使用 CoffeeScript 与 SQLite 数据库进行通信。

Installation

可以 node-sqlite3 模块将 SQLite3 数据库与 CoffeeScript 集成。此模块适用于 Node.js v0.10.x、v0.12.x、v4.x 和 v5.x。除了它还可以提供一个直接查询和参数绑定接口以及一个查询序列化 API 之外,此模块迎合了使用 CoffeeScript 与 SQLite3 进行通信的各种功能。

可以使用 npm 安装 node-sqlite3 模块,如下所示。

npm install sqlite3

要使用 sqlite3 模块,必须首先创建一个表示数据库的连接对象,并且此对象将帮助你执行所有 SQL 语句。

Connecting to Database

为了连接到 SQLite 数据库,首先通过调用 require() 函数的 node-sqlite3 模块创建其包,并将字符串 sqlite3 作为参数传递给它。然后,通过将数据库的名称传递给 sqlite3.Database() 构造,连接到数据库。

以下 CoffeeScript 代码显示了如何连接到现有数据库。如果数据库不存在,则会使用给定名称 test.db 创建数据库,然后打开数据库,最后返回数据库对象。

#Creating sqlite3 package
sqlite3 = require('sqlite3')

#Creating a Database instance
db = new (sqlite3.Database)('test.db')
console.log "Database opened successfully."

我们还可以提供 :memory: 来创建匿名内存数据库,以及空字符串来创建匿名基于磁盘的数据库,而不是 test.db。将上述代码保存为一个名为 create_db.coffee 的文件,并按如下所示执行该代码。如果数据库成功创建,那么它将产生以下消息:

c:\> coffee create_db.coffee
Successfully connected

Creating a Table

你可以通过 CoffeeScript 中的 run() 函数创建 SQLite 数据库中的表。以字符串格式将创建表的查询传递给该函数。

以下 CoffeeScript 程序将用于在先前 test.db 数据库中创建表:

#Creating sqlite3 package
sqlite3 = require('sqlite3')

#Creating a Database instance
db = new (sqlite3.Database)('test.db')
console.log "Successfully connected"

db.serialize ->
  db.run 'CREATE TABLE STUDENT (name TEXT, age INTEGER, city TEXT)'
  console.log "Table created successfully"
  return
db.close()

serialize() 函数将数据库设置为序列化模式。在这种模式下,当遇到回调时,它将立即被调用。该回调中的查询会被串行执行。该函数返回后,数据库将再次被设置为正常模式。在完成事务之后,我们需要使用 close() 函数关闭连接。

将上述代码保存为一个名为 create_table.coffee 的文件,并按如下所示执行该代码。这将在 test.db 数据库中创建名为 STUDENT 的表,显示以下消息。

C:\> coffee create_table.coffee
Successfully connected
Table created successfully

Inserting / Creating Data

可以通过执行插入语句将数据插入 SQLite 数据库中,方法是使用 CoffeeScript 代码。为此,可以使用准备 SQL 语句的 prepare() 函数。

它还接受具有绑定变量 ( ? ) 的查询,可以使用 run() 函数附加值到这些变量。可以使用预处理语句插入多条记录,插入所有记录后,需要使用 finalize() 函数最终确定预处理语句。

以下 CoffeeScript 程序展示了如何插入到上一个示例中创建的 STUDENT 表中记录。

#Creating sqlite3 package
sqlite3 = require('sqlite3').verbose()

#Creating a Database instance
db = new (sqlite3.Database)('test.db')
console.log "Successfully connected"

db.serialize ->
  stmt = db.prepare('INSERT INTO STUDENT VALUES (?,?,?)')
  stmt.run 'Ram',24,'Hyderabad'
  stmt.run 'Robert',25,'Mumbai'
  stmt.run 'Rahim',26,'Bangalore'
  stmt.finalize()
  console.log "Data inserted successfully"
  return
db.close()

将以上代码保存在以 insert_data.coffee 命名的文件中,并按照如下所示执行。这将填充名为 STUDENT 的表格,显示以下消息。

C:\> coffee insert_data.coffee
Successfully connected
Data inserted successfully

Reading / Retrieving Data

可以使用 each() 函数从 SQLite 表中获取数据。此函数接受可选的回调函数,该回调函数将针对每一行调用。

以下 CoffeeScript 程序展示了如何从上一个示例中创建的 STUDENT 表中提取和显示记录

#Creating sqlite3 package
sqlite3 = require('sqlite3').verbose()

#Creating a Database instance
db = new (sqlite3.Database)('test.db')
console.log "Successfully connected"

db.serialize ->
  console.log "The contents of the table STUDENT are ::"
  db.each 'SELECT rowid AS id, name,age,city FROM STUDENT', (err, row) ->
    console.log row.id + ': ' +row.name+', '+ row.age+', '+ row.city
    return
  return
db.close()

将以上代码保存在以 retrive_data.coffee 命名的文件中,并按照如下所示执行。这将检索名为 STUDENT 的表中的所有记录,并在控制台按如下方式显示。

C:\> coffee retrive_data.coffee
Successfully connected
The contents of the table STUDENT are ::
1: Ram, 24, Hyderabad
2: Robert, 25, Mumbai
3: Rahim, 26, Bangalore

Updating Data

以下 CoffeeScript 代码显示了如何使用 UPDATE 语句更新任何记录,然后提取和显示名为 STUDENT 的表中更新后的记录

#Creating sqlite3 package
sqlite3 = require('sqlite3').verbose()

#Creating a Database instance
db = new (sqlite3.Database)('test.db')
console.log "Successfully connected"

db.serialize ->
  #Updating data
  stmt = db.prepare('UPDATE STUDENT SET city = ? where name = ?')
  stmt.run 'Delhi','Ram'
  console.log "Table updated"
  stmt.finalize()

  #Retrieving data after update operation
  console.log "The contents of the table STUDENT after update operation are ::"
  db.each 'SELECT rowid AS id, name, city FROM STUDENT', (err, row) ->
    console.log row.id + ': ' +row.name+', '+ row.city
    return
  return
db.close()

将以上代码保存在以 update_data.coffee 命名的文件中,并按照如下所示执行。这会更新名为 Ram 的学生的城市,并在更新操作后按如下所示在表中显示所有记录。

C:\> coffee update_data.coffee
Successfully connected
Table updated
The contents of the table STUDENT after update operation are ::
1: Ram, Delhi
2: Robert, Mumbai
3: Rahim, Bangalore

Deleting Data

以下 CoffeeScript 代码显示了如何使用 DELETE 语句删除任何记录,然后提取和显示名为 STUDENT 的表中余下的记录。

#Creating sqlite3 package
sqlite3 = require('sqlite3').verbose()

#Creating a Database instance
db = new (sqlite3.Database)('test.db')
console.log "Successfully connected"

db.serialize ->
  #Deleting data
  stmt = db.prepare('DELETE FROM STUDENT WHERE name = ?')
  stmt.run 'Ram'
  console.log "Record deleted"
  stmt.finalize()

  #Retrieving data after delete operation
  console.log "The contents of the table STUDENT after delete operation are ::"
  db.each 'SELECT rowid AS id, name, city FROM STUDENT', (err, row) ->
    console.log row.id + ': ' +row.name+', '+ row.city
    return
  return
db.close()

将以上代码保存在以 delete_data.coffee 命名的文件中,并按照如下所示执行。它会删除名为 Ram 的学生的记录,并在删除操作后按如下所示显示表中所有余下的记录。

Successfully connected
Record deleted
The contents of the table STUDENT after delete operation are ::
2: Robert, Mumbai
3: Rahim, Bangalore