Ruby - 字符串

a

ASCII（与无相同）。 这是默认设置。

e

EUC.

n

None (same as ASCII).

u

UTF-8.

str % arg

使用格式规范格式化字符串。 如果 arg 包含多个替换，则它必须是一个数组。 有关格式规范的信息，请参阅"内核模块"下的 sprintf。

str * integer

返回一个包含整数倍 str 的新字符串。 换句话说，str 是重复的整数次。

str + other_str

将 other_str 连接到 str。

str << obj

将一个对象连接到 str。 如果对象是 0.255 范围内的 Fixnum，则将其转换为字符。 将其与 concat 进行比较。

str <=> other_str

将 str 与 other_str 进行比较，返回 -1（小于）、0（等于）或 1（大于）。 比较区分大小写。

str == obj

测试 str 和 obj 是否相等。 如果 obj 不是字符串，则返回 false； 如果 str <=> obj 返回 0，则返回 true。

str =~ obj

将 str 与正则表达式模式 obj 匹配。 返回匹配开始的位置； 否则为假。

str.capitalize

将字符串大写。

str.capitalize!

与大写相同，但进行了适当的更改。

str.casecmp

对字符串进行不区分大小写的比较。

str.center

使字符串居中。

str.chomp

从字符串末尾删除记录分隔符 ($/)，通常为 \n。 如果不存在记录分隔符，则不执行任何操作。

str.chomp!

与 chomp 相同，但已进行了适当的更改。

str.chop

删除 str 中的最后一个字符。

str.chop!

与chop相同，但已进行了适当的更改。

str.concat(other_str)

将 other_str 连接到 str。

str.count(str, ...)

计算一组或多组字符。 如果有多个字符集，则计算这些集的交集

str.crypt(other_str)

将单向加密哈希应用于 str。 参数是盐字符串，它应该是两个字符长，每个字符在 a.z, A.Z, 0.9, 范围内。 或者 /。

str.delete(other_str, ...)

返回 str 的副本，其中删除了其参数交集中的所有字符。

str.delete!(other_str, ...)

与删除相同，但更改已就地进行。

str.downcase

返回 str 的副本，其中所有大写字母都替换为小写。

str.downcase!

与小写相同，但已进行了更改。

str.dump

返回一个版本的 str ，其中所有非打印字符都被 \nnn 表示法替换，并且所有特殊字符都被转义了。

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

使用参数作为记录分隔符（默认为 $/）拆分 str，将每个子字符串传递给提供的块。

str.each_byte { |fixnum| block }

将每个字节从 str 传递到块，将每个字节作为字节的十进制表示形式返回。

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

使用参数作为记录分隔符（默认为 $/）拆分 str，将每个子字符串传递给提供的块。

str.empty?

如果 str 为空（长度为零），则返回 true。

str.eql?(other)

如果两个字符串具有相同的长度和内容，则它们是相等的。

str.gsub(pattern, replacement) [or]

str.gsub(pattern) { |match| block }

返回 str 的副本，其中所有出现的模式替换为替换或块的值。 该模式通常是一个正则表达式； 如果是字符串，则不会解释正则表达式元字符（即 /d/ 将匹配一个数字，但 'd' 将匹配一个反斜杠后跟一个 'd'）

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

引用 str，使用以下参数:一个 Fixnum，在 fixnum 处返回一个字符代码； 两个 Fixnum，返回从偏移量（第一个 fixnum）到长度（第二个 fixnum）的子字符串； range，返回范围内的子字符串； 正则表达式返回匹配字符串的一部分； 带有 fixnum 的正则表达式，返回 fixnum 处的匹配数据； other_str 返回匹配 other_str 的子字符串。 负的 Fixnum 以 -1 开头。

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 }

就地执行 String#gsub 的替换，如果没有执行替换，则返回 str 或 nil。

str.hash

根据字符串的长度和内容返回一个哈希值。

str.hex

将 str 中的前导字符视为十六进制数字字符串（带有可选的符号和可选的 0x）并返回相应的数字。 出错时返回零。

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

如果 str 包含给定的字符串或字符，则返回 true。

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

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

str.index(regexp [, offset])

返回给定子字符串、字符 (fixnum) 或模式 (regexp) 在 str 中第一次出现的索引。 如果没有找到则返回 nil。 如果存在第二个参数，它指定字符串中开始搜索的位置。

str.insert(index, other_str)

在给定索引处的字符之前插入 other_str，修改 str。 负索引从字符串末尾开始计数，并插入给定字符之后。 目的是插入一个字符串，以便它从给定的索引开始。

str.inspect

返回 str 的可打印版本，特殊字符已转义。

str.intern [or] str.to_sym

返回与 str 对应的符号，如果符号以前不存在，则创建该符号。

str.length

返回 str 的长度。 比较大小。

str.ljust(integer, padstr = ' ')

如果整数大于 str 的长度，则返回一个长度为整数的新字符串，其中 str 左对齐并用 padstr 填充； 否则，返回 str。

str.lstrip

返回删除前导空格的 str 副本。

str.lstrip!

从 str 中删除前导空格，如果没有进行任何更改，则返回 nil。

str.match(pattern)

将模式转换为正则表达式（如果还不是），然后在 str 上调用其匹配方法。

str.oct

将 str 的前导字符视为八进制数字字符串（带有可选符号）并返回相应的数字。 如果转换失败，则返回 0。

str.replace(other_str)

将 str 的内容和污点替换为 other_str 中的相应值。

str.reverse

以相反的顺序返回一个新字符串，其中包含 str 中的字符。

str.reverse!

将 str 反转到位。

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

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

str.rindex(regexp [, fixnum])

