Showing posts with label codeacademy. Show all posts
Showing posts with label codeacademy. Show all posts

Friday, June 14, 2013

Python : Battleship


import random

board = []
for x in range(5):
    board.append(["O"] * 5)
def print_board(board):
    for row in board:
        print " ".join(row)
print "Let's play Battleship!"
print_board(board)
def random_row(board):
    return random.randint(0, len(board) - 1)
def random_col(board):
    return random.randint(0, len(board[0]) - 1)
ship_row = random_row(board)
ship_col = random_col(board)
print ship_row
print ship_col
# Everything from here on should go in your for loop!
# Be sure to indent four spaces!
for turn in range(4):
    guess_row = input("Guess Row:")
    guess_col = input("Guess Col:")
    if guess_row == ship_row and guess_col == ship_col:
        print "Congratulations! You sunk my battleship!"
        break
    else:
        if turn > 3:
            print "Game Over"
        else:

            if (guess_row < 0 or guess_row > 4) or (guess_col < 0 or guess_col > 4):
                print "Oops, that's not even in the ocean."
            elif(board[guess_row][guess_col] == "X"):
                print "You guessed that one already."
            else:
                print "You missed my battleship!"
                board[guess_row][guess_col] = "X"
    print "You have", (3-turn), "turns remain."
    #    print_board(board)

Saturday, June 8, 2013

Python : Student Becomes Teacher




lloyd = {
    "name": "Lloyd",
    "homework": [90.0, 97.0, 75.0, 92.0],
    "quizzes": [88.0, 40.0, 94.0],
    "tests": [75.0, 90.0]
}
alice = {
    "name": "Alice",
    "homework": [100.0, 92.0, 98.0, 100.0],
    "quizzes": [82.0, 83.0, 91.0],
    "tests": [89.0, 97.0]
}
tyler = {
    "name": "Tyler",
    "homework": [0.0, 87.0, 75.0, 22.0],
    "quizzes": [0.0, 75.0, 78.0],
    "tests": [100.0, 100.0]
}

# Add your function below!
def average(x):
    return sum(x) / len(x)

* * *

def get_average(student):
    return average(student["homework"]) * 0.1 + average(student["quizzes"]) * 0.3 + average(student["tests"]) * 0.6

def get_letter_grade(score):
    if score >= 90:
        return "A"
    elif score  >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

print get_letter_grade(get_average(lloyd))

def get_class_average(students):
    student_averages = []
    for i in students:
        student_averages.append(get_average(i))
    return average(student_averages)

students = [lloyd, alice, tyler]

print get_class_average(students)

Tuesday, June 4, 2013

Python : PygLatin


pyg = 'ay'

original = raw_input('Enter a word:')
word = original.lower()
first = original[0]
new_word = word + pyg

if len(original) > 0 and original.isalpha():
    if first == "a" or first == "e" or first == "i" or first == "o" or first == "u":
        print 'vowel'
    else:
        new_word = original[1:] + original[0:1] + pyg
        print new_word
else:
    print 'empty'
 
 
 

Monday, June 3, 2013

J.S. Project: Building a Cash Register


// Here is my final J.S. Project before I move on to Python: 

function StaffMember(name,discountPercent){
    this.name = name;
    this.discountPercent = discountPercent;
}

var sally = new StaffMember("Sally",5);
var bob = new StaffMember("Bob",10);

// Create yourself again as 'me' with a staff discount of 20%
var me = new StaffMember("Jenny",20);

var cashRegister = {
    total:0,
    lastTransactionAmount: 0,
    add: function(itemCost){
        this.total += (itemCost || 0);
        this.lastTransactionAmount = itemCost;
    },
    scan: function(item,quantity){
        switch (item){
        case "eggs": this.add(0.98 * quantity); break;
        case "milk": this.add(1.23 * quantity); break;
        case "magazine": this.add(4.99 * quantity); break;
        case "chocolate": this.add(0.45 * quantity); break;
        }
        return true;
    },
    voidLastTransaction : function(){
        this.total -= this.lastTransactionAmount;
        this.lastTransactionAmount = 0;
    },
    // Create a new method applyStaffDiscount here
    applyStaffDiscount: function(employee){
        this.total -= (this.total*(employee.discountPercent/100));
    }
    
};

cashRegister.scan('eggs',1);
cashRegister.scan('milk',1);
cashRegister.scan('magazine',3);
// Apply your staff discount by passing the 'me' object 
// to applyStaffDiscount
cashRegister.applyStaffDiscount(me);

// Show the total bill
console.log('Your bill is '+cashRegister.total.toFixed(2));

Monday, May 20, 2013

J.S. Project: Dragon Slayer



We'll be combining while loops with some other control statements (like if / else statements) to create a dragon slaying minigame.

