¿Qué son los tipos de datos primitivos?

Imagina que estás construyendo una casa con bloques de Lego. Los bloques de Lego más básicos, como los ladrillos de 2x4 o las placas lisas, son los bloques de construcción fundamentales. No puedes descomponer un ladrillo de 2x4 en piezas de Lego aún más pequeñas.

En el mundo de la programación, los tipos de datos primitivos son como esos bloques de Lego básicos. Son las piezas fundamentales que utilizamos para representar la información dentro de un programa como numeros, texto, valores booleanos, etc.

Estos no pueden dividirse en partes mas simples, pero si pueden usarse para construir estructuras de datos mas complejas.

Son extremadamente cruciales ya que nos permiten decirle a la computadora que tipo de información vamos a manejar, y la computadora puede hacer un uso mas eficiente de los datos asignandole lugares correctos en la memoria.

Cada lenguaje tiene asociado a cada tipo de dato operaciones especiales que se pueden realizar con el. Por ejemplo en algunos lenguajes podemos sumar dos numeros enteros, lo cual si fueran dos textos no tendria sentido.

Tipos de datos primitivos comunes

Enteros

En programación, al igual que en matemáticas, los números enteros son aquellos que no tienen parte decimal ni fraccionaria. Pueden ser positivos (como 5, 100), negativos (como -3, -25) o cero (0).

edad = 30
cantidad_items = -5
cero = 0
 
print(edad)
print(cantidad_items)
print(cero)

En Python, simplemente asignas un valor entero a una variable. Python automáticamente reconoce que es un número entero.

let edad = 30;
let cantidadItems = -5;
let cero = 0;
 
console.log(edad);
console.log(cantidadItems);
console.log(cero);

Al igual que en Python, JavaScript también infiere el tipo de dato como entero cuando le asignas un valor sin decimales.

public class EjemploEnteros {
    public static void main(Stringargs) {
        int edad = 30;
        int cantidadItems = -5;
        int cero = 0;
 
        System.out.println(edad);
        System.out.println(cantidadItems);
        System.out.println(cero);
    }
}

En Java, debes declarar explícitamente que la variable será de tipo entero utilizando la palabra clave int.

#include <iostream>
 
int main() {
    int edad = 30;
    int cantidad_items = -5;
    int cero = 0;
 
    std::cout << edad << std::endl;
    std::cout << cantidad_items << std::endl;
    std::cout << cero << std::endl;
 
    return 0;
}

Similar a Java, en C++ también declaras las variables enteras con la palabra clave int.

public class EjemploEnteros
{
    public static void Main(stringargs)
    {
        int edad = 30;
        int cantidadItems = -5;
        int cero = 0;
 
        System.Console.WriteLine(edad);
        System.Console.WriteLine(cantidadItems);
        System.Console.WriteLine(cero);
    }
}

En C#, la palabra clave para declarar un entero es también int.

edad = 30
cantidad_items = -5
cero = 0
 
puts edad
puts cantidad_items
puts cero

Ruby, al igual que Python y JavaScript, infiere el tipo de dato como entero cuando se le asigna un valor sin decimales.

package main
 
import "fmt"
 
func main() {
    var edad int = 30
    var cantidadItems int = -5
    var cero int = 0
 
    fmt.Println(edad)
    fmt.Println(cantidadItems)
    fmt.Println(cero)
}

En Go, puedes declarar una variable entera usando var nombre_variable int = valor. También puedes omitir el tipo si el valor inicial ya lo deja claro (por ejemplo, var edad = 30).

Operaciones Básicas Comunes con Números:

Suma (+): Se utiliza para agregar dos o más números.
Resta (-): Se utiliza para restar un número de otro.
Multiplicación (*): Se utiliza para multiplicar dos o más números.
División (/): Se utiliza para dividir un número 1 por otro. Es importante tener en cuenta que en algunos lenguajes, la división entre enteros puede dar como resultado un entero (truncando la parte decimal), mientras que en otros puede dar un número de punto flotante.
Módulo (%): También conocido como “resto” o “residuo”. Devuelve el resto de una división entera. Por ejemplo, 7 % 3 es 1 porque 7 dividido por 3 es 2 con un resto de 1.
Exponenciación: Se utiliza para elevar un número a una potencia. La sintaxis varía entre los lenguajes.

numero1 = 10
numero2 = 3
 
suma = numero1 + numero2
resta = numero1 - numero2
multiplicacion = numero1 * numero2
division = numero1 / numero2
modulo = numero1 % numero2
exponenciacion = numero1 ** numero2  # En Python se usa ** para la exponenciación

let numero1 = 10;
let numero2 = 3;
 
let suma = numero1 + numero2;
let resta = numero1 - numero2;
let multiplicacion = numero1 * numero2;
let division = numero1 / numero2;
let modulo = numero1 % numero2;
let exponenciacion = numero1 ** numero2; // En JavaScript también se usa ** para la exponenciación

public class EjemploEnteros {
    public static void main(Stringargs) {
        int numero1 = 10;
        int numero2 = 3;
 
        int suma = numero1 + numero2;
        int resta = numero1 - numero2;
        int multiplicacion = numero1 * numero2;
        double division = (double) numero1 / numero2; // Necesitamos convertir a double para obtener decimales
        int modulo = numero1 % numero2;
        double exponenciacion = Math.pow(numero1, numero2); // En Java se usa Math.pow() para la exponenciación
 
    }
}

En Java, C++ y Go, si divides dos números enteros sin realizar una conversión explícita a un tipo de punto flotante (como double o float64), el resultado será un entero (la parte decimal se trunca).

#include <iostream>
 
int main() {
    int numero1 = 10;
    int numero2 = 3;
 
    int suma = numero1 + numero2;
    int resta = numero1 - numero2;
    int multiplicacion = numero1 * numero2;
    double division = static_cast<double>(numero1) / numero2; // Casting a double para obtener decimales
    int modulo = numero1 % numero2;
    double exponenciacion = std::pow(numero1, numero2); // En C++ se usa std::pow()
 
    return 0;
}

public class EjemploEnteros
{
    public static void Main(stringargs)
    {
        int numero1 = 10;
        int numero2 = 3;
 
        int suma = numero1 + numero2;
        int resta = numero1 - numero2;
        int multiplicacion = numero1 * numero2;
        double division = (double)numero1 / numero2; // Casting a double para obtener decimales
        int modulo = numero1 % numero2;
        double exponenciacion = Math.Pow(numero1, numero2); // En C# se usa Math.Pow()
    }
}

numero1 = 10
numero2 = 3
 
suma = numero1 + numero2
resta = numero1 - numero2
multiplicacion = numero1 * numero2
division = numero1.to_f / numero2 # Convertimos a float para obtener decimales
modulo = numero1 % numero2
exponenciacion = numero1 ** numero2 # En Ruby también se usa **

package main
 
import (
    "fmt"
    "math"
)
 
func main() {
    numero1 := 10
    numero2 := 3
 
    suma := numero1 + numero2
    resta := numero1 - numero2
    multiplicacion := numero1 * numero2
    division := float64(numero1) / float64(numero2) // Convertimos a float64 para obtener decimales
    modulo := numero1 % numero2
    exponenciacion := math.Pow(float64(numero1), float64(numero2)) // Usamos math.Pow() y convertimos a float64
}

Go utiliza la función math.Pow() del paquete math.

Numeros de punto flotante

En esencia, un número de punto flotante es una forma de representar números reales (tanto racionales como irracionales) en una computadora. La idea detrás del “punto flotante” es que la posición del punto decimal puede “flotar”, es decir, puede estar en diferentes lugares dependiendo de la magnitud del número.

Piensa en la notación científica que aprendiste en la escuela: un número se representa como un número entre 1 y 10 multiplicado por una potencia de 10 (por ejemplo, $1.23 x 10^3$ ). Los números de punto flotante en las computadoras funcionan de manera similar, pero en base 2 (porque las computadoras usan bits, que son 0s y 1s).

pi = 3.14159
print(pi)

let pi = 3.14159;
console.log(pi);

public class EjemploFlotante {
    public static void main(Stringargs) {
        double pi = 3.14159;
        System.out.println(pi);
    }
}

#include <iostream>
 
int main() {
    double pi = 3.14159;
    std::cout << pi << std::endl;
    return 0;
}

public class EjemploFlotante
{
    public static void Main(stringargs)
    {
        double pi = 3.14159;
        System.Console.WriteLine(pi);
    }
}

pi = 3.14159
puts pi

package main
 
import "fmt"
 
func main() {
    pi := 3.14159
    fmt.Println(pi)
}

Las operaciones sobre numeros flotantes son similares a la de los enteros, pero con numeros con coma.

numero1_float = 10.5
numero2_float = 2.5
 
suma_float = numero1_float + numero2_float
resta_float = numero1_float - numero2_float
multiplicacion_float = numero1_float * numero2_float
division_float = numero1_float / numero2_float
modulo_float = numero1_float % numero2_float
exponenciacion_float = numero1_float ** numero2_float

let numero1Float = 10.5;
let numero2Float = 2.5;
 
let sumaFloat = numero1Float + numero2Float;
let restaFloat = numero1Float - numero2Float;
let multiplicacionFloat = numero1Float * numero2Float;
let divisionFloat = numero1Float / numero2Float;
let moduloFloat = numero1Float % numero2Float;
let exponenciacionFloat = numero1Float ** numero2Float;

public class EjemploFlotante {
    public static void main(Stringargs) {
        double numero1Float = 10.5;
        double numero2Float = 2.5;
 
        double sumaFloat = numero1Float + numero2Float;
        double restaFloat = numero1Float - numero2Float;
        double multiplicacionFloat = numero1Float * numero2Float;
        double divisionFloat = numero1Float / numero2Float;
        double moduloFloat = numero1Float % numero2Float;
        double exponenciacionFloat = Math.pow(numero1Float, numero2Float);
    }
}

#include <iostream>
#include <cmath>
 
int main() {
    double numero1Float = 10.5;
    double numero2Float = 2.5;
 
    double sumaFloat = numero1Float + numero2Float;
    double restaFloat = numero1Float - numero2Float;
    double multiplicacionFloat = numero1Float * numero2Float;
    double divisionFloat = numero1Float / numero2Float;
    double moduloFloat = std::fmod(numero1Float, numero2Float); // Usamos std::fmod para módulo con floats
    double exponenciacionFloat = std::pow(numero1Float, numero2Float);
 
    return 0;
}

