El paquete strings de la biblioteca estándar de Go provee de muchas funciones que nos permiten administrar cadenas de caracteres. Veremos una serie de ejemplos utilizando funciones provistas por este paquete.
Confeccionar un programa que solicite la carga de una cadena con algunos caracteres en mayúsculas y otros en minúsculas. Luego guardar en otros dos string la misma cadena en uno todo con mayúsculas y en otro todo con minúsculas.
package main
import (
"fmt"
"strings"
)
func main() {
var cad string
fmt.Print("Ingrese una cadena con algunos caracteres en mayúsculas y otros en minúsculas:")
fmt.Scan(&cad)
mayus := strings.ToUpper(cad)
fmt.Println("Toda en mayúsculas:", mayus)
minus := strings.ToLower(cad)
fmt.Println("Toda en minúsculas:", minus)
}
Como necesitamos recursos de los paquetes fmt y strings procedemos a importarlos:
import (
"fmt"
"strings"
)
Luego de cargar un string por teclado procedemos a llamar a la función ToUpper del paquete strings. Esta función retorna el contenido del string que le pasamos como parámetro convertido a mayúsculas:
mayus := strings.ToUpper(cad)
fmt.Println("Toda en mayúsculas:", mayus)
De forma similar la función ToLower retorna un string convertido a minúsculas:
minus := strings.ToLower(cad)
fmt.Println("Toda en minúsculas:", minus)
Ingresar dos palabras por teclado. Verificar si la segunda palabra esta contenida en la primera e indicar en que posición comienza.
package main
import (
"fmt"
"strings"
)
func main() {
var palabra1, palabra2 string
fmt.Print("Ingrese primer palabra:")
fmt.Scan(&palabra1)
fmt.Print("Ingrese segunda palabra:")
fmt.Scan(&palabra2)
pos := strings.Index(palabra1, palabra2)
if pos == -1 {
fmt.Println("No esta contenida la palabra", palabra2, "dentro de", palabra1)
} else {
fmt.Println("La palabra", palabra2, "esta contenida en", palabra1, "a partir de la posición", pos)
}
}
Para identificar si un string esta contenido en otro string el paquete "strings" nos provee la función Index. A la función Index le pasamos como primer parámetro el string a analizar y como segundo parámetro el string a buscar. La función Index retorna un -1 si no encuentra la palabra2 dentro de palabra1. Si lo encuentra retorna la posición.
Si ingresamos las palabras:
coliflor flor
Luego en pos se almacena el número 4 que es donde comienza el string "flor"
Ingresar una palabra por teclado. Generar otro string que contenga la palabra ingresada 100 veces.
package main
import (
"fmt"
"strings"
)
func main() {
var palabra string
fmt.Print("Ingrese una palabra:")
fmt.Scan(&palabra)
palabrarepe := strings.Repeat(palabra, 100)
fmt.Println(palabrarepe)
}
Para resolver este problema llamamos a la runción Repeat y le pasamos el string original y la cantidad de repeticiones a generar. La función nos retorna otro string con la cadena inicial con tantas repeticiones como la indicada.
Definir un string con la siguiente cadena:
cadena := "Esto es una prueba y es fácil"
Generar un nuevo string remplazando todas las subcadenas "es" por "no es".
package main
import (
"fmt"
"strings"
)
func main() {
cadena := "Esto es una prueba y es fácil"
cadenanueva := strings.Replace(cadena, "es", "no es", -1)
fmt.Println(cadenanueva) // Esto no es una prueba y no es fácil
}
La función Replace del paquete strings le enviamos como primer parámetro la cadena a procesar, el segundo parámetro es la cadena a buscar, el tercer parámetro es la cadena que remplazará a las apariciones del segundo parámetro. El último parámetro es un entero: -1 indica que remplace todas las apariciones, en caso de ser un valor positivo se remplazan tantas apariciones como indica dicho valor.
El paquete strings contiene más de 40 funciones para procesar cadenas de caracteres. Cuando uno programa en Go y no recuerda las funciones del paquete strings puede visitarlo en: Paquete strings
cadena := "Esto es una prueba y es fácil"
Ingresar por teclado una cadena y luego mostrar un mensaje si la cadena ingresada está contenida en el string cadena.
cadena := "Esto es una prueba y es fácil"
Contar la cantidad de apariciones del sttring "es" dentro de cadena.
ejercicio148.go
package main
import (
"fmt"
"strings"
)
func main() {
cadena := "Esto es una prueba y es fácil"
slice1 := strings.Split(cadena," ")
for f := 0; f < len(slice1); f++ {
fmt.Println(slice1[f])
}
}
ejercicio149.go
package main
import (
"fmt"
"strings"
)
func main() {
cadena := "Esto es una prueba y es fácil"
fmt.Print("Ingrese una palabra:")
var palabra string
fmt.Scan(&palabra)
if strings.Contains(cadena, palabra) {
fmt.Println("La cadena", palabra, "esta contenida en", cadena)
} else {
fmt.Println("La cadena", palabra, "no esta contenida en", cadena)
}
}
ejercicio150.go
package main
import (
"fmt"
"strings"
)
func main() {
cadena := "Esto es una prueba y es fácil"
cant := strings.Count(cadena, "es")
fmt.Println("La cantidad de veces que aparece \"es\" en \"", cadena, "\" es", cant)
}
ejercicio151.go
package main
import (
"fmt"
"strings"
)
func main() {
var palabra1, palabra2 string
fmt.Print("Ingrese primer palabra:")
fmt.Scan(&palabra1)
fmt.Print("Ingrese segunda palabra:")
fmt.Scan(&palabra2)
if strings.HasPrefix(palabra1, palabra2) {
fmt.Println(palabra2,"coincide con los primeros caracteres de", palabra1)
} else {
fmt.Println(palabra2,"no coincide con los primeros caracteres de", palabra1)
}
}