【学习笔记】ruby基础学习

admin
admin
admin
142269
文章
117
评论
2022年12月3日16:28:57评论41 views字数 8312阅读27分42秒阅读模式

[huayang]

因为macOS自带ruby这里就不说怎么安装了

因为是临阵磨枪只有半天的时间学习就不讲很详细了

Ruby 语法

新建个文件123.rb，写入

puts "hello word"

在命令使用ruby打印出来就行了

ruby 123.rb
【学习笔记】ruby基础学习

Ruby 中的 Here Document

建立多行字符串

print <<EOF
    这是第一种方式创建here document 。
    多行字符串。
EOF

print <<"EOF";                # 与上面相同
    这是第二种方式创建here document 。
    多行字符串。
EOF

print <<`EOC`                 # 执行命令
	echo hi there
	echo lo there
EOC

print <<"foo", <<"bar"	      # 您可以把它们进行堆叠
	I said foo.
foo
	I said bar.
bar
【学习笔记】ruby基础学习

Ruby BEGIN 语句

声明 code 会在程序运行之前被调用

puts "这是主 Ruby 程序"
 
BEGIN {
   puts "初始化 Ruby 程序"
}
【学习笔记】ruby基础学习

Ruby END 语句

声明 code 会在程序的结尾被调用。

puts "这是主 Ruby 程序"
 
END {
   puts "停止 Ruby 程序"
}
BEGIN {
   puts "初始化 Ruby 程序"
}
【学习笔记】ruby基础学习

Ruby 数据类型

您可以使用序列 #{ expr } 替换任意 Ruby 表达式的值为一个字符串。在这里，expr 可以是任意的 Ruby 表达式。

#!/usr/bin/ruby -w
 
puts "相乘 : #{24*60*60}";

这将产生以下结果：

相乘 : 86400

Ruby 类和对象

在 Ruby 中定义类

在 Ruby 中，类总是以关键字 class 开始，后跟类的名称。类名的首字母应该大写

class Customer
end

您可以使用关键字 end 终止一个类。类 中的所有数据成员都是介于类定义和 end 关键字之间。

Ruby 类中的变量

Ruby 提供了四种类型的变量：

  • 局部变量：局部变量是在方法中定义的变量。局部变量在方法外是不可用的。在后续的章节中，您将看到有关方法的更多细节。局部变量以小写字母或 _ 开始。
  • 实例变量：实例变量可以跨任何特定的实例或对象中的方法使用。这意味着，实例变量可以从对象到对象的改变。实例变量在变量名之前放置符号（@）。
  • 类变量：类变量可以跨不同的对象使用。类变量属于类，且是类的一个属性。类变量在变量名之前放置符号（@@）。
  • 全局变量：类变量不能跨类使用。如果您想要有一个可以跨类使用的变量，您需要定义全局变量。全局变量总是以美元符号（$）开始。

使用类变量 @@no_of_customers，您可以判断被创建的对象数量，这样可以确定客户数量。

class Customer
   @@no_of_customers=0
end

在 Ruby 中使用 new 方法创建对象

cust1 = Customer. new
cust2 = Customer. new

在这里，cust1 和 cust2 是两个对象的名称。对象名称后跟着等号（=），等号后跟着类名，然后是点运算符和关键字 new。

下面的实例将创建类 Sample 的一个对象，并调用 hello 方法：

class Sample
   def hello
      puts "Hello Ruby!"
   end
end
 
# 使用上面的类来创建对象
object = Sample. new
object.hello

这将会产生下面的结果：

Hello Ruby!

Ruby 变量

Ruby 支持五种类型的变量。

  • 一般小写字母、下划线开头：变量（Variable）。
  • $开头：全局变量（Global variable）。
  • @开头：实例变量（Instance variable）。
  • @@开头：类变量（Class variable）类变量被共享在整个继承链中
  • 大写字母开头：常数（Constant）。

Ruby 全局变量

全局变量以 $ 开头

用法：


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$global_variable = 10
class Class1
  def print_global
      puts "全局变量在 Class1 中输出为 #$global_variable"
  end
end
class Class2
  def print_global
      puts "全局变量在 Class2 中输出为 #$global_variable"
  end
end
 
class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

在这里，$global_variable 是全局变量。这将产生以下结果：

注意：在 Ruby 中，您可以通过在变量或常量前面放置 # 字符，来访问任何变量或常量的值。

全局变量在 Class1 中输出为 10
全局变量在 Class2 中输出为 10

Ruby 实例变量

实例变量以 @ 开头

用法：


