DEV Community: Andressa

Receiving input from user in Ruby

Andressa — Wed, 20 Jul 2022 22:47:37 +0000

How gets actually work under the hood

It uses the $stdin global variable. It represents the current standard input.

The method gets, communicates with the input stream on your computer ( which is connected to your Operating System ) receiving data from the $stdin global variable and assigning it to your variable while returning the value stored with a new line char appended at the end.

irb(main):005:0> name = gets
andressa
=> "andressa\n"

we can get rid of the new line char by calling the chomp method.

irb(main):006:0> name = gets.chomp
andressa
=> "andressa"

If dealing with files, it returns nil when reaching the end of the file.

gets receives input in a string format, so if you are expecting to deal with integers, for example, you will need to convert it to an int first.

irb(main):009:0> number = gets.chomp
34
=> "34"                                                                         
irb(main):010:0> number.class
=> String

Variables in Ruby

Andressa — Sat, 18 Jun 2022 10:40:50 +0000

Quick index

What are variables?
Duping and Freezing Objects
Types of variables

What are variables?

They are a pointer to a memory location. A reference. So when we assign it, it will actually hold the address in memory in which that object is stored.

for example:

address_holder = 'I am a String obj'
second_address_holder = address_holder

puts address_holder.object_id == second_address_holder.object_id #=> true

If I change my string object, both variables should display the same:

pointer_to_location.upcase!

puts address_holder            #=> I AM A STRING OBJ
puts second_address_holder     #=> I AM A STRING OBJ

References have a many-to-one relationship to their objects.

Immediate values
That behaviour is not always true. Some objects in ruby are stored in variables as immediate values: integers, symbols, true, false, and nill.

Any object that is represented as an immediate value is always exactly the same object, no matter how many variables it is assigned to. There is only one object 100, only one object false, and so on¹.

Note that, if I reassign a variable, it will now point to another location. Take as an example:

a = 'first location'
b = a 

puts a.object_id    #=> 720
puts b.object_id    #=> 720

a = 'second location'

puts a.object_id    #=> 740
puts b.object_id    #=> 720

Variable b in this case, is still pointing for the memory address a was pointing. Variable a is now pointing to a new location.

❗️ Ruby is not a typed variable language, which means we can assign a string to a variable now, and later on, we can assign an integer to it with not problem.

Duping and Freezing Objects

To protect objects from being changed there are three methods available:

freeze prevents from undergoing further change.
dup will duplicate the object. If you duplicate a frozen object, the duplicated one will not be frozen.
clone a lot like dup, but if you clone a frozen object, the clone will be also frozen.

note: if you freeze an array, you will be freezing the array itself, not the elements of it.

Types of variables

Constants Even though Ruby allows us to change those variables, they are used for variables that do not have a need to change or should not be changed.

MY_CONSTANT = 'I should not be changed through the application'

Global variables They are accessible through the whole application and it is not recommended to use them if there is no need for it.

$global_variable = 'try avoiding me'

Class variables They are accessible through the entire class and by instances of it.

@@class_variable = 'I can be modified inside my class or its instances.'

Instance variables Those are only available inside the instance of the parent class.

@instance_variable = 'I don't follow strictly the scope rules.'

local variables most common one.

local_variable = ''

References

David A. Black and Joseph Leo III. 2019. The Well-Grounded Rubyist. 3rd ed. ↩

Strings in Ruby

Andressa — Fri, 10 Jun 2022 02:11:18 +0000

Quick index

String Creation
Single and Double quotes
String Manipulation
1. Escape Characters
2. Concatenation
3. Substrings
4. Methods
Symbols vs Strings
References

String creation

A string can be created by using String literal:

greetings = 'hello all!'

with String::new you have more options for creating a string, mostly regarding the encoding type you want your string:

greetings = String.new('hello all!', encoding: 'ASCII')

or if you need a multiline string, you can use heredoc literal:

