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