Comment changer la police avec Golang

Golang est un langage de programmation rapide et pratique qui a reçu une attention et une utilisation de plus en plus répandues ces dernières années. Dans la programmation Golang de base, il est souvent nécessaire de changer la police du texte. Cet article explique comment utiliser Golang pour changer la police.

Les étapes de base pour changer la police sont les suivantes :

1. Télécharger la police
2. Installer la police sur l'ordinateur
3. Utiliser Golang pour imprimer et utiliser la police

Étape 1 : Télécharger la police

Il existe de nombreuses façons pour télécharger la police, mais le plus simple. Le meilleur moyen est de la télécharger en ligne et de choisir la police qui répond à vos besoins. Après avoir téléchargé les polices, nous devons les déplacer vers le dossier de notre projet Golang.

Étape 2 : Installer les polices sur l'ordinateur

Les fichiers de polices ont généralement un suffixe .ttf ou .otf Sous les systèmes Windows, nous pouvons copier ces fichiers de polices dans le dossier Polices du système d'exploitation. Sous le système Mac, nous devons copier les fichiers de polices dans le dossier /Bibliothèque/Fonts ou ~/Library/Fonts.

Étape 3 : Imprimer et utiliser des polices avec Golang

Golang fournit un moyen de générer des polices dans la console. Nous pouvons utiliser la fonction Println dans le package fmt intégré dans Golang pour imprimer la chaîne avec la police modifiée. Cependant, il est important de noter que nous devons utiliser les polices installées lors de la deuxième étape pour imprimer le résultat.

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "golang.org/x/image/font"
    "golang.org/x/image/font/basicfont"
    "golang.org/x/image/font/inconsolata"
    "golang.org/x/image/font/opentype"
    "image"
    "image/color"
    "image/draw"
    "image/png"
    "io/ioutil"
    "os"
)

func main() {
    tempFile, err := downloadFontTemporarily()
    if err != nil {
        fmt.Printf("Failed to download the font: %v", err)
        return
    }
    // Cleanup the temp file.
    defer os.Remove(tempFile.Name())

    fontBytes, err := ioutil.ReadFile(tempFile.Name())
    if err != nil {
        fmt.Printf("Failed to read the font: %v", err)
        return
    }

    // Parse the font, allowing for a variety of font types.
    f, err := opentype.Parse(fontBytes)
    if err != nil {
        fmt.Printf("Failed to parse the font: %v", err)
        return
    }

    const size = 72
    d := &font.Drawer{
        Dst:  draw.NewRGBA(image.Rect(0, 0, 1024, 1024)),
        Src:  image.NewUniform(color.White),
        Face: truetype.NewFace(f, &truetype.Options{Size: size}),
    }
    d.Dot = fixed.Point26_6{
        X: (fixed.I(10)),
        Y: (fixed.I(50)),
    }
    d.DrawString("Hello World!")

    img := d.Dst.(*draw.RGBA)
    png.Encode(os.Stdout, img)
}

func downloadFontTemporarily() (*os.File, error) {
    // Download a font so we can draw it.
    resp, err := http.Get("https://storage.googleapis.com/golang/go1.9beta1.linux-amd64.tar.gz")
    if err != nil {
        return nil, fmt.Errorf("Failed to open source image: %v", err)
    }

    // Write the file to a temporary directory so `font.OpenType` can use it.
    tempFile, err := ioutil.TempFile("", "font.ttf")
    if err != nil {
        return nil, fmt.Errorf("Failed to create temp file: %v", err)
    }

    // Cleanup the temporary file,
    defer os.Remove(tempFile.Name())

    if _, err = io.Copy(tempFile, resp.Body); err != nil {
        return nil, fmt.Errorf("Failed to write font to temp file: %v", err)
    }

    // Seek back to the start of the file so it can be read again later.
    if _, err = tempFile.Seek(0, io.SeekStart); err != nil {
        return nil, fmt.Errorf("Failed to seek to start of temporary file: %v", err)
    }

    return tempFile, nil
}

Il s'agit d'un exemple de programme pour imprimer la chaîne "Hello World!". Il utilise la police spécifiée et utilise la fonction DrawString pour dessiner les caractères sur l'image, et enfin convertit le code. image au format PNG Sortie vers la sortie standard.

Pour différentes polices, nous pouvons également utiliser le package de polices intégré ou le package basicfont dans Golang ou le package golang.org/x/image/font/inconsolata pour dessiner des polices.

Résumé

À travers l'introduction de cet article, nous pouvons voir que la méthode de changement de police dans Golang est très simple. Téléchargez simplement la police, installez la police, puis utilisez la fonction Println dans Golang pour générer la police spécifiée. Dans le même temps, en utilisant le package de polices intégré ou le package basicfont ou le package golang.org/x/image/font/inconsolata pour dessiner des polices, nous pouvons considérablement augmenter la flexibilité et l'évolutivité des applications 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!