Ruby知识总结-一般变量+操作符+if+数组和哈希

ruby入门掌握其实很简单，下面对我司主要使用的部分入门做一个简单的归纳总结：

本文的文章结构:

1、变量

2、操作符

3、if_elseend 、unless

4、数组（Array）

5、哈希（Hash）

6、循环（each do|变量|）

                                                                                                                                                                             1、变量

变量分为：整数型（int）；浮点型（float）；布尔型（bool）；字符串型（string）

int型：1,2,3

float型：1.2

bool型：true/ false

string型："abc"

不同类型间的转换：

.to_f :转为浮点型

.to_s:转为字符串型

例如

p 123.to_s

=>"123"

变量分为：全局变量（$），局部变量和类变量（@@），它们的作用范围由大到小排列

                                                                                                                                                                                  2、对于变量而言含有的操作符

对于int和float，为倍数相乘，但是对于字符串，即为重复几次，例如：

str1 = "a"

p str13

=>"aaa"

对于字符串，+也有特殊意义，为字符串间的简单拼接

②|| 或（一真全真）、&&且（一假全假） 、！非 （特别注意 nil为假）

③三目操作符：

口？口：口 问号前面的是布尔型的判断，true的话执行第二个方块的语句，false的话执行第三个方块的语句

例如：

value =(nil ? 0 : 1)

p value

=>1

⑤== 表示判断，两侧是否相等，相等为true，不相等为false

3、if语句的基本知识

if _elseend 不要丢掉end哦！！！

例如：

num = 100

if num <100

p "数字小于100"

elsif num >100 #elsif 后面还是可以加判断条件的

p "数字大于100"

else #else 就是指其他的，后面不能再加判断条件

p "数字等于100"

end

=> "数字等于100"

if还能这样用：

num = 100

p "数字等于100" if num =100 #if后面的判断为真后，再去执行前面的语句

=> "数字等于100"

与if一样同为判断的还有一个方式：unless 用法就是unless后面的条件不成立，才会执行下一条语句，否则就跳到下一个判断，因为逻辑比较绕，所以一般多于1个判断的时候，就直接用if好了。

例如：

num = 50

p "数字小于100" unless num>100

                                                                                                                                                                                4、数组的基础知识及方法

数组（Array）

创建一个新的数组可以这样：arr = Array.new ,或者直接定义一个空的数组 ：arr = [ ]，这个中括号就是数组的标志。

①最重要的知识点就是 索引，就是数组所在的位置，它是有序的，在物理磁盘按照顺序存储，它跟python一样，都是从0开始计数

arr = [1,2,3,4,5]

p arr[0]

=>"1" #拿出来一个元素，不是数组哦

p arr[-1] #取倒数第一个元素

=>"5"

②数组内的操作符：

加号（+）单纯的将两个数组连接，不做去重；

减号（-）用前一个数组减去后一个数组里的东西，只对被减数做修改；

取并集“|”（可以看到，比对于变量的操作，少了一个竖杠）；

取交集“&”（可以看到，比对于变量的操作，少了一个&）；

数组间的拼接： “<<” 这个字符的意思是拼接，并不是将两个数组简单的拼接起来，这跟字符串中的用法不一样，它是把箭头后面的元素作为一个新的元素加到左边的数组里面去。

例如：

数组1 = ['1','2','3']

数组2 = ['1','3','4']

p 数组1 - 数组2

=>["2"]

p 数组1 + 数组2

=>["1", "2", "3", "1", "3", "4"]

p 数组1 | 数组2 #数组里的取并集，是一个竖杠"|",而变量里面是"||"

=>["1", "2", "3", "4"]

p 数组1 & 数组2 #你看，数组里的取交集，是一个&

=>["1", "3"]

例如：

p ['1','2','3']<<["aaa"]

=> ['1','2','3',['aaa']]

方法:

.empty? #判断是否为空,输出结果为布尔型

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

p a.empty?

=>false

.include?("变量") #判断是否含有某元素,输出结果为布尔型

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

p a.include？("c")

=>true

.index("元素") #寻找某个元素的索引

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

p a.index("c")

=>2

.size #查询数组的长度

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

p a.size

