Javascript overloading dot

You can do this with Proxy objects (MDN | spec). Proxies let you create objects that are true proxies (facades) for other objects. Here's a simple example that turns any property values that are strings to all caps on retrieval:

const original = { "foo": "bar" };
const proxy = new Proxy(original, {
    get(target, name, receiver) {
        let rv = target[name];
        if (typeof rv === "string") {
            rv = rv.toUpperCase();
        }
        return rv;
    }
});

console.log(`original.foo = ${original.foo}`); // "bar"
console.log(`proxy.foo = ${proxy.foo}`);       // "BAR"

The output of the above is:

original.foo = bar
proxy.foo = BAR

Operations you don't override have their default behavior. In the above, all we override is get, but there's a whole list of operations you can hook into (getting a property, setting a property, looking up the list of existing properties, and others).

In the get handler function's arguments list:

• target is the object being proxied (original, in our case).
• name is (of course) the name of the property being retrieved.
• receiver is either the proxy itself or something that inherits from it. In our case, receiver is === proxy, but if proxy were used as a prototype, receiver could be a descendant object, hence it being on the function signature (but at the end, so you can readily leave it off if, as with our example above, you don't actually use it).

This lets you create an object with the catch-all getter and setter feature you want:

const obj = new Proxy({}, {
    get(target, name) {
        if (!(name in target)) {
            console.log(`Getting non-existent property "${name}"`);
            return undefined;
        }
        return target[name];
    },
    set(target, name, value) {
        if (!(name in target)) {
            console.log(`Setting non-existent property '${name}', initial value: ${value}`);
        }
        target[name] = value;
    }
});

console.log("[before] obj.foo = " + obj.foo);
obj.foo = "bar";
console.log("[after] obj.foo = " + obj.foo);

The output of the above is:

Getting non-existent property 'foo'
[before] obj.foo = undefined
Setting non-existent property 'foo', initial value: bar
[after] obj.foo = bar

Note how we get the "non-existent" message when we try to retrieve foo when it doesn't yet exist, and again when we create it, but not subsequently.

On recent JS versions, there is indeed something similar to Python's properties.

Also see question Javascript getters and setters for dummies?

It may be enough for you, although Python is still way more flexible and compact.

Nope, you can't overload or replace it in JavaScript. I wish I had a more comprehensive/informational answer for you...but it just isn't possible, I guess there was never a need seen to add the ability.

As others have stated, this is impossible as operator overloading is impossible in ECMAscript.

If you really need to do this then I would use some preprocessing to convert the parts of code (and only those that really needs to be instrumented like this) into instrumented code.

This could easily be done using a little regexp like this

var a= "var a = b.c['foo']" // get this via xhr or something
var re = /(\[(.*)\])|(\.([\w\d]+)\b)/g;

var b = a.replace(re, function(m){
    return ".get('" +  m.replace(/[[\].'\"]/g,"") + "')";
});
b; // "var a = b.get('c').get('foo')"

eval(b);

You may invoke methods that don't exist in the original target object. I use this functionality to 'invoke' methods on a local object, that get actually posted to a worker, and to invoke methods on an object in the worker, to be actually posted to it's parent.

class Original {
  aa = (a, b) => {
    console.log(`aa invoked with ${a}, ${b}`);
  };
  defaultMethod = (name, ...args) => {
    console.log(
      `defaultMethod invoked as ${name} with ${
      args.map(JSON.stringify).join(', ')}`);
  };
};
let orig = new Original();
let proxy = new Proxy(orig, {
  get: (target, name) => {
    if (!(name in target)) {
        target[name] = (...args) => {
            target.defaultMethod(name, ...args);
        };
    }
    return target[name];
  }
});
proxy.aa(1, 2);
proxy.bb(1, 2, 3);

This answer is working now in 2024, and I didn't try to implement it for older browsers.