Résumé de l'extrait de code lors du développement avec Go

introduction

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é!

Enregistrement d'extraits avec vscode

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

Syntaxe d'enregistrement des extraits

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"
},

A propos de la spécification de la position du curseur

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

À propos des autres caractères spéciaux

Fragment

• Impression de débogage --Fonction de structure
• package
• Test piloté par table
• gomock --Contexte de Gin pour les tests --http demande

Impression de débogage

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", )

Fonction de structure

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

Test piloté par table

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()

Tester le contexte du gin

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

demande http

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()

À la fin

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!