Ich merke es nicht, wenn ich es schreibe, und selbst wenn ich es mir anschaue, nachdem ich es fertig geschrieben habe, ist es schwierig, den von mir geschriebenen Code zu zerlegen und zu rekonstruieren. Dies liegt daran, dass Sie beim Neuerstellen einen anderen Ansatz zum Schreiben von Code benötigen. Der Ort, an dem ich einmal dachte, dass dies der Fall ist und den Code mit einem leeren Kopf umschrieb, ist der Berg. Dieses Mal werde ich einige Muster aufschreiben, die mir in einem so umgeschriebenen Teil aufgefallen sind. Es ist ein Memorandum, das auf meiner eigenen Erfahrung basiert.
Eigentlich ist der Prozess, den ich ausführen möchte, der gleiche, aber es gibt zwei Arten von Parameterinhalten, die als Argumente übergeben werden: on_total und on_this_month. Wenn einer dieser beiden Prozesse erkannt wird, wollte ich einen zu sortierenden Prozess einschließen. Der erste, den ich geschrieben habe, ist unten.
bad_1.rb
def self.ascend_checkins(param, hash)
if param == "on_total"
hash.sort_by { |k,v| -v["total"] }.to_h
elsif param == "on_this_month"
hash.sort_by { |k,v| -v["month"] }.to_h
end
end
Aus dem oben genannten Grund wurde der gleiche Sortiervorgang aufgenommen. Ändern Sie ihn daher wie folgt.
mod_1.rb
def self.ascend_checkins(hash, param)
key_of = {"on_total" => "total", "on_this_month" => "month"}
value = key_of[param]
raise "unknown param" if !value
hash.sort_by { |k,v| -v[value] }.to_h
end
Da es nur zwei Parameter gibt, bereiten Sie einen Hash vor, empfangen Sie den Parameter, beurteilen Sie den ihm entsprechenden Wert anhand des Booleschen Werts und löschen Sie denselben Prozess, indem Sie den Prozess ausführen, wenn er wahr ist.
Im Folgenden wird die Benutzer-ID als Zeichenfolge extrahiert, deren Anzahl gezählt und in einen Hash konvertiert. Es ist zu einem Prozess mit vielen temporären Variablen geworden, wenn ein leeres Array vorbereitet wird.
bad_2.rb
def self.get_monthly_count(ids, users)
uids = []
ids.each do |id|
uids.push id.uid.to_s
end
uid = {}
count = 0
users.each do |user|
uid[user] = uids[count]
count += 1
end
uid.to_h
end
Es ist in einer Zeile aufgeräumt, im Fall von Ruby.
mod_2.rb
def self.get_monthly_count(ids, users)
users.zip(ids.map{ |id| id.uid.to_s }).to_h
end
Wenn Sie die Map-Methode verwenden, benötigen Sie zunächst nur eine Zeile, um sie als Zeichenfolge zu extrahieren und als Array neu zu erstellen. Wenn Sie ein leeres Array erstellen und die Verarbeitung mithilfe von Indizes schreiben, können Sie anscheinend von Anfang an sauberen Code schreiben, wenn Sie zuerst diese Art von Methode verwenden möchten. Danach verwende ich die Zip-Methode, um ein Paar-Array zu erstellen und es schließlich zu hashen.
Es ist eine Methode, die Elemente eines Arrays wie ein Spannfutter kombinieren kann.
zip.rb
array_keys = ["Tom", "Bob", "Joge"]
array_values = [167, 156, 181]
zipped = array_keys.zip(array_values)
p zipped # [["Tom", 167], ["Bob", 156], ["Joge", 181]]
hash = zipped.to_h
p hash # {"Tom"=>167, "Bob"=>156, "Joge"=>181}
Es gibt drei, Benutzernamen, UID und Benutzer, aber Sie müssen sie nicht so erstellen.
bad_3.rb
def self.get(check_ins)
user_names = []
check_ins.each do |check_in|
uid = check_in.uid
users = community_number_collection.document(uid).get
user_names.push users.data[:nickname]
end
user_names
end
Wenn ein leeres Array erstellt wird, wird es mithilfe von map verarbeitet und in einer Zeile zusammengefasst, ohne dass zusätzliche Variablen erstellt werden.
mod_3.rb
def self.get(check_ins)
check_ins.map do |check_in|
community_number_collection.document(check_in.uid).get.data[:nickname]
end
end
Kombinieren Sie die oben genannten, um den Prozess zu verkürzen.
bad_4.rb
def self.get_total(merged_data, users)
sum = []
merged_data.keys.each do |value|
uid = merged_data[value]["uid"]
sum.push self.where(uid: uid).count
end
sum
total = {}
count = 0
users.each do |user|
total[user] = sum[count]
count += 1
end
total
end
Karte und Reißverschluss machen es viel kürzer. Es war auch eine Entdeckung, dass die gesamte Blockverarbeitung in eine Variable namens sum verschoben wurde. Der Block ist ein Ausdruck und kann zugewiesen werden.
mod_4.rb
def self.get_total(merged_data, users)
sums = merged_data.keys.map do |key|
self.where(uid: merged_data[key]["uid"]).count
end
users.zip(sums).to_h
end
Hashes zählen Duplikate und sind nützlich für die Aggregation. Aber je kürzer es ist, desto besser.
bad_5.rb
def self.get_this_month(check_ins)
check = {}
check_ins.each do |check_in|
uid = check_in.uid.to_s
uid_count = check[uid] || 0
check[uid] = uid_count + 1
end
check.values.each do |value|
value
end
end
Ich habe diesmal kein leeres Array verwendet, aber wenn Sie die Elemente des ursprünglichen Arrays in jedes Array extrahieren, ist es besser, das gewünschte Array mit Map neu zu erstellen und dieses Array mit jedem Array zu drehen. .. Wenn Sie die Standardmethode verwenden, können Sie alle Werte einmal auf 0 setzen.
mod_5.rb
def self.get_this_month(check_ins)
check = {}
check.default = 0
check_ins.map{ |c| c.uid.to_s }.each do |uid|
check[uid] += 1
end
check.values
end
Vor dem folgenden Code gab es zwei Funktionen, die dasselbe taten, außer dass die Schlüssel des übergebenen Hashs unterschiedlich waren. Ich habe es in einer abstrakten Funktion zusammengefasst. Deklarieren Sie nach dem Vorbereiten eines leeren Arrays ein leeres Array mit dem angegebenen Schlüssel (verschachtelt = {}), und in jedem können Sie einen wertlosen Hash für den Schlüssel haben (verschachtelt [Schlüssel] = {}) ).
sample_1.rb
def self.label_hash(hash_dictionary, keys)
nested = {}
keys.each do |key|
nested[key] = {}
hash_dictionary.each do |name, hash|
nested[key][name] = hash[key]
end
end
nested
end
Als aufrufende Methode wird die Methode zum Gruppieren der Argumente zu einem Hash verwendet. In der oberen Funktion sind die verwendeten Wörter nahezu abstrakt, und im unteren Aufruf werden Wörter mit starker Spezifität verwendet. Sie können sehen, dass die Rollen durch die Benennung klar getrennt sind.
sample_2.rb
labeled_totally_count = CheckIn.label_hash({
"month" => zipped_monthly_count,
"total" => zipped_totally_count
}, zipped_monthly_count.keys)
Wenn es viele temporäre Variablen gibt, stellen Sie sich vor, wie Sie sie gelöscht schreiben.
Beachten Sie den Moment, in dem Sie die von Ruby bereitgestellte Methode je nach Situation verwenden (insbesondere, wenn Sie einen leeren Array- und Indexzählprozess schreiben).
Ein weiteres Problem beim Schreiben von Code, der schwer zu lesen ist, besteht darin, dass der Name, den Sie bereits verwenden, in der Programmierwelt als ein anderes Konzept verwurzelt ist, sodass ein erfahrener Ingenieur den Code sehen kann. Beachten Sie, dass es häufig vorkommt, dass Sie sich am Ende daran erinnern, was zu Fehlinterpretationen führt. Daher ist der von Ihnen geschriebene Code schwer zu lesen.
Recommended Posts