Javascript

/*

* DATATYPES:

*

* Datatypes are nothing more than all of the values we store/access/use

* throughout our javascript code.

*

* We can separate datatypes into two (2) catagories:

*

* O - Simple/Primative

* O - Complex

*

* Let's take a quick look at some examples of each of them!

*/

// Simple/Primative //

// Number //

var num = 1;

// String //

var string = 'This is a string!';

// Boolean //

var thisIsTrue = true;

var thisIsFalse = false;

// Why are they simple? //

// Atomic, immutable: they do not hold, collect or aggregate other values, //

// and operations on simple values return new simple values, they do not alter //

// the original value. //

// Copy by value - when assigning or passing, simple data-types are copied from //

// one variable to the next. //

// *!Now for the Complex!* //

// Complex //

// Object //

var obj = {};

// Array //

var arr = [];

// Function //

function thisIsAFunction() {};

// Why are they complex? //

// Complex values aggregate other values and therefore are of indefinite size. //

// Copy by reference - when assigning or passing, complex data-types are //

// passed by reference. //

var notANumber = 'NaN';

var nullEx = null;

var partyTime = undefined;

console.log(notANumber++);

console.log(partyTime); // logs undefined

console.log(nullEx);

// infinty and -infinity

console.log(Infinity ); /* Infinity */

console.log(Infinity + 1 ); /* Infinity */

console.log(Math.pow(10, 1000)); /* Infinity */

console.log(Math.log(0) ); /* -Infinity */

console.log(1 / Infinity ); /* 0 */

// String //

// Character or textual data //

// Strings are character data, we MUST enclose Strings in single or double quotes //

var string0 = "Like this";

var string1 = 'Or this';

// Why are strings called strings? Like Mardi Gras beads are a string of //

// (cheap) pearls, strings are a string of characters, or an Array of characters. //

// Strings can be treated like an Array of characters. We can access the //

// individual characters of strings using what’s called, Array-syntax, or //

// bracket notation. //

console.log(string0[0]); // Prints 'L' to the console.

// Can change case

var string2 = "Hmmmmm";

console.log(string2.toUpperCase()); //HMMMMM

console.log(string2.toLowerCase()); //hmmmmm

// Can change string to an array

console.log(string2.split("")); //['h', 'm', 'm', 'm', 'm']

// Can fuse strings (cocatenate)

console.log(string0 + " " + string1); // "Like this Or this"

// Can get string length

console.log(string0.length) // logs 9

// Can replace parts of strings

string0 = string0.replace('Like','Mike');

console.log(string0);

// CONTROL FLOW //

// JavaScript supports a compact set of statements, specifically control flow //

// statements, that you can use to incorporate a great deal of interactivity //

// in your application. //

// The semicolon (;) character is used to separate statements in JavaScript code. //

// BLOCK STATEMENTS //

// The most basic statement is a block statement that is used to group statements. //

// The block is delimited by a pair of curly brackets: //

// Block statements are commonly used with control flow statements //

// (e.g. if, for, while, switch). //

let x = 10;

while (x > 0) {

x--;

}

if (x === 0) {

console.log('BOTH STATEMENTS WORKED');

}

for (let i = 10; i > x; i--) {

console.log('The For Loop is Running');

}

// Switch Statement //

// Convienient When:

// 1. You are comparing multiple possible conditions of an expression and the

// 1. expression itself is non-trivial. //

// 2. You have multiple values that may require the same code. //

// 3. You have some values that will require essentially all of another value's //

// 3. execution, plus only a few statements. //

let z = 5;

switch (z) {

case 1:

console.log('No');

break;

case 2:

console.log('No2');

break;

case 3:

console.log('No3');

break;

case 4:

console.log('No4');

break;

default:

console.log("You'll get to 5 eventually");

break;

};

let exNum = 0;

// If/ElseIf/Else Example

if (exNum > 0) {

console.log('good');

} else if (exNum < 0) {

console.log('bad');

} else {

console.log('neither');

}

/*

* VARIABLES:

*

* 0. To hold things in memory during the life-cycle of a program, we can use variables. Variables

* are named identifiers that can point to values of a particular type, like a Number, String,

* Boolean, Array, Object or another data-type. Variables are called so because once created, we

* can CHANGE the value (and type of value) to which they point.

*

* 1. To create a variable we use the keyword, var, followed by a name (id or alias) for our

* variable.

*

* 2. There are 2 phases of using variables: declaration and initialization (or assignment).

*/

// 1. declaration //

var myName;

/*

* At the declaration phase, the variable myName is undefined because we have NOT initialized

* it to anything

*/

console.log(myName); // prints => undefined

// 2. initialization or assignment //

myName = 'john';

console.log(myName); // prints => john

// 3. re-assignment //

myName = 'bob';

console.log(myName); // prints => bob

// NOTE: We can assign and re-assign anything to a variable - we cannot do this with constants //

var myVariable = 1;

myVariable = true;

myVariable = "someString";

console.log(myVariable);

// Constants are containers who's value can never be changed once it has been declared //

// They are created using the keyword const and must be assigned a value immediately. //

const birthDate = 02241998;

console.log(birthDate);

// ALL CAPS are recommended for constant names //

// Let //

// Not hoiseted to their code block //

// Limits the variable's scope to the block it's declared in. //

var letThemEatCake = undefined;

console.log(letThemEatCake);

if (birthDate === 02241998) {

let letThemEatCake = 'Happy Birthday!!!';

console.log(letThemEatCake);

}

console.log(letThemEatCake);

// OPERATORS //

// Operatiors act on the data we have throughout our javascript. They can //

// assign data to variables, compare them, or include them in arithmetic //

// operations. //

// Operators are sorted into categories based upon what they do and the ammount //

// of operands-(the values that operators act on) they require. //

// Unary - 1 value //

// Binary - 2 //

// Ternary - 3 //

// COMPARISON OPERATORS //

// Comparison operators (as the name would imply) compare two values and return //

// either true or false. //

console.log(1 < 2);

console.log(5 > 3);

console.log(2 <= 2);

console.log(6 >= 5);

// STRICT COMPARISON //

// Strict comparison takes value and type of the variables into account when //

// comparing them. DON'T USE NON-STRICT COMPARISON UNLESS YOU ABSOLUTELY HAVE TO //

// (BASICALLY NEVER!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!) //

console.log(2 === 2);

console.log(2 === '2');

console.log(2 !== 2);

console.log(2 !== '2');

// LOGICAL OPERATORS //

// && (The AND Operator): Both conditions MUST be true //

console.log(2 < 3 && 1 > 0);

// || (The OR Operator): At least one of the conditions must be true //

console.log(1 == 1 || 2 == 3);

// ! (The BANG Operator): Flips the truthiness of the value //

console.log(!true);

// !! (The (ALMIGHTY) DOUBLE BANG Operator): Coerces a value to Boolean //

// If the value was falsey (0, null, undefined, etc.), it will be false. //

// Otherwise, you'll get true instead. //

console.log(!!1);

// ARITHMETIC OPERATORS //

var a = 10;

console.log(1 + 1);

console.log(2 - 1);

console.log(2 * 3);

console.log(4 / 2);

console.log(4 % 2);

console.log(a += a); // a = 20

console.log(a -= 19); // a = 1

console.log(a *= 55); // a = 55

console.log(a /= 5); // a = 11

// UNARY OPERATORS //

// This is a set of operators that only take one operand

let i = 0;

i++;

console.log(i);

console.log(--i);

console.log(!true);

console.log(i--);

++i;

console.log(i);

// TERNARY OPERATORS //

// Shorthand if/else statements.

i === 10 ? console.log(false) : console.log(true);