Idiomatisk Ruby: at skrive smuk kode

Ruby er et smukt programmeringssprog.

Ifølge Rubys officielle webside er Ruby en:

Dynamisk, open source programmeringssprog med fokus på enkelhed og produktivitet. Den har en elegant syntaks, der er naturlig at læse og let at skrive. ”

Ruby blev skabt af Yukihiro Matsumoto, en japansk softwareingeniør. Siden 2011 har han været chefdesigner og softwareingeniør for Ruby i Heroku.

Matsumoto har ofte sagt, at han forsøger at gøre Ruby naturlig, ikke enkel , på en måde, der afspejler livet.

"Rubin er enkel i udseende, men er meget kompleks indeni, ligesom vores menneskelige krop" - Yukihiro Matsumoto

Jeg har det på samme måde med Ruby. Det er et komplekst, men meget naturligt programmeringssprog med en smuk og intuitiv syntaks.

Med mere intuitiv og hurtigere kode er vi i stand til at opbygge bedre software. I dette indlæg vil jeg vise dig, hvordan jeg udtrykker mine tanker (alias kode) med Ruby ved hjælp af kodestykker.

At udtrykke mine tanker med matrixmetoder

Kort

Brug kortet metode til at forenkle din kode og få, hvad du ønsker.

Metoden kortet returnerer en ny array med resultaterne ved at drive en blok en gang for hvert element i enum.

Lad os prøve det:

an_array.map  element * element 

Så simpelt er det.

Men når du begynder at kode med Ruby, er det let at altid bruge hver iterator.

Den hver iterator som vist nedenfor

user_ids = [] users.each user

Kan forenkles med kort i en enkelt smuk kodelinje:

user_ids = users.map  user.id 

Eller endnu bedre (og hurtigere):

user_ids = users.map(&:id)

Vælg

Og når du er vant til at kode med kort , kan din kode nogle gange være sådan:

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

Brug af kortet til kun at vælge lige tal returnerernul objekt også. Brug den kompakte metode til at fjerne alle nul objekter.

Og ta-da, du har valgt alle lige tal.

Mission fuldført.

Kom nu, vi kan gøre det bedre end dette! Hørte du om den valgte metode fra et modul, der kan tælles?

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

Bare en linje. Enkel kode. Let at forstå.

Bonus

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

Prøve

Forestil dig, at du har brug for at få et tilfældigt element fra en matrix. Du er lige begyndt at lære Ruby, så din første tanke bliver: "Lad os bruge den tilfældige metode", og det er hvad der sker:

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

Vi kan forstå koden, men jeg er ikke sikker på, om den er god nok. Og hvad hvis vi bruger shuffle- metoden?

[1, 2, 3].shuffle.first

Hmm. Jeg foretrækker faktisk at bruge shuffle over rand . Men da jeg opdagede prøvemetoden , gav det så meget mere mening:

[1, 2, 3].sample

Virkelig, virkelig enkel.

Temmelig naturligt og intuitivt. Vi beder om en prøve fra en matrix, og metoden returnerer den. Nu er jeg glad.

Hvad med dig?

At udtrykke mine tanker med Ruby-syntaks

Som jeg nævnte før, elsker jeg den måde, Ruby lader mig kode på. Det er virkelig naturligt for mig. Jeg viser dele af den smukke Ruby-syntaks.

Implicit afkast

Enhver erklæring i Ruby returnerer værdien af ​​det sidst evaluerede udtryk. Et simpelt eksempel er getter- metoden. Vi kalder en metode og forventer en værdi til gengæld.

Lad os se:

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

Men som vi ved, returnerer Ruby altid det sidste evaluerede udtryk. Hvorfor bruge afkastet erklæring?

Efter at have brugt Ruby i 3 år har jeg det godt med at bruge næsten alle metoder uden returneringserklæringen .

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

Flere opgaver

Ruby giver mig mulighed for at tildele flere variabler på samme tid. Når du begynder, koder du muligvis sådan:

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

Men hvorfor ikke tildele flere variabler på samme tid?

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

Ret sejt.

Metoder, der stiller spørgsmål (også kaldet predikater)

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

Vi lærte også, hvordan Ruby er smuk og intuitiv og løber endnu hurtigere.

Og det er det, fyre! Jeg opdaterer og inkluderer flere detaljer til min blog. Ideen er at dele godt indhold, og samfundet hjælper med at forbedre dette indlæg! ☺

Jeg håber I sætter pris på indholdet og lærte at programmere smuk kode (og bedre software).

Hvis du vil have et komplet Ruby-kursus, lære virkelige kodningsfærdigheder og opbygge projekter, kan du prøve One Month Ruby Bootcamp . Vi ses der ☺

Dette indlæg optrådte først her på min Renaissance Developer-publikation .

Hav det sjovt, fortsæt med at lære, og fortsæt altid med at kode!

Min Twitter & Github. ☺