Je résumerai brièvement les extraits que j'utilise personnellement lors de la programmation avec Go. Il existe différents types, de ceux qui sont utilisés très souvent à ceux qui ne sont utilisés qu'occasionnellement. On dirait qu'il peut être utilisé! !! !! Je serais heureux si vous pouviez présenter juste ceux que vous avez pensé!
Tout d'abord, je présenterai brièvement comment enregistrer des extraits avec vscode
Code -> Preferences -> User Snippets
↓
Ensuite, un écran comme celui-ci apparaîtra, alors cliquez sur aller
↓
Ensuite, le fichier json suivant sera affiché, c'est comme ajouter l'extrait de code que vous souhaitez utiliser ici
L'enregistrement d'extraits de code peut être effectué avec la syntaxe suivante
python
"Titre de l'extrait": {
"prefix": "Quels types de caractères doivent être saisis pour une conversion prédictive?",
"body": [
"Quel type de chaîne de caractères doit être généré?",
"Si vous souhaitez ouvrir une entreprise, vous pouvez l'ouvrir en la saisissant séparée par des virgules comme celle-ci",
],
"description": "Explication détaillée"
},
Vous pouvez également décider où placer le curseur en entrant le caractère «$ 1» après avoir tapé l'extrait. Par exemple, lorsque vous créez l'extrait de code suivant
python
"Print to console": {
"prefix": "fff",
"body": ["fmt.Printf(\"==========%#v\\n\", $1)"],
"description": "Journal pour vérifier le mouvement"
},
Après avoir utilisé l'extrait
python
fmt.Printf("==========%#v\n", )
//↑ Le curseur vient ici
Viendra dire
Caractère que vous souhaitez insérer | Comment insérer |
---|---|
$ | \\$ |
languette | \t |
Double citation | " |
Simple citation | ' |
Ceci est une impression pour le débogage. Il est souvent utilisé pour vérifier le contenu de la structure et pour identifier l'emplacement de l'erreur.
python
"Print to console": {
"prefix": "fff",
"body": ["fmt.Printf(\"==========%#v\\n\", $1)"],
"description": "Journal pour vérifier le mouvement"
},
↓ fff
python
fmt.Printf("==========%#v\n", )
Je l'ai créé car il est trop ennuyeux d'entrer des parenthèses lors de la création d'une méthode de structure. Je l'utilise personnellement aussi
python
"func": {
"prefix": "fc",
"body": ["func ($1) $2($3)($4){", "\t$0", "}"],
"description": "Créer une fonction pour struct"
},
↓fc
python
func () ()(){
}
package
Imprimez simplement package
C'est étonnamment facile!
python
"package": {
"prefix": "pac",
"body": "package",
"description": "Je ne veux même pas écrire un "package""
},
↓pac
python
package
Il crée un modèle de test piloté par table à la fois. C'est assez ennuyeux d'écrire à partir de 0 à chaque fois, donc je l'ai fait à peu près d'abord avec ceci (Pour un test basé sur une table, cliquez ici](https://qiita.com/takehanKosuke/items/cbfc88c4b7956adede79))
python
"test func": {
"prefix": "fct",
"body": [
"func Test$1(t *testing.T) {",
"\tt.Parallel()",
"\tasserts := assert.New(t)",
"\ttests := []struct{",
"\t\tname string",
"\t\tinput string",
"\t\toutput string",
"\t}{",
"\t\t{",
"\t\t\tname: \"\",",
"\t\t\tinput: \"\",",
"\t\t\toutput: \"\",",
"\t\t},",
"\t}",
"\tfor _, td := range tests {",
"\t\ttd := td",
"\t\tt.Run(fmt.Sprintf(\"$1: %s\", td.name), func(t *testing.T) {",
"\t\t})",
"\t}",
"}"
],
"description": "Base de test de table"
},
↓fct
python
func Test(t *testing.T) {
t.Parallel()
asserts := assert.New(t)
tests := []struct{
name string
input string
output string
}{
{
name: "",
input: "",
output: "",
},
}
for _, td := range tests {
td := td
t.Run(fmt.Sprintf(": %s", td.name), func(t *testing.T) {
})
}
}
gomock C'est une commande que vous écrirez certainement dans gomock, qui est une bibliothèque fictive souvent utilisée dans go. C'est utile car il est facile d'oublier comment le dessiner.
python
"Gomock template": {
"prefix": "tgomock",
"body": [
"//paramètres de gomock",
"ctrl := gomock.NewController(t)",
"defer ctrl.Finish()"
],
"description": "Créer ginContext pour le test"
},
↓tgomock
python
//paramètres de gomock
ctrl := gomock.NewController(t)
defer ctrl.Finish()
Ceci est un extrait de code utilisé lors de l'écriture d'un test qui inclut un contexte gin avec gin, qui est un framework de go (voir ici pour plus de détails).
python
"test gin Context": {
"prefix": "tgincontext",
"body": [
"//Générer un contexte de gin pour le test",
"ginContext, _ := gin.CreateTestContext(httptest.NewRecorder())",
"req, _ := http.NewRequest(\"GET\", \"/\", nil)",
"//req.Header.Add(\"Authorization\", td.inputHeader)",
"//req.Header.Add(\"Authorization\", td.inputHeader)",
"ginContext.Request = req"
],
"description": "Phrase fixe initiale pour gomock"
},
↓tgincontext
python
//Générer un contexte de gin pour le test
ginContext, _ := gin.CreateTestContext(httptest.NewRecorder())
req, _ := http.NewRequest("GET", "/", nil)
//req.Header.Add("Authorization", td.inputHeader)
//req.Header.Add("Authorization", td.inputHeader)
ginContext.Request = req
Ceci est un extrait de code utilisé pour ignorer les requêtes http avec go. Il est facile d'oublier comment ajouter des en-têtes et des paramètres, donc je me souviens toujours de l'utiliser.
python
"HTTP GET request": {
"prefix": "httpget",
"body": [
"url := \"\"",
"req, err := http.NewRequest(\"GET\", url, nil)",
"if err != nil{",
"\treturn nil, err",
"}",
"//entête",
"req.Header.Add(\"\", \"\")",
"//Paramètres de requête",
"params := req.URL.Query()",
"params.Add(\"\",\"\")",
"req.URL.RawQuery = params.Encode()"
],
"description": "HTTP GET request"
}
↓httpget
python
url := ""
req, err := http.NewRequest("GET", url, nil)
if err != nil{
return nil, err
}
//entête
req.Header.Add("", "")
//Paramètres de requête
params := req.URL.Query()
params.Add("","")
req.URL.RawQuery = params.Encode()
Personnellement, les extraits de code sont des expressions fixes, mais beaucoup d'entre eux sont faits pour des choses qui ont tendance à oublier les méthodes de réglage détaillées. Je pense que je vais l'utiliser souvent à l'avenir! J'aimerais ajouter plus d'informations au besoin!