#!/usr/bin/ruby
 
class Customer
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
end
 
# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")
 
# 调用方法
cust1.display_details()
cust2.display_details()

结果：

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Ruby 类变量

类变量以 @@ 开头，且必须初始化后才能在方法定义中使用


#!/usr/bin/ruby
 
class Customer
   @@no_of_customers=0
   def initialize(id, name, addr)
      @cust_id=id
      @cust_name=name
      @cust_addr=addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
    end
    def total_no_of_customers()
       @@no_of_customers += 1
       puts "Total number of customers: #@@no_of_customers"
    end
end
 
# 创建对象
cust1=Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2=Customer.new("2", "Poul", "New Empire road, Khandala")
 
# 调用方法
cust1.total_no_of_customers()
cust2.total_no_of_customers()

结果

Total number of customers: 1
Total number of customers: 2

Ruby 局部变量

局部变量以小写字母或下划线 _ 开头

局部变量的作用域从 class、module、def 或 do 到相对应的结尾或者从左大括号到右大括号 {}。

Ruby 常量

常量以大写字母开头

定义在类或模块内的常量可以从类或模块的内部访问，定义在类或模块外的常量可以被全局访问。

常量不能定义在方法内。引用一个未初始化的常量会产生错误。对已经初始化的常量赋值会产生警告

Ruby 伪变量

  • self: 当前方法的接收器对象。
  • true: 代表 true 的值。
  • false: 代表 false 的值。
  • nil: 代表 undefined 的值。
  • __FILE__: 当前源文件的名称。
  • __LINE__: 当前行在源文件中的编号。

Ruby 判断

支持elsif

Ruby if 修饰符

if修饰词组表示当 if 右边之条件成立时才执行 if 左边的式子。即如果 conditional 为真，则执行 code。

#!/usr/bin/ruby
 
$debug=1
print "debug\n" if $debug

以上实例输出结果：

debug

Ruby unless 语句

如果 conditional 为假，则执行 code。

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$var =  1
print "1 -- 这一行输出\n" if $var
print "2 -- 这一行不输出\n" unless $var
 
$var = false
print "3 -- 这一行输出\n" unless $var

以上实例输出结果：

1 -- 这一行输出
3 -- 这一行输出

Ruby case 语句

case先对一个 expression 进行匹配判断，然后根据匹配结果进行分支选择。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$age =  5
case $age
when 0 .. 2
    puts "婴儿"
when 3 .. 6
    puts "小孩"
when 7 .. 12
    puts "child"
when 13 .. 18
    puts "少年"
else
    puts "其他年龄段的"
end

以上实例输出结果为：

小孩

Ruby 循环

Ruby while 语句

语法中 do 或 : 可以省略不写。但若要在一行内写出 while 式，则必须以 do 或 : 隔开条件式或程式区块。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$i = 0
$num = 5
 
while $i < $num  do
   puts("在循环语句中 i = #$i" )
   $i +=1
end

以上实例输出结果为：

在循环语句中 i = 0
在循环语句中 i = 1
在循环语句中 i = 2
在循环语句中 i = 3
在循环语句中 i = 4

Ruby while 修饰符

当 conditional 为真时，执行 code。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$i = 0
$num = 5
begin
   puts("在循环语句中 i = #$i" )
   $i +=1
end while $i < $num

以上实例输出结果为：

在循环语句中 i = 0
在循环语句中 i = 1
在循环语句中 i = 2
在循环语句中 i = 3
在循环语句中 i = 4

Ruby until 语句

当 conditional 为假时，执行 code。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$i = 0
$num = 5
 
until $i > $num  do
   puts("在循环语句中 i = #$i" )
   $i +=1;
end

以上实例输出结果为：

在循环语句中 i = 0
在循环语句中 i = 1
在循环语句中 i = 2
在循环语句中 i = 3
在循环语句中 i = 4
在循环语句中 i = 5

Ruby until 修饰符

当 conditional 为 false 时，执行 code。

如果 until 修饰符跟在一个没有 rescue 或 ensure 子句的 begin 语句后面，code 会在 conditional 判断之前执行一次。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
$i = 0
$num = 5
begin
   puts("在循环语句中 i = #$i" )
   $i +=1;
end until $i > $num

以上实例输出结果为：

在循环语句中 i = 0
在循环语句中 i = 1
在循环语句中 i = 2
在循环语句中 i = 3
在循环语句中 i = 4
在循环语句中 i = 5

Ruby for 语句

