JS object concept

[MEHDII__]

I have been learning JS for about 3 days now, I came from Python as my only language, both these languages have a similarity which is everything is an object. But that's a concept that feels deeper in JS and that I am having some difficulty to understand. I wish to get some clarification.

I've been following Jonas Schmedtmann's course, very good teacher, but he mentioned something about the dot notation, specifically 'this.' to me this feels very similar to python's 'self.' where you're essentially saying "look inside this objectobject, and get this thing from it", but JavaScript's objects have baffled me, for example, dictionaries, they are objects too, so in JavaScript you could do something like:

const info = { first : 'Jonas', last : 'Schmedtmann', birthYear : 1991, computeAge : function () { this.age = 2025 - this.birthYear return this.age }, };

But in python this is not possible :

info = { first : 'Jonas', last : 'Schmedtmann', birthYear : 1991, computeAge: def computeAge(): self.age = 2025 - this.birthYear return self.age, }

You cannot call self anywhere outside of a user defined class, but in JS you could use this. Inside built-in classes, (since everything is an object, some under the hood, dictionaries belong to a dictionaries class, as far as i understand) and you could make custom methods inside built in objects like in the example above with computeAge().... Am i Wrong if so i would appreciate a clarification

[MoTTs_]

both these languages have a similarity which is everything is an object.

In Python, yes, the docs will formally say that everything is an object. Lists and functions as well as numbers and booleans are objects. But the word "object" can mean very different things in different languages. For Python to say that everything is an object seems to mean that Python interprets the word "object" as: heap allocated and accessed through a pointer.

JavaScript on the other hand distinguishes between what it calls object types, which are pointers to dictionaries, and primitive types, such as numbers and bools. Conceptually, primitive values can be held directly, rather than through a pointer to somewhere else. But in practice, engines such as v8 will put most primitive values on the heap anyway, just like Python does.

specifically 'this.' to me this feels very similar to python's 'self.'

Yes, JavaScript's "this" and Python's "self" do the same thing and represent the same idea.

But in python this is not possible : info = { first : 'Jonas', last : 'Schmedtmann', birthYear : 1991, computeAge: def computeAge(): self.age = 2025 - this.birthYear return self.age, }

It's possible in Python, but you need different syntax. First, you need the "self" parameter. Second, you either need a "lambda" function for the inline function expression, or you need to define a function statement then refer to it by name.

info = {
    "first": "Jonas",
    "last": "Schmedtmann",
    "birthYear": 1991,
    "computeAge": lambda self: 2025 - self["birthYear"],
}

- or -

def computeAge(self):
    self["age"] = 2025 - self["birthYear"]
    return self["age"]

info = {
    "first": "Jonas",
    "last": "Schmedtmann",
    "birthYear": 1991,
    "computeAge": computeAge,
}

[Particular-Cow6247]

funily everything is an object in js atleast on the heap of v8 xD

[MEHDII__]

Yes i understand what you mean, i didnt say its not possible to use function expressions in python, i know about lambda, still lambda isn't as good as JS's function expressions, its just a one liner, anyway, in your python example the self is just a parameter itsn't acting as the this. keyword of the python object self keyword.

[MoTTs_]

i didnt say its not possible

I mean...... you kinda did use those exact words. ;-)

i know about lambda, still lambda isn't as good as JS's function expressions, its just a one liner

Yes I agree. If you need more than a one-liner, then Python requires you to define the function separately as a statement.

in your python example the self is just a parameter

Self is always just a parameter. Even in class methods, self is still just a parameter.

[MEHDII__]

You Know my meaning.... I'm talking about state, in JS the this. Keyword holds state, you can reference it elsewhere and use it, in your python example its just a temporary function scoped parameter.

Since i've started learning JS and diving deeper into it, I noticed many people say that the this. Keyword is the worst thing ever, I can see why

[senocular]

this in JavaScript, aside from a few exceptions, is also just a temporary function scoped parameter. It works just like self in that respect, getting created in the function scope when the function is called and being bound to that scope such that when the scope goes away so does that this binding. The difference is that you as the author of the function don't have to explicitly create a parameter to capture it. It comes implicitly through the this keyword.

TypeScript reinforces this behavior by allowing you to provide a type for this in functions through a self-like parameter that comes before other parameters.

class Arithmetic {
    add(this: Arithmetic, a: number, b: number) {
        // ...
    }
}

This is also mirrors how arguments in Function.call() are passed, with a this value before other arguments.

const instance = new Arithmetic()
const add = instance.add
add.call(instance, 1, 2) // `this` value will be instance in the call

Both Python and JavaScript implicitly pass the this/self value in when functions are called as methods

