[GOLANG] Valeurs unique de chaque maps "map[string]map[string]string"

Bonjour à tous,

Je cherche un moyen d'optimiser la fonction que j'ai écrit qui me permet determiner les clés/valeurs uniques, elles méme présentent dans plusieurs maps.

J'ai en valeur d'entré cette structure: map[string]map[string]string

{
  "deploymentAbc": {
    "app": "nginx",
    "env": "dev",
    "composant": "nginx",
    "type": "frontend"
  },
  "deploymentBcd": {
    "app": "mongo",
    "env": "dev",
    "composant": "mongo-db",
    "type": "database"
  },
  "deploymentEfg": {
    "app": "mongo",
    "env": "dev",
    "composant": "mongo-express",
    "type": "database"
  },
  "deploymentHij": {
    "app": "php",
    "env": "dev",
    "composant": "authz",
    "type": "backend"
  }
}

J'ai en valeur de sortie cette structure: map[string][]string

{
  "deploymentAbc": [
    "app=nginx",
    "composant=nginx",
    "type=frontend"
  ],
  "deploymentBcd": [
    "composant=mongo-db"
  ],
  "deploymentEfg": [
    "composant=mongo-express"
  ],
  "deploymentHij": [
    "app=php",
    "composant=authz",
    "type=backend"
  ]
}

La fonction que j'ai écrit:

func FindUniqueLabels(composants map[string]map[string]string) map[string][]string {
        unique := make(map[string][]string, len(composants))
        for composant, o := range composants {
                for labelName, labelValue := range o {
                        skip := false
                        label := fmt.Sprintf("%s=%s", labelName, labelValue)
                        for composantO, uo := range composants {
                                if composant != composantO {
                                        for labelNameO, labelValueO := range uo {
                                                labelO := fmt.Sprintf("%s=%s", labelNameO, labelValueO)
                                                if label == labelO {
                                                        skip = true
                                                }
                                        }
                                }
                        }
                        if !skip {
                                unique[composant] = append(unique[composant], label)
                        }
                }
        }
        return unique
}

Je suis pas fan de mes boucles dans mes boucles et je me demande s'il n'existerait pas déja des fonctions ou libs qui font le travaille...

J'ai déja vu des fonctions qui s'appelle elle même, mais je vois pas comment l'implémenter ni ne sais le reel gain de perf que ça peut permettre.

Si quelqu'un voit comment on peut faire plus propre et joli je suis preneur !

Bien à vous
Exil'