A way to fire logic at the end of completion of the current class method (regardless of super call order).

Michael Haufe tno at thenewobjective.com
Tue Feb 12 04:34:08 UTC 2019


You can use a Proxy in the base class:

<script>
let handlerExample = {
    get(target, prop) {
        let feature = target[prop]
        return feature instanceof Function ?
            function () {
                console.log('Before call');
                let result = feature.apply(this, arguments)
                console.log('After call');
                return result
            }
            : feature
    }
}

class Base {
    constructor() {
        return new Proxy(this, handlerExample)
     }
    m1() { return "m1" }
}

class Sub extends Base {
    m1() { return `override ${super.m1()}` }
    m2() { return `m2` }
}

let base = new Base()
console.log(base.m1())

let sub = new Sub()
console.log(sub.m1())
console.log(sub.m2())
</script>

/Michael


On Fri, Feb 8, 2019 at 1:22 AM #!/JoePea <joe at trusktr.io> wrote:

 > I many times find myself in cases where a base class wants to ensure that logic is always fired after the current method's execution, so that for example no matter in which order sub classes call the `super` method, the `super` method can still guarantee that logic fires after the whole stack of the same method in the class hierarchy.

> So what I can do now is use `Promise.resolve().then(() => { ... })` to schedule that logic for later, that way all the invocations of a `foo` method along the class hierarchy have all fired. But this means that other code can also fire before the next microtask.

> Is there some way to do it? If not, I wonder if some language feature for doing it would be possible?


More information about the es-discuss mailing list