Instruction and explanation not clear


#1

Can someone explain to me the difference between dot and bracket notation and explain the instructions.


#2

Whitch task number???


#3

I need help with task number 5


#4

What your doing is setting the property of james to a string. Then logging the property. I wont give you the anwser but an example to help you solve your task!

var lion= {
attackPower: 90,
name: "lion"
};

// set to the first property name of "lion"
var aProperty = lion["attackPower"];

// print the value of the first property of "james" 
// using the variable "aProperty"

console.log(aProperty); // Prints 90

#5

I did that

Can you also tell me the difference between dot and bracket. The explanation confuse me.


#6

I will admit that the introduction to objects II is a bit confusing, but this looks like a bug. Let me get somone to help you. @albionsrefuge to the rescue!

Explaning Object Literal notation and Object Constructor

So the brackets are called Javascript Object Literal Notation(As sad in dyn-web and MDN):

An object literal is a comma-separated list of name-value pairs wrapped in curly braces. Object literals encapsulate data, enclosing it in a tidy package. This minimizes the use of global variables which can cause problems when combining code.

The following demonstrates an example object literal:

var myObject = {
    sProp: 'some string value',
    numProp: 2,
    bProp: false
};

Object literal property values can be of any data type, including array literals, functions, and nested object literals. Here is another object literal example with these property types:

var Swapper = {
    // an array literal
    images: ["smile.gif", "grim.gif", "frown.gif", "bomb.gif"],
    pos: { // nested object literal
        x: 40,
        y: 300
    },
    onSwap: function() { // function
        // code here
    }
};

Object Literal Syntax

Object literals are defined using the following syntax rules:

  1. A colon separates property name[1] from value.
  2. A comma separates each name-value pair from the next.
  3. There should be no comma after the last name-value pair.[2]

The Dot is called Object Constructor. Prototype

From Javascriptkit

In the world of OOP, the previous ways of defining an object is too limiting in many situations. We need a way to create an object "type" that can be used multiple times without having to redefine the object every time to meet each particular instance's needs. The standard way to achieve this is to use the Object Constructor function.

An object constructor is merely a regular JavaScript function, so it's just as robust (ie: define parameters, call other functions etc). The difference between the two is that a constructor function is called via the new operator (which you'll see below). By basing our object definition on the function syntax, we get its robustness as well.

Lets use a real world item "cat" as an example. A property of a cat may be its color or name. A method may be to "meeyow". The important thing to realize, however is that every cat will have a different name or even meeyow noise. To create an object type that accommodates this need for flexibility, we'll use an object constructor:

<script language="javascript" type="text/javascript">
<!--
 
function cat(name) {
    this.name = name;
    this.talk = function() {
        alert( this.name + " say meeow!" )
    }
} 
 
cat1 = new cat("felix")
cat1.talk() //alerts "felix says meeow!"
 
cat2 = new cat("ginger")
cat2.talk() //alerts "ginger says meeow!"
 
//-->
</script>

Here the function "cat()" is an object constructor, and its properties and methods are declared inside it by prefixing them with the keyword "this." Objects defined using an object constructor are then instantiated using the new keyword. Notice how we're able to easily define multiple instances of cat, each with its own name- that's the flexibility object constructor brings to custom objects. Constructors create the blueprints for objects, not the object itself.

Adding methods to our object using prototype

We saw above how to add a method to our constructor function by merely declaring it inside the function. Another approach is through prototyping, which is also more popular due to its elegance. Prototype is a type of inheritance in JavaScript. We use it when we would like an object to inherit a method after it has been defined. Think of prototyping mentally as "attaching" a method to an object after it's been defined, in which all object instances then instantly share.

Lets extend our original cat() object above with an additional method to change the cat's name, using prototype:

<script language="javascript" type="text/javascript">
<!--
 
cat.prototype.changeName = function(name) {
    this.name = name;
}
 
firstCat = new cat("pursur")
firstCat.changeName("Bill")
firstCat.talk() //alerts "Bill says meeow!"
 
//-->
</script>

As you can see we merely use the keyword "prototype" immediately following the object's name to utilize this functionality. The custom method changeName() is now shared by all instances of cat.
Using prototype on prebuilt JavaScript objects

Prototyping works on both custom objects and select prebuilt objects, such as Date() or String. For the later, the general rule is that you can prototype any prebuilt object that's initialized with the "new" keyword. I'm now going to give you an example of the later, by adding additional functionality to the prebuilt Array object of JavaScript.

<script language="javascript" type="text/javascript">
<!--
 
// The shift() and unshift() methods.
 
if(!Array.prototype.shift) { // if this method does not exist..
 
    Array.prototype.shift = function(){
        firstElement = this[0];
        this.reverse();
        this.length = Math.max(this.length-1,0);
        this.reverse();
        return firstElement;
    }
     
}
 
if(!Array.prototype.unshift) { // if this method does not exist..
     
    Array.prototype.unshift = function(){
        this.reverse();
         
            for(var i=arguments.length-1;i>=0;i--){
                this[this.length]=arguments[i]
            }
             
        this.reverse();
        return this.length
    }
}
 
//-->
</script>

Another Example of Prototyping.

// Class definition / constructor
var Vehicle = function Vehicle(color) {
  // Initialization
  this.color = color;
}

// Instance methods
Vehicle.prototype = {
  go: function go() {
    return "Vroom!";
  }
}

The possibilities are endless.


#8

Here is the first task for that exercise:

In line 7, set aProperty to a string of the first property in james (ie. the job property).

You wrote:

var aProperty = james["job"];

If you now print aProperty, you will get this:

programmer

Wait, that isn't a property at all, it's a value. So what did we do wrong?

james["job"] will give us a value but what we want is a property.

If you look back at james, you can see that it has two properties, job and married. Now, remember what the task is: set aProperty to a string of the first property in james.

Does that help you figure out what you should put on the right hand side of this assignment?:

var aProperty =

#9


I agree this is a bit okay, really confusing!
What they want you to do is to set aProperty to "job"
then after console log it using bracket notation (james[aProperty])
hope this helps


#10

Its litterarly the same thing!!!

You tell me:
@codejumper43323 way:

var aProperty = james["job"] 
console.log(aProperty)

Codecademy way:

var aProperty = "job"
console.log(james[aProperty])

The only diffrence is in codecademy its setting it to a variable. In terminolgy and result its the exact same!


#11

It is the same thing Codecademy just wants its a specific way :smile:


#12

It looks like the answer has been given now, but please try not to mention so many people at once like you did, as it sends each one of us notifications and I'm sure that not all of us want that.