DEV Community: akaaronkim

Ternary ? Conditionals : JavaScript

akaaronkim — Wed, 04 Mar 2020 19:23:40 +0000

What is best practice when it comes to conditions? When using standard conditions, it takes a couple blocks of code to get an assignment finished.

Let's take a look at what a standard conditional looks like.

const isAaronTired = true;
let energy;

if (isAaronTired) {
     energy = "5 Hour Energy";
} else {
     energy = "Willpower"
}

Do you see how many blocks that took? Yeah I know.

We will take this step by step to make our code shorter and more concise.

const isAaronTired = true;
let energy;

//Ternary conditional start:

 `yourCondition`

//you are checking your condition first

const isAaronTired = true;
let energy;

//Ternary conditional operator follows:

yourCondition `?`

//the question mark operator is there to separate the condition and the action

const isAaronTired = true;
let energy;

//Ternary conditional expression:

yourCondition ? `chooseThisForTrue : chooseThisForFalse`


//a colon separates the expressions. Left for true and right for false.



const isAaronTired = true; 
let energy;

//Standard Conditional


if (isAaronTired) {
     energy = "5 Hour Energy";
} else {
     energy = "Willpower"
}


//standard conditional converted into a ternary conditional

yourCondition ? chooseThisForTrue : chooseThisForFalse

isAaronTired ? "5 Hour Energy" : "Willpower"

//because const isAaronTired is true we use the left expression of the ternary expression which is "5 Hour Energy"

If you want to store the variable then you just add it to the ternary conditional.

const isAaronTired = true;
let energy;

let energy = isAaronTired ? "5 Hour Energy" : "Willpower"

//energy is now set to "5 Hour Energy"

If you want to concatenate using a ternary conditional, make sure to wrap it with parentheses

const isAaronTired = true;
let energy;

return "Aaron is using:" + (isAaronTired ? "5 Hour Energy" : "Willpower")

You can also compound ternary conditions.

const isAaronTired = true;
const doesAaronHaveAProjectDue = false;


return "Aaron is using:" + (`isAaronTired && doesAaronHaveAProjectDue` ? "5 Hour Energy" : "Willpower")

//because one variable boolean is false, the condition is false. 
// it would return "Aaron is using: WillPower"

There can be multiple actions as well.

const isAaronTired = true;
const doesAaronHaveAProjectDue = true;

let energy;
let decision;

isAaronTired && doesAaronHaveAProjectDue ? 
    (energy = "5 Hour Energy", decision = "power through")
     : 
    (energy = "Willpower", decision = "lie in bed")

return "Aaron needs a" + energy + "and" + "his decision is to" + decision

//it will return "Aaron needs a 5 Hour Energy and his decision is to power through"

Nesting a ternaries is also possible.

const isAaronTired = false; 
const doesAaronHaveAProjectDue = true;
const timeLeft = true;
let time;
let energy;
let decision;


isAaronTired && doesAaronHaveAProjectDue ? 
  (energy = "Willpower", decision = "lie in bed")
  : 
  timeLeft ? (time = "2 days" : time = "no time left")

return "Aaron has" + time + "to do his project"

//it will return "Aaron has 2 days to do his project"

There are so many ways to use ternary conditionals. Implement them into your practice and your peers will thank you for it!

Basics to Restful Routes

akaaronkim — Wed, 22 Jan 2020 20:56:00 +0000

Understanding how to create routes is essential in Rails. So we are going back to the fundamentals because rails is magical on what it can do for you. Let's take that away and see how rails can interact within.

The main thing though to take away from this is that the Route is such an important part of the application if and especially in these server rendered applications, kind of the type of things, you build when you're building fully in rails. If your browser had no JavaScript you disabled it, the only way a user could ever interact with your application would be through a route. It's this endpoint that is put in the address bar of a browser. So it's really important that you understand that when you're in your address bar, you know this might say Google.com everything after the slash is the only real way that you interact with the application and most the time of course the user doesn't actually type that in your dress they're clicking on a link or they're clicking on a button in a form and that's really just going to another endpoint. This is the only real way a user communicates with your app.

Understanding how to build that from the very beginning is very important. A route is made up of a unique pairing of the method also known like the HTTP verb and the endpoint itself, which is just the the structure of everything after that slash. You can have one unique route the pairs a gap verb with this specific URL now you can put other verbs in front of it that could be put, post, delete, etc. But the unique pairing is very important. And then what a route does is it specifically says go to this controller and (this) action on the controller it's a very that you will you can have multiple routes go to the same controller action but which is generally quite rare but whatever your route is doing it is very specifically going through a controller action.

