Curso Kotlin | #5. Tipo String
Tags: kotlin, programming, tutorial, spanish
Published: 2022-12-13 12:42:04

Bienvenido/a a otro capítulo del Curso de Kotlin! Podés consultar el curso completo desde [este link](https://github.com/maxwellnewage/kotlin-course) que te dejo acá. Podés seguirme por [LinkedIn](https://www.linkedin.com/in/maximilianoburgos/) o [Twitter](https://twitter.com/maxwellnewage) si querés estar al tanto de las próximas publicaciones.

## Que es un String?
Definimos un string en su traducción directa como una cadena. En cuestiones de programación, como una cadena de caracteres. En Kotlin la definimos de la siguiente manera:

```kotlin
val name: String = "Max"
```

Para poder imprimir en pantalla dicha cadena, podemos usar println:

```kotlin
println(name)

#output: Max
```

Si quisiéramos concatenar dicho valor a un string literal, podemos usar la siguiente forma:

```kotlin
println("Hola, mi nombre es " + name)

#output: Hola, mi nombre es Max
```

Es importante agregar el espacio en el string literal para que no se pegue al valor de la variable name.

Pero como vimos en el capítulo anterior, podemos usar lo que llamamos String Templates. Por ejemplo:

```kotlin
println("Hola, mi nombre es $name")
```

Agregando el signo “$” seguido de la variable, podemos incluirlo en el string literal sin estar concatenando con “+”.

## Métodos y Propiedades de String
Existen una serie de métodos y atributos interesantes que podemos usar del tipo String.

### Atributo Length
Un atributo conocido es length, el cual nos devuelve el tamaño del string.

```kotlin
println(name.length)
```

Si quisiéramos usar String Templates, deberíamos agregar llaves. Esto aplica a métodos y atributos:

```kotlin
println("Mi nombre ocupa ${name.length} caracteres")

#output: Mi nombre ocupa 3 caracteres
```

### Método Equals
Un método que se usaba mucho en Java y también existe en Kotlin es equals, para comparar dos strings. En este caso devuelve una expresión de tipo Boolean si el string es igual o no.

```kotlin
println("${name.equals("Tomas")}")

#output: false
```

Kotlin nos sugiere en este caso usar el operador “==”, el cual generaría el mismo resultado:

```kotlin
println("${name == "Tomas"}")
```

Esto en Java no era posible, pero Kotlin si soporta este tipo de comparadores en Strings. Lo veremos más adelante en detalle.

### Método Contains
Usamos contains cuando queremos verificar si el string posee en alguna parte el valor que estamos pidiendo. Por ejemplo:

```kotlin
println("${name.contains("a")}")
#output: true
```

Nos devuelve true, porque dentro de “Max” existe el caracter “a”.

Este método es muy útil para búsquedas.

### Método Plus
Podemos usar Plus como otra forma de agregar valor a un string existente.

```kotlin
val name = "Max"
println("Hola, mi nombre es $name")
val fullName = name.plus(" Tompson")
println("Hola, mi nombre es $fullName")
```

Este método retorna un string con el valor agregado, por lo cual es necesario guardarlo en una variable. Aunque también se puede simplificar llamándolo en el println:

```kotlin
println("Hola, mi nombre es ${name.plus(" Tompson")}")
```
Sin usar plus, podríamos igualmente llegar al mismo resultado:

```kotlin
val fullName = "$name Tompson"
println("Hola, mi nombre es $fullName")
```

Lo importante es entender que este método existe, porque en posteriores capítulos le daremos un uso fundamental en otros tipos de variables.

## Conclusiones
Como ven, un String no es solo una cadena de caracteres. Al ser una clase y no un tipo primitivo, tenemos atributos y métodos que nos permiten tener las herramientas adecuadas para evaluar su valor y trabajar con los resultados.

Es importante entender que como clase, String hereda de CharSequence, y a su vez esta hereda de Char. Estos tipos son elementales para los métodos que vamos a ver en la siguiente clase.