Forem: Felix Imbanga

More Classes

Felix Imbanga — Sat, 23 Mar 2024 04:08:44 +0000

def year=(new_year): Defines a setter method that allows you to set the value of @year with car.year = 2022.
def year(new_year): Defines a regular instance method that needs to be called with car.year(2022) and does not assign the value to @year unless you explicitly do so inside the method.

sentences = [
  "the dog, the cat, the zebra, the giraffe",
  "the, the code, and the developer",
  "then the- their"
]
sentence = sentences.sample
pp sentence
# write your program below
the_count = sentence.scan(/\bthe\b/).count
pp "'the' appeared #{the_count} times"

The issue with the code is how the .count method is being used. The .count method in Ruby, when used on strings, doesn’t count occurrences of whole words but instead counts individual characters that match any in the set of characters provided as an argument. In this case, new_sentence.count("the") is counting each occurrence of ‘t’, ‘h’, and ‘e’ individually, not the word ‘the’.

To count occurrences of the whole word ‘the’, you would need to use a different approach, such as using the .scan method with a regular expression that matches the word ‘the’ followed by a boundary to ensure it’s a whole word:

Here, /\bthe\b/ is a regular expression where \b denotes a word boundary, ensuring that only the whole word ‘the’ is matched, not ‘the’ within other words like ‘then’ or ‘their’. The .scan method returns an array of all matches, and calling .count on that array gives you the number of times the whole word ‘the’ appeared in the sentence.

If statements

Felix Imbanga — Wed, 20 Mar 2024 16:49:28 +0000

Type end immediately after typing the if. Indent
elsif is only when you need to check more than 2 conditions.
Causing code to execute is known as 'truthy'
Causing code to not execute is known as 'falsy'
Only nil and false are falsy.
!= means not equivalent
p if for quick inspection, pp is for more human readable representations. especially with complex data structures.
In variables you can put methods on both sides to evaluate if statements more concise.
&& both statements have to be true
|| at least one statement has to be true.

Integer, Float, and Array class

Felix Imbanga — Wed, 20 Mar 2024 16:42:19 +0000

Integer class
/ when dividing only returns the whole
% returns the remainder
Rubyists tend to end method names with a question marks when methods return true or false.
rand returns a random number. rand(n) will return a random integer between 0 and n-1 rather than 1 and n
object#method is different from object.method
.to_f is useful in converting an integer to a float.

Float class
Division with floats works the way we're used to. It returns fractional results, as a float.
If either number when dividing with \ is a float, float division will be performed.
rand can also be called without methods.
push == << for shorthand.

Array class
.at method in an array refers to the index, which starts at 0. nil represents absence of in index in the array aka doesn't exist.
In an array, to count backwards through a list of items, start with -1 (aka the last item)
.at == object[index] shorthand.
.index method returns the index where it resides
.split will return an array of substrings
.split with an argument tells the program to split at the character of the argument.
.spliting with an empty argument ("") turns a string into an array of individual characters.
.count counts how many items are in a list if called with no arguments. If an argument is provided it counts how many times that argument occurs in the list.
.sample returns an unpredicted item from an array

String and Date classes

Felix Imbanga — Wed, 20 Mar 2024 16:27:54 +0000

String Class
Formal way to create a new object is with the .new method
.concat method accepts a number as a method, interprets it as an ASCII code, translates it from a single character, and adds it to the end of an original story.
.concat can be replaced with +, you can also drop the ., as well as the parenthesis.

Data Class
Arguments within pp p print or puts need to be seperated with a comma or with interpolation. Date.parse() accepts a string and converts it to a Date object.

String Interpolation + printing
Alternative to .to_s
Easier when it comes to composing strings
Only double quotes interpolate
pp shows the gory technical details, which is usually what you want when debugging code. It calls inspect on whatever object you give it. backend?
puts calls a method .to_s on whichever object you give it. Better for human interaction, frontend?
\n represents a new paragraph or line break. An active character.
\s represents a space between within a line.
Single quotes within double quotes is one way to include a string within a string.
If you want double quotes you need to use the escape character backslash.

"\"Felix\"" ---> "Felix"
The \ before " says treat this next quotation as a character not as the string literal syntactic sugar.
ms = multiline string as long there is one opening and closing quote.

What, why, how

Felix Imbanga — Wed, 20 Mar 2024 16:13:19 +0000

Ruby has a lot of advantages for beginners. Rails is also good for small teams, and solo developing.

self is a special object that represents different objects at different times.
pp is a method we use to call the main object "pretty print"
syntactic sugar makes things easier to print
object.method - the primary method to write examples. what we will be using most often
object.method(parameter) - make up an expression which is the return value.
self.pp is more useful when debugging or when you want to inspect data in a more human reading format. Shows the structure and nesting which makes it easier to understand complex nested objects.
gsub - globally substitute, will replace all occurrences of one substring w another substring. Often used to remove illegal characters from usernames before saving.
Skill leves as a programmer is essential and about the number of error messages that you have encountered in the past and now recognize.
use #comments liberally.
= - variable assignment operator, evaluates right side first. Most ruby methods don't modify the object they are called upon. Rather they just return a modified copy.
Variables can only contain lowercase letters, numbers, and underscores, no spaces and cant begin with a number. They should be descriptive no matter the length.

Object oriented programming

Felix Imbanga — Tue, 19 Mar 2024 00:59:10 +0000

Almost everything in ruby is an object. Class names in ruby use CamelCase. initialize is a method used to boot up each object the class creates. Use @ before a variable to signify that it always is an instance variable. This means that the variable is attached to the instance of the class.

@ - whenever a class is created, it has to have your @ and each instance of your class will have its own @. Scope of a variable is the context in which it is visible to the program.

Global variable - available everywhere
Local variable - only available in methods
Class - only available in classes
Instance - only available in instances of classes.

Class variable begin with @@
Global variables inside a method or class begin with $

Inheritance - process by which one class takes on the attributes and methods of another. It is used to express and is-a relationship. When you call super from inside a method, that tells ruby to look in the superclass of the current class and find a method with the same name as the one from which super is called. If it finds it, ruby will us the superclass version of the method. Mixins, allow for data and functions of multiple classes to be put in one.

If you want to end a ruby statement without going on a new line you can just type a semicolon.

Public methods allow for an interface with the rest of the program. Private methods are for classes to do their work undisturbed. In private methods, methods cannon be called with an explicit receiver. in order to access private info we have to create public methods such as attr_reader and attr_writer. These are shorthand notations for defining getter and setter methods within a class for instance variables. Important in object orienting encapsulation principle.

module - a toolbox that contains a set of methods and constants. These are written in CamelCase. Constants included in methods are defined with all caps.

name-spacing - how ruby separated methods and constants.
scope resolution operation - ruby's way of saying it tells rubys where you're looking for a specific bit of code.

If we say Math::PI ruby knows to look inside the math module to get that PI, not any other PI.

In the following code : def initialize (name, balance=100)
This signifies an optional parameter
Ruby is saying that you can pass 1 or 2 arguments to initialize. If you pass 2, it uses your balance argument to set @balance. If you only pass name, balance gets a default value of 100 and this is what is stored in balance.

In Ruby , private methods can be called without an explicit receiver within the context of a class.

Blocks, Procs, and Lambdas

Felix Imbanga — Tue, 19 Mar 2024 00:37:45 +0000

Lambdas - nameless methods. This is how methods accept blocks using the yield keyword.

.collect method - returns a copy of a variable, doesn't change or mutate the original variable. ie .collect! in which the ! means this method can do something dangerous in ruby.

Blocks - these are one of the few exceptions of things that aren't objects in ruby. Bit of code between do or end or {}, but can be passed to methods like .each or .select.

Proc - a block which is saved to a variable. Good for keeping code DRY aka Dont Repeat Yourself.

To pass a proc to a method expecting a block use & right before the the parameter.

Procs are objects so they have the power/abilities of objects and can be called over and over. This prevents you from having to retype the contents of your block every-time you need to execute a particular block of code.

We can call procs directly by using ruby's .call method

Remember, in ruby there is always more than one way to do something.

I learned I cant puts a proc because it is an object not a string, this will print the memory address instead of a proc. procs are callable objects that contain blocks of code and to see the effect of the code within a proc, you must call it. Lambdas are also objects.

**Lambdas vs procs
Lambdas check the number of arguments passed to it while a proc does not. This means lambdas will give an error if you a pass it the wrong number of arguments. While a proc will ignore unexpected arguments and assign nil to any missing arguments.
When Lambdas return, control is passed back to the calling method. When a proc returns it does so immediately without going back to the calling method.
& is used to pass a lambda.
() and {} are important in the syntax of lambdas.

String Interpolation/Refactoring in Ruby

Felix Imbanga — Thu, 14 Mar 2024 21:37:00 +0000

You can always add + or << to add a variable value into a string "#{interpolation}"

Refactoring - fancy way of saying we're improving the structure or appearance of code without changing what it actually does.
Omit needless words
Make sure to us the when defining methods
Using puts inside methods is generally discouraged if the methods are meant to be used as part of a library or for refactoring values as it can lead to unwanted console output. puts is mostly used for debugging or for scraping that interaction directly with the user via the terminal.

Zen of Ruby

Felix Imbanga — Thu, 14 Mar 2024 17:20:14 +0000

Ternary operation- takes 3 arguments; boolean, expression to determine if boolean is true + one to determine falseness
syntax = boolean? Do this if true(Evaluate this if true):Do this if false(Evaluate this if false)
Only requires 1 puts statement at boolean part.
|| - used to only assign a variable which hasn't been assigned. nil is ruby for nothing.
Ruby's method will return the result of the last evaluated expression unlike python where you have to explicitly state the evaluation. No need for return

Short circuit evaluation
Better tools to handle repetitive tasks in ruby than for loops. To evaluate a specific number of times use .times method. To repeat an action for every element in a collection use .each method.

Single blocks are great for short/concise operations where multi line blocks using do and end are more practical for longer/more complex operations.

Refactoring - Ruby

Felix Imbanga — Tue, 12 Mar 2024 17:03:51 +0000

case statement - a concise alternative to if/else statements. I wondered why there's so much change between the syntax of case and if/else statements.

There should be 4 verbs of your programs operations aka operations that add, display, update, and delete or CRUD for short. These are actions you take when you update an entry in a database, ask a website for info, write a blog post. I'll see these in everything from API calls to web frameworks like ruby on rails.

Ruby is a language prioritizing program productivity over program optimization.

I don't need and end when my if statement is on one line.

Ordering your library + Hashes and symbols

Felix Imbanga — Sat, 02 Mar 2024 21:33:25 +0000

Today I worked on ordering my library as well as hashes and symbols. I learned about def methods and parameters. Also learned about rev=false and this causes def methods to default to false if the user types in 2 arguments. I should also remember to put == in conditionals, I've been making the mistake of putting = which is used for assignment.

Building on methods is great for using code over and over without having to retype things but it is also great for abstracting or simplifying your program.

There are two ways to write hashes
Hash literal notation is new_hash = { "one" => 1 } ornew_hash = Hash.new`

Along with false, nil is one of 2 non-true values in ruby. Every other object is regarded as truthful. False means not true. nil is ruby's way of saying nothing at all.

You can add key/value pairs in Hash.new like this:
empty_hash = Hash.new
empty_hash.store(:key, "value") If you want to provide a default value for any key that doesnt exist in the hash, pass this argumentdefault_hash = Hash.new("default"). This will return default instead of nil`. The hash is empty until you explicitly add key-values when using this method.

symbols- can only be one copy of a particular symbol at a given time. They can start with a : and spaced with a _. They are primarily used with hash keys for referencing method names. They are immutable meaning they cant be changed once created. Only one copy exists at a given time, saving memory. Symbol-as-keys are faster than string-as-keys. .to_s is to string while .to_sym converts to symbol. .intern is also another way to convert to a symbol.

With the new update, symbol syntax has changed to where you put the : after the symbol instead of before it, you dont need the hash rocket anymore.

Blocks and Sorting Ruby

Felix Imbanga — Fri, 01 Mar 2024 03:37:00 +0000

This is a good example of methods and splat arguments from codeacademy's training

def what_up(greeting, *friends)
  friends.each { |friend| puts "#{greeting}, #{friend}!" }
end

what_up("What up", "Ian", "Zoe", "Zenas", "Eleanor")

Methods are reusable sections of code that perform a specific task in a program

seperation of concerns- make program less redundant and code more readable.

Methods defines a new
-header include the def key word
-Body included the procedure the methods carries out
-end includes the end key word
argument - code that you put between a methods parenthesis when you call it, parameter is the name you put between methods parenthesis when you define it.

Splat argument - argument preceding an asterisk. tells program you can use 1 or more arguments

puts always returns nil when included in a method. you must use something like return because puts will be evaluated in the expression

ruby evaluates for expression truthiness/falsiness. An expression in ruby will inherently return a boolean value when used in a context that expects a boolean. Without needing explicit statements of return false or return true.

abstraction - making something simpler.

sort is non destructive while sort! is destructive. the first stores original string while the latter erases and completely creates a new string. they each have their benefits based on what you plan on doing with your code.

<=> means if 1>2 then 1 is returned, if 1<2, -1 is returned, and if the values are equal 0 is returned. Also be careful not to set this equal to a variable because ruby will print out the numeric value to the console, rather than ordered strings.