add funcs HasPrefix, HasSuffix with test and docs

Author: cdvelop

README.md

@@ -85,6 +85,8 @@ Replace common `strings` package functions with TinyString equivalents:
 | `strings.TrimSpace()` | `Convert(s).TrimSpace().String()` |
 | `strings.TrimPrefix()` | `Convert(s).TrimPrefix(prefix).String()` |
 | `strings.TrimSuffix()` | `Convert(s).TrimSuffix(suffix).String()` |
+| `strings.HasPrefix()` | `HasPrefix(s, prefix)` |
+| `strings.HasSuffix()` | `HasSuffix(s, suffix)` |
 
 #### Other String Transformations
 
@@ -103,6 +105,14 @@ pos := Index("hello world", "world")                  // out: 6 (first occurrenc
 found := Contains("hello world", "world")              // out: true
 count := Count("abracadabra", "abra")       // out: 2
 
+// Prefix / Suffix checks
+isPref := HasPrefix("hello", "he")          // out: true
+isSuf := HasSuffix("file.txt", ".txt")      // out: true
+
+// Note: this library follows the standard library semantics for prefixes/suffixes:
+// an empty prefix or suffix is considered a match (HasPrefix(s, "") == true,
+// HasSuffix(s, "") == true).
+
 // Find last occurrence (useful for file extensions)
 pos := LastIndex("image.backup.jpg", ".")             // out: 12
 if pos >= 0 {

search.go

@@ -13,7 +13,7 @@ package tinystring
 func Index(s, substr string) int {
 	n := len(substr)
 	if n == 0 {
-		return 0 // Comportamiento estándar: cadena vacía se encuentra en posición 0
+		return 0 // Standard behavior: empty string is found at position 0
 	}
 	if n == 1 {
 		// Optimized single byte search
@@ -80,3 +80,43 @@ func Contains(Conv, search string) bool {
 	}
 	return Index(Conv, search) != -1
 }
+
+// HasPrefix reports whether the string 'conv' begins with 'prefix'.
+// Implemented using Index for consistency with other helpers in this package.
+//
+// Examples:
+//
+//	HasPrefix("hello", "he")   // returns true
+//	HasPrefix("hello", "hello") // returns true
+//	HasPrefix("hello", "")      // returns false (empty prefix)
+//	HasPrefix("a", "abc")       // returns false (prefix longer than string)
+func HasPrefix(conv, prefix string) bool {
+	if len(prefix) == 0 {
+		return true // Follow stdlib semantics: empty string is a prefix of any string
+	}
+	if len(conv) < len(prefix) {
+		return false
+	}
+	// Search only in the slice that should match the prefix; Index must return 0.
+	return Index(conv[:len(prefix)], prefix) == 0
+}
+
+// HasSuffix reports whether the string 'Conv' ends with 'suffix'.
+// Implemented using Index by checking the tail of the string.
+//
+// Examples:
+//
+//	HasSuffix("testing", "ing")  // returns true
+//	HasSuffix("file.txt", ".txt") // returns true
+//	HasSuffix("hello", "")        // returns false (empty suffix)
+//	HasSuffix("go", "golang")     // returns false
+func HasSuffix(conv, suffix string) bool {
+	if len(suffix) == 0 {
+		return true // Follow stdlib semantics: empty string is a suffix of any string
+	}
+	if len(conv) < len(suffix) {
+		return false
+	}
+	// The suffix should be at the start of the tail slice
+	return Index(conv[len(conv)-len(suffix):], suffix) == 0
+}

searchHasPrefixSuffix_test.go

@@ -0,0 +1,57 @@
+package tinystring
+
+import "testing"
+
+func TestHasPrefix(t *testing.T) {
+	tests := []struct {
+		name   string
+		s      string
+		prefix string
+		want   bool
+	}{
+		{"empty prefix", "hello", "", true},
+		{"exact match", "hello", "hello", true},
+		{"short prefix", "hello", "he", true},
+		{"not a prefix", "hello", "ello", false},
+		{"prefix longer than string", "hi", "hello", false},
+		{"single byte", "abc", "a", true},
+		{"null byte prefix", "a\x00b", "a\x00", true},
+		{"unicode prefix", "ñandú", "ñan", true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := HasPrefix(tc.s, tc.prefix)
+			if got != tc.want {
+				t.Fatalf("HasPrefix(%q, %q) = %v; want %v", tc.s, tc.prefix, got, tc.want)
+			}
+		})
+	}
+}
+
+func TestHasSuffix(t *testing.T) {
+	tests := []struct {
+		name   string
+		s      string
+		suffix string
+		want   bool
+	}{
+		{"empty suffix", "hello", "", true},
+		{"exact match", "hello", "hello", true},
+		{"short suffix", "hello", "lo", true},
+		{"not a suffix", "hello", "hel", false},
+		{"suffix longer than string", "go", "golang", false},
+		{"single byte", "abc", "c", true},
+		{"null byte suffix", "a\x00b", "\x00b", true},
+		{"unicode suffix", "pingüino", "üino", true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := HasSuffix(tc.s, tc.suffix)
+			if got != tc.want {
+				t.Fatalf("HasSuffix(%q, %q) = %v; want %v", tc.s, tc.suffix, got, tc.want)
+			}
+		})
+	}
+}