Introduccion a Rust
## Objetivos de Aprendizaje
- Comprender la historia y filosofia de Rust
- Configurar el entorno de desarrollo de Rust
- Escribir y ejecutar tu primer programa en Rust
- Comprender los fundamentos de la sintaxis de Rust
## Que es Rust?
Rust es un lenguaje de programacion de sistemas desarrollado por Mozilla. Enfatiza la seguridad, concurrencia y rendimiento sin requerir un recolector de basura.
```rust
fn main() {
println!("Hello, World!");
}
```
## Por que Rust?
### Caracteristicas Clave
- **Seguridad de Memoria** - El sistema de propiedad previene errores de memoria
- **Abstracciones Sin Costo** - Caracteristicas de alto nivel compilan a codigo eficiente
- **Concurrencia Sin Temor** - Prevencion de carreras de datos en tiempo de compilacion
- **Herramientas Modernas** - Gestor de paquetes Cargo, pruebas integradas
### Filosofia de Rust
1. Seguridad de memoria a traves de propiedad
2. Sin recoleccion de basura en runtime
3. Concurrencia sin miedo
4. Coincidencia de patrones e inferencia de tipos
## Instalando Rust
### Usando rustup
```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
### Verificar Instalacion
```bash
rustc --version
cargo --version
```
### Actualizar Rust
```bash
rustup update
```
## Tu Primer Programa
### Archivo: main.rs
```rust
fn main() {
println!("Hello, World!");
}
```
### Compilar y Ejecutar
```bash
rustc main.rs # Crea ejecutable 'main'
./main # Ejecuta el programa
```
O con Cargo:
```bash
cargo new hello_world
cd hello_world
cargo run
```
## Comandos de Cargo
| Comando | Descripcion |
|---------|-------------|
| cargo new | Crear nuevo proyecto |
| cargo build | Compilar proyecto |
| cargo run | Compilar y ejecutar |
| cargo test | Ejecutar pruebas |
| cargo doc | Generar documentacion |
| cargo build --release | Compilacion de lanzamiento |
## Estructura de un Programa Rust
```rust
fn main() { // Punto de entrada
// Las sentencias van aqui
let message = "Hello"; // Variable inmutable
println!("{}", message); // Imprimir linea
}
```
### Componentes
1. **fn** - Palabra clave para declarar funciones
2. **main** - Funcion de punto de entrada (sin argumentos, sin valor de retorno)
3. **println!** - Macro para imprimir con nueva linea
4. **Sentencias** - Comandos que terminan en punto y coma
## Comentarios
```rust
// Comentario de una sola linea
/*
* Comentario de
* multiples lineas
*/
/// Comentario de documentacion (para librerias)
/// # Ejemplos
/// ```
/// let x = 5;
/// ```
//! Comentario de documentacion interno (se aplica al elemento que encierra)
```
## Impresion y Formateo
```rust
fn main() {
// Impresion simple
println!("Hello");
// Impresion formateada
println!("Name: {}", "Alice");
println!("Age: {}", 30);
println!("{} + {} = {}", 2, 3, 5);
// Argumentos posicionales
println!("{0} is {1}, {0} is {2}", "Alice", 30, "human");
// Argumentos nombrados
println!("{name} is {age} years old", name = "Bob", age = 25);
// Trait Debug
println!("Debug: {:?}", (1, 2, 3));
// Alineacion y precision
println!("{:*<10}", "left"); // Alineado a la izquierda, ancho 10
println!("{:*>10}", "right"); // Alineado a la derecha, ancho 10
println!("{:.*}", 3, 3.14159); // 3 decimales
}
```
## Argumentos de Linea de Comandos
```rust
use std::env;
fn main() {
let args: Vec = env::args().collect();
if args.len() > 1 {
println!("Hello, {}!", args[1]);
} else {
println!("Hello, World!");
}
}
```
```bash
cargo run Alice
# Salida: Hello, Alice!
```
## Soporte de IDE
### IDEs Recomendados
- **VS Code** con extension rust-analyzer
- **IntelliJ Rust** (JetBrains)
- **Vim/Neovim** con coc-rust-analyzer
- **CLion** con plugin de Rust
## Ediciones de Rust
```bash
rustc --version # Verificar version instalada
```
| Edicion | Ano | Caracteristicas |
|---------|------|----------|
| Rust 2015 | 2015 | Primera edicion estable |
| Rust 2018 | 2018 | Async/await, revision de modulos |
| Rust 2021 | 2021 | Closures, cambios en prelude |
## Estructura del Proyecto Hello World
```text
hello_world/
├── Cargo.toml # Manifiesto del proyecto
└── src/
└── main.rs # Codigo fuente
```
### Cargo.toml
```toml
[package]
name = "hello_world"
version = "0.1.0"
edition = "2021"
[dependencies]
```
## Resumen
- Rust es un lenguaje de programacion de sistemas enfocado en seguridad
- Instalar via rustup: `curl https://sh.rustup.rs | sh`
- `cargo new` crea nuevos proyectos
- `cargo run` compila y ejecuta programas
- `println!` es una macro para imprimir
- Los comentarios usan `//` para una linea, `/* */` para multiples lineas
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →