DEV Community: Aizat Ibraimova

VS Code shortcuts

Aizat Ibraimova — Mon, 03 Jun 2024 15:11:46 +0000

% bash prompt
Ctrl + C cancel any currently running terminal
pry or rails console for interacting with a database
q to quit
cmd + K clear terminal
cmd + Shift + P Command Palette(fuzzy search)
cmd + P quick open file

Option + Cmd + J hard refresh in Chrome
ctrl + A/Cmd + A Jump back to the beginning of the line
Ctrl + E ed of the line
Cmd + F find(and replace)
Cmd + Shift + F find (and replace) Global
Cmd + D Find next selection
Shift + Option + Down Duplicate lines

Hashes and Symbols

Aizat Ibraimova — Wed, 24 Jan 2024 17:28:34 +0000

Codecademy Cheatsheet

Ruby Symbols

In Ruby, symbols are immutable names primarily used as hash keys or for referencing method names.

my_bologna = {
  :first_name => "Oscar",
  :second_name => "Meyer",
  :slices => 12
}

puts my_bologna[:second_name] # => Meyer

Symbol Syntax
Symbols always start with a colon (:). They must be valid Ruby variable names, so the first character after the colon has to be a letter or underscore (_); after that, any combination of letters, numbers, and underscores is allowed.

Make sure you don’t put any spaces in your symbol name—if you do, Ruby will get confused.

:my symbol # Don't do this!
:my_symbol # Do this instead.

What are Symbols Used For?
Symbols pop up in a lot of places in Ruby, but they’re primarily used either as hash keys or for referencing method names.

sounds = {
  :cat => "meow",
  :dog => "woof",
  :computer => 10010110,
}

Symbols make good hash keys for a few reasons:

They’re immutable, meaning they can’t be changed once they’re created;
Only one copy of any symbol exists at a given time, so they save memory;
Symbol-as-keys are faster than strings-as-keys because of the above two reasons.

Ruby Hashes, Symbols, & Values

In Ruby hashes, key symbols and their values can be defined in either of two ways, using a => or : to separate symbol keys from values.

my_progress = {
  :program => "Codecademy",
  :language => "Ruby",
  :enthusiastic? => true 
}
#Key symbols and their values can be defined with a =>, also known as a hash rocket.

my_progress = {
  program: "Codecademy",
  language: "Ruby",
  enthusiastic?: true 
}
#Key symbols and their values can also be defined with the colon (:) at the end of the symbol followed by its value.

Converting Between Symbols and Strings

Converting between strings and symbols is a snap.

:sasquatch.to_s
# ==> "sasquatch"

"sasquatch".to_sym
# ==> :sasquatch

The .to_s and .to_sym methods are what you’re looking for!

strings = ["HTML", "CSS", "JavaScript", "Python", "Ruby"]

symbols = []

strings.each do |s|
 symbols.push(s.to_sym)
end
print symbols

Besides using .to_sym, you can also use .intern. This will internalize the string into a symbol and works just like .to_sym:

"hello".intern
# ==> :hello

Ruby’s .to_sym method can convert a string to a symbol, and .to_i will convert a string to an integer.

Ruby .select Method
In Ruby, the .select method can be used to grab specific values from a hash that meet a certain criteria.

olympic_trials = {
  Sally: 9.58,
  John: 9.69,
  Bob: 14.91
}

olympic_trials.select { |name, time| time <  10.05 }
#The example above returns {:Sally=>9.58, :John=>9.69} since Sally and John are the only keys whose values meet the time < 10.05 criteria.

Ruby .each_key & .each_value

In Ruby, the .each_key and .each_value methods are used to iterate over only the keys or only the values in a hash

my_hash = { one: 1, two: 2, three: 3 }

my_hash.each_key { |k| print k, " " }
# ==> one two three

my_hash.each_value { |v| print v, " " }
# ==> 1 2 3

The Case Statement

if and else are powerful, but we can get bogged down in ifs and elsifs if we have a lot of conditions to check. Thankfully, Ruby provides us with a concise alternative: the case statement. The syntax looks like this:

case language
  when "JS"
    puts "Websites!"
  when "Python"
    puts "Science!"
  when "Ruby"
    puts "Web apps!"
  else
    puts "I don't know!"
