Arrays

Arrays sind indexorientierte Variablen.

Array mit vordefinierten Werten erstellen

arr = [1, 3, 8, 2]		# das Array mit dem Bezeichner 'arr' wird befüllt
 
p! arr					# gibt das ganze Array aus
p! arr[0]				# Index 0 gibt das erste Element aus
p! arr[2]

Ausgabe:
arr # => [1, 3, 8, 2]
arr[0] # => 1
arr[2] # => 8

to_a

Man kann auch die Funktion 'to_a' verwenden.

arr = {3, 5, 2, 1}.to_a

p! arr

Ausgabe:
arr # => [3, 5, 2, 1]

Neues Element anhängen:

arr = [1, 3, 8, 2]
p! arr

arr << 7		# mit '<<' wird ein neues Element angehängt
p! arr

Array anlegen

Wenn man ein leeres Array anlegt, muss man dem Compiler mitteilen, welchen Typ man speichern möchte. Im Beispiel wollen wir Int16 speichern.

# leeres Array anlegen
arr_lang = Array(Int16).new 
arr_lang << 17
p! arr_lang

# Kurzform
arr_kurz = [] of Int16 
arr_kurz << 23
p! arr_kurz

Ausgabe:
arr_kurz # => [23]
arr_lang # => [17]

Array anlegen und mit einer bestimmten Anzahl von Werten befüllen.

Die Zahl 3 in den runden Klammern bedeutet, dass der Funktionsblock in den geschweiften Klammer 3 mal ausgeführt werden soll. Dabei wird die Variable 'xi' an die Funktion, die das Array erstellt übergeben. (siehe auch Blocks und yield)

arr = Array.new(3) {|xi| xi + 1}
 
p! arr

Ausgabe:
arr # => [1, 2, 3]

Mehrdimensionale Arrays

Mehrdimensionale Array sind Arrays, die in anderesn Arrays verschachtelt sind. Im Beispiel wird ein 2 x 3 großes Array anglegt und mit 0 befüllt.
Die 3 in den runden Klammen bedeutet, dass die Angaben in den ersten geschweiften Klammern 3 mal ausgeführt werden sollen. Gleiches gilt für die {0}, welche 2 mal für das innere Array ausgeführt wird.

arr = Array.new(3) {Array.new(2) {0}}
p! arr
arr[1][0] = 33
p! arr

Ausgabe:
arr # => [[0, 0], [0, 0], [0, 0]]
arr # => [[0, 0], [33, 0], [0, 0]]

Mehrdimensionales Array mit verschiedenen Typen

Es wird ein 2 dimensionales Array angelet und mit 0 vorbefüllt. Es dürfen sowohl Strings, unsigned Intergers und Floats gespeichert werden.

arr = Array.new(3) {Array(String | UInt32 | Float32).new(6) {0_u32}}

# bei der Wertezuweisung muss der Typ angegeben werden
arr[0][0] = 42_u32
arr[0][1] = 0.22
arr[1][0] = "Test"

p! arr[0]
p! arr[1]

Ausgabe:
arr[0] # => [42, 0.22, 0, 0, 0, 0]
arr[1] # => ["Test", 0, 0, 0, 0, 0]

Mehrere Arrays miteinander verbinden

Will man mehrere Array mit einander verbinden, wir einfach der + Operator verwendet.

# first we create 2 arrays
arr1 = Array.new(3) {|xi| xi + 1}
arr2 = [4, 5, 6]
 
# merge arr1 and arr2
arr3 = arr1 + arr2
 
# have look at each array
p! arr1
p! arr2
p! arr3

# Output
Ausgabe:
arr1 # => [1, 2, 3]
arr2 # => [4, 5, 6]
arr3 # => [1, 2, 3, 4, 5, 6]

%w

Besonderheit für Array aus Strings. Über die Angabe von '%w' können Arrays mit Strings ohne großartiges Getippe angelegt werden.
Alle 5 Beispiele sind genau gleichwertig. Sie unterscheiden sich nur bei der Anlage durch die unterschiedlichen Trennzeichen (Delimiter).
Erlaubt sind: (), [], {}, <>, ||

arr = %w(null eins zwei drei)
p! arr
p! arr[2]

arr = %w[null eins zwei drei]
p! arr
p! arr[1]

arr = %w{null eins zwei drei}
p! arr
p! arr[3]

arr = %w<null eins zwei drei>
p! arr
p! arr[0]

arr = %w|null eins zwei drei|
p! arr
p! arr[2]

size

Mit der Methode 'size' erhält man die Anzahl der Elemente von einem Array.

arr = %w(null eins zwei drei)
p! arr.size

Ausgabe:
arr.size # => 4

max und min

Die Methoden 'max' und 'min' liefern jeweils den größten und kleinsten Wert in einem Array.

arr = [1, 3, 4, 2]
 
p! arr.max
p! arr.min

Ausgabe:
arr.max # => 4
arr.min # => 1

sort

Die Methode 'sort' erstellt ein neues sortiertes Array.

# array anlegen
arr = [3, 5, 18, 39, 1, 34, 99]
 
# sort legt ein neues array
sortiert = arr.sort
 
# niedrigsten und höchsten wert ermitteln
kleinster_wert = arr.sort[0]
hoechster_wert = arr.sort[-1]
 
p! sortiert
p! kleinster_wert
p! hoechster_wert

Ausgabe:
sortiert # => [1, 3, 5, 18, 34, 39, 99]
kleinster_wert # => 1
hoechster_wert # => 99

clone

Mit 'clone' wird ein komplettes Array geklont bzw. in ein neues kopiert.

# Array anlegen
arr = [3, 5, 18, 39, 1, 34, 99]

# Array klonen bzw kopieren
arr_doppelt = arr.clone

# zum Test einen Wert ändern
arr_doppelt[1] = 398

p! arr
p! arr_doppelt

Ausgabe:
arr # => [3, 5, 18, 39, 1, 34, 99]
arr_doppelt # => [3, 398, 18, 39, 1, 34, 99]

in?

Auf vorhandenen Wert im Array prüfen.

# array anlegen
arr = [1, 2, 5, 9]

# Abfrage, ob 3 im Array ist
if 3.in?(arr)
  puts "3 ist im array"
else
  puts "3 ist nicht im array"
end

# geht auch mit Variablen
test = 5

if test.in?(arr)
  puts "#{test} ist im array"
else
  puts "#{test} ist nicht im array"
end

# geht auch mit einema anderen Array
test = [1, 4]

test.each do |i|
  if  i.in?(arr)
    puts "#{i} ist im array"
  else
    puts "#{i} ist nicht im array"
  end
end

Ausgabe:
3 ist nicht im array
5 ist im array
1 ist im array
4 ist nicht im array

clear

Inhalt von einem Array komplett löschen:

# Array befüllen
arr = [3, 5, 18, 39, 1, 34, 99]
p! arr

# Array löschen
arr.clear
p! arr


Ausgabe:
arr # => [3, 5, 18, 39, 1, 34, 99]
arr # => []

index

Die Methode index liefert die Position vom ersten Vorkommen eines Elements.
Gezählt wird mit 0 beginnend von links.

# Array befüllen
arr = [3, 5, 18, 39, 1, 34, 99]

# Liefert die Position von 18
p! arr.index(18)

Ausgabe:
arr.index(18) # => 2