golang瀛楃

Guri Bee

2 min read

·

23-10-2024

1

0

Share

Delving into Golang Strings: A Comprehensive Guide

Golang, renowned for its simplicity and efficiency, offers a robust string manipulation system. Understanding how Golang handles strings is crucial for any developer working with the language. In this article, we will delve into the world of Golang strings, exploring their fundamental characteristics, key operations, and practical examples.

What are Golang Strings?

In Golang, strings are immutable sequences of bytes. This means that once a string is created, its underlying data cannot be directly modified. Any operation that appears to modify a string actually creates a new string in memory.

Here's an example:

str := "Hello"
str[0] = 'J' // This will cause a compile-time error

This seemingly simple code will fail because Golang prevents direct modification of string elements.

Key Operations on Golang Strings

Let's explore some essential operations you'll likely encounter when working with Golang strings:

1. String Creation:

str := "Hello, world!" // String literal
str2 := `This is a raw string` // Raw string literal (preserves formatting)
str3 := "Go" + "lang" // String concatenation 

2. String Length:

len(str) // Returns the number of bytes in the string

3. String Indexing:

fmt.Println(str[0]) // Accessing the first character (byte)

4. String Slicing:

fmt.Println(str[1:5]) // Extracts a substring from index 1 (inclusive) to 5 (exclusive)

5. String Comparison:

str1 == str2 // Checks if two strings are equal
str1 != str2 // Checks if two strings are not equal

6. String Conversion:

strconv.Itoa(123) // Convert integer to string
strconv.ParseInt("123", 10, 64) // Convert string to integer (base 10, 64-bit)

7. String Searching:

strings.Contains(str, "world") // Checks if a string contains a substring
strings.Index(str, "world") // Returns the index of the first occurrence of a substring

8. String Manipulation:

strings.ToUpper(str) // Converts string to uppercase
strings.ToLower(str) // Converts string to lowercase
strings.Replace(str, "world", "Golang", 1) // Replaces the first occurrence of a substring

Practical Examples

Let's see some practical applications of Golang strings:

1. Parsing User Input:

import (
	"fmt"
	"strings"
)

func main() {
	var name string
	fmt.Print("Enter your name: ")
	fmt.Scanln(&name)
	
	parts := strings.Split(name, " ")
	fmt.Println("First name:", parts[0])
	fmt.Println("Last name:", parts[len(parts)-1])
}

This example demonstrates how to split a user-entered name into its constituent parts.

2. Validating Email Addresses:

import (
	"fmt"
	"regexp"
)

func main() {
	var email string
	fmt.Print("Enter your email address: ")
	fmt.Scanln(&email)
	
	// Regular expression for email validation
	emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

   


  


  

    

      close
       
      

        
      
    

    

      close
       
      

        

      
    
  

  


    




      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
   
   
      

         

            

            

            

               

                  

                     

                        Guri Bee
                        

                           

                              

                              

                                 
                              
                              

                                 
                              
                           
                        
                     
                     

                        

                           
                              
                                 

                                    
Home
                                 
                              
                           
                        
                     
                     

                        

                           
                              

                                 
                              
                           
                        
                     
                     

                        
                           

                              
                              

                           
                        
                     
                  
               
               

                  

                     

                        

                     
                     

                        

                           

                              
                              

                                 

                                    

                                    

                                       

                                          

                                             

                                                
golang瀛楃
                                                

                                                   

                                                      

                                                         

                                                            

                                                               

                                                                  
                                                                     

                                                                        

                                                                           

                                                                              

                                                                                 
                                                                                 

                                                                              
                                                                           
                                                                        
                                                                     
                                                                  
                                                               
                                                            
                                                            

                                                               

                                                                  

                                                                     
                                                                        

                                                                           

                                                                              

                                                                                 

                                                                                    

                                                                                       
Guri Bee
                                                                                    
                                                                                 
                                                                              
                                                                           
                                                                        
                                                                     
                                                                  
                                                               
                                                               

                                                                  
                                                                     

                                                                        
                                                                           

                                                                              2 min read
                                                                              
·
                                                                              23-10-2024
                                                                              
                                                                              
                                                                           
                                                                        
                                                                     
                                                                  
                                                               
                                                            
                                                         
                                                         

                                                            

                                                               

                                                                  

                                                                     

                                                                        
                                                                           
                                                                              

                                                                                 

                                                                                    

                                                                                       
                                                                                    
                                                                                 
                                                                              
                                                                           
                                                                        
                                                                     
                                                                     

                                                                        

                                                                           
                                                                           
                                                                           

                                                                              

                                                                                 
                                                                                    1
                                                                                 
                                                                              
                                                                           
                                                                        
                                                                     
                                                                  
                                                               
                                                               

                                                                  

                                                                     

                                                                        
                                                                           
                                                                              

                                                                                 

                                                                                    

                                                                                       
                                                                                    
                                                                                 
                                                                              
                                                                           
                                                                        
                                                                     
                                                                     

                                                                        

                                                                           

                                                                              

                                                                                 
                                                                                    0
                                                                                 
                                                                              
                                                                           
                                                                        
                                                                     
                                                                  
                                                               
                                                            
                                                            

                                                               

                                                               

                                                               

                                                                  

                                                                     

                                                                        
                                                                           
                                                                           

                                                                              Share
                                                                           
                                                                        
                                                                     
                                                                  
                                                               
                                                            
                                                         
                                                      
                                                   
                                                
                                             
                                             

                                                

                                                   

                                                      
                                                         
                                                      
                                                   
                                                
                                             
                                             
                                             
)
	if emailRegex.MatchString(email) {
		fmt.Println("Valid email address")
	} else {
		fmt.Println("Invalid email address")
	}
}

import (
	"fmt"
	"strings"
)

func main() {
	message := "Welcome, %s! You have %d notifications."
	username := "John Doe"
	notifications := 5
	
	fmt.Println(fmt.Sprintf(message, username, notifications))
}