roebe 0.5.109

data/lib/roebe/documentation/array.rb

@@ -0,0 +1,1100 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module Roebe::Documentation
+
+  # ========================================================================= #
+  # === Roebe::Documentation.array
+  #
+  # ARRAYS array tag arrays tag
+  #
+  #   rf ruby arrays
+  #
+  # ========================================================================= #
+  def self.array
+    div(css_class: 'outer_div') {
+    div(css_class: 'default', id: __method__.to_s) {
+      h2(__method__)+
+      br+
+      frage('Was für einen Vorteil hat es einen Array anstatt eines Hashes
+      zu verwenden?')+
+      e('Ein Array ist effizienter (und somit schneller) als ein Hash.')+
+      frage('Wie füge ich neue Einträge an ein Array hinzu? (array push)','array')+
+      e('Ähnlich wie in der Programmiersprache Perl, kann man in Ruby
+      folgende Methoden verwenden:')+
+      br+
+      cmd('join, push, pop,insert or to say, array.join, array.push, 
+      array.pop, array.insert, array.shift')+
+      br+
+      e('.pop <b>entfernt</b> das letzte Element eines Array (und
+      gibt es wieder).')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('  a = ["a","b"] # => ["a", "b"]')+
+      cmd('  a.pop # => "b" # Das "Gegenteil" von pop ist übrigens
+      <b>.shift</b>')+ # .shift
+      cmd('  a     # => ["a"]')+
+      br+
+      e('<span class="col">.push</span> fügt das Element am 
+      <b class="yel">Ende des Arrays hinzu</b>
+      (muss man aber nicht verwenden, es existiert ja auch noch
+      &#60;&#60; ist sogar schneller als .push)')+
+      br+
+      anm('Jedoch kann man mittels .push mehrere Elemente auf einmal
+      hinzufügen, &#60;&#60; hingegen erlaubt es einem nur jeweils
+      ein Element hinzuzufügen.')+
+      br+
+      e('<span class="col">.pop</span> <b class="yel">entfernt das letzte Objekt</b>')+
+      br+
+      e('<span class="col">.last</span> <b class="yel">sagt was an letzter
+      Stelle im Array vorkommt</b>, aber verändert nichts. .last() akzeptiert
+      auch Argumente.')+
+      br+
+      e('Mittels <span class="col">.length</span> sieht man wie lange ein 
+      Array ist. (Das alias zu .length ist .size. Ich verwende in meinem
+      Code ausschliesslich <span class="col">.size</span>)')+
+      br+
+      e('<span class="col">.insert</span>(position,value) lets you add anything
+      to the array at any position you want to by putting the value at
+      position, and moving everything else behind that position by
+      +1. (insert(0,nil)). Allerdings bevorzuge ich [] statt 
+      insert.')+
+      br+
+      e('Mittels <span class="col">.shift</span> entfernt man 
+      <b class="yel">das erste Element eines Array und gibt es wieder</b>. 
+      (The other elements are shifted down by one).')+
+      br+
+      e('Mittels <span class="col">.unshift</span> wird das Objekt zu 
+      <b class="s1 yel">Beginn des Array hinzugefügt</b> (quasi
+      ein <i class="bold">left-add</i>):')+
+      br+
+      cmd('  a = [ "b", "c", "d" ]')+
+      cmd('  a.unshift("z") # => ["z", "b", "c", "d"]')+
+      cmd('  a.unshift 1, 2 # => [ 1, 2, "a", "b", "c", "d"]')+
+      cmd('  array = [ "a", "b", "c" ]')+
+      cmd("  %w( b c d ).unshift 'a' # => ['a', 'b', 'c', 'd']")+
+      br+
+      e('Mittels <b>push</b> fügt man am <b>Ende des Array</b> hinzu:','','array_push')+
+      br+
+      cmd('  array.push("d", "e", "f") # => leads to  ["a", "b", "c", "d", "e", "f"]')+
+      br+
+      anm('Ich finde << ist aber besser.')+
+      br+
+      cmd('  array << ("d", "e", "f")')+
+      br+
+      e('<b>.join()</b> ist immer dann wichtig wenn man Elemente eines
+      Arrays miteinander verknüpfen möchte.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('  array = [ "a", "b", "c" ]')+
+      cmd('  array.join(" - ") # leads to "a - b - c"')+
+      cmd('  array * " - " # leads to "a - b - c", is an alias to .join')+
+      br+
+      anm('* auf Array angewandt ist ein Alias zu .join')+
+      br+
+      a('http://www.ruby-doc.org/core-2.1.0/Array.html#method-i-join')+
+      br+
+      e('Die genannten Commands sind keine Funktionen sondern 
+      Methodenaufrufe, wobei wir hier self. weglassen 
+      können.')+
+      br+
+      e('Sie sehen Funktionen natürlich ähnlich.')+
+      br+
+      frage('Wie zeige ich Elemente des Array an?')+
+      br+
+      e('Heisst der Array <b>foo</b>, so kann man das erste Element im Array
+      wie folgt ansprechen:')+
+      br+
+      cmd('  foo[0]')+
+      br+
+      e('Das zweite Element mittels:')+
+      br+
+      cmd('  foo[1]')+
+      br+
+      e('Und so weiter und so fort. Formel ist: n-1, Element Nummber 10
+      wird also mittels foo[9] angesprochen.')+
+      br+
+      e('Zur Ausgabe kann man puts verwenden:')+
+      br+
+      cmd('  puts foo[1]')+
+      br+
+      frage('Wie erhalte ich ein zufälliges Element des Array? (rand tag)')+
+      cmd('  [1,2,3].sample')+
+      br+
+      anm('Die <b>.shuffle</b> Methode mischt den Array neu. Und 
+      mit .first geben wir einfach das erste Element wieder.')+
+      br+
+      e('Es gibt übrigens auch die <b>.shuffle!</b> Methode.')+
+      br+  
+      frage('Wie kann ich einen Array mit Index nutzen?')+
+      cmd('  array = ["5",5,222]')+  
+      cmd('  array.each_with_index { |item, index| puts "  "+index.to_s + " => " + item.to_s }')+
+      br+
+      e('Man kann auch mittels des Range Objekt einen Array erstellen,
+      wie folgendes Beispiel demonstriert, indem man die <b>.to_a</b>
+      Methode aufruft:')+
+      br+
+      cmd('  array = (0..20).to_a # => [0, 1, 2, 3, 4, 5, 6, 7,
+      8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]')+
+      br+
+      frage('Wie entferne ich die ersten 3 Elemente eines Array?')+
+      cmd('  a = [1, 2, 3, 4, 5, 0]')+
+      cmd('  a.drop(3) # => [4, 5, 0]')+
+      br+
+      anm('.drop() entfernt immer eine Range. Will man nur ein bestimmtes
+      Element entfernen kann man .delete_at() anwenden.')+
+      br+
+      e('Dies geht allerdings erst ab Ruby 1.8.7.')+
+      br+
+      frage('Ich will bestimmte Elemente aus einem Array rauswerfen - wie 
+      mache ich das? (Conditionally remove items from an array based 
+      on the items .length?)')+
+      br+
+      cmd('  (1..30).reject {|i| i % 4 == 0 } # =>
+      [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17, 18, 19,
+      21, 22, 23, 25, 26, 27, 29, 30]')+
+      br+
+      cmd('  %w( cat dog monkey ).reject {|s| s.size > 4 } # => ["cat", "dog"]')+
+      br+
+      frage('Ich habe einen Array und ich will schauen ob dieser Array einen
+      String hat, der einen bestimmten Substring enthält. Wie mache ich
+      dies? (array include)')+
+      br+
+      cmd('  array = ["cat","dog","help"]')+
+      cmd('  array.each { |t| puts t if t.include?("do") }')+
+      br+
+      e('Oder mittels .select')+
+      br+
+      cmd('  array.select { |t| t if t.include?("do") } # => ["dog"]')+
+      br+
+      frage('Wie konkateniere/flatten ich die ersten beiden Elemente eines Array?')+
+      cmd('  x = ["cat","dog","horse"]')+
+      cmd('  x[0] += x[1]')+
+      cmd('  x.delete_at(1); x # => ["catdog", "horse"]')+
+      br+
+      frage('Wie entferne ich alle <b>nil</b> aus einem Array?')+
+      br+
+      e('Man verwendet hierzu die Methode <b>.compact</b>.')+
+      br+
+      cmd('  array.compact!')+
+      br+
+      frage("Wie mache ich einen String, der aus einem Array gebastelt wird, 
+      und verschiedene Zeichen dazu erhalten kann?")+
+      cmd('  array = ["foo","bar"]')+
+      cmd('  array.map {|s| s.dump}.join(",") # => ""foo","bar""')+
+      br+
+      e('oder')+
+      br+
+      cmd('  %w( foo bar fee faa ).map {|s| s.dump}.join(" <----> ") # => 
+      "foo" <----> "bar" <----> "fee" <----> "faa"')+
+      br+
+      frage('Wie lösche ich ein Array Member an einer bestimmten
+      Position? (remove member at position)')+
+      br+
+      e('Am besten geht dies mittels <b>.delete_at</b>.')+
+      br+
+      cmd('  array = ["a","b","c","d"]')+
+      cmd('  array.delete_at(0) # => ["b", "c", "d"]')+
+      cmd('  array = ["ant", "bat", "cat", "dog"]')+
+      cmd('  array.delete_at(2) # => "cat"')+
+      cmd('  array # => ["ant", "bat", "dog"]')+
+      br+
+      frage('Was ist mit pack und unpack? (Array.pack, Array.unpack)','pack')+
+      e('Das ganze ist ein wenig komplizierter ...')+
+      br+
+      e('Zuerst einmal sollte man folgende <b class="lightblue">Tabelle</b>
+      studieren, um diese Art Code entschlüsseln zu können:')+
+      br+
+      table3('marr1em marl1em martb1em s1_5em BG_White Black','','',
+        '<b>Format</b>','<b>Function</b>','<b>Returns</b>',
+        '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.','   ---'
+      )+
+      frage('Wie reversiere ich einen Array? (drehe ihn also um)')+
+      cmd('  ["foo","bar","fii"].reverse')+
+      br+
+      # Array to hash
+      frage('Wie konvertiere ich einen Array in einen Hash? Die neuen Hash Keys
+      sollen wie die Array Members sein, so das ein Array wie ["a","b"] ein Hash
+      in dieser Form {"a"=>"a","b"=>"b"} sein sollte (array to hash, array2hash,
+      to_hash, array_to_hash)')+
+      br+
+      cmd('  array.inject(Hash.new) { |h, i| h[i] = i }')+
+      br+
+      e('oder')+
+      br+
+      cmd('  array = %w( a b c d); hash = Hash[*array.zip(array).flatten]')+
+      cmd('  Hash[ *[1,2,3,4] ] # => {1=>2, 3=>4}')+
+      cmd('  Hash[[["code", "01"], ["value", "02"]]] # => {"code"=>"01", "value"=>"02"}')+
+      br+
+      e('Oder noch besser:')+
+      br+
+      cmd('  Hash[*"foo,bar,xyz,123".split(",")] # => {"xyz"=>"123", "foo"=>"bar"}')+
+      br+
+      e('Ein weiteres Beispiel:')+
+      br+
+      cmd('  a.inject({}) { |m,o| m.merge o }')+
+      br+
+      frage('Wie merge ich einen hash?(merge hash, hash merge, merge 
+      tag)','merge_hash')+ # merge tag
+      cmd('  h1 = { "a" => 100, "b" => 200 }')+
+      cmd('  h2 = { "b" => 254, "c" => 300, "d" => 400 }')+
+      cmd('  h1.merge(h2) # => {"a" => 100, "b" => 254, "c" => 300, "d" => 400}','merge')+
+      cmd('  h1           # => {"a" => 100, "b" => 200}')+
+      br+
+      e('Man braucht <b>.merge!</> um diese Änderungen "permanent" zu machen.')+
+      br+
+      e('Obacht - wenn ein Key in beiden Hashes vorhanden 
+      ist, dann wird der erste Key <b>überschrieben</b>!')+
+      br+
+      e('Hash.update ist Hash.merge recht ähnlich:', id: 'hash_update')+ # rf ruby hash_update
+      br+
+      cmd('  h1 = { "a" => 100, "b" => 200 }')+
+      cmd('  h2 = { "b" => 254, "c" => 300, "d" => 400 }')+
+      cmd('  h1.update(h2) # => {"a"=>100, "b"=>254, "c"=>300, "d"=>400}')+
+      br+
+      e('Man erkennt, das der Wert von b mittels update überschrieben wurde 
+      - update ist also genau wie merge, ausser das <b>update die Werte 
+      überschreibt</b> während merge dies nicht tut.')+
+      br+
+      anm('Und um das ganze dauerhaft zu implementieren, verwendet
+      man <b>.merge!</b>')+
+      br+
+      # ========================================================================= #
+      # === Joining an Array.
+      # ========================================================================= #
+      frage('Gibt es eine <b>Array.join_by_array</b> Methode?')+
+      e('Ja, indirekt - über <b>.zip</b>','','zip')+
+      br+
+      cmd('  ["a","b","c","d"].join_by_array(["1","2"])')+
+      cmd('  ["a","b","c","d"].zip ["1","2"]) # => 
+      [["a", "1"], ["b", "2"], ["c", nil], ["d", nil]]"')+
+      br+
+      e('Mittels <b>.zip</b> kann man zwei Arrays kombinieren (das
+      Reissverschlussverfahren):')+
+      br+
+      cmd('  a = [1,2,3]')+
+      cmd("  b = ['a','b','c']")+
+      cmd('  a.zip(b) # => [[1, "a"], [2, "b"], [3, "c"]]')+
+      br+
+      # ========================================================================= #
+      # Wie mache ich einen Array "kleiner":
+      # ========================================================================= #
+      frage('Wie kann ich einen Array, der andere Arrays enthält,
+      auf einen Array bringen?')+
+      br+
+      cmd('  array.flatten! oder array.flatten')+
+      br+
+      anm('.flatten akzeptiert ein Argument, <b>level</b> genannt.
+      Am besten sieht man sich folgendes Beispiel an um zu verstehen
+      wie .flatten mit Argument funktioniert.')+
+      br+
+      cmd('  a = [[1, 2, 3], 3, [[2224, 4412421]]]')+
+      cmd('  a.flatten 1 # => [1, 2, 3, 3, [2224, 4412421]]')+
+      br+
+      e('Man sieht, der ursprüngliche Array wurde nur einmal geflattened.')+
+      br+
+      frage('Was macht .any?')+
+      br+
+      cmd("  Returns true if the block is true for any of the array's elements")+
+      cmd("  $ary.any? {|_| _.include? 'a'} # => true")+
+      br+
+      e('Damit kann man auch partial includes durchführen:')+
+      br+
+      cmd("  ['[]', '[DONE]', 'DONE'].any? { |x| x =~ /DO/ } # => true")+
+      cmd("  array = %w( abc def ghi$ ).any? {|entry| entry.include? '$' } # => true")+
+      br+
+      frage('Wie lösche ich jedes 2. Element in einem Array?')+
+      cmd('  array = [ 2,251152,512152,51252,2552,52,5252 ]')+
+      cmd('  flag = true')+
+      cmd('  puts array.delete_if { flag = (not flag) }')+
+      br+
+      frage('Wie initialisiere ich einen Array using weird syntax?')+      
+      cmd('  x = [ [] ] * 5 # => [[], [], [], [], []]')+
+      br+
+      e('Eine andere Art einen Array aufzufüllen ist diese hier:')+
+      br+
+      cmd('  list_of_var_names.each {|v| instance_variable_set("@#{v}", "") }')+
+      br+
+      frage('Was macht Array.map?')+
+      br+
+      e('Es ist ein Synonym für collect. Beide tun folgendes:')+
+      br+
+      s2('Invokes block once for each element of arr, replacing the 
+      element with the value returned by block. (It only does a 
+      real replacing if ! is used)','lightblue s2em BLOCK BO')+
+      br+
+      e('Mit anderen Worten wird etwas auf jedes Element eines Array 
+      angewendet, und dann der neue Array zurückgegeben.')+
+      br+
+      anm('Die .map Methode ist im module Enumerable definiert. 
+      Hash und Range enthalten ebenso die Enumerable method.')+
+      br+
+      e('A good yet easy way to use it is to calculate something, like
+      multiplying each element of an array with 5, and getting the 
+      result)','lightblue BO')+
+      br+
+      cmd('  a = [ "a", "b", "c", "d" ]')+
+      cmd('  a.map! {|x| x + "!" } # leads to ,["a!", "b!", "c!", "d!"]')+
+      cmd('  a,  # ["a!", "b!", "c!", "d!"]')+
+      cmd('[1,2,3].map {|e| e * 3 }   # => new array: [3,6,9]')+
+      cmd('[3,12,53].map {|e| e * 5 } # => new array:  [15, 60, 265]')+
+      br+
+      frage('Wie teile ich einen Array auf und gebe die Mitglieder an 
+      eine Methode?')+
+      br+
+      cmd('  method(*[a, b, c])')+
+      br+
+      e('Dies ist das gleiche wie:')+
+      br+
+      cmd('  method(a, b, c)')+
+      br+
+      frage('Wie mache ich 3-dimensional Arrays?')+
+      br+
+      cmd('  pp a = Array.new(3) { Array.new(4) { Array.new(7) } }')+
+      br+
+      frage('Wie mache ich ein Array, including using a Range object and 
+      additionally how do I verify the class of a var?')+
+      br+
+      e('Use [], as in')+
+      br+
+      cmd('  array = [1, 2, "3"]')+
+      br+
+      e('oder')+
+      br+
+      cmd('  array = [% w(1 2 "3") ]')+
+      br+
+      e('The [] is a shortcut for this')+
+      br+ 
+      e('<i class="BO gold">Array.[](position1,position2)</i>
+      and so on')+
+      br+
+      e('To find out about the class use varname.class, as in')+
+      br+
+      cmd('  puts array.class')+
+      br+
+      e('If you need to use the index, you can use')+
+      br+ 
+      e('.each_with_index (each_with_key...)','yel')+
+      br+
+      frage('How can I get multidimensional arrays?')+
+      e('Hier gibt es mehrere Wege. ')+
+      br+
+      e('Der erste Weg geht über die <b>Matrix</b> Klasse:')+
+      br+
+      cmd("  require 'matrix'")+
+      cmd('  Matrix.I(3)')+
+      cmd('  Matrix[[0,1],[2,0]] * Vector[1.2,3.4]')+
+      br+
+      frage('Wie addiere ich [1,2] mit [2,3] zu [3,5]?')+
+      br+
+      cmd('   Matrix[[1],[2]] + Matrix[[2],[3]] # => Matrix[[3], [5]')+
+      br+
+      e('Another way is to use the ArrayMD extension of the Array class. 
+      Look at my custom_functions.rb file. Here is an example that stores 
+      a 8 / 8 chess map.')+
+      br+
+      cmd('array_storing_all_fields = ArrayMD.new')+
+      cmd('i = 1')+
+      cmd('y = 1')+
+      cmd('64.times do ' )+
+      cmd2('  array_storing_all_fields[y][i] = "da is was"+rand(2892892).to_s ')+
+      cmd2('  if i % 8 == 0')+
+      cmd3('    i = 0')+
+      cmd3('    y += 1')+
+      cmd2('  end')+
+      cmd2('  i += 1 ')+
+      cmd('end')+
+      br+
+      frage('Wie teste ich, ob ein Array i einem anderen Array inkludiert
+      ist?')+
+      br+
+      e('Verwende dies')+
+      br+
+      cmd("  array1 = ['fred','peter','janning']")+
+      cmd("  array2 = ['joe','peter','frank','jimbo']")+
+      cmd('  array1.each do |item|')+
+      cmd2('  if array2.include? item')+
+      cmd3('    puts "   Listing found in the Array that has these 
+      members -- #{array1} == Found this item: #{item} =="')+
+      cmd2('  end')+
+      cmd2('  puts')+
+      cmd2('  puts')+
+      cmd('end')+
+      br+
+      frage('Ich will je 3 Member eines Array ausgeben, 
+      wie geht dies?','array_members')+ # rf ruby array_members
+      e('Verwende das hier:')+
+      br+
+      cmd('  num.step(limit, step) { |i| block }','step')+
+      cmd('  0.step($ary.size, 3) do |x| p $ary[x, 3] end' )+
+      cmd('  0.step(3) { |x| p $ary[x, 3] }')+
+      cmd('  (100 .. 500).step(55) {|x| print x,", "} # => 100, 
+      155, 210, 265, 320, 375, 430, 485, # => 100..500')+
+      cmd('  array = [1, 2, 3, 4, 5, 6]; array.slice(2)')+
+      br+ 
+      frage('How do I get the even numbers from an 
+      array? (even numbers, odd numbers)')+
+      cmd('  array = [1,4,6,22,31,51]')+
+      cmd('  array.map {|i| i % 2 == 0 }')+
+      br+
+      e('oder')+
+      br+
+      cmd('  array.select { |i| i % 2 == 0 }','select')+ # rf ruby select
+      cmd('  (1..10).select { |i| i % 2 == 0 } # => [2, 4, 6, 8, 10]')+
+      br+
+      e('Oder noch kürzer:')+
+      br+
+      cmd('  (1..10).select { |i| i.even? }')+
+      cmd('  (1..10).select { |i| i.odd? }')+
+      br+
+      e('Mit <b>.select</b> wählt man Elemente aus dem Block aus, 
+      für <b>die die Bedingung true ist</b>.')+
+      br+
+      e(' Das folgende Beispiel gibt alle Nummern zurück die 
+      durch 3 teilbar sind, und zwar von 1 bis 5000')+
+      br+
+      cmd('  (1..5000).select {|i| i % 3 == 0 } # Wählt 3,6,9,12
+      etc.. aus')+
+      br+
+      frage('How can I check whether something is included in 
+      an array or not? (inarray, is in array, in_array)')+
+      cmd('  a = [ "a", "b", "c" ] #')+
+      cmd('  a.include?("b") # true')+
+      br+
+      e('If you want to do this for an object called x and the array y')+
+      br+
+      cmd('  y.member?(x)')+
+      br+
+      frage("I am used to perl's qw(). How to make this in ruby? Is
+      there a shortcut for creating arrays? (quoted words)")+
+      cmd('  x = %w(63 362 63632 dog cat)')+
+      br+
+      e('The lowercased %w extracts space-separated 
+      tokens into array elements.')+
+      br+
+      e(' The uppercased %W does double-quoted string subtiutions. 
+      Useful if you want to use variables.')+
+      br+
+      e('Beispiel für %W:')+
+      br+
+      cmd('x=%W(  one two -#{Time.now}-)')+
+      br+
+      frage('Wie suche ich nach einem String in einem Array?','grep')+
+      cmd('  array = ["one","two","three","four"]')+
+      cmd('  array.grep("three")')+
+      br+
+      frage('How do i output array member 12 to 24?')+
+      cmd('  array[12,24]')+
+      br+
+      frage("I got an array filled with strings. I want to output the 
+      strings that are larger than LIMIT chars. How?")+
+      cmd('LIMIT = 5')+
+      cmd('array = [ "hin", "hoe","yodelyo","makutatete" ]')+
+      cmd('puts array.find_all { |e| e.size > LIMIT }')+
+      br+
+      e('To complete it , there is another way using case but this 
+      one is not so nice...')+
+      cmd('array.each do |e|; case e.size; when 4; #....; end; end')+
+      br+
+      frage("If I have an array of integers, how can i find out 
+      which one is the highest one before a limes number? And 
+      which one is the highest one in a group of integers")+
+      e('Hmm. Mach daraus eine Klasse:')+
+      br+
+      cmd('class Array ')+
+      cmd('  def count(&action) ')+
+      cmd2('    count = 0 ')+
+      cmd2('    self.each { |v| count = count + 1 if action.call(v) }')+
+      cmd2('    return count ')+
+      cmd('  end ')+
+      cmd('  end')+
+      br+
+      cmd('  a = Array[1, 2, 3, 2,22,4,24, 5, 6, 7, 8, 9, 10]')+
+      cmd('  puts a.count { |v| v < 5 }')+
+      br+
+      e('This is the same as this by the way (Enumerable#find_all):')+
+      br+
+      cmd('  a = (1..10).to_a')+
+      cmd('  puts a.find_all {|v| v < 5 }.size')+
+      cmd('  x = $iarray.inject do |y,z|')+
+      cmd2('    y > z ? y : z')+
+      cmd('  end')+
+      br+
+      e('Or use <b>array.max</b>')+
+      br+
+      anm('<b>.select</b> ist ein alias zu .find_all, und wohl
+      auch gebräuchlicher.')+
+      br+
+      e('You can also use the dot notation to re-index an 
+      existing array, for example:')+
+      br+
+      cmd('a = [1,3,5,7,9]')+
+      cmd('a[1..4] # leads to [1,3,5,7]')+
+      br+
+      e('If you would have used a[1...4] instead,
+      then the last number would not have been included.')+
+      br+
+      e("I have an array consisting of numbers. How can I 
+      make the sum and product of those numbers?")+
+      br+
+      e('Use inject, as in')+
+      br+
+      cmd('[1,3,5,7,9,22].inject(0) {|sum, element| sum+element}')+
+      br+
+      e('# and for the product')+
+      br+
+      cmd('[1,3,5,7,9,22].inject(1) {|product, element| product*element}')+
+      br+
+      e('Inject must be set to 1 for the first time because it is the
+      multiplier. If it is 0, no output will be generated - 0 * anything
+      is still 0.')+
+      br+
+      e('Actually, you dont need any params in the above examples.')+
+      br+
+      frage('How do I output each member of an array? How do I output the 
+      content of an array? How can i ignore certain chars like . and ..,
+      ie how can i exclude . and ..? (each array member)')+
+      br+
+      e('Use sth like ')+
+      br+
+      cmd('  a.each {|x| print x, " - " }')+
+      br+
+      e('About the second question, use')+
+      cmd("  unless ( x == '.') || (x == '..')")+
+      e('Output it:')+
+      br+
+      cmd('  puts array')+
+      br+
+      frage('I have an array with 1000 entries. How can i slice the
+      first 100 entries and move them to the end of the array?')+
+      e('Verwende in etwa folgenden Code:')+
+      br+
+      cmd('  array = (1..1000).to_a')+
+      cmd('  array += array.slice!(0, 99)')+
+      cmd('  puts array')+
+      br+
+      frage('I want to use the name of an array. How can i do this?')+
+      cmd('class Array')+
+      br+
+      cmd2('  attr_accessor :name')+
+      br+
+      cmd('end')+
+      br+
+      cmd('def xs(inp)')+
+      cmd2("puts inp.name + ':' + inp.join(' ')")+
+      cmd('end')+
+      br+
+      cmd("(xpa12 = ['foo', 'bar']).name = 'xpa12'")+
+      cmd("(xpa13 = ['bla', 'ble']).name = 'xpa13'")+
+      cmd('  d = xpa13')+
+      cmd('  xs(xpa12)  # => xpa12:foo bar')+
+      cmd('  xs(d)      # => xpa13:bla ble')+
+      br+
+      frage('Can i duplicate the content of an array?')+
+      cmd('  array *2')+
+      br+
+      frage("I have input between 1-100 entries (integers). I want to 
+      initialize a class for each entry. How to do?")+
+      e('Initialize an array.')+
+      br+
+      cmd('players = []')+
+      br+
+      e('And if you know how many entries , you could use
+      this(of course adapt for your class, and your needs):')+
+      br+
+      cmd('(1..players_n).each { |n| players[n] = PlayerData.new(5,5,5) }')+
+      br+
+      e('The block-form of Array.new also yields the index')+
+      br+
+      cmd('  players = Array.new(player_count) { Player.new }')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('Array.new(3) { |x| x * 2 } would give you [0, 2, 4]')+
+      br+
+      e('Remember, with Array.new() you can declare how many
+      entries the array shall contain.')+
+      br+
+      e('How do I add new entries to an array? ')+
+      br+
+      e('Use + or just define a new member of the array. 
+      Examples are following.')+
+      br+
+      e('Given the above solution, use <span class="col">array + ["foo", "bar"]</span>.
+      In general, if you define a new entry number, it will be added to the array, 
+      for example via <span class="col">array[5] = "five"</span>.')+
+      br+
+      frage('Wie frage ich ein Objekt ob es ein Array ist?')+
+      cmd('  object.is_a? Array')+
+      br+
+      frage('Wie mache ich dynamische Arrays?')+
+      e('At first glance these seems to be a little bit tricky.')+
+      br+
+      e('First basics are, that you can assign multidimensional arrays, as
+      in')+
+      br+
+      cmd('  x =[   [1, 2, 3], [4, 5, 6], [7, 8]   ]')+
+      br+
+      e('You can access this array as in')+
+      br+
+      cmd('  y=x[1]')+
+      br+
+      e('and redefine parts of it')+
+      br+
+      cmd('  six = x[1][2]')+
+      br+
+      frage('How do I get the first entry of an array?')+
+      e('Sometimes you will have an array
+      containing other arrays, and you want to get the first
+      entry of each of these entries.')+
+      br+
+      e('Then this method call can turn out to be useful:')+
+      br+
+      cmd('  array = [ "q","r","s","gjklgjkl" ]')+
+      cmd('  array.first')+
+      cmd('  array.first(3)')+
+      br+
+      frage('How do I delete entries from an array?')+
+      e('Use -. ')+
+      e('  If you know the name of the entry, you can delete 
+      it via')+
+      br+
+      cmd('array - [ "name" ]')+
+      br+
+      e('You can also use <b>Array#delete</b> ')+
+      br+
+      frage('How do I join members of an array using a token of my 
+      choice?')+
+      cmd("  foo.join(', ')")+
+      br+
+      e('You can do this is a more complex manner, like 
+      append something after you joined them, see')+
+      br+
+      cmd("  foo.join(' (and) ') + '8)'")+
+      br+
+      e('How do I sort arrays?')+
+      e('Lets take the array x = [ 1, 7, 3 ]. ')+
+      br+
+      e('We can now sort it by doing 
+      <span class="col">x.sort</span>. This handsomely works 
+      with strings as easily.')+
+      br+
+      e('You can also reverse arrays, like')+
+      e('<span class="col">
+      x.reverse</span>.')+
+      br+
+      e('Please note that ruby has the <=> operator, which 
+      simplifies sorting. Just try it in your irb like 3 <=> 1.')+
+      br+
+      e('And because you want it, here is another Example:')+
+      br+
+      cmd('primzahlen = [ 11, 5, 7, 2, 13, 3 ]')+
+      cmd('primzahlen.sort')+
+      br+
+      e('Und noch Namen:')+
+      br+
+      cmd('namen = [ "Melissa", "Daniel", "Samantha", "Jeffrey","Idiot","RubyRules"]')+
+      cmd('namen.sort')+
+      br+
+      e('I need to create 1001 words for an array. Is there a simple way 
+      to do it? An alternate array way to initialize strings?')+
+      br+
+      e('Let some script make the words for you or gather the necessarray 
+      data. Manually you can do this')+
+      br+
+      e('<span class="col">%w</span> which tells ruby that the following 
+      data is meant to be used as words in an array. Example:')+
+      br+
+      cmd('  foo = %w{ one two three four five }')+
+      br+
+      e('You can still access them via')+
+      br+
+      cmd('  foo[0]')+
+      br+
+      e('and so on.')+
+      br+
+      frage('How do I convert an array into a string?')+
+      e('Use <span class="col">join</span>.
+      Given the array variable above, you can use it like this: 
+      <span class="col">str= array.join(".")</span>')+
+      br+
+      e('How do I convert a string into an array? (string split=')+
+      br+
+      e('Use <span class="col">split</span>, like in 
+      <span class="col">str.split(":")</span>')+
+      br+
+      e('Actually, this does a bit more, because it splits your string 
+      at the given keyword, and returns an array with the remaining 
+      information.')+
+      br+
+      e('You could use it to retrieve some info as in:')+
+      br+
+      cmd('x = "xxx  100% 7932KB   2.6MB/s   00:03" yyy  100%   10MB   2.6MB/s   00:04"')+
+      br+
+      frage("Wie applizierte ich etwas something on each member of
+      an array? (each array, each member array)")+
+      e('Use <span class="col">each</span>, like in')+
+      br+
+      cmd('foo.each { |current_item|')+
+      cmd2('  puts current_item')+
+      cmd('}')+
+      br+
+      e('Dont forget, every member of an array is also an object in 
+      ruby, and the each is actually called an iterator.')+
+      br+
+      e('An example is the following:')+
+      br+
+      cmd('  ["dog","cat","bird"].each {|i|')+
+      cmd2('    printf "This is a %s\n", i')+
+      cmd('}')+
+      br+
+      e('And for cool effects, combine it with a loop:')+
+      br+
+      cmd('  (1..10).each {|i|')+
+      cmd2('    print sprintf("%04d\n", i)')+
+      cmd('  }')+
+      br+
+      e('We can combine this with sort and downcasing as well')+
+      br+
+      cmd('y.each do |x|')+
+      cmd('  print x.downcase')+
+      cmd('end;puts')+
+      br+
+      frage('How do I split a string at a given token, and create an array 
+      with the remaining information? (split string, string2array)')+
+      cmd('array = "foo bar doo car".split(" ")')+
+      cmd('puts array')+
+      br+
+      e('The character given in split() is called <b>delimiter</b>.')+
+      e('If you dont need an array:')+
+      br+
+      cmd('  "string foo bar".split')+
+      br+
+      e('or')+
+      br+
+      cmd('"string foo bar".split("o")')+
+      br+
+      # === Delete duplicated array members
+      frage("Wie kann ich duplizierte Mitglieder eines Array löschen und
+      wie kann ich all jene Mitglieder löschen, die bestimmte 
+      Kriterien erfüllen? (Ein Filter. remove duplicates / array duplicate / 
+      array delete member / array delete entry)")+
+      cmd('  a = ["a","a","b","c"]')+
+      cmd('  puts a.uniq # => a,b,c # Alle weiteren a-Einträge nach 
+      dem ersten a werden gelöscht')+
+      br+
+      # === Delete members of an Array
+      e('Mitglieder eines Array kann man so löschen: ')+
+      br+
+      cmd('  a = ["a","a","b","c"]')+
+      cmd('  a.delete("a")')+
+      cmd('  puts a # b c')+
+      br+
+      # === Find all duplicates of an Array
+      frage('Wie finde ich alle Duplicates eines Array?')+
+      cmd('  def only_duplicates(array)')+
+      cmd2('   duplicates = []')+
+      cmd2('   array.each {|member| duplicates << member if array.count(member) > 1}')+
+      cmd2('    duplicates.uniq')+
+      cmd('  end')+
+      br+
+      anm('<< ist ein Alias zu push, nicht zu concat.')+
+      br+
+      e('Ein anderer Weg ist folgender (ist besser da er keinen weiteren
+      Array benötigt):')+
+      br+
+      cmd('  array.detect { |e| array.count(e) > 1 }')+
+      br+
+      e('Genauer:')+
+      br+
+      cmd('  array = [1, 2, 1, 3, 5, 4, 5, 5] # => [1, 2, 1, 3, 5, 4, 5, 5]')+
+      cmd('  dup = array.select{|element| array.count(element) > 1 } # => [1, 1, 5, 5, 5]')+
+      cmd('  dup.uniq # => [1, 5]')+
+      cmd('  dup # => [1, 1, 5, 5, 5]')+
+      br+
+      frage('Ich habe einen Array mit Zahlen. Wie erhalte ich die
+      Summe davon?')+
+      cmd('  [1,3,4].reduce(:+) # => 8')+
+      br+
+      frage('Wie kann ich 32 zufällige Arrays erstellen die von 
+      0 bis 26 variieren können?')+
+      cmd('  Array.new(32) { rand(26) }')+
+      br+
+      frage('Wie erhalte ich ein bestimmtes Produkt eines Array?')+
+      cmd('%w(a b c).product([*1..3]).map(&:join) # => ["a1", "a2",
+      "a3", "b1", "b2", "b3", "c1", "c2", "c3"]')+
+      br+
+      frage('Wie kann ich einen Array in zwei Arrays aufteilen?')+
+      cmd('  [1, 2, 3, 4].each_slice(2).to_a # => [[1, 2], [3, 4]]')+
+      br+
+      frage('Wie erreiche ich eine Intersektion (Gemeinsamkeiten)
+      zwischen 2 Arrays?')+
+      cmd('  %w( abc def ghi ) & %w( ghi jkl mno ) # => ["ghi"]')+
+      br+
+      frage('Wie finde ich heraus ob ein Array einen anderen
+      Array inkludiert?')+
+      cmd("  require 'set'")+
+      br+
+      cmd('  array.to_set == other_array.to_set')+
+      cmd('  $ary1.to_set == $ary2.to_set')+
+      cmd('  %w( b c a ).to_set.subset?(%w( a b c ).to_set) # => true')+
+      br+
+      frage('Wie finde ich heraus ob ein Array empty (leer) ist?')+
+      cmd('  array.empty?')+
+      br+
+      frage('Wie finde ich einen Index in einem Array?')+
+      cmd('  array = ["1", "2", "3", "4", "5", "6", "7",
+      "8", "9", "0", "a", "b", "c", "d", "e", "abc",
+      "cat", "dog", "a", nil, nil]')+
+      br+
+      cmd("  array.find_index 'cat' # => 16")+
+      br+
+      # Find subarray in an array.
+      frage('Wie finde ich einen bestimmten Subarray in einem Array?')+
+      cmd('  %w( abc def ghi ).index {|x| x =~ /de/ } # => 1')+
+      br+
+      frage('Wie teile ich einen Array auf in n Subarrays? (split
+      array in two)')+
+      cmd('  [1,2,3,4,5,6].each_slice(2) {|slice| p slice} # =>  
+      [1, 2], [3, 4], [5, 6]')+
+      br+
+      frage('Wie kann ich jedes Mitglied eines Array in einen
+      neuen Array werfen?')+
+      cmd('  %w( Red Green Blue Yellow ).product # =>
+      [["Red"], ["Green"], ["Blue"], ["Yellow"]]')+
+      br+
+      frage('Wie lösche ich Elemente die repetitiv nacheinander folgen?')+
+      cmd('   [1, 1, 2, 3, 2, 2, 1].chunk {|i| i }.map(&:first)')+
+      br+
+      frage('Wie gebe ich einen Array wieder, aber in umgekehrter Reihenfolge?')+
+      cmd('  [1,2,3,4,5].reverse_each {|x| puts x}')+
+      br+
+      frage('Wie und wieso verwende ich .to_ary, und wie hängt
+      dies mit .try_convert zusammen?')+
+      e('Jede Klasse in Ruby kann eine <b>to_ary</b> Methode definieren.')+
+      br+
+      e('Dies erlaubt es dieser Klasse in einen Array konvertiert zu werden.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd( '  class Foo')+
+      cmd2('    def to_ary')+
+      cmd3('      ["John", "Doe", "Yo"]')+
+      cmd2('    end')+
+      cmd('  end')+
+      br+
+      cmd( '  Array.try_convert Foo.new')+
+      e('Mit anderen Worten, hier versucht man einen Array zu erstellen.')+
+      br+
+      frage('Wie finde ich gemeinsame Elemente zwischen 2 oder mehr Arrays?')+
+      e('Mittels dem Intersection-Operator <b>&</b>.')+
+      br+
+      cmd('  ["a","b","c"] &  ["b","f","g"] # => ["b"]')+
+      br+
+      frage('Wie vereine ich 2 Arrays? (Array merge, merge array)')+
+      e('Dies geschieht mittels .concat, wobei + recht ähnlich zu 
+      .concat ist, jedoch eine copy erstellt:')+
+      br+
+      cmd('  array1 = %w( a b c )')+
+      cmd('  array2 = %w( e f g )')+
+      cmd('  array1.concat(array2) # => ["a", "b", "c", "d"]')+
+      cmd('  array1 + array2')+
+      br+
+      anm('Wieso verwenden wir hier nicht << statt contact? Da .concat auch
+      <b>automatisch ein .flatten anwendet</b>, << hingegen nicht.')+
+      br+
+      frage('Wie erstelle ich ein Union von 2 Arrays ohne Duplikate?')+
+      e('Mittels dem <b>| Operator</b>.')+
+      br+
+      cmd('  %w( a b c d e f ) | %w( c d a ) # => ["a", "b", "c", "d", "e", "f"]')+
+      br+
+      frage('Wie kann ich den Array auswählen der ein bestimmtes 
+      Element aufweisen kann?')+
+      e('Dies geht mittels <b>.assoc</b>')+
+      br+
+      cmd('  array1 = %w( colours red blue green white )')+
+      cmd('  array2 = %w( letters a b c d e )')+
+      cmd('  s3 = "foo"')+
+      cmd('  a = [array1, array2, s3]')+
+      cmd('  a.assoc "letters" # => ["letters", "a", "b", "c",
+      "d", "e"]')+
+      br+
+      frage('Wie erhalte ich ein bestimmtes Element eines Arrays?')+
+      e('Mittels <b>.at</b>')+
+      br+
+      cmd('  a = [ "a", "b", "c", "d", "e" ]')+
+      cmd('  a.at(0)  # => "a"')+
+      cmd('  a.at(-1) # => "e"')+
+      br+
+      e('You can also use <b>.clear</b>, as in array.clear. This will remove
+      all elements from our array in question and thus empties it again.')+
+      br+
+      e('Example for this follows next:','','clear')+
+      br+
+      cmd('  a = ["a","b","c"]')+
+      cmd('  a.clear')+
+      cmd('  a # => []')+
+      br+
+      frage('Wie kann ich alle Kombinationen eines Array darstellen?')+
+      e('Mittels .combination().')+
+      br+
+      frage('Wie erhalte ich die Anzahl an Elementen in einem Array?')+
+      cmd('  %w( 1 2 3 4 5 6 6 6 ).count("6") # => 3')+
+      br+
+      frage('Wie fülle ich einen Array mit bestimmten Elementen?')+
+      cmd("  %w( a b c ).fill('z',3,4) # => ['a', 'b', 'c',
+      'z','z', 'z', 'z']")+
+      br+
+      frage('Wie erhalte ich den Index eines Elements zur rechten
+      Seite?')+
+      e('Mittels .rindex()')+
+      br+
+      cmd('  %w( a b c d e f g b h i ).rindex("b") # => 7')+
+      br+
+      frage('Was macht <b>.transpose</b>?','transpose')+ # rf ruby transpose
+      e('Die <b>.transpose</b> Methode auf Arrays - transpose heisst
+      "vertauschen" - nimmt einen existierenden, 2-dimensionalen
+      Array (eine Matrix) und verändert sie an einer Seite:')+
+      br+
+      cmd('a = [[1,2], [3,4], [5,6]]')+
+      cmd('puts a.transpose.inspect # => [[1, 3, 5], [2, 4, 6]]')+
+      br+
+      e('Noch ein Beispiel:')+
+      br+
+      cmd('  [[1,2,3,4],[:a, :b, :c, :d]].transpose 
+      # => [[1, :a], [2, :b], [3, :c], [4, :d]]')+
+      br+
+      e('Mit anderen Worten, das erste Element jedes Array wird zu
+      einem neuen Array. Das funktioniert aber nicht mit Arrays
+      denen ein Element fehlt, daher diese Lösung:')+
+      br+
+      cmd('class Array')+
+      cmd2('  def safe_transpose')+
+      cmd3('    result = []')+
+      cmd3('    max_size = self.max { |a,b| a.size <=> b.size }.size')+
+      cmd3('    max_size.times { |i|')+
+      cmd4('      result[i] = Array.new(self.first.size)')+
+      cmd4('      self.each_with_index { |r,j| result[i][j] = r[i] }')+
+      cmd3('    }')+
+      br+
+      cmd3('    result')+
+      cmd2('  end')+
+      cmd('end')+
+      br+
+      e('Nun kann <b>safe_transpose</b> angewandt werden.')+
+      br+
+      e('Es berechnet die Länge of the longest row and uses that as
+      the baseline to perform the transposition.')+
+      br+
+      e('So our original example becomes:')+
+      br+
+      cmd('  a = [[1,2], [3,4], [5]]')+
+      cmd('  puts a.safe_transpose.inspect')+
+      cmd('  [[1, 3, 5], [2, 4, nil]]')+
+      br+
+      frage('Wie erhalte ich die Summe eines Integer-Array?','integer_sum')+
+      cmd('  array = [ 5,2,52,52,2,54,5444 ]')+
+      cmd('  array.inject(0) { |x,y| x+y } # => 5611')+
+      br+
+      e('Oder in einer Wurscht:')+
+      br+
+      cmd('  [ 5,2,52,52,2,54,5444 ].inject(0) { |x,y| x+y } # => 5611')+
+      br+
+      e('Inject wurde zuerst in Smalltalk verwendet und funktioniert wie folgt:')+
+      br+
+      e('The first time the block is called, x will be set to the 
+      value given in inject, in our case 0, while y will be the value 
+      of the first array member.')+
+      br+
+      e('Danach wird x an den Rückgabewert des Blocks gleichgesetzt.')+
+      br+
+      # === Find position in an Array
+      frage('Wie finde ich die Position eines Array Mitglieds
+      heraus? (array subsequence, array index, array position)')+
+      e('Mittels <b>.index</b>')+
+      br+
+      anm('Übrigens, .index ist ein alias zu <b>.find_index</b>.')+
+      cmd('  index = @data.find_index { |entry| entry[0].downcase.include? i }')+
+      br+
+      frage('Wie nehme ich das erste Element eines Arrays und füge
+      es ganz hinten an?')+
+      br+
+      e('Mittels <b>.rotate()</b>.')+
+      br+
+      cmd('  [ "a", "b", "c", "d" ].rotate # => ["b", "c", "d", "a"]')+
+      br+
+      frage('Wie finde ich heraus ob ein Array nur ein Element hat?')+
+      cmd('  array.one?')+
+      br+
+      # ===================================================================== #
+      # === partition
+      # ===================================================================== #
+      frage('Wie kann ich die Guten ins Töpfchen legen und die
+      Schlechten ins Kröpfchen? (split in two','array_partition')+
+      cmd('  rejected, good = [1, 2, 3, 4].partition { |a| a == 1 }
+      # => [[1], [2, 3, 4]]','partition')+
+      br+
+      # ===================================================================== #
+      # === Array#minmax
+      # ===================================================================== #
+      frage('Wie erhalte ich sowohl den höchsten als auch den niedrigsten
+      Wert aus einem Array?')+
+      cmd('  array = [1,5,33,11]; array.minmax # => [1, 33]')+
+      br+
+      # ===================================================================== #
+      # === Links to RUBY Arrays.
+      # ===================================================================== #
+      div {
+        h2('Links zu Ruby Array Sachen:')+
+        p {
+          a('http://www.ruby-doc.org/core/classes/Array.html',
+            content: 'DEF', css_class: 'slateblue')+
+          br
+        }
+  }
+    }
+    }
+  end
+
+end