In Files

  • minirake
  • mrbgems/mruby-sprintf/mrblib/string.rb
  • mrbgems/mruby-string-ext/mrblib/string.rb
  • mrblib/string.rb
toggle debugging

String

Public Class Methods

try_convert(obj) → string or nil click to toggle source

Try to convert obj into a String, using to_str method. Returns converted string or nil if obj cannot be converted for any reason.

String.try_convert("str")     #=> "str"
String.try_convert(/re/)      #=> nil
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 14
def self.try_convert(obj)
  if obj.respond_to?(:to_str)
    obj.to_str
  else
    nil
  end
end
            

Public Instance Methods

%(args) click to toggle source
 
               # File mrbgems/mruby-sprintf/mrblib/string.rb, line 2
def %(args)
  if args.is_a? Array
    sprintf(self, *args)
  else
    sprintf(self, args)
  end
end
            
=~(re) click to toggle source

ISO 15.2.10.5.3

 
               # File mrblib/string.rb, line 213
def =~(re)
  raise TypeError, "type mismatch: String given" if re.respond_to? :to_str
  re =~ self
end
            
[]=(*args) click to toggle source

Modify self by replacing the content of self. The portion of the string affected is determined using the same criteria as +String#[]+.

 
               # File mrblib/string.rb, line 158
def []=(*args)
  anum = args.size
  if anum == 2
    pos, value = args
    case pos
    when String
      posnum = self.index(pos)
      if posnum
        b = self[0, posnum.to_i]
        a = self[(posnum + pos.length)..-1]
        self.replace([b, value, a].join(''))
      else
        raise IndexError, "string not matched"
      end
    when Range
      head = pos.begin
      tail = pos.end
      tail += self.length if tail < 0
      if pos.exclude_end?
        tail -= 1
      end
      if tail < 0 || tail > self.length
        raise IndexError, "index #{args[0]} out of string"
      end
      return self[head, tail-head]=value
    else
      pos += self.length if pos < 0
      if pos < 0 || pos > self.length
        raise IndexError, "index #{args[0]} out of string"
      end
      b = self[0, pos.to_i]
      a = self[pos + 1..-1]
      self.replace([b, value, a].join(''))
    end
    return value
  elsif anum == 3
    pos, len, value = args
    pos += self.length if pos < 0
    if pos < 0 || pos > self.length
      raise IndexError, "index #{args[0]} out of string"
    end
    if len < 0
      raise IndexError, "negative length #{len}"
    end
    b = self[0, pos.to_i]
    a = self[pos + len..-1]
    self.replace([b, value, a].join(''))
    return value
  else
    raise ArgumentError, "wrong number of arguments (#{anum} for 2..3)"
  end
end
            
__sub_replace(pre, m, post) click to toggle source

private method for gsub/sub

 
               # File mrblib/string.rb, line 23
def __sub_replace(pre, m, post)
  s = ""
  i = 0
  while j = index("\\", i)
    break if j == length-1
    t = case self[j+1]
        when "\\"
          "\\"
        when "`"
          pre
        when "&", "0"
          m
        when "'"
          post
        else
          self[j, 2]
        end
    s += self[i, j-i] + t
    i = j + 2
  end
  s + self[i, length-i]
end
            
casecmp(other_str) → -1, 0, +1 or nil click to toggle source

Case-insensitive version of String#<=>.

"abcdef".casecmp("abcde")     #=> 1
"aBcDeF".casecmp("abcdef")    #=> 0
"abcdef".casecmp("abcdefg")   #=> -1
"abcdef".casecmp("ABCDEF")    #=> 0
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 141
def casecmp(str)
  self.downcase <=> str.to_str.downcase
rescue NoMethodError
  raise TypeError, "no implicit conversion of #{str.class} into String"
end
            
chars(&block) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 355
def chars(&block)
  if block_given?
    self.split('').each do |i|
      block.call(i)
    end
    self
  else
    self.split('')
  end
end
            
clear → string click to toggle source

Makes string empty.

a = "abcde"
a.clear    #=> ""
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 31
def clear
  self.replace("")
end
            
codepoints(&block) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 375
def codepoints(&block)
  len = self.size

  if block_given?
    self.split('').each do|x|
      block.call(x.ord)
    end
    self
  else
    self.split('').map{|x| x.ord}
  end
end
            
Also aliased as: each_codepoint
each_byte(&block) click to toggle source