end

A NIGHT AT THE MOVIES

movies = {
  harry_potter: 4
}
puts "What would you like to do?"

choice = gets.chomp

case choice
 when "add"
   puts "What movie would you like to add?"
   title = gets.chomp
   if movies[title.to_sym].nil?
   puts "What rating does the movie have? (Type a number from 0 to 4)"
   rating = gets.chomp
   movies[title.to_sym] = rating.to_i
   puts "#{title} was added with a rating of #{rating}!"
   else 
   puts "That movie already exists! Its rating is #{movies[title.to_sym]}'"
   end
 when "update"
   puts 'What movie would you like to update?'
   title = gets.chomp
   if movies[title].nil?
   puts "There has been an error! Please check the spelling again."
   else
   puts "What is the new rating?"
   rating = gets.chomp
   movies[title.intern] = rating.to_i
   puts "#{title} has been updated with new rating of #{rating}."
   end
 when "display"
   movies.each { |movie, rating| 
   puts "#{movie}: #{rating}"}
 when "delete"
   puts "What is the title of the movie you would like to delete?"
   title = gets.chomp
   if movies[title.intern].nil?
   puts "The movie was not found"
   else
   movies.delete(title.to_sym)
   puts "#{title} has been removed."
   end
 else 
 puts "Error!"
end

Blocks and Sorting

Aizat Ibraimova — Wed, 24 Jan 2024 04:39:03 +0000

Codecademy Cheatsheet

Ruby method
(like JS functions)

A Ruby method is a reusable section of code written to execute a certain task. It is defined with the def keyword, followed by a method name, a method body, and ends with the end keyword:

def greeting
  puts "Hello world!"
end

#In this example, the first line or header contains the keyword "def" and the method name. puts "Hello world!" is within the body of the method, which describes the certain task that the method carries out. It is also indented two spaces by convention. Following the body, the method ends with the end keyword.

Ruby Method Parameters & Arguments

In Ruby, parameters are placeholders for real values or arguments passed into a method when it is called. When calling a method that requires parameters, arguments (ie. real values) must be passed in for those parameters.

def square(num) # num is the parameter
  puts num ** 2
end

square(5) #5 is the argument
#Output => 25

Ruby Method Splat

In a Ruby method, a splat (*) operator is used to indicate that a parameter can have an unknown number of arguments.

#The * preceding the parameter "clubs" allows for multiple arguments to be passed into the method when you actually call it.
def extra_curriculars(*clubs)
  clubs.each { |club| puts "After school, I'm involved with #{club}" }
end

extra_curriculars("chess club", "gymnastics", "anime club", "library services")

#Output
#After school, I'm involved with chess club
#After school, I'm involved with gymnastics
#After school, I'm involved with anime club
#After school, I'm involved with library services
Ruby Block Parameter

Ruby Return

In Ruby, the return keyword is used to pass back a value from a method.

def generous_tip(bill)
  return bill * (0.25)
end

generous_tip(100) # 25

#In this example, the generous_tip method is returning the product of bill and 0.25. In order to see that value, a "puts" or "print" can be added before the method call.

Ruby Block

(like anonymous JS functions)

In Ruby, a block is a section of code defined within the keywords do and end or with curly braces {}. This is usually preceded by an integer followed by .times to indicate how many times the code is to be executed.

2.times do
  puts "I'm a code block!"
end  

#Output
#I'm a code block!
#I'm a code block!

3.times { puts "So am I!" }

#Output
#"So am I!"
#"So am I!"
#"So am I!"

How Blocks Differ from Methods

There are some differences between blocks and methods, however.

Check out the code in the editor. The capitalize method capitalizes a word, and we can continually invoke the capitalize method by name. We can capitalize("matz"), capitalize("Eduardo"), or any string we like to our hearts’ content.

However, the block that we define (following .each) will only be called once, and in the context of the array that we are iterating over. It appears just long enough to do some work for each, then vanishes into the night.

# method that capitalizes a word
def capitalize(string) 
  puts "#{string[0].upcase}#{string[1..-1]}"
end

capitalize("ryan") # prints "Ryan"
capitalize("jane") # prints "Jane"

# block that capitalizes each string in the array
["ryan", "jane"].each {|string| puts "#{string[0].upcase}#{string[1..-1]}"} # prints "Ryan", then "Jane"

Ruby Block Parameter

In Ruby, a method can take a block as a parameter.

Passing a block to a method is a great way of abstracting certain tasks from the method and defining those tasks when we call the method.

# The block, {|i| puts i}, is passed the current array item each time it is evaluated. This block prints the item. 
[1, 2, 3, 4, 5].each { |i| puts i }

Ruby Sort Method

In Ruby, the .sort array method is used to sort items in an array in ascending order (least to greatest).

In Ruby, there are two sorting methods, .sort or sort!. The first method, .sort, simply returns a sorted array while leaving the original array alone. The second method, .sort!, modifies the actual array.

my_array = [3, 4, 8, 7, 1, 6, 5, 9, 2]
my_array.sort!
#Attaching an ! to the end of .sort or any other Ruby method modifies the original array.
print my_array
# => [1, 2, 3, 4, 5, 6, 7, 8, 9]
#If you didn't use !, print my_array returns the original array.

Ruby Combined Comparison Operator

In Ruby, the combined comparison operator, <=>, also known as the spaceship operator is used to compare two objects. It returns 0 if the first operand equals the second, 1 if the first operand is greater than the second, and -1 if the first operand is less than the second.

puts "Keanu" <=> "Adrianna" # The first letters of each word are compared in ASCII order and since "K" comes after "A", 1 is printed.

puts 1 <=> 2 # -1

puts 3 <=> 3 # 0

#<=> can also be used inside of a block and to sort values in descending order:
my_array = [3, 0, 8, 7, 1, 6, 5, 9, 4]
my_array.sort! { |first_num, second_num| second_num <=> first_num }
print my_array
#Output => [9, 8, 7, 6, 5, 4, 3, 1, 0]

ORDERING YOUR LIBRARY

def alphabetize(arr, rev=false)
  if rev
    arr.sort { |item1, item2| item2 <=> item1 }
  else
    arr.sort { |item1, item2| item1 <=> item2 }
  end
end

books = ["Heart of Darkness", "Code Complete", "The Lorax", "The Prophet", "Absalom, Absalom!"]

puts "A-Z: #{alphabetize(books)}"
puts "Z-A: #{alphabetize(books, true)}"

def alphabetize(arr, rev = false)
  arr.sort!
  if rev == true
  return arr.reverse!
  else
  return arr
  end
end

numbers = [3, 5, 1, 6]

puts alphabetize(numbers)

Arrays and Hashes

Aizat Ibraimova — Wed, 24 Jan 2024 02:45:34 +0000

Codecademy Cheatsheet

Ruby Array

In Ruby, an array is an ordered collection of Ruby objects separated by commas and enclosed in []. An array can contain the same or different types of Ruby objects, such as Integers, Strings, Floats, etc. An array can also be empty.

numbers = [1, 2, 3, 4, 5]
#An array of Integers

words = ["See", "Spot", "run"]
#An array of Strings

mixed = ["hello", 5, true, 3.0]
#An array with a String, Integer, Boolean, and Float

empty = []
#An empty array

Ruby Array Index

In Ruby, each item inside of an array is at a numbered position called an index. The first item is at index 0, the second item is at index 1, and so on. We can access the ith element of an array by putting the index in square brackets after invoking the array’s name; this is known as access by index

example = ["Car", "Boar", 45, 9.9, true]

#For an array named `example`, you can retrieve an item of a particular index by referencing its index.

puts example[2] # => 45
puts example[0] # => Car

Arrays of Arrays

multi_d_array = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]

multi_d_array.each { |x| puts "#{x}\n" }

#[0, 0, 0, 0]

#[0, 0, 0, 0]

#[0, 0, 0, 0]

#[0, 0, 0, 0]

Ruby Hash

In Ruby, a hash is a collection of key-value pairs.

A hash is denoted by a set of curly braces ({}) which contains key-value pairs separated by commas. Each value is assigned to a key using a hash rocket (=>). Calling the hash followed by a key name within brackets grabs the value associated with that key.

