El objetivo de este episodio es ofrecer una guía práctica para migrar scripts de Bash a Rust-script, destacando las diferencias clave en la gestión de estados, argumentos, validación, comandos, rutas, variables de entorno, generación de logs, lectura de archivos y concurrencia. Soy consciente que explicar este tema en un episodio es algo realmente complicado y difícil de seguir, por lo que he todos los ejemplos, los he dejado en las notas del episodio. De cualquier forma, como sabes me gustan los retos, esto es un auténtico reto, y difícil de conseguir. Así que vamos a ello.
Migra de Bash a Rust. Procesa millones de líneas en segundos
Gestión de estados y errores (status)
En Bash, dependemos de la inspección manual de la variable $?. En Rust, el manejo de errores es parte del flujo natural del código.
Bash (0_status.sh): Utiliza un bloque condicional if [ $? -ne 0 ] después de ejecutar mkdir para verificar si la operación falló.
Rust (0_status.rsc): El operador ? sustituye por completo al condicional de Bash. Si la función fs::create_dir falla, el script termina inmediatamente y propaga el error de forma automática.
Ventaja: El código es mucho más limpio y es imposible olvidar gestionar un error, ya que el compilador te obliga a manejar el tipo Result.
#!/bin/bash
# Intentamos crear un directorio
mkdir /root/test_dir 2>/dev/null
if [ $? -ne 0 ]; then
echo "Error: No se pudo crear el directorio."
exit 1
fi
echo "Directorio creado con éxito."
#!/usr/bin/env rust-script
use std::fs;
use std::io;
fn main() -> io::Result<()> {
// El operador '?' sustituye al 'if [ $? -eq 0 ]'
// Si mkdir falla, el script termina aquí y devuelve el error
fs::create_dir("/root/test_dir")?;
println!("Directorio creado con éxito.");
Ok(())
}
Paso de argumentos
Bash trata todo como cadenas de texto, lo que obliga a validaciones manuales complejas. Rust ofrece seguridad de tipos desde el primer momento.
Bash (1_argumentos.sh): Requiere comprobar el número de argumentos ($#) y usar expresiones regulares para validar que un argumento sea un número antes de usarlo en un bucle.
Rust (1_argumentos.rsc): Utiliza iteradores para extraer valores (args.next()). Al usar .parse()?, Rust realiza la conversión a un tipo numérico y la validación de errores en un solo paso.
Ventaja: Evitas errores en tiempo de ejecución causados por datos mal formados, capturándolos en el momento del parseo.
#!/bin/bash
# Comprobar si hay suficientes argumentos
if [ "$#" -ne 2 ]; then
echo "Uso: $0 <nombre> <repeticiones>"
exit 1
fi
NOMBRE=$1
REPETICIONES=$2
# Validar si es un número (Bash no tiene tipos, hay que usar Regex o trucos)
if ! [[ "$REPETICIONES" =~ ^[0-9]+$ ]]; then
echo "Error: $REPETICIONES no es un número válido"
exit 1
fi
for i in $(seq 1 $REPETICIONES); do
echo "Hola $NOMBRE, esta es la vez $i"
done
#!/usr/bin/env rust-script
use std::env;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut args = env::args().skip(1); // Saltamos el nombre del script
// Extraemos los valores o lanzamos error si faltan
let nombre = args.next().ok_or("Falta el argumento: <nombre>")?;
let repeticiones: u32 = args.next()
.ok_or("Falta el argumento: <repeticiones>")?
.parse()?;
for i in 1..=repeticiones {
println!("{i}.- Hola {nombre}");
}
Ok(())
}
Validación
La validación en Rust es semántica y exhaustiva, a diferencia de los condicionales lógicos de Bash.
Bash (2_validacion.sh): Combina Regex con operadores lógicos (&&) para validar rangos numéricos.
Rust (2_validacion.rsc): Utiliza match para validar el parseo y el rango matemático de forma simultánea.
Ventaja: El Pattern Matching permite cubrir todos los casos posibles de forma explícita, mejorando la legibilidad y seguridad del script.
#!/bin/bash
EDAD=$1
if [[ "$EDAD" =~ ^[0-9]+$ ]] && [ "$EDAD" -ge 0 ] && [ "$EDAD" -le 120 ]; then
echo "Edad válida"
else
echo "Entrada inválida"
fi
#!/usr/bin/env rust-script
fn main() {
let entrada = "25"; // Vendría de un argumento
// El parseo ya descarta texto no numérico.
// Luego validamos el rango de forma matemática.
match entrada.parse::<u8>() {
Ok(edad) if (0..=120).contains(&edad) => println!("Edad válida: {edad}"),
_ => eprintln!("Error: La edad debe ser un número entre 0 y 120"),
}
}
Comandos
Capturar la salida de un comando externo requiere transformar bytes en texto con sentido.
Bash (3_comando.sh): La sintaxis $(…) captura la salida y elimina el salto de línea automáticamente.
Rust (3_comando.rsc): Utiliza Command::new().output()? para ejecutar el proceso. Es necesario convertir explícitamente los bytes (u8) a String y usar .trim() para igualar el comportamiento de Bash.
Ventaja: Rust es más seguro frente a inyecciones de comandos, ya que separa el ejecutable de los argumentos.
#!/bin/bash
# Captura la salida (quita el \n automáticamente)
FECHA=$(date +%Y-%m-%d)
# Imprime el resultado
echo "Hoy es: $FECHA"
#!/usr/bin/env rust-script
use std::process::Command;
fn main() -> Result<(), Box<dyn std::error::Error>> {
// 1. Ejecutamos y capturamos (equivalente a $(...))
let salida = Command::new("date").arg("+%Y-%m-%d").output()?;
// 2. Convertimos bytes a String y limpiamos el \n final (como hace Bash)
let fecha = String::from_utf8(salida.stdout)?.trim().to_string();
// 3. Imprimimos (equivalente a echo)
println!("Hoy es: {fecha}");
Ok(())
}
Rutas
Bash trata las rutas como simples cadenas, lo que causa errores críticos si existen espacios. Rust utiliza objetos con conciencia estructural.
Bash (5_rutas.sh): Requiere un uso meticuloso de comillas dobles («$RUTA») para evitar que el intérprete divida la ruta al encontrar espacios.
Rust (5_rutas.rsc): Utiliza PathBuf, que gestiona la construcción de la ruta de forma interna y añade los separadores necesarios automáticamente.
Ventaja: Eliminas errores accidentales por nombres de archivos «extraños» y aseguras que el script funcione correctamente en diferentes sistemas operativos.
#!/bin/bash
DIR="mi carpeta con espacios"
FICHERO="notas.txt"
# Si olvidas las comillas en "$DIR/$FICHERO", el script falla
RUTA="$DIR/$FICHERO"
touch "$RUTA"
#!/usr/bin/env rust-script
use std::path::PathBuf;
fn main() {
let mut ruta = PathBuf::from("mi carpeta con espacios");
ruta.push("notas.txt"); // Añade la barra / automáticamente
println!("Ruta lista para usar: {}", ruta.display());
}
Variables de entorno
La gestión de valores por defecto es más legible y menos propensa a errores sintácticos en Rust.
Bash (6_variables_entorno.sh): Emplea la expansión de parámetros ${VARIABLE:-default}, una sintaxis potente pero críptica para usuarios noveles.
Rust (6_variables_entorno.rsc): Usa env::var().unwrap_or_else(), un método que define claramente qué hacer si la variable no existe.
Ventaja: El código se vuelve autodocumentado y facilita la depuración de configuraciones faltantes.
#!/bin/bash
# Sintaxis críptica para el usuario medio
LOG_LEVEL=${LOG_LEVEL:-"info"}
echo "Nivel de log: $LOG_LEVEL"
#!/usr/bin/env rust-script
use std::env;
fn main() {
// Intentamos leer la variable, si no existe o es inválida, usamos el default
let log_level = env::var("LOG_LEVEL").unwrap_or_else(|_| "info".into());
println!("Nivel de log: {log_level}");
}
Generar un log
import random
import time
from datetime import datetime
# Configuración
FILENAME = "access_log.txt"
LINES_COUNT = 2000000
# Datos para aleatoriedad
LOG_LEVELS = ["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"]
IPS = [f"192.168.1.{i}" for i in range(1, 255)]
MESSAGES = [
"User logged in successfully",
"Failed login attempt",
"Database connection established",
"Timeout waiting for response",
"File uploaded: /uploads/image.png",
"Disk usage above 80%",
"API request received: GET /v1/users",
"Session expired for user_id: 4502"
]
def generate_logs():
print(f"Generando {LINES_COUNT} líneas en '{FILENAME}'...")
start_time = time.time()
with open(FILENAME, "w", encoding="utf-8") as f:
for _ in range(LINES_COUNT):
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
level = random.choice(LOG_LEVELS)
ip = random.choice(IPS)
msg = random.choice(MESSAGES)
# Formato: [TIMESTAMP] [LEVEL] IP: MESSAGE
f.write(f"[{timestamp}] [{level}] {ip}: {msg}\n")
end_time = time.time()
print(f"¡Listo! Tiempo transcurrido: {end_time - start_time:.2f} segundos.")
if __name__ == "__main__":
generate_logs()
#!/usr/bin/env rustscript
//! ``cargo
//! [dependencies]
//! rand = "0.8"
//! chrono = "0.4"
//! ``
use std::fs::File;
use std::io::{BufWriter, Write};
use std::time::Instant;
use rand::seq::SliceRandom; // Necesitas la crate 'rand'
fn main() -> std::io::Result<()> {
let path = "access_log.txt";
let num_lines = 2_000_000;
// Datos aleatorios
let levels = ["INFO", "DEBUG", "WARNING", "ERROR", "CRITICAL"];
let ips = ["192.168.1.10", "10.0.0.5", "172.16.0.20", "192.168.1.50"];
let messages = [
"User logged in successfully",
"Failed login attempt",
"Database connection established",
"Timeout waiting for response",
"Disk usage above 80%",
];
let start = Instant::now();
let file = File::create(path)?;
let mut writer = BufWriter::new(file);
let mut rng = rand::thread_rng();
for _ in 0..num_lines {
let level = levels.choose(&mut rng).unwrap();
let ip = ips.choose(&mut rng).unwrap();
let msg = messages.choose(&mut rng).unwrap();
// Usamos writeln! para agregar el salto de línea automáticamente
writeln!(
writer,
"[{:?}] [{}] {}: {}",
chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
level,
ip,
msg
)?;
}
// Asegurar que todo se escriba al disco
writer.flush()?;
let duration = start.elapsed();
println!("¡Listo! 100,000 líneas generadas en {:?}", duration);
Ok(())
}
Leer archivos
Cuando pasas de miles a millones de líneas, la velocidad y la gestión de memoria de Rust no tienen competencia.
Bash (8_leer_archivo.sh): El bucle while read es extremadamente lento para procesar millones de líneas, ya que invoca procesos internos en cada iteración.
Rust (8_leer_archivo.rsc): Utiliza BufReader, que lee el archivo en bloques (buffers), permitiendo un procesamiento casi instantáneo sin saturar la RAM.
Ventaja: Una tarea que en Bash puede tardar minutos, en Rust se completa en segundos, permitiendo scripts de mantenimiento mucho más ambiciosos.
#!/bin/bash
while IFS= read -r linea; do
if [[ "$linea" == *"ERROR"* ]]; then
echo "Cuidado: $linea"
fi
done < access_log.txt
#!/usr/bin/env rust-script
use std::fs::File;
use std::io::{self, BufRead};
fn main() -> io::Result<()> {
let archivo = File::open("access_log.txt")?;
let lector = io::BufReader::new(archivo);
for linea in lector.lines() {
let l = linea?; // Manejo de error si la línea es corrupta
if l.contains("ERROR") {
println!("Cuidado: {l}");
}
}
Ok(())
}
Hilos y concurrencia
Paralelizar tareas es el punto donde Rust ofrece una arquitectura de ingeniería superior.
Bash (9_hilos.sh): Lanza procesos al fondo con & y usa wait para sincronizar. El problema es que lanza 50 procesos ping pesados simultáneamente sin control de recursos.
Rust (9_hilos.rsc): Crea hilos ligeros del sistema con thread::spawn y utiliza move para transferir la propiedad de los datos de forma segura. Finalmente, sincroniza todo con .join().
Ventaja: Tienes un control total sobre el ciclo de vida de cada hilo y evitas la saturación de procesos que podría causar una «fork bomb» accidental en Bash si la lista de servidores creciera masivamente.
#!/bin/bash
SERVIDORES=(
"google.com" "github.com" "atareao.es" "rust-lang.org" "linux.org"
"debian.org" "archlinux.org" "ubuntu.com" "fedora.org" "kernel.org"
"duckduckgo.com" "bing.com" "yahoo.com" "wikipedia.org" "wikimedia.org"
"youtube.com" "vimeo.com" "twitch.tv" "netflix.com" "spotify.com"
"amazon.com" "ebay.com" "aliexpress.com" "microsoft.com" "apple.com"
"facebook.com" "instagram.com" "twitter.com" "linkedin.com" "reddit.com"
"cloudflare.com" "digitalocean.com" "linode.com" "hetzner.com" "ovh.com"
"docker.com" "kubernetes.io" "ansible.com" "terraform.io" "gitlab.com"
"stackoverflow.com" "medium.com" "dev.to" "hackernews.com" "slashdot.org"
"nytimes.com" "bbc.com" "elpais.com" "elmundo.es" "nasa.gov"
)
comprobar_ping() {
if ping -c 1 -W 1 "$1" > /dev/null 2>&1; then
echo "✅ $1 está vivo"
else
echo "❌ $1 está caído"
fi
}
echo "Lanzando ${#SERVIDORES[@]} comprobaciones al fondo..."
for ip in "${SERVIDORES[@]}"; do
# Lanzamos en segundo plano con &
comprobar_ping "$ip" &
done
# Esperamos a que todos los procesos hijos terminen
wait
echo "Monitorización finalizada."
#!/bin/bash
SERVIDORES=(
"google.com" "github.com" "atareao.es" "rust-lang.org" "linux.org"
"debian.org" "archlinux.org" "ubuntu.com" "fedora.org" "kernel.org"
"duckduckgo.com" "bing.com" "yahoo.com" "wikipedia.org" "wikimedia.org"
"youtube.com" "vimeo.com" "twitch.tv" "netflix.com" "spotify.com"
"amazon.com" "ebay.com" "aliexpress.com" "microsoft.com" "apple.com"
"facebook.com" "instagram.com" "twitter.com" "linkedin.com" "reddit.com"
"cloudflare.com" "digitalocean.com" "linode.com" "hetzner.com" "ovh.com"
"docker.com" "kubernetes.io" "ansible.com" "terraform.io" "gitlab.com"
"stackoverflow.com" "medium.com" "dev.to" "hackernews.com" "slashdot.org"
"nytimes.com" "bbc.com" "elpais.com" "elmundo.es" "nasa.gov"
)
# Definimos la lógica en una función
comprobar_ping() {
if ping -c 1 -W 1 "$1" > /dev/null 2>&1; then
echo "✅ $1 está vivo"
else
echo "❌ $1 está caído"
fi
}
# Exportamos la función para que parallel la reconozca
export -f comprobar_ping
# Ejecutamos en paralelo
# ::: pasa los elementos del array como argumentos
printf "%s\n" "${SERVIDORES[@]}" | parallel comprobar_ping
#!/usr/bin/env rust-script
use std::process::Command;
use std::thread;
fn main() {
let servidores = vec![
"google.com", "github.com", "atareao.es", "rust-lang.org", "linux.org",
"debian.org", "archlinux.org", "ubuntu.com", "fedora.org", "kernel.org",
"duckduckgo.com", "bing.com", "yahoo.com", "wikipedia.org", "wikimedia.org",
"youtube.com", "vimeo.com", "twitch.tv", "netflix.com", "spotify.com",
"amazon.com", "ebay.com", "aliexpress.com", "microsoft.com", "apple.com",
"facebook.com", "instagram.com", "twitter.com", "linkedin.com", "reddit.com",
"cloudflare.com", "digitalocean.com", "linode.com", "hetzner.com", "ovh.com",
"docker.com", "kubernetes.io", "ansible.com", "terraform.io", "gitlab.com",
"stackoverflow.com", "medium.com", "dev.to", "hackernews.com", "slashdot.org",
"nytimes.com", "bbc.com", "elpais.com", "elmundo.es", "nasa.gov"
];
let mut hilos = vec![];
for ip in servidores {
// Creamos un hilo por cada IP
let hilo = thread::spawn(move || {
let status = Command::new("ping")
.args(["-c", "1", "-W", "1", ip])
.stdout(std::process::Stdio::null()) // Silenciamos la salida
.stderr(std::process::Stdio::null())
.status();
match status {
Ok(s) if s.success() => println!("✅ {ip} está vivo"),
_ => println!("❌ {ip} está caído o no responde"),
}
});
hilos.push(hilo);
}
// El "colofón": esperar a que todos terminen antes de cerrar el script
for h in hilos {
let _ = h.join();
}
println!("Monitorización finalizada.");
}
#!/usr/bin/env rust-script
//! ``cargo
//! [dependencies]
//! rayon = "1.8"
//! ``
use rayon::prelude::*;
use std::process::Command;
use std::process::Stdio;
fn main() {
let servidores = vec![
"google.com", "github.com", "atareao.es", "rust-lang.org", "linux.org",
"debian.org", "archlinux.org", "ubuntu.com", "fedora.org", "kernel.org",
"duckduckgo.com", "bing.com", "yahoo.com", "wikipedia.org", "wikimedia.org",
"youtube.com", "vimeo.com", "twitch.tv", "netflix.com", "spotify.com",
"amazon.com", "ebay.com", "aliexpress.com", "microsoft.com", "apple.com",
"facebook.com", "instagram.com", "twitter.com", "linkedin.com", "reddit.com",
"cloudflare.com", "digitalocean.com", "linode.com", "hetzner.com", "ovh.com",
"docker.com", "kubernetes.io", "ansible.com", "terraform.io", "gitlab.com",
"stackoverflow.com", "medium.com", "dev.to", "hackernews.com", "slashdot.org",
"nytimes.com", "bbc.com", "elpais.com", "elmundo.es", "nasa.gov"
];
println!("Iniciando comprobación paralela con Rayon de {} servidores...", servidores.len());
// AQUÍ ESTÁ LA MAGIA: .into_par_iter() en lugar de .into_iter()
servidores.into_par_iter().for_each(|ip| {
let status = Command::new("ping")
.args(["-c", "1", "-W", "1", ip])
.stdout(Stdio::null())
.stderr(Stdio::null())
.status();
match status {
Ok(s) if s.success() => println!("✅ {ip} está vivo"),
_ => println!("❌ {ip} está caído o no responde"),
}
});
println!("Monitorización finalizada en tiempo récord.");
}
Comparativa
Característica
Bash
Rust-script
Por qué ganarás
Manejo de Errores
Inspección manual de la variable $?
Uso del operador ? y tipo Result
El script se detiene ante errores automáticamente, evitando fallos en cadena.
Paso de Argumentos
Validación manual con expresiones regulares
Tipado fuerte y método .parse()
Aseguras que los datos de entrada (como números) son válidos antes de procesarlos.
Lógica de Datos
Condicionales if/else y lógica de texto
match y Pattern Matching exhaustivo
Cubres todos los casos posibles (rangos, errores) de forma explícita y legible.
Captura de Salida
Captura implícita y limpieza con $(...)
Control manual de stdout y bytes
Control total sobre la codificación (UTF-8) y el tratamiento de la salida del sistema.
Consumo de APIs
Dependencia externa de herramientas como jq
Serialización integrada con serde_json
Script autocontenido; procesas datos JSON de forma segura sin fallos silenciosos.
Gestión de Rutas
Concatenación de cadenas de texto
Uso de objetos PathBuf
Evitas que un espacio en un nombre de archivo rompa la lógica del script.
Variables de Entorno
Expansión de parámetros ${VARIABLE:-default}
Métodos funcionales Result / Option
El código explica por sí mismo qué ocurre si la configuración no existe.
Escritura Masiva
Redirecciones de shell (>>) o echo
BufWriter para escritura en bloques
Generación de millones de líneas con rendimiento profesional y bajo consumo.
Lectura de Archivos
Bucle while read (lento en archivos grandes)
BufReader para lectura eficiente
Procesas archivos de logs de Gigabytes en segundos sin saturar la memoria RAM.
Concurrencia
Procesos al fondo mediante & y wait
Hilos nativos seguros con std::thread
Ejecución de tareas paralelas (como pings) de forma coordinada, rápida y segura.
Hola soy lorenzo y esto es atareado con Linux episodio número 763 en el episodio 761 te,
Hablé de por qué o qué razones había para hacer determinados scripts en rast script en,
Verde en base en este episodio pues te voy a dar algunas pautas algunas ideas algunos conceptos,
Para que esa migración ese cambio de bus a rast script sea sencillo y tenga y tenga sentido quiero,
Decir al final hay determinados aspectos por los que un script debería de continuar siendo estando,
Implementado en bus y otros scripts pues tienen más sentido que estén por ejemplo en rast script en,
Python o como tú quieras pero lo que está claro es que hay determinadas ideas determinadas determinados,
Conceptos que sí que deberías de aplicar con independencia de la longitud o de la complejidad,
Del script al que te vayas a enfrentar así en este episodio te voy a intentar dar algunas ideas,
Algunos tips sobre esos 10 puntos para realizar la migración de bus a rast script y tómatelo como,
Eso como simplemente puntos ideas conceptos que deberías de aplicar o la solución que puedes,
Utilizar para esto en lugar de continuar con base así que me voy a enfrentar a un episodio realmente,
Complejo porque contar todo esto pues no te creas que tiene su miga y esperemos que consiga retenerte,
Por lo menos hasta el minuto 3 o el minuto 4 va a ser algo complejo pero como te digo al final me,
Gustan los retos y me gustan las cosas realmente complicadas así que vamos directos al turrón en,
Este episodio te voy a hablar sobre una guía de migración de bus a rast y empiezo pues empiezo por bueno,
Lo primero y principal en este episodio he conseguido incorporar o reincorporar la música de entrada y,
Salida en otros episodios en los últimos dos o tres episodios por por lo que fuera bueno por lo,
Que fuera no porque lo tenía muteado pues por eso no salía pero bueno aquí ya está así que como te,
Digo vamos vamos al lío y lo primero es pues la gestión de estados y errores en cualquier script al,
Final muchas de las operaciones que haces deber de comprobar si esa operación se ha realizado de,
Forma correcta o no se ha realizado de forma correcta por ejemplo cuando creas un directorio,
Pues es interesante darle feedback al usuario y decirle oye que el directorio se ha creado y si,
No se ha creado porque no se ha creado esto por ponerte un ejemplo no pero valdría para cualquier,
Otro comando que quieras ejecutar ya sea una ejecución o simplemente como te digo crear un directorio,
Qué es lo que sucede bueno pues lo que sucede es que habitualmente para este tipo de cosas pues,
Tienes que utilizar en base un condicional es decir utilizas el dólar interrogante para saber si el,
Resultado es un cero que entonces el resultado del script en base es correcto y si no pues ya sabes que,
Que el ha sido ha sido fallo en en rast esto es completamente distinto porque bueno completamente,
Distinto no pero en rast lo que tienes es el operador interrogante y ese operador interrogante,
Realmente simplifica mucho las operaciones simplemente con que tú le digas crear un directorio,
Él al final te va a generar un o sea una vez ha ejecutado ese comando lo que genera es una estructura,
De tipo result o mejor dicho un en una enumeración de tipo result que puede ser ok o error en el caso,
De que sea ok pues ya lo tienes claro en el caso de que sea error también lo tienes claro entonces lo,
Que antes se había convertido en un condicional aquí en este caso es simplemente un operador con lo,
Cual realmente las estructuras quedan súper sencillas independientemente con esto si comparas uno con el,
Otro que te digo que están todos los ejemplos que de los que voy a hablar en este episodio están en,
Las notas del episodio además con una comparativa al final de todas las cosas para que te quede claro,
Bueno si comparas una cosa con la otra verás que prácticamente son exactamente lo mismo que no hemos,
Ahorrado ni siquiera una línea y sin embargo si te fijas se simplifica considerablemente una operación a,
Otra luego al final esto es tan sencillo como ejecutarlo si ejecutas en el archivo el status como,
Le he llamado status sh pues te va a decir que no se puede crear el directorio porque ya lo he hecho,
Para que no se pueda crear y si lo ejecutas en rast lo que te dice es más información no solamente te dice,
Que te ha dado un error sino que además te dice que no tienes permiso para hacerlo esto sería la,
Gestión de estados es decir saber el resultado de una determinada operación otra de las cosas que,
Habitualmente vas a tener que hacer es pasar argumentos sí que hay comandos como por ejemplo,
Cd que no necesita bueno cd justo también necesita un argumento y eco también bueno en fin que para,
Cualquier comando para cualquier script o sea hay script que no necesitan que le pases ningún tipo de,
Argumento pero normalmente por lo general lo habitual es que le tengas que pasar algún tipo de,
Argumento por ejemplo si lo que quieres es hacer un repetir una palabra un número de veces pues,
Tienes que pasarle dos argumentos el lo que quieres repetir y el número de veces que lo quieres,
Repetir esto en el caso de de bus es realmente sencillo y en el caso de rast también,
En el caso de rast para el paso de argumentos,
Y en el caso de rast para el paso de argumentos la cuestión es que,
Es bastante como te digo es bastante sencillo de hacer simplemente en el caso de bus lo que vas a,
Hacer primero preguntarle cuántos argumentos tienes y en caso de que no tengas suficientes argumentos vas a,
Lanzar un mensaje de error y luego tienes que comprobar que el número de repeticiones es un,
Número o sea un entero o mejor dicho cumple una expresión regular del tipo que lo que le estás,
Pasando son números del cero al lo que sea y claro y si no has metido el nombre también va a dar un error,
Vale entonces lo primero que te encuentras aquí es que te tienes que pelear con las expresiones,
Regulares para verificar que los parámetros que le estás pasando son correctos luego tienes que,
Utilizar otra vez el tema de los condicionales de los que ya he hablado en el en la sección anterior,
En el sentido de que vas a tener que utilizar un condicional preguntarle si si el resultado es,
Correcto si no es correcto en fin todo ese tipo de operaciones de nuevo aquí hacemos uso,
Básicamente del operador interrogante que lo que nos va a permitir es precisamente ahorrarnos,
Condicionales básicamente si miras si comparas una cosa con la otra si comparas el script en,
Bus con el script en rush script lo que te vas a encontrar en el de bus son dos condicionales,
Mientras que en el caso del rush script lo que te vas a encontrar son dos dos como te diría dos,
Instrucciones claras no le pasas por un lado intentas obtener el nombre y en caso de que no lo encuentres,
Directamente te va a decir oye no encuentro el nombre y luego cuando le pases el número de repeticiones,
Lo va a intentar convertir directamente a un entero y en caso de que no lo pueda convertir a un entero,
Te va a decir también el error y si falta el argumento también te lo va a decir,
Luego el bucle prácticamente es lo mismo en uno y otro pero la simplicidad con la que se compara,
Una cosa con la otra pues lo cierto es que cuando lo miras de un solo vistazo ya tienes claro qué es,
Lo que está haciendo uno y el otro es un poquito más complejo repito al final todo esto son cosas que,
Simplemente las vas a ver un poco o sea me refiero que si comparas estos dos scripts vas a decir hombre,
Pues tampoco nos ahorramos tanto entre uno y el otro pero luego a la hora de mantener este que,
Tenerlo en cuenta y al final estos son solamente tips de cómo deberías de hacerlo para cuando tienes,
Que pasar muchos más variables por ejemplo en este caso simplemente hemos pasado un par de variables pero,
Si tienes que pasar más probablemente para el caso de que tengas que pasar muchas más variables ahí lo que,
Tenga sentido es utilizar algún tipo de crate que te permita hacer esto de una manera mucho más sencilla,
Pero bueno esto es para que te hagas al final como te digo una idea luego el siguiente,
El siguiente de los de las de las cuestiones hemos visto los estados los argumentos ahora tocaría,
Lo que son las validaciones las validaciones tanto en rast como en vash entonces para el tema de las validaciones por ejemplo vamos a hacer una validación que sea muy sencilla no simplemente vamos a preguntar una edad entonces para comprobar que esa edad es válida pues lo que,
Es lo que tienes que hacer primero tienes que asegurar que el parámetro que le has pasado es un número entero,
Luego estamos preguntando por una edad con lo cual la edad tiene que ser por lo menos mayor o sea como mínimo tiene que ser mayor de cero y luego por otro lado también pues deberíamos de mirar por la parte superior,
Es decir por ejemplo que no nos pongamos más de 120 años por ejemplo esto por decirte cómo se resuelve esto pues esto se resuelve básicamente con una expresión regular y con un par de condiciones adicionales,
De nuevo entramos en el mundo de las expresiones regulares que como bien sabes es un mundo bastante tenebroso para mucha gente,
En el caso de rast script la cosa se simplifica bastante porque aquí lo primero que haces es un parseo de manera que si lo que le estás enviando ya no es un número te va a dar un error,
Lo siguiente es que si como le estás paseando como un número entero si es un número que no es que es negativo ya te va a dar otro error,
Y además lo valida contra que sea entre cero y 120 y ahí ya lo tienes completamente resuelto de nuevo es simplemente,
Una operación de matcheo que a mí inicialmente cuando empecé con todo esto me parecía algo un poco complejo pero actualmente bueno,
Es muy cómodo trabajar con ello lo siguiente va a ser los comandos,
Para el tema de los comandos simplemente esta es otra de las operaciones habituales que se suelen hacer el tema de los comandos es lo más normal,
Que tengas que hacer así para el tema de los comandos lo primero evidentemente es en el caso de bash por ejemplo yo he hecho,
Un ejemplo muy claro que es ejecutar un date que es realmente sencillo de hecho si miras el script en bash vas a decir,
Ostras pero si es que es mucho más sencillo que hacerlo en bash que en rast script,
En bash tienes que utilizar la estructura del tipo dólar y paréntesis para capturar la salida y eliminar el salto de línea,
Mientras que en rast script utilizas una herramienta que se llama command y con command y output ejecutas y extraes el proceso,
Además es necesario convertir de manera explícita los bytes a string y además hacer un trim para igualar exactamente el comportamiento,
¿Qué ventaja tienes con toda esta parafernalia que hemos montado simplemente al pasar de bash a rast script.
Bueno rast script es mucho más seguro en inyecciones de comandos ya que separa el ejecutable de los argumentos,
Aquí no le puedes pasar no le puedes pasar todo de golpe sino que tienes que hacer las cosas con bastante más detalle,
Y esto pues al final te permite tener un control mucho más exhaustivo de lo que vas a hacer,
Eso del tema de los comandos la siguiente sería el talón de Aquiles de bash que no es ni más ni menos que jason,
Y digo que no es ni más ni menos que jason porque al final uno de los grandes problemas que tienes con,
Con con con bash es pelearte exactamente con con las estructuras con los jason con los jammel con los xml,
Y aquí tienes un problema en el caso particular de rast la gran ventaja que tienes es que todo este tipo de cosas,
Ya las puedes tratar directamente en el ejemplo que he puesto estoy utilizando por un lado en el tema de bash,
Estoy utilizando curl aparte de curl evidentemente tenemos que poner un if para verificar que el resultado que obtenemos,
Es un resultado correcto si no deberíamos dar un error de red luego tenemos que pasar la respuesta que hemos obtenido,
Por jq para obtener la ip y luego preguntarle a o verificar que la respuesta es correcta,
En el sentido de que la respuesta no está vacía y la respuesta no es un null y ya daríamos el resultado correcto,
Con lo cual como te digo tienes por un lado el comando o la llamada que haces las dos condicionales,
Y con esto pues obtendrías el resultado aquí ya vemos la primera de las grandes ventajas que te ofrece,
Rast script para este tipo de cosas la primera es que directamente vas con un crate vas a hacer la llamada,
No tienes que utilizar una herramienta externa y luego directamente ya lo conviertes en un valor de tipo json,
Y a partir de aquí lo único que tienes que hacer es extraer la ip y mostrar el valor,
¿Y por qué digo que se simplifica todo? pues de nuevo aquí viene la magia del operador interrogante,
Con el operador interrogante lo que vas a hacer es que cada vez que se produzca un error directamente lo vas a sacar por pantalla,
Tanto en el caso de que haya un problema para hacer la llamada como que la llamada te dé un error,
Que lo que te devuelva no es correcto igual que cuando hagas la conversión,
Si conviertes cuando lo conviertes si no has encontrado el campo ip te va a dar un error,
Y todo esto lo tienes en dos líneas incluso todavía podríamos resumirlo más,
Pero vamos que con dos líneas lo tienes perfectamente y es realmente interesante,
Lo siguiente y evidentemente necesario son las variables de entorno,
En el caso de las variables de entorno estamos en las mismas,
Aquí para el tema de las variables de entorno cuando tienes que utilizar variables de entorno,
Por defecto pues ahí te puedes encontrar con una sintaxis que normalmente es bastante críptica,
Es bastante extraña para el usuario normal para bueno para el usuario habitual para quiero decir,
Si ya estás acostumbrado a utilizar vas para hacer scripting en vas pues probablemente no tengas ningún tipo de problema,
Pero si no seguro que aquí te vas a encontrar más de una más de una sorpresa,
Y luego por otro lado en el caso de de rast script es realmente muy sencillo,
Porque aquí lo que haces como de costumbre es tirar de el de del estándar env,
Y luego preguntas si ha conseguido obtener el valor,
Y si no ha obtenido conseguido si no ha obtenido el valor,
Directamente utiliza por ejemplo info que es lo que yo estaba probando,
Con lo cual con esto queda muy claro quiero decir que al final es bastante verboso,
Si se le puede decir de esa manera la manera de mostrarte valga la redundancia,
La manera de devolverte el valor que necesitas,
Lo siguiente y algo habitual que hacemos son trabajar con rutas,
Es decir simplemente me refiero a trabajar con rutas a mostrarte los valores de algunas,
Por ejemplo si quieres ver o si quieres por ejemplo crear un archivo en un directorio concreto,
Por ejemplo si tienes una carpeta que se llame mi carpeta con espacios,
E intentas crearla en bus sabes perfectamente que tienes que tener un excesivo,
O mejor dicho un cuidado riguroso con las dobles comillas,
Porque si no utilizas bien las dobles comillas lo que te puedes llevar la sorpresa,
De que aquello en lugar de hacerte un directorio te hace tres o cuatro directorios,
O vete a saber lo que hace,
Por contra en el caso particular de rast script,
Pues evidentemente lo primero es que tiene en cuenta los espacios,
Porque al contrario de lo que sucede con bus,
Que todo se considera como texto,
Aquí lo has convertido ya a una ruta,
Cuando añades nuevas cosas a la ruta directamente añade la barra automáticamente,
Con lo cual todas estas ventajas las tienes incorporadas,
Digamos que en este caso es bastante más seguro,
O bastante más sencillo gestionar rutas en rast script que con simplemente bus,
Ahora nos tocaría el tema de,
Bueno realmente lo que quería hacer ahora es mostrarte como se lee un archivo grande,
Pero para esto lo que he hecho ha sido primero,
Generar un archivo,
Antes de leerlo generar un archivo de varios millones de líneas,
En concreto de dos millones de líneas,
Y tú dirás ¿por qué has generado un archivo tan grande,
Bueno pues porque quería mostrarte realmente lo rápido,
Comparado con bus,
Que es trabajar con rast script,
Para generar ese archivo lo que he hecho ha sido hacerlo en rast script,
Por un lado y también lo he hecho en python,
No lo he hecho en bus,
Simplemente por comodidad ¿vale,
Porque ya es un pelín más complejo,
Y tampoco me ha querido complicar mucho la vida,
No te creas,
Al final se trata de un script que utiliza,
Rant para generar de forma completamente aleatoria,
Las líneas y luego un command,
El create chrono para el tema de los tiempos,
Este simplemente lo he dejado un poco para que te hagas una idea de,
Cómo sería hacer lo mismo en rast que en python,
Y luego está la operación de leer archivos,
Para leer archivos,
Para leer archivos,
Estamos en las mismas,
Cuando ves el script en bus,
Dices ostras es que es súper sencillo leer miles de líneas en bus,
Y si lo comparas con rast script pues,
Tienes que importar determinadas herramientas,
Tienes que hacer determinadas operaciones,
Y puedes llegar a pensar que es un poco más complejo,
Sin embargo la cosa cambia sensiblemente cuando lo ejecutas,
Si ejecutas el leer archivos en bus,
Bus 8 leer archivos sh,
Pues te vas a dar cuenta que por lo menos tarda,
Yo quiero recordar que cuando lo ejecuté al hacer esto,
Eran unos 20 segundos más o menos,
Lo que tardaba en operar directamente con bus,
En leer esas dos millones de líneas,
Claro,
Habitualmente no te vas a enfrentar con dos millones de líneas,