Ruby(3):基本语法中

字符串分割成数组:
可以使用先scan再join的方法,当然其实有更好的 split方法,专门用来分割字符串

1 # 在Ruby中,如果不使用inspect,直接使用puts输出数组,那么每个元素会占用一行输出
2 irb(main):001:0> puts "Short sentence.Another.No more".split(/\./)
3 Short sentence
4 Another
5 No more
6 => nil
7 irb(main):002:0> puts "Short sentence.Another.No more".split(/\./).inspect
8 ["Short sentence", "Another", "No more"]
9 => nil

Split

数组迭代:
可以直接使用each方法来对每个元素进行遍历输出:

 1 irb(main):005:0> a = [1, 2, 3, 4]
 2 => [1, 2, 3, 4]
 3 # collection对每一个元素进行迭代,返回的结果作为新的数组结果
 4 irb(main):009:0> b = a.collect do |element| element*2 end
 5 => [2, 4, 6, 8]
 6 irb(main):010:0> b
 7 => [2, 4, 6, 8]
 8 # 如果不对元素进行任何操作,则返回的为同样个数每个元素为nil的数组
 9 irb(main):011:0> b = a.collect do |element| puts element end
10 1
11 2
12 3
13 4
14 => [nil, nil, nil, nil]
15 irb(main):012:0> b
16 => [nil, nil, nil, nil]
17 # each永远返回原来的数组,没法改变原来的数组
18 irb(main):013:0> b = a.each do |element| end
19 => [1, 2, 3, 4]
20 irb(main):014:0> b
21 => [1, 2, 3, 4]
22 irb(main):015:0> b = a.each do |element| element*3  end
23 => [1, 2, 3, 4]
24 irb(main):016:0> b
25 => [1, 2, 3, 4]
26 # each一般用来进行相关操作
27 irb(main):018:0> a.each do |element| puts element end
28 1
29 2
30 3
31 4
32 => [1, 2, 3, 4]

ArrayIterator

ruby中的数组声明同java,最后一个,(逗号) 可要可不要
 
数组的其他操作:

 1 irb(main):019:0> b = [2, 3, 4, 5]
 2 => [2, 3, 4, 5]
 3 # 数组支持 + -,相当于Redis中的UNION和DIFF。返回操作之后的数组,原数组不会变
 4 irb(main):020:0> a - b
 5 => [1]
 6 # 判断是否为空
 7 irb(main):021:0> puts "a is not empty" unless a.empty?
 8 a is not empty
 9 => nil
10 # 判断是否包含某元素
11 irb(main):022:0> a.include?(3)
12 => true
13 # 返回第一个元素
14 irb(main):023:0> a.first
15 => 1
16 # 返回最后一个元素
17 irb(main):024:0> a.last
18 => 4
19 # 返回开始的3个元素
20 irb(main):025:0> a.first(3)
21 => [1, 2, 3]
22 irb(main):026:0> a.last(3)
23 => [2, 3, 4]
24 # 逆序
25 irb(main):027:0> a.reverse
26 => [4, 3, 2, 1]
27 # 原数组不会变
28 irb(main):028:0> a
29 => [1, 2, 3, 4]

OtherOp

散列表:

 1 # 基本形式
 2 irb(main):029:0> dict = {‘cat‘=>‘cat1‘, ‘dog‘=>‘dog1‘}
 3 => {"cat"=>"cat1", "dog"=>"dog1"}
 4 # key必须为字符串或者标志
 5 irb(main):030:0> dict2 = {cat=>cat1}
 6 NameError: undefined local variable or method `cat‘ for main:Object
 7 Did you mean?  catch
 8     from (irb):30
 9     from /usr/bin/irb:11:in `<main>‘
10 irb(main):031:0> dict2 = {‘cat‘=>cat1}
11 NameError: undefined local variable or method `cat1‘ for main:Object
12 Did you mean?  catch
13     from (irb):31
14     from /usr/bin/irb:11:in `<main>‘
15 irb(main):032:0> dict2 = {:cat=>‘cat1‘}
16 => {:cat=>"cat1"}
17 # length和size都可以得到长度
18 irb(main):033:0> dict.length
19 => 2
20 irb(main):034:0> dict.size
21 => 2
22 irb(main):035:0> dict[‘cat‘]
23 => "cat1"
24 # 不支持.访问
25 irb(main):036:0> dict.cat
26 NoMethodError: undefined method `cat‘ for {"cat"=>"cat1", "dog"=>"dog1"}:Hash
27     from (irb):36
28     from /usr/bin/irb:11:in `<main>‘

