DEV Community: Patkul Shah

Integer Reversal - Common Interview Problem

Patkul Shah — Wed, 16 Oct 2019 13:37:35 +0000

Hi all, I'll make this quick and go straight to the meat and paneer :) of things.

Reversing a string or reversing a number is one of the common questions asked at programming interviews. Let’s take a look at how this is done.

Limitations/Rules:
negative numbers should remain negative
any leading zeroes must be removed
function that can accept floats or integers
the function will return integers a integers

//enclose your code in parsefloat first
const reversedNum = num => { parseFloat(num.toString()
 .split('')
 .reverse()
 .join(''))*Math.sign(num) //make sure you multiply by this to correct the negative sign 
}
reverseNum(1234) // 4321

Ok, so now we have mentioned the limitations, let's break down the following arrow function solution into step.Arrow functions have an implicit return value — if they can be written in one line, without the need for the{} braces.

Notice, first we must convert the number into a string in order to use the split array method. num.toString() converts the given number into a String so we can use the split function on it next.
the split function - takes a a string and turns it into a array of characters, we need to do this in order to use the next array reverse function.
Reverse the array - num.reverse() reverses the order of the items in the array
join() function - num.join() function - combines the reversed characters into a string.
Parse the input value into a floating point number. parseFloat(num) converts num into a float from a String. Notice the example below, it removes the 0s and the - and gives you only the float point numbers.

num = '0012345-'
parseFloat(num)
//num - 12345

Multiply it by the sign of the original number in order to maintain the negative value. num* Math.sign(num)

original value of num = -5432100
//num = 12345

num * Math.sign(-5432100)

//num = -12345

and there you have it!

ES6 Block Scope is The New IIFE

Patkul Shah — Mon, 07 Oct 2019 14:49:54 +0000

I will be summarizing how we don't really need IIFE anymore when using ES6 Block Scope. Specifically, we will learn how let and const are going to be super useful! Basically, let and const is beneficial if you need to scope something to a block, or if you want to make a variable that cannot be changed by accident or on purpose.

Background on IIFE (skip if you already know):

An IIFE function runs itself immediately, and it creates a scope where nothing is going to leak into the parent scope. In our case, nothing is going to leak into the global scope of the window.

Creating a named function pollutes the global name space. It also means the named function is hanging around. With the function hanging out, oh-so readily available, it could accidentally be invoked again. IIFE isn’t named and therefore can’t accidentally be called later — avoiding any potential security implications.

If you try to call name in the console now, it’s not undefined, it’s blank because, like I mentioned, it’s just blank because that is a property that lives on the window in JavaScript.

HERE COMES LET AND CONST TO THE RESCUE!

With let and const variables, we don’t need a function for our variables to be scoped to that.

Why? Because let and const use block scope.

Let’s start over with a const instead of a var

If we call this in the console, we’ll see 'Awesomeness', but if we wrap it in curly brackets ( see first lines of code below )

Our const is going to be scoped to that block. If you try to call name in the console, we’ll get the window’s name equal to "result", whatever that means(you can explain it in the discussion section!). But if we add a console.log to our block ( see last lines of code above )

You don’t the IIFE stuff anymore. You’re using let and const because they are going to be scoped to that block. Let me know what other examples you guys can think of in the discussion section below!

Spread Syntax (ES6) (Must know for React)

Patkul Shah — Sun, 06 Oct 2019 16:27:36 +0000

JavaScript is becoming more powerful every day (thanks to ES6 and Babel), new syntax and tools allow us to write concise code and the less code we have to write the less errors. This is for my skill reinforcement purpose but you if can learn valuable knowledge from this then be the force with you!

Let's start from examples:

Example 1: Combining/Intersecting two arrays

In this code, we will use the old way of combining two arrays using concat then the second way is using the spread syntax.

There is not much of a difference here as we are just putting two arrays together but where things get interesting is when we want to insert an array in the middle of another array.

Example 2 — You can also use the spread operator on objects, this makes it very easy to make a copy of an object and not worry about object references and mutability which can lead to unexpected behavior.

Example 3 — Combining two objects - Notice the spread syntax which is separated by a comma in order to combine!