roebe 0.5.187

data/doc/core/string.md

@@ -0,0 +1,854 @@
+## How can we return the first, capitalized character from a long string?
+
+  Use [//], as in:
+
+    "my name is Bert"[/[A-Z]/]
+
+  This works because it is using a regex as an index.
+
+  Another example demonstrating this functionality:
+
+    "abcd"[/bc/] => "bc"
+
+## How to count a range of characters, in a given String?
+
+  Use a '-' hyphen, together with .count(), as in:
+  
+    "abcdefghi".count("a-d") # => 4
+
+## How can we convert between different encodings in Ruby?
+
+  Make use of the method #encode.
+
+  Example:
+
+    string_object_here.encode("iso-8859-1")
+
+## Why should we prefer to freeze Strings, in Ruby?
+
+  By freezing a String object we ensure that the ruby interpreter
+  creates only one String object that can be re-used at a later
+  moment in time. That way we save memory, as we avoid the
+  creation of many String objects that may ultimately all have
+  the very same content.
+
+## How can we concatenate two Strings in Ruby? How to add one String onto another? (concat tag)
+
+  Use:
+
+    +
+
+  Or alternatively use .concat(). Example for this:
+
+    string = 'foo'
+    string.concat('d') # => "food"
+
+  Or use << as in:
+
+    string << 'd'
+
+  This will simply append "d" onto the String "foo". The new String would
+  then be "food".
+
+## How can we obtain a substring from a String, in Ruby? How can we access certain characters in a String?
+
+  Several possibilities exist here. One of the simplest is to make
+  use of the method .slice(), as in:
+ 
+    "foobar".slice(3, 5) # => "bar"
+
+  Via .slice!() it is possible to modify the String directly.
+
+  Example for this:
+
+    string = "this is a string"
+    string.slice!(2) # => i
+    string # => "ths is a string"
+    foo = "bar"
+    foo[0,1]
+    foo[0]
+    foo[1]
+
+## How can we test whether two String-objects are equal, in Ruby?
+
+  Use ==, as in:
+
+    "foo" == "foo"
+
+## How can we left-align or right-align a String in Ruby? (string padding)
+
+  Make use of <span class="s1">ljust</span> or
+  <span class="s1">rjust</span>.
+
+  Usage examples:
+
+    x = "blabla".ljust(50) # => "blabla"
+    x = "blabla".rjust(50) # => "blabla"
+
+## How can we find out whether a String, in Ruby, begins with a specific character, or several queried characters?
+
+  Use the method .start_with?(), as in:
+
+    'abcdef'.start_with?('e','a') # => true
+
+  It is also possible to determine whether a String begins with a number.
+
+  Example for this:
+
+    '45'.start_with? *'0'..'9'
+
+## How can we convert all spaces in a String into a single space each? (replaces runs of spaces with a single space, same char replace)
+
+  Use .squeeze() as in:
+
+    str = "  dsasdsdasg       &nbsp;&nbsp;&nbsp;&nbsp; egge"
+    str.squeeze(" ") # => " dsasdsdasg &nbsp;&nbsp;&nbsp;&nbsp; egge"
+
+## What is the purpose of the .squeeze() method?
+
+  .squeeze will remove all characters that occur more than
+  once in a given String.
+
+  An example for this:
+
+    'aabcdef'.squeeze # => "abcdef"
+
+  Documentation for .squeeze() can be found here:
+
+    https://ruby-doc.org/core-2.1.0/String.html#method-i-squeeze
+
+## How do we split a String (in Ruby) only on the first occurrence of a pattern?
+
+  Use .split() but also pass a number to it, as the second argument. That
+  number should be 2 specifically.
+
+  Example:
+
+    'I am, what you are not, pal'.split(',', 2) # => ["I am", " what you are not, pal"] 
+
+  As can be seen, this will create an Array with two members.
+
+## How do we format a string in Ruby?  (string format, beauty string, pretty string, string beautifyer, beauty tag))
+
+  One way is to make use of <b>Text::Format</b>. <b>Text::Format</b>
+  provides strong text formatting capabilities to Ruby.
+
+  It is based on Perl's <b>Text::Format</b> and offers all of the functionality
+  that the module does.
+
+  More generally though, in order to format a String in Ruby, you could use
+  a shortcut like this (differ between strings and integers!):
+
+    "%-9s" % "12251" # => "12251    "
+    "%9s"  % 12251   # => "    12251"
+    "%09d" % 12251   # => "000012251"
+    "%09d" % 3       # => "000000003"
+    "%03d" % 3       # => "003"
+    "%015d" % "123456" # => "000000000123456"
+    "%02d" % 4 # => "04"
+    "%.2f" % "33.3333333".to_f # => "33.33"
+    "%.3f" % "33".to_f         # => "33.000"
+    "%.3f" % "33.333".to_f     # => "33.333"
+
+  If the format specification contains more than one substitution,
+  then arg must be an Array containing the values to be
+  substituted.
+
+## How can we convert an ASCII Char into an Integer value?
+
+  Make use of the method <b>.ord()</b>.
+
+  Example:
+
+    "0".ord # => 48
+    48.chr  # => "0"','chr
+    "97".to_i.chr # => "a"
+
+## How to sort a String
+
+  Use:
+
+    "String".split(//).sort.join("")
+  
+  .split() works on regexes too, by the way.
+
+  The following example shows this:
+      
+    text = "foo bar far foo"
+    text.split /f/ # => ["", "oo bar ", "ar ", "oo"]
+
+## How can we upcase the first non-alpha character in a String?
+
+  Use a regex, and .sub(), as in:
+
+    '12ab'.sub /[a-z]/, &:upcase # => '12Ab'
+
+## Show an example where the method .empty? is used and how to query whether a String is empty or whether it is not
+
+    "foo bar".empty? # returns false
+    "".empty?        # returns true
+
+## How can we convert a String into an Array, with three characters each?
+
+    'abcdefghijkl'.chars.each_slice(3).each_slice(2).to_a.flatten(1) # => [["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"], ["j", "k", "l"]]
+
+## How do we remove everything but numbers from a string?
+
+    'abc123def456'.gsub(/\D/, '') # => "123456"
+
+## How can we delete the last 10 characters of a String?
+
+    string = 'abc def ghi jkl mno pqr'
+    string[-10 .. -1] = ''
+    string # => 'abc def ghi j'
+
+## How can we concatenate two Strings in ruby, without using <b>.join</b>?
+
+  Make use of <b>+</b>.
+
+  Example for this:
+
+    'Hello' + 'World' # => 'HelloWorld'
+    
+## What simple methods can be used for Strings in ruby
+
+    .capitalize
+    .reverse
+    .next
+    .upcase
+    .downcase
+    .swapcase
+  
+  See the following examples:
+
+    "heLoLLLo WoRLd".capitalize # => "Helolllo world"
+    "heLoLLLo WoRLd".reverse # => "dLRoW oLLLoLeh"
+    "hello world".next # => "hello worle"
+    "heLoLLLo WoRLd".upcase # => "HELOLLLO WORLD"
+    "heLoLLLo WoRLd".downcase # => "helolllo world"
+    "heLoLLLo WoRLd".swapcase # => "HElOlllO wOrlD"
+    "rentner-rennen".reverse.capitalize # => "Nenner-rentner"
+
+  Take note that .capitalize() upper-cases the <b>first
+  character</b>; the rest of the String will be small.
+      
+## How to delete a part of a String
+
+  Use <b>.delete()</b>.
+
+  Examples:
+      
+    "hello hello hello".delete("l","lo") # => "heo heo heo"
+    "hello hello hello".delete(" ") # => "hellohellohello"
+    "foobar".delete("o") # => "fbar"
+    "foobar\n okidokie".tr("\n",'')
+    "foobar rawr".delete "r"
+
+  It is also possible to use Rangers, and thus delete more parts
+  of a String:
+
+    str = "Bond, James Bond"
+    str.delete("a-z", "^n" ) #"Bn, J Bn"
+      
+  There also exists a <b class="lightgreen">.delete!</b> variant,
+  similar to how <b>.gsub</b> also has a <b>.gsub!</b>.
+      
+## How can we output Strings and Variables in Ruby 
+
+  For instance:
+      
+    print Lightred, " -Passed Args are ", $ARGV,"\n"
+
+  Also possible is:
+
+    bar = "test"
+    print "foo"+bar
+      
+  And of course, there is always puts, p, and pp as
+  well to output variables.
+
+## How to insert chars into a string, in Ruby?
+
+  Use:
+
+    puts 'abcdef'.insert(3,' ghi ') # => "abc ghi def"
+    puts 'abcdef'.insert(-1,'XXX') # => "abcdefXXX"
+
+  The last is the same as <b>.append</b>.
+
+Note however that the fastest way to append something is
+to simply use <b><<</b> and to avoid any #{} interpolation.
+
+Also note that <b>.append()</b> is not a method in standard-ruby -
+I simply found it convenit to have and think about this
+in terms of an append-operation.
+
+## How to query for string lengths and then output all characters past the 5th position
+
+    x = "dsasdsdasg egge"; x.length
+    "dsasdsdasg egge"[5..-1]
+    x[0..-1]
+
+## How to convert a string containing newlines into an Array
+
+    "string\ntest".lines # => ["string\n", "test"]
+
+## How can we obtain the last two characters of a String in ruby?
+
+    "string"[-2,2]
+
+## How to test whether a String is part of another String? (string contains, stringcont, is_in_string)
+
+  The method <b>.include?</b> can be used for this.
+  
+  Examples:
+
+    'Hello World'.include?('orl')
+    'x'.include? ' '
+    string = '40bla'
+    
+    # alternatively a regex can be used as well:
+
+    puts "Yes, it contains a number!" if string[/\d/]
+    puts "Yes, it contains a number!" if string =~ /\d+/
+
+## How do we center a String in Ruby?
+
+  Make use of the method called <b>.center()</b>.
+
+  Example:
+
+    "abc".center(12) # => "    abc     "
+
+## String .downcase versus .downcase! - which of these two is faster?
+
+  The .downcase! variant is faster than the .downcase variant. The
+  reason as to why this is the case, is because in the variant
+  without the !, a new object will be instantiated.
+
+## How can we prepend a String to another String?
+
+  There are at the least two possibilities.
+
+  The first one is .prepend(), which is available since as of
+  Ruby 1.9.3.
+
+  Example:
+
+    a = 'world'
+    a.prepend('hello ')
+    a # => "hello world"
+
+  Here we can see that the variable a has been modified.
+
+  Another way is to make use of a Regex, as is shown next:
+
+    a = 'test'
+    a[/^/] = 'prepended_'
+    a # => "prepended_test"
+
+  Note that <b>.prepend()</b> is faster than
+  <b>[0,0] = ""</b>.
+
+## How can we re-arrange a String in such as way as to change the words into the correct order?
+
+  Let us assume our starting String is this:
+
+    s = "order, wrong the in are words These"
+
+  Next, several possible solutions can be determined here.
+
+  One is to make use of .reverse and join:
+
+    s.split(/(\s+)/).reverse.join("") # => "These words are in the wrong order,"
+
+  We could also use \b rather than \s.
+
+  Note that .split() accepts more than one argument. This can potentially
+  be useful.
+
+    "1 2 3  4 ".split(/ /, -1) => ["1", "2", "3", "", "4", ""]
+
+## How can we store binary numbers in ruby?
+
+    octal = "\000\001\010\020"
+    octal.each_byte { |entry| puts entry } # => 0, 1, 8, 16
+      .each_byte is faster than .scan() by the way.
+
+  If we wish to convert a String into the Octal system
+  then we have to make use of <b>.to_i(8)</b>:
+
+    "0644".to_i(8)
+    "0755".to_i(8)
+    "01666".to_i(8) # => 950
+
+  This may be helpful when one wants to modify file permissions
+  on Linux.
+
+## How can we create a String without using .new, "" or '' single quotes?
+
+  Use %q() such as in:
+
+    %q( foo/bar ) # => " foo/bar"
+
+  Or alternatively use %Q() which will use string interpolation:
+
+    %Q()
+    %Q(Seconds/day: #{24*60*60}) # => "Seconds/day: 86400"
+
+## How would we determine whether a String contains only ASCII characters?
+
+  Use the method .ascii_only?() such as:
+
+    "dog".ascii_only? # true
+
+## How do we obtain hexadecimal numbers?
+
+  Use .hex, as in:
+
+    '0x0a'.hex # => 10
+
+  The reverse procedure would go like this:
+
+    '0x%0.2x' % 10
+    '10'.to_i.to_s(16)
+    '%#0.2x'
+
+## How can we pad a string with a specific character?
+
+  Use .ljust(), as in:
+
+    'abc'.ljust(5, 'x') # => "abcxx"
+
+## How can we display specific unicode characters?
+
+  All Strings (in Ruby) that begin with a \u will be
+  shown in UTF-8 encoding.
+
+  Example for this:
+
+    puts "Greek pi: \u03c0"
+
+## How can we remove leading and trailing whitespace from a String, including the trailng newline?
+
+  Use:
+
+    str.strip
+
+  as in
+
+    "  hello    world  ".strip # => "hello    world"
+    "\tgoodbye hello  \r\n".strip
+    "goodbye \000".strip
+    "goodbye \000   ".strip
+
+  The whitespace-characters are as follows:
+
+    space # aka ' '
+    tab (\t)
+    newline (\n)
+    linefeed (\r)
+    form feed (\f)
+
+## How can we replace a string completely, with another content?
+
+    s = 'abcdef'
+    s.replace "Hello World"
+
+## How do we determine whether two Strings are similar to one another?
+
+  For instance, 'hamlet' should be similar to 'hamlat' as well as
+  'hamlett', to some extent.
+
+  We can use the levensthein distance for that.
+
+## How do we use HEREDOC in Ruby?
+
+  The first use case goes as follows:
+
+    print <<HERE
+    HERE
+
+  Alternative we can also use a - character:
+
+    print <<-"TERE"
+    THERE
+
+  In the second case, the THERE part can be placed anywhere.
+
+## How do we determine the position of a character in a String?
+
+    "foo bar cii".index("c") # => 8
+
+  .index yields to us the position of a first substring.
+
+  This behaviour can be influenced via the second parameter
+  to .index(), such as in:
+
+    "fooxo".index(/o/, 3) # This would yield the third position of 'o' in this String.
+    x = '|abc| def'.index(/\|/, 2) # => 4
+
+  It is also possible to use .rindex in order to
+  obtain the right index - that is, the last position:
+
+    'fobor'.rindex('o') # => 3
+    'abc? def? ghi?".rindex '?' # => 13
+
+## How can we find out which character is before another character?
+
+  A regex can be used for this.
+
+  Example:
+
+    string = "abcdef////"
+    string[/(.)\//, 1] # => "f"
+
+    string = "Katze" # What is before the e character?
+    string[/(.)e/, 1] # => "z"
+
+## How can we count how often a specific character is part of a given String?
+
+    x = 'Bond, James Bond - I am a naughty boy.'
+    x.count 'aeiou'      # => 9
+    x.count 'a-z'        # => 23
+    x.count 'a-z', "^n"  # => 20
+
+## How can we split a string at every 80 chars? (80 char string break)
+
+    limit_at = 80
+    inp = "abc def"
+    puts ( "#{inp}" * 100 ).gsub(/(.{limit_at})/,"\\1\n")
+
+  Or another solution
+
+    x = "testfoxixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxssssssssssss " * 70
+    puts x.gsub(/(.{80})/,"\\1\n") # here for 80 chars...
+    puts x.gsub(/(.{0,80})(?=\b)/, "\\1\n")
+
+## Documentation for class String:
+
+  https://www.ruby-doc.org/core/classes/String.html
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## How does replace() work:
+
+Folgendes Beispiel zeigt nochmal wie .replace funktioniert:
+
+    a = [ "xxEins", "xxZwei", "xxDrei" ]
+    a.each do |s|
+        s.replace( s[2..-1] )
+    end
+    p a  # => ["Eins", "Zwei", "Drei"]
+
+Alle bestimmten Characters in einem String kann man mittels 
+      der .tr Methode ersetzen (die funktioniert also so wie .gsub):
+
+      'abcabc'.tr 'a','b' # => 'bbcbbc'
+      'LOWERCASE ALL VOWELS'.tr('AEIOU', 'aeiou') # => 'LoWeRCaSe aLL VoWeLS'
+      'Swap case of ALL VOWELS'.tr('AEIOUaeiou', 'aeiouAEIOU')
+      # rf ruby center_string
+
+
+Man übergibt dieser Methode einen Integer Wert, der der .center
+      Methode .center sagt, wie viele Chars centered werden. ->
+      center(lineWidth))
+
+Dies erlaubt es uns somit Text neu zu positionieren.
+
+Beispiel:
+
+    s = "some text"
+    "hello".center(20) # => "       hello        "','padding
+    s.center(15)
+    s.center 88
+    "abc".ljust(15) # => "abc            " # .lpad
+    "abc".rjust(20) # => "                 abc"
+
+Auch mit 0 aufpadden kann man:
+
+    37.to_s(2).rjust(8, "0") # => "00100101"
+
+
+
+
+## Wie kopiere ich ein String Objekt? (string copy)
+Ein String Objekt hält normalerweise nur eine Referenz, ist also 
+      nicht ein "echtes" Objekt.
+
+Will man ein String Objekt kopieren, muss man <b>.dup</b> verwenden.
+      Dies erstellt eine echte Kopie eines String Objekts.
+
+    person1 = "tim"
+    person2 = person1.dup
+
+Diese Methode, .dup (man kann auch .clone verwenden, das ist 
+      aber nicht ganz das selbe - für eigens erstellte Klassen ist
+      .clone besser)
+
+clone copies everything; internal state, singleton methods, and so on. 
+      dup copies <b>object contents only</b> (plus taintness status) method - the 
+      process of invoking .dup on an object - is called <b class="lightgreen">Shallow 
+      Copys</b> (flache Kopien) in ruby.
+
+This is a very important aspect of ruby, and it can be tricky if
+      you did not understand it.
+
+Lets consider another example
+
+    x = MySuperClass.new; y = x
+
+In this example, y now points at x. Thus you have "renamed" x.
+
+The Object#dup method will make a shallow copy of an object.
+      To achieve this, the dup method will call the initialize_copy
+      method of that class.
+
+Dies kann man verwenden um z. Bsp 2 nach "0x2" zu konvertieren:
+
+    i = 2; "0x#{i.to_s(16)}" # => 0x2
+
+## Wie teile ich meinen String in einen Array auf, der
+        verschiedene Wörter enthält? And how do I use .scan?
+        (str2array, string2array, string to array)
+  
+      array = "cruel world 123 /dev/sda3"
+      all_words = array.scan(/\w+/) # ["cruel", "world", "123"]
+      array.scan(/.../)             # => ["cru", "el ", "wor", "ld ", "123", " /d", "ev/", "sda"]
+      array.scan(/(...)/)           # => [["cru"], ["el "], ["wor"], ["ld "], ["123"], [" /d"], ["ev/"], ["sda"]]
+      array.scan(/(..)(..)/), #,[["cr", "ue"], ["l ", "wo"]]
+      array.scan(/\/dev\/sd.*/)
+  
+  Scan ist sehr flexibel, liefert aber zum Teil auch einen
+        verschachtelten Array. Dies muss man dann mit .flatten 
+        korrigieren:','','scan
+  
+      x = "foo: bar\nbla: fii\nxx"
+      x.scan(/^.*?: (.*?)$/m).flatten #["bar ", "fii"]
+      x.scan(/^.*?: (.*?)\s*$/m).flatten #["bar", "fii"]')
+
+
+## "How do I compare two strings, casecompare them, and on
+      a related note, how do I sort this string (stringsort,string sort)?
+      e(
+        sg('PROGRAMMING_LANGUAGES/RUBY/SORTING.png','pad5px marl2em')
+      )+
+    x = "blabla"
+    y = "blabla"
+    y.casecmp(x) # return 0
+
+If return 0, strings are equal.
+Otherwise, either the one, or the other, is longer.
+To compare, use &#60;=&#62;
+If it is equal, the result is 0,
+      if left side comes after the right side (alfabet) then it is +1,
+      else if left side comes earlier, it is -1.
+
+Auf Deutsch, von links nach rechts, wenn es im Alphabet ist,
+      ist es -1, ansonsten +1.
+
+    "Ruby" == "Ruby"                  # - true
+    "Ru"+"by" == "Ruby"               # - true
+    "Ruby" &#60;=&#62; "Ruby"         # - 0
+    "Ruby" &#60;=&#62; "Objective-C"  # - 1
+    "Ruby" &#60;=&#62; "ruby"         # - -1
+    "Axone" &#60;=&#62; "Zeus"        # - +1
+
+Belated, you can use the Module <b>Comparable</b>. 
+
+Examples:
+
+    3.between?(1,7)
+    8.between?(1,7)
+    "cat".between?("ant","dog")
+
+One more example:','comparable
+
+    class CompareOnSize
+    include Comparable
+    attr :str
+    def <=>(other)
+        str.length <=> other.str.length  
+    end
+    def initialize(str) 
+        @str = str
+      end
+    end
+    s1 = CompareOnSize.new("Z")
+    s2 = CompareOnSize.new([1,2])
+    s3 = CompareOnSize.new("XXX")
+    s1 < s2
+    s2.between?(s1, s3)
+    s2.between?(s1,s2)
+    [s3,s2,s1].sort
+
+Instead of == you can use egl? as well.
+
+## "How do I replace occurences of foo in the string str? How do
+      I make word censors? (This can be used to replace arbitrarray chars
+      within a string too by the way) (replace string)
+
+In general:
+
+  gsub( /pattern/, replacement)
+
+      cmd("'strfoo'.gsub(/[aeiou]/, '*') ,#results to  'strf**'
+    "strfoo".gsub(/([aeiou])/, \'&#60;\1&#62;\')
+    #results to  "strf&#60;&#62;&#60;o&#62;"
+    "str   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;    foo".gsub(/( )/, \'\')
+  #results to  "strf&#60;o&#62;&#60;o&#62;"
+
+ { # .unpack bekommt sein eigenens div. Unpack tag
+  ## Was macht .unpack?(s)','unpack # rf ruby unpack
+  Decodes <b class="lightgreen">s</b>r (which may contain binary data) 
+        according to the format string, returning an array of each value extracted.
+  
+  The format string consists of a sequence of single-character directives.')
+
+Each directive may be followed by a number, indicating the number 
+  of times to repeat with this directive. An asterisk (*) will use up 
+  all remaining elements. The directives sSiIlL may each be followed by 
+  an underscore (_) to use the underlying platforms native size for the 
+  specified type; otherwise, it uses a platform-independent consistent 
+  size. Spaces are ignored in the format string.  
+  Directives for String#unpack
+    Format   Function   Returns
+    A String with trailing nulls and spaces removed. String
+    a String.   String
+    B Extract bits from each character (msb first).  String
+    b Extract bits from each character (lsb first).  String
+    C Extract a character as an unsigned integer.   Fixnum
+    c Extract a character as an integer.   Fixnum
+    d Treat sizeof(double) characters as a native double.   Float
+    E Treat sizeof(double) characters as a double in little-endian byte order.   Float
+    e Treat sizeof(float) characters as a float in little-endian byte order. Float
+    f Treat sizeof(float) characters as a native float.   Float
+    G Treat sizeof(double) characters as a double in network byte order.   Float
+    g Treat sizeof(float) characters as a float in network byte order.   Float
+    H Extract hex nibbles from each character (most significant first).   String
+    h Extract hex nibbles from each character (least significant first).   String
+    I Treat sizeof(int) 1 successive characters as an unsigned native integer.   Integer
+    i Treat sizeof(int) 1 successive characters as a signed native integer.   Integer
+    L Treat four1 successive characters as an unsigned native long integer.   Integer
+    l Treat four1 successive characters as a signed native long integer.   Integer
+    M Extract a quoted-printable string.   String
+    m Extract a base64 encoded string.   String
+    N Treat four characters as an unsigned long in network byte order.   Fixnum
+    n Treat two characters as an unsigned short in network byte order.   Fixnum
+    P Treat sizeof(char *) characters as a pointer, and return len characters 
+       from the referenced location.   String
+    p Treat sizeof(char *) characters as a pointer to a null-terminated string.   String
+    S Treat two1 successive characters as an unsigned short in native byte order.   Fixnum
+    s Treat two1 successive characters as a signed short in native byte order.   Fixnum
+    U Extract UTF-8 characters as unsigned integers.   Integer
+    u Extract a UU-encoded string. String
+    V Treat four characters as an unsigned long in little-endian byte order. Fixnum
+    v Treat two characters as an unsigned short in little-endian byte order. Fixnum
+    X Skip backward one character.   
+    x Skip forward one character. 
+    Z String with trailing nulls removed.   String
+    @ Skip to the offset given by the length argument.
+    1 May be modified by appending _ to the directive.
+      div {
+  
+  Beispiele zu <b>.unpack</b>:
+  
+      "abc \0\0abc \0\0".unpack("A6Z6")   ["abc", "abc"]
+      "abc \0\0".unpack("a3a3") #  ["abc", " \000\000"]
+      "aa".unpack("b8B8")   #   ["10000110", "01100001"]
+      "aaa".unpack("h2H2c") #   ["16", "61", 97]
+      "\xfe\xff\xfe\xff".unpack("sS")   [-2, 65534]
+      "now=20is".unpack("M*")   ["now is"]
+      "whole".unpack("xax2aX2aX1aX2a")   ["h", "e", "l", "l", "o"]')
+
+
+    # Sprintf tag. rffruby sprintf
+  ## Wie verwende ich <b>sprintf</b>?','sprintf
+      puts sprintf( "Test: %-20s %-20s %-20s", "Joe", "Doe", "022-2222" )
+  
+  In diesem Beispiel teilt der <b>-</b> Operator dem Interpreter das
+        Ergebnis an die linke Seite zu stellen, und die 20 bedeutet das man
+        die textarea.länge auf 20 Zeichen setzt.
+  
+  Hier gibt es weitere Beispiele:
+  
+      counter = 1; sprintf("%02d", counter)          # => "01"
+      sprintf("%d %04x", 123, 123)                   # => "123 007b"
+      sprintf("%1$*2$s %2$d %1$s", "hello", 8)       # => "   hello 8 hello"
+      sprintf("%1$*2$s %2$d", "hello", -8)           # => "hello    -8"
+      sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23)       # => "+1.23: 1.23:1.23"
+      sprintf("%03d", "1")                           # => "001"
+      sprintf("%03f", "123")                         # => "123.000000"
+      sprintf("%-20s %s", "[ac]res for", "15 gold.") # => "[ac]res for          15 gold."
+      [200,0,0].map{|i|"%0.2x" % i}.join # => "c80000" # A hexstring
+      ("%0.2x" * 3) % [200,0,0]
+  
+  If you want, you could use something silly like this: 
+  
+    def beautify_string(inp1, inp2)
+       sprintf("%-20s %s",inp1,inp2)
+    end
+  
+    beautify_string("GAh jslskljdsdjl","haeh?")
+  
+        Also be aware that you can use this in for example a
+        constant too, and then apply printf formatting to it (%s).')
+
+## Wie bekomme ich bestimmte Meta-Characters?
+
+      table2('mars1em','','',
+        '?a # => "a"','ASCII character',
+        '?\n # => "\n"','newline 0x0a',
+        '?\C-a # => "\x01"','control a = 0x65',
+        '?\M-a # => "\xE1"','meta set bit 7',
+        '?\M-\C-a','meta and control a'
+      )
+
+## Wie kann ich einen String in Ascii 8-Bit umwandeln?
+    "win+\xC3\x9F".b
+
+      Alternative geht auch der ältere Weg,
+      mittels <b>force_encoding(Encoding::ASCII_8BIT))</b>
+
+
+
+
+
+Die Modes für Strings in ruby sind: <b>r,r+,w,w+,a,a+,b</b>
+
+      table2('s1em mar2px bblack1 marl2em','','TableRubyModeStrings',
+        '<b>Mode</b>','<b>Meaning</b>',
+        '<span class="marl2em">r</span>','read only, default mode, SOF',
+        '<span class="marl2em">r+</span>','read and write, SOF',
+        '<span class="marl2em">w</span>','write only, create new 
+         file or truncate existing file to 0',
+        '<span class="marl2em">w+</span>','read and write,
+         truncates existing file to 0',
+        '<span class="marl2em">a</span>','<b>Write-only</b>,
+         append only at EOF <b>if</b> file exists, 
+             <b>otherwise</b> creates new file',
+        '<span class="marl2em">a+</span>','read and write, starts at EOF if file exists, 
+         otherwise creates new file for read and write',
+        '<span class="marl2em">b</span>','binarray file mode für DOS and Windows',
+        '<span class="marl2em">wb</span>','write binarray file mode' 
+   
+