01 / 04 : Let's first start off by declaring the variables which we'll be using. We're going to need a variable to check if we're still slaying, a variable to check if we hit the dragon, a variable to keep track of how much damage we've dealt the dragon this round, and a variable to keep track of total damage. We'll also be relying on random numbers to see if we hit the dragon, and if so, how much damage we did. JavaScript generates random numbers like this:
    var randomNumber = Math.random();
This creates a random number between 0 and 1. By multiplying the number and rounding it down, we can make it a random whole number. For example:
    Math.floor(Math.random() * 5 + 1);
will generate a random number between 1 and 5 inclusive. Now let's declare and set the following variables:
    1. slaying equal to true
    2. youHit to a random number that's either 0 (which JavaScript reads as 'false') or 1 {which JavaScript reads as 'true')
    3. damageThisRound to a random number between 1 and 5 (inclusive)
    4. totalDamage to 0
    HINT - by multiplying the random number (which is between 0 and 1) by 5, we make it a random number between 0 and 5 (for example, 3.1841). Math.floor() rounds this number down to a whole number, and adding 1 and the end changes the range from between 0 and 4 to between 1 and 5 (up to and including 5).

var slaying = true;
var youHit = Math.random();
var damageThisRound = Math.floor(Math.random() * 5 + 1);
var totalDamage = 0;

02 / 04 : Wonderful. Now let's add in our while loop. We want to run this whole game as long as we're trying to kill the dragon--that is, while slaying is true. When checking variables like slaying that are set to true, we don't need to write something like this:
    while(slaying === true)
Instead, we can just write:
    while(slaying)
Now let's create a while loop that only executes when slaying is true. For this exercise, set slaying to false in the body of the loop (we want to make sure the loop can exit... no infinite loops for us!) 

var slaying = true;
while(slaying) {
    slaying = false;
}

03 / 04 : Now time to add a couple of branches to our program so it can handle different outcomes. You know what this means... if and else! Inside the while loop, create an if / else statement that checks the value of youHit. If it's 1 (true), it should log a congratulatory message to the console, telling the user (s)he hit the dragon. If it's 0 (false), it should log a message to the console saying that the dragon defeated you. Either way, slaying should be set to false, since either you beat the dragon (and the slaying's over) or the dragon beat you!

while(slaying) {
    if (youHit) {
        console.log("You hit!");
    } else {
        console.log("You missed!");
    }
    slaying = false;
}

04 / 04 : We're gonna add the second 'if' statement. In the first branch of our if statement (right after the console.log() where we congratulate the player for hitting the dragon), let's set totalDamage equal to totalDamage + damageThisRound. The shortcut for this is: the += operator. When you type
    totalDamage += damageThisRound 
you're telling JavaScript to add totalDamage and damageThisRound together, then assign the new value to totalDamage. Inside the first if statement, create a second if statement that checks to see if totalDamage is greater than or equal to 4. If so, it should log to the console that the player slew the dragon and set slaying equal to false (since the dragon's dead, the slaying is over). If totalDamage isn't greater than or equal to 4, youHit should be assigned a new random 1 or 0. (This is as easy as setting youHit to the same expression you used when you first declared it.)


while(slaying) {
    if (youHit) {
        console.log("You hit!");
        totalDamage += damageThisRound;
            if ( totalDamage >= 4) {
                console.log("You win!");
                slaying = false
            } else { 
                youHit = Math.floor(Math.random()*2);
            }
    } else {
        console.log("You missed!");
        slaying = false;
    }
}


You did it! You've written your own dragon slaying game!

Wednesday, May 15, 2013

J.S. Project: Search Text for Your Name



Today, we're going to write a short program that checks a block of text for my name. More specifically, it's going to check for the first letter of my name, then push (add) the number of characters equal to my name's length to an array. By inspecting the array, we'll be able to see if our name was mentioned.

/*jshint multistr:true */
text = "Blah blah blah blah blah blah blah blah Jenny blah \
blah blah blah blah blah blah Jenny blah blah blah blah \
blah blah blah blah blah blah blah blah blah Jenny";

var myName = "Jenny";
var hits = [];

// Look for "J" in the text
for(var i = 0; i < text.length; i++) {
    if (text[i] === "J) {
        // If we find it, add characters up to
        // the length of my name to the array
        for(var j = i; j < (myName.length + i) ; j++) {
            hits.push(text[j]);
        }
    }
}

if (hits.length === 0) {
    console.log("Your name wasn't found!");
} else {
    console.log(hits);
}

01 / 05 : Let's start by declaring our variables: text, myName, and hits. Since text could be quite long, try putting a blackslash (\) at the end of each line to make our string "wrap" to the next line of the editor. We can ignore the /*jshint multistr:true */ for now because all it does is tell the console to stop worrying about our use of backslash characters for wrapping long lines of text. Now set the following three variables:
1. text, and make a string containing some text
2. myName, and make a string containing just your name
3. hits, and make it an empty array
    HINT - make an empty array by setting your variable equal to [] (an array with nothing in it)

