Unix & Shell-Programmierung: Strings und Operationen auf Zeichenreihen

Online	Dokumentation

Semantik von Strings
Ruby 1.8	Strings bestehen aus einer Folge von Zeichen, diese Zeichen können die Werte von 0 bis 255 annehmen.
	Also keine vernünftige Unicode Unterstützung
	Ruby 1.9 hat Unicode Unterstützung
Alle Methoden	"a".methods.sort => ["%", "*" , "+" , "<", "<<", "<=", "<=>" , "==", "===", "=~", ">", ">=" , "[]", "[]=" , "__id__", "__send__" , "all?", "any?", "between?" , "capitalize", "capitalize!" , "casecmp", "center" , "chomp", "chomp!", "chop", "chop!" , "class", "clone", "collect" , "concat", "count", "crypt" , "delete", "delete!", "detect", "display" , "downcase", "downcase!", "dump", "dup" , "each", "each_byte" , "each_line", "each_with_index" , "empty?" , "entries", "eql?" , "equal?", "extend" , "find", "find_all" , "freeze", "frozen?" , "grep", "gsub", "gsub!" , "hash", "hex", "id", "include?" , "index", "inject", "insert" , "inspect", "instance_eval" , "instance_of?", "instance_variable_defined?" , "instance_variable_get" , "instance_variable_set" , "instance_variables" , "intern", "is_a?", "kind_of?" , "length", "ljust", "lstrip", "lstrip!" , "map", "match" , "max", "member?" , "method", "methods" , "min" , "next", "next!", "nil?" , "object_id", "oct" , "partition" , "private_methods" , "protected_methods", "public_methods" , "reject", "replace", "respond_to?" , "reverse", "reverse!" , "rindex", "rjust", "rstrip", "rstrip!" , "scan", "select", "send" , "singleton_methods" , "size", "slice", "slice!" , "sort", "sort_by" , "split" , "squeeze", "squeeze!" , "strip", "strip!" , "sub", "sub!" , "succ", "succ!" , "sum", "swapcase", "swapcase!" , "taint", "tainted?" , "to_a", "to_f", "to_i", "to_s" , "to_str", "to_sym" , "tr", "tr!" , "tr_s", "tr_s!" , "type" , "unpack", "untaint" , "upcase", "upcase!", "upto" , "zip"]
	Welche Operationen sind wichtig?
Konkatenation	"abc" + "xyz" # => "abcxyz" "abc" * 3 # => "abcabcabc" "%d" % (6 * 7) # => "42" "abc" << "xyz" # => "abcxyz" "abc" << (6 * 7) # => "abc42" s = "abc" s << "def" # => "abcdef" s # => "abcdef" s << "xyz" # => "abcdefxyz" s # => "abcdefxyz"
Selektoren	"abc"[0] # => 97 "abc"[1] # => 98 "abc"[-1] # => 99 "abc"[0..1] # => "ab" "abc"[0..0] # => "a" "abc"[1..0] # => "" "abc"[1..27] # => "bc" "abc"[3..27] # => "" "abc"[4..27] # => nil "abc"[-1..-1] # => "c" "abc"[-2..-1] # => "bc" "abc"[-3..-1] # => "abc" "abc"[-4..-1] # => nil
Zuweisungen und Bereichszuweisung	a="abcd" ; a[1] = 120 ; a # => "axcd" a="abcd" ; a[1] = ?x ; a # => "axcd" a="abcd" ; a[1] = "120" ; a # => "a120cd" a="abcd" ; a[1..0] = "120" ; a # => "a120bcd" a="abcd" ; a[1..2] = "xy" ; a # => "axyd" a="abcd" ; a[1..2] = "" ; a # => "ad"
	Mit Bereichszuweisungen kann das Einfügen, das Löschen und das Ersetzen von Teilzeichenreihen realisisert werden.
Vergleiche, Tests und einfache Abfragen	"a" <=> "a" # => 0 "" <=> "a" # => -1 "a" <=> "" # => +1 "a" == "a" # => true "a" == "b" # => false "a" > "a" # => false "a" > "" # => true "a" >= "a" # => true "a" >= "aa" # => false "a" < "a" # => false "a" < "b" # => true "a" < "aa" #= > true "a" < "" # => false "a" <= "a" # => true "b" <= "a" # => false "a" =~ /a+/ # => 0 "xay" =~ /a+/ # => 1 "xyz" =~ /a+/ # => nil "a" =~ /x*/ # => 0 "".empty? # => true "a".empty? # => false "a".length # => 1 "".length # => 0 "a".size # => 1 "".size # => 0

Einfache Manipulation von Texten	a="abc" ; b="ABC" ; c="AbC" a.capitalize # => "Abc" a.upcase # => "ABC" b.downcase # => "abc" c.swapcase # => "aBc" a.center(5) # => " abc " a.ljust(5) # => "abc " a.rjust(5) # => " abc" a.chomp("c") # => "ab" a.chomp("bc") # => "a" a.chomp("d") # => "abc" a.chop # => "ab" a.chop.chop # => "a" a.chop.chop.chop # => "" a.chop.sui # => ??? a=" abc \n\t" a.strip # => "abc" a.reverse # => "cba" a.reverse.reverse # => "abc" "otto".reverse # => "otto"

Suchen	a="abcda" a.include?("b") # => true a.include?("bc") # => true a.include?("x") # => false a.index("b") # => 1 a.index("cd") # => 2 a.index("x") # => nil a.rindex("a") # => 4 a.rindex("bc") # => 1 a.rindex("x") # => nil

Konversionen	a="123" a.to_i # => 123 a.to_f # => 123.0 a.to_s # => "123"

Operationen mit regulären Ausdrücken	a="aabbccaa" a.gsub(/a/,"A") # => "AAbbccAA" a.gsub(/bb/,"") # => aaccaa a.sub(/a/,"A") # => "Aabbccaa" a.sub(/bb/,"") # => aaccaa a=" 1 3 5 " a.gsub(/ +/,"") # => "135" a="123.456.789" r=/^([0-9]+)[.]([0-9]+)[.]([0-9]+)$/ s="\\3.\\2.\\1" a.gsub(r,s) # => "789.456.123" a="xyz" a.gsub(r,s) # => "xyz" a="123.456.789" a.scan(/[0-9]+/) # => ["123", "456", "789"] a.split(".") # => ["123", "456", "789"] a.split(/./) # => [] a.split(/[.]/) # => ["123", "456", "789"] a.split(//) # => ["1", "2", "3", "." # , "4", "5", "6", "." # , "7", "8", "9"] a=" abc xyz " a.split # => ["abc", "xyz"]