profile = {
  "name" => "Magnus",
  "profession" => "chess player",
  "ranking" => 1,
  "grandmaster?" => true
}

# "name", "profession", "ranking", and "grandmaster?" are the keys. "Magnus", "chess player", 1 and true are the values.

puts profile["name"] # => Magnus

P.S Hashes are like JS objects.

Ruby Hash New

In Ruby, a hash can be created through literal notation (because we are literally assigning what key=>value pairs we want in the hash) or by assigning a variable equal to Hash.new which generates a new, empty hash.

#Creating a hash through literal notation:
lunch = {
  "protein" => "chicken",
  "greens" => "lettuce",
  "organic?" => true
}

#Creating a hash through Hash.new
lunch = Hash.new
puts lunch # => {}

Adding to a Hash
We can add to a hash two ways: if we created it using literal notation, we can simply add a new key-value pair directly between the curly braces. If we used Hash.new, we can add to the hash using bracket notation:

pets = Hash.new
pets["Stevie"] = "cat"
# Adds the key "Stevie" with the
# value "cat" to the hash

Ruby Method .Each

In Ruby, the .each method is used to iterate over arrays and hashes. This allows each element in an array and each key-value pair in a hash to be iterated.

#In this example, the each method iterates over every color in the colors array and prints it to the console.

colors = ["red", "blue", "green", "yellow"]

colors.each { |color| puts color }
#Output
#red
#blue
#green
#yellow

#When iterating over hashes, two placeholder variables are needed to represent each key/value pair.

polygons = {
  "pentagon" => 5,
  "hexagon" => 6,
  "nonagon" => 9
}

polygons.each do |shape, sides|
  puts "A #{shape} has #{sides} sides."
end
#Output
#A pentagon has 5 sides.
#A hexagon has 6 sides.
#A nonagon has 9 sides.

Iterating Over Multidimensional Arrays

s = [["ham", "swiss"], ["turkey", "cheddar"], ["roast beef", "gruyere"]]

s.each { | sub_array | sub_array.each { | item | puts item} }

#or 

s.each do | sub_array |
  sub_array.each do | y |
    puts y
  end
end

Iterating Over Hashes

When iterating over hashes, we need two placeholder variables to represent each key/value pair.

restaurant_menu = {
  "noodles" => 4,
  "soup" => 3,
  "salad" => 2
}

restaurant_menu.each do |item, price|
  puts "#{item}: #{price}"
end

Sorting the Hash

colors = { 
  "blue" => 3,
  "green" => 1,
  "red" => 2
}
colors = colors.sort_by do |color, count|
  count
end
colors.reverse!

In the example above, we first create a hash called colors that maps color strings to numbers.
Then, we sort colors into green, red, and blue, from smallest to largest by count. Just so you know, the .sort_by function returns an array of arrays, but that’s fine for our purposes.
Finally, we reverse the array order so that the colors with the largest counts are first.

CREATE A HISTOGRAM

puts "Enter a phrase you'd like to analyze: "
text = gets.chomp

words = text.split

frequencies = Hash.new(0)

words.each { |word| frequencies[word] += 1 }

frequencies = frequencies.sort_by { |word, count|
  count }


frequencies.reverse!

frequencies.each { |word, count|
  puts word + " " + count.to_s }

Ruby Loops and Iterators

Aizat Ibraimova — Wed, 24 Jan 2024 01:49:07 +0000

Codecademy Cheatsheet

Ruby while Loop

Putting a block of code in a while loop in Ruby will cause the code to repeatedly run the code as long as its condition is true.

If the block of code doesn’t have a way for the condition to be changed to false, the while loop will continue forever and cause an error.

i = 1

while i <= 3 do
  puts "Message number #{i}"
  i = i + 1
end

# Output:
# Message number 1
# Message number 2
# Message number 3

The 'Until' Loop

Putting a block of code inside an until loop in Ruby will cause the code to run as long as its condition remains false. It’s only when the condition becomes true that the loop stops.

If the block of code doesn’t allow for a way for the condition to be changed to true then the loop will continue forever and it will cause an error.:

i = 0
until i == 6
  i = i + 1
