Golang bytes.Map函数代码示例

func (h *hub) run(st *store) {
	h.db = db
	for {
		select {
		case c := <-h.register:
			Log("Registering...\n")
			h.connections[c] = true
			c.stcmd = st.cmd
		case c := <-h.unregister:
			if _, ok := h.connections[c]; ok {
				Log("UnRegistering...\n")
				delete(h.connections, c)
				close(c.cmd)
			}
		case m := <-h.broadcast:
			Log("Broadcasting...\n")
			m = bytes.Map(func(r rune) rune {
				if r < ' ' {
					return -1
				}
				return r
			}, m)
			for c := range h.connections {
				c.cmd <- m
			}
		}
	}
}

func BenchmarkReadString(b *testing.B) {
	b.StopTimer()
	c := new(Context)

	rand.Seed(time.Now().UnixNano())
	max := 64
	length := 64
	strings := make([]*bytes.Buffer, max)

	for i := 0; i < max; i++ {
		w := new(bytes.Buffer)
		s := bytes.Repeat([]byte{'a'}, length)
		b := bytes.Map(randRune, s)
		w.Write([]byte{ettString})
		binary.Write(w, binary.BigEndian, uint16(len(b)))
		w.Write(b)
		strings[i] = w
	}

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		in := strings[i%max]
		_, err := c.Read(in)

		if err != io.EOF && err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkReadPid(b *testing.B) {
	b.StopTimer()
	c := new(Context)

	rand.Seed(time.Now().UnixNano())
	max := 64
	length := 16
	pids := make([]*bytes.Buffer, max)

	for i := 0; i < max; i++ {
		w := new(bytes.Buffer)
		s := bytes.Repeat([]byte{'a'}, length)
		b := bytes.Map(randRune, s)
		b[6] = '@'
		w.Write([]byte{ettPid, ettSmallAtom, byte(length)})
		w.Write(b)
		w.Write([]byte{0, 0, 0, uint8(rand.Int())})
		w.Write([]byte{0, 0, 0, uint8(rand.Int())})
		w.Write([]byte{uint8(rand.Int())})
		pids[i] = w
	}

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		in := pids[i%max]
		_, err := c.Read(in)

		if err != io.EOF && err != nil {
			b.Fatal(err)
		}
	}
}

func BenchmarkWriteBinary(b *testing.B) {
	b.StopTimer()
	c := new(Context)

	rand.Seed(time.Now().UnixNano())
	max := 64
	length := 64
	binaries := make([][]byte, max)

	for i := 0; i < max; i++ {
		s := bytes.Repeat([]byte{'a'}, length)
		binaries[i] = bytes.Map(
			func(rune) rune { return rune(byte(rand.Int())) },
			s,
		)
	}

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		in := binaries[i%max]
		if err := c.writeBinary(Discard, in); err != nil {
			b.Fatal(in, err)
		}
	}
}

func APIRequest(api string, values url.Values) ([]byte, error) {
	query := values.Encode()
	if query != "" {
		query = "?" + query
	}
	url := api + query

	response, err := http.Get(url)
	if err != nil {
		return []byte{}, err
	}

	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		return []byte{}, err
	}

	res := bytes.Map(func(r rune) rune {
		switch r {
		case '\r', '\n':
			return -1
		default:
			return r
		}
	}, body)

	return res, nil
}

func BenchmarkWritePid(b *testing.B) {
	b.StopTimer()
	c := new(Context)

	rand.Seed(time.Now().UnixNano())
	max := 64
	length := 16
	pids := make([]Pid, max)

	for i := 0; i < max; i++ {
		s := bytes.Repeat([]byte{'a'}, length)
		b := bytes.Map(randRune, s)
		b[6] = '@'
		pids[i] = Pid{
			Atom(b),
			uint32(rand.Intn(65536)),
			uint32(rand.Intn(256)),
			byte(rand.Intn(16)),
		}
	}

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		in := pids[i%max]
		if err := c.writePid(Discard, in); err != nil {
			b.Fatal(in, err)
		}
	}
}

