Golang strings.ContainsRune Function

The strings.ContainsRune function in Golang is part of the strings package and is used to check if a specific Unicode character (rune) is present within a given string. It returns a boolean value indicating whether the rune exists in the string. This function is useful for verifying the presence of specific characters in a string, such as checking for punctuation, special characters, or individual letters.

Table of Contents

1. Introduction
2. ContainsRune Function Syntax
3. Examples
   • Basic Usage
   • Checking for Specific Characters
4. Real-World Use Case
5. Conclusion

Introduction

The strings.ContainsRune function allows you to determine if a specific rune is present in a string. This function is particularly useful when you need to verify the presence of individual characters, such as checking for a specific letter, digit, or punctuation mark in a string. Runes in Go are used to represent Unicode code points, making this function applicable for multi-byte characters as well.

ContainsRune Function Syntax

The syntax for the strings.ContainsRune function is as follows:

func ContainsRune(s string, r rune) bool

Parameters:

• s: The main string to be searched.
• r: The rune (Unicode code point) to search for within the main string.

Returns:

• A boolean value (true or false) indicating whether the rune is present in the main string.

Examples

Basic Usage

This example demonstrates how to use the strings.ContainsRune function to check if a string contains a specific character.

Example

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Define the main string
	str := "Hello, Golang!"

	// Define the rune to search for
	r := 'G'

	// Use strings.ContainsRune to check for the rune
	contains := strings.ContainsRune(str, r)

	// Print the result
	if contains {
		fmt.Printf("The string contains the rune '%c'.\n", r)
	} else {
		fmt.Printf("The string does not contain the rune '%c'.\n", r)
	}
}

Output:

The string contains the rune 'G'.

Checking for Specific Characters

You can use strings.ContainsRune to check for the presence of specific characters, such as punctuation marks, in a string.

Example

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Define the main string
	str := "Hello, World!"

	// Define the punctuation mark to search for
	punctuation := '!'

	// Use strings.ContainsRune to check for the punctuation mark
	containsPunctuation := strings.ContainsRune(str, punctuation)

	// Print the result
	if containsPunctuation {
		fmt.Printf("The string contains the punctuation mark '%c'.\n", punctuation)
	} else {
		fmt.Printf("The string does not contain the punctuation mark '%c'.\n", punctuation)
	}
}

Output:

The string contains the punctuation mark '!'.

Real-World Use Case

Validating Passwords

In real-world applications, strings.ContainsRune can be used to check for the presence of specific characters, such as special characters, in passwords.

Example

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Define a list of passwords
	passwords := []string{"Pass123", "Secure!2024", "noSpecialChar"}

	// Define a special character to check for
	specialChar := '!'

	// Validate each password for the presence of the special character
	fmt.Println("Validating passwords:")
	for _, password := range passwords {
		if strings.ContainsRune(password, specialChar) {
			fmt.Printf("Password '%s' contains the special character '%c'.\n", password, specialChar)
		} else {
			fmt.Printf("Password '%s' does not contain the special character '%c'.\n", password, specialChar)
		}
	}
}

Output:

Validating passwords:
Password 'Pass123' does not contain the special character '!'.
Password 'Secure!2024' contains the special character '!'.
Password 'noSpecialChar' does not contain the special character '!'.

Conclusion

The strings.ContainsRune function is a simple and efficient way to check for the presence of a specific Unicode character in a string in Go. It is particularly useful for tasks that involve verifying the existence of individual characters, such as checking for punctuation, special characters, or specific letters. By using strings.ContainsRune, you can easily determine whether a character is present in your strings, making it a valuable function for handling string data and input validation in your Go programs.