var text = "blah blah Jenny blah blah blah Jenny blah";
var myName = "Jenny";
var hits = [];

02 / 05 : Let's write our outer for loop. Below our existing code, create a for loop that starts at 0, continues until it reaches the end of text, and increments by 1 each time. (Meaning it will check each character in the string).
    HINT - Remember the syntax for a for loop looks like this:
        for(var i = 0; i < condition; i++) {
            // Do something !
        }
    In place of "condition", put the condition that will stop the loop from running. In this case, our  
    condition should be less text.length.

for(var i = 0; i < text.length; i++) {

}

03 / 05 : Nice! Now let's move on to the if statement. We'll want to place the if statement inside our for loop to make sure the program checks the if statement each time it moves forward through the loop. Essentially, the for loop is saying: "Hey program! Go through every letter in 'text'." The if statement will say: if you see something interesting, push that text into an array!" You can treat a string like an array of characters: For instance, you know that
        var myArray = ['hello', 'world'];
        myArray[0]; // equals 'hello'
But this also works on strings!
        var myName = 'Jenny';
        myName[0] // equals 'J'
Add your if statement in the body of your for loop and it should check to see whether the curent letter is equal to the first letter of your name.
    HINT - Remember, an if statement looks like thisis:
        if (some condition) {
            // Do something!
        }

    You can check the i th letter of text like so: \
    // Assuming your name starts with 'E'
    if (text[i] === 'E') {
        // Do something!
    }

for (var i = 0; i < text.length; i++){
    if (text[i] === 'J') {
 
    }
}

