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

遍历

# 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

Ruby入门笔记的更多相关文章

  1. Ruby小白入门笔记之 <Gemfile 文件>

    因为初学Ruby,四处查资料无果,才来的贴出亲自试过的操作,覆盖整个个人入门笔记博客中,故所有的操作,都以最明了的方式阐述,当你创建完一个新的Rails应用后,你发现JAVA中我们可以编写maven聚 ...

  2. 每天成长一点---WEB前端学习入门笔记

    WEB前端学习入门笔记 从今天开始,本人就要学习WEB前端了. 经过老师的建议,说到他每天都会记录下来新的知识点,每天都是在围绕着这些问题来度过,很有必要每天抽出半个小时来写一个知识总结,及时对一天工 ...

  3. ES6入门笔记

    ES6入门笔记 02 Let&Const.md 增加了块级作用域. 常量 避免了变量提升 03 变量的解构赋值.md var [a, b, c] = [1, 2, 3]; var [[a,d] ...

  4. [Java入门笔记] 面向对象编程基础(二):方法详解

    什么是方法? 简介 在上一篇的blog中,我们知道了方法是类中的一个组成部分,是类或对象的行为特征的抽象. 无论是从语法和功能上来看,方法都有点类似与函数.但是,方法与传统的函数还是有着不同之处: 在 ...

  5. React.js入门笔记

    # React.js入门笔记 核心提示 这是本人学习react.js的第一篇入门笔记,估计也会是该系列涵盖内容最多的笔记,主要内容来自英文官方文档的快速上手部分和阮一峰博客教程.当然,还有我自己尝试的 ...

  6. redis入门笔记(2)

    redis入门笔记(2) 上篇文章介绍了redis的基本情况和支持的数据类型,本篇文章将介绍redis持久化.主从复制.简单的事务支持及发布订阅功能. 持久化 •redis是一个支持持久化的内存数据库 ...

  7. redis入门笔记(1)

    redis入门笔记(1) 1. Redis 简介 •Redis是一款开源的.高性能的键-值存储(key-value store).它常被称作是一款数据结构服务器(data structure serv ...

  8. OpenGLES入门笔记四

    原文参考地址:http://www.cnblogs.com/zilongshanren/archive/2011/08/08/2131019.html 一.编译Vertex Shaders和Fragm ...

  9. OpenGLES入门笔记三

    在入门笔记一中比较详细的介绍了顶点着色器和片面着色器. 在入门笔记二中讲解了简单的创建OpenGL场景流程的实现,但是如果在场景中渲染任何一种几何图形,还是需要入门笔记一中的知识:Vertex Sha ...

随机推荐

  1. dwz关闭当前dialog

    首先,前台代码如下: <form method="post" class="pageForm required-validate" onsubmit=&q ...

  2. MapReduce开发技巧

    数据类型的选择 自定义数据类型 参考:Hadoop提交作业自定义排序和分组 MapWritable/SortedMapWritable Hadoop中可传输的Map集合,和Java中的Map用法差不多 ...

  3. [Functional Programming] Working with two functors(Applicative Functors)-- Part1 --.ap

    What is applicative functor: the ability to apply functors to each other. For example we have tow fu ...

  4. Dreamweaver界面主要菜单功能介绍

    启动界面有四个功能:主要使用新建HTML,其中HTML有很多版本,由于国内IE6.0占据了将近百分之七十的比例,所以最新的HTML1.1对他支持的不好,我们主要使用XHTML 1.0 Transiti ...

  5. PL/SQL 之 基础

    PL/SQL(Procedural Language extensions to SQL)是Oracle 对标准 SQL 语言的过程化扩展,是专门用于各种环境下对 Oracle 数据库进行访问和开发的 ...

  6. 从主机系统向虚拟机系统里面copy 文件

    从主机系统向虚拟机系统里面copy 文件: 一:请确保你的虚拟机里面安装了 VMTools 1:安装VMTools 2: 进入虚拟机系统里面,如果没有自动运行 VMtool安装程序,请打开我的电脑,手 ...

  7. Linux下全局符号覆盖问题

    在windows上,默认情况下,动态库中的符号都是对外隐藏的,除非你显示的指出要导出哪些符号,否则外界是看不到的.但是linux下情况刚好相反,对静态变量和全局变量,linux下so里面的符号对外可见 ...

  8. Spring整合JDBC实现简单的增删改

    Spring整合JDBC实现简单的增删改: 1.导入Spring的包和数据库的驱动包: 2.选择一个数据源(dbcp和C3P0) 3.导入数据源的包(这里我们使用dbcp) <span styl ...

  9. 算法笔记_139:二分图的最大权匹配(Java)

    目录 1 问题描述 2 解决方案   1 问题描述 何为二分图的最大权匹配问题? 最大权二分匹配问题就是给二分图的每条边一个权值,选择若干不相交的边,得到的总权值最大. 2 解决方案 对于此问题的讲解 ...

  10. Python 倒叙切片

    倒序切片 对于list,既然Python支持L[-1]取倒数第一个元素,那么它同样支持倒数切片,试试: >>> L = ['Adam', 'Lisa', 'Bart', 'Paul' ...