Hash

迭代散列表:

1 irb(main):037:0> dict.each do |key, value| puts "#{key} matches #{value}" end
2 cat matches cat1
3 dog matches dog1
4 => {"cat"=>"cat1", "dog"=>"dog1"}

Iterator

得到散列中的所有键和值:

1 irb(main):038:0> dict.keys.inspect
2 => "[\"cat\", \"dog\"]"
3 irb(main):039:0> dict.values.inspect
4 => "[\"cat1\", \"dog1\"]"

KeysValues

删除散列中的元素:

 1 # 直接删除
 2 => "[\"cat1\", \"dog1\"]"
 3 irb(main):040:0> dict.delete(‘cat‘)
 4 => "cat1"
 5 irb(main):041:0> dict
 6 => {"dog"=>"dog1"}
 7 # 有条件的删除
 8 irb(main):042:0> dict.delete_if do |key, value| value == ‘dog1‘ end
 9 => {}
10 irb(main):043:0> dict
11 => {}

Delete

添加元素:

可以利用merge小技巧

 1 irb(main):053:0> dict.merge({‘dog‘=>‘dog1‘})
 2 => {"dog"=>"dog1"}
 3 irb(main):054:0> dict.merge({‘cat‘=>‘cat1‘, ‘newDog‘=>‘dog2‘, ‘newCat‘=>‘cat2‘})
 4 => {"cat"=>"cat1", "newDog"=>"dog2", "newCat"=>"cat2"}
 5 # 发现merge只是返回一个新的hash,不能改变原来的hash
 6 irb(main):055:0> dict
 7 => {}
 8 # 可以通过下面的方式巧妙的添加元素:
 9 irb(main):057:0> dict = dict.merge({‘cat‘=>‘cat1‘, ‘newDog‘=>‘dog2‘, ‘newCat‘=>‘cat2‘})
10 => {"cat"=>"cat1", "newDog"=>"dog2", "newCat"=>"cat2"}
11 irb(main):058:0> dict
12 => {"cat"=>"cat1", "newDog"=>"dog2", "newCat"=>"cat2"}

Add

散列表中可以嵌套散列表,我们可以通过多重key值进行访问

1 # 散列中的元素也可以是散列值
2 irb(main):059:0> dict = dict.merge({‘animal‘=>{‘insideCat‘=>‘cat3‘}})
3 => {"cat"=>"cat1", "newDog"=>"dog2", "newCat"=>"cat2", "animal"=>{"insideCat"=>"cat3"}}
4 irb(main):060:0> dict[‘animal‘]
5 => {"insideCat"=>"cat3"}
6 # 可以嵌套获取值
7 irb(main):061:0> dict[‘animal‘][‘insideCat‘]
8 => "cat3"

InsideHash

流程控制:
if 、unless 
if elsif 
case:

 1 fruit = ‘orange‘
 2 irb(main):084:0> case fruit
 3 irb(main):085:1> when ‘orange‘
 4 irb(main):086:1> color = ‘orange‘
 5 irb(main):087:1> when ‘apple‘
 6 irb(main):088:1> color = ‘green‘
 7 irb(main):089:1> else
 8 irb(main):090:1* color = ‘unknown‘
 9 irb(main):091:1> end
10 => "orange"
11
12 # 上例可以简化为
13 irb(main):092:0> color = case fruit
14 irb(main):093:1> when ‘orange‘
15 irb(main):094:1> ‘orange‘
16 irb(main):095:1> else ‘unknown‘ end
17 => "orange"
18 irb(main):096:0> color
19 => "orange"

Case

while
until:与while相反,直到条件满足才跳出循环

1 irb(main):097:0> x = 1
2 => 1
3 irb(main):098:0> until x > 99
4 irb(main):099:1> puts x
5 irb(main):100:1> x = x * 20
6 irb(main):101:1> end
7 1
8 20
9 => nil

Until

时间: 2024-08-12 19:17:44

Ruby(3):基本语法中的相关文章

JavaScript语法中分号使用的细节

关于JavaScript中可选分号的问题有几个细节要注意: 一般来说,JavaScript和其他语言一样都是使用分号,将语句隔开,但在JavaScript中,如果语句各自独立一行,有时也可以省略分号的 细节1: 如果当前语句和随后的非空格字符不能当成一整体来解析的话,JavaScript就在当前语句行结束处自动填补分号 var a a = 3 console.log(a); JavaScript将上述代码解析为: var a; a=3; console.log(a); 第一行代码 var a自动

js语法中运算符的二义性之逗号&ldquo;,&rdquo;的二义性

