# Ruby 语法结构

> 原文： [https://zetcode.com/lang/rubytutorial/lexis/](https://zetcode.com/lang/rubytutorial/lexis/)

像人类语言一样，计算机语言也具有词汇结构。 Ruby 程序的源代码由令牌组成。 令牌是原子代码元素。 在 Ruby 语言中，我们具有各种词汇结构，例如注释，变量，字面值，空白，运算符，定界符和关键字。

## Ruby 注释

注释被人类用来阐明源代码。 Ruby 中有两种类型的注释。 单行和多行注释。 单行注释以`#`字符开头。 多行注释放在`=begin`和`=end`标记之间。

```ruby
#!/usr/bin/ruby

=begin
  comments.rb
  author Jan Bodnar
  ZetCode 2011
=end

# prints message to the terminal
puts "Comments example"

```

显示两种类型注释的示例。 注释会被 Ruby 解释器忽略。

```ruby
=begin
  comments.rb
  author Jan Bodnar
  ZetCode 2014
=end

```

这是多行注释的示例。 这两个标记必须从行的开头开始。

## Ruby 空白字符

Ruby 中的空白用于分隔标记并终止源文件中的语句。 它还用于提高源代码的可读性。

```ruby
if true then
    puts "A message"
end

```

在某些地方需要空格。 例如，在`if`关键字和`true`关键字之间。 或在`puts`方法和实际字符串之间。 在其他地方，这是禁止的。 它不能出现在变量标识符或语言关键字中。

```ruby
a=1
b = 2
c  =  3

```

标记之间放置的空间量与 Ruby 解释器无关。 但是，在整个项目中拥有一种风格很重要。

```ruby
#!/usr/bin/ruby

x = 5 + 3
puts x

x = 5 
      + 3
puts x      

x = 5 + 
        3
puts x

```

可以使用换行符（空白格式）来终止语句。

```ruby
x = 5 + 3

```

在第一种情况下，我们有一个语句。 加法的总和分配给`x`变量。 该变量为 8。

```ruby
x = 5 
      + 3

```

现在，有两个语句。 第一条语句以换行符终止。 `x`变量为 5。还有另一个语句`+3`，它无效。

```ruby
x = 5 + 
        3

```

最后，我们有一个语句。 换行符前面带有`+`二进制运算符，因此解释器需要另一个值。 它看起来在第二行。 在这种情况下，它将两行都作为一条语句。 `x`变量为 8。

```ruby
$ ./whitespace.rb
8
5
8

```

输出。

## Ruby 变量

变量是一个标识符，它保存一个值。 在编程中，我们说我们为变量分配了一个值。 从技术上讲，变量是对存储值的计算机内存的引用。 在 Ruby 中，变量可以容纳字符串，数字或各种对象。 可以随时间为变量分配不同的值。

Ruby 中的变量名称是由字母数字字符和下划线（`_`）字符创建的。 变量不能以数字开头。 解释器可以更容易地区分字面值数字和变量。 变量名不能以大写字母开头。 如果标识符以大写字母开头，则在 Ruby 中将其视为常量。

```ruby
Value
value2
company_name

```

这些是有效的变量名。

```ruby
12Val
exx$
first-name

```

这些是无效变量名称的示例。

变量名前面可以带有两个特殊字符`$`和`@`。 它们用于创建特定的变量范围。

变量是区分大小写。 这意味着`price`和`pRice`是两个不同的标识符。

```ruby
#!/usr/bin/ruby

number = 10
numBER = 11

puts number, numBER

```

在脚本中，我们将两个数字值分配给两个标识符。 `number`和`numBER`是两个不同的变量。

```ruby
$ ./case.rb
10
11

```

这是脚本的输出。

## Ruby 常量

常量是值持有者，随着时间的推移仅持有一个值。 具有第一个大写字母的标识符是 Ruby 中的常量。 在编程中，习惯上以大写形式写入常量的所有字符。

与其他语言不同，Ruby 不会将常量强制为随时间推移仅具有一个值。 仅当我们为现有常量分配新值时，解释器才会发出警告。

```ruby
#!/usr/bin/ruby

Name = "Robert"
AGE = 23

Name = "Juliet"

```

在上面的示例中，我们创建了两个常量。 常量之一将在以后重新定义。

```ruby
Name = "Robert"
AGE = 23

```

创建两个常量。 当标识符的名称以大写字母开头时，在 Ruby 中将有一个常量。 按照约定，常量通常用大写字母表示。

```ruby
Name = "Juliet"

```

我们重新定义一个常数。 哪个发出警告。

```ruby
$ ./constants.rb
./constants.rb:6: warning: already initialized constant Name

```

运行示例。

## Ruby 字面量

字面值是类型的特定值的字面值表示。 字面值类型包括布尔值，整数，浮点数，字符串，字符和日期。 从技术上讲，字面值将在编译时分配一个值，而变量将在运行时分配。

```ruby
age = 29
nationality = "Hungarian"

```

在这里，我们为变量分配了两个字面值。 数字 29 和字符串`"Hungarian"`是字面值。

```ruby
#!/usr/bin/ruby

require 'date'

sng = true
name = "James"
job = nil
weight = 68.5
born = Date.parse("November 12, 1986")

puts "His name is #{name}"

if sng == true
    puts "He is single"
else
    puts "He is in a relationship"
end

puts "His job is #{job}"
puts "He weighs #{weight} kilograms"
puts "He was born in #{born}"

```

在上面的示例中，我们有多个字面值。 布尔字面值可以具有值`true`或`false`。 詹姆斯是一个字符串字面值。 `nil`是一个值的缺失。 68.5 是浮点字面值。 最后，1987 年 11 月 12 日是日期字面值。

```ruby
$ ./literals.rb
His name is James
He is single
His job is 
He weighs 68.5 kilograms
He was born in 1986-11-12

```

这是`literals.rb`脚本的输出。

## 红宝石块

Ruby 语句通常被组织成代码块。 可以使用`{ }`字符或`do`和`end`关键字来分隔代码块。

```ruby
#!/usr/bin/ruby

puts [2, -1, -4, 0].delete_if { |x| x < 0 }

[1, 2, 3].each do |e|
    puts e
end

```

在示例中，我们显示了两个代码块。

Ruby 代码的流控制通常使用`if`关键字进行。 关键字后跟一段代码。 在这种情况下，代码块由`then`和`end`关键字定界，其中第一个关键字是可选的。

```ruby
#!/usr/bin/ruby

if true then
    puts "Ruby language"
    puts "Ruby script"
end

```

在上面的示例中，我们有一个简单的代码块。 它有两个语句。 该块由`then`和`end`关键字定界。 `then`关键字可以省略。

## Ruby 标记

标记`$, @`是特殊字符，表示变量的作用域。 `$`用于全局变量，`@`用于实例变量，`@@`用于类变量。

```ruby
$car_name = "Peugeot"
@sea_name = "Black sea"
@@species = "Cat"

```

记号始终放在变量标识符的开头。

## Ruby 运算符

运算符是用于对某个值执行操作的符号。 （answers.com）

```ruby
!    +    -    ~    *    **    /    %
<<    >>    &    |    ^
==    ===    !=    <=>    >=    >
<    <=    =    %=    /=    -=
+=    *=    **=    ..    ...    not
and    or    ?:    &&    || 

```

这是 Ruby 语言中可用的运算符的列表。 我们将在本教程的后面部分讨论运算符。

## Ruby 分隔符

定界符是一个或多个字符的序列，用于指定纯文本或其他数据流中单独的独立区域之间的边界。 （维基百科）

```ruby
(       )       [       ]       {       }      
,       ;       '       "       |       |

```

```ruby
#!/usr/bin/ruby

name = "Jane"
occupation = 'Student'
numbers = [ 2, 3, 5, 3, 6, 2 ]

puts name; puts occupation
puts numbers[2]
numbers.each { |i| puts i }
puts ( 2 + 3 ) * 5

```

在上面的示例中，我们展示了各种 Ruby 分隔符的用法。

```ruby
name = "Jane"
occupation = 'Student'

```

单引号和双引号用于在 Ruby 中定界字符串。

```ruby
numbers = [ 2, 3, 5, 3, 6, 2 ]

```

方括号用于设置数组的边界。 逗号用于分隔数组中的项目。

```ruby
puts name; puts occupation

```

在 Ruby 中，用分号分隔 Ruby 源代码中的两个语句。

```ruby
puts numbers[2]

```

分隔符可以在不同的上下文中使用。 在这里，方括号用于访问数组中的项目。

```ruby
numbers.each { |i| puts i }

```

圆括号用于定义代码块。 管道用于定义一个元素，该元素在每个循环周期中都填充有当前数组项。

```ruby
puts ( 2 + 3 ) * 5

```

括号可用于更改表达式的求值。

## Ruby 关键字

关键字是 Ruby 编程语言中的保留字。 关键字用于在计算机程序中执行特定任务。 例如，将值打印到控制台，执行重复性任务或执行逻辑操作。 程序员不能将关键字用作普通变量。

```ruby
alias    and      BEGIN      begin    break    case
class    def      defined?   do       else     elsif
END      end      ensure     false    for      if
in       module   next       nil      not      or
redo     rescue   retry      return   self     super
then     true     undef      unless   until    when 
while    yield 

```

这是 Ruby 关键字的列表。

这就是 Ruby 的词汇结构。