【学习笔记】ruby基础学习

[huayang]

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

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

Ruby 语法

新建个文件123.rb,写入

puts "hello word"

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

ruby 123.rb

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 BEGIN 语句

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

puts "这是主 Ruby 程序"
 
BEGIN {
   puts "初始化 Ruby 程序"
}

Ruby END 语句

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

puts "这是主 Ruby 程序"
 
END {
   puts "停止 Ruby 程序"
}
BEGIN {
   puts "初始化 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 语句

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


#!/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]

==>转载请注明来源哦<==
暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