1
votes

Trouver la valeur min (max) parmi tous les object.properties et renvoyer le résultat en tant qu'objet ou (modifier l'objet d'origine)

Cette tâche un peu facile à première vue, avec la recherche des valeurs min / max dans Object, est devenue un défi pour moi.

J'ai l'objet suivant (avec 3 clés fixes):

if (resultObject.property === 'derivative') {
   resultObject.derivative = {
      price: resultObject.derivative  //15
   }
}

Et j'essaie non seulement de trouver la valeur min / max, mais de la renvoyer sous forme d'objet / de modifier l'original, qui devrait ressembler à ceci:

résultat pour min : // en tant qu'objet

/** Create an array of objects from object_*/

let array = [
   {market: 2},
   {vendor: 5},
   {derivative: 15}
]

/** Find the necessary values in array with map and reduce*/

résultat pour max : // en tant qu'objet

XXX

Pour l'instant, j'ai le code suivant qui résout ce problème en créant un tableau à partir des propriétés de l'objet d'origine (en vérifiant manuellement le nom de chaque propriété), comme:

derivative: {
    price: 15 //(Number)
}

Et puis trouver les valeurs min / max de tous les objets à l'intérieur du tableau, mais le problème est que je devrais reconvertir le résultat de mon code dans le schéma d'origine comme:

{ market: 2}

javascript object arrays design-patterns

4 commentaires

Bonjour, @NinaScholz. Désolé, je veux dire, je devrais trouver des valeurs min / max dans toutes les propriétés de l'objet. Je viens donc de corriger le titre / la description de la question.

à partir de toutes les propriétés de object_ (vendeur, marché, dérivé). Le défi est que la propriété dérivée n'est pas un Number, c'est un autre objet avec ses propres champs et un seul champ nommé price dans il a la valeur Number nécessaire pour comparer avec market et `vendor` Et je devrais retourner une sorte de pointeur qui montre le plus bas / le plus élevé la valeur est stockée dans une certaine propriété

que doit-il se passer si plus d'une propriété est min ou max?

vous voulez dire, si {vendor: 1} et {market: 1} également? Tbh je n'y ai pas pensé. Dans mon cas, il existe une forte hiérarchie entre eux. vendor est le "plus lourd" et le dérivé a la "priorité la plus basse". Jusqu'à ce que vous demandiez, je n'y ai jamais pensé, donc je devrais ajouter ceci à mon code.

3 Réponses :

1
votes

Au début de la fonction, définissez min index sur 0. Ensuite, parcourez chaque clé de l'objet à partir de l'index 1. Testez si la valeur de la touche est un objet, et si elle est appelée la fonction actuelle, et définissez la valeur sur la valeur renvoyée, puis testez si la valeur est inférieure à un à l'index. S'il est mis index à i. À la fin, retournez un objet avec la valeur.

function getMin(obj) {
    let minIndex = 0;
    let keys = Object.keys(obj); //Get all the keys in the object
    for(let i = 0;i < keys.length;i++) { // Loop through the keys
        let value = obj[keys[i]];
        if(typeof value !== 'number') { // If it's not a number get the minimum value in the object
            value = getMin(value);
        }
        if(value < obj[keys[minIndex]]) minIndex = i; //If the value is less than the value at the min index, set the min index to the current index
        // You can just change the sign to greater for the max function
    }
    let returnObject = {};
    returnObject[keys[minIndex]] = obj[keys[minIndex]]; // Sets the object so it doesn't only return the value
    return returnObject;
}

0 commentaires

0
votes

Ma propre solution que j'utilise actuellement. Il fait bien le travail, mais c'est un peu monstrueux je suppose. Je ne l'accepterai donc pas comme réponse à ma propre question. Mais c'est quand même une option.

let object = {
    market: 5,
    vendor: 2,
    derivative: {
        price: 15
    }
};

let bufferArray = [];

for (const property in object) {
    if (typeof object[property] === 'object') {
        bufferArray.push({name: property, value: object[property].price});
    } else {
        bufferArray.push({name: property, value: object[property]});
    }
}

let {name, value} = bufferArray.reduce((prev, curr) => prev.value < curr.value ? prev : curr); //just change < to > for max value
let newObject = {[name]: value};
console.log(newObject); //{ vendor: 2 }

0 commentaires

1
votes

Vous pouvez obtenir la valeur et le chemin d'accès, sélectionner les valeurs min et max et reconstruire les objets pour min et max.

Cette approche ne fonctionne que pour des valeurs min et max.

.as-console-wrapper { max-height: 100% !important; top: 0; }

const
    getValues = object => {
        return Object
            .entries(object)
            .flatMap(([k, v]) => v && typeof v === 'object'
                ? getValues(v).map(([keys, v]) => [[k, ...keys], v])
                : [[[k], v]]
            );
    },
    setValue = (target, [keys, value]) => {
        const last = keys.pop();
        keys.reduce((o, k) => o[k] = o[k] || {}, target)[last] = value;
        return target;
    },
    getMinMax = object => {
        const
            [min, max] = getValues(object)
                .reduce((r, v, i) => {
                    if (!i) return [v, v];
                    if (v[1] < r[0][1]) r[0] = v;
                    if (v[1] > r[1][1]) r[1] = v;
                    return r;
                }, [])
                .map(v => setValue({}, v));
        return { min, max };
    },
    object = { vendor: 5, market: 2, derivative: { price: 15 } },
    result = getMinMax(object);

console.log(result);

0 commentaires