先计算表达式得到一个对象，然后针对 expression 中的每个元素分别执行一次 code。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
for i in 0..5
   puts "局部变量的值为 #{i}"
end

在这里，我们已经定义了范围 0..5。语句 for i in 0..5 允许 i 的值从 0 到 5（包含 5）。

以上实例输出结果为：

局部变量的值为 0
局部变量的值为 1
局部变量的值为 2
局部变量的值为 3
局部变量的值为 4
局部变量的值为 5

Ruby break 语句

终止最内部的循环。如果在块内调用，则终止相关块的方法（方法返回 nil）。

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
for i in 0..5
   if i > 2 then
      break
   end
   puts "局部变量的值为 #{i}"
end

以上实例输出结果为：

局部变量的值为 0
局部变量的值为 1
局部变量的值为 2

Ruby next 语句

跳到循环的下一个迭代。如果在块内调用，则终止块的执行（yield 表达式返回 nil）。

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
for i in 0..5
   if i < 2 then
      next
   end
   puts "局部变量的值为 #{i}"
end

以上实例输出结果为：

局部变量的值为 2
局部变量的值为 3
局部变量的值为 4
局部变量的值为 5

Ruby redo 语句

重新开始最内部循环的该次迭代，不检查循环条件。如果在块内调用，则重新开始 yield 或 call。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
for i in 0..5
   if i < 2 then
      puts "局部变量的值为 #{i}"
      redo
   end
end

这将产生以下结果，并会进入一个无限循环：

局部变量的值为 0
局部变量的值为 0
............................

Ruby retry 语句

如果 retry 出现在 begin 表达式的 rescue 子句中，则从 begin 主体的开头重新开始。


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
for i in 1..5
   retry if  i > 2
   puts "局部变量的值为 #{i}"
end

这将产生以下结果，并会进入一个无限循环：

局部变量的值为 1
局部变量的值为 2
局部变量的值为 1
局部变量的值为 2
局部变量的值为 1
局部变量的值为 2
............................

Ruby 方法


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
def test(a1="Ruby", a2="Perl")
   puts "编程语言为 #{a1}"
   puts "编程语言为 #{a2}"
end
test "C", "C++"
test

以上实例运行输出结果为：

编程语言为 C
编程语言为 C++
编程语言为 Ruby
编程语言为 Perl

Ruby return 语句


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
def test
   i = 100
   j = 200
   k = 300
return i, j, k
end
var = test
puts var

以上实例运行输出结果为：

100
200
300

可变数量的参数

假设您声明了一个带有两个参数的方法，当您调用该方法时，您同时还需要传递两个参数。

但是，Ruby 允许您声明参数数量可变的方法。让我们看看下面的实例：


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
def sample (*test)
   puts "参数个数为 #{test.length}"
   for i in 0...test.length
      puts "参数值为 #{test[i]}"
   end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"

在这段代码中，您已经声明了一个方法 sample，接受一个参数 test。但是，这个参数是一个变量参数。这意味着参数可以带有不同数量的变量。以上实例运行输出结果为：

参数个数为 3
参数值为 Zara
参数值为 6
参数值为 F
参数个数为 4
参数值为 Mac
参数值为 36
参数值为 M
参数值为 MCA

类方法

当方法定义在类的外部，方法默认标记为 private。另一方面，如果方法定义在类中的，则默认标记为 public。

我们已经知道方法 return_date 是如何声明的。它是通过在类名后跟着一个点号，点号后跟着方法名来声明的。您可以直接访问类方法，如下所示： 

Accounts.return_date

如需访问该方法，您不需要创建类 Accounts 的对象。

Ruby alias 语句

这个语句用于为方法或全局变量起别名。别名不能在方法主体内定义。即使方法被重写，方法的别名也保持方法的当前定义。

alias foo bar
alias $MATCH $&

在这里，我们已经为 bar 定义了别名为 foo，为 $& 定义了别名为 $MATCH。

Ruby undef 语句

这个语句用于取消方法定义。undef 不能出现在方法主体内。

下面的实例取消名为 bar的方法定义： undef bar

Ruby 块

  • 块由大量的代码组成。
  • 您需要给块取个名称。
  • 块中的代码总是包含在大括号 {} 内。
  • 块总是从与其具有相同名称的函数调用。这意味着如果您的块名称为 test，那么您要使用函数 test 来调用这个块。
  • 您可以使用 yield 语句来调用块。

yield 语句


#!/usr/bin/ruby
# -*- coding: UTF-8 -*-
 
def test
   puts "在 test 方法内"
   yield
   puts "你又回到了 test 方法内"
   yield