看到<js语言精髓与编程实践>中讲解的js语法中运算符的二义性之逗号的二义性,做些笔记 我们先来看看这两个例子: alert(eval('a=(1,2,3);'));//示例1 alert(eval('a=1,2,3;'));//示例2 结果是两者都会弹出3,这种用法产生的混乱,是因为逗号","既可以是语法分隔符,又可以是运算符所导致的.在上面的示例1,示例2中,逗号都被作为"连续运算符"在使用.示例1中的括号强制运算符,因此它的效果是运算如下表达式:

C#语法中一个问号(?)和两个问号(??)的运算符是什么意思?

(1).C#语法中一个个问号(?)的运算符是指:可以为 null 的类型. MSDN上面的解释: 在处理数据库和其他包含不可赋值的元素的数据类型时,将 null 赋值给数值类型或布尔型以及日期类型的功能特别有用.例如,数据库中的布尔型字段可以存储值 true 或 false,或者,该字段也可以未定义. (2).C#语法中两个问号(??)的运算符是指null 合并运算符,合并运算符为类型转换定义了一个预设值,以防可空类型的值为Null. MSDN上面的解释: ?? 运算符称为 null 合并运算符

C#语法中一个问号(?)与两个问号(??)有什么区别

(1).C#语法中一个个问号(?)的运算符是指:可以为 null 的类型. MSDN上面的解释: 在处理数据库和其他包含不可赋值的元素的数据类型时,将 null 赋值给数值类型或布尔型以及日期类型的功能特别有用.例如,数据库中的布尔型字段可以存储值 true 或 false,或者,该字段也可以未定义. (2).C#语法中两个问号(??)的运算符是指null 合并运算符,合并运算符为类型转换定义了一个预设值,以防可空类型的值为Null. MSDN上面的解释: ?? 运算符称为 null 合并运算符

HTML5语法中需要掌握的3个要点

在HTML5中,有些元素可以省略标签.具体来讲有3种情况, 不允许写结束标记的元素有 area.base.br.col.command.embed.hr.img.input.keygen.link.meta.param.source.track.wbr 不允许写结束标记的元素是指,不允许使用开始标记与结束标 记将元素括起来的的形式,只允许使用""<元素/>"的形式进行 书写.例如:"<br>-</br>"的写法是错误的.

理解 ES6 语法中 yield 关键字的返回值

在 ES6 中新增了生成器函数的语法,本文解释了生成器函数内 yield 关键字的返回值. 描述 根据语法规范,yield 关键字用来暂停和继续执行一个生成器函数.当外部调用生成器的 next() 方法时,yield 关键字右侧的表达式才会执行. 执行结果会转化为一个对象(包含两个属性, value 和 done),作为 next() 方法的返回值. 对于  var foo = yield expression 语句,yield 左侧变量 foo 的值将在下一次调用 next() 方法时获得,并

转: 全面理解.htaccess语法中RewriteCond和RewriteRule意义

关于.htaccess伪静态的使用,章郎虫一直没有好好想过.以前一直是在网上找现成的,然后修改下网址实现重定向.今天我专门找资料看了下RewriteCond和RewriteRule的意思及使用方法.然后回过头看<网站地址更改之htaccess和php的301重定向>这篇文章,终于有些理解.现在不用一直找现成的代码,也可以自己写一些规则实现重定向了.下面就简单的介绍下他们的用法. RewriteCond的语法 RewriteCond TestString CondPattern [Flags]其

JS_ECMA基本语法中的几种封装的小函数-2

大家好!今天继续给大家写一下ECMA中的剩下的小函数以及实用的实例: 首先先给大家说一下字符串.数组.数学方法以及json的一点小知识点: 字符串方法: str.length str.charAt(i):取字符串中的某一个; str.indexOf('e');找第一个出现的位置;找不到返回-1; str.lastIndexOf('e'):找最后一个e出现的位置;找不到返回-1; str.toUpperCase();转大写 str.toLowerCase();转小写 str.substring(起

.htaccess语法中RewriteCond和RewriteRule意义

如果 xxx 匹配ooo 并且 如果 xxx2 匹配ooo 并且 那么 xxx3的访问 应该变为 xxx4 举个例子: RewriteCond %{REQUEST_URI} ^.*$ RewriteCond %{REQUEST_URI} ^/(?!pic).*$ RewriteRule ^(.*)$ /frontend/web/$1 代码解释: 如果 字符串 %{REQUEST_URI} 是 除 "\n"以外的字符开头,并且出现零次或多次,并且除 "\n"以外的字符