paramètres de police Golang

Le langage Go est un langage de programmation open source lancé par Google en 2009. Ses principales caractéristiques sont la simplicité, la rapidité et l’efficacité, ce qui en fait le langage de prédilection de nombreux développeurs. Dans le langage Go, nous pouvons facilement utiliser les paramètres de police pour restituer et afficher le texte. Dans cet article, nous présenterons quelques méthodes de configuration des polices Golang couramment utilisées.

1. Charger les polices

Tout d'abord, nous devons charger le fichier de police. Généralement, le nom du fichier de police se termine par ".ttf" ou ".otf". En langage Go, nous pouvons utiliser la fonction truetype.Parse dans le package "github.com/golang/freetype/truetype" pour charger les fichiers de polices. Son utilisation est la suivante :

fontFile, err := os.Open("path/to/font.ttf")
if err != nil {
    log.Fatal(err)
}
defer fontFile.Close()

fontBytes, err := ioutil.ReadAll(fontFile)
if err != nil {
    log.Fatal(err)
}

font, err := truetype.Parse(fontBytes)
if err != nil {
    log.Fatal(err)
}

Dans le code ci-dessus, "path/to/font.ttf" est le chemin d'accès au fichier de police. Tout d’abord, nous ouvrons le fichier de police, puis lisons le contenu du fichier de police et utilisons la fonction truetype.Parse pour analyser le fichier de police en un objet de police « police ».

2. Définir la taille de la police

La définition de la taille de la police est également très simple. Tout d’abord, nous devons définir un objet freetype.Context. Il contient un objet Canvas pour dessiner du texte, des objets de police et quelques autres paramètres. Ensuite, nous passons l'objet font à l'objet Context en définissant la propriété Font de freetype.Context.

Voici un exemple :

import (
    "image"
    "image/color"
    "golang.org/x/image/font"
    "golang.org/x/image/font/gofont/goregular"
    "golang.org/x/image/font/gofont/gosmallcaps"
    "golang.org/x/image/math/fixed"
)

func main() {
    bounds := image.Rect(0, 0, 1024, 768)
    img := image.NewGray(bounds)
    ctx := freetype.NewContext()
    ctx.SetDPI(72)
    ctx.SetFont(font.Font{})
    ctx.SetFontSize(14)
    ctx.SetClip(img.Bounds())
    ctx.SetDst(img)
    ctx.SetSrc(image.NewUniform(color.Black))

    pt := freetype.Pt(50, 50)
    _, err := ctx.DrawString("Hello, world!", pt)
    if err != nil {
        log.Println(err)
    }
}

Dans le code ci-dessus, nous utilisons la fonction image.NewGray pour créer une nouvelle image en niveaux de gris et créons un nouvel objet Context via la fonction freetype.NewContext. Ensuite, nous définissons la police à l'aide de la fonction ctx.SetFont. Le paramètre de cette fonction est un objet qui implémente l'interface Font dans le package image/font. Dans cet exemple, nous utilisons un objet police de type font.Face. Enfin, nous dessinons un morceau de texte à l'aide de la fonction ctx.DrawString.

3. Définir le style de police

La définition du style de police est également très simple. Nous pouvons utiliser l'objet font.FaceOptions pour définir le style de la police. Voici un exemple :

import (
    "github.com/golang/freetype"
    "github.com/golang/freetype/truetype"
    "golang.org/x/image/font"
)

func main() {
    fontFile, err := os.Open("path/to/font.ttf")
    if err != nil {
        log.Fatalf("failed to open font file: %v", err)
    }
    
    defer fontFile.Close()
    
    fontBytes, err := ioutil.ReadAll(fontFile)
    if err != nil {
        log.Fatalf("failed to read font file: %v", err)
    }
    
    font, err := truetype.Parse(fontBytes)
    if err != nil {
        log.Fatalf("failed to parse font: %v", err)
    }
    
    size := 24.0
    
    ctx := freetype.NewContext()
    ctx.SetDPI(72)
    ctx.SetFont(font)
    
    var hinting font.Hinting
    ctx.SetHinting(hinting)

    faceOptions := truetype.Options{
        Size: size,
        DPI: 72,
        Hinting: hinting,
    }
    
    boldFont := truetype.NewFace(font, &faceOptions)
    
    italicFaceOptions := faceOptions
    italicFaceOptions.FauxBold = true
    italicFaceOptions.FauxItalic = true
    italicFaceOptions.Size = size + 6
    
    italicBoldFont := truetype.NewFace(font, &italicFaceOptions)
}

Dans le code ci-dessus, nous avons défini deux variables faceOptions et italicFaceOptions, qui sont utilisées pour définir le style de police. Ensuite, nous appelons la fonction truetyp.NewFace pour créer les variables de police boldFont et italicBoldFont.

Grâce à ces méthodes, nous pouvons facilement définir la taille et le style de la police, rendant notre programme plus créatif et plus beau.

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!