ruby模块，字符串

来源：互联网发布：mysql修改字段值编辑：程序博客网时间：2024/04/30 10:14

模块是一种把方法，类和常量组合在一起的方式。

模块提供了一个命名空间和避免名字冲突。

模块实现了mixin装置。

语法

moduleIdentifier

statement1

statement2

...........

end

模块常量命名与类常量命名类似，以大写字母开头。方法定义看起来也相似：模块方法定义与类方法定义类似。

通过类方法，您可以在类方法名称前面放置模块名称和一个点号来调用模块方法，您可以使用模块名称和两个冒号来引用一个常量。

Ruby require 语句

require 语句类似于 C 和 C++ 中的 include 语句以及 Java 中的 import 语句。如果一个第三方的程序想要使用任何已定义的模块，则可以简单地使用 Ruby require 语句来加载模块文件：

语法

requirefilename

在这里，文件扩展名 .rb 不是必需的。

实例

$LOAD_PATH <<'.'

require'trig.rb'

require'moral'

y =Trig.sin(Trig::PI/4)

wrongdoing = Moral.sin(Moral::VERY_BAD)

在这里，我们使用 $LOAD_PATH << '.' 让 Ruby 知道必须在当前目录中搜索被引用的文件。如果您不想使用 $LOAD_PATH，那么您可以使用 require_relative 来从一个相对目录引用文件。

注意：在这里，文件包含相同的函数名称。所以，这会在引用调用程序时导致代码模糊，但是模块避免了这种代码模糊，而且我们可以使用模块的名称调用适当的函数。

Ruby 中的 Mixins

在阅读本节之前，您需要初步了解面向对象的概念。

当一个类可以从多个父类继承类的特性时，该类显示为多重继承。

Ruby 不直接支持多重继承，但是 Ruby 的模块（Module）有另一个神奇的功能。它几乎消除了多重继承的需要，提供了一种名为 mixin 的装置。

Ruby 没有真正实现多重继承机制，而是采用成为mixin技术作为替代品。将模块include到类定义中，模块中的方法就mix进了类中。

让我们看看下面的示例代码，深入了解 mixin：

实例

moduleA

defa1

end

defa2

end

moduleB

defb1

end

defb2

end

classSample

include A

include B

defs1

end

samp=Sample.new

samp.a1

samp.a2

samp.b1

samp.b2

samp.s1

模块 A 由方法 a1 和 a2 组成。
模块 B 由方法 b1 和 b2 组成。
类 Sample 包含了模块 A 和 B。
类 Sample 可以访问所有四个方法，即 a1、a2、b1 和 b2。

因此，您可以看到类 Sample 继承了两个模块，您可以说类 Sample 使用了多重继承或 mixin 。

Ruby 字符串（String）

2017年9月6日

9:24

Ruby 中的 String 对象用于存储或操作一个或多个字节的序列。

Ruby字符串分为单引号字符串（'）和双引号字符串（"），区别在于双引号字符串能够支持更多的转义字符。

如果您需要在单引号字符串内使用单引号字符，那么需要在单引号字符串使用反斜杠(\)，这样 Ruby解释器就不会认为这个单引号字符是字符串的终止符号

在双引号字符串中我们可以使用 #{} 井号和大括号来计算表达式的值。

Ruby 中还支持一种采用 %q 和 %Q 来引导的字符串变量，%q 使用的是单引号引用规则，而 %Q是双引号引用规则，后面再接一个 (! [ { 等等的开始界定符和与 } ] ) 等等的末尾界定符。

