Life As A Girl Developer

Primitive Types and Operators

Published February 2nd, 2018 under #javascript #programming #code #types #software #html #css #development (102 notes)

JavaScript is a dynamically typed language, which means that types can change at runtime, unlike other programming languages. The JavaScript engine will determine the type. Okay okay, this might still sound very vague. What it basically means is that we can do this:

The type of the variable a has changed from a number to a string. It is important to know what the types are in JavaScript before we’ll focus more on this phenomenon (called coercion, just fyi).

Primitive Types

There are 6 primitive types in ES6. With “primitive type”, we mean a type of data that represents a single value. This explains why an object isn’t a primitive type: an object represents a collection of name/value pairs! 

• undefined: represents the lack of existence. Don’t set a variable to undefined please! That’s not good practice (as the JavaScript engine sets it to undefined, which can cause a lot of confusion while debugging)
  
• null: this also represents the lack of existence, however it is completely safe to set a variable to null!
• boolean: is either true or false.
• number: represents a floating point number. There are always some decimals, even if you can’t see them!
• string: represents a sequence of characters.
• symbol: this is new in ES6! Yay, more to remember! 

Operators

Operators are, for example, + - * /.  You use the ones I just mentioned to add, subtract, multiply and divide! But what are operators really under the hood? How does the engine know what to do when I type 4 + 3? 

Well, operators are actually special functions, and we use infix notation, meaning that the operator sits nice and cozy in between the arguments (which you can see in 3 + 4 ). You could visualize this as +(3, 4), which is how you would normally invoke a function. Luckily, we don’t have to worry about this, and luckily we don’t have to write it like that because that would be rather ugly.  

Operator Precedence & Associativity

Published February 2nd, 2018 under #javascript #software #programming #code #study #inspiration #motivation #html #css #development #developer #website #app (20 notes)

Let’s make these scary words less intimidating first, shall we?

Operator Precedence: which operator gets called first? 
Associativity: in what order do the operators get called if they have the same precedence? (Either left-to-right or right-to-left)

A good example would be: 3 + 4 * 5.  Everyone who’s had math in high school knows that there is some kind of precedence: the * operator gets called first, then the +. However, sometimes you’re not quite sure which one gets called first! If that happens, you could check it here in the MDN docs.

3 + 4 * 5 results in 23, as 4 times 5 is 20, plus 2 is 23.
If we change this to (3 + 4) * 5, it will result in 35. As you can read in the docs, the grouping operator has the highest precedence, which will be called first! 3 plus 4 is 7, times 5 is 35! 

Comparison operators

For example, 3 < 2 < 1. 3 is smaller than 2, is smaller than 1. This obviously is not correct when you say it like that, however if you look at your console, you’ll see something you probably didn’t expect! 

What?! Seriously, JavaScript.. again?  Okay well, actually it makes sense. Let’s look at the precedence table again, but this time we will focus on the associativity! 

Ahaaaa. Left-to-right! Does it start to make sense now? 

3 < 2 < 1. First it will handle the first operator, thus 3 < 2. What will 3 < 2 result in? Exactly, false of course. So now we have false < 1. Okay.. but what is false? 

*grasp* so it actually says 0 < 1! Which is true! So 3 < 2 < 1, is true!

This is a good example of why JavaScript might seem very random, but if you look some steps further, it actually makes sense! 

Coercion

Published February 2nd, 2018 under #javascript #software #developer #tips #study #inspiration #motivation #computer #css #html #app #website (17 notes)

Finally we get to coercion! I’ve mentioned it before real quick, so you might remember what it is.

Coercion: converting a value from one type to another. Remember: 

We just changed the type of the value from a number to a string. This is possible because JavaScript is dynamically typed! Meaning, it’s not statically typed, meaning that the type of a variable is not known at compile time. 

This might sound nice and all, because we have to do less, but it could leave you looking at your computer screen like ‘whaaat the heck just happened’ quite often (talking from experience). Let’s take this example:

We have a number, and a string. And we want to add that, for some reason. What do you think the output would be? Spoiler alert! 

JavaScript is at it again! Well, what actually happened here is that the first parameter was coerced into a string, which changed the variable to “1″ + “2″, which results in “12″. Now you might think okay, but who would ever write it this way? 

This one’s already a bit more confusing. Now imagine this in a real app!  Always make sure that the variables you’re passing in have the types you’d expect

The Global Environment

Published February 2nd, 2018 under #javascript #development #software #inspiration #study #motivation #html #css #app #website #js (9 notes)

Whenever JavaScript code is run, the JavaScript engine wraps the execution code into an execution context. Don’t panic, it’s not as scary as it sounds!

As you probably know, machines don’t know JavaScript. The code you’ve written first has to be “translated” in order to work! When you run JavaScript code, the global execution context is created. Global, meaning its’ accessible to everything everywhere in the code and not inside a function. The global execution context creates two things for you:

1. A global object
   
2. A special variable called ‘this’

Okay it might still sounds scary, I agree.. But let’s just look at this! I’m running an empty JavaScript file here (absolutely no code, it just has the .js at the end):

Awesome!! The global execution context created the “this” keyword, and also a global object, which is “window” whenever we run JS code in a browser! Now let’s look at this example: 

We declared a variable in the file, whoo! Now let’s look at the console again.

Nice! Our variable is stored in the global object! You can also see that window and this are equal to each other in this case, and that it’s clearly an object (as you can access it by using the dot notation, like we do in objects). If a variable is not in a function, they’re always attached to the global object.

So, remember, when JavaScript code is executed:

1. 1. A global object is created by the JavaScript engine as a part of the execution context. 
   
2. You get “this”
3. An outer environment is created (we’ll get back to that later)
4. Your code is being run

Hoisting

Published February 2nd, 2018 under #javascript #software #developer #development #html #css #inspiration #study #app #website (12 notes)

Hoisting is something you hear like all the time in the JavaScript, but most people seem to understand it for just about 60%. It’s easy to show what it means by giving examples!

We invoke a function that we have declared later in the code, and want to log a variable that’s also declared later in the code. What do you expect would happen? Well….. 

What?! It had access to the function, and the variable returned “undefined”? Why was there no error, how could the code know what we meant? Because of, yeah you guessed it, hoisting! 

Hoisting: variables and functions are available, even if they’re written later in the code, because as you compile your JavaScript code, all variables and functions are given “spots in memory”. When we ran the code I wrote above, the code could access the function from memory, so it could execute it. However, with variables it’s different. When variables are “memorized”, they’re given a certain placeholder, with the ‘value’ of “undefined”. Note that undefined doesn’t mean not defined (*sigh* confusing!), it simply means that it knows that later on in the code you have defined it, just not yet. 

Look at this difference:

Now, myVar is actually not defined, instead of undefined, we because we never declared a variable called myVar! 

7 Keys to Improving your Self-Esteem

Published March 20th, 2014 (11,545 notes)

onlinecounsellingcollege:

1. Stop comparing yourself to others

2. Stop demanding and expecting perfection (from yourself and other people)

3. Practice kindness and understanding

4. Be your own best friend when you make a mistake

5. Look for things that you like about yourself and choose to take pleasure, and find joy, in them

6. Believe that you deserve to experience good things

7. Make the decision to enjoy your life, and to love what you are doing, and to believe in yourself.

(via adventurewithasplashofsunshine)