04 / 05 : Now time to add your second "for" loop. You're going to write it inside the body of your first if statement (between the if's {}s). This loop is going to make sure each character of your name gets pushed to the final array. The if statement says: "If we find the first letter of your name, start the second for loop!" This loop says: "I'm going to add characters to the array until I hit the length of the user's name." So if your name is 11 letters long, your loop should add 11 characters to hits if it ever sees the first letter of myName in text. We'll want to set our second loop's iterator to start at the first one, so it picks up where that one left off. If our first loop starts with
    for(var i = 0; // rest of loop setup
our second loop should be something like
    for(var j = i; // rest of loop setup
In the body of our loop, have our program use the .push() method of hits. Just like strings and arrays have a .length method, arrays have a .push() method that adds the thing between parentheses to the end of the array, for example:
    newArray = [];
    newArray.push('hello');
    newArray[0] // equals 'hello'
    HINT - the loop should stop when it hits the value of the first iterator plus the length of the myName
    variable.

for(var i = 00; i < text.length; i++){
    if (text[i] === 'J') {
        for(var j = i; j < (myName.length + i); j++){
            hits.push(text[j]);
        }
    }
}

05 / 05 : You've now got the engine of your search program running! It's going to:
    1. loop through the array
    2. compare each letter to the first letter of your name, and if it sees that letter:
    3. it will push that letter and all the letters that follow it to an array, stopping when the number of
        letters it pushes are equal to the number of letters in your name.
So under your existing code (and outside all your other loops!) Set up an if / else statement. If you don't have any hits, log "Your name wasn't found!" to the console. Otherwise, log the hits array to the console.

if (hits.length === 0) {
    console.log("Your name wasn't found!");
} else {
    console.log(hits);
}

** Unfortunately, this system isn't perfect. For instance, if the paragraph contains both "Jenny" and "Jerry", we'll see this in our hits array:
['J', 'e', 'n', 'n', 'y', 'J', 'e', 'r', 'r', 'y']

Friday, May 3, 2013

Javascript: Review of Functions


// Introducing Functions 

A function can be defined by preceding a bunch of code with the word function followed by its inputs. These inputs are known as parameters and are enclosed with (). The associated code is enclosed with {}.

// Accepts a number x as input and returns its square
var square = function(x) {
    return x * x;
};

// Accepts a number x as input and returns its cube
var cube = function(x) {
    return x * x * x;
};

cube(7);

// Understanding Parameters
Functions can have zero, one, or more parameters. You can think of these as input that the function receives, and then uses to do something.

// the code example shows a function that takes two number as arguments and returns their product
var multiply = function (x, y) {
    return x * y;
};

multiply(2, 5);

// Argument Types, part 1
We just saw that the naming of parameters doesn't impact the caller of a function. In JavaScript, you don't need to specify a type when defining a function which means that when someone else calls your function, they can supply any type of argument that they want to-- a number, a string, an array, etc. This may lead to some strange behavior if you call your multiply function with a string:

multiply("tweedledee", "tweedledum");
// returned value is NaN (stands for, not a number)

// Argument Types, part 2
Let's say that we want to make sure that the caller always gets a numeric value back, even if the input wasn't of the right type... To achieve that, we need to check the type of argument that was passed in. If it wasn't a number, we probably shouldn't try to multiply it. We'll just return 0 in that case.

var cube = function (x) {
    if (typeof(x) !== 'number') return 0;
    return x * x * x;
};

// the cube() function should return 0.
cube("test");

// Local Variables
Each parameter of a function is effectively a variable. It has a name that we can use inside the function to refer to the value that was supplied by the call to the function. Once the function has been called, is that name available outside the function? To test this, let's run the code below as is:

var volume = function (w, l, h) {
    return w * l * h;
};

volume(2, 3, 4) ;
console.log(w);

We get a "Reference: Error", w is not defined. What that means is that the name w was set to the value 2 inside the function when it was called, but was never defined outside of the function. For the code to work, we've got to set:

var w = 15;

What if you need additional local variables beyond the arguments (e.g. to hold an intermediate result)? In the volume function, you can see an example of such a local variable. The variable area is local because it is visible only inside the function. Even after the function has been called, area is still not defining outside the function and referring to it triggers an error.

var volume = function (w, l, h) {
    var area = w * l;
    return area * h;
};

// var area = 36
console.log("Inside the function, area is 6");
console.log("The volume is " + volume(2, 3, 4));
console.log("Outside the function, area is " + area);

You'll get another Reference Error: area is not defined... so now, uncomment line 6 and you'll have:
Inside the function, the area is 6
The volume is 24
Outside the function, area is 36

Now you see a slightly different version of the volume function: can you spot the difference?


var area = 36;
var volume = function (w, l, h) {
    area = w * l;
    return area * h;
};

console.log(volume(2, 3, 4));
console.log(area);


Area is no longer preceded by var. The area variable is no longer local to the function. Instead, when the function has been called, the area is set to 2 * 3 = 6 when volume is called. The area variable outside the function is called a global variable because it is visible everywhere. Modifying it inside a function is referred to as a side-effect and is generally something you want to avoid. This is why you should always use var when declaring variables!

var area = 36;
var volume = function (w, l, h) {
    var area = w * l;
    return area * h;
};

console.log(volume(2, 3, 4));
console.log(area);

Friday, April 26, 2013

J.S. Project: Choose Your Own Adventure!


Today, we're going to create a 'choose your own adventure' game. Exciting, right? It will have a basic story line, the opportunity for the user to make a couple of decisions, and a happy ending (hopefully).

01 / 07 : Let's use the confirm command to ask your user if they are ready to play.
    HINT - remember, to get the user to confirm something, the syntax looks like this:
        confirm("I understand confirm!");

// Check if the user is ready to play!
confirm("Are you ready to embark on this adventure of fun?");


02 / 07 : However before we start playing, we're going to check to see if the user is old enough to play! This step involves two bits of code. Declare a variable age using prompt. Make that age equal to the answer you prompt the user to give (ie. ask the user 'how old are you?'). Finally, create an if / else statement: if the user is less than 19, use console.log and tel the that they're allowed to play but you take no responsibility. Else, use console.log and give them an encouraging message to play on!
    HINT - recall the syntax for if / else statements:
        if (condition) {
            code code code;
        } else {
            code code code;
        }

var age = prompt("How old are you?");
    if (age < 18) {
        console.log("You're allowed to play, but I take no responsibility.");
    } else {
        console.log("Well, what are you waiting for? Let's get started already!");
    }


03 / 07 : We've gotta set up the scene for our story. Here's a short little introduction that we can use for now: Snow White and Batman were hanging out at the bus stop, waiting to go to the shops. There was a sale on and both needed some new threads. You've never really liked Batman. You walk up to him.
Let's print the intro using console.log. The intro is full of words... remember how words are called 'strings' in JavaScript? Don't forget how to properly use strings!
    HINT - don't forget to put quotes around the intro!

// introduction
console.log("Snow White and Batman were hanging out at the bus stop, waiting to go to the shops. There was a sale on and both needed some new threads. You've never really liked Batman. You walk up to him.");


04 / 07 : Our story is ready to move along! There's a scene and your user is about to talk to batman. Under your existing code, print out the storyline: "Batman glares at you." Then declare a variable userAnswer and make it equal a prompt that asks the user "Are you feeling lucky, punk?" (This will be the question that Batman asks your user).

console.log("Batman glares at you.");
var userAnswer = prompt("Are you feeling lucky, punk?");


05 / 07 : Now we've gotta create different scenarios using the if / else statements! Use an if / else statement to write out the last part of this game. If userAnswer is "yes", print out: "Batman hits you very hard. It's Batman and you're you! Of course Batman wins!" Otherwise, print out: "You did not say yes to feeling lucky. Good choice! You are a winner in the game of not getting beaten up by Batman."
    HINT - Remember: = is for assignment, and === is to check this are equal!

if (userAnswer === "yes") {
    console.log("Batman hits you very hard. It's Batman and you're you! Of course Batman wins!");
} else {
    console.log "You did not say yes to feeling lucky. Good choice! You are a winner in the game of not getting beaten up by Batman.");
}


06 / 07 : It's probably worthwhile to ask your user for feedback. Let's create a variable called feedback and prompt the user to rate your game out of 10. If the score is greater than 8, print out: "This is just the beginning of my game empire. Stay tuned for more!" Otherwise, print out: "I slaved away at this game and you gave me that score?! The nerve! Just you wait!"
    HINT - var feedback  = prompt("Message");

var feedback = prompt("Could you rate my game out of 10?");
    if (feedback > 8) {
        console.log("This is just the beginning of my game empire. Stay tuned for more!");
    } else {
        console.log("I slaved away at this game and you gave me that score?! The nerve! Just you wait!");
    }


07 / 07 : Congrats! You've just programmed your first game! Now it's your turn to program your own 'choose your own aventure game'.






Thursday, April 25, 2013

Javascript: Objects II in Review


01/ 04
Instructions: Examine the languages object. Three properties are strings, whereas one is a number. Use a for-in loop to print out the three ways to say hello. In the loop, you should check to see if the property value is a string so you don't accidentally print a number.
    HINT: Use an if statement in combination with the typeof operator to figure out whether or not something is a "string". If it's a "string", then print it!

Make sure you're checking the property value (e.g., "Hello!") and no the property name (e.g., english). Recall that if we save a property name to a variable, we can access the value associated with that name using bracket notation.

Recall the for-in loop:

for(var x in obj) {
executeSomething();
}

/* This will go through all properties of obj one by one and assign the property name on each run of the loop. */

var languages = {
    english: "Hello!",
    french: "Bonjour!",
    notALanguage: 4,
    spanish: "Hola!"
};

// print hello in the 3 different languages
for(var x in languages) {
if (typeof languages[x]);
}
}