public class EjemploFlotante
{
    public static void Main(stringargs)
    {
        double numero1Float = 10.5;
        double numero2Float = 2.5;
 
        double sumaFloat = numero1Float + numero2Float;
        double restaFloat = numero1Float - numero2Float;
        double multiplicacionFloat = numero1Float * numero2Float;
        double divisionFloat = numero1Float / numero2Float;
        double moduloFloat = numero1Float % numero2Float;
        double exponenciacionFloat = Math.Pow(numero1Float, numero2Float);
    }
}

numero1_float = 10.5
numero2_float = 2.5
 
suma_float = numero1_float + numero2_float
resta_float = numero1_float - numero2_float
multiplicacion_float = numero1_float * numero2_float
division_float = numero1_float / numero2_float
modulo_float = numero1_float % numero2_float
exponenciacion_float = numero1_float ** numero2_float

package main
 
import (
    "fmt"
    "math"
)
 
func main() {
    numero1Float := 10.5
    numero2Float := 2.5
 
    sumaFloat := numero1Float + numero2Float
    restaFloat := numero1Float - numero2Float
    multiplicacionFloat := numero1Float * numero2Float
    divisionFloat := numero1Float / numero2Float
    moduloFloat := math.Mod(numero1Float, numero2Float) // Usamos math.Mod para módulo con floats
    exponenciacionFloat := math.Pow(numero1Float, numero2Float)
}

📝 Consideraciones

