Ruby入门笔记

Ruby入门笔记

一切皆为对象

“Hello”.length

方法

定义：def开头 end结尾

命名一般采用下划线分隔单词

字符串中可以嵌入表达式

返回值：a）return+返回值 b) 函数最后一行代码的值为返回值（太神奇了）

类

定义：class 开头 end结尾

Initialize是构造方法

@开头的变量是实例变量（一个实例对应一个变量）

to_s 方法可重载

self. 定义类方法（用类名调用，类似类静态方法，不需实例化对象）

@@开头是类变量（类似静态变量）

类的继承

<表示继承

class Popsong < Song

def initialize(name, artist, duration, lyrics)

super(name, artist, duration)

@lyrics=lyrics

end

end

super调用父类同名方法

模块Module

模块是一种集中方法、类和常量的方法

好处：

  1. 模块提供了一个namespace，防止命名冲突
  2. 通过模块能实现混合插入（mixin）功能，混合插入机制实现了多重继承

定义：以module开头，以end结尾

块（block）

一种匿名函数，或称作闭包closure

{puts “hello world”}

或者

do

puts “Hi!”

end

还不太懂

Ruby基本数据类型

数字型

多大整数都可以显示，不会自动转换成浮点型

运算符

+-*/%**

%取模

**幂运算

&|^ 与或非

<<>>[]左移右移取位(从低到高)

abs取绝对值

ceil/floor/round 向下取整、向上取整、四舍五入

odd?/even?/zero? 奇数？偶数？零？ 返回bool型

times/upto/downto/step

# 执行n次block

5.times { puts "+" }           # 打印5个+

# 从1加到5

1.upto(5) { |i| print i, "+" }      # 1+2+..5+

# 从99减到95

99.downto(95) { |i| print i, "+" }     # 99+..95+

# 从50到80，以5为间隔

50.step(80, 5) { |i| print i, "+" }        # 50+55+..80+

字符串

双引号或者单引号

单引号内不执行转义

字符串典型方法

size/length/bytesize/empty?

其中size和length返回字符数

bytesize返回字节数

+/<< 字符串拼接

*  字符串重复

%格式化输出

"%05d" % 123                    # "00123"

"%-5s: %08x" % [ "ID", 123 ]   # "ID   : 123"

功能强大的[]

a = "hello there"

a[1]                     #=> "e"

a[1,3]                          #=> "ell"

a[1..3]                         #=> "ell"

a[-3,2]                         #=> "er"

a[-4..-2]                      #=> "her"

a[12..-1]                     #=> nil

a[-2..-4]                      #=> ""

a[/[aeiou](.)\1/]                 #=> "ell"

a[/[aeiou](.)\1/, 0]   #=> "ell"

a[/[aeiou](.)\1/, 1]   #=> "l"

a[/[aeiou](.)\1/, 2]   #=> nil

a["lo"]                         #=> "lo"

a["bye"]                      #=> nil

很神奇，很多不明白

start_with?/end_with?/include?

# 是否以he开头

"hello world".start_with? "he"       # true

# 是否以ld结尾

"hello world".end_with? "ld"  # true

# 是否包含hi

"hello world".include? "hi"      # false

upcase/downcase/swapcase/capitalize

puts "Hi, Ruby".upcase            # HI, RUBY

puts "Hi, Ruby".downcase       # hi, ruby

puts "Hi, Ruby".swapcase       # hI,rUBY

puts "hii, ruby".capitalize                  # Hi, ruby

encoding/force_encoding/encode

# 查看字符串的编码，若编码不为GBK则应该注意

puts "我爱Ruby".encoding     # ASCII-8BIT

# 强制转化编码，只改变编码标识，并不改变内容

#（当你知道其本来编码的时候非常有用）

"我爱Ruby".force_encoding("GBK")

# 假设某字符串是UTF-8编码的，可以encode为GBK

"我爱Ruby".encode("GBK")

split/scan

# 切割字符串为数组

"1,2,,3,4,,".split(‘,‘) # ["1", "2", "", "3", "4"]

# 扫描字符串为数组（与split相反）

a = "cruel world"

a.scan(/\w+/)                    # ["cruel", "world"]

a.scan(/(..)(..)/)                  # [["cr", "ue"], ["l ", "wo"]]

a.scan(/\w+/) {|w| print "<<#{w}>> " }

# <<cruel>> <<world>>

strip/rstrip/lstrip

# 去除字符串旁边的空白

"    hello    ".lstrip             # "hello   "

"    hello    ".rstrip             # "    hello"

"    hello    ".strip              # "hello"

each_char/each_byte/each_line/

# 遍历字符

"hello".each_char {|c| print c, ‘ ‘ }

# h e l l o

# 遍历字节

"hello".each_byte {|c| print c, ‘ ‘ }

# 104 101 108 108 111

# 遍历每一行

"hello\nworld".each {|s| p s}

#

"hello\n"

"world"

数组

表示

[ 3.14159, "pie", 99 ]      # 中括号

Array.new                           # 相当于 []

%w{ haha xixi hoho }         # %w方式定义字符串数组

Ruby的数组（及其他集合）中成员类型不必一样，这就是传说中的异构

典型方法

+/-/*/&/<<

# +等于concat

[ 1, 2, 3 ] + [ 4, 5 ]    #=> [ 1, 2, 3, 4, 5 ]

# - 即A集合减去B集合中所有的元素

[ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]

[ 1, 2, 3 ] * 3    #=> [ 1, 2, 3, 1, 2, 3, 1, 2, 3 ]

# 两个数组的交集

[ 1, 1, 3, 5 ] & [ 1, 2, 3 ]   #=> [ 1, 3 ]

#  把一个对象push到数组当中

[ 1, 2 ] << "c" << "d" << [ 3, 4 ]

#=> [ 1, 2, "c", "d", [ 3, 4 ] ]

[]

# []的有三种用法

a = [ "a", "b", "c", "d", "e" ]

a[2] +  a[0] + a[1]   #=> "cab"

a[6]           #=> nil

a[1, 2]               #=> [ "b", "c" ]

a[1..3]                #=> [ "b", "c", "d" ]

a[4..7]                #=> [ "e" ]

a[6..10]             #=> nil

a[-3, 3]               #=> [ "c", "d", "e" ]

# special cases

a[5]           #=> nil

a[5, 1]                #=> []

a[5..10]             #=> []

find/find_all

# find到一个即返回，别名detect

(1..100).find {|i|

i % 5 == 0 and i % 7 == 0

}

#=> 35

# find_all找到全部符合条件的对象，别名select

(1..100).find_all {|i|

i % 5 == 0 and i % 7 == 0

}

#=> [35,70]

first/last/join

a = [ "q", "r", "s", "t" ]

# 第一个元素

a.first                          #=> "q"

a.first(2)                     #=> ["q","r"]前两个元素

# 最后一个元素

a.last     #=> "t"

# 把数组变成字符串

[ "a", "b", "c" ].join #=> "abc"

[ "a", "b", "c" ].join("-")   #=> "a-b-c"

inject/collect

# inject理解的难点在于block中的两个参数

# sum是上一次block的返回值，初始化为0或nil

# n是遍历数组的每一个元素

[5,6,7,8,9,10].inject {|sum, n| sum + n }            #=> 45

输出45

遍历

# collect别名map，遍历数组并改变它们的内容后输出

a = [ "a", "b", "c", "d" ]

a.collect {|x| x + "!" }   #=> ["a!", "b!", "c!", "d!"]

each/each_with_index/cycle

# 遍历元素

a = [ "a", "b", "c" ]

a.each {|x| print x, " -- " }遍历元素输出，以—分隔

# 遍历元素并带上下标 第一个参数是数组值，第二个参数是下标

a.each_with_index {|obj, i| print "a[#{i}] : #{obj}" }

# 循环一个数组

a.cycle {|x| puts x }        # print, a, b, c, a, b, c,.. forever.

a.cycle(2) {|x| puts x }    # print, a, b, c, a, b, c.

delete/delete_if/insert/pop/push

# 删除所有的b字符串

a = [ "a", "b", "b", "b", "c" ]

a.delete "b"                        # b

# 删除满足条件的元素

a.delete_if {|x| x >= "b" }                  # ["a"]

# 在某序列前插入对象

a.insert(2, “b1")                         # ["a", "b", "b1"...

# pop和push组合起来可以把一个Array直接当成Stack

a.pop                                    # "c"

a.push "d"

sort/uniq/shuffle/shift

# 自动排序

[ "b", "c", "a" ].sort                   # ["a","b","c"]

# 去重

[ "a", "a", "b", "b", "c" ] .uniq          # ["a", "b", "c"]

# 随机变化 洗牌么~

a = [ 1, 2, 3 ]

a.shuffle                     # [2, 3, 1]

a.shuffle                     # [1, 3, 2]

#shift是神马？

哈希Hash

表示

[]表示数组，{}表示hash 跟perl一样么

{ "foo"=>123, "bar"=>456 }             # 大括号

典型方法

[]/[]=

# 取Hash中的某key的值

h = { "a" => 100, "b" => 200 }

h["a"]                                   #=> 100

h["c"]                                  #=> nil

# 设置Hash的对象

h["a"] = 9

h["c"] = 4

h               #=> {"a"=>9, "b"=>200, "c"=>4}

has_key?/has_value?

# 验证Hash中是否存在某key

h = { "a" => 100, "b" => 200 }

h.has_key?("a")                #=> true

#验证Hash中是否存在某value

h.has_value?(999)   #=> false

each/each_key

# 取Hash中的某key的值

h = { "a" => 100, "b" => 200 }

h.each {|key, value| puts "#{key} is #{value}" }

h.each_key {|key| puts key }

*each若只一个参数，则取出每个键值对

h.each {|key| puts "#{key}" }

delete/delete_if/select

# 删除某个key

h = { "a" => 100, "b" => 200 }

h.delete("a")                      #=> 100

# 只删除满足条件的

h.delete_if {|key, value| key >= "b" }

# 挑选出元素

h = { "a" => 100, "b" => 200, "c" => 300 }

h.select {|k,v| v < 200}              #=> {"a" => 100}

范围Range

表示

.. 相当于[]

…相当于[ ）

1..10                # 包含10

1...10                # 不包含10

‘a‘..‘z‘               # 从a到z的字母

0...anArray.length

典型方法

to_a/begin/end

# 把范围展开

(1..7).to_a                 #=> [1, 2, 3, 4, 5, 6, 7]

# 取头

(1..7).begin                #=> 1

# 取尾

(1..7).end                   #=> 7

===/include?

# ===主要是用在case when语句中，相当于在range中查找某值

# 与include?结果相同

("a".."z").include?("g")  # => true

("a".."z")===("g")  # => true

each

# 把范围展开

(10..15).each do |n|

print n, ‘ ‘

end

# =》 10 11 12 13 14 15

正则表达式Regexp

表示

a = Regexp.new(‘^\s*[a-z]‘)             # /^\s*[a-z]/

b = /^\s*[a-z]/                   # 两个斜杠是最简单的表示法

c = %r{^\s*[a-z]}                         # /^\s*[a-z]/

d = %r<^\s*[a-z]>                      # /^\s*[a-z]/

典型方法

=~、!~、

#确定匹配

/a/ =~ "Fats Waller"                  # true

# match是=~的别名

/a/.match "Fats Waller"           # true

# 否定匹配

/z/ !~ "Fats Waller"          # false

表达式

条件控制if（注意elsif）

if count > 10

puts "Try again"

elsif tries == 3

puts "You lose"

else

puts "Enter a number"

end

条件控制unless

unless  等价于  if not ，意思是： 除非 或 如果不

puts "ok" unless count > 10

真或假

只有false和nil是假，其余的都为真

puts "not execute" if nil

puts "execute" if 1

puts "execute" if 0

puts "not execute" if false

puts "execute" if true

puts "execute" if ""

puts "execute" if Array.new

case…when

其实也就是大家熟悉的switch case，只不过更加高级一点

例如：

case 主角状态
when "昏迷"
   print "你昏迷了.."
when "中毒"
   print "你中毒了.."
when "昏睡"
   print "你昏睡了.."

else

print "未知状态"
end

每个when后面不用再跟break了

通用比较操作符

循环

while表示循环地球人都知道，Ruby里面until也可以用来循环，意思与while相反，直到条件为真，才停止操作

while i <= 60

# ...

end

等价于

until i > 60

# ...

end

转自：http://www.cnblogs.com/lunashang/archive/2012/05/07/2487600.html

时间： 2024-07-31 17:03:43

Ruby入门笔记的相关文章

MySQL入门笔记（一）

MySQL入门笔记(二) 一.数据类型 1. 整型 2. 浮点型 3. 字符型 4. 日期时间型 二.数据库操作 1. 创建库 CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] db_name [DEFAULT] CHARACTER SET [=] charset_name; ??上述代码中DATABASE和SCHEMA完全相同,可任选一个(花括号内的参数为任选其一): ??添加IF NOT EXISTS的作用则是,若新建数据库的名称与已有数据库名称冲突,则产

Django入门笔记【一】

入门笔记翻译整理自:https://docs.djangoproject.com/en/1.8/ *该笔记将使用一个关于投票网络应用(poll application)的例子来阐述Django的用法. 1. 查看Django是否安装及版本 1 $ python -c "import django; print(django.get_version())" 2. 创建一个项目(project) 通过cd方式进入自创目录,然后运行: 1 $ django-admin startprojec

嵌入式OS入门笔记-以RTX为案例：十.Keil的RTX调试支持

嵌入式OS入门笔记-以RTX为案例:十.Keil的RTX调试支持 调试(debug)是软件开发的一个重要环节,对于嵌入式开发而言这个环节其实比较依赖一些硬件资源(硬件debugger)的支持.传统的嵌入式系统的调试比较依赖断点(breakpoint)和单步调试(single step through).而 ARM cortex-M 系列的芯片其实有很强的CoreSight片上调试支持,实际上就是一个小的调试硬件,作为ARM的标准,内嵌在ARM的芯片里.在ARM自家的调试器ULINK-pro等的帮

Ajax 入门笔记

AJAX =Asynchronous Javascript + XML,是一种在无需重新加载整个网页的情况下,能够更新部分网页的技术. 通过在后台与服务器进行少量数据交换,AJAX 可以使网页实现异步更新.这意味着可以在不重新加载整个网页的情况下,对网页的某部分进行更新. XMLHttpRequest 是 AJAX 的基础.XMLHttpRequest 用于在后台与服务器交换数据.这意味着可以在不重新加载整个网页的情况下,对网页的某部分进行更新. 1:创建 XMLHttpRequest 对象 为

iBatis 入门笔记

iBatis简介 iBatis是一个"半自动"的轻量级O/R Mapping框架. O/R Mapping是指对象与数据库之间的映射,而iBatis就是这样一个映射器,映射器的主要作用是在对象和数据库之间搬运数据,同时保证对象.数据库和映射器之间相互独立. 通过O/R Mapping你将不用再面对那一堆令人厌恶的JDBC代码,为一堆打开连接.关闭连接的代码而眼花头昏. 何为"半自动"?    这里的半自动是与Hibernate这样的O/R Mapping方案对比得出

Hive入门笔记-----架构以及应用介绍

Hive这个框架在Hadoop的生态体系结构中占有及其重要的地位,在实际的业务当中用的也非常多,可以说Hadoop之所以这么流行在很大程度上是因为Hive的存在.那么Hive究竟是什么,为什么在Hadoop家族中占有这么重要的地位,本篇文章将围绕Hive的体系结构(架构).Hive的操作.Hive与Hbase的区别等对Hive进行全方面的阐述. 在此之前,先给大家介绍一个业务场景,让大家感受一下为什么Hive如此的受欢迎: 业务描述:统计业务表consumer.txt中北京的客户有多少位?下面是

JAVA数据库编程(JDBC技术)-入门笔记

本菜鸟才介入Java,我现在不急着去看那些基本的语法或者一些Java里面的版本的特征或者是一些晋级的知识,因为有一点.Net的OOP编程思想,所以对于Java的这些语法以及什么的在用到的时候在去发现学习一下.我现在很迫不及待用JAVA想来实现以下对数据库的增删改查.想实现就来看Java是怎么操作数据库的,回想下.Net里你可能会配置web.Config,或者你去写一些DBhelper类然后调用里面的自己定义的一些增删改查的方法,更或者你去配一些数据控件等等往往发现操作基本都是一体化的简单.现在面

Django入门笔记【三】

入门笔记翻译整理自:https://docs.djangoproject.com/en/1.8/ *该笔记将使用一个关于投票网络应用(poll application)的例子来阐述Django的用法. Public interface - views. 1. 定义 视图(View)是Django应用中用于实现某一特定功能的Web页面.比如,一个博客可以有博客展示页面,博客创建页面,评论页面. 2. 视图示例 写入代码 1 #polls/views.py 2 3 from django.http

Ruby学习笔记

Ruby学习笔记 Ruby语言中,以对象为基本单位,可以说所有的元素都是对象.按照之前对于面向对象程序的理解,对象是指包含了特定属性和方法集合的一组程序.对象由类来定义,具体的表现为对象实例.也就是说,对象是类的实例化[2]. Ruby语言的基础元素 对象:数值对象.字符串对象.正则表达式对象.时间对象.文件对象.目录对象.数组.哈希.例外对象等 数值对象   由于Ruby中一切数据都是对象,所以我们处理的数字实际上也是对象. a = 10,这样一个简单的赋值语句,实际上应当理解为 a = Nu