七叶笔记 » golang编程 » 「Golang」字符串转义和反转义

「Golang」字符串转义和反转义

分类: golang编程 | 浏览: 2654

前言：在做扫描的时候有一些探测是要发送一些字节和数据流才可以识别，这时候就需要针对一些字符串做一些解释，达到数据流这些字符。

需要的转的字符 

 #原值
\x41\x00\x00\x00\x3a\x30\x00\x00
#发送时候的数据
A:0

在go的代码里使用双引号 

 str := "\x41\x00\x00\x00\x3a\x30\x00\x00"
log.Print(str)

#结果正常
A:0

使用反引号 

 str := `\x41\x00\x00\x00\x3a\x30\x00\x00`
log.Print(str)

#结果
\x41\x00\x00\x00\x3a\x30\x00\x00

双引号，单引号，反引号 

 双引号，会自动解析 \t \n \r \x \uxxx \U 这些特殊的字符
单引号，只能放一个字符 'a' 'b'' '1'
反引号，不会解析任何特殊标记，可以适用于大量文本的情况下，建议使用；

但是反引号因为不转义，需求又想要这样的解析特殊字符，这时候怎么操作？

strconv.Unquote 函数跟踪 

 strconv.Unquote 反解析函数，当内容如：`"\t\n"` 那么就会自动进行解析双引号里的内容，达到和双引号直接引入的效果。那么具体怎么实现的呢？

方法源码 (加注释和解释)：
func Unquote(s string) (string, error) {
	n := len(s)
	if n < 2 {
		return "", ErrSyntax
	}
	quote := s[0]
  // 本步骤是判断第一个字符和最后一个字符是否相等，如果相等，向下走，也就是 "xxxxxxx" 
	if quote != s[n-1] {
		return "", ErrSyntax
	}
	s = s[1 : n-1]

  // 判断标记是不是 反引号开始
	if quote == '`' {
		if contains(s, '`') {
			return "", ErrSyntax
		}
		if contains(s, '\r') {
			// -1 because we know there is at least one \r to remove.
			buf := make([] byte , 0, len(s)-1)
			for i := 0; i < len(s); i++ {
				if s[i] != '\r' {
					buf = append(buf, s[i])
				}
			}
			return string(buf), nil
		}
		return s, nil
	}
  // 这个过程是为了确定，是不是以 双引号或者单引号 开始
	if quote != '"' && quote != '\'' {
		return "", ErrSyntax
	}
  // 如果双引号内容有回车，那么调用该方法直接就会失败
	if contains(s, '\n') {
		return "", ErrSyntax
	}

	// Is it trivial? Avoid allocation.
	if !contains(s, '\\') && !contains(s, quote) {
		switch quote {
		case '"':
			if utf8.ValidString(s) {
				return s, nil
			}
		case '\'':
			r, size := utf8.DecodeRuneInString(s)
			if size == len(s) && (r != utf8.RuneError || size != 1) {
				return s, nil
			}
		}
	}

  // 开始到解析的过程了
	var runeTmp [utf8.UTFMax]byte
	buf := make([]byte, 0, 3*len(s)/2) // Try to avoid more allocations.
	for len(s) > 0 {
    // 核心解析方法  会进入到 UnquoteChar 方法详细解析  c 就是本次解析返回的结果
		c, multibyte, ss, err := UnquoteChar(s, quote)
		if err != nil {
			return "", err
		}
		s = ss
		if c < utf8.RuneSelf || !multibyte {
			buf = append(buf, byte(c))
		} else {
			n := utf8.EncodeRune(runeTmp[:], c)
			buf = append(buf, runeTmp[:n]...)
		}
		if quote == '\'' && len(s) != 0 {
			// single-quoted must be single character
			return "", ErrSyntax
		}
	}
	return string(buf), nil
}

func UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error) {
	// easy cases
	if len(s) == 0 {
		err = ErrSyntax
		return
	}
  //取出字符串的第一位 判断是否相等，如果相等就直接返回了
	switch c := s[0]; {
	case c == quote && (quote == '\'' || quote == '"'):
		err = ErrSyntax
		return
	case c >= utf8.RuneSelf:
		r, size := utf8.DecodeRuneInString(s)
		return r, true, s[size:], nil
	case c != '\\':
		return rune(s[0]), false, s[1:], nil
	}

	// hard case: c is backslash
	if len(s) <= 1 {
		err = ErrSyntax
		return
	}
  // 取出字符串的第二位 也是就是 x  这一步是按索引值进行获取
	c := s[1]
  // s 从第三位开始截取，重新赋值
	s = s[2:]

	switch c {
	case 'a':
		value = '\a'
	case 'b':
		value = '\b'
	case 'f':
		value = '\f'
	case 'n':
		value = '\n'
	case 'r':
		value = '\r'
	case 't':
		value = '\t'
	case 'v':
		value = '\v'
	case 'x', 'u', 'U':
		n := 0
		switch c {
      // 如果x ,则默认就取两位，这也是固定写法  针对特定的进制转换取的固定长度
		case 'x':
			n = 2
      // u 就是四位
		case 'u':
			n = 4
      // 大写U 就是八位
		case 'U':
			n = 8
		}
		var v rune
		if len(s) < n {
			err = ErrSyntax
			return
		}
		for j := 0; j < n; j++ {
      // 开始做运算，判断是不是16进制的数据 如果是接着取第二位，如果不是，也是直接就返回err 
			x, ok := unhex(s[j])
			if !ok {
				err = ErrSyntax
				return
			}
      // 做位运算 + 异或 该值 就是本次 \x41 第一个解析的结果
			v = v<<4 | x
		}
    // 再次重新截取 将 \x41去除，这时候字符串就变成了 \x00.....
		s = s[n:]
		if c == 'x' {
			// single-byte string, possibly not UTF-8
      // 单字节字符 可能非utf8  到这其实就已经解析完了。
			value = v
			break
		}
		if v > utf8.MaxRune {
			err = ErrSyntax
			return
		}
		value = v
		multibyte = true
	case '0', '1', '2', '3', '4', '5', '6', '7':
		v := rune(c) - '0'
		if len(s) < 2 {
			err = ErrSyntax
			return
		}
		for j := 0; j < 2; j++ { // one digit already; two more
			x := rune(s[j]) - '0'
			if x < 0 || x > 7 {
				err = ErrSyntax
				return
			}
			v = (v << 3) | x
		}
		s = s[2:]
		if v > 255 {
			err = ErrSyntax
			return
		}
		value = v
	case '\\':
		value = '\\'
	case '\'', '"':
		if c != quote {
			err = ErrSyntax
			return
		}
		value = rune(c)
	default:
		err = ErrSyntax
		return
	}
	tail = s
	return
}

// 核心就是通过对 \x 来判断什么类型，然后再做各种进制的快速运算，获取到一个值

strconv.Quote 函数 

 该函数是向一个字符串，添加双引号和转义；如果内容 `\x41` 使用了该函数，就会变成 `"\\x41"`
这时候在需要解析的时候，其实也是不正确的， 因为 \\ 会变成 \ 依然会原形输出。
所以为了兼容可以转换，再做一个替换，将 \\ 替换成 \ 
再调用 Unquote函数即可

总结

go的字符串取决于你的内容是不是双引号或者反引号，如果是反引号不会进行解析，所以需要使用到辅助的解析字符串函数 strconv.Unquote ；但是这个函数必须在两层有双引号才可以去执行。所以又借助了 strconv.Quote 函数，怎么解决该函数带的问题，在上面解释了。所以如果大家有遇到这方面的问题可以这样去解决；期待大佬们有更好的结果。

相关文章