end
puts i

Ruby Assignment Operators

Assignment operators in Ruby are used to assign or update values to variables. The most common assignment operator is = but others also exist, like +=, -=, *= and /=.

a = 1;
a += 3;
puts a; # Output: 4

b = 4;
b -= 2;
puts b; # Output: 2

num = 12;
num *= 2;
puts num; # Output: 24

num /= 4;
puts num; # Output: 6

Ruby for Loop

A block of code can be repeated a set amount of times with the for loop in Ruby.

for i in 1..3 do
  puts "Message number #{i}"
end

# Output
# Message number 1
# Message number 2
# Message number 3

Inclusive and Exclusive Ranges

for num in 1...10. What this says to Ruby is: “For the variable num in the range 1 to 10, do the following.” The following was to puts "#{num}", so as num took on the values of 1 to 9, one at a time, those values were printed to the console.

The reason this program counted to 9 and not 10 was that we used three dots in the range; this tells Ruby to exclude the final number in the count: for num in 1...10 means “go up to but don’t include 10.” If we use two dots, e.g. for num in 1..10, this tells Ruby to include the highest number (10) in the range.

Ruby loop

A loop method can be used to run a block of code repeatedly in Ruby. Either use curly braces ({}) or the do/end keyword combination to wrap the block of code that will be looped.

iterator
An iterator is just a Ruby method that repeatedly invokes a block of code. The code block is just the bit that contains the instructions to be repeated, and those instructions can be just about anything you like!

num = 1
loop do
  puts "We are in the loop!"
  num += 1
  break if num > 3
end

puts "We have exited the loop!"

# Output
# We are in the loop!
# We are in the loop!
# We are in the loop!
# We have exited the loop!

The break keyword is our Get Out of Jail Free card: it breaks a loop as soon as its condition is met.

Next!
In Ruby, the next keyword is used within a loop to pass over certain elements and skip to the following iteration. It is useful for omitting elements that you do not wish to have iterated. next is followed by an if statement which defines which elements are to be skipped.

for i in 1..5
  next if i % 2 == 0
  print i
end

i = 20
loop do
  i -= 1
  next if i % 2 == 1
  print "#{i}"
  break if i <= 0
end

array

my_array = [1,2,3,4,5]

Ruby each Method

To iterate over an array in Ruby, use the .eachmethod. It is preferred over a for loop as it is guaranteed to iterate through each element of an array.

object.each { |item| 
  # Do something 
}

You can also use the do keyword instead of {}:

object.each do |item| 
  # Do something 
end

data = [3, 6, 9, 12]

data.each do |num|
  puts "The number is: #{num}"
end

# Output:
# The number is: 3
# The number is: 6
# The number is: 9
# The number is: 12

The .times Iterator
The .times method is like a super compact for loop: it can perform a task on each item in an object a specified number of times.

For example, if we wanted to print out "Chunky bacon!" ten times, we might type

10.times { print "Chunky bacon!" }

Examples:

i = 1
while i <= 50
  print i
  i -= 1
end

i = 1
until i == 50 do
print i
i += 1
end

for i in 1..50
print i 
i += 1
end

m = 0
loop do 
m += 1
print "Ruby!"
break if m >= 30
end

puts "Text to search through: "
text = gets.chomp
puts "Word to redact: "
redact = gets.chomp

words = text.split(" ")

words.each do |word|
  if word != redact
    print word + " "
  else
    print "REDACTED "
  end
end

Control Flow in Ruby

Aizat Ibraimova — Thu, 18 Jan 2024 16:26:24 +0000

Codecademy Cheatsheet

if 1 < 2
  print "I'm getting printed because one is less than two!"
end

Ruby doesn’t care about whitespace (spaces and blank lines), so the indentation of the print statement isn’t necessary. However, it’s a convention that Rubyists (Ruby enthusiasts) follow, so it’s good to get in the habit now. The block of code following an if should be indented two spaces.

When you’re done with your if, you have to tell Ruby by typing end.

Else

The partner to the if statement is the elsestatement. An if/elsestatement says to Ruby: “If this expression is true, run this code block; otherwise, run the code after the else statement.”