Call the given block for each byte of self.

 
               # File mrblib/string.rb, line 145
def each_byte(&block)
  bytes = self.bytes
  pos = 0
  while pos < bytes.size
    block.call(bytes[pos])
    pos += 1
  end
  self
end
            
each_char(&block) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 366
def each_char(&block)
  return to_enum :each_char unless block

  split('').each do |i|
    block.call(i)
  end
  self
end
            
each_codepoint(&block) click to toggle source
Alias for: codepoints
each_line(&block) click to toggle source

Calls the given block for each line and pass the respective line.

ISO 15.2.10.5.15

 
               # File mrblib/string.rb, line 12
def each_line(&block)
  offset = 0
  while pos = self.index("\n", offset)
    block.call(self[offset, pos + 1 - offset])
    offset = pos + 1
  end
  block.call(self[offset, self.size - offset]) if self.size > offset
  self
end
            
ext(newext='') click to toggle source
 
               # File minirake, line 11
def ext(newext='')
  return self.dup if ['.', '..'].include? self
  if newext != ''
    newext = (newext =~ /^\./) ? newext : ("." + newext)
  end
  self.chomp(File.extname(self)) << newext
end
            
gsub(*args, &block) click to toggle source

Replace all matches of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Return the final value.

ISO 15.2.10.5.18

 
               # File mrblib/string.rb, line 53
def gsub(*args, &block)
  if args.size == 2
    s = ""
    i = 0
    while j = index(args[0], i)
      seplen = args[0].length
      k = j + seplen
      pre = self[0, j]
      post = self[k, length-k]
      s += self[i, j-i] + args[1].__sub_replace(pre, args[0], post)
      i = k
    end
    s + self[i, length-i]
  elsif args.size == 1 && block
    split(args[0], -1).join(block.call(args[0]))
  else
    raise ArgumentError, "wrong number of arguments"
  end
end
            
gsub!(*args, &block) click to toggle source

Replace all matches of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Modify self with the final value.

ISO 15.2.10.5.19

 
               # File mrblib/string.rb, line 80
def gsub!(*args, &block)
  str = self.gsub(*args, &block)
  return nil if str == self
  self.replace(str)
end
            
insert(index, other_str) → str click to toggle source

Inserts other_str before the character at the given index, modifying str. Negative indices count from the end of the string, and insert after the given character. The intent is insert aString so that it starts at the given index.

"abcd".insert(0, 'X')    #=> "Xabcd"
"abcd".insert(3, 'X')    #=> "abcXd"
"abcd".insert(4, 'X')    #=> "abcdX"
"abcd".insert(-3, 'X')   #=> "abXcd"
"abcd".insert(-1, 'X')   #=> "abcdX"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 256
def insert(idx, str)
  if idx == -1
    return self << str
  elsif idx < 0
    idx += 1
  end
  self[idx, 0] = str
  self
end
            
ljust(integer, padstr=' ') → new_str click to toggle source

If integer is greater than the length of str, returns a new String of length integer with str left justified and padded with padstr; otherwise, returns str.

"hello".ljust(4)            #=> "hello"
"hello".ljust(20)           #=> "hello               "
"hello".ljust(20, '1234')   #=> "hello123412341234123"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 277
def ljust(idx, padstr = ' ')
  if idx <= self.size
    return self
  end
  newstr = self.dup
  newstr << padstr
  while newstr.size <= idx
    newstr << padstr
  end
  return newstr.slice(0,idx)
end
            
lstrip → new_str click to toggle source

Returns a copy of str with leading whitespace removed. See also String#rstrip and String#strip.

"  hello  ".lstrip   #=> "hello  "
"hello".lstrip       #=> "hello"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 45
def lstrip
  a = 0
  z = self.size - 1
  a += 1 while " \f\n\r\t\v".include?(self[a]) and a <= z
  (z >= 0) ? self[a..z] : ""
end
            
lstrip! → self or nil click to toggle source

Removes leading whitespace from str, returning nil if no change was made. See also String#rstrip! and String#strip!.

"  hello  ".lstrip   #=> "hello  "
"hello".lstrip!      #=> nil
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 97
def lstrip!
  s = self.lstrip
  (s == self) ? nil : self.replace(s)
end
            
match(re, &block) click to toggle source

ISO 15.2.10.5.27

 
               # File mrblib/string.rb, line 220
