o is an instantiated object. Every time you execute Cat , a new o is generated. The instantiation of o is completed after var o =. is executed.

try the following code:

var Cat = function() {
    var o = {
        say: function() {
            console.log('say something');
        }
    }
    let say = o.say;
    setInterval(function(){
        say();
    }, 1000)
    return o
}

var cat = Cat()

cat.say = function() {
    console.log('Hello');
}

then the output is

Say something

has nothing to do with setInterval . The callback function of setInterval in the code you provided holds a reference to the instance of o , not to o.say . Therefore, when this callback is executed a second later, you will find o first, and then look for o.say . The callback function of setInterval in the code I provided holds a reference to the o.say function, and is a reference to the old o.say , so when the callback is executed a second later, it will directly find the old o.say .

I don't know if this is clear to you.

first executes the function Cat () , defines the say () method in the object, and then encounters setInterval , which is an asynchronous task, so join the asynchronous queue. Then execute cat.say = function () {console.log ('Hello'} ), at which point the say method of the instance object cat has been overridden. Next, the Synchronize task is finished, and the callback function is added to the asynchronous queue before execution, so the output is Hello .

to output 'say something', the key is to run the exact reference to o in Cat in the timer callback, or you can do this:

var Cat = function() {
var another;
    var o = {
        say: function() {
            console.log('say something');
        }
    }
    another = o.say;
    setInterval(function(){
        another ();
    }, 1000)
    return o
}

code is simplified to

var o = {
    say: function() {
        console.log('say something');
    }
}
setInterval(function(){
    o.say()
}, 1000);
var cat = o;

cat.say = function() {
    console.log('Hello');
}

draw a picture:

The
1. o and Cat variables both point to the 0x0001 address, where an object is stored;
There is a say pointer to 0x0002 on the
2. object, where is the say function;
3. later, the say pointer is reassigned to the 0x0003 address, which is a new say function;
4. finally, the setInterval function calls 0x0003's say function, not 0x0002's say function.

although the code for setInterval is written first, it will be executed first because the first three steps are Synchronize tasks.
you can search for the event loop in JS. The Synchronize task code is executed first, and macro tasks such as setInterval and setTimeout are placed in an asynchronous queue to wait for the Synchronize task to complete.