go语言返回199之间随机数的方法_c语言如何产生随机数
刀豆文库小编猜你可能喜欢“c语言如何产生随机数”。
go语言返回199之间随机数的方法(（共9篇））由网友“MoZmaqORrIko”投稿提供，下面小编为大家整理后的go语言返回199之间随机数的方法，希望大家喜欢!
篇1：go语言返回199之间随机数的方法
作者：heishui 字体：[增加 减小] 类型：
这篇文章主要介绍了go语言返回1-99之间随机数的方法,实例分析了Go语言中rand的使用技巧,需要的朋友可以参考下
本文实例讲述了go语言返回1-99之间随机数的方法，分享给大家供大家参考。具体实现方法如下：
代码如下:
package main
import (
\“fmt\”
\“math/rand\”
)
func main {
max := big.NewInt(100)
i, err := rand.Int(rand.Reader, max)
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇2：Go语言生成随机数的方法
作者：不吃皮蛋 字体：[增加 减小] 类型：转载
golang生成随机数可以使用math/rand包
代码如下:
package main
import (
\“fmt\”
\“math/rand\”
)
func main() {
for i:=0; i<10; i++ {
fmt.Println(rand.Intn(100))
}
}
发现这种情况,每次执行的结果一样,不满意
代码如下:
package main
import (
\“fmt\”
\“time\”
\“math/rand\”
)
func main() {
r := rand.New(rand.NewSource(time.Now().UnixNano()))
for i:=0; i<10; i++ {
fmt.Println(r.Intn(100))
}
}
这种方式就可以使用时间种子来获取不同的结果了
希望本文所述对大家的Go语言程序设计有所帮助，
篇3：Go语言计算两个经度和纬度之间距离的方法
作者：不吃皮蛋 字体：[增加 减小] 类型：
代码如下:
package main
import (
\“fmt\”
\“math\”
)
func main {
lat1 := 29.490295
lng1 := 106.486654
lat2 := 29.615467
lng2 := 106.581515
fmt.Println(EarthDistance(lat1, lng1, lat2, lng2))
}
func EarthDistance(lat1, lng1, lat2, lng2 float64) float64 {
radius := 6371000 // 6378137
rad := math.Pi/180.0
lat1 = lat1 * rad
lng1 = lng1 * rad
lat2 = lat2 * rad
lng2 = lng2 * rad
theta := lng2 - lng1
dist := math.Acos(math.Sin(lat1) * math.Sin(lat2) + math.Cos(lat1) * math.Cos(lat2) * math.Cos(theta))
return dist * radius
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇4：Go语言单链表实现方法
作者：OSC首席键客 字体：[增加 减小] 类型：转载
1. singlechain.go代码如下：
代码如下:
//////////
//单链表 -- 线性表
package singlechain
//定义节点
type Node struct {
Data int
Next *Node
}
/*
* 返回第一个节点
* h 头结点
*/
func GetFirst(h *Node) *Node {
if h.Next == nil {
return nil
}
return h.Next
}
/*
* 返回最后一个节点
* h 头结点
*/
func GetLast(h *Node) *Node {
if h.Next == nil {
return nil
}
i := h
for i.Next != nil {
i = i.Next
if i.Next == nil {
return i
}
}
return nil
}
//取长度
func GetLength(h *Node) int {
var i int = 0
n := h
for n.Next != nil {
i++
n = n.Next
}
return i
}
//插入一个节点
//h: 头结点
//d:要插入的节点
//p:要插入的位置
func Insert(h, d *Node, p int) bool {
if h.Next == nil {
h.Next = d
return true
}
i := 0
n := h
for n.Next != nil {
i++
if i == p {
if n.Next.Next == nil {
n.Next = d
return true
} else {
d.Next = n.Next
n.Next = d.Next
return true
}
}
n = n.Next
if n.Next == nil {
n.Next = d
return true
}
}
return false
}
//取出指定节点
func GetLoc(h *Node, p int) *Node {
if p < 0 || p > GetLength(h) {
return nil
}
var i int = 0
n := h
for n.Next != nil {
i++
n = n.Next
if i == p {
return n
}
}
return nil
}
2. main.go代码如下：
代码如下:
package main
import \“fmt\”
import \“list/singlechain\”
func main() {
//初始化一个头结点
var h singlechain.Node
//往链表插入10个元素
for i := 1; i <= 10; i++ {
var d singlechain.Node
d.Data = i
singlechain.Insert(&h, &d, i)
fmt.Println(singlechain.GetLoc(&h, i))
}
fmt.Println(singlechain.GetLength(&h))
fmt.Println(singlechain.GetFirst(&h))
fmt.Println(singlechain.GetLast(&h))
fmt.Println(singlechain.GetLoc(&h, 6))
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇5：Go语言实现简单留言板的方法
作者：不吃皮蛋 字体：[增加 减小] 类型：
代码如下:
package main
import (
// \“fmt\”
\“io\”
\“log\”
\“net/http\”
\“text/template\”
\“time\”
\“database/sql\”
\“github.com/ziutek/mymysql/godrv\”
)
// 留言结构
type Liuyan struct {
Id int
Name string
Content string
Time int
}
// 显示留言时间
func (l Liuyan) ShowTime string {
t := time.Unix(int64(l.Time), 0)
return t.Format(\“-01-02 15:04:05\”)
}
func main() {
godrv.Register(\“SET NAMES utf8\”)
// 连接数据库
db, err := sql.Open(\“mymysql\”, \“tcp:127.0.0.1:3306*go/root/123456\”)
if err != nil {
panic(err)
}
defer db.Close()
// 准备模板
tpl, err := template.New(\“liuyanbook\”).Parse(html)
if err != nil {
panic(err)
}
// 显示留言页面 /
requestList := func(w http.ResponseWriter, req *http.Request) {
// 查询数据
rows, err := db.Query(\“select * from liuyan\”)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
// 获取数据
lys := []Liuyan{}
for rows.Next() {
ly := Liuyan{}
err := rows.Scan(&ly.Id, &ly.Name, &ly.Content, &ly.Time)
if nil != err {
log.Fatal(err)
}
lys = append(lys, ly)
}
// 显示数据
err = tpl.ExecuteTemplate(w, \“list\”, lys)
if err != nil {
log.Fatal(err)
}
}
// 留言页面 /liuyan
requestLiuyan := func(w http.ResponseWriter, req *http.Request) {
err := req.ParseForm()
if err != nil{
log.Fatal(err)
}
if \“POST\” == req.Method {
if len(req.Form[\“name\”]) < 1 {
io.WriteString(w, \“参数错误!\\n\”)
return
}
if len(req.Form[\“content\”]) < 1 {
io.WriteString(w, \“参数错误!\\n\”)
return
}
name := template.HTMLEscapeString(req.Form.Get(\“name\”))
content := template.HTMLEscapeString(req.Form.Get(\“content\”))
// sql语句
sql, err := db.Prepare(\“insert into liuyan(name, content, time) values(?, ?, ?)\”)
if err != nil {
log.Fatal(err)
}
defer sql.Close()
// sql参数,并执行
_, err = sql.Exec(name, content, time.Now().Unix())
if err != nil {
log.Fatal(err)
}
// 跳转
w.Header().Add(\“Location\”, \“/\”)
w.WriteHeader(302)
// 提示信息
io.WriteString(w, \“提交成功!\\n\”)
return
}
err = tpl.ExecuteTemplate(w, \“liuyan\”, nil)
if err != nil {
log.Fatal(err)
}
}
http.HandleFunc(\“/\”, requestList)
http.HandleFunc(\“/liuyan\”, requestLiuyan)
err = http.ListenAndServe(\“:12345\”, nil)
if err != nil {
log.Fatal(\“ListenAndServe: \”, err)
}
}
// 网页模板
var html string = `{{define \“list\”}}{{/* 留言列表页面 */}}
给我留言
{{range .}}
{{.Id}}{{.Name}}{{.Content}}{{.ShowTime}}
{{end}}
{{end}}
{{define \“liuyan\”}}{{/* 发布留言页面 */}}
姓名:
内容:
{{end}}
希望本文所述对大家的Go语言程序设计有所帮助，
篇6：Go语言生成素数的方法
作者：依山带水 字体：[增加 减小] 类型：转载
这篇文章主要介绍了Go语言生成素数的方法,实例分析了Go语言生成素数的技巧,需要的朋友可以参考下
本文实例讲述了Go语言生成素数的方法，分享给大家供大家参考。具体实现方法如下：
代码如下:
package main
// 生成2, 3, 4, ... 到 channel ‘ch‘中.
func Generate(ch chan<- int) {
for i := 2; ; i++ {
ch <- i // Send ‘i‘ to channel ‘ch‘.
}
}
// 从管道复制值 ‘in‘ 到 channel ‘out‘,
// 移除可整除的数 ‘prime‘.
func Filter(in <-chan int, out chan<- int, prime int) {
for {
i := <-in // 接收值 ‘in‘.
if i%prime != 0 {
out <- i // 传入 ‘i‘ 到 ‘out‘.
}
}
}
func main() {
ch := make(chan int) // Create a newchannel.
go Generate(ch) // Launch Generate goroutine.
for i := 0; i < 10; i++ {
prime := <-ch
print(prime, \“\\n\”)
ch1 := make(chan int)
go Filter(ch, ch1, prime)
ch = ch1
}
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇7：Go语言使用MySql的方法
作者：不吃皮蛋 字体：[增加 减小] 类型：
此代码需要先安装mysql的go语言驱动。
首先安装mysql的go语言驱动：
代码如下:
go get github.com/ziutek/mymysql/godrv
示例代码如下：
代码如下:
package users
import (
\“database/sql\”
\“fmt\”
_ \“github.com/ziutek/mymysql/godrv\”
)
const (
DB_NAME = \“mysql_database_name\”
DB_USER = \“mysql_user\”
DB_PASS = \“mysql_password\”
)
type User struct {
Id int `json:\“id\”`
Name string `json:\“name\”`
Alias string `json:\“alias\”`
}
func OpenDB *sql.DB {
db, err := sql.Open(\“mymysql\”, fmt.Sprintf(\“%s/%s/%s\”, DB_NAME, DB_USER, DB_PASS))
if err != nil {
panic(err)
}
return db
}
func UserById(id int) User {
db := OpenDB()
defer db.Close()
row := db.QueryRow(\“SELECT `id`, `name`,`alias` FROM `users` WHERE id=?\”, id)
user := new(User)
row.Scan(&user.Id, &user.Name, &user.Alias)
return user
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇8：Go语言常用字符串处理方法实例
作者：work24 字体：[增加 减小] 类型：转载
代码如下:
package main
import (
\“fmt\”
\“strings\”
//\“unicode/utf8\”
)
func main() {
fmt.Println(\“查找子串是否在指定的字符串中\”)
fmt.Println(\“ Contains 函数的用法\”)
fmt.Println(strings.Contains(\“seafood\”, \“foo\”)) //true
fmt.Println(strings.Contains(\“seafood\”, \“bar\”)) //false
fmt.Println(strings.Contains(\“seafood\”, \“\”)) //true
fmt.Println(strings.Contains(\“\”, \“\”)) //true 这里要特别注意
fmt.Println(strings.Contains(\“我是中国人\”, \“我\”)) //true
fmt.Println(\“\”)
fmt.Println(\“ ContainsAny 函数的用法\”)
fmt.Println(strings.ContainsAny(\“team\”, \“i\”)) // false
fmt.Println(strings.ContainsAny(\“failure\”, \“u & i\”)) // true
fmt.Println(strings.ContainsAny(\“foo\”, \“\”)) // false
fmt.Println(strings.ContainsAny(\“\”, \“\”)) // false
fmt.Println(\“\”)
fmt.Println(\“ ContainsRune 函数的用法\”)
fmt.Println(strings.ContainsRune(\“我是中国\”, ‘我‘)) // true 注意第二个参数，用的是字符
fmt.Println(\“\”)
fmt.Println(\“ Count 函数的用法\”)
fmt.Println(strings.Count(\“cheese\”, \“e\”)) // 3
fmt.Println(strings.Count(\“five\”, \“\”)) // before & after each rune result: 5 , 源码中有实现
fmt.Println(\“\”)
fmt.Println(\“ EqualFold 函数的用法\”)
fmt.Println(strings.EqualFold(\“Go\”, \“go\”)) //大小写忽略
fmt.Println(\“\”)
fmt.Println(\“ Fields 函数的用法\”)
fmt.Println(\“Fields are: %q\”, strings.Fields(\“ foo bar baz \”)) //[\“foo\” \“bar\” \“baz\”] 返回一个列表
//相当于用函数做为参数，支持匿名函数
for _, record := range []string{\“ aaa*1892*122\”, \“aaa\\taa\\t\”, \“124|939|22\”} {
fmt.Println(strings.FieldsFunc(record, func(ch rune) bool {
switch {
case ch > ‘5‘:
return true
}
return false
}))
}
fmt.Println(\“\”)
fmt.Println(\“ HasPrefix 函数的用法\”)
fmt.Println(strings.HasPrefix(\“NLT_abc\”, \“NLT\”)) //前缀是以NLT开头的
fmt.Println(\“\”)
fmt.Println(\“ HasSuffix 函数的用法\”)
fmt.Println(strings.HasSuffix(\“NLT_abc\”, \“abc\”)) //后缀是以NLT开头的
fmt.Println(\“\”)
fmt.Println(\“ Index 函数的用法\”)
fmt.Println(strings.Index(\“NLT_abc\”, \“abc\”)) // 返回第一个匹配字符的位置，这里是4
fmt.Println(strings.Index(\“NLT_abc\”, \“aaa\”)) // 在存在返回 -1
fmt.Println(strings.Index(\“我是中国人\”, \“中\”)) // 在存在返回 6
fmt.Println(\“\”)
fmt.Println(\“ IndexAny 函数的用法\”)
fmt.Println(strings.IndexAny(\“我是中国人\”, \“中\”)) // 在存在返回 6
fmt.Println(strings.IndexAny(\“我是中国人\”, \“和\”)) // 在存在返回 -1
fmt.Println(\“\”)
fmt.Println(\“ Index 函数的用法\”)
fmt.Println(strings.IndexRune(\“NLT_abc\”, ‘b‘)) // 返回第一个匹配字符的位置，这里是4
fmt.Println(strings.IndexRune(\“NLT_abc\”, ‘s‘)) // 在存在返回 -1
fmt.Println(strings.IndexRune(\“我是中国人\”, ‘中‘)) // 在存在返回 6
fmt.Println(\“\”)
fmt.Println(\“ Join 函数的用法\”)
s := []string{\“foo\”, \“bar\”, \“baz\”}
fmt.Println(strings.Join(s, \“, \”)) // 返回字符串：foo, bar, baz
fmt.Println(\“\”)
fmt.Println(\“ LastIndex 函数的用法\”)
fmt.Println(strings.LastIndex(\“go gopher\”, \“go\”)) // 3
fmt.Println(\“\”)
fmt.Println(\“ LastIndexAny 函数的用法\”)
fmt.Println(strings.LastIndexAny(\“go gopher\”, \“go\”)) // 4
fmt.Println(strings.LastIndexAny(\“我是中国人\”, \“中\”)) // 6
fmt.Println(\“\”)
fmt.Println(\“ Map 函数的用法\”)
rot13 := func(r rune) rune {
switch {
case r >= ‘A‘ && r <= ‘Z‘:
return ‘A‘ + (r-‘A‘+13)%26
case r >= ‘a‘ && r <= ‘z‘:
return ‘a‘ + (r-‘a‘+13)%26
}
return r
}
fmt.Println(strings.Map(rot13, \“‘Twas brillig and the slithy gopher...\”))
fmt.Println(\“\”)
fmt.Println(\“ Repeat 函数的用法\”)
fmt.Println(\“ba\” + strings.Repeat(\“na\”, 2)) //banana
fmt.Println(\“\”)
fmt.Println(\“ Replace 函数的用法\”)
fmt.Println(strings.Replace(\“oink oink oink\”, \“k\”, \“ky\”, 2))
fmt.Println(strings.Replace(\“oink oink oink\”, \“oink\”, \“moo\”, -1))
fmt.Println(\“\”)
fmt.Println(\“ Split 函数的用法\”)
fmt.Printf(\“%q\\n\”, strings.Split(\“a,b,c\”, \“,\”))
fmt.Printf(\“%q\\n\”, strings.Split(\“a man a plan a canal panama\”, \“a \”))
fmt.Printf(\“%q\\n\”, strings.Split(\“ xyz \”, \“\”))
fmt.Printf(\“%q\\n\”, strings.Split(\“\”, \“Bernardo O‘Higgins\”))
fmt.Println(\“\”)
fmt.Println(\“ SplitAfter 函数的用法\”)
fmt.Printf(\“%q\\n\”, strings.SplitAfter(\“/home/m_ta/src\”, \“/\”)) //[\“/\” \“home/\” \“m_ta/\” \“src\”]
fmt.Println(\“\”)
fmt.Println(\“ SplitAfterN 函数的用法\”)
fmt.Printf(\“%q\\n\”, strings.SplitAfterN(\“/home/m_ta/src\”, \“/\”, 2)) //[\“/\” \“home/m_ta/src\”]
fmt.Printf(\“%q\\n\”, strings.SplitAfterN(\“#home#m_ta#src\”, \“#\”, -1)) //[\“/\” \“home/\” \“m_ta/\” \“src\”]
fmt.Println(\“\”)
fmt.Println(\“ SplitN 函数的用法\”)
fmt.Printf(\“%q\\n\”, strings.SplitN(\“/home/m_ta/src\”, \“/\”, 1))
fmt.Printf(\“%q\\n\”, strings.SplitN(\“/home/m_ta/src\”, \“/\”, 2)) //[\“/\” \“home/\” \“m_ta/\” \“src\”]
fmt.Printf(\“%q\\n\”, strings.SplitN(\“/home/m_ta/src\”, \“/\”, -1)) //[\“\” \“home\” \“m_ta\” \“src\”]
fmt.Printf(\“%q\\n\”, strings.SplitN(\“home,m_ta,src\”, \“,\”, 2)) //[\“/\” \“home/\” \“m_ta/\” \“src\”]
fmt.Printf(\“%q\\n\”, strings.SplitN(\“#home#m_ta#src\”, \“#\”, -1)) //[\“/\” \“home/\” \“m_ta/\” \“src\”]
fmt.Println(\“\”)
fmt.Println(\“ Title 函数的用法\”) //这个函数，还真不知道有什么用
fmt.Println(strings.Title(\“her royal highness\”))
fmt.Println(\“\”)
fmt.Println(\“ ToLower 函数的用法\”)
fmt.Println(strings.ToLower(\“Gopher\”)) //gopher
fmt.Println(\“\”)
fmt.Println(\“ ToLowerSpecial 函数的用法\”)
fmt.Println(\“\”)
fmt.Println(\“ ToTitle 函数的用法\”)
fmt.Println(strings.ToTitle(\“loud noises\”))
fmt.Println(strings.ToTitle(\“loud 中国\”))
fmt.Println(\“\”)
fmt.Println(\“ Replace 函数的用法\”)
fmt.Println(strings.Replace(\“ABAACEDF\”, \“A\”, \“a\”, 2)) // aBaACEDF
//第四个参数小于0，表示所有的都替换， 可以看下golang的文档
fmt.Println(strings.Replace(\“ABAACEDF\”, \“A\”, \“a\”, -1)) // aBaaCEDF
fmt.Println(\“\”)
fmt.Println(\“ ToUpper 函数的用法\”)
fmt.Println(strings.ToUpper(\“Gopher\”)) //GOPHER
fmt.Println(\“\”)
fmt.Println(\“ Trim 函数的用法\”)
fmt.Printf(\“[%q]\”, strings.Trim(\“ !!! Achtung !!! \”, \“! \”)) // [\“Achtung\”]
fmt.Println(\“\”)
fmt.Println(\“ TrimLeft 函数的用法\”)
fmt.Printf(\“[%q]\”, strings.TrimLeft(\“ !!! Achtung !!! \”, \“! \”)) // [\“Achtung !!! \”]
fmt.Println(\“\”)
fmt.Println(\“ TrimSpace 函数的用法\”)
fmt.Println(strings.TrimSpace(\“ \\t\\n a lone gopher \\n\\t\\r\\n\”)) // a lone gopher
}
希望本文所述对大家的Go语言程序设计有所帮助，
篇9：Go语言中使用反射的方法
作者：不吃皮蛋 字体：[增加 减小] 类型：转载
代码如下:
// Data Model
type Dish struct {
Id int
Name string
Origin string
Query func()
}
创建实例如下：
代码如下:
shabushabu = Dish.new
shabushabu.instance_variables # => []
shabushabu.name = \“Shabu-Shabu\”
shabushabu.instance_variables # => [\“@name\”]
shabushabu.origin = \“Japan\”
shabushabu.instance_variables # => [\“@name\”, \“@origin\”]
完整代码如下：
代码如下:
package main
import(
\“fmt\”
\“reflect\”
)
func main(){
// iterate through the attributes of a Data Model instance
for name, mtype := range attributes(&Dish{}) {
fmt.Printf(\“Name: %s, Type %s\\n\”, name, mtype.Name())
}
}
// Data Model
type Dish struct {
Id int
Name string
Origin string
Query func()
}
// Example of how to use Go‘s reflection
// Print the attributes of a Data Model
func attributes(m interface{}) (map[string]reflect.Type) {
typ := reflect.TypeOf(m)
// if a pointer to a struct is passed, get the type of the dereferenced object
if typ.Kind() == reflect.Ptr{
typ = typ.Elem()
}
// create an attribute data structure as a map of types keyed by a string.
attrs := make(map[string]reflect.Type)
// Only structs are supported so return an empty result if the passed object
// isn‘t a struct
if typ.Kind() != reflect.Struct {
fmt.Printf(\“%v type can‘t have attributes inspected\\n\”, typ.Kind())
return attrs
}
// loop through the struct‘s fields and set the map
for i := 0; i < typ.NumField(); i++ {
p := typ.Field(i)
if !p.Anonymous {
attrs[p.Name] = p.Type
}
}
return attrs
}
希望本文所述对大家的Go语言程序设计有所帮助，
