paramètres de police Golang

Golang est un langage de programmation puissant, très riche en fonctionnalités et adapté à divers projets de développement logiciel. Dans Golang, la définition des polices est une tâche très importante car elle affecte directement l'effet d'affichage du programme dans l'interface utilisateur. Cet article vous présentera comment définir les polices dans Golang.

Dans Golang, il existe un package appelé "golang.org/x/image/font", qui fournit un moyen simple de définir les polices. Les étapes spécifiques sont les suivantes :

1. Installez le fichier de police

Tout d'abord, Vous devez télécharger et installer les fichiers de polices que vous souhaitez utiliser. Cela peut être fait de différentes manières, par exemple en téléchargeant à partir de bibliothèques de polices gratuites ou en achetant auprès de fournisseurs de polices commerciaux.

2. Introduisez le package de polices

Après avoir installé le fichier de police, vous devez introduire le package "golang.org/x/image/font" dans votre projet Golang. Vous pouvez le télécharger dans la ligne de commande en utilisant la commande suivante :

go get golang.org/x/image/font

3 Utilisation des fichiers de police

Après avoir introduit le package de polices, vous devez charger le fichier de police dans le fichier. Projet Golang. Vous pouvez charger le fichier de police dans le programme en utilisant le code suivant :

fontBytes, err := ioutil.ReadFile("path/to/your/font/file.ttf")
if err != nil {
    log.Fatalf("read font file: %v", err)
}
font, err := truetype.Parse(fontBytes)
if err != nil {
    log.Fatalf("parse font: %v", err)
}

Vous pouvez remplacer le chemin d'accès au fichier de police par le chemin réel du fichier de police que vous utilisez.

4. Définir la police

Après avoir chargé la police, vous devez utiliser la police pour définir la police et la taille du texte. Voici un exemple :

const dpi = 72
fontFace := truetype.NewFace(font, &truetype.Options{
    Size:    12,
    DPI:     dpi,
    Hinting: font.HintingFull,
})

Dans le code ci-dessus, nous spécifions la police et la taille de la police en créant un objet truetype.NewFace. « DPI » fait référence à « PPI » ou « pixels par pouce », qui correspond au nombre de points que vous voyez sur votre moniteur. Dans ce cas, nous le définissons sur 72, qui est la valeur PPI par défaut.

En plus de la taille de la police, vous pouvez également définir le type de police, comme gras, italique, etc. Vous pouvez utiliser le code suivant :

fontFaceBold := truetype.NewFace(font, &truetype.Options{
    Size:    12,
    DPI:     dpi,
    Hinting: font.HintingFull,
    Weight:  truetype.Bold,
})

Dans le code ci-dessus, nous précisons que la police est en gras en définissant "Weight" sur truetype.Bold.

5. Utilisation des polices

Après avoir défini et chargé la police, vous pouvez l'utiliser pour définir la police de votre sortie. Voici un exemple :

import (
    "image"
    "image/color"
    "image/png"
    "os"

    "golang.org/x/image/font"
    "golang.org/x/image/font/basicfont"
    "golang.org/x/image/font/gofont/gomonobold"
    "golang.org/x/image/math/fixed"
)

func main() {
    img := image.NewRGBA(image.Rect(0, 0, 400, 200))
    col := color.RGBA{0xff, 0xff, 0xff, 0xff}
    drawString(img, "Hello, Golang!", 100, 100, fontFace, col)
    drawString(img, "Hello, Golang Bold!", 100, 150, fontFaceBold, col)

    f, err := os.Create("output.png")
    if err != nil {
        log.Fatalf("create output file: %v", err)
    }
    png.Encode(f, img)
    if err := f.Close(); err != nil {
        log.Fatalf("close file: %v", err)
    }
}

func drawString(img *image.RGBA, str string, x, y int, face font.Face, col color.Color) {
    d := &font.Drawer{
        Dst:  img,
        Src:  image.NewUniform(col),
        Face: face,
    }
    d.Dot = fixed.Point26_6{
        X: fixed.Int26_6(x * 64),
        Y: fixed.Int26_6(y * 64),
    }
    d.DrawString(str)
}

Dans l'extrait de code ci-dessus, nous avons créé une fonction personnalisée appelée "drawString" pour écrire une chaîne dans une image. Dans cette fonction, nous prenons comme paramètres de fonction l'image elle-même, la chaîne à écrire, la position de la chaîne, ainsi que le type de police et la couleur à utiliser. Nous utilisons ensuite "font.Drawer" pour écrire la chaîne dans l'image.

L'image de sortie finale contiendra la sortie de Hello, Golang ! et Hello, Golang Bold !

Résumé

Dans cet article, nous avons présenté un moyen simple de définir des polices dans Golang. En utilisant le package "golang.org/x/image/font" fourni par Golang, vous pouvez facilement définir la police ainsi que la taille et le type de police. J'espère que cet article vous a aidé à mieux comprendre comment définir les polices dans Golang.

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!