Idiomatischer Rubin: schönen Code schreiben

Ruby ist eine schöne Programmiersprache.

Laut Rubys offizieller Webseite ist Ruby ein:

Dynamische Open Source-Programmiersprache mit Fokus auf Einfachheit und Produktivität. Es hat eine elegante Syntax, die natürlich zu lesen und leicht zu schreiben ist. “

Ruby wurde von Yukihiro Matsumoto, einem japanischen Software-Ingenieur, erstellt. Seit 2011 ist er Chefdesigner und Softwareentwickler für Ruby bei Heroku.

Matsumoto hat oft gesagt, dass er versucht , Ruby auf eine Weise natürlich und nicht einfach zu machen , die das Leben widerspiegelt.

„Ruby sieht einfach aus, ist aber innen sehr komplex, genau wie unser menschlicher Körper“ - Yukihiro Matsumoto

Bei Ruby geht es mir genauso. Es ist eine komplexe, aber sehr natürliche Programmiersprache mit einer schönen und intuitiven Syntax.

Mit intuitiverem und schnellerem Code können wir bessere Software erstellen. In diesem Beitrag werde ich Ihnen zeigen, wie ich meine Gedanken (auch bekannt als Code) mit Ruby ausdrücke, indem ich Codeausschnitte verwende.

Meine Gedanken mit Array-Methoden ausdrücken

Karte

Verwenden Sie die Kartenmethode , um Ihren Code zu vereinfachen und das zu erhalten, was Sie möchten.

Verfahren Karte gibt ein neues Array mit den Ergebnissen einen Block einmal für jedes Element in ENUM läuft.

Lass es uns versuchen:

an_array.map  element * element 

So einfach ist das.

Wenn Sie jedoch mit dem Codieren mit Ruby beginnen, ist es einfach, immer jeden Iterator zu verwenden.

Die jeweils Iterator wie unten gezeigt

user_ids = [] users.each user

Kann mit Karte in einer einzigen schönen Codezeile vereinfacht werden:

user_ids = users.map  user.id 

Oder noch besser (und schneller):

user_ids = users.map(&:id)

Wählen

Und wenn Sie es gewohnt sind, mit einer Karte zu codieren , kann Ihr Code manchmal so aussehen:

even_numbers = [1, 2, 3, 4, 5].map element # [ni, 2, nil, 4, nil] even_numbers = even_numbers.compact # [2, 4]

Wenn Sie die Karte verwenden , um nur die geraden Zahlen auszuwählen, wird das zurückgegebenauch kein Objekt. Verwenden Sie die kompakte Methode, um alle Nullobjekte zu entfernen .

Und ta-da, Sie haben alle geraden Zahlen ausgewählt.

Mission erfüllt.

Komm schon, wir können es besser machen! Haben Sie von der Auswahlmethode aus dem Aufzählungsmodul gehört?

[1, 2, 3, 4, 5].select  

Nur eine Zeile. Einfacher Code. Einfach zu verstehen.

Bonus

[1, 2, 3, 4, 5].select(&:even?)

Stichprobe

Stellen Sie sich vor, Sie müssen ein zufälliges Element aus einem Array abrufen. Du hast gerade angefangen, Ruby zu lernen, also wird dein erster Gedanke sein: „Lass uns die Zufallsmethode verwenden“, und genau das passiert:

[1, 2, 3][rand(3)]

Nun, wir können den Code verstehen, aber ich bin mir nicht sicher, ob er gut genug ist. Und was ist, wenn wir die Shuffle- Methode verwenden?

[1, 2, 3].shuffle.first

Hmm. Eigentlich bevorzuge ich Shuffle über Rand . Aber als ich die Beispielmethode entdeckte, machte es viel mehr Sinn:

[1, 2, 3].sample

Wirklich sehr, sehr einfach.

Ziemlich natürlich und intuitiv. Wir fragen ein Beispiel aus einem Array und die Methode gibt es zurück. Jetzt bin ich glücklich.

Was ist mit Ihnen?

Meine Gedanken mit Ruby-Syntax ausdrücken

Wie ich bereits erwähnt habe, mag ich die Art und Weise, wie Ruby mich codieren lässt. Für mich ist das ganz natürlich. Ich werde Teile der schönen Ruby-Syntax zeigen.

Implizite Rückgabe

Jede Anweisung in Ruby gibt den Wert des zuletzt ausgewerteten Ausdrucks zurück. Ein einfaches Beispiel ist die Getter- Methode. Wir rufen eine Methode auf und erwarten einen Gegenwert.

Mal sehen:

def get_user_ids(users) return users.map(&:id) end

Wie wir jedoch wissen, gibt Ruby immer den zuletzt ausgewerteten Ausdruck zurück. Warum die return- Anweisung verwenden?