s = <<HEREDOC
This would contain specially formatted text.

That might span many lines
HEREDOC

Note that it is a good way to add snippets of code, specially SQL if you are in the backend connected to the database, for example.

It preserves the original formatting and can have interpolation inside of it as well. Here we have two good examples from Ruby Guides:

type  = "healthy"
table = "food"
query = <<-SQL
SELECT * FROM #{table}
WHERE #{type} = true
SQL

doc = <<-TIME
Current time is #{Time.now}
TIME

print doc  #=> Current time is 2022-06-07 14:51:09 +0000

We can use single quotes to disable the interpolation.

doc = <<-'TIME'
Current time is #{Time.now}
TIME

print doc  #=> Current time is #{Time.now}

Single (hard) and double (soft) quotes

Interpolation: #{ sequence }. We can place any code inside it. It is very useful.

We call single quotes as hard quotes because it is not possible to use interpolation within it, nor escape characters.

name = 'all'
print 'hello #{name}!'  #=> hello #{name}!

On the other hand, double quotes allows interpolation and to escape chars, and that is why we call it soft quotes.

name = 'all'
print "hello #{name}!"  #=> hello all!

⁉️ For readability, it is recommended to use doble quotes only when the interpolation is present, but there is no problem if you decide to use only double quotes through your code.

String Manipulation

Escape Characters

Some chars have a special meaning. For example, " can terminate a string before the intended. We can add a backslash in front of it to be able to display it in our string.

print "Double quotes: \""  #=> Double quotes: "

Here is a list of some escape sequences:

escape sequences
\b	backspace, ASCII 08h (BS)
\t	horizontal tab, ASCII 09h (TAB)
\n	newline (line feed), ASCII 0Ah (LF)
\v	vertical tab, ASCII 0Bh (VT)
\f	form feed, ASCII 0Ch (FF)
\r	carriage return, ASCII 0Dh (CR)
\e	escape, ASCII 1Bh (ESC)
\s	space, ASCII 20h (SPC)
\	backslash, \
\nnn	octal bit pattern, where nnn is 1-3 octal digits ([0-7])
\xnn	hexadecimal bit pattern, where nn is 1-2 hexadecimal digits ([0-9a-fA-F])
\unnnn	Unicode character, where nnnn is exactly 4 hexadecimal digits ([0-9a-fA-F])

Concatenation

The same way you can use interpolation to group strings, you can use concatenation.

print 'hello' + ' all' #=> hello all

print 'hello' << ' all' #=> hello all

print 'hello'.concat(' all') #=> hello all

Substrings

We can access substrings by accessing its indexes just like we would do with an array.

"hello"[0]      #=> "h"

"hello"[0..1]   #=> "he"

"hello"[0, 4]   #=> "hell"

"hello"[-1]     #=> "o"

Methods

There is a long list of methods to support you to handle a string. What is important to note is that in general methods ending with a bang mutantes self and returns self.

Methods that do not have a bang, usually, do not mutate and return a new string.

take the methods capitalize and capitalize! as an example:

a = "hello all!"
a.capitalize

print a #=> hello all!

a.capitalize!

print a #=> Hello all!

Best practice is always to pay attention to the return. Some methods like replace does not have a bang, but modifies self either way.

You can take a look at the methods available here

Symbols vs Strings

symbols are stored in memory only once and it makes things faster. Good for use in hashes.

Strings, on the other hand, need to be stored every time it is used because it can change its content.

"string".object_id == "string".object_id  #=> false

:symbol.object_id == :symbol.object_id    #=> true

References

5 Different methods to print data in Ruby

Andressa — Fri, 10 Jun 2022 01:39:44 +0000

Quick index

print vs puts
1. puts
2. print
p vs pp vs ap
1. p
2. pp
3. ap
How they actually work
References

print vs puts

First thing to notice, they print the content, but both return nil.

puts

Appends a new line at the end of the return
Attempts to convert everything into a string by calling the to_s method