División : La división entre números de punto flotante generalmente produce otro número de punto flotante en todos estos lenguajes.
Módulo : Para el operador módulo con números de punto flotante, algunos lenguajes pueden requerir una función específica. Por ejemplo, en C++ se usa std::fmod y en Go se usa math.Mod. En otros lenguajes, el operador % también funciona con floats.
Exponenciación : Al igual que con los enteros, la exponenciación se realiza con ** en Python, JavaScript y Ruby, y con funciones como Math.pow() (Java, C#) y std::pow() (C++) y math.Pow() (Go).
Precisión : Recuerda que los cálculos con números de punto flotante pueden tener pequeñas imprecisiones debido a la forma en que se representan internamente en la computadora.

Booleanos

Un booleano (a veces llamado valor booleano o tipo lógico) es un tipo de dato primitivo que representa un valor de verdad. Se utiliza para expresar si una condición es verdadera o falsa. Son fundamentales para la toma de decisiones en los programas, ya que permiten que el código se comporte de manera diferente según ciertas condiciones.

Tiene tan solo dos valores posibles:

Verdadero (True) : Indica que una condición se cumple o es cierta.
Falso (False) : Indica que una condición no se cumple o es falsa.

Estos valores son usados generalmente se utilizan en estructuras de control como las declaraciones if, else, while y for para determinar qué parte del código se debe ejecutar. Por ejemplo, “Si esta condición es verdadera, entonces haz esto; si no, haz aquello”. Evaluación de condiciones: El resultado de comparar valores (por ejemplo, si un número es mayor que otro) siempre es un booleano (verdadero o falso). Indicadores (flags): Se pueden usar como “interruptores” para recordar si algo ha ocurrido o si una cierta condición se ha activado.

es_verdadero = True
es_falso = False

let esVerdadero = true;
let esFalso = false;

public class EjemploBooleano {
    public static void main(String[] args) {
        boolean esVerdadero = true;
        boolean esFalso = false;
    }
}

#include <iostream>
 
int main() {
    bool esVerdadero = true;
    bool esFalso = false;
    return 0;
}

public class EjemploBooleano
{
    public static void Main(string[] args)
    {
        bool esVerdadero = true;
        bool esFalso = false;
    }
}

es_verdadero = true
es_falso = false

package main
 
import "fmt"
 
func main() {
    esVerdadero := true
    esFalso := false
}

📝 ¿Que es una tabla de verdad?

Imagina una tabla que muestra todas las posibles combinaciones de valores de entrada para una operación lógica, y el resultado (verdadero o falso) para cada una de esas combinaciones.

Supongamos que tenemos dos entradas booleanas, llamadas A y B, y queremos ver el resultado de la operación A AND B. La tabla de verdad se vería así:

A	B	A AND B
Verdadero	Verdadero	Verdadero
Verdadero	Falso	Falso
Falso	Verdadero	Falso
Falso	Falso	Falso

La primera fila nos dice que si A es verdadero Y B es verdadero, entonces el resultado de A AND B es verdadero.
La segunda fila nos dice que si A es verdadero Y B es falso, entonces el resultado de A AND B es falso.
Y así sucesivamente para las otras combinaciones.

Operaciones Básicas Comunes con Booleanos:

AND (Y lógico): El resultado es verdadero solo si ambos operandos son verdaderos. En caso contrario, el resultado es falso.

A	B	A AND B
Verdadero	Verdadero	Verdadero
Verdadero	Falso	Falso
Falso	Verdadero	Falso
Falso	Falso	Falso

OR (O lógico): El resultado es verdadero si al menos uno de los operandos es verdadero. El resultado es falso solo si ambos operandos son falsos.

A	B	A OR B
Verdadero	Verdadero	Verdadero
Verdadero	Falso	Verdadero
Falso	Verdadero	Verdadero
Falso	Falso	Falso

NOT (Negación lógica): Invierte el valor del operando. Si el operando es verdadero, el resultado es falso, y si el operando es falso, el resultado es verdadero.

A	NOT A
Verdadero	Falso
Falso	Verdadero

valor1 = True
valor2 = False
 
and_resultado = valor1 and valor2
or_resultado = valor1 or valor2
not_resultado1 = not valor1
not_resultado2 = not valor2

let valor1 = true;
let valor2 = false;
 
let andResultado = valor1 && valor2;
let orResultado = valor1 || valor2;
let notResultado1 = !valor1;
let notResultado2 = !valor2;

public class EjemploBooleano {
    public static void main(String[] args) {
        boolean valor1 = true;
        boolean valor2 = false;
 
        boolean andResultado = valor1 && valor2;
        boolean orResultado = valor1 || valor2;
        boolean notResultado1 = !valor1;
        boolean notResultado2 = !valor2;
    }
}

#include <iostream>
 
int main() {
    bool valor1 = true;
    bool valor2 = false;
 
    bool andResultado = valor1 && valor2;
    bool orResultado = valor1 || valor2;
    bool notResultado1 = !valor1;
    bool notResultado2 = !valor2;
}

public class EjemploBooleano
{
    public static void Main(string[] args)
    {
        bool valor1 = true;
        bool valor2 = false;
 
        bool andResultado = valor1 && valor2;
        bool orResultado = valor1 || valor2;
        bool notResultado1 = !valor1;
        bool notResultado2 = !valor2;
    }
}

valor1 = true
valor2 = false
 
and_resultado = valor1 && valor2
or_resultado = valor1 || valor2
not_resultado1 = !valor1
not_resultado2 = !valor2

package main
 
import "fmt"
 
func main() {
    valor1 := true
    valor2 := false
 
    andResultado := valor1 && valor2
    orResultado := valor1 || valor2
    notResultado1 := !valor1
    notResultado2 := !valor2
}

Operadores : Los símbolos utilizados para representar estas operaciones pueden variar ligeramente entre los lenguajes.
1. AND: Generalmente se usa && (en Java, C++, C#, JavaScript, Go) o la palabra clave and (en Python y Ruby).
2. OR: Generalmente se usa || (en Java, C++, C#, JavaScript, Go) o la palabra clave or (en Python y Ruby).
3. NOT: Generalmente se usa ! (en Java, C++, C#, JavaScript, Go y Ruby) o la palabra clave not (en Python).
Resultado : El resultado de estas operaciones siempre será un valor booleano (True o False, o sus equivalentes).

Caracteres

Imagina que quieres representar una sola letra, un número como un símbolo (por ejemplo, el ‘5’ como carácter, no como el número cinco), un signo de puntuación o incluso un espacio en blanco. El tipo de dato carácter se utiliza para almacenar exactamente eso: un único símbolo de texto.

Un carácter representa una unidad individual de texto. Esto puede ser:

Letras del alfabeto (mayúsculas y minúsculas): ‘a’, ‘B’, ‘z’
Dígitos numéricos (como símbolos): ‘0’, ‘1’, ‘9’
Símbolos de puntuación: ’.’, ’,’, ’?’, ’!’
Caracteres especiales: ’$’, ’#’, ’@’
Caracteres de espacio en blanco: ’ ’ (espacio), ‘\t’ (tabulador), ‘\n’ (nueva línea)

Hoy en día, la mayoría de los lenguajes de programación utilizan un estándar llamado Unicode para representar caracteres. Unicode asigna un número único a cada carácter que existe en casi todos los sistemas de escritura del mundo. Esto permite que las computadoras manejen texto de diferentes idiomas de manera consistente.

En Python, no existe un tipo de dato “carácter” separado como en otros lenguajes. Las cadenas de texto de un solo carácter se consideran simplemente cadenas.

caracter = 'A'

Al igual que en Python, en JavaScript los caracteres individuales se representan como cadenas de texto de longitud 1.

let caracter = 'A';

Java tiene un tipo de dato primitivo llamado char que se utiliza específicamente para almacenar un único carácter Unicode. Los literales de carácter se escriben entre comillas simples.

public class EjemploCaracter {
    public static void main(String[] args) {
        char caracter = 'A';
    }
}

C++ también tiene un tipo de dato primitivo llamado char para representar caracteres individuales. También se utilizan comillas simples.

#include <iostream>
 
int main() {
    char caracter = 'A';
    std::cout << caracter << std::endl;
    return 0;
}

C# tiene un tipo de dato char similar a Java y C++. Los literales de carácter también van entre comillas simples.

public class EjemploCaracter
{
    public static void Main(string[] args)
    {
        char caracter = 'A';
        System.Console.WriteLine(caracter);
    }
}

En Ruby, al igual que en Python y JavaScript, los caracteres individuales se representan como cadenas de texto de longitud 1.

caracter = 'A'

Go tiene un tipo de dato rune que se utiliza para representar un carácter Unicode. Aunque técnicamente no es un char en el sentido tradicional de otros lenguajes (que a menudo se limitan a ASCII), rune cumple la función de representar un carácter individual. Los literales de carácter se escriben entre comillas simples.

package main
 
import "fmt"
 
func main() {
    caracter := 'A'
    fmt.Println(caracter)
}

Operaciones Básicas Comunes con Caracteres:

Comparación: Podemos comparar caracteres entre sí para ver si son iguales, diferentes, o si uno es mayor o menor que otro (según su valor Unicode).
Conversión de caso: Podemos convertir un carácter de minúscula a mayúscula y viceversa (si es una letra).
Verificación de tipo: Podemos verificar si un carácter es una letra, un dígito, un espacio en blanco, etc.

caracter1 = 'a'
caracter2 = 'A'
caracter3 = '5'
caracter4 = ' '
 
# Comparación
print(f"¿'{caracter1}' es igual a '{caracter2}'? {caracter1 == caracter2}")
print(f"¿'{caracter1}' es menor que '{caracter2}'? {caracter1 < caracter2}")
 
# Conversión de caso
print(f"'{caracter1}' en mayúscula: {caracter1.upper()}")
print(f"'{caracter2}' en minúscula: {caracter2.lower()}")
 
# Verificación de tipo
print(f"¿'{caracter3}' es un dígito? {caracter3.isdigit()}")
print(f"¿'{caracter1}' es una letra? {caracter1.isalpha()}")
print(f"¿'{caracter4}' es espacio en blanco? {caracter4.isspace()}")

let caracter1 = 'a';
let caracter2 = 'A';
let caracter3 = '5';
let caracter4 = ' ';
 
// Comparación
console.log(`¿'${caracter1}' es igual a '${caracter2}'? ${caracter1 === caracter2}`);
console.log(`¿'${caracter1}' es menor que '${caracter2}'? ${caracter1 < caracter2}`);
 
// Conversión de caso
console.log(`'${caracter1}' en mayúscula: ${caracter1.toUpperCase()}`);
console.log(`'${caracter2}' en minúscula: ${caracter2.toLowerCase()}`);
 
// Verificación de tipo (no hay métodos directos para un solo carácter, se pueden usar expresiones regulares)
console.log(`¿'${caracter3}' es un dígito? ${/\d/.test(caracter3)}`);
console.log(`¿'${caracter1}' es una letra? ${/[a-zA-Z]/.test(caracter1)}`);
console.log(`¿'${caracter4}' es espacio en blanco? ${/\s/.test(caracter4)}`);

public class EjemploChar {
    public static void main(String[] args) {
        char caracter1 = 'a';
        char caracter2 = 'A';
        char caracter3 = '5';
        char caracter4 = ' ';
 
        // Comparación
        System.out.println("¿'" + caracter1 + "' es igual a '" + caracter2 + "'? " + (caracter1 == caracter2));
        System.out.println("¿'" + caracter1 + "' es menor que '" + caracter2 + "'? " + (caracter1 < caracter2));
 
        // Conversión de caso
        System.out.println("'" + caracter1 + "' en mayúscula: " + Character.toUpperCase(caracter1));
        System.out.println("'" + caracter2 + "' en minúscula: " + Character.toLowerCase(caracter2));
 
        // Verificación de tipo
        System.out.println("¿'" + caracter3 + "' es un dígito? " + Character.isDigit(caracter3));
        System.out.println("¿'" + caracter1 + "' es una letra? " + Character.isLetter(caracter1));
        System.out.println("¿'" + caracter4 + "' es espacio en blanco? " + Character.isWhitespace(caracter4));
    }
}

#include <iostream>
#include <cctype> // Para las funciones de verificación de tipo
 
int main() {
    char caracter1 = 'a';
    char caracter2 = 'A';
    char caracter3 = '5';
    char caracter4 = ' ';
 
    // Comparación
    std::cout << "¿'" << caracter1 << "' es igual a '" << caracter2 << "'? " << (caracter1 == caracter2) << std::endl;
    std::cout << "¿'" << caracter1 << "' es menor que '" << caracter2 << "'? " << (caracter1 < caracter2) << std::endl;
 
    // Conversión de caso
    std::cout << "'" << caracter1 << "' en mayúscula: " << static_cast<char>(std::toupper(caracter1)) << std::endl;
    std::cout << "'" << caracter2 << "' en minúscula: " << static_cast<char>(std::tolower(caracter2)) << std::endl;
 
    // Verificación de tipo
    std::cout << "¿'" << caracter3 << "' es un dígito? " << std::isdigit(caracter3) << std::endl;
    std::cout << "¿'" << caracter1 << "' es una letra? " << std::isalpha(caracter1) << std::endl;
    std::cout << "¿'" << caracter4 << "' es espacio en blanco? " << std::isspace(caracter4) << std::endl;
 
    return 0;
}

public class EjemploChar
{
    public static void Main(string[] args)
    {
        char caracter1 = 'a';
        char caracter2 = 'A';
        char caracter3 = '5';
        char caracter4 = ' ';
 
        // Comparación
        System.Console.WriteLine($"¿'{caracter1}' es igual a '{caracter2}'? {caracter1 == caracter2}");
        System.Console.WriteLine($"¿'{caracter1}' es menor que '{caracter2}'? {caracter1 < caracter2}");
 
        // Conversión de caso
        System.Console.WriteLine($"'{caracter1}' en mayúscula: {char.ToUpper(caracter1)}");
        System.Console.WriteLine($"'{caracter2}' en minúscula: {char.ToLower(caracter2)}");
 
        // Verificación de tipo
        System.Console.WriteLine($"¿'{caracter3}' es un dígito? {char.IsDigit(caracter3)}");
        System.Console.WriteLine($"¿'{caracter1}' es una letra? {char.IsLetter(caracter1)}");
        System.Console.WriteLine($"¿'{caracter4}' es espacio en blanco? {char.IsWhiteSpace(caracter4)}");
    }
}

caracter1 = 'a'
caracter2 = 'A'
caracter3 = '5'
caracter4 = ' '
 
# Comparación
puts "¿'#{caracter1}' es igual a '#{caracter2}'? #{caracter1 == caracter2}"
puts "¿'#{caracter1}' es menor que '#{caracter2}'? #{caracter1 < caracter2}"
 
# Conversión de caso
puts "'#{caracter1}' en mayúscula: #{caracter1.upcase}"
puts "'#{caracter2}' en minúscula: #{caracter2.downcase}"
 
# Verificación de tipo (no hay métodos directos tan concisos)
puts "¿'#{caracter3}' es un dígito? #{caracter3 =~ /\d/}" # Retorna la posición o nil
puts "¿'#{caracter1}' es una letra? #{caracter1 =~ /[a-zA-Z]/}"
puts "¿'#{caracter4}' es espacio en blanco? #{caracter4 =~ /\s/}"

package main
 
import (
    "fmt"
    "strings"
    "unicode"
)
 
func main() {
    caracter1 := 'a'
    caracter2 := 'A'
    caracter3 := '5'
    caracter4 := ' '
 
    // Comparación
    fmt.Printf("¿'%c' es igual a '%c'? %t\n", caracter1, caracter2, caracter1 == caracter2)
    fmt.Printf("¿'%c' es menor que '%c'? %t\n", caracter1, caracter2, caracter1 < caracter2)
 
    // Conversión de caso
    fmt.Printf("'%c' en mayúscula: %c\n", caracter1, unicode.ToUpper(caracter1))
    fmt.Printf("'%c' en minúscula: %c\n", caracter2, unicode.ToLower(caracter2))
 
    // Verificación de tipo
    fmt.Printf("¿'%c' es un dígito? %t\n", caracter3, unicode.IsDigit(caracter3))
    fmt.Printf("¿'%c' es una letra? %t\n", caracter1, unicode.IsLetter(caracter1))
    fmt.Printf("¿'%c' es espacio en blanco? %t\n", caracter4, unicode.IsSpace(caracter4))
}

Python, JavaScript, Ruby: No tienen un tipo de dato char distinto. Los caracteres individuales se tratan como cadenas de texto de longitud uno. Las operaciones se realizan utilizando métodos de cadena o expresiones regulares.
Java, C++, C#: Tienen un tipo de dato char específico para representar un único carácter. Ofrecen métodos o funciones para realizar operaciones como conversión de caso y verificación de tipo.
Go: Utiliza el tipo rune para representar caracteres Unicode, que es un entero de 32 bits. El paquete unicode proporciona funciones para trabajar con runes.
Comparación: La comparación de caracteres se basa en su valor numérico Unicode.

Cadenas de texto

Ahora imagina que quieres representar una palabra, una frase, un párrafo o incluso un libro entero. Una cadena de texto es una secuencia ordenada de caracteres que se utiliza para almacenar y manipular texto en los programas. Piensa en ella como un collar de cuentas, donde cada cuenta es un carácter.

Una cadena de texto es una secuencia de uno o más caracteres (letras, números, símbolos, espacios en blanco, etc.) que se tratan como una sola unidad de datos. Se utilizan para representar texto que puede ser mostrado en pantalla, leído desde un archivo, enviado a través de la red, etc.

saludo = "Hola, mundo!"

let saludo = "Hola, mundo!";

public class EjemploString {
    public static void main(String[] args) {
        String saludo = "Hola, mundo!";
        System.out.println(saludo);
    }
}

#include <iostream>
#include <string> // Necesitas incluir la librería string para usar el tipo string
 
int main() {
    std::string saludo = "Hola, mundo!";
    std::cout << saludo << std::endl;
    return 0;
}

public class EjemploString
{
    public static void Main(string[] args)
    {
        string saludo = "Hola, mundo!";
        System.Console.WriteLine(saludo);
    }
}

saludo = "Hola, mundo!"

package main
 
import "fmt"
 
func main() {
    saludo := "Hola, mundo!"
    fmt.Println(saludo)
}

Operaciones Básicas Comunes con Cadenas de Texto:

Concatenación: Unir dos o más cadenas para formar una cadena más larga.
Longitud: Obtener el número de caracteres que contiene la cadena.
Acceso a caracteres: Obtener un carácter específico de la cadena según su posición (índice).
Búsqueda: Encontrar la posición de una subcadena dentro de la cadena.
Reemplazo: Sustituir una parte de la cadena por otra.
Conversión de caso: Cambiar la cadena a mayúsculas o minúsculas.
Dividir (Split): Dividir una cadena en una lista de subcadenas según un delimitador.
Eliminar espacios en blanco (Trim): Eliminar los espacios en blanco al principio y al final de la cadena.

saludo = "Hola, mundo!"
 
# Concatenación
saludo_completo = saludo + " ¡Bienvenido!"
print(f"Concatenación: {saludo_completo}")
 
# Longitud
longitud = len(saludo)
print(f"Longitud: {longitud}")
 
# Acceso a caracteres (indexación empieza en 0)
primer_caracter = saludo[0]
print(f"Primer carácter: {primer_caracter}")
 
# Búsqueda (devuelve el índice de la primera ocurrencia, -1 si no se encuentra)
indice_mundo = saludo.find("mundo")
print(f"Índice de 'mundo': {indice_mundo}")
 
# Reemplazo
nuevo_saludo = saludo.replace("mundo", "Python")
print(f"Reemplazo: {nuevo_saludo}")
 
# Conversión de caso
mayusculas = saludo.upper()
minusculas = saludo.lower()
print(f"Mayúsculas: {mayusculas}")
print(f"Minúsculas: {minusculas}")
 
# Dividir (por espacio)
palabras = saludo.split(" ")
print(f"Dividir: {palabras}")
 
# Eliminar espacios en blanco (no hay en este ejemplo, pero veamos cómo sería)
con_espacios = "   Hola   "
sin_espacios = con_espacios.strip()
print(f"Eliminar espacios: '{sin_espacios}'")

let saludo = "Hola, mundo!";
 
// Concatenación
let saludoCompleto = saludo + " ¡Bienvenido!";
console.log(`Concatenación: ${saludoCompleto}`);
 
// Longitud
let longitud = saludo.length;
console.log(`Longitud: ${longitud}`);
 
// Acceso a caracteres (indexación empieza en 0)
let primerCaracter = saludo[0];
console.log(`Primer carácter: ${primerCaracter}`);
 
// Búsqueda (devuelve el índice de la primera ocurrencia, -1 si no se encuentra)
let indiceMundo = saludo.indexOf("mundo");
console.log(`Índice de 'mundo': ${indiceMundo}`);
 
// Reemplazo
let nuevoSaludo = saludo.replace("mundo", "JavaScript");
console.log(`Reemplazo: ${nuevoSaludo}`);
 
// Conversión de caso
let mayusculas = saludo.toUpperCase();
let minusculas = saludo.toLowerCase();
console.log(`Mayúsculas: ${mayusculas}`);
console.log(`Minúsculas: ${minusculas}`);
 
// Dividir (por espacio)
let palabras = saludo.split(" ");
console.log(`Dividir: ${palabras}`);
 
// Eliminar espacios en blanco
let conEspacios = "   Hola   ";
let sinEspacios = conEspacios.trim();
console.log(`Eliminar espacios: '${sinEspacios}'`);

public class EjemploString {
    public static void main(String[] args) {
        String saludo = "Hola, mundo!";
 
        // Concatenación
        String saludoCompleto = saludo + " ¡Bienvenido!";
        System.out.println("Concatenación: " + saludoCompleto);
 
        // Longitud
        int longitud = saludo.length();
        System.out.println("Longitud: " + longitud);
 
        // Acceso a caracteres (indexación empieza en 0)
        char primerCaracter = saludo.charAt(0);
        System.out.println("Primer carácter: " + primerCaracter);
 
        // Búsqueda (devuelve el índice de la primera ocurrencia, -1 si no se encuentra)
        int indiceMundo = saludo.indexOf("mundo");
        System.out.println("Índice de 'mundo': " + indiceMundo);
 
        // Reemplazo
        String nuevoSaludo = saludo.replace("mundo", "Java");
        System.out.println("Reemplazo: " + nuevoSaludo);
 
        // Conversión de caso
        String mayusculas = saludo.toUpperCase();
        String minusculas = saludo.toLowerCase();
        System.out.println("Mayúsculas: " + mayusculas);
        System.out.println("Minúsculas: " + minusculas);
 
        // Dividir (por espacio)
        String[] palabras = saludo.split(" ");
        System.out.println("Dividir:");
        for (String palabra : palabras) {
            System.out.println(palabra);
        }
 
        // Eliminar espacios en blanco
        String conEspacios = "   Hola   ";
        String sinEspacios = conEspacios.trim();
        System.out.println("Eliminar espacios: '" + sinEspacios + "'");
    }
}

#include <iostream>
#include <string>
#include <algorithm> // Para transformar a mayúsculas/minúsculas
 
int main() {
    std::string saludo = "Hola, mundo!";
 
    // Concatenación
    std::string saludoCompleto = saludo + " ¡Bienvenido!";
    std::cout << "Concatenación: " << saludoCompleto << std::endl;
 
    // Longitud
    size_t longitud = saludo.length();
    std::cout << "Longitud: " << longitud << std::endl;
 
    // Acceso a caracteres (indexación empieza en 0)
    char primerCaracter = saludo[0];
    std::cout << "Primer carácter: " << primerCaracter << std::endl;
 
    // Búsqueda (devuelve la posición de la primera ocurrencia, std::string::npos si no se encuentra)
    size_t indiceMundo = saludo.find("mundo");
    std::cout << "Índice de 'mundo': " << indiceMundo << std::endl;
 
    // Reemplazo (requiere más código, aquí un ejemplo sencillo)
    std::string nuevoSaludo = saludo;
    size_t pos = nuevoSaludo.find("mundo");
    if (pos != std::string::npos) {
        nuevoSaludo.replace(pos, 5, "C++");
    }
    std::cout << "Reemplazo: " << nuevoSaludo << std::endl;
 
    // Conversión de caso
    std::string mayusculas = saludo;
    std::transform(mayusculas.begin(), mayusculas.end(), mayusculas.begin(), ::toupper);
    std::string minusculas = saludo;
    std::transform(minusculas.begin(), minusculas.end(), minusculas.begin(), ::tolower);
    std::cout << "Mayúsculas: " << mayusculas << std::endl;
    std::cout << "Minúsculas: " << minusculas << std::endl;
 
    // Dividir (requiere más lógica, no hay una función split directa estándar)
    // Ejemplo básico dividiendo por espacio:
    std::cout << "Dividir (ejemplo básico):" << std::endl;
    size_t start = 0;
    size_t end = saludo.find(" ");
    while (end != std::string::npos) {
        std::cout << saludo.substr(start, end - start) << std::endl;
        start = end + 1;
        end = saludo.find(" ", start);
    }
    std::cout << saludo.substr(start) << std::endl;
 
    // Eliminar espacios en blanco (requiere más lógica)
    std::string conEspacios = "   Hola   ";
    conEspacios.erase(0, conEspacios.find_first_not_of(" "));
    conEspacios.erase(conEspacios.find_last_not_of(" ") + 1);
    std::cout << "Eliminar espacios: '" << conEspacios << "'" << std::endl;
 
    return 0;
}

public class EjemploString
{
    public static void Main(string[] args)
    {
        string saludo = "Hola, mundo!";
 
        // Concatenación
        string saludoCompleto = saludo + " ¡Bienvenido!";
        System.Console.WriteLine($"Concatenación: {saludoCompleto}");
 
        // Longitud
        int longitud = saludo.Length;
        System.Console.WriteLine($"Longitud: {longitud}");
 
        // Acceso a caracteres (indexación empieza en 0)
        char primerCaracter = saludo[0];
        System.Console.WriteLine($"Primer carácter: {primerCaracter}");
 
        // Búsqueda (devuelve el índice de la primera ocurrencia, -1 si no se encuentra)
        int indiceMundo = saludo.IndexOf("mundo");
        System.Console.WriteLine($"Índice de 'mundo': {indiceMundo}");
 
        // Reemplazo
        string nuevoSaludo = saludo.Replace("mundo", "C#");
        System.Console.WriteLine($"Reemplazo: {nuevoSaludo}");
 
        // Conversión de caso
        string mayusculas = saludo.ToUpper();
        string minusculas = saludo.ToLower();
        System.Console.WriteLine($"Mayúsculas: {mayusculas}");
        System.Console.WriteLine($"Minúsculas: {minusculas}");
 
        // Dividir (por espacio)
        string[] palabras = saludo.Split(' ');
        System.Console.WriteLine("Dividir:");
        foreach (string palabra in palabras)
        {
            System.Console.WriteLine(palabra);
        }
 
        // Eliminar espacios en blanco
        string conEspacios = "   Hola   ";
        string sinEspacios = conEspacios.Trim();
        System.Console.WriteLine($"Eliminar espacios: '{sinEspacios}'");
    }
}

saludo = "Hola, mundo!"
 
# Concatenación
saludo_completo = saludo + " ¡Bienvenido!"
puts "Concatenación: #{saludo_completo}"
 
# Longitud
longitud = saludo.length
puts "Longitud: #{longitud}"
 
# Acceso a caracteres (indexación empieza en 0)
primer_caracter = saludo[0]
puts "Primer carácter: #{primer_caracter}"
 
# Búsqueda (devuelve el índice de la primera ocurrencia, nil si no se encuentra)
indice_mundo = saludo.index("mundo")
puts "Índice de 'mundo': #{indice_mundo}"
 
# Reemplazo
nuevo_saludo = saludo.gsub("mundo", "Ruby")
puts "Reemplazo: #{nuevo_saludo}"
 
# Conversión de caso
mayusculas = saludo.upcase
minusculas = saludo.downcase
puts "Mayúsculas: #{mayusculas}"
puts "Minúsculas: #{minusculas}"
 
# Dividir (por espacio)
palabras = saludo.split(" ")
puts "Dividir: #{palabras}"
 
# Eliminar espacios en blanco
con_espacios = "   Hola   "
sin_espacios = con_espacios.strip
puts "Eliminar espacios: '#{sin_espacios}'"

package main
 
import (
    "fmt"
    "strings"
)
 
func main() {
    saludo := "Hola, mundo!"
 
    // Concatenación
    saludoCompleto := saludo + " ¡Bienvenido!"
    fmt.Println("Concatenación:", saludoCompleto)
 
    // Longitud
    longitud := len(saludo)
    fmt.Println("Longitud:", longitud)
 
    // Acceso a caracteres (indexación empieza en 0, devuelve el código Unicode)
    primerCaracter := saludo[0]
    fmt.Println("Primer carácter (código Unicode):", primerCaracter)
    primerCaracterRune := rune(saludo[0]) // Obtener el rune (carácter)
    fmt.Printf("Primer carácter (rune): %c\n", primerCaracterRune)
 
    // Búsqueda (devuelve el índice de la primera ocurrencia, -1 si no se encuentra)
    indiceMundo := strings.Index(saludo, "mundo")
    fmt.Println("Índice de 'mundo':", indiceMundo)
 
    // Reemplazo
    nuevoSaludo := strings.ReplaceAll(saludo, "mundo", "Go")
    fmt.Println("Reemplazo:", nuevoSaludo)
 
    // Conversión de caso
    mayusculas := strings.ToUpper(saludo)
    minusculas := strings.ToLower(saludo)
    fmt.Println("Mayúsculas:", mayusculas)
    fmt.Println("Minúsculas:", minusculas)
 
    // Dividir (por espacio)
    palabras := strings.Split(saludo, " ")
    fmt.Println("Dividir:", palabras)
 
    // Eliminar espacios en blanco
    conEspacios := "   Hola   "
    sinEspacios := strings.TrimSpace(conEspacios)
    fmt.Println("Eliminar espacios:", sinEspacios)
}

Introduccion a las ciencias de la computacion