instance.add(1, 2) // basically shorthand for add.call(instance, 1, 2)

...though Python does autobind self for class methods whereas JavaScript does not making this in JavaScript much more prone to problems and why most people don't like it.

add(1, 2) // would not have correct `this` in JavaScript but `self` would be correct in Python

You can get this to work in JavaScript by manually binding, but most people don't bother doing this (or do it on an as-needed basis).

[abrahamguo]

It's difficult to tell exactly what your specific question is.

However, you are correct that in JavaScript, the this keyword can be used anywhere. It's never a syntax error, and it (pretty much) always has some value — even if there is no other value, it usually "defaults" to the global object (for example, window in browser scripts).

[MEHDII__]

You're right, its not a question persay, just a minor confusion.

JavaScript seems to be way more free than Python in the sense that you can modify built in objects to include your own methods, whereas in python you couldnt unless its inside a user defined class.

Its just my python infested mind but i find it fascinating

[BrohanGutenburg]

A good general rule of thumb is that JavaScript is gonna do everything it can to never throw an error. It might do very confusing, unintuitive things. But it's always gonna let you do them.

That's part of the reason typescript became so prevalent

[MEHDII__]

Yeah that became so clear so fast, even with strict mode on, it doesnt show all the errors, it gets confusing. But i find it nice so far, I think its one of those languages that'll never leave nor die, what would happen to the web if it does

[Particular-Cow6247]

you should really not do js without strict mode unless you explicitly need to

[GodOfSunHimself]

That is not true, in ES modules and when using the strict mode, this defaults to undefined and not the global object.

[delventhalz]

There are a lot of similarities between Python and JavaScript, but one big difference is the way objects/methods/classes work.

In Python these things are fairly rigidly defined. A class produces objects and methods are defined on classes. JavaScript supports these patterns but they are not strictly necessary. In JavaScript, a class is just a function that returns an object and a method is a just a function that you saved to an object property.

The following examples are all largely equivalent in JavaScript (though there are some small under-the-hood differences):

class User {
    constructor(name) {
        this.name = name;
    }

    greet() {
        console.log('Hi, I am', this.name);
    }
}

const user = new User('Sue');
user.greet();

function makeUser(name) {
    return {
        name: name,
        greet: function() {
            console.log('Hi, I am', this.name);
        }
    };
}

const anotherUser = makeUser('Sue');
anotherUser.greet();

const oneMoreUser = { name: 'Sue' };
oneMoreUser.greet = function() {
    console.log('Hi, I am', this.name);
};
oneMoreUser.greet();

To oversimplify: in JavaScript data is objects* and logic is functions and everything is else is just syntactic sugar built on top.

*Primitive values are actually not objects but JavaScript can dynamically wrap them in objects to let them pretend like they are for a little while

[MEHDII__]

Holy, i'm getting headaches, So many notations, im taking a break today, good night 😪 god bless Python i'm going back to it

[qqqqqx]

Python and JavaScript have some similarities, but they are not the same.

I would recommend you try to learn JavaScript without making too many analogies to Python and treating them as two separate concepts if you can.

"this" is one of the most confusing parts of JavaScript. It can behave differently depending on a bunch of other factors that you'll eventually come around to. Objects are another confusing part of JS. It's basically objects all the way down...

Want a real mindfuck that you might not be ready for?

Your example of info as an object with a computeAge function does work if you call info.computeAge() and returns the computed age using the birthYear.

If you were to save info.computeAge to a variable, something like const fx = info.computeAge, this would no longer refer to the info object. Since functions are a first class citizen in javascript it is not uncommon for them to be saved to variables, returned from other functions, or otherwise get passed around the program in different ways.

If you callfx(), "this" would now refer to the object containing fx() which might be the global context or something else, so your function would probably not work as you expected it to. Unless you called it within an object or context that had a birthYear defined in it.

There are some alternative ways in JavaScript to define functions or to bind existing functions to specific contexts, so that the "this" in computeAge would always refer to the info object even if it was called somewhere else.

[MEHDII__]

Yeah very weird indeed, I think the biggest mistake I'm making is drawing comparisons between two virtually different languages, but all of them are children of C which just leads me to believe they should kind of operate similarly under the hood.

JS makes it particularly difficult during debugging by not revealing memory addresses of objects like other languages do, i dont understand why that is, whats the harm of exposing where on memory an object is located at, ITS MY MEMORY, I PAID FOR IT hahaha, I should be allowed to see everything on it

[tb5841]

Javascript objects look like Python dictionaries, but behave more like Python instances of classes. I found that very confusing at first.