func BenchmarkReadBinary(b *testing.B) {
	b.StopTimer()
	c := new(Context)

	rand.Seed(time.Now().UnixNano())
	max := 64
	length := 64
	binaries := make([]*bytes.Buffer, max)

	for i := 0; i < max; i++ {
		w := new(bytes.Buffer)
		s := bytes.Repeat([]byte{'a'}, length)
		b := bytes.Map(func(rune) rune { return rune(byte(rand.Int())) }, s)
		w.Write([]byte{ettBinary})
		binary.Write(w, binary.BigEndian, uint32(len(b)))
		w.Write(b)
		binaries[i] = w
	}

	b.StartTimer()

	for i := 0; i < b.N; i++ {
		in := binaries[i%max]
		_, err := c.Read(in)

		if err != io.EOF && err != nil {
			b.Fatal(err)
		}
	}
}

// Parse input parses a slice of bytes representing the sudoku challenge and
// returns a slice of ints.
func parseInput(in []byte) ([]int, error) {
	// Use bytes.Map to eliminate all characters that are not ints or underscores.
	// Replace underscores by 0.
	res := bytes.Map(func(r rune) rune {
		if string(r) == "_" {
			return '0'
		} else if _, err := strconv.Atoi(string(r)); err != nil {
			return -1
		} else {
			return r
		}
	}, in)

	// The result should be 81 characters long. If not, the input was not valid.
	if len(res) != 81 {
		return nil, errors.New("Input was not in a valid format!")
	}

	// Convert the result in a slice of integers.
	ints := make([]int, 81)
	for i, r := range string(res) {
		// no need to check for errs, we made sure everything is an int during the
		// mapping earlier
		ints[i], _ = strconv.Atoi(string(r))
	}
	return ints, nil
}

func consumeLine(data []byte, atEOF bool) (advance int, token []byte, err error) {
	advance, token, err = bufio.ScanLines(data, atEOF)
	if advance == 0 && len(token) == 0 {
		return
	}
	tokenString := string(token)
	//Skip empty lines
	if advance == 2 {
		advance, token, err = consumeLine(data[advance:len(data)], atEOF)
		advance = advance + 2
	}
	//Drop lines with comments OR drop line ending with comments
	if strings.IndexAny(tokenString, "/") == 0 {
		storedAdvance := advance
		advance, token, err = consumeLine(data[storedAdvance:len(data)], atEOF)
		advance = advance + storedAdvance
	} else if commentIndex := strings.IndexAny(tokenString, "/"); commentIndex != -1 {
		token = token[0:commentIndex]
	}

	//Remove all spaces
	token = bytes.Map(func(r rune) (newR rune) {
		if unicode.IsSpace(r) {
			newR = -1
		} else {
			newR = r
		}
		return
	}, token)
	return
}

func main() {
	s1 := []byte("大家上午好")
	s2 := []byte("12345678")
	m1 := func(r rune) rune {
		if r == '上' {
			return '下'
		}
		return r
	}
	m2 := func(r rune) rune {
		return r + 1
	}
	fmt.Println(string(bytes.Map(m1, s1)))
	fmt.Println(string(s1))
	fmt.Println(string(bytes.Map(m2, s2)))
	fmt.Println(string(s2))
}

func removeNewlines(p []byte) []byte {
	return bytes.Map(func(r rune) rune {
		switch r {
		case '\n', '\r':
			return -1
		}
		return r
	}, p)
}

func chordMechanic(in []byte) (string, string, int) {
	var chord, khord string
	var mec int
	var isRelease, isButton bool
	if spl := bytes.Split(in, []byte("+")); spl[len(spl)-1][0] == RELEASE {
		isRelease = true
	}
	if bytes.Contains(in, []byte("button")) {
		isButton = true
	}
	cut := func(r rune) rune {
		if r == '@' {
			return -1
		}
		return r
	}
	switch {
	case !isRelease && !isButton:
		s := string(in)
		chord = s
		khord = s
		mec = KeyPress
	case isRelease && !isButton:
		chord = string(bytes.Map(cut, in))
		khord = string(in)
		mec = KeyRelease
	case !isRelease && isButton:
		s := string(in)
		chord = s
		khord = s
		mec = ButtonPress
	case isRelease && isButton:
		chord = string(bytes.Map(cut, in))
		khord = string(in)
		mec = ButtonRelease
	default:
		s := string(in)
		chord = s
		khord = s
		mec = KeyPress
	}
	return chord, khord, mec
}

func sortCompact(text []byte) (buf []byte, histo map[string]int, numTokens int) {

	// text = bytes.Replace(text, []byte(" hbr"), []byte{}, -1)
	// text = bytes.Replace(text, []byte(" sbr"), []byte{}, -1)
	text = bytes.Replace(text, []byte(`[img] `), []byte{}, -1)
	// text = bytes.Replace(text, []byte(`[a] `), []byte{}, -1)

	mapping := func(r rune) rune {
		if ret, ok := sortCompactReplace[r]; ok {
			return ret
		}
		return r
	}

	text = bytes.Map(mapping, text)

	words := bytes.Fields(text)

	histo = map[string]int{}
	for _, word := range words {
		sword := string(word)
		sword = strings.TrimSpace(sword)
		sword = strings.ToLower(sword)
		if len(words) > 3 {
			if len(sword) > 3 {
				histo[sword]++
			}
		} else {
			histo[sword]++ // no minimum length for tiny texts
		}
	}
	numTokens = len(histo)

	keys := make([]string, 0, len(histo))
	for k, _ := range histo {
		keys = append(keys, k)
	}

	sort.Strings(keys)

	buf = []byte{32}
	for _, key := range keys {
		if len(key) > 1 {
			buf = append(buf, []byte(key)...)
			buf = append(buf, byte(32))
			// num := fmt.Sprintf("%v", mp[key])
			// buf = append(buf, []byte(num)...)
			// buf = append(buf, byte(32))
		}
	}

	buf = bytes.TrimSpace(buf)

	return
}

func main() {
	flag.Parse()

	log.Printf("Fetching %q...", *remote)
	resp, err := http.Get(*remote)
	if err != nil {
		log.Fatalf("failed to download from %q: %s", *remote, err)
	}
	defer resp.Body.Close()

	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatalf("failed to read %q: %s", *remote, err)
	}

	ids, cls, err := usbid.ParseIDs(bytes.NewReader(data))
	if err != nil {
		log.Fatalf("failed to parse %q: %s", *remote, err)
	}

	log.Printf("Successfully fetched %q:", *remote)
	log.Printf("  Loaded %d Vendor IDs", len(ids))
	log.Printf("  Loaded %d Class IDs", len(cls))

	rawTemplate, err := ioutil.ReadFile(*dataFile)
	if err != nil {
		log.Fatalf("failed to read template %q: %s", *dataFile)
	}

	template, err := template.New("").Parse(string(rawTemplate))
	if err != nil {
		log.Fatalf("failed to parse template %q: %s", *dataFile, err)
	}

	out, err := os.Create(*outFile)
	if err != nil {
		log.Fatalf("failed to open output file %q: %s", *outFile, err)
	}
	defer out.Close()

	templateData := struct {
		Data      []byte
		Generated time.Time
		RFC3339   string
	}{
		Data:      bytes.Map(sanitize, data),
		Generated: time.Now(),
	}
	if err := template.Execute(out, templateData); err != nil {
		log.Fatalf("failed to execute template: %s", err)
	}

	log.Printf("Successfully wrote %q", *outFile)
}

func maptest() {
	s := []byte("各位上午好")
	m := func(r rune) rune {
		if r == '上' {
			r = '下'
		}
		return r
	}

	fmt.Println(string(s))
	fmt.Println(string(bytes.Map(m, s)))
}