package main
import (
"bytes"
"fmt"
"log"
"github.com/PuerkitoBio/goquery"
)
func main() {
rawHtml := bytes.NewBuffer([]byte(`
<div name="lesson" class="lesson" title="
<p class=tooltip_name><b>1-1</b></p>
<p class=tooltip_professor>Преп2</p>
<hr />
<p class=tooltip_aud>Практическое занятие</p>
" style="background-color: #D5F6FF;">
<p>Физ культура</p>
<p class="lesson_aud">ЗАЛ1</p>
</div>
`))
doc, err := goquery.NewDocumentFromReader(rawHtml)
if err != nil {
log.Fatal(err)
}
title, ok := doc.Find(".lesson").Attr("title") // получаем значение title
if !ok {
log.Fatal("Cannot find the node with the class 'lesson'")
}
// Парсим то, что лежит в title
docFromTitle, err := goquery.NewDocumentFromReader(bytes.NewBuffer([]byte(title)))
if err != nil {
log.Fatal(err)
}
// Получаем элемент с именем преподавателя
teacher := docFromTitle.Find(".tooltip_professor").Text()
fmt.Println(teacher)
}
package main
import (
"net/http"
"gopkg.in/gin-gonic/gin.v1"
)
func main() {
r := gin.Default()
r.GET("/ping", PingHandler)
r.GET("/user/:name", UserGetHandler)
r.POST("/user/:name", UserPostHandler)
r.Run()
}
func PingHandler(c *gin.Context) {
c.JSON(200, gin.H{
"message": "pong",
})
}
func UserGetHandler(c *gin.Context) {
name := c.Param("name")
c.String(http.StatusOK, "Hello %s\n", name)
}
func UserPostHandler(c *gin.Context) {
name := c.Param("name")
// Do some actions
c.String(http.StatusOK, "User %s was edited\n", name)
}
$ curl 127.0.0.1:8080/ping
{"message":"pong"}
$ curl 127.0.0.1:8080/user/john
Hello john
$ curl -XPOST 127.0.0.1:8080/user/john
User john was edited
package main
import (
"bytes"
"fmt"
"html/template"
"log"
)
type Data struct {
Name string
}
func main() {
var tmpl *template.Template
funcMap := template.FuncMap{
"executeIfExists": func(name string, data interface{}) template.HTML {
t := tmpl.Lookup(name)
if t == nil {
return ""
} else {
buf := bytes.NewBuffer([]byte{})
err := t.Execute(buf, data)
if err != nil {
log.Printf("Error executing template '%s': %v", name, err)
return ""
} else {
return template.HTML(buf.Bytes())
}
}
},
}
tmpl = template.Must(template.New("main").Funcs(funcMap).
Parse(`Content: {{ executeIfExists "content" . }} {{ executeIfExists "someAbsentTemplate" . }}`))
tmpl = template.Must(tmpl.New("content").Parse(`Hello, <b>{{ .Name }}</b>!`))
data := Data{
Name: "John",
}
buf := bytes.NewBuffer([]byte{})
err := tmpl.ExecuteTemplate(buf, "main", data)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(buf.Bytes()))
}
package main
import (
"bytes"
"fmt"
"html/template"
"log"
)
func main() {
out := bytes.NewBuffer([]byte{})
t, err := template.New("foo").Parse(`<!DOCTYPE html>
<html>
<head>
<title></title>
<script type="text/javascript">
var data = JSON.parse( {{.}} );
</script>
</head>
<body>
</body>
</html>`)
if err != nil {
log.Fatal("Cannot parse the template: ", err)
}
err = t.Execute(out, `[{"ID":"1"}]`)
if err != nil {
log.Fatal("Cannot execute the template: ", err)
}
fmt.Println(string(out.Bytes()))
}
package main
import (
"bytes"
"fmt"
"html/template"
"log"
)
type A []struct {
ID string
}
func main() {
out := bytes.NewBuffer([]byte{})
t, err := template.New("foo").Parse(`<!DOCTYPE html>
<html>
<head>
<title></title>
<script type="text/javascript">
var data = {{.}};
</script>
</head>
<body>
</body>
</html>`)
if err != nil {
log.Fatal("Cannot parse the template: ", err)
}
data := A{
{ID: "1"},
}
err = t.Execute(out, data)
if err != nil {
log.Fatal("Cannot execute the template: ", err)
}
fmt.Println(string(out.Bytes()))
}
func ServeWs(hub *Hub, w http.ResponseWriter, r *http.Request) {
conn, err := wsupgrader.Upgrade(w, r, nil)
if err != nil {
log.Println(err)
return
}
client := &Client{hub: hub, conn: conn, send: make(chan []byte, 256)}
client.hub.register <- client
for {
var msg MsgType
err := conn.ReadJSON(&msg)
if err != nil {
client.hub.unregister <- client
return
}
}
}
package main
import (
"bufio"
"fmt"
"log"
"os/exec"
)
func main() {
cmd := exec.Command("cmd", "/C", "C:/gopath/src/script/for.exe")
// Получаем reader для STDOUT запущенной программы
// Это нужно делать до её запуска
stdoutPipe, err := cmd.StdoutPipe()
if err != nil {
log.Fatal("Cannot get stdout pipe: ", err)
}
// Запускаем команду
err = cmd.Start()
if err != nil {
log.Fatal("Cannot start the command: ", err)
}
// Создаём более удобный интерфейс чтения
r := bufio.NewReader(stdoutPipe)
// Читаем из stdout одну строку (пока не встретим перевод строки \n)
str, err := r.ReadString('\n')
if err != nil {
log.Fatal("Cannot read from STDOUT: ", err)
}
fmt.Println(str)
}
package main
import (
"fmt"
"strconv"
)
func main() {
var t map[string]interface{} // Создаем переменную, сейчас она nil и мы не можем в неё класть ключи
t = make(map[string]interface{}) // Создаем map в памяти, теперь можем класть ключи
t["key"] = "1" // Кладём ключ
var num int
rawValue, ok := t["key"] // Вытаскиваем ключ из map
if ok {
stringValue, ok := rawValue.(string) // Вытаскиваем string из interface{}
if ok {
var err error
num, err = strconv.Atoi(stringValue) // Парсим string в int
if err == nil {
fmt.Println(num)
} else {
fmt.Println("Число имеет неверный формат")
}
} else {
fmt.Println("Внутри interface{} лежит не тип string")
}
} else {
fmt.Println("Такого ключа нет в map")
}
}
NewFoo(sliceBar...)