Une 'Carte' légèrement meilleure peut vous y amener plus facilement...

En JavaScript, Map est une classe intégrée très utile qui crée une recherche O(1) entre une clé et une valeur.

const myMap = new Map()

for(const file of files) {
    const [,extension] = file.name.split(".")
    if(!myMap.has(extension)) {
        myMap.set(extension, [])
    }
    myMap.get(extension).push(file)
}

Vous pouvez utiliser Maps pour toutes sortes de choses que vous êtes susceptible de faire régulièrement :

• Création de listes groupées de données, comme l'exemple ci-dessus, regroupant par extension de fichier

• Agréger des données, comme compter ou additionner des valeurs sur une plage de clés
  

// 1) Counting occurrences
const items = ['apple','apple','orange','banana','apple'];
const counts = new Map();
for (const item of items) {
  counts.set(item, (counts.get(item) || 0) + 1);
}

• Création de recherches rapides à utiliser dans les étapes suivantes

const users = [
  {id:1,name:'A',role:'admin'},
  {id:2,name:'B',role:'user'},
  {id:3,name:'C',role:'user'}
];
const userMap = new Map();
for (const u of users) {
  userMap.set(u.id, u);
}

Map est préférable à l'utilisation d'un simple objet ({}) pour plusieurs raisons, à condition que vous n'ayez pas à stocker le résultat à l'aide d'un stringify :

• Il peut prendre des clés qui ne sont pas des chaînes
• C'est légèrement plus rapide qu'un objet même si vous utilisez des clés de chaîne

Il peut y avoir beaucoup de problèmes passe-partout et mixtes, cependant, si l'objet que vous stockez dans la carte a besoin d'une construction, qui va d'un simple tableau à un objet complexe, cela doit être entrecoupé du code qui l'utilise. .

const map = new Map()

for(const item of items) {
   if(!map.has(item.type)) {
       const newType = new Type(item.type, getInfoForType(item.type))
       map.set(item.type, newType)
   }
   map.get(item.type).doSomething(item)

}

Cela "peut" être ok, mais il devient plus difficile de rester SEC si vous devez mettre à jour ou initialiser la valeur à plusieurs endroits.

Pour cette raison, j'utilise une classe MapPlus, qui est une extension de Map qui fournit une fonction d'initialisation de clé manquante qui peut être fournie au constructeur ou comme deuxième paramètre pour get si l'initialiseur a besoin d'informations contextuelles au-delà de simplement la clé.

class MapPlus extends Map {
    constructor(missingFunction) {
        super()
        this.missingFunction = missingFunction
    }

    get(key, createIfMissing = this.missingFunction) {
        let result = super.get(key)
        if (!result && createIfMissing) {
            result = createIfMissing(key)
            if (result && result.then) {
                const promise = result.then((value) => {
                    super.set(key, value)
                    return value
                })
                super.set(key, promise)
            } else {
                super.set(key, result)
            }
        }
        return result
    }
}

Avec cela, vous pouvez simplement faire des choses comme :

const map = new MapPlus(()=>[])

for(const item of items) {
    map.get(item.type).push(item)
}

Comme si la clé manquait, cela créerait simplement un tableau vide.

J'ai souvent besoin de deux niveaux, donc j'aurai des cartes définies comme ceci :

const map = new MapPlus(()=>new MapPlus(()=>[]))
for(const item of items) {
   map.get(item.type).get(item.subType).push(item)
}

La fonction constructeur récupère la clé utilisée, nous pouvons donc également faire :

const map = new MapPlus((type)=>new Type(type, getInfoForType(type))

for(const item of items) {
    map.get(item.type).doSomething(item)
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!