Allez les transformateurs

Go-Utils

go-utils est une bibliothèque qui vise à fournir des bibliothèques utiles pour réduire les efforts des développeurs pour créer des éléments et augmenter
productivité.

Peu de fonctionnalités sont mentionnées ci-dessous.

Exécuteur de tâches

Le problème fondamental que cela essaie de résoudre est de savoir comment vous souhaitez exécuter plusieurs tâches en fonction d'une demande que vous avez reçue.
Considérez le scénario suivant.

• processA traite un scénario et peut produire une erreur.
• processB traite le deuxième scénario et peut produire une erreur.

Comme vous pouvez le constater, tous ces processus peuvent entraîner une erreur. Golang est intrinsèquement très verbeux dans la gestion des erreurs. Parfois, nous ne voulons pas voir ce code redondant.
Cela réduit également la lisibilité.

Envisagez maintenant un autre scénario -
Une fois que vous avez géré l'erreur pour processA et que vous avez oublié processB, Golang ne générera pas d'erreur de compilation, ce qui vous fera manquer ce cas. Un petit raté peut faire des ravages. Bien que nous soyons censés suivre de nombreux processus avant l'expédition en production, demandez-vous si vous suivez toujours ou non ?

Pour résoudre cela, j'ai développé une approche où vous serez
plus concentré sur l'écriture de ce qui compte et sur la facilité avec laquelle il serait de regarder un fn et de comprendre ce qu'il fait. Cela aidera également à surmonter l’ombrage variable. Dans les cas où plusieurs erreurs sont détectées, une observation d'erreur peut se produire et cela peut être mauvais. Suivre ce modèle et un bon codage peut aider à éviter de tels scénarios étranges.

Exemples -

Un code avec une gestion des erreurs redondante et une lisibilité réduite.

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    err := processFoo(ctx, &req)
    if err != nil {
        return err
    }
    err = processBar(ctx, &req)
    if err != nil {
        return err
    }
    return nil
}

Un code avec le task runner

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    runner := NewSimpleTaskRunner(ctx, req)
    _, err := runner.
        Then(processFoo).
        Then(processBar).
        Result()
    return err
}

Comme vous pouvez le constater, à quel point le code est lisible et exécutable. Ce processus de réflexion et ce cadre peuvent améliorer la lisibilité du code.

Amateurs de routine

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    runner := NewSimpleTaskRunner(ctx, req)
    _, err := runner.
        Parallel(processFooParallel).
        Parallel(processBarParallel).
        Result()
    return err
}

Utilitaires de flux

Nous connaissons tous les fameuses fonctions lambdas et flèches. Golang
ne prend pas intrinsèquement en charge la syntaxe des flèches. Ce serait bien d'avoir
ça en golang. Pour l'instant, supposons que nous devions effectuer une opération sur la carte
c'est là que les choses deviennent difficiles. Eh bien, vous êtes prêt pour une mise en œuvre sympa
de ma part pour résoudre ça pour vous. Après cette mise en œuvre ci-dessous, je le ferais
demandez-vous de réfléchir par vous-même à la manière dont cela aurait été mis en œuvre.

func TestMapRunner(t *testing.T) {
    // Create a map with some values
    floatingStrings := []string{"0.1", "0.2", "22", "22.1"}

    res, err := NewTransformer[string, float64](floatingStrings).
        Map(MapIt[string, float64](func(item string) (float64, error) { return strconv.ParseFloat(item, 64) })).
        Map(MapIt[float64, float64](func(item float64) (float64, error) { return item * 10, nil })).
        Result()
    if err != nil {
        t.Errorf("Testcase failed with error : %v", err)
        return
    }
    // Output: [0.1 0.2 22 22.1]
    t.Logf("Result: %v", res)
    assert.ElementsMatch(t, []any{float64(1), float64(2), float64(220), float64(221)}, res)

}

L'exemple ci-dessus concerne une conversion de chaîne en float64.
Cela gérera les erreurs pour vous s'il y en a. La seule exception sera qu'il peut y avoir des erreurs d'exécution s'il y en a
Problèmes de diffusion de type Soyez donc prudent avec cela. Essayez d'écrire les cas de test
ce qui devrait éviter ce problème.

Combo mortel de filtre et de mappeur

Un ajout à la fonctionnalité est fait maintenant, la filtration fonctionne également.
Bon moment les amis !!

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    err := processFoo(ctx, &req)
    if err != nil {
        return err
    }
    err = processBar(ctx, &req)
    if err != nil {
        return err
    }
    return nil
}

Importez une bibliothèque dans votre projet pour créer des trucs sympas.

allez chercher -u github.com/mahadev-k/go-utils@v1.0.1

Ajoutez ceci à votre go.mod.
Utilisez-le comme dans le module exemples.

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    runner := NewSimpleTaskRunner(ctx, req)
    _, err := runner.
        Then(processFoo).
        Then(processBar).
        Result()
    return err
}

Exemple simple

func FooBar() error {
    req := struct{
        isFoo bool
        isBar bool
    }{}
    ctx := context.TODO()
    runner := NewSimpleTaskRunner(ctx, req)
    _, err := runner.
        Parallel(processFooParallel).
        Parallel(processBarParallel).
        Result()
    return err
}

Consultez le dépôt :
Github : https://github.com/mahadev-k/go-utils

Considérant que vous avez lu ceci et que vous l'avez aimé. Si vous souhaitez me contacter
Suivez-moi sur X - https://x.com/mahadev_k_
Linkedin - https://in.linkedin.com/in/mahadev-k-934520223
Proposez plus d'idées de contributions à ce dépôt si vous êtes intéressé.
Merci ??

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!