end
test {puts "你在块内"}

以上实例运行结果为：

在 test 方法内
你在块内
你又回到了 test 方法内
你在块内

现在，看下面的语句：

 test {|i| puts "你在块 #{i} 内"}

在这里，值 5 会在变量 i 中收到。现在，观察下面的 puts 语句：

 puts "你在块 #{i} 内"

这个 puts 语句的输出是： 你在块5 内

如果您想要传递多个参数，那么 yield 语句如下所示：

 yield a, b

此时，块如下所示： 

test {|a, b| statement}

参数使用逗号分隔。

块和方法

您已经看到块和方法之间是如何相互关联的。您通常使用 yield 语句从与其具有相同名称的方法调用块。

但是如果方法的最后一个参数前带有 &，那么您可以向该方法传递一个块，且这个块可被赋给最后一个参数。如果 * 和 & 同时出现在参数列表中，& 应放在后面


#!/usr/bin/ruby
 
def test(&block)
   block.call
end
test { puts "Hello World!"}

BEGIN 和 END 块

每个 Ruby 源文件可以声明当文件被加载时要运行的代码块（BEGIN 块），以及程序完成执行后要运行的代码块（END 块）。


#!/usr/bin/ruby
 
BEGIN { 
  # BEGIN 代码块
  puts "BEGIN 代码块"
} 
 
END { 
  # END 代码块
  puts "END 代码块"
}
  # MAIN 代码块
puts "MAIN 代码块"

一个程序可以包含多个 BEGIN 和 END 块。BEGIN 块按照它们出现的顺序执行。END 块按照它们出现的相反顺序执行。当执行时，上面的程序输出以下结果：

BEGIN 代码块
MAIN 代码块
END 代码块

Ruby 模块（Module）

模块（Module）是一种把方法、类和常量组合在一起的方式。模块（Module）为您提供了两大好处。

  • 模块提供了一个命名空间和避免名字冲突。
  • 模块实现了 mixin 装置。

模块（Module）定义了一个命名空间，相当于一个沙盒，在里边您的方法和常量不会与其他地方的方法常量冲突。

模块类似与类，但有以下不同：

  • 模块不能实例化
  • 模块没有子类
  • 模块只能被另一个模块定义

Ruby require 语句

如果一个第三方的程序想要使用任何已定义的模块，则可以简单地使用 Ruby require 语句来加载模块文件：

require filename

Ruby include 语句

您可以在类中嵌入模块。为了在类中嵌入模块，您可以在类中使用 include 语句：

如果模块是定义在一个单独的文件中，那么在嵌入模块之前就需要使用 require 语句引用该文件。

include modulename

Ruby 字符串（String）

Ruby 字符串分为单引号字符串（’）和双引号字符串（”），区别在于双引号字符串能够支持更多的转义字符。

Ruby 数组（Array）

创建数组

有多种方式创建或初始化数组。一种方式是通过 new 类方法： 

names = Array.new

您可以在创建数组的同时设置数组的大小： 

names = Array.new(20)

#!/usr/bin/ruby
 
names = Array.new(4, "mac")
 
puts "#{names}"

以上实例运行输出结果为：

["mac", "mac", "mac", "mac"]

数组内建方法

我们需要有一个 Array 对象的实例来调用 Array 方法。下面是创建 Array 对象实例的方式：


#!/usr/bin/ruby
 
digits = Array(0..9)
 
num = digits.at(6)
 
puts "#{num}"

以上实例运行输出结果为：6

[/huayang]

FROM：浅浅淡淡[hellohy]

免责声明:文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由读者承担全部法律及连带责任，本站不承担任何法律及连带责任；如有问题可邮件联系(建议使用企业邮箱或有效邮箱,避免邮件被拦截，联系方式见首页)，望知悉。
  • 左青龙
  • 微信扫一扫
  • weinxin
  • 右白虎
  • 微信扫一扫
  • weinxin
admin
  • 本文由 发表于 2022年12月3日16:28:57
  • 转载请保留本文链接(CN-SEC中文网:感谢原作者辛苦付出)：
                   【学习笔记】ruby基础学习https://cn-sec.com/archives/1442845.html
                  免责声明:文章中涉及的程序(方法)可能带有攻击性，仅供安全研究与教学之用，读者将其信息做其他用途，由读者承担全部法律及连带责任，本站不承担任何法律及连带责任；如有问题可邮件联系(建议使用企业邮箱或有效邮箱,避免邮件被拦截，联系方式见首页)，望知悉.

发表评论

匿名网友 填写信息