def match(re, &block)
  if re.respond_to? :to_str
    if Object.const_defined?(:Regexp)
      r = Regexp.new(re)
      r.match(self, &block)
    else
      raise NotImplementedError, "String#match needs Regexp class"
    end
  else
    re.match(self, &block)
  end
end
            
partition(sep) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 147
def partition(sep)
  raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String
  n = index(sep)
  unless n.nil?
    m = n + sep.size
    [ slice(0, n), sep, slice(m, size - m) ]
  else
    [ self, "", "" ]
  end
end
            
pathmap(spec=nil, &block) click to toggle source
 
               # File minirake, line 19
def pathmap(spec=nil, &block)
  return self if spec.nil?
  result = ''
  spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag|
    case frag
    when '%f'
      result << File.basename(self)
    when '%n'
      result << File.basename(self).ext
    when '%d'
      result << File.dirname(self)
    when '%x'
      result << File.extname(self)
    when '%X'
      result << self.ext
    when '%p'
      result << self
    when '%s'
      result << (File::ALT_SEPARATOR || File::SEPARATOR)
    when '%-'
      # do nothing
    when '%%'
      result << "%"
    when /%(-?\d+)d/
      result << pathmap_partial($1.to_i)
    when /^%\{([^}]*)\}(\d*[dpfnxX])/
      patterns, operator = $1, $2
      result << pathmap('%' + operator).pathmap_replace(patterns, &block)
    when /^%/
      fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'"
    else
      result << frag
    end
  end
  result
end
            
rjust(integer, padstr=' ') → new_str click to toggle source

If integer is greater than the length of str, returns a new String of length integer with str right justified and padded with padstr; otherwise, returns str.

"hello".rjust(4)            #=> "hello"
"hello".rjust(20)           #=> "               hello"
"hello".rjust(20, '1234')   #=> "123412341234123hello"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 300
def rjust(idx, padstr = ' ')
  if idx <= self.size
    return self
  end
    padsize = idx - self.size
    newstr = padstr.dup
    while newstr.size <= padsize
      newstr << padstr
    end
  return newstr.slice(0,padsize) + self
end
            
rpartition(sep) click to toggle source
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 158
def rpartition(sep)
  raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String
  n = rindex(sep)
  unless n.nil?
    m = n + sep.size
    [ slice(0, n), sep, slice(m, size - m) ]
  else
    [ "", "", self ]
  end
end
            
rstrip → new_str click to toggle source

Returns a copy of str with trailing whitespace removed. See also String#lstrip and String#strip.

"  hello  ".rstrip   #=> "  hello"
"hello".rstrip       #=> "hello"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 62
def rstrip
  a = 0
  z = self.size - 1
  z -= 1 while " \f\n\r\t\v\0".include?(self[z]) and a <= z
  (z >= 0) ? self[a..z] : ""
end
            
rstrip! → self or nil click to toggle source

Removes trailing whitespace from str, returning nil if no change was made. See also String#lstrip! and String#strip!.

"  hello  ".rstrip   #=> "  hello"
"hello".rstrip!      #=> nil
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 113
def rstrip!
  s = self.rstrip
  (s == self) ? nil : self.replace(s)
end
            
scan(reg, &block) click to toggle source

Calls the given block for each match of pattern If no block is given return an array with all matches of pattern.

ISO 15.2.10.5.32

 
               # File mrblib/string.rb, line 92
def scan(reg, &block)
  ### *** TODO *** ###
  unless Object.const_defined?(:Regexp)
    raise NotImplementedError, "scan not available (yet)"
  end
end
            
slice!(fixnum) → new_str or nil click to toggle source
slice!(fixnum, fixnum) → new_str or nil
slice!(range) → new_str or nil
slice!(other_str) → new_str or nil

Deletes the specified portion from str, and returns the portion deleted.

