JS: Performance of Constructor using Key-Value Pairs

Are there any negative performance implications for using object literals inside of object constructors in JavaScript?

For example:

class Thingy {
    constructor(props) {
        if (!props) {
            props = {};
        }

        // defaults
        this.name = '';
        this.amount = 0;

        for (let key in props) {
            let value = props[key];

            switch (key) {
                case 'name':
                    this.name = value;
                    break;

                case 'amount':
                    this.amount = value;
                    break;

                ...

                default:
                    throw `Invalid property ${key}`;
            }
        }
    }

    ...
}

let thingy1 = new Thingy({
    name: 'The Thing',
    amount: 6
});

let thingy2 = new Thingy({
    amount: 4,
    name: 'Another Thing'
});

The idea is to make it easier to see what values are being attached to which properties as well as to be able to mix the order of properties passed (or even omit some), as opposed to the default method:

class Thingy {
    constructor(name, amount) {
        this.name = name;
        this.amount = amount;
    }

    ...
}

let thingy1 = new Thingy('The Thing', 6);

Obviously, this is a non-standard and more complex way of using constructors, but would it slow down performance?