返回 str 中给定子字符串、字符 (fixnum) 或模式 (regexp) 的最后一次出现的索引。 如果没有找到则返回 nil。 如果存在第二个参数，它指定字符串中结束搜索的位置。超出此点的字符将不被考虑。

str.rjust(integer, padstr = ' ')

如果 integer 大于 str 的长度，则返回一个长度为 integer 的新 String，str 右对齐并用 padstr 填充； 否则，返回 str。

str.rstrip

返回删除尾随空格的 str 副本。

str.rstrip!

从 str 中删除尾随空格，如果没有进行任何更改，则返回 nil。

str.scan(pattern) [or]

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

两种形式都遍历 str，匹配模式（可能是正则表达式或字符串）。 对于每个匹配，都会生成一个结果并将其添加到结果数组或传递给块。 如果模式不包含任何组，则每个单独的结果都包含匹配的字符串 $&。 如果模式包含组，则每个单独的结果本身就是一个数组，每个组包含一个条目。

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 中删除指定部分，并返回已删除的部分。 如果值超出范围，采用 Fixnum 的表单将引发 IndexError； Range 表单将引发 RangeError，而 Regexp 和 String 表单将默默地忽略分配。

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

根据分隔符将 str 划分为子字符串，返回这些子字符串的数组。

如果pattern是一个String，那么它的内容在分割str时作为分隔符。 如果 pattern 是单个空格，则 str 在空格上拆分，忽略前导空格和连续空格字符的运行。

如果 pattern 是一个正则表达式，str 在模式匹配的地方被分割。 每当模式与零长度字符串匹配时，str 就会被拆分为单个字符。

如果pattern被省略，$的值； 用来。 如果 $; 为 nil（这是默认值），str 在空格上拆分，就像指定了 ` `。

如果省略 limit 参数，则禁止尾随空字段。 如果 limit 是一个正数，最多将返回该数量的字段（如果 limit 为 1，则整个字符串作为数组中的唯一条目返回）。 如果为负数，则返回的字段数没有限制，并且不抑制尾随的空字段。

str.squeeze([other_str]*)

使用针对 String#count 描述的过程从 other_str 参数构建一组字符。 返回一个新字符串，其中出现在此集中的相同字符的运行被单个字符替换。 如果没有给出参数，则所有相同字符的运行都将替换为单个字符。

str.squeeze!([other_str]*)

将 str 压缩到位，如果未进行任何更改，则返回 str 或 nil。

str.strip

返回删除前导和尾随空格的 str 副本。

str.strip!

从 str 中删除前导和尾随空格。 如果 str 未更改，则返回 nil。

str.sub(pattern, replacement) [or]

str.sub(pattern) { |match| block }

返回 str 的副本，其中第一次出现的模式替换为替换或块的值。 该模式通常是一个正则表达式； 如果它是字符串，则不会解释正则表达式元字符。

str.sub!(pattern, replacement) [or]

str.sub!(pattern) { |match| block }

就地执行 String#sub 的替换，如果没有执行替换，则返回 str 或 nil。

str.succ [or] str.next

返回 str 的后继者。

str.succ! [or] str.next!

等效于 String#succ，但在适当的位置修改接收器。

str.sum(n = 16)

返回 str 中字符的基本 n 位校验和，其中 n 是可选的 Fixnum 参数，默认为 16。结果只是 str 中每个字符的二进制值的总和，模 2n - 1。 好的校验和。

str.swapcase

返回 str 的副本，其中大写字母字符转换为小写，小写字符转换为大写。

str.swapcase!

等效于 String#swapcase，但在适当的位置修改接收器，返回 str，如果未进行任何更改，则返回 nil。

str.to_f

>返回将 str 中的前导字符解释为浮点数的结果。 超过有效数字末尾的无关字符将被忽略。 如果 str 的开头没有有效数字，则返回 0.0。 此方法从不引发异常。

str.to_i(base = 10)

返回将 str 中的前导字符解释为整数基数（基数为 2、8、10 或 16）的结果。 超过有效数字末尾的无关字符将被忽略。 如果 str 的开头没有有效数字，则返回 0。 此方法从不引发异常。

str.to_s [or] str.to_str

返回接收器。

str.tr(from_str, to_str)

返回 str 的副本，其中 from_str 中的字符被 to_str 中的相应字符替换。 如果 to_str 比 from_str 短，则用最后一个字符填充。 两个字符串都可以使用 c1.c2 表示法来表示字符范围，并且 from_str 可以以 ^ 开头，表示除列出的字符之外的所有字符。

str.tr!(from_str, to_str)

使用与 String#tr 相同的规则，就地翻译 str。 返回 str，如果没有进行任何更改，则返回 nil。

str.tr_s(from_str, to_str)

按照 String#tr 中的说明处理 str 的副本，然后删除受翻译影响的区域中的重复字符。

str.tr_s!(from_str, to_str)

就地对 str 执行 String#tr_s 处理，返回 str，如果未进行任何更改，则返回 nil。

str.unpack(format)

>根据格式字符串解码 str（可能包含二进制数据），返回提取的每个值的数组。 格式字符串由一系列单字符指令组成，总结在表 18 中。每个指令后面可以跟一个数字，表示使用该指令重复的次数。 星号 (*) 将用完所有剩余元素。 指令 sSiIlL 每个都可以后跟一个下划线 (_) 以使用指定类型的底层平台的本机大小； 否则，它使用与平台无关的一致大小。 格式字符串中的空格被忽略。

str.upcase

返回 str 的副本，其中所有小写字母都替换为对应的大写字母。 该操作对区域设置不敏感。 只有字符 a 到 z 受到影响。

str.upcase!

将 str 的内容更改为大写，如果没有更改则返回 nil。

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

遍历连续的值，从 str 开始，到 other_str 结束，依次将每个值传递给块。 String#succ 方法用于生成每个值。