string = "this is a string"
string.slice!(2)        #=> "i"
string.slice!(3..6)     #=> " is "
string.slice!("r")      #=> "r"
string                  #=> "thsa sting"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 185
def slice!(arg1, arg2=nil)
  raise "wrong number of arguments (for 1..2)" if arg1.nil? && arg2.nil?

  if !arg1.nil? && !arg2.nil?
    idx = arg1
    idx += self.size if arg1 < 0
    if idx >= 0 && idx <= self.size && arg2 > 0
      str = self[idx, arg2]
    else
      return nil
    end
  else
    validated = false
    if arg1.kind_of?(Range)
      beg = arg1.begin
      ed = arg1.end
      beg += self.size if beg < 0
      ed += self.size if ed < 0
      ed -= 1 if arg1.exclude_end?
      validated = true
    elsif arg1.kind_of?(String)
      validated = true
    else
      idx = arg1
      idx += self.size if arg1 < 0
      validated = true if idx >=0 && arg1 < self.size
    end
    if validated
      str = self[arg1]
    else
      return nil
    end
  end
  unless str.nil? || str == ""
    if !arg1.nil? && !arg2.nil?
      idx = arg1 >= 0 ? arg1 : self.size+arg1
      str2 = self[0...idx] + self[idx+arg2..-1].to_s
    else
      if arg1.kind_of?(Range)
        idx = beg >= 0 ? beg : self.size+beg
        idx2 = ed>= 0 ? ed : self.size+ed
        str2 = self[0...idx] + self[idx2+1..-1].to_s
      elsif arg1.kind_of?(String)
        idx = self.index(arg1)
        str2 = self[0...idx] + self[idx+arg1.size..-1] unless idx.nil?
      else
        idx = arg1 >= 0 ? arg1 : self.size+arg1
        str2 = self[0...idx] + self[idx+1..-1].to_s
      end
    end
    self.replace(str2) unless str2.nil?
  end
  str
end
            
strip → new_str click to toggle source

Returns a copy of str with leading and trailing whitespace removed.

"    hello    ".strip   #=> "hello"
"\tgoodbye\r\n".strip   #=> "goodbye"
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 78
def strip
  a = 0
  z = self.size - 1
  a += 1 while " \f\n\r\t\v".include?(self[a]) and a <= z
  z -= 1 while " \f\n\r\t\v\0".include?(self[z]) and a <= z
  (z >= 0) ? self[a..z] : ""
end
            
strip! → str or nil click to toggle source

Removes leading and trailing whitespace from str. Returns nil if str was not altered.

 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 125
def strip!
  s = self.strip
  (s == self) ? nil : self.replace(s)
end
            
sub(*args, &block) click to toggle source

Replace only the first match of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Return the final value.

ISO 15.2.10.5.36

 
               # File mrblib/string.rb, line 106
def sub(*args, &block)
  if args.size == 2
    pre, post = split(args[0], 2)
    return self unless post # The sub target wasn't found in the string
    pre + args[1].__sub_replace(pre, args[0], post) + post
  elsif args.size == 1 && block
    split(args[0], 2).join(block.call(args[0]))
  else
    raise ArgumentError, "wrong number of arguments"
  end
end
            
sub!(*args, &block) click to toggle source

Replace only the first match of pattern with replacement. Call block (if given) for each match and replace pattern with the value of the block. Modify self with the final value.

ISO 15.2.10.5.37

 
               # File mrblib/string.rb, line 125
def sub!(*args, &block)
  str = self.sub(*args, &block)
  return nil if str == self
  self.replace(str)
end
            
upto(other_str, excl=false, &block) click to toggle source
str.upto(other_str, exclusive=false) {|s| block }   -> str
str.upto(other_str, exclusive=false)                -> an_enumerator

Iterates through successive values, starting at str and ending at other_str inclusive, passing each value in turn to the block. The String#succ method is used to generate each value. If optional second argument exclusive is omitted or is false, the last value will be included; otherwise it will be excluded.

If no block is given, an enumerator is returned instead.

"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
  print s, ' '
end

produces:

a8 a9 b0 b1 b2 b3 b4 b5 b6
a8 a9 b0 b1 b2 b3 b4 b5 b6

If str and other_str contains only ascii numeric characters, both are recognized as decimal numbers. In addition, the width of string (e.g. leading zeros) is handled appropriately.

"9".upto("11").to_a   #=> ["9", "10", "11"]
"25".upto("5").to_a   #=> []
"07".upto("11").to_a  #=> ["07", "08", "09", "10", "11"]
 
               # File mrbgems/mruby-string-ext/mrblib/string.rb, line 341
def upto(other_str, excl=false, &block)
  return to_enum :upto, other_str, excl unless block

  str = self
  n = self.<=>other_str
  return self if n > 0 || (self == other_str && excl)
  while true
    block.call(str)
    return self if !excl && str == other_str
    str = str.succ
    return self if excl && str == other_str
  end
end
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.