02/ 04
Instructions: Add the sayHello method to the Dog class by extending its prototype. sayHello should print to the console: "Hello this is a [breed] dog", where [breed] is the dog's breed.
    HINT: recall how we previously added a method to the Dog class:
Dog.prototype.bark = function()
{
    console.log("Woof");
}; 

To access a dog's breed from within the method, use this.breed.

function Dog (breed) {
    this.breed = breed;
};

// add the sayHello method to the Dog class
// so all dogs now can say hello
Dog.prototype.sayHello = function()
{
    console.log("Hello this is a " + this.breed + " dog");
};

var yourDog = new Dog("golden retriever");
yourDog.sayHello();

var myDog = new Dog("dachshund");
myDog.sayHello();

03/ 04 
Instructions: Let's first see what type Object.prototype is. Do this in line 2 and save it into prototypeType. If all goes well, you should realize that Object.prototype itself is an object! And since all objects have the hasOwnProperty method, it's pretty easy to check if hasOwnProperty comes from Object.prototype.
    HINT: to see what type Object.prototype is, we should use typeof Object.prototype. The property we want to check for is actually "hasOwnProperty", so line 6 should look like: Object.prototype.hasOwnProperty("hasOwnProperty").

// what is this "Object.prototype" anyway...?
var prototypeType = typeof Object.prototype; 
console.log(prototypeType);

// now let's examine it!
var hasOwn = Object.prototype.hasOwnProperty("hasOwnProperty"); 
console.log(hasOwn);

04/ 04 
Instructions: Modify the StudentReport class so that no grades will be printed to the console in the for-in loop. However, getGPA should still function properly in the last line.
    HINT: You should be changing public variables ( this.grade ) to private variables ( var grade ). If we want to getGPA to be able to be called from outside this class, should we change it to be private? You should find yourself needing to modify getGPA itself. this.grade1 will not be available if you did not declare it previously.

function StudentReport() {
    var grade1 = 4;
    var grade2 = 2;
    var grade3 = 1;
    this.getGPA = function() {
        return ( grade1 + grade2 + grade3 ) / 3;
    };
}

var myStudentReport = new StudentReport();

for(var x in myStudentReport) {
    if(typeof myStudentReport[x] !== "function") {
        console.log("Muahaha! "+myStudentReport[x]);
    }
}

console.log("Your overall GPA is "+myStudentReport.getGPA());







Sunday, April 21, 2013

Javascript: Inheritance in Object Oriented Programming


Inheritance allows one class to see and use the methods and properties of another class. Let's create a class called Animal, along with a sayName method:

function Animal(name, numLegs) {
    this.name  = name;
    this.numLegs = numLegs;
};