Nachdem ich Ruby 3 Jahre lang verwendet habe, fühle ich mich großartig, wenn ich fast jede Methode ohne die return- Anweisung verwende.

def get_user_ids(users) users.map(&:id) end

Mehrere Aufgaben

Mit Ruby kann ich mehrere Variablen gleichzeitig zuweisen. Wenn Sie beginnen, codieren Sie möglicherweise folgendermaßen:

def values [1, 2, 3] end one = values[0] two = values[1] three = values[2]

Aber warum nicht mehrere Variablen gleichzeitig zuweisen?

def values [1, 2, 3] end one, two, three = values

Ziemlich cool.

Methoden, die Fragen stellen (auch Prädikate genannt)

One feature that caught my attention when I was learning Ruby was the question mark (?) method, also called the predicates methods. It was weird to see at first, but now it makes so much sense. You can write code like this:

movie.awesome # => true

Ok… nothing wrong with that. But let’s use the question mark:

movie.awesome? # => true

This code is much more expressive, and I expect the method’s answer to return either a true or false value.

A method that I commonly use is any? It’s like asking an array if it has anything inside it.

[].any? # => false [1, 2, 3].any? # => true

Interpolation

For me string interpolation is more intuitive than string concatenation. Period. Let’s see it in action.

An example of a string concatenation:

programming_language = "Ruby" programming_language + " is a beautiful programming_language" # => "Ruby is a beautiful programming_language"

An example of a string interpolation:

programming_language = "Ruby" "#{programming_language} is a beautiful programming_language" # => "Ruby is a beautiful programming_language"

I prefer string interpolation.

What do you think?

The if statement

I like to use the if statement:

def hey_ho? true end puts "let’s go" if hey_ho?

Pretty nice to code like that.

Feels really natural.

The try method (with Rails mode on)

The try method invokes the method identified by the symbol, passing it any arguments and/or the block specified. This is similar to Ruby’s Object#send. Unlike that method, nil will be returned if the receiving object is a nil object or NilClass.

Using if and unless condition statement:

user.id unless user.nil?

Using the try method:

user.try(:id)

Since Ruby 2.3, we can use Ruby’s safe navigation operator (&.) instead of Rails try method.

user&.id

Double pipe equals (||=) / memoization

This feature is so C-O-O-L. It’s like caching a value in a variable.

some_variable ||= 10 puts some_variable # => 10 some_variable ||= 99 puts some_variable # => 10

You don’t need to use the if statement ever. Just use double pipe equals (||=) and it’s done.

Simple and easy.

Class static method

One way I like to write Ruby classes is to define a static method (class method).

GetSearchResult.call(params)

Simple. Beautiful. Intuitive.

What happens in the background?

class GetSearchResult def self.call(params) new(params).call end def initialize(params) @params = params end def call # ... your code here ... end end

The self.call method initializes an instance, and this object calls the call method. Interactor design pattern uses it.

Getters and setters

For the same GetSearchResult class, if we want to use the params, we can use the @params

class GetSearchResult def self.call(params) new(params).call end def initialize(params) @params = params end def call # ... your code here ... @params # do something with @params end end

We define a setter and getter:

class GetSearchResult def self.call(params) new(params).call end def initialize(params) @params = params end def call # ... your code here ... params # do something with params method here end private def params @params end def params=(parameters) @params = parameters end end

Or we can define attr_reader, attr_writer, or attr_accessor

class GetSearchResult attr_reader :param def self.call(params) new(params).call end def initialize(params) @params = params end def call # ... your code here ... params # do something with params method here end end

Nice.

We don’t need to define the getter and setter methods. The code just became simpler, just what we want.

Tap

Imagine you want to define a create_user method. This method will instantiate, set the parameters, and save and return the user.

Let’s do it.

def create_user(params) user = User.new user.id = params[:id] user.name = params[:name] user.email = params[:email] # ... user.save user end

Simple. Nothing wrong here.

So now let’s implement it with the tap method

def create_user(params) User.new.tap do |user| user.id = params[:id] user.name = params[:name] user.email = params[:email] # ... user.save end end

You just need to worry about the user parameters, and the tap method will return the user object for you.

That’s it

We learned I write idiomatic Ruby by coding with

  • array methods
  • syntax

We also learned how Ruby is beautiful and intuitive, and runs even faster.

And that’s it, guys! I will be updating and including more details to my blog. The idea is to share great content, and the community helps to improve this post! ☺

I hope you guys appreciate the content and learned how to program beautiful code (and better software).

If you want a complete Ruby course, learn real-world coding skills and build projects, try One Month Ruby Bootcamp. See you there ☺

This post appeared first here on my Renaissance Developer publication.

Have fun, keep learning, and always keep coding!

My Twitter & Github. ☺