Ruby
Inhalt | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11

Offizielle Ruby FAQ

Wenn Sie Fehler melden oder Verbesserungen für diese FAQ vorschlagen möchten, besuchen Sie bitte unser GitHub-Repository und öffnen Sie ein Issue oder einen Pull Request.

Weitere Funktionen

Was bedeutet a ? b : c?

Dies ist der sogenannte „ternäre Operator“ und bedeutet dasselbe wie if a then b else c end.

Wie kann ich die Anzahl der Zeilen in einer Datei zählen?

Der folgende Code kann das schnellste Ergebnis liefern.

File.readlines("example").size  # => 3

Was geben MatchData#begin und MatchData#end zurück?

Sie interagieren mit $~ und geben den Startindex und den Endindex der gefundenen Daten im Originalstring zurück. Sehen Sie ein Beispiel in der Tabulator-Erweiterung.

Wie kann ich die Elemente eines Arrays aufsummieren?

Dieser Abschnitt oder Teile davon könnten veraltet oder nicht bestätigt sein.

Anstatt das spezifische Problem zu lösen, lösen wir den allgemeinen Fall. Zuerst erstellen wir eine Methode, die über ein Enumerable-Objekt iteriert und ein einzelnes Ergebnis sammelt. Smalltalk nennt diese Methode inject, also werden wir das auch tun.

module Enumerable

  # inject(n) {|n, i| ...}
  def inject(n)
    each {|i| n = yield(n, i) }

    n
  end
end

Beachten Sie, wie wir die Methode zu Enumerable hinzugefügt haben. Das bedeutet, dass alles, was Enumerable beinhaltet, jetzt inject verwenden kann. Aber wie verwenden wir es? Es nimmt ein einzelnes Argument n und einen Block. Für jedes Element in der aufzählenden Sache ruft es den Block auf und übergibt n und das Element selbst. Das Ergebnis des Blocks wird wieder n zugewiesen. Um also sum zu definieren, könnten wir schreiben:

module Enumerable
  def sum
    inject(0) {|n, i| n + i }
  end
end

[1,3,5,7,9].sum  # => 25
(1..100).sum     # => 5050

Wie kann ich Continuations verwenden?

Dieser Abschnitt oder Teile davon könnten veraltet oder nicht bestätigt sein.

Rubys Continuations ermöglichen es Ihnen, ein Objekt zu erstellen, das einen Ort in einem Ruby-Programm darstellt, und dann jederzeit zu diesem Ort zurückzukehren (auch wenn er scheinbar aus dem Gültigkeitsbereich entfernt wurde). Continuations können zur Implementierung komplexer Kontrollstrukturen verwendet werden, sind aber typischerweise nützlicher, um Leute zu verwirren.

In [ruby-talk:4482] postete Jim Weirich die folgenden Beispiele für Continuations.

# --------------------------------------------------------------------
# Simple Producer/Consumer
# --------------------------------------------------------------------
# Connect a simple counting task and a printing task together using
# continuations.
#
# Usage:  count(limit)

def count_task(count, consumer)
  (1..count).each do |i|
    callcc {|cc| consumer.call cc, i }
  end
  nil
end

def print_task()
  producer, i = callcc { |cc| return cc }
  print "#{i} "
  callcc { |cc| producer.call }
end

def count(limit)
  count_task(limit, print_task())
  print "\n"
end

# --------------------------------------------------------------------
# Filtering Out Multiples of a Given Number
# --------------------------------------------------------------------
# Create a filter that is both a consumer and producer. Insert it
# between the counting task and the printing task.
#
# Usage:  omit(2, limit)

def filter_task(factor, consumer)
  producer, i = callcc { |cc| return cc }
  if (i%factor) != 0 then
    callcc { |cc| consumer.call cc, i }
  end
  producer.call
end

def omit(factor, limit)
  printer = print_task()
  filter = filter_task(factor, printer)
  count_task(limit, filter)
  print "\n"
end

# --------------------------------------------------------------------
# Prime Number Generator
# --------------------------------------------------------------------
# Create a prime number generator. When a new prime number is
# discovered, dynamically add a new multiple filter to the chain of
# producers and consumers.
#
# Usage:  primes(limit)

def prime_task(consumer)
  producer, i = callcc { |cc| return cc }
  if i >= 2 then
    callcc { |cc| consumer.call cc, i }
    consumer = filter_task(i, consumer)
  end
  producer.call
end

def primes(limit)
  printer = print_task()
  primes = prime_task(printer)
  count_task(limit, primes)
  print "\n"
end
Inhalt | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11