animal.prototype.sayName = function()
{
    console.log("Hi my name is " + this.name)
};

// here's a code to test the above constructor and method
var penguin = new Animal("Captain Cook", 2);
penguin.sayName();

Wouldn't it be cool if we created a Penguin class? Let's do that so that we can give it some methods unique only to a penguin and not confuse it with the Animal class.

function Penguin(name, numLegs) {
    this.name = name;
    this.numLegs = numLegs;
}

Penguin.prototype.sayName = function()
{
    console.log("Hi my name is " + this.name);
};

We seemed to have reused a lot of the same code as the Animal class. This goes against the "DRY" principle--aka "don't repeat yourself"! We're going to create a new Penguin class, but we're going only take a name parameter, and within the constructor itself, set this.numLegs to 2.

function Penguin (name) {
    this.name = name;
    this.numLegs = 2

// set its prototype to be a new instance of Animal
Penguin.prototype = new Animal();

Now we're going to create an Emperor class that takes a single name parameter and sets its name property to be this value.

// create your Emperor class and make it inherit from Penguin
function Emperor (name) {
    this.name = name;
}

Emperor.prototype = new Penguin();
// create an "emperor" object and print the number of legs it has
var emperor = new Emperor("Mr. McWaddle");
console.log(emperor.numLegs);

The "prototype chain" in Javascript sort of like a food chain. If JavaScript encounters something it can't find it the current class's methods or properties, it looks up the prototype chain to see if it's defined in a class that it inherits from. This keeps going upwards until it stops all the way at the top: the Object.prototype. All classes inherit directly from Object, unless we change the class's prototype.

// original classes
function Animal(name, numLegs) {
    this.name = name;
    this.numLegs = numLegs;
    this.isAlive = true;
}
function Penguin(name)
    this.name = name;
    this.numLegs = 2;
}
function Emperor(name) {
    this.name = name;
    this.saying = "Waddle waddle";
}

// set up the prototype chain
Penguin.prototype = name Animal();
Emperor.prototype = new Penguin();

var myEmperor = new Emperor("Jules");

console.log( myEmperor.saying ); // should print "Waddle waddle"
console.log( myEmperor.numLegs ); // should print 2
console.log( myEmperor.isAlive ); // should print true

Saturday, April 20, 2013

Javascript: Object-Oriented Programming Basics


Alright, so now we can finally learn the basics of OOP! The first thing I'm going to introduce is a class.    When you make a constructor, you are actually defining a new class! A class can be thought of as a type, or a category of objects -- remember numbers and strings? Those are types too!

/* take a look at the example below, jenny and alex are two separate objects, but they both belong to the class Person */
function Person(name, age) {
    this.name = name;
    this.age = age;
};

var jenny = new Person("Jenny", 18);
var alex = new Person("Alex", 13);

A prototype keeps track of what a given class can or cannot do. Javascript automatically defines the prototype for class with a constructor.

// for example, this dog constructor ensures that the dog prototype has a breed property
function Dog (breed) {
    this.breed = breed;
};

Classes are really useful because they tell us helpful information about objects. You can actually think of an object as a particular instance of a class. Look at our Person class. We know that any Person will have a  name and age because they are in they are in the constructor. Let's create a function like printPersonName--this will take a Person as an argument and print out their name.

// recall our Person class
function Person(name, age) {
    this.name = name;
    this.age = age;
};

// a function that prints out the name of any given person
function printPersonName(p) {
    console.log(p.name);
};

var jenny = new Person("Jenny", 18);
printPersonName(jenny);

If you want to add a method to a class such that all members of the class can use it, we use the following syntax to extend the prototype:

className.prototype.newMethod = 
function() {
statements; 

}; 

// here's another example using the dog class:
function Dog (breed) {
    this.breed = breed;
};

// here we make fifi and teach her how to bark
var fifi = new Dog("pomeranian");
Dog.prototype.bark = function() {
    console.log("Arf!");
};
fifi.bark();

// here we make maya
var maya = new Dog("Pug");
maya.bark();

P.S. I created a youtube channel where I'll be uploading vlogs and cooking videos and random miscellaneous things, so if you want to get to know me a little better, I suggest you check it out! (And subscribe!) :)

Friday, April 19, 2013

Javascript: Even More on Objects




















How do we figure out if something is an object? We can call typeof thing to figure this out. In general, most types fall under "number", "string", "function", and "object".
var someObject = {someProperty: someValue};
console.log( typeof someObject ); 

// concrete example
var anObj = { job: "I'm an object!" };
console.log( typeof anObj );

Every object in JS comes with some baggage, including a method called hasOwnProperty. This lets us know if an object has a particular property.
// this is how you use hasOwnProperty
var myObj = {
    name: myObj
};