=>3

                                                                                                                                                                            5、哈希的基础知识和方法

创建一个新的哈希可以这样：hash = Hash.new ,或者直接定义一个空的哈希 ：hash = {}，这个中括号就是哈希的标志。

哈希是以键值对的形式存在的，表达方式有2种，我司常用的是{“a”=>“b”}形式，一个key可对应多个value，它们是在物理地址是不连续的，所以没有索引的说法，而是通过key去查找对应的value，效率会高于数组。这个哈希其实就相当于python里的字典。

所以定位哈希的时候，是用key去定位的，hash[key ],例如：

hash= {"a"=>"b","c"=>"d"}

p hash["c"]

=>"d"

下面简列一下hash的方法：

empty? #判断是否为空,输出结果为布尔型

a = {}

p a.empty?

=>true

.include?("value") #判断是否含有某元素,输出结果为布尔型

hash= {"a"=>"b","c"=>"d"}

p hash.include？("f")

=>true

.size #查询哈希的个数，记住，是以键（keys）为标准

hash= {"a"=>"b","c"=>"d"}

p hash.size

p=>2

.keys #这个方法是将哈希里的所有键取出来，组成1个数组

hash= {"a"=>"b","c"=>"d"}

p hash.keys

=>["a", "c"]

.value #这个方法是将值取出来，组成一个数组

hash= {"a"=>"b","c"=>"d"}

p hash.values

=>["b", "d"]

另外，哈希里面的value，不一定是字符串，还有可能是数组，例如：

hash= {"a"=>["b","e"],"c"=>"d"}，这样都是允许的，如果我想定位到元素“e”,很简单，如下操作就可以：

p hash["a"][1]

=>"e"

6、循环

循环首先简单介绍三种方式：请记住都有end作为结尾哦！~并且这里面的变量并没有用""引号给引起来

①.each do |命名变量|

...

end

②.each_with_index do |元素,索引| #这里命名变量，是2个变量。应用于数组，将数组的元素拿出来，并将其位置表示出来.特别需要注意的是，这里面的变量并没有用""引号给引起来

p 元素

p 索引+1

end

③0.upto (n) do |命名变量| #这个方法可以用来将数组（array）进行循环,且n>=0,当然，那个0也不是固定值，看你需要定位到哪个元素。而且既然有upto,当然也就有downto，这个不多说。记得凡是方法，都有"."；中间都有空格！！

...

end

现在举几个例子熟悉一下：

对于数组的循环，取出里面的所有元素，举例如下：

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

arr.each do |元素|

p 元素

end

=>"a"

"b"

"c"

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

arr.each_with_index do |元素，索引|

p 元素

p 索引+1

end

=>"a"

1

"b"

2

"c"

3

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

0.upto (2) do |索引|

p arr[索引]

end

=>"a"

"b"

"c"

对于哈希的循环，一种就是将每一个的key-value组成一个数组，并将其输出。例如：

hash= {"a"=>["b","e"],"c"=>"d","dada"=>[1,2,3]}

hash.each do |内容|

p 内容

end

=>["a", ["b", "e"]]

["c", "d"]

["dada", [1, 2, 3]]

如果针对上面的哈希，我想要输出形成的数组的特定值，比如第一个元素：

hash= {"a"=>["b","e"],"c"=>"d","dada"=>[1,2,3]}

hash.each do |内容|

p 内容[0]

end

=>"a"

"c"

"dada"

hash= {"a"=>["b","e"],"c"=>"d","dada"=>[1,2,3]}

hash.each do |内容|

p 内容[1][0]

end

=>["b", "e"]

"d"

[1, 2, 3]

hash= {"a"=>["b","e"],"c"=>"d","dada"=>[1,2,3]}

hash.each do |内容|

p 内容[1][1]

end

=>"e"

nil #由此可以看出，当索引超出了数组的长度时，不会报错，而是nil

2

另一种就是输出键“\n”值，但不组成数组，用的是.each do|键，值|，例如：

hash= {"a"=>["b","e"],"c"=>"d","dada"=>[1,2,3]}

hash.each do |键，值|

=>p 键

p 值

end

相信通过上面的简要介绍，对于ruby语法的基础是有了，继续加油更新哦~~