Maintenant que je connais le système de paquets, je vais vous présenter Hello World

La prochaine étape de Hello World! Hello Servant!

La première étape pour faire progresser l'apprentissage de la programmation 「Hello World」 C'est la même chose qu'avant, non?

Mais la programmation moderne est Paquet ... Paquet Forfait de toute façon Qui contrôle le système d'emballage Il n'est pas exagéré de dire qu'il contrôle la programmation moderne.

Donc cette fois, la version de programmation moderne "Hello World" Je voudrais proposer une méthode d'apprentissage appelée "Hello Servant".

Langue Go Trendy

Tout d'abord, Hello World normalement

main.go

package main

import (
	"fmt"
)

func main()  {
	fmt.Println("Hello World")
}

go run main.go
-> Hello World

Puis "Hello World" pour le système de paquets Essayons "Hello Servant". Créez un répertoire appelé "serviteur" à la racine du projet Eh bien, cela signifie «serviteur» pour dire «Hello World» Dans le sens d'une personne qui salue Faisons un paquet appelé "Greeter".

mkdir -p servant/Greeter
touch servant/Greeter/Greeter.go

servant/Greeter/Greeter.go

package Greeter

import (
	"fmt"
)

type Greeter struct {}


func Summon() *Greeter {
	return &Greeter{}
}

func (g *Greeter) ServeHello() {
	fmt.Println("Hello Servant!")
}

Réécrivez main.go comme suit.

main.go

package main

import (
	"<Nom du module donné au moment du go mod>/servant/Greeter"
)

func main()  {
	//Invoquez Greeter! !!
	greeter := Greeter.Summon()
	//exécution du service! !!
	greeter.ServeHello()
}

go run main.go
-> Hello Servant!

En langage Go, la version du système de package "Hello World" a été créée comme ceci.

Python à la mode

La structure du répertoire ressemble à ceci

.
├── main.py
└── servant
    ├── Greeter.py
    └── __init__.py

servant/Greeter.py

class Summon:
    def __init__(self):
        self.message = "Hello Servant!"

    def serve_hello(self):
        print(self.message)

main.py

from servant import Greeter

#Invoquez Greeter! !!
greeter = Greeter.Summon()
#exécution du service! !!
greeter.serve_hello()

python main.py
-> Hello Servant!

Essayez-le avec TypeScript

Eh bien, parce que c'est TypeScript, cela ressemble à ceci, y compris le répertoire dist.

.
├── dist
│   ├── main.js
│   └── main.js.map
└── src
    ├── main.ts
    └── servant
        └── Greeter.ts

src/servant/Greeter.ts

export module Greeter {
    export class Summon {
        constructor() {}
        serveHello(): void {
            console.log('hello Servant!')
        }
    }
}

src/main.ts

import { Greeter } from './servant/Greeter'

const greeter = new Greeter.Summon()

greeter.serveHello()

parcel build src/main.ts
node dist/main.js

-> Hello Servant!

Résumé

Tout un apprentissage de la programmation Après avoir fait "Hello World" En essayant de développer une application Il y a beaucoup de gens qui ont du mal à apprendre parce qu'il y a un écart. N'est-ce pas?

Ce "Hello Servant" Après cela, par exemple

main.go

greeter := Greeter.Summon("Yamada Taro")
greeter.ServeHello()
->Bonjour Taro Yamada!

J'ai essayé de faire ça Créez un serviteur appelé Scraper Par exemple, à partir d'un site qui répertorie les athlètes Tirez la liste des noms d'athlètes Essayez de créer un Greeter qui vous accueille dans la langue de ce pays en fonction de la nationalité de l'athlète

L'éventail de la pratique n'est-il pas beaucoup plus large que le Hello World ordinaire?

À propos, ce concept de design de «serviteur» C'est un concept de design très compatible avec les personnes qui ont joué aux cartes Yugioh ou aux jeux de cartes. Il dit simplement "Invoquer". Et il est également possible de récupérer des données sur le Web comme le scraping C'est sensuellement similaire à la carte Yugioh ou quelque chose comme "○○ sur le terrain". La programmation elle-même devient amusante comme si vous jouiez déjà à un jeu de cartes.