And then another thing that might always be a apps wish because rails hides it is that it always renders a view. The reason this doesn't seem so obvious is because in a controller on Rails, if you don't say render review it will choose where to render it instead by convention. But you can always choose to render something else entirely that doesn't match the convention. Understanding how to do that and when to do that is very important.

class PostsController < ApplicationController

 def index
   render '/app/views/posts/index.html.erb'
 end
end

Finally the view will always just spit out a new piece of HTML on your in your browser that will have other links that will go to other routes. There was one other piece to cover in that in rails, specifically rails, is that it provides what is called helpers. You have probably heard of
helpers in terms of view helpers and form helpers. Helpers are really just a ruby method a named Ruby method that you call and it will execute a block of code for you. These helpers get attached to your route and it is a way to say, “anytime I want to call this specific route the get posts route” I can use this posts_path and and that will send through to this route. So instead of having to explicitly write out the route you can use the helper.

Sharpen your code through Pry

akaaronkim — Thu, 02 Jan 2020 20:55:52 +0000

Navigating through an unknown territory is frustrating when you don't have the the right tools guide you. As a programmer, I often wrote code aimlessly until I got the right response. It felt good until I dove deeper and deeper into my learning that the knowledge that I've built failed to explain my understanding of the language- Ruby. This isn't the case anymore. And here is an excerpt from a book called The 7 Habits of Highly Effective People, that illustrates mindfulness in coding.

There's a guy who stumbled into a lumberjack in the mountains. The man stops to observe the lumberjack, watching him feverishly sawing at this very large tree. He noticed that the lumberjack was working up a sweat, sawing and sawing, yet going nowhere. The bystander noticed that the saw the lumberjack was using was about as sharp as a butter knife. So, he says to the lumberjack, "Excuse me Mr. Lumberjack, but I couldn't help noticing how hard you are working on that tree, but going nowhere." The lumberjack replies with sweat dripping off of his brow, "Yes... I know. This tree seems to be giving me some trouble." The bystander replies and says, "But Mr. Lumberjack, your saw is so dull that it couldn't possibly cut through anything." "I know", says the lumberjack, 'but I am too busy sawing to take time to sharpen my saw."

-Stephen R. Covey

Surely, practicing as much as possible will improve your skills the best. But we definitely need to be mindful about how we improve out craft. One way that we can do that is through Pry.

What is pry?

Pry is a debugging tool and a Ruby REPL that helps alleviate our headaches.

Using pry will stop at a specific line of code where you can then evaluate your code in your project. First, your project will need to require 'pry'. Install the gem if you already haven't. Then You want to install binding.pry at the breakpoint(the area of code you want to test).

Here is an example of using binding.pry to get the outcome we want:

 def add_numbers_to_arr(numbers_arr, num1, num2)
     # add num1 and num2 to numbers_arr
     numbers_arr << num1
     binding.pry
     numbers_arr = num2
     binding.pry
     numbers_arr
 end

result = add_numbers_to_arr([3,4], 5, 6)
puts result == [3, 4, 5, 6] # why is this false?

After running our code in the terminal we get:

 3: def add_numbers_to_arr(numbers_arr, num1, num2)
     4:     # add num1 and num2 to numbers_arr
     5:     numbers_arr << num1
 =>  6:     binding.pry
     7:     numbers_arr = num2
     8:     binding.pry
     9:     numbers_arr
    10: 
    11: end

[1] pry(main)>

We enter numbers_arr and get:

[1] pry(main)> numbers_arr
=> [3, 4, 5]
[2] pry(main)>

Line 5 looks good, but when we enter numbers_arr again we get:

     3: def add_numbers_to_arr(numbers_arr, num1, num2)
     4:     # add num1 and num2 to numbers_arr
     5:     numbers_arr << num1
     6:     binding.pry
     7:     numbers_arr = num2
 =>  8:     binding.pry
     9:     numbers_arr
    10: 
    11: end

[1] pry(main)>

Here is where we find our issue. We set the value of numbers_arr to num2. We were not able to add num1 and num2 together. But this is good! We now know where we need to fix the issue. That is line 7.

[1] pry(main)> numbers_arr
=> 6
[2] pry(main)>

Now that we know where the issue is we can change the code to get the outcome. We know shovel num2 into numbers_arr

def add_numbers_to_arr(numbers_arr, num1, num2)
    # add num1 and num2 to numbers_arr
    numbers_arr << num1
    binding.pry
    numbers_arr << num2 
    binding.pry
    numbers_arr

end

We did it!

[1] pry(main)> numbers_arr
=> [3, 4, 5, 6]

In conclusion, we have tools to help us know how to navigate our code. Use them so that you're equipped to know your code.