do not understand object oriented programming

Question

I have looked at a number of tutorials but I'm still struggling with the following code, can someone please explain this code. Can you please explain what each part is and what oit does.

function Person (name, age) {
    this.name = name;
    this.age = age;
}


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

var alice = new Person("Alice", 30);
var billy = new Person("Billy", 25);

// get the difference in age between alice and billy using our function
var diff =

Check out this tutorial http://www.codeproject.com/Articles/22769/Introduction-to-Object-Oriented-Programming-Concep and read points 4.4 and 4.5. Those should already explain what happens in this code. — Bas Jansen, Jul 17 '13 at 12:54
There is missing something like `ageDifference(alice, billy);` at the end. — Niko, Jul 17 '13 at 12:54
We have created two example people, alice and billy. Complete line 17 by calling ageDifference and saving the result in our global diff variable. — Wer Erew, Jul 17 '13 at 13:01
He isn't asking for code, he is asking for an explanation of code and how it relates to object-oriented programming, a valid question and something that is very complicated and deserves attention. — Ilan Biala, Jul 17 '13 at 14:21

Paul S. · Answer 1 · 2013-07-17T13:03:21.053

2

function Person(name, age) { // define a _constructor_ called _Person_
    this.name = name;        // constructor sets instance property _name_
    this.age = age;          // constructor sets instance property _age_
} // when invoked with _new_, this creates an..
  // ..Object which is an instance of Person

var ageDifference = function (person1, person2) { // a function (expression)
    return person1.age - person2.age;  // which returns the difference.. 
}                                      // ..between _age_ properties

var alice = new Person("Alice", 30); // new instance of _Person_
var billy = new Person("Billy", 25); // another new instance
/* _alice_ now looks like    |    _billy_ now looks like
     {                       |      {
         age: 30,            |          age: 25,
         name: "Alice"       |          name: "Billy"
     }                       |      }
*/
// get the difference in age between alice and billy using our function
var diff = ageDifference(alice, billy); // passing the instances from above..
                                        // ..into the function expression

edited Jul 17 '13 at 13:03

answered Jul 17 '13 at 12:55

Paul S.

58,277
8
106
120

Not to be pedantic, but `ageDifference` is just a function, not a method. – Niko Jul 17 '13 at 12:57
Isn't it more that you pass the objects as parameters to the function `ageDifference()` instead of applying the function to the objects? – insertusernamehere Jul 17 '13 at 13:01
@insertusernamehere okay I'll re-word that away from `apply`, which can have other meanings – Paul S. Jul 17 '13 at 13:02
Wording on answers to questions like that can always be tricky and everybody has something to say. :) Still +1 for the detailed analysis. – insertusernamehere Jul 17 '13 at 13:04

score 0 · Answer 2 · edited May 23 '17 at 12:21

javascript is not the best language to write object oriented. Basicly wat what you do is: you create a new object with the new operator.

What is the 'new' keyword in JavaScript?

all the this.[variable] setters will be stored in that object. so when you call new Person all the this assignments in function will be stored as an object, so this object (which is like a map) will have the keys name and age with the assigned values.

so alice will be { name : "Alice", age : 30 } and billy will be { name : "Billy", age : 25 }

cause javascript doesn't type check you can simply do: ageDifference({age: 20},{age: 30}); and it will still work. Thats why javascript is not the best object oriented language.

(you could use typeScript to write javascript object oriented: http://www.typescriptlang.org/)

score 0 · Answer 3 · answered Jul 17 '13 at 13:07

This code shows a contsructor at the top, which is used to create Person objects by providing the parameters name and age. This object can be given more properties, such as hair color, height, weight, and much more. By using these objects, you can simply store all the objects in an array or list and this will provide for a psuedo database that could be use for the census bureau to keep track of people. Object-oriented programming is all about creating objects to store data instead of relying mainly on variables with each person's name before the variable.

For example, instead of:

var ericName = 'Eric';
var ericAge = '22';

You could do:

var eric = new Person('Eric', '22');

and this will create a Person object stored in the variable eric. His age would be accessed by calling eric.name and eric.age. Object-oriented programming simplifies having so many variables into having just a few and having lots of methods to access their information and change it.

The next segment:

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

should actually be rewritten as:

function getAgeDifference(person1, person2) {
    return person1.age - person2.age;
}

To get the age difference between two people, you would call getAgeDifference(alice, billy);. This calls the getAgeDifference method that will use their age properties to provide you with more information.

Object-oriented languages such as Java, C++, Objective-C, also make use of classes that help separate sections of relevant code into different classes or files. This idea of classes is very helpful yet hard to understand and if you are looking to learn a lot about it I would recommend picking up a book about a specific language and going along with the information it provides to give you an idea of how to write object-oriented code and some examples and guides of what to do each step of the way.

Good luck!

`should actually be rewritten as` why **should** it? Is there reasoning behind this? What is wrong with a _function expression_, especially in this context where you may (in the next step of learning) be going on to _prototypes_? — Paul S., Jul 17 '13 at 13:10
I learned Java as an object-oriented language that uses specific methods - accessor and mutator methods mainly - to interact with objects. Though you can store the result in a variable, usually I don't because I use it right away or wait to call the function until I need it. — Ilan Biala, Jul 17 '13 at 14:23
Sorry, I did not understand "Though you can store the result in a variable". What result? The _function_ is being defined as an _expression_ with the reference being the variable, the differences between a _function expression_ and _function declaration_ mainly come down to when they may be invoked, and if it's after the definition, both act pretty much the same. The other main difference being you can assign properties of _Objects_ as functions directly when you use expressions, vs needing to make sure you don't have namespace conflicts and an extra assigning line for declarations — Paul S., Jul 17 '13 at 16:25

do not understand object oriented programming

3 Answers3