irb(main):002:0> puts "take a look at where the cursor is :) "
take a look at where the cursor is :) 
=> nil                                  

irb(main):004:0> 2.times {puts "hey you!"}
hey you!
hey you!                                                                        
=> 2     

# Puts converts everything it cans to string
irb(main):031:0> puts [1,nil,nil,2]
1


2
=> nill

print

no new lines appended here

irb(main):001:0> print "you should not see a new line at the end"
you should not see a new line at the end => nil

irb(main):003:0> 2.times {print "hey you!"}
hey you!hey you! => 2

print [1,nil,nil,2]
[1, nil, nil, 2] => nil

p vs pp vs ap

It is more useful for debugging as it will show ( return ) a raw version of the object.

They are similar to puts as it adds a newline at the end, but instead of calling to_s:

p

calls the inspect method.

irb(main):033:0> p 1
1
=> 1                                             
irb(main):034:0> p '1'
"1"
=> "1"                                           
irb(main):035:0>

irb(main):035:0> puts 1
1
=> nil                                           
irb(main):036:0> puts '1'
1
=> nil                                           
irb(main):037:0> puts '1'.inspect
"1"
=> nil

pp

calls the pretty_inspect method. More useful when dealing with complex nested objects.

irb(main):038:0> data = [ false, 42, %w(forty two), { :now => Time.now, :class =
> Time.now.class, :distance => 42e42 } ]
=> 
[false,                                                                         
...                                                                             
irb(main):039:0> pp data
[false,
 42,                                                                            
 ["forty", "two"],                                                              
 {:now=>2022-06-09 12:06:44.161486 -0400, :class=>Time, :distance=>4.2e+43}]    
=>                                                                              
[false,                                                                         
 42,                                                                            
 ["forty", "two"],                                                              
 {:now=>2022-06-09 12:06:44.161486 -0400, :class=>Time, :distance=>4.2e+43}]    
irb(main):040:0>

ap

Most recently version of Ruby does not contain ap [at the time of writing this article, ruby 3.1.2], you will have to install it by running:

gem install awesome_print

and will have to add require "awesome_print" into your irb session.

irb(main):002:0> require "awesome_print"
=> true
irb(main):003:0> data = [ false, 42, %w(forty two), { :now => Time.now, :class =
> Time.now.class, :distance => 42e42 } ]
=> 
[false,                                 
...                                     
irb(main):004:0> ap data
[
    [0] false,                             
    [1] 42,                                
    [2] [                                  
        [0] "forty",                       
        [1] "two"                          
    ],                                     
    [3] {                                  
             :now => 2022-06-09 12:56:59.184906 -0400,
           :class => Time < Object,
        :distance => 4.2e+43
    }
]
=> nil

How they actually work

They all use the $stdout global variable. It represents the current standard output.

Those methods we have talked about today, communicate with the output stream on your computer (which will communicate with the Operating System) by sending the message using the $stdout global variable, and output the message to the console.

References

Numbers in Ruby

Andressa — Tue, 07 Jun 2022 02:08:46 +0000

Quick index

Numeric
1. Integer
2. Float
3. BigDecimal
4. Complex
5. Rational
Important Notes
Summary from wikibooks.org
References

Numeric

Numeric is the parent class for all numeric classes existing in ruby and it inherits directly from the Object class.

As you might know, when we create an object, it is stored in the Heap designated memory space. It is the Numeric class that allows the allocation of a physical address in the heap for that numerical instance.

Each other child class is a single immutable object passed by value. There can only ever be one instance of a number.

a = 1  
a.object_id == 1.object_id #=> true

In Ruby, negative numbers can be represented by placing a minus sign in front of it. Just like in -404.

An underscore can be placed to separate the thousands if you wish. As it is in 1_234.56. At the end of the day, that underscore will be ignored by the compiler.

Integer

Integers are whole numbers, used when we don't care about precision.

Parent class for Fixnum and Bignum in the past. Nowadays, Fixnum and Bignum are considered deprecated, but under the hood they function the same way.

Fixnum represents all whole numbers that fits into 32 or 64 bits.

Bignum represents whole numbers that are outside that range.

1.class #=> Fixnum
100000000000.class #=> Bignum

Float

Float point numbers are the ones with decimal places. Although they are often used to have a more exact result, they are quite imprecise because of rounding errors. So you could see something like this:

(2.0-1.1) == 0.9 #=> false

This is not a Ruby particularity, it is like that because of the way floats are stored, and it would only be a concern if you need a very precise results.

2.0-1.1 #=> 0.8999999999999999

BigDecimal

That is the one to go if you need that extreme precise result.

The down side: it is 12x slower than a float and that is the reason float is the default.

Complex

This type is used when pairing real number with an imaginary number.

2+1i                 #=> (2+1i)
Complex(1)           #=> (1+0i)
Complex(2, 3)        #=> (2+3i)
3.to_c               #=> (3+0i)

Rational

They are used for fractions. They have the numerator and denominator. To represent one, we just need to add r to the fraction:

1/4r + 2/4r #=> 3/4

Important notes

Calculations with two integers, will always result in an integer. 5/2 #=> 2
To get a more precise result, use one of the operands as a float. 5/2.0 #=> 2.5
There is a bunch of methods available for Numerics in general, for Integers, Floats, BigDecimals, Complexes, and Rationals as well.

Summary from wikibooks.org

numbers	Its type
123	Fixnum
-123	Fixnum (signed)
1_123	Fixnum (underscore is ignored)
-543	Negative Fixnum
123_456_789_123_456_789	Bignum
123.45	Float
1.2e-3	Float
123.45r	Rational, introduced in ruby 2.1
0xaabb	(Hexadecimal) Fixnum
0377	(Octal) Fixnum
-0b1010	(Binary [negated]) Fixnum
0b001_001	(Binary) Fixnum
?a	ASCII character code for 'a'(97)

References

Starting over again...

Andressa — Sun, 05 Jun 2022 06:04:52 +0000

I never had a blog before, thought it would be a perfect occasion for a first time.

Even thought I don't know where it will get, my intension is to take a look back in a couple of years and see where I was when I decided to start over.

A brief introduction would be very welcomed.

My name is Andressa, 30yo, Brazilian. Decided to start a new career in tech when I was 27. Long story short, hated my career at the time and wanted to do something that could make me excited and proud. Existential crises? maybe 👀

I got to college again, thought I could not make it, but I made it and I am going to my convocation ceremony in 10 days from now [Jun 15, 2022] 👩🏻‍🎓🥳

and why have I decided to name my first post here as "Starting over again"?

Well, giving a brief overview... I got my first full-time development job in a big company. At that time, I could not even put in words how delightful I was. Could not be happier. I was so proud of myself! my family and I were celebrating all the time. I was literally thinking I could do everything, but I couldn't. Things were way different than what I was told, and from what I was expecting.

I started to feel devastated. And here I want to emphasize that I was feeling terrible. I am still felling terrible. Was not on my plans to quit, but I decided to quit. I decided to quit because I knew I could do better. I always wanted to be productive and grow as a developer, and my decision was based on that.

oh boy, I am starting again. Looking for a new full-time development job. Starting again to search companies I want to work for, starting again to write resumes and cover letters, starting again to wait for responses to positions I have applied for, starting again to have those moments of felling I am not good enough. That is scary AF, but Andressa, you got this.

You had your downs, but you were always determined and always got where you decided to get. You are about to find a job you will love and a job you will proudly say "oh yeah, I work there! 😎". I trust you. Your family trusts you. We know everything is gonna be just fine.

Finally, I am starting this blog to document the process of reviewing coding concepts I find important to have well grounded, and also sharing my progress through this journey again.