7.7 KiB

Raw Blame History

Javascript Fundamentals Review

Primative Data Types

Javascript has several basic data types:

'this is a string' // string (text)
123 // number (int)
1.2 // number (float)
true // boolean
false // boolean

They can be combined in the usual ways

2+2
3.2*4
5/2
9.6-2
'first string ' + 'second string.';

Variables

Declaring variables is done with the keyword var. Variables are dynamically typed (decided during execution) since there is no compilation process.

var foo = 'string';
var bar = 1;

Reassignment is done by omitting the var keyword. Variables are loosely typed (can be reassigned to any other value, regardless of their initial value)

var foo = 'a string';
foo = 123.4;

Functions and Scope

Declare functions with keyword function. Do not need to specify return type.

function myFunc(){
	return 5;
}

To execute a function, invoke its name with parentheses

myFunc();

Can pass parameters into functions

function addFive(numberToAddFiveTo){
	return numberToAddFiveTo + 5;
}
addFive(6); // returns 11

Variables declared inside a function cannot be accessed outside of it

function foo(){
	var myVar = 1;
	return myVar;
}
console.log(myVar); // error

but variables declared outside a function are accessible within it

var myVar = 1;
function foo(){
	return myVar;
}
console.log(foo());

Objects

Objects in javascript are just key/value pairs

var myObj = {
	property1: 'value1',
	property2: 'value2'
}

Can retrieve values using dot notation

myObj.property1

Can modify an object's properties like so:

myObj.property1 = 'new value';
myObj.newProperty = 'asdf';

Arrays

Can create arrays, which are lists of elements of whatever type

var numbers = [1,'string',3.234,true];

Can access an array element by index (which start at 0)

numbers[0]; //first element in array

Can alter values at a preexisting index. Type does not matter

numbers[1] = 123;

Arrays are objects, so they have properties

numbers.length //gives you the length of the array
numbers.pop() //remove the last element and returns it
numbers.push(26) //adds a number to the last position of the array
numbers.shift() //remove the first element and returns it
numbers.unshift(56) //adds a number to the first position of the array and pushes everything down

Equality

Can test for equality with ==

1 == 2 //false
1 == 1 //true
'asdf' == 'asdf' //true
'asdf' == 'asdfasdf' //false

These are not exact and will attempt type conversion

'1' == 1 //true?!?!

To make it exact, use ===

`1` === 1 //false

Control Flow (loops, if/else)

We can use equality in if/else statements

if(1 === 2){
	console.log('should not run');
} else if (1 === 3){
	console.log('also should not run');
} else {
	console.log('runs if all else fails');
}

Loops

We can repeat a block of code over and over again while a certain statement is true

var i = 1;
while(i < 5){
	console.log(i);
	i++;
}

We can use for loops as a shorthand for the above

for(var i = 1; i < 5; i++){
	console.log(i);
}

Functions are objects

Functions can be assigned to variables

var myFunc = function(){

}

myFunc();

Can be assigned to properties of objects. These functions are referred to as methods of the object

var myObj = {
	functionProperty: function(){

	}
}

myObj.functionProperty();

When invoking methods, you can reference other properties of the object with the keyword this

var myObj = {
	color: 'blue',
	functionProperty: function(){
		console.log(this.color);
	}
}

myObj.functionProperty(); //logs 'blue'

Can be passed as parameters to other functions

function invokingFunction(callbackFunctionParam){ //referenced without ()
	console.log('event handler');
	callbackFunctionParam(); //invoked by adding ()
}

var callbackFunction = function(){
	console.log('inside callback function');
}

invokingFunction(callbackFunction); //passed as an object by omitting ()

This can be done anonymously

function invokingFunction(callbackParam){
	console.log('event handler');
	callbackParam();
}

invokingFunction(function(){
	console.log('inside callback function');
});

Remember that functions can access variables defined outside their scope. When dealing with functions executed after they declaration, make sure you examine what the values of the variables are

function invokingFunction(callbackParam){
	callbackParam();
}

var foo = 1;

var callbackFunction = function(){
	console.log(foo);       
}

foo = 2;

invokingFunction(callbackFunction); //logs 2

Asynchronicity, Events, and Callbacks

Javascript is event driven, meaning that we define event handling functions that just sit around for something to happen and then execute a callback function

//setTimeout is the event handling function here.  It is built into Node.  The event it handles is the passing of two seconds.  Once this event occurs, it executes its callback function
setTimeout(function(){
	console.log('callback function executed!');
}, 2000);

Node is aware of all event handler functions that are still waiting to execute their callback functions. It will not return control to the user until either all event handlers have finished waiting or the user forces the process to stop.

It is VERY important to be aware that variables outside a callback function's scope can change value even after it has been registered, but before it is called

var foo = 1;

setTimeout(function(){
	console.log(foo); // log 2, even though foo is 1 at time of registration
}, 500);

foo = 2;

Object Oriented JS

If you need to create multiple objects of the same type, object literals ({ property:'value'}) can be inefficient. We can create constructor functions, which act like class declarations.

var Person = function(){
	this.numArms = 2; //use the this keyword to create properties and methods
	this.numLegs = 2;
}

var me = new Person(); //use the new keyword to instantiate a new object
var someoneElse = new Person();
console.log(me);
console.log(someoneElse);

We can pass parameters into constructor functions to make instances unique

var Person = function(name){
	this.name = name;
	this.numArms = 2; //use the this keyword to create properties and methods
	this.numLegs = 2;
}

var me = new Person('Matt'); //use the new keyword to instantiate a new object
var someoneElse = new Person('Joey Jo-Jo Junior Shabadoo');
console.log(me);
console.log(someoneElse);

Methods act just like adding properties

var Person = function(name){
	this.name = name;
	this.numArms = 2; //use the this keyword to create properties and methods
	this.numLegs = 2;
	this.sayHello = function(){
		console.log("Hello, my name is " + this.name);
	}
}

var me = new Person('Matt'); //use the new keyword to instantiate a new object
me.sayHello();

Since functions are objects, we can create static properties/methods (properties and methods that relate to the class, not the instances of the class) by using dot notation

var Person = function(){
	/*
	usual stuff here...
	*/
}

Person.genders = ['male', 'female'];
console.log(Person.genders);

We can have a "class" inherit from another class, using the .call static method of a function

var Car = function(){
	this.wheels = 4;
}

var Humvee = function(){
	Car.call(this);
	this.numAmericanFlags = 4;
}

var murica = new Humvee();
console.log(murica);

7.7 KiB Raw Blame History