Show me your unnecessary code

#code #cleancode #challenge #showdev

Hi. Somehow, I wrote this code piece in the past. Today, I don't use this code but this still exists in our project.

function isNumber(data) {
    return typeof data == 'number' && !isNaN(data)
}

function isBoolean(data) {
    return typeof data === "boolean"
}

function isFloat(data){
    return isNumber(data) && data % 1 !== 0
}

function isNull(data){
    return !data && Object.is(data, null) && data === null
}

function isUndefined(data) {
    return !data && Object.is(data, undefined) && data === undefined
}

function isEmpty(data) {
    return data === "" && data.length === 0
}

const I = {
    sware: {
        this(data) {
            return {
                is: {
                    number: () => isNumber(data),
                    float: () => isFloat(data),
                    bool: () => isBoolean(data),
                    null: () => isNull(data),
                    undefined: () => isUndefined(data),
                    empty: () => isEmpty(data)
                }
            }
        }
    }
}

const aNumericValue = 341
const aFloatValue = 3.14
const aBoolValue = false
const aNullValue = null

You can use this like that;

const aNumericValue = 341
I.sware.this(aNumericValue).is.number()

So, what is yours?

Top comments (5)

Madza • Jul 6 '20

Static values in pre-ES6:

Object.defineProperty(typeof global === "object" ? global : window, "static", {
    value:        10,
    enumerable:   true,
    writable:     false,
    configurable: false
})

instead now:

const static = 10;

Keff • Jul 6 '20

Nice, I'll add a bit. It's a little experiment I did back in the day and now I think is not very useful:

const ffor = {
    _baseFor: () => ({
        _pipes: [],
        _coupled: [],
        pipe(...fns) {
            this._pipes.push(...fns);
            return this;
        },
        merge(fforInstance) {
            this._pipes.push(...fforInstance._pipes);
            return this;
        }
    }),
    get of() {
        return {
            ...this._baseFor(),
            with(values = []) {
                let newValues = [];
                for (let val of values) {
                    for (let pipe of this._pipes) {
                        val = pipe(val, values) || val;
                    }
                    if (val) newValues.push(val);
                }

                return newValues;
            }
        }
    },
    get in() {
        return {
            ...this._baseFor(),
            with(values = []) {
                let newValues = [];
                for (let key in values) {
                    let val = values[key];
                    for (let pipe of this._pipes) {
                        val = pipe(key, values[key], values) || val;
                    }
                    if (val) newValues.push(val);
                }

                return newValues;
            }
        }
    },
};

You can use it as follows:

// For of
let logItems =
    ffor.of
        .pipe((item) => console.log('item is: ' + item));

let forOf =
    ffor.of
        .pipe((item) => item + 1);

let result = forOf.merge(logItems).with([1, 2, 3, 4]);
console.log(result);


// For in
let forIn =
    ffor.in
        .pipe((key, value) => {
            console.log(key + ' is: ' + value)
            return { key: key, value: value };
        });

let result2 = forIn.with({ name: 'Manolo', lastname: 'Edge' });
console.log(result2);