if 1 > 2
  print "I won't get printed because one is less than two."
else
  print "That means I'll get printed!"
end

Elsif

if x < y  # Assumes x and y are defined
  puts "x is less than y!"
elsif x > y
  puts "x is greater than y!"
else
  puts "x equals y!"
end

Unless

Sometimes you want to use control flow to check if something is false, rather than if it’s true. You could reverse your if/else, but Ruby will do you one better: it will let you use an unless statement.

Let’s say you don’t want to eat unless you’re hungry. That is, while you’re not hungry, you write programs, but if you are hungry, you eat. You might write that program in Ruby like this:

unless hungry
  # Write some sweet programs
else
  # Have some noms
end

Equal or Not

In Ruby, we assign values to variables using =, the assignment operator. But if we’ve already used = for assignment, how do we check to see if two things are equal? Well, we use ==, which is a comparator (also called a relational operator). == means “is equal to.” When you type

x = 2
y = 2
if x == y
  print "x and y are equal!"
end

you’re saying: “if x equals y, print ‘x and y are equal!’” You can also check to see if two values are not equal using the != comparator.

And

Comparators aren’t the only operators available to you in Ruby. You can also use logical or boolean operators. Ruby has three: and (&&), or (||), and not (!). Boolean operators result in boolean values: true or false.

The boolean operator and, &&, only results in true when both expression on either side of && are true. Here’s how && works:

true && true # => true
true && false # => false
false && true # => false
false && false # => false

Ruby also has the or operator (||). Ruby’s || is called an inclusive or because it evaluates to true when one or the other or both expressions are true. Check it out:

true || true # => true
true || false # => true
false || true # => true
false || false # => false

Not

Finally, Ruby has the boolean operator not (!). ! makes true values false, and vice-versa.

!true # => false
!false # => true

Combining Boolean Operators

(x && (y || w)) && z

Daffy Duckified

print "Pleathe enter a thtring: " 
user_input = gets.chomp
user_input.downcase!

if user_input.include? "s"
  user_input.gsub!(/s/, "th")
else
  puts "There are no 's's in your string."
end

puts "Your new thtring is #{user_input}."

For the if half of our branch, we want to check whether the user’s input contains an "s".

if string_to_check.include? "substring"

When we find "s", we want Ruby to replace every instance of "s" it finds with "th". We can do this with the .gsub! method, which stands for global substitution.

The syntax looks like this:

string_to_change.gsub!(/s/, "th")

Intro to Ruby

Aizat Ibraimova — Thu, 18 Jan 2024 04:09:20 +0000

Codecademy Cheatsheet

Everything in Ruby is an Object

'puts' and 'print'

The print command just takes whatever you give it and prints it to the screen. puts (for “put string”) is slightly different: it adds a new (blank) line after the thing you want it to print. You use them like this:

puts "What's up?"

print "Oxnard Montalvo"

No parentheses or semicolons needed!

The '.length' Method

"I love espresso".length
# ==> 15

The '.reverse' Method

"Eric".reverse

will result in

"cirE"

'.upcase' & '.downcase'

puts "Aizat".upcase

puts "Aizat".downcase

Multi-Line Comments

=begin

This is for when

you have a lot of comments to write! 

=end

Strings and String Methods
In Ruby, you can do this two ways: each method call on a separate line, or you can chain them together, like this:

name.method1.method2.method3

name = "Jamie"

puts name.downcase.reverse.upcase

gets.chomp
gets is the Ruby method that gets input from the user. When getting input, Ruby automatically adds a blank line (or newline) after each bit of input; chomp removes that extra line. (Your program will work fine without chomp, but you’ll get extra blank lines everywhere.)

variable_name = gets.chomp

Formatting with String Methods

print "This is my question?"
answer = gets.chomp
answer2 = answer.capitalize 
answer.capitalize!

First we introduce one new method, capitalize, here. It capitalizes the first letter of a string and makes the rest of the letters lower case. We assign the result to answer2
The next line might look a little strange, we don’t assign the result of capitalize to a variable. Instead you might notice the ! at the end of capitalize. This modifies the value contained within the variable answer itself. The next time you use the variable answer you will get the results of answer.capitalize