console.log( myObj. hasOwnProperty('name')); // should print true

console.log( myObj. hasOwnProperty('nickname')); // should print false

// here's another example of hasOwnProperty used in an if-else statement: 

/* recall if-else statements: 
if ( expression ) {
} else {
} */

var suitcase = {
    shirt: "Hawaiian"
}; 

if (suitcase.hasOwnProperty("shorts")) {
    console.log(suitcase.shorts); 
} else {
    suitcase.shorts = "red"; 
    console.log(suitcase.shorts);
}

To work with all the properties that belong to an object, let's bring back the for-in loop. 

// define some object 
var pom = {
species: "pomeranian", 
age: 10, 
color: "golden",
};

// for-in loop to print out pom's property names 
for(var property in pom) {
console.log(property); 

We've just learned how to print all of an object's property names with a for-in loop, but how do we print out the values associated with every property?

// for-in loop to print out the value of all pom's properties 

// recall 
pom.species = pom["species"] = "pomeranian" 
// if we say
var x = "species" 
// then
dog[x] = "pomeranian'

for(var x in pom) {
console.log(pom [x]); 

Thursday, April 18, 2013

Javascript: Objects in Review


Objects give us a way to represent things--IRL or virtual. We're able to do this by storing information within the object's properties.

So far, we have learned two ways to make objects:
// literal notation, where we use var Name = { }; 
var cutedork = {
    age: 18,
    country: "United States"
};

// constructor notation, where we use the keyword new
var cutedork2 = new Object(); 
    cutedork2.age = 18;
    cutedork2.country = "United States";

Remember what properties are? They're similar to variables... except that they belong to an object and hold information. We can access properties in two ways:

// dot notation, with ObjectName.PropertyName
var age = jenny.ages

// bracket notation, with ObjectName["PropertyName"] (--don't forget the quotes!)
var country = jenny['country']

Methods act like functions associated with an object and they're especially useful when you ether want to:
1. Update the object properties
2. Calculate something based on an object's properties

// example of defining area and perimeter methods
function Circle (radius) {
    this.radius = radius;
    this.area = function () {
        return Math.PI * this.radius * this.radius;
    };

function Perimeter (radius) {
    this.radius = radius;
    this.area = function() {
        return 2 * Math.PI * this.radius;
    };
}}

Lastly--in addition to our basic object constructor, we can create our own custom constructors which are helpful for two reasons:
1. We can assign our object properties through parameters we pass in when the object is created.
2. We can give our object methods automatically.

// 3 lines are required to make mdfrmscrtch
var mdfrmscrtch = new Object(); 
mdfrmscrtch.blogURL = "http://mdrmscrtch.blogspot.com";
mdfrmscrtch.creator = "Jenny"

// A custom constructor for blog
function Blog (blogURL, creator) {
    this.blogURL = blogURL;
    this.creator = creator;
}

// Use this new creator to make hello_cutedork in one line!
var hello_cutedork = new Blog("http://hellocutedork.blogspot.com", "Jenny");

Song of the day // Lucky Ones (Lana Del Rey)

Javascript: Combining Objects with Arrays, Loops, and Functions


a slice of coconut cake @ souen

Objects are just another type--like a string or number, but a bit more complex. So just as we can make arrays of strings and numbers, we can also makes arrays of objects:

// here, we have a person constructor:
function Person (name, age) {
    this.name = name;
    this.age = age;
};

// now we can make an array of people:
var family = new Array();
family[0] = new Person("jenny", 18);
family[1] = new Person("alex", 13);
family[2] = new Person("mom", 51);
family[3] = new Person("dad", 49);

Arrays filled with objects will work just like arrays filled with numbers and strings. In the same we we can loop through an array of numbers to print them out or to calculate a sum, we can loop through an array of objects and access properties or methods:

// loop through our new array and print out the name of each family member:
for (i = 0; i < family.length; i++ )
{console.log(family[i].name)
};

We can also use objects as parameters for functions as well. That way, we can take advantage of the methods and properties that a certain object type provides. In addition to our Person constructor, we have also introduced a new function, ageDifference. This function takes two Person objects as parameters and returns the difference in age between the two people:

// create var ageDifference
var ageDifference = function(person1, person2) {
    return person1.age - person2.age;
};

// create multiple example people
var jenny = new Person("Jenny", 18);
var alex = new Person("Alex", 13);

// create new variable diff
var diff = ageDifference(jenny, alex);

Javascript: Construction Junctions

chocolate green tea lava cake @ spot dessert bar 


constructor is a way to create an object. So far, we've been using a built-in constructor called Object. Already defined by the JS language, it creates an object with no properties/methods.
var thecutedork = new Object();
thecutedork.url = "http://hellocutedork.blogspot.com";
thecutedork.platform = "blogger"

However, don't you agree that this makes adding properties one at a time for every single object kind of tedious? Well, we can create our own constructions. This way, we can actually set the properties for an object right when it is created!

function Blog(url, platform) {
  this.url = url;
  this.platform = platform;



// let's make goodwillgrrl and mdfrmscrtch, using our constructor:
var goodwillgrrl = new Blog("http://goodwillgrrl.blogspot.com ", "blogger")
var mdfrmscrtch = new Blog("http://mdfrmscrtch.blogspot.com", "blogger")

In addition to setting properties, constructors can also define methods.

/* here is a Rectangle constructor, which sets the length and width properties equal to the arguments, just like our Blog constructor did with url and platform.

Notice the calcArea method. This calculates the area of the rectangle in terms of its length and width. */

function Rectangle(length, width) {
  this.length = length;
  this.width = width;
  this.calcArea = function() {
    return this.length * this.width;
}; 
}

var rex = new Rectangle(7,3);
var area = rex.calcArea();

/* Constructors are a way to make objects with the keyword new. We have one final example of a constructor which defines an adjective property and adescribeMyself method: /*

function Rabbit(adjective) {
  this.adjective = adjective;
  this.describeMyself = function(){
    console.log("I am a " + this.adjective + " rabbit");
  };
}

// now we can easily make all of our rabbits:
var rabbit1 = new Rabbit("fluffy");
var rabbit2 = new Rabbit("happy");
var rabbit3 = new Rabbit("sleepy");

rabbit1.describeMyself();

rabbit2.describeMyself();
rabbit3.describeMyself();

Javascript: Methods

my brother's science project

Methods are an important part of OOP (object oriented programming). Remember last time we worked with properties? Whereas properties are similar to variables, a method is like a function associated with an object. Methods are important because they serve several purposes including:

1. The ability to change object property values
2. The ability to make calculations based on object properties. Functions can only use parameters as an input, but methods can make calculations with object properties. Cool, huh? 

Here's an example: 

// make cutedork here, and first give her an age of 8
var cutedork = new Object();
cutedork.age = 8; 
cutedork.setAge = setAge; 

// here, update cutedork's age to 18 using the method
cutedork.setAge(18);

Another slightly more challenging example: 

var square = new Object();
square.sideLength = 6;
square.calcPerimeter = function() {
  return this.sideLength * 4;
};

// help us define an area method here
square.calcArea = function() {
  return this.sideLength * this.sideLength
};

var p = square.calcPerimeter();
var a = square.calcArea();

Javascript: More on Objects

Plants on the windowsill
Today, I worked a little on objects. In my previous lessons, I've only really worked with numbers and strings. The third data type I'm learning about are objects. They let us code real things and entities by storing all relevant information in one place. To create an object, we use var, followed by the name of the object and =. Each object then starts with {has information inside, and ends with };

// for example:
var Jenny = { };

Each piece of information we include in an object is called a property. Each property has a name, followed by : and then the value of that property. For example, if we want to display my age, we'd type:

age: 18 

we can access properties using two different methods: dot notation and literal notation.

// dot notation
var jenny = new Object();
jenny.username = "cutedork";
jenny.age = 18;

// literal notation
var jenny = {
    username: "cutedork",
    age: 18
};

Song of the day // Static Mind (Girl in a Coma)

Javascript: Intro to Objects

homemade meatballs using Chef John's recipe


We finally get to use 'nouns' and 'verbs' together!!! In Javascript, let's think of 'nouns' as data such as arrays, variables, strings, etc. and 'verbs' as functions... With objects, we can finally put the two--our information and the function that uses our information, together in the same place. REUNITED AT LAST!

// here is a short code:

var blogEntry = {};

blogEntry.name = 'Jenny';
blogEntry.URL = 'thecutedork.blogspot.com';
blogEntry.blog = function(){
  console.log('Check out ' + this.name + ' at ' + this.URL + '...');
};

blogEntry.blog();

Javascript: &&, ||, !

Fifi


Today, I covered: and(&&), or(||), not(!).
For and(&&), remember:
true && true // => true
true && false // => false
false && true // => false
false && false // => false

Whereas or(||):
true || true // => true
true || false // => true
false || true // => true
false || false // => false 

Lastly, not(!):
!true // => false
!false // => true

Here is a code I wrote which uses &&, ||, !:

// set variables to either true or false:
var iLoveYoga = true;
var iLoveRunning = true;

if(iLoveYoga && iLoveRunning) {
    // if iLoveYoga AND iLoveRunning:
    console.log("Awesome, yoga and running work hand-in-hand!");
} else if (!(iLoveYoga || iLoveRunning)) {
    // if NOT iLoveYoga OR iLoveRunning:
    console.log("You've gotta get your lazy butt off the couch and out the door!!!");
} else {
    console.log("You only like one, but not the other?");
}