跟在 q 或 Q后面的字符是分界符.分界符可以是任意一个非字母数字的单字节字符.如:[,{,(,<,!等,字符串会一直读取到发现相匹配的结束符为止.

转义字符

下标列出了可使用反斜杠符号转义的转义字符或非打印字符。

注意：在一个双引号括起的字符串内，转义字符会被解析。在一个单引号括起的字符串内，转义字符不会被解析，原样输出。

字符编码

Ruby 的默认字符集是 ASCII，字符可用单个字节表示。如果您使用 UTF-8 或其他现代的字符集，字符可能是用一个到四个字节表示。

您可以在程序开头使用 $KCODE 改变字符集，如下所示：

$KCODE = 'u'

下面是 $KCODE 可能的值。

字符串内建方法

我们需要有一个 String 对象的实例来调用 String 方法。下面是创建 String 对象实例的方式：

new[String.new(str="")]

这将返回一个包含 str 副本的新的字符串对象。现在，使用 str 对象，我们可以调用任意可用的实例方法。例如：

实例

#!/usr/bin/rubymyStr =String.new("THIS IS TEST")foo = myStr.downcaseputs"#{foo}"

这将产生以下结果：

this is test

下面是公共的字符串方法（假设 str 是一个 String 对象）：

str % arg

str * integer

str + other_str

str << obj

str <=> other_str

str == obj

str =~ obj

str.capitalize

str.capitalize!

str.casecmp

str.center

str.chomp

str.chomp!

str.chop

str.chop!

str.concat(other_str)

str.count(str, ...)

str.crypt(other_str)

str.delete(other_str, ...)

str.delete!(other_str, ...)

str.downcase

str.downcase!

str.dump

str.each(separator=$/) { |substr| block }

str.each_byte { |fixnum| block }

str.each_line(separator=$/) { |substr| block }

str.empty?

str.eql?(other)

str.gsub(pattern, replacement) [or]
str.gsub(pattern) { |match| block }

str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]

str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] =new_str [or] str[regexp, fixnum] =new_str [or] str[other_str] = new_str ]

str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match| block }

str.hash

str.hex

str.include? other_str [or] str.include? fixnum

str.index(substring [, offset]) [or]
str.index(fixnum [, offset]) [or]
str.index(regexp [, offset])

str.insert(index, other_str)

str.inspect

str.intern [or] str.to_sym

str.length

str.ljust(integer, padstr=' ')

str.lstrip

str.lstrip!

str.match(pattern)

str.oct

str.replace(other_str)

str.reverse

str.reverse!

str.rindex(substring [, fixnum]) [or]
str.rindex(fixnum [, fixnum]) [or]
str.rindex(regexp [, fixnum])

str.rjust(integer, padstr=' ')

str.rstrip

str.rstrip!

str.scan(pattern) [or]
str.scan(pattern) { |match, ...| block }

str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]
str.slice(range) [or] str.slice(regexp) [or]
str.slice(regexp, fixnum) [or] str.slice(other_str)
See str[fixnum], etc.
str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or] str.slice!(range) [or] str.slice!(regexp) [or] str.slice!(other_str)

str.split(pattern=$;, [limit])

基于分隔符，把 str 分成子字符串，并返回这些子字符串的数组。

如果 pattern 是一个字符串 String，那么在分割 str 时，它将作为分隔符使用。如果 pattern 是一个单一的空格，那么 str 是基于空格进行分割，会忽略前导空格和连续空格字符。

如果 pattern 是一个正则表达式 Regexp，则 str 在 pattern 匹配的地方被分割。当 pattern 匹配一个玲长度的字符串时，str 被分割成单个字符。

如果省略了 pattern 参数，则使用 $; 的值。如果 $; 为 nil（默认的），str 基于空格进行分割，就像是指定了 ` ` 作为分隔符一样。

如果省略了 limit 参数，会抑制尾随的 null 字段。如果 limit 是一个正数，则最多返回该数量的字段（如果 limit 为 1，则返回整个字符串作为数组中的唯一入口）。如果 limit 是一个负数，则返回的字段数量不限制，且不抑制尾随的 null 字段。

str.squeeze([other_str]*)

str.squeeze!([other_str]*)

str.strip

str.strip!

str.sub(pattern, replacement) [or]
str.sub(pattern) { |match| block }

str.sub!(pattern, replacement) [or]
str.sub!(pattern) { |match| block }

str.succ [or] str.next

str.succ! [or] str.next!

str.sum(n=16)

str.swapcase

str.swapcase!

str.to_f

str.to_i(base=10)

str.to_s [or] str.to_str

str.tr(from_str, to_str)

str.tr!(from_str, to_str)

str.tr_s(from_str, to_str)

str.tr_s!(from_str, to_str)

str.unpack(format)

str.upcase

str.upcase!

str.upto(other_str) { |s| block }

字符串 unpack 指令

下表列出了方法 String#unpack 的解压指令。

阅读全文

0 0