feat: improve IsMethod

header.go

@@ -503,47 +503,47 @@ func (h *RequestHeader) SetRequestURIBytes(requestURI []byte) {
 
 // IsGet returns true if request method is GET.
 func (h *RequestHeader) IsGet() bool {
-	return bytes.Equal(h.Method(), strGet)
+	return string(h.Method()) == MethodGet
 }
 
 // IsPost returns true if request method is POST.
 func (h *RequestHeader) IsPost() bool {
-	return bytes.Equal(h.Method(), strPost)
+	return string(h.Method()) == MethodPost
 }
 
 // IsPut returns true if request method is PUT.
 func (h *RequestHeader) IsPut() bool {
-	return bytes.Equal(h.Method(), strPut)
+	return string(h.Method()) == MethodPut
 }
 
 // IsHead returns true if request method is HEAD.
 func (h *RequestHeader) IsHead() bool {
-	return bytes.Equal(h.Method(), strHead)
+	return string(h.Method()) == MethodHead
 }
 
 // IsDelete returns true if request method is DELETE.
 func (h *RequestHeader) IsDelete() bool {
-	return bytes.Equal(h.Method(), strDelete)
+	return string(h.Method()) == MethodDelete
 }
 
 // IsConnect returns true if request method is CONNECT.
 func (h *RequestHeader) IsConnect() bool {
-	return bytes.Equal(h.Method(), strConnect)
+	return string(h.Method()) == MethodConnect
 }
 
 // IsOptions returns true if request method is OPTIONS.
 func (h *RequestHeader) IsOptions() bool {
-	return bytes.Equal(h.Method(), strOptions)
+	return string(h.Method()) == MethodOptions
 }
 
 // IsTrace returns true if request method is TRACE.
 func (h *RequestHeader) IsTrace() bool {
-	return bytes.Equal(h.Method(), strTrace)
+	return string(h.Method()) == MethodTrace
 }
 
 // IsPatch returns true if request method is PATCH.
 func (h *RequestHeader) IsPatch() bool {
-	return bytes.Equal(h.Method(), strPatch)
+	return string(h.Method()) == MethodPatch
 }
 
 // IsHTTP11 returns true if the request is HTTP/1.1.

header_timing_test.go

@@ -178,3 +178,73 @@ func BenchmarkRemoveNewLines(b *testing.B) {
 		})
 	}
 }
+
+func BenchmarkRequestHeaderIsPost(b *testing.B) {
+	req := &RequestHeader{method: strPost}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsPost()
+		}
+	})
+}
+func BenchmarkRequestHeaderIsHead(b *testing.B) {
+	req := &RequestHeader{method: strHead}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsHead()
+		}
+	})
+}
+func BenchmarkRequestHeaderIsPut(b *testing.B) {
+	req := &RequestHeader{method: strPut}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsPut()
+		}
+	})
+}
+
+func BenchmarkRequestHeaderIsDelete(b *testing.B) {
+	req := &RequestHeader{method: strDelete}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsDelete()
+		}
+	})
+}
+
+func BenchmarkRequestHeaderIsConnect(b *testing.B) {
+	req := &RequestHeader{method: strConnect}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsConnect()
+		}
+	})
+}
+
+func BenchmarkRequestHeaderIsOptions(b *testing.B) {
+	req := &RequestHeader{method: strOptions}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsOptions()
+		}
+	})
+}
+
+func BenchmarkRequestHeaderIsTrace(b *testing.B) {
+	req := &RequestHeader{method: strTrace}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsTrace()
+		}
+	})
+}
+
+func BenchmarkRequestHeaderIsPatch(b *testing.B) {
+	req := &RequestHeader{method: strPatch}
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			req.IsPatch()
+		}
+	})
+}

strings.go

@@ -24,15 +24,15 @@ var (
 
 	strResponseContinue = []byte("HTTP/1.1 100 Continue\r\n\r\n")
 
-	strGet     = []byte(MethodGet)
-	strHead    = []byte(MethodHead)
-	strPost    = []byte(MethodPost)
-	strPut     = []byte(MethodPut)
-	strDelete  = []byte(MethodDelete)
-	strConnect = []byte(MethodConnect)
-	strOptions = []byte(MethodOptions)
-	strTrace   = []byte(MethodTrace)
-	strPatch   = []byte(MethodPatch)
+	strGet     = []byte(MethodGet)     //nolint:unused
+	strHead    = []byte(MethodHead)    //nolint:unused
+	strPost    = []byte(MethodPost)    //nolint:unused
+	strPut     = []byte(MethodPut)     //nolint:unused
+	strDelete  = []byte(MethodDelete)  //nolint:unused
+	strConnect = []byte(MethodConnect) //nolint:unused
+	strOptions = []byte(MethodOptions) //nolint:unused
+	strTrace   = []byte(MethodTrace)   //nolint:unused
+	strPatch   = []byte(MethodPatch)   //nolint:unused
 
 	strExpect           = []byte(HeaderExpect)
 	strConnection       = []byte(HeaderConnection)