Gestión de proyectos Java con Maven

Explicación de Maven en Java

Maven es una herramienta de gestión y construcción de proyectos Java que se utiliza principalmente para simplificar el proceso de compilación, empaquetado y distribución de aplicaciones. Fue desarrollado por Apache y sigue un enfoque basado en convenciones sobre configuraciones, lo que significa que utiliza un conjunto estándar de reglas y estructuras para facilitar la administración de proyectos.

Funciones principales de Maven

• Gestión de dependencias: Maven permite manejar automáticamente las bibliotecas externas (dependencias) que un proyecto necesita. Esto elimina la necesidad de descargar manualmente los JARs y gestionar sus versiones.
• Construcción del proyecto: Proporciona un sistema estandarizado para compilar, probar, empaquetar y desplegar aplicaciones Java.
• Generación de documentación: Puede generar documentación de proyectos utilizando herramientas como Javadoc.
• Automatización: Facilita la automatización de tareas repetitivas como pruebas unitarias, generación de informes, etc.
• Estandarización: Define una estructura de proyecto común que ayuda a mantener el código organizado y consistente.

Opciones más importantes de Maven

A continuación, se enumeran las opciones y comandos más utilizados en Maven:

Comandos básicos

• mvn clean: Elimina los archivos generados en la carpeta target, limpiando el entorno de trabajo.
• mvn compile: Compila el código fuente del proyecto.
• mvn test: Ejecuta las pruebas unitarias del proyecto utilizando frameworks como JUnit.
• mvn package: Empaqueta el proyecto en un archivo JAR, WAR u otro formato según la configuración.
• mvn install: Instala el artefacto generado en el repositorio local de Maven (~/.m2/repository) para que pueda ser utilizado por otros proyectos.
• mvn deploy: Despliega el artefacto en un repositorio remoto, como Nexus o Artifactory.

Opciones avanzadas

• mvn archetype:generate: Crea un nuevo proyecto Maven a partir de un arquetipo (template).
• mvn dependency:tree: Muestra un árbol de dependencias del proyecto, útil para identificar conflictos de versiones.
• mvn site: Genera un sitio web con información del proyecto, incluyendo métricas, documentación y reportes.
• mvn verify: Ejecuta todas las fases hasta la verificación del paquete, incluyendo pruebas integradas.
• -DskipTests: Opción para omitir la ejecución de pruebas durante la construcción del proyecto.

Estructura básica de un proyecto Maven

Un proyecto Maven típico sigue esta estructura de directorios:

        proyecto-maven/
        ├── src/
        │   ├── main/
        │   │   ├── java/         # Código fuente principal
        │   │   └── resources/    # Recursos principales (archivos de configuración, propiedades, etc.)
        │   └── test/
        │       ├── java/         # Pruebas unitarias
        │       └── resources/    # Recursos para las pruebas
        ├── pom.xml               # Archivo de configuración de Maven
    

Archivo POM (Project Object Model)

El archivo pom.xml es el corazón de un proyecto Maven. Contiene la configuración del proyecto, incluyendo dependencias, plugins, metadatos y el ciclo de vida del build. A continuación, se muestra un ejemplo básico:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ejemplo</groupId>
    <artifactId>proyecto-ejemplo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
    

Este archivo define el grupo, el nombre del artefacto, la versión, las dependencias y los plugins necesarios para construir el proyecto.

Conclusión

Maven es una herramienta poderosa que simplifica la gestión de proyectos Java al proporcionar un enfoque estandarizado y automatizado para construir, probar y distribuir aplicaciones. Su capacidad para manejar dependencias y su flexibilidad mediante plugins lo hacen indispensable en el desarrollo de software moderno.

Opciones de Gradle para Java y Kotlin

Explicación de Gradle para Java y Kotlin

Gradle es un sistema de construcción automatizado y flexible que se utiliza ampliamente en proyectos Java (y otros lenguajes como Kotlin, Groovy, etc.). Permite gestionar las dependencias del proyecto, compilar el código fuente, ejecutar pruebas, empaquetar aplicaciones y realizar otras tareas relacionadas con el ciclo de vida del desarrollo de software.

Gradle utiliza un lenguaje de scripting basado en Groovy o Kotlin DSL para definir las tareas y la configuración del proyecto. Esto lo hace más flexible y potente en comparación con herramientas anteriores como Maven o Ant.

Listado de opciones comunes de Gradle para Java

Comandos básicos

• gradle tasks: Muestra una lista de todas las tareas disponibles en el proyecto.
• gradle build: Compila el código fuente, ejecuta las pruebas y genera los artefactos finales (por ejemplo, un archivo .jar).
• gradle clean: Elimina los archivos generados previamente durante la construcción del proyecto (limpia el directorio build).
• gradle assemble: Compila el código fuente y genera los artefactos sin ejecutar las pruebas.
• gradle test: Ejecuta las pruebas unitarias del proyecto.
• gradle check: Ejecuta todas las verificaciones del proyecto, incluyendo las pruebas.
• gradle run: Ejecuta la aplicación si el proyecto incluye un plugin de aplicación ejecutable (como application).

Gestión de dependencias

• gradle dependencies: Muestra un árbol de dependencias del proyecto, mostrando todas las bibliotecas utilizadas y sus versiones.
• gradle dependencyInsight --dependency : Proporciona información detallada sobre una dependencia específica, incluyendo conflictos de versión.
• gradle build --refresh-dependencies: Obliga a Gradle a descargar nuevamente todas las dependencias desde los repositorios remotos.

Compilación y empaquetado

• gradle compileJava: Compila solo el código fuente Java.
• gradle jar: Genera un archivo .jar con el código compilado.
• gradle bootJar (si se usa Spring Boot): Genera un archivo .jar ejecutable compatible con Spring Boot.
• gradle war: Genera un archivo .war para desplegar en servidores de aplicaciones.

Plugins específicos

• gradle init: Inicializa un nuevo proyecto Gradle, permitiendo seleccionar el tipo de proyecto (Java, Kotlin, etc.).
• gradle wrapper: Genera el script del Wrapper de Gradle (gradlew), que permite ejecutar Gradle sin necesidad de instalarlo globalmente.
• gradle sonarqube: Ejecuta análisis de calidad de código utilizando SonarQube (requiere el plugin de SonarQube).
• gradle javadoc: Genera la documentación Javadoc del proyecto.

Opciones avanzadas

• gradle --info: Muestra información detallada sobre la ejecución de las tareas.
• gradle --debug: Habilita el modo de depuración para obtener registros más detallados.
• gradle --profile: Genera un informe de rendimiento de la construcción, útil para identificar cuellos de botella.
• gradle --offline: Ejecuta Gradle en modo fuera de línea, utilizando solo las dependencias ya descargadas.
• gradle --continue: Continúa ejecutando las tareas incluso si alguna falla.

Tareas personalizadas

Puedes definir tus propias tareas en el archivo build.gradle. Por ejemplo:

task hello {
    doLast {
        println '¡Hola, mundo!'
    }
}
    

Este comando se ejecuta con:

gradle hello
    

Ejemplo de archivo build.gradle básico para un proyecto Java

plugins {
    id 'java'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter:3.0.0'
    testImplementation 'junit:junit:4.13.2'
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}
    

Resumiendo

Gradle es una herramienta poderosa y flexible para gestionar proyectos Java. Su capacidad para personalizar tareas y manejar dependencias de manera eficiente lo convierte en una opción popular entre desarrolladores. Los comandos y opciones mencionados anteriormente son solo una parte de lo que Gradle puede hacer; explorar su documentación oficial te permitirá aprovechar al máximo sus capacidades.

Opciones de terraform

Terraform: Explicación y Comandos

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0" # AMI de Ubuntu 20.04 LTS
  instance_type = "t2.micro"

  tags = {
    Name = "terraform-example"
  }
}

output "instance_id" {
  value = aws_instance.example.id
}

        

Opciones de Ansible

ansible all -m ping

ansible all -m apt -a "name=nginx state=present" --become

---
- name: Configurar servidor web con Nginx
  hosts: webservers
  become: yes
  tasks:
    - name: Instalar Nginx
      apt:
        name: nginx
        state: present

    - name: Iniciar servicio Nginx
      service:
        name: nginx
        state: started
        enabled: yes

        

---
- name: Crear un archivo de prueba
  hosts: all
  tasks:
    - name: Crear archivo en /tmp/test.txt
      file:
        path: /tmp/test.txt
        state: touch

        

[webservers]
server1.example.com
server2.example.com

[dbservers]
db1.example.com
db2.example.com

        

ansible-vault encrypt secret.yml

Opciones de Ansible en Línea de Comandos

Opciones del comando Eslint

Os dejo aqui las opciones más típicas de ESLint

--format json       // Salida en formato JSON
--format table      // Salida en formato de tabla
--format junit      // Salida compatible con JUnit

        

npx eslint --init

        

node_modules/
dist/
*.min.js

        

{
  "rules": {
    "semi": ["error", "always"],
    "quotes": ["error", "double"]
  }
}

        

{
  "env": {
    "browser": true,
    "node": true,
    "es6": true
  }
}

        

Comandos y Opciones de Composer

Comandos y Opciones de Composer

composer completion --shell-type bash > ~/.bash_completion
source ~/.bash_completion

Opciones de comandos de PHP

Aqui va un resumen de las opciones más comunes del comando php en la terminal:

🔧 Uso general

php [opciones] [-f] archivo.php [-- argumentos]

🔹 Opciones comunes

🔸 Ejemplos útiles

• Ejecutar código inline:

  php -r "echo 'Hola mundo';"
  

• Comprobar errores en un script:

  php -l archivo.php
  

• Iniciar servidor local en el puerto 8000:

  php -S localhost:8000
  

• Ver ubicación del php.ini:

  php --ini
  

• Ver funciones de una clase:

  php --rf DateTime
  

• Ver definición de una clase:

  php --rc Exception
  

• Ver información de una extensión:

  php --ri json
  

Opciones para SQLServer

Y aquiva van las opciones para el comandos de consola sqlcmd y sqlpackage:

🧱 Opciones para SQL Server en consola (sqlcmd y sqlpackage)

🔹 Conectarse a SQL Server:

sqlcmd -S servidor -U usuario -P contraseña

🔹 Ejecutar un archivo .sql:

sqlcmd -S servidor -U usuario -P contraseña -d base -i script.sql

🔹 Ejecutar una consulta desde consola:

sqlcmd -S servidor -U usuario -P contraseña -Q "SELECT * FROM tabla"

🔹 Exportar backup (modo nativo):

sqlcmd -S servidor -U usuario -P contraseña -Q "BACKUP DATABASE [base] TO DISK = N'/ruta/respaldo.bak' WITH INIT"

🔄 Automatización de respaldo con SQL Server

🔸 Script backup_sqlserver.sh

#!/bin/bash

SERVIDOR="localhost"
USUARIO="tu_usuario"
CLAVE="tu_contraseña"
BASES=(base1 base2)
DIR_BACKUP="/ruta/a/backups"
FECHA=$(date +%F)

mkdir -p "$DIR_BACKUP"

for BASE in "${BASES[@]}"; do
  sqlcmd -S "$SERVIDOR" -U "$USUARIO" -P "$CLAVE" -Q "BACKUP DATABASE [$BASE] TO DISK = N'$DIR_BACKUP/${BASE}_$FECHA.bak' WITH INIT"
done

⏰ Programar con cron

Como en los anteriores:

crontab -e

Y añade:

0 2 * * * /ruta/a/backup_sqlserver.sh

Comandos de PostgreSQL

Aqui van los comandos de consola (CLI) relacionados con PostgreSQL y tambien, un pequeño script para lanzar backups periodicos:

🐘 Equivalente para PostgreSQL (psql y pg_dump)

🔹 Comandos de consola con psql

🔸 Conectarse al servidor PostgreSQL:

psql -U usuario -d nombre_base

🔸 Conectarse a un host remoto:

psql -h direccion_ip -U usuario -d nombre_base

🔸 Ejecutar un archivo SQL:

psql -U usuario -d nombre_base -f archivo.sql

🔸 Ejecutar un comando SQL desde consola:

psql -U usuario -d nombre_base -c "SELECT * FROM tabla;"

🔹 Comandos típicos con pg_dump

🔸 Respaldar una base de datos completa:

pg_dump -U usuario nombre_base > respaldo.sql

🔸 Respaldar una base de datos con compresión:

pg_dump -U usuario nombre_base | gzip > respaldo.sql.gz

🔸 Respaldar una tabla específica:

pg_dump -U usuario -t nombre_tabla nombre_base > tabla.sql

🔸 Respaldar solo la estructura:

pg_dump -U usuario -s nombre_base > estructura.sql

🔸 Respaldar todas las bases de datos:

pg_dumpall -U usuario > todas_las_bases.sql

🔸 Restaurar una base de datos:

psql -U usuario -d nombre_base < respaldo.sql

🔄 Automatización de respaldos con PostgreSQL

🔸 Script backup_postgres.sh

#!/bin/bash

# Configuración
USUARIO="tu_usuario"
BASES=(base1 base2)
DIR_BACKUP="/ruta/a/backups"
FECHA=$(date +%F)

mkdir -p "$DIR_BACKUP"

for BASE in "${BASES[@]}"; do
    pg_dump -U "$USUARIO" "$BASE" | gzip > "$DIR_BACKUP/${BASE}_$FECHA.sql.gz"
done

Asegúrate de que el usuario pueda autenticarse sin contraseña, o usa .pgpass para guardar credenciales.

⏰ Programar con cron

Igual que antes:

crontab -e

Y añade:

0 2 * * * /ruta/a/backup_postgres.sh

Comandos de Mysql y Mysqldump

Aqui os paso los comandos de consola (CLI) relacionados con mysql y mysqldump,en un resumen claro y directo de los más usados:

🔹 Comandos de consola con mysql

🔸 Conectarse al servidor MySQL:

mysql -u usuario -p

🔸 Conectarse a un host remoto:

mysql -h direccion_ip -u usuario -p

🔸 Ejecutar un archivo SQL:

mysql -u usuario -p nombre_base < archivo.sql

🔸 Ejecutar un comando SQL desde consola:

mysql -u usuario -p -e "SHOW DATABASES;"

🔸 Exportar el resultado de una consulta a un archivo:

mysql -u usuario -p -e "SELECT * FROM tabla;" nombre_base > salida.txt

🔹 Comandos típicos con mysqldump

🔸 Respaldar una base de datos completa:

mysqldump -u usuario -p nombre_base > respaldo.sql

🔸 Respaldar todas las bases de datos:

mysqldump -u usuario -p --all-databases > todas.sql

🔸 Respaldar solo la estructura (sin datos):

mysqldump -u usuario -p -d nombre_base > estructura.sql

-d o --no-data

🔸 Respaldar una tabla específica:

mysqldump -u usuario -p nombre_base nombre_tabla > tabla.sql

🔸 Respaldar con compresión:

mysqldump -u usuario -p nombre_base | gzip > respaldo.sql.gz

🧠 Tip extra: Comprobar versión de MySQL

mysql --version

🔄 Automatización de respaldos diarios con script

Aqui os paso un script Bash para automatizar los backups:

🔸 Script backup_mysql.sh

#!/bin/bash

# Configuración
USUARIO="tu_usuario"
PASSWORD="tu_contraseña"
BASES=(base1 base2)  # Lista de bases a respaldar
DIR_BACKUP="/ruta/a/backups"
FECHA=$(date +%F)

mkdir -p "$DIR_BACKUP"

for BASE in "${BASES[@]}"; do
    mysqldump -u "$USUARIO" -p"$PASSWORD" "$BASE" | gzip > "$DIR_BACKUP/${BASE}_$FECHA.sql.gz"
done

Asegúrate de darle permisos de ejecución:

chmod +x backup_mysql.sh

⏰ Programar con cron

Para que el script se ejecute automáticamente cada día a las 2:00 AM:

crontab -e

Y añade:

0 2 * * * /ruta/a/backup_mysql.sh

Opciones de Alchemy y Alembic

Aqui van los comandos de SQLAlchemy en Python junto con  migraciones usando Alembic:

🧪 ¿Qué es Alembic?

Alembic es una herramienta de migración de bases de datos para SQLAlchemy. Permite aplicar cambios en el esquema de la base de datos (como crear o modificar tablas/columnas) mediante scripts de migración.

🔧 Instrucciones básicas de uso

1. Instalación

pip install alembic

Si usas SQLAlchemy también:

pip install sqlalchemy

2. Inicializar Alembic en tu proyecto

alembic init alembic

Esto crea una carpeta alembic/ y un archivo alembic.ini.

3. Configurar la conexión a la base de datos

Edita el archivo alembic.ini:

sqlalchemy.url = sqlite:///./mibasededatos.db

O puedes configurarlo dinámicamente en alembic/env.py.

4. Crear una migración (autogenerada)

Si estás usando el modelo ORM de SQLAlchemy:

alembic revision --autogenerate -m "mensaje descriptivo"

Esto crea un nuevo script en alembic/versions/ con los cambios detectados.

5. Aplicar las migraciones (upgrade)

alembic upgrade head

Esto aplica la última versión de la migración.

6. Volver atrás una migración (downgrade)

alembic downgrade -1

Esto revierte la última migración aplicada.

📜 Comandos útiles de Alembic

Opciones de Tox

🔥 Opciones principales de tox

tox es una herramienta de automatización que permite probar un paquete en múltiples entornos de Python, asegurando compatibilidad y calidad del código.

🚀 Comandos básicos

1️⃣ Ejecutar tox con la configuración predeterminada

tox

Ejecuta las pruebas en todos los entornos configurados en tox.ini.

2️⃣ Especificar un entorno de ejecución

tox -e py38

Ejecuta solo el entorno Python 3.8 (debe estar configurado en tox.ini).

3️⃣ Listar todos los entornos disponibles

tox --listenvs

Muestra todos los entornos configurados en tox.ini.

4️⃣ Mostrar información detallada de los entornos

tox --listenvs-all

Incluye entornos excluidos o omitidos en la ejecución por defecto.

⚡ Opciones avanzadas

5️⃣ Ejecutar sin crear nuevos entornos (Usar los ya creados para ahorrar tiempo)

tox --skip-missing-interpreters false

Ejecuta solo en entornos de Python instalados en el sistema.

6️⃣ Forzar recreación del entorno virtual

tox --recreate

Elimina y vuelve a crear los entornos virtuales, asegurando un entorno limpio.

7️⃣ Ejecutar un solo comando en un entorno específico

tox -e py39 -- python script.py

Ejecuta script.py en el entorno py39 sin correr todas las pruebas.

8️⃣ Ejecutar pruebas en paralelo

tox -p auto

Ejecuta en paralelo utilizando el máximo de núcleos disponibles.

🛠 Personalización y Debugging

9️⃣ Ejecutar un entorno de prueba con una shell interactiva

tox -e py310 --devenv .venv

Crea un entorno virtual .venv para pruebas interactivas.

🔟 Depurar un fallo de configuración

tox --showconfig

Muestra la configuración actual de tox.ini y los valores utilizados.

🔹 Ejecutar tox sin instalar dependencias de prueba

tox --notest

Crea el entorno virtual pero no ejecuta las pruebas.

tox es ideal para probar compatibilidad en múltiples versiones de Python y automatizar pruebas en diferentes entornos. 🚀

Automatización de validaciones antes de commit

🔥 pre-commit – Automatización de validaciones antes de un commit

pre-commit es una herramienta que ejecuta verificaciones automáticas en el código antes de realizar un commit en Git. Se usa para prevenir errores y mantener un código limpio y coherente en los repositorios.

🚀 Características principales

✅ Ejecuta herramientas como black, ruff, isort, pylint, flake8, mypy antes del commit.
✅ Detecta errores antes de que lleguen al repositorio.
✅ Configurable mediante un archivo .pre-commit-config.yaml.
✅ Compatible con Python y otros lenguajes.

🛠 Instalación y configuración

🔹 Instalar pre-commit

pip install pre-commit

🔹 Inicializar pre-commit en un repositorio

pre-commit install

Esto activa los ganchos (hooks) que se ejecutarán antes de cada commit.

🔹 Ejemplo de configuración (.pre-commit-config.yaml)

repos:
  - repo: https://github.com/psf/black
    rev: 23.1.0
    hooks:
      - id: black

  - repo: https://github.com/pycqa/ruff
    rev: v0.1.5
    hooks:
      - id: ruff

Este archivo configura black y ruff para ejecutarse antes de cada commit.

🔹 Ejecutar manualmente pre-commit en todo el código

pre-commit run --all-files

Ejecuta los hooks en todos los archivos del proyecto.

Usar pre-commit mejora la calidad del código, evita errores antes de hacer commit y automatiza tareas repetitivas. ¡Ideal para cualquier flujo de trabajo con Git! 

Makefile para proyectos de Python

📌 Opciones de Makefile en proyectos de Python

En proyectos de Python, Makefile se usa para automatizar tareas como instalación de dependencias, ejecución de pruebas, formateo de código y despliegue.

🛠️ 1. Ejemplo de Makefile para Python

PYTHON = python3
VENV = venv

setup:                 # Crea un entorno virtual e instala dependencias
	$(PYTHON) -m venv $(VENV)
	$(VENV)/bin/pip install -r requirements.txt

install:               # Instala las dependencias
	$(VENV)/bin/pip install -r requirements.txt

test:                  # Ejecuta pruebas con pytest
	$(VENV)/bin/pytest tests/

lint:                  # Analiza el código con pylint y flake8
	$(VENV)/bin/pylint src/
	$(VENV)/bin/flake8 src/

format:                # Formatea el código con Black
	$(VENV)/bin/black src/

run:                   # Ejecuta el programa principal
	$(VENV)/bin/python src/main.py

clean:                 # Elimina archivos generados
	rm -rf $(VENV)
	find . -name "*.pyc" -delete
	find . -name "__pycache__" -delete

🚀 2. Opciones avanzadas en Makefile

📌 Variables configurables

PYTHON = python3
VENV = .venv
REQS = requirements.txt

install:
	$(PYTHON) -m venv $(VENV)
	$(VENV)/bin/pip install -r $(REQS)

Puedes ejecutar:

make install REQS=requirements-dev.txt

📌 Paralelismo con -j

Ejecutar varias tareas a la vez:

make -j 2 lint test

📌 Uso de .PHONY para evitar conflictos con archivos

.PHONY: install test lint format run clean

Makefile en Python facilita tareas repetitivas como instalación, pruebas y formateo de código. 🚀

Opciones de phpunit

PHPUnit es un marco de pruebas para PHP ampliamente utilizado. Se ejecuta desde la línea de comandos y ofrece múltiples opciones para personalizar la ejecución de pruebas.

⚙️ Opciones principales de PHPUnit

📌 1. Ejecutar pruebas

phpunit tests

Ejecuta todas las pruebas dentro del directorio tests.

📌 2. Mostrar ayuda y versión

phpunit --help       # Muestra todas las opciones disponibles  
phpunit --version    # Muestra la versión instalada de PHPUnit  

📌 3. Filtros y selección de pruebas

phpunit --filter nombreDeLaPrueba    # Ejecuta solo una prueba específica  
phpunit --testsuite nombreSuite      # Ejecuta un conjunto de pruebas definido en `phpunit.xml`
phpunit --group grupo                # Ejecuta solo pruebas de un grupo específico  
phpunit --exclude-group grupo        # Excluye un grupo de pruebas  

📌 4. Generar reportes y cobertura de código

phpunit --coverage-html coverage/      # Genera un reporte de cobertura en HTML  
phpunit --coverage-clover coverage.xml # Genera un reporte en formato Clover  
phpunit --coverage-text                # Muestra la cobertura de código en la terminal  
phpunit --log-junit report.xml         # Genera un reporte en formato JUnit  

📌 5. Opciones de salida y depuración

phpunit --verbose      # Muestra detalles adicionales sobre la ejecución  
phpunit --debug        # Imprime información de depuración sobre cada prueba  
phpunit --colors=auto  # Resalta los resultados con colores (auto, never, always)  
phpunit --testdox      # Muestra los resultados en formato legible para humanos  

📌 6. Manejo de excepciones y errores

phpunit --stop-on-error         # Detiene la ejecución al encontrar un error  
phpunit --stop-on-failure       # Detiene la ejecución al encontrar una falla  
phpunit --stop-on-risky         # Detiene la ejecución si hay pruebas riesgosas  
phpunit --stop-on-skipped       # Detiene la ejecución si hay pruebas omitidas  
phpunit --stop-on-incomplete    # Detiene la ejecución si hay pruebas incompletas  
phpunit --fail-on-warning       # Trata las advertencias como errores  

📌 7. Otras opciones avanzadas

phpunit --bootstrap bootstrap.php  # Especifica un archivo de arranque  
phpunit --configuration phpunit.xml # Usa un archivo de configuración específico  
phpunit --order-by=random          # Ejecuta las pruebas en orden aleatorio  
phpunit --repeat 5                 # Repite la ejecución de las pruebas 5 veces  
phpunit --dont-report-useless-tests # No muestra pruebas sin aserciones  

📂 Ejemplo de archivo phpunit.xml

Si no quieres escribir las opciones en la línea de comandos cada vez, puedes configurarlas en un archivo phpunit.xml:

<phpunit bootstrap="bootstrap.php" colors="true">
    <testsuites>
        <testsuite name="MiSuite">
            <directory>tests</directory>
        </testsuite>
    </testsuites>
    <filter>
        <whitelist>
            <directory>src</directory>
        </whitelist>
    </filter>
</phpunit>

Opciones del analizador de codigo Ruff

Ruff es un analizador de código y formateador para Python, diseñado para ser rápido y compatible con múltiples reglas de estilo y linters. Sus opciones se pueden configurar desde la línea de comandos o a través de archivos de configuración como pyproject.toml, .ruff.toml o ruff.yaml.

⚙️ Opciones principales de Ruff

1️⃣ Análisis de código estático (Linter)

Ruff puede reemplazar herramientas como flake8, pylint y mypy en algunas funciones:

• Detección de errores comunes (E, W)

• Errores de sintaxis y estilo (F)

• Complejidad del código (C)

• Seguridad (S)

• Tipos de datos (ANN para anotaciones)

Ejemplo:

ruff check .

Opciones útiles:

ruff check --fix                 # Corrige errores automáticamente
ruff check --select E,W,F         # Solo chequea reglas específicas
ruff check --ignore ANN,S         # Ignora ciertas reglas
ruff check --show-source          # Muestra el código fuente de los errores
ruff check --preview              # Activa reglas en desarrollo

2️⃣ Formateo de código

Ruff también puede formatear el código como black:

ruff format .

Opciones útiles:

ruff format --check               # Verifica si el código ya está formateado
ruff format --diff                # Muestra los cambios sin aplicarlos

3️⃣ Soporte para archivos de configuración

Puedes personalizar Ruff en pyproject.toml:

[tool.ruff]
line-length = 88
target-version = "py311"

[tool.ruff.lint]
select = ["E", "W", "F", "C"]
ignore = ["ANN", "S"]

4️⃣ Integración con pre-commit

Puedes usar Ruff con pre-commit para evitar errores antes de hacer un commit:

- repo: https://github.com/astral-sh/ruff-pre-commit
  rev: v0.1.0
  hooks:
    - id: ruff
    - id: ruff-format

Uso de Pytest para pruebas unitarias

Aquí teneis un listado de los comandos más importantes de pytest, una de las herramientas más utilizadas para pruebas en Python.

🚀 Comandos básicos de pytest

1️⃣ Ejecutar todas las pruebas en el proyecto

pytest

Ejecuta automáticamente todas las pruebas encontradas en archivos con prefijo test_ o sufijo _test.py.

2️⃣ Ejecutar pruebas de un archivo específico

pytest test_mi_modulo.py

Ejecuta solo las pruebas dentro de test_mi_modulo.py.

3️⃣ Ejecutar un solo test dentro de un archivo

pytest test_mi_modulo.py::test_funcion_especifica

Ejecuta solo la función de prueba test_funcion_especifica dentro del archivo test_mi_modulo.py.

4️⃣ Mostrar más detalles en la salida (modo verboso)

pytest -v

Muestra más información sobre cada prueba ejecutada.

5️⃣ Detener la ejecución en el primer fallo

pytest -x

Detiene la ejecución en cuanto una prueba falla.

🔥 Opciones avanzadas

6️⃣ Reintentar pruebas fallidas

pytest --maxfail=3

Detiene la ejecución después de 3 fallos.

7️⃣ Ejecutar solo pruebas que fallaron en la última ejecución

pytest --lf

(--last-failed) Reejecuta solo las pruebas fallidas en la última ejecución.

8️⃣ Volver a ejecutar automáticamente las pruebas fallidas varias veces

pytest --reruns 3

Ejecuta nuevamente las pruebas fallidas hasta 3 veces antes de reportarlas como fallidas.

9️⃣ Ejecutar pruebas con cobertura de código

pytest --cov=mi_modulo

Requiere pytest-cov. Muestra qué partes del código fueron ejecutadas durante las pruebas.

🔟 Ejecutar pruebas paralelamente

pytest -n auto

Requiere pytest-xdist. Ejecuta pruebas en paralelo usando múltiples núcleos del procesador.

🧪 Filtrado de pruebas

🔹 Ejecutar solo pruebas con un nombre específico

pytest -k "nombre_test"

Ejecuta solo las pruebas que contengan "nombre_test" en su nombre.

🔹 Ejecutar pruebas de una clase específica

pytest test_mi_modulo.py::TestClase

Ejecuta todas las pruebas dentro de TestClase.

🔹 Ejecutar solo pruebas con un marcador específico

pytest -m "marca_especifica"

Ejecuta solo las pruebas que tengan el decorador @pytest.mark.marca_especifica.

🛠 Depuración y análisis

🔹 Depurar cuando una prueba falla

pytest --pdb

Abre el depurador interactivo (PDB) en el punto exacto donde falló la prueba.

🔹 Mostrar cada print() en tiempo real

pytest -s

Evita que pytest capture la salida de print() y la muestra en la terminal en tiempo real.

🔹 Generar un informe en JUnit (para integración con CI/CD)

pytest --junitxml=report.xml

Crea un archivo report.xml con los resultados de las pruebas, útil en integración continua (CI/CD).

Opciones de NPX

🔥 Comandos típicos de npx

npx (Node Package eXecute) es una herramienta incluida en npm que permite ejecutar paquetes sin instalarlos globalmente. Aquí tienes los comandos más útiles y típicos:

🚀 Uso básico de npx

1. Ejecutar un paquete sin instalarlo

   • npx cowsay "Hola Mundo" → Muestra un mensaje con una vaca ASCII.

   • npx figlet "Hello" → Convierte texto en arte ASCII.

2. Crear proyectos rápidamente

   • npx create-react-app my-app → Crea un nuevo proyecto React sin instalar create-react-app.

   • npx create-next-app my-next-app → Genera un proyecto Next.js.

   • npx express-generator my-app → Crea una plantilla para una app de Express.

3. Ejecutar scripts o herramientas específicas

   • npx eslint . → Ejecuta ESLint sin instalarlo globalmente.

   • npx prettier --write . → Formatea el código con Prettier.

   • npx serve → Sirve archivos estáticos en un servidor local.

⚡ Comandos avanzados de npx

4. Ejecutar una versión específica de un paquete

   • npx eslint@8.0.0 . → Usa una versión específica de ESLint.

   • npx webpack@5 --version → Ejecuta Webpack 5 sin instalarlo.

5. Ejecutar comandos en diferentes versiones de Node.js

   • npx -p node@14 node -v → Usa Node.js 14 temporalmente.

6. Ejecutar un binario dentro de un proyecto

   • npx tsc → Ejecuta TypeScript Compiler si está en node_modules.

7. Ver la ubicación de un paquete ejecutado con npx

   • npx --cache → Muestra la caché de paquetes usados con npx.

🛠 Diferencias entre npm, npx y yarn dlx

npx es especialmente útil cuando quieres probar herramientas sin instalarlas en tu sistema. ¿Necesitas algún uso específico? 🚀

Opciones de la alternativa a npm: yarn

Aquí tienes una lista de los comandos más interesantes y típicos de Yarn, que es una alternativa a npm con mejoras en velocidad y gestión de dependencias.

🚀 Comandos esenciales

1. yarn init – Inicializa un nuevo proyecto y crea un package.json.

   • yarn init -y → Usa valores predeterminados.

2. yarn add <paquete> – Instala un paquete en el proyecto.

   • yarn add express → Instala Express.

   • yarn add lodash --dev → Instala lodash como dependencia de desarrollo.

   • yarn add react@latest → Instala la última versión de React.

3. yarn install – Instala todas las dependencias definidas en package.json.

4. yarn upgrade – Actualiza todos los paquetes a la última versión permitida en package.json.

   • yarn upgrade lodash → Actualiza lodash.

5. yarn remove <paquete> – Elimina un paquete instalado.

   • yarn remove express → Borra Express del proyecto.

🔥 Comandos útiles

6. yarn list – Muestra una lista de las dependencias instaladas.

   • yarn list --depth=0 → Lista solo los paquetes de nivel superior.

7. yarn why <paquete> – Muestra por qué un paquete está instalado y qué lo requiere.

   • yarn why react → Muestra detalles de React en el proyecto.

8. yarn cache clean – Limpia la caché de Yarn.

9. yarn audit – Analiza las dependencias en busca de vulnerabilidades.

   • yarn audit --fix → Intenta corregir problemas automáticamente.

10. yarn run <script> – Ejecuta un script definido en package.json.

    • yarn run dev → Ejecuta el script dev.

⚡ Comandos avanzados

11. yarn create <paquete> – Ejecuta un generador de plantillas sin instalarlo globalmente.

    • yarn create react-app my-app → Crea un nuevo proyecto React.

12. yarn set version latest – Actualiza Yarn a la última versión.

13. yarn version – Muestra la versión actual del proyecto.

    • yarn version --patch → Incrementa la versión de parche (0.0.X).

    • yarn version --minor → Incrementa la versión menor (0.X.0).

    • yarn version --major → Incrementa la versión mayor (X.0.0).

14. yarn link – Vincula un paquete localmente para desarrollo.

15. yarn workspaces – Gestiona múltiples paquetes en un solo repositorio (monorepos).

    • yarn workspaces info → Muestra información sobre los espacios de trabajo.

16. yarn dlx <paquete> – Ejecuta paquetes sin instalarlos globalmente (equivalente a npx).

    • yarn dlx create-next-app my-next-app → Crea un proyecto Next.js sin instalar create-next-app.

Yarn es más rápido que npm en muchos casos gracias a su enfoque en la paralelización y la caché de dependencias. ¿Buscas algún comando en particular? 🚀

Opcviones de NPM

Aquí teneis una lista de comandos interesantes y típicos de npm (Node Package Manager), junto con una breve explicación de cada uno:

🚀 Comandos esenciales

1. npm init – Inicializa un nuevo proyecto creando un package.json.

   • npm init -y → Usa valores predeterminados.

2. npm install <paquete> – Instala un paquete en el proyecto.

   • npm i express → Instala Express.

   • npm i lodash -D → Instala lodash como dependencia de desarrollo.

   • npm i → Instala todas las dependencias definidas en package.json.

3. npm update – Actualiza las dependencias a la última versión permitida por package.json.

   • npm update lodash → Actualiza lodash.

4. npm outdated – Muestra qué paquetes tienen versiones más recientes disponibles.

5. npm uninstall <paquete> – Elimina un paquete instalado.

   • npm uninstall express → Elimina Express.

🔥 Comandos útiles

6. npm list – Muestra una lista de los paquetes instalados.

   • npm list -g → Muestra paquetes instalados globalmente.

7. npm dedupe – Optimiza dependencias eliminando duplicados.

8. npm audit – Escanea el proyecto en busca de vulnerabilidades de seguridad.

   • npm audit fix → Intenta arreglar problemas automáticamente.

9. npm cache clean --force – Limpia la caché de npm.

10. npm run <script> – Ejecuta un script definido en package.json.

    • npm run dev → Ejecuta el script dev si está definido.

⚡ Comandos avanzados

11. npm ci – Instala dependencias de forma rápida y consistente según package-lock.json.

12. npm version <tipo> – Cambia la versión del proyecto.

    • npm version major → Incrementa la versión mayor (X.0.0).

    • npm version minor → Incrementa la versión menor (0.X.0).

    • npm version patch → Incrementa la versión de parche (0.0.X).

13. npm publish – Publica un paquete en npm (requiere cuenta).

14. npx <comando> – Ejecuta paquetes sin instalarlos globalmente.

    • npx create-react-app my-app → Crea un proyecto React sin instalar create-react-app.

15. npm link – Vincula un paquete localmente para desarrollo.

Comandos de Nginx

Resumen de los comandos más típicos para administrar Nginx:

📌 Gestión del servicio Nginx

Estos comandos se usan para iniciar, detener y reiniciar Nginx en sistemas basados en systemd:

• Iniciar Nginx

  sudo systemctl start nginx
  

• Detener Nginx

  sudo systemctl stop nginx
  

• Reiniciar Nginx

  sudo systemctl restart nginx
  

• Recargar la configuración sin interrumpir el servicio

  sudo systemctl reload nginx
  

• Ver el estado de Nginx

  sudo systemctl status nginx
  

🔍 Verificación de configuración

Antes de aplicar cambios en la configuración de Nginx, es recomendable verificarlos:

sudo nginx -t

Si todo está correcto, verás un mensaje como:
nginx: configuration file /etc/nginx/nginx.conf test is successful

📂 Gestión de archivos de configuración

• Archivo de configuración principal:

  /etc/nginx/nginx.conf
  

• Directorio para sitios habilitados:

  /etc/nginx/sites-enabled/
  

• Directorio para sitios disponibles:

  /etc/nginx/sites-available/
  

Para activar un sitio:

sudo ln -s /etc/nginx/sites-available/misitio /etc/nginx/sites-enabled/

Para desactivar un sitio:

sudo rm /etc/nginx/sites-enabled/misitio

📊 Logs y depuración

• Ver los registros de acceso

  sudo tail -f /var/log/nginx/access.log
  

• Ver los registros de errores

  sudo tail -f /var/log/nginx/error.log
  

🔧 Otras operaciones útiles

• Ver la versión de Nginx

  nginx -v
  

• Ver procesos de Nginx en ejecución

  ps aux | grep nginx
  

• Recargar Nginx en caso de fallo sin reiniciarlo

  sudo nginx -s reload
  

Comandos Apache

Aquí va una lista de los comandos más habituales para administrar el servidor web Apache HTTP Server en sistemas Linux/Unix y Windows:

📌 Comandos básicos en Linux/Unix (systemd - Ubuntu/Debian/CentOS)

Iniciar, detener, reiniciar y ver el estado de Apache:

sudo systemctl start apache2    # Iniciar Apache (en Debian/Ubuntu)
sudo systemctl start httpd      # Iniciar Apache (en CentOS/RHEL)
sudo systemctl stop apache2     # Detener Apache
sudo systemctl restart apache2  # Reiniciar Apache (cierra y abre conexiones)
sudo systemctl reload apache2   # Recargar configuración sin reiniciar (sin caída)
sudo systemctl status apache2   # Ver estado del servicio

Habilitar/deshabilitar inicio automático:

sudo systemctl enable apache2   # Iniciar automáticamente al arrancar el sistema
sudo systemctl disable apache2  # Desactivar inicio automático

Ver errores y logs:

sudo tail -f /var/log/apache2/error.log  # Monitorizar errores en tiempo real (Debian/Ubuntu)
sudo tail -f /var/log/httpd/error_log    # CentOS/RHEL

📌 Comandos en Windows (si Apache está instalado como servicio):

net start Apache2.4     # Iniciar Apache
net stop Apache2.4      # Detener Apache
httpd -k restart        # Reiniciar (desde la terminal con permisos)
httpd -k graceful       # Recargar configuración sin desconexiones

📌 Comandos generales útiles:

Probar sintaxis de configuración antes de reiniciar:

sudo apachectl configtest  # Verificar errores en archivos de configuración

Ver versión de Apache:

apache2 -v    # Debian/Ubuntu
httpd -v      # CentOS/RHEL

Listar módulos instalados:

apache2ctl -M   # Debian/Ubuntu
httpd -M        # CentOS/RHEL

📌 Gestión de hosts virtuales (vhosts):

• Habilitar un sitio (en Debian/Ubuntu):

  sudo a2ensite mi-sitio.conf    # Habilitar sitio
  sudo a2dissite mi-sitio.conf   # Deshabilitar sitio
  

• Habilitar módulos (como rewrite):

  sudo a2enmod rewrite    # Activar módulo
  sudo a2dismod rewrite   # Desactivar módulo
  

🔍 Notas importantes:

• En CentOS/RHEL/Fedora, el nombre del servicio suele ser httpd en lugar de apache2.
• Después de cambios en la configuración, siempre verifica con sudo apachectl configtest antes de reiniciar.
• Si usas XAMPP, los comandos son distintos (ej: /opt/lampp/lampp start en Linux).

Gestor de paquetes pip

Aquí van algunas opciones típicas de pip, el gestor de paquetes de Python:

🔹 Instalación y Actualización de Paquetes

• pip install <paquete> → Instala un paquete desde PyPI.

• pip install <paquete>==<versión> → Instala una versión específica de un paquete.

• pip install -r requirements.txt → Instala paquetes desde un archivo de dependencias.

• pip install --upgrade <paquete> → Actualiza un paquete a la última versión.

• pip install --upgrade pip → Actualiza pip a la última versión.

🔹 Gestión de Paquetes Instalados

• pip list → Lista todos los paquetes instalados.

• pip freeze → Muestra los paquetes instalados en formato compatible con requirements.txt.

• pip show <paquete> → Muestra información detallada sobre un paquete.

• pip uninstall <paquete> → Desinstala un paquete.

🔹 Gestión de Caché y Depuración

• pip cache purge → Elimina la caché de pip.

• pip check → Verifica que no haya dependencias rotas o incompatibles.

Si quieres que agregue estos comandos a tu documento o necesitas más detalles, dime. 🚀

Aquí tienes un resumen de los comandos más típicos para administrar Nginx:

📌 Gestión del servicio Nginx

Estos comandos se usan para iniciar, detener y reiniciar Nginx en sistemas basados en systemd:

• Iniciar Nginx

  sudo systemctl start nginx
  

• Detener Nginx

  sudo systemctl stop nginx
  

• Reiniciar Nginx

  sudo systemctl restart nginx
  

• Recargar la configuración sin interrumpir el servicio

  sudo systemctl reload nginx
  

• Ver el estado de Nginx

  sudo systemctl status nginx
  

🔍 Verificación de configuración

Antes de aplicar cambios en la configuración de Nginx, es recomendable verificarlos:

sudo nginx -t

Si todo está correcto, verás un mensaje como:
nginx: configuration file /etc/nginx/nginx.conf test is successful

📂 Gestión de archivos de configuración

• Archivo de configuración principal:

  /etc/nginx/nginx.conf
  

• Directorio para sitios habilitados:

  /etc/nginx/sites-enabled/
  

• Directorio para sitios disponibles:

  /etc/nginx/sites-available/
  

Para activar un sitio:

sudo ln -s /etc/nginx/sites-available/misitio /etc/nginx/sites-enabled/

Para desactivar un sitio:

sudo rm /etc/nginx/sites-enabled/misitio

📊 Logs y depuración

• Ver los registros de acceso

  sudo tail -f /var/log/nginx/access.log
  

• Ver los registros de errores

  sudo tail -f /var/log/nginx/error.log
  

🔧 Otras operaciones útiles

• Ver la versión de Nginx

  nginx -v
  

• Ver procesos de Nginx en ejecución

  ps aux | grep nginx
  

• Recargar Nginx en caso de fallo sin reiniciarlo

  sudo nginx -s reload
  

Opciones del gestor de dependencias Poetry

Aquí tienes algunas opciones típicas de Poetry, el gestor de dependencias para Python:

🔹 Gestión de Proyectos

• poetry new <nombre_proyecto> → Crea un nuevo proyecto con la estructura básica.

• poetry init → Inicializa un nuevo proyecto en un directorio existente.

• poetry install → Instala las dependencias del proyecto.

• poetry update → Actualiza las dependencias según el pyproject.toml.

🔹 Gestión de Dependencias

• poetry add <paquete> → Añade una dependencia al proyecto.

• poetry add <paquete> --dev → Añade una dependencia solo para desarrollo.

• poetry remove <paquete> → Elimina una dependencia.

🔹 Entornos Virtuales

• poetry shell → Activa el entorno virtual del proyecto.

• poetry env list → Muestra los entornos virtuales disponibles.

• poetry env remove <python_version> → Elimina un entorno virtual.

🔹 Gestión de Versiones

• poetry version → Muestra la versión actual del proyecto.

• poetry version <nueva_version> → Cambia la versión del proyecto.

🔹 Publicación y Distribución

• poetry build → Construye el paquete del proyecto.

• poetry publish → Publica el paquete en PyPI.

Si quieres que agregue estos comandos a tu documento o necesitas más detalles, dime. 🚀

Docker-compose

Aquí tienes un resumen de los comandos más útiles de Docker Compose:

🔹 Docker Compose

• docker-compose up -d → Inicia los servicios definidos en docker-compose.yml en segundo plano.

• docker-compose down → Detiene y elimina los contenedores de docker-compose.

• docker-compose logs -f → Muestra los logs de los servicios en tiempo real.

• docker-compose ps → Lista los contenedores gestionados por docker-compose.

• docker-compose restart → Reinicia los servicios.

• docker-compose stop → Detiene los servicios sin eliminarlos.

• docker-compose rm → Elimina los contenedores gestionados por docker-compose.

• docker-compose exec <servicio> <comando> → Ejecuta un comando en un contenedor de docker-compose.

🔹 Limpieza del Sistema

• docker system prune -a → Elimina contenedores, imágenes y volúmenes no utilizados.

• docker container prune → Elimina todos los contenedores detenidos.

• docker image prune → Elimina imágenes no utilizadas.

Si necesitas un comando más específico o con opciones adicionales, dime y te ayudo. 🚀

Comandos de Docker

Aquí tienes un resumen de los comandos más útiles de Docker:

🔹 Gestión de Imágenes

• docker pull <imagen> → Descarga una imagen desde Docker Hub.

• docker images → Lista las imágenes disponibles en el sistema.

• docker rmi <imagen> → Elimina una imagen localmente.

• docker build -t <nombre:tag> . → Construye una imagen desde un Dockerfile.

🔹 Gestión de Contenedores

• docker run -d -p 8080:80 --name <nombre> <imagen> → Crea y ejecuta un contenedor en segundo plano.

• docker ps → Lista los contenedores en ejecución.

• docker ps -a → Lista todos los contenedores, incluidos los detenidos.

• docker stop <contenedor> → Detiene un contenedor en ejecución.

• docker start <contenedor> → Inicia un contenedor detenido.

• docker restart <contenedor> → Reinicia un contenedor.

• docker rm <contenedor> → Elimina un contenedor.

• docker exec -it <contenedor> bash → Accede a la terminal de un contenedor en ejecución.

🔹 Gestión de Volúmenes y Redes

• docker volume create <nombre> → Crea un volumen.

• docker volume ls → Lista los volúmenes.

• docker volume rm <nombre> → Elimina un volumen.

• docker network ls → Lista las redes de Docker.

• docker network create <nombre> → Crea una red personalizada.

• docker network connect <red> <contenedor> → Conecta un contenedor a una red.

🔹 Docker Compose

• docker-compose up -d → Inicia los servicios definidos en docker-compose.yml en segundo plano.

• docker-compose down → Detiene y elimina los contenedores de docker-compose.

• docker-compose logs -f → Muestra los logs de los servicios en tiempo real.

🔹 Limpieza del Sistema

• docker system prune -a → Elimina contenedores, imágenes y volúmenes no utilizados.

• docker container prune → Elimina todos los contenedores detenidos.

• docker image prune → Elimina imágenes no utilizadas.

Si necesitas un comando más específico o con opciones adicionales, dime y te ayudo. 🚀

Comandos de Git

Aquí va un listado de comandos esenciales de Git organizados por categorías:

🔹 Configuración Inicial

git config --global user.name "Tu Nombre"    # Configura el nombre de usuario  
git config --global user.email "tu@email.com" # Configura el correo electrónico  
git config --list                             # Muestra la configuración actual  

🔹 Inicialización y Clonación

git init             # Inicia un nuevo repositorio en el directorio actual  
git clone URL        # Clona un repositorio remoto  

🔹 Estado y Registro

git status         # Muestra el estado del repositorio  
git log           # Muestra el historial de commits  
git log --oneline # Historial en una sola línea  
git diff          # Muestra diferencias entre archivos  

🔹 Añadir y Confirmar Cambios

git add archivo     # Añade un archivo al área de preparación  
git add .           # Añade todos los cambios  
git commit -m "Mensaje"  # Guarda los cambios con un mensaje  
git commit --amend  # Modifica el último commit  

🔹 Ramas (Branches)

git branch               # Lista las ramas  
git branch nombre_rama   # Crea una nueva rama  
git checkout nombre_rama # Cambia a una rama existente  
git checkout -b nueva_rama # Crea y cambia a la nueva rama  
git merge nombre_rama    # Fusiona una rama con la actual  
git branch -d nombre_rama # Elimina una rama local  

🔹 Trabajo con Remoto

git remote -v                # Lista los repositorios remotos  
git remote add origin URL    # Conecta un repositorio local con uno remoto  
git push origin main         # Sube cambios a la rama principal  
git pull origin main         # Descarga cambios de la rama principal  
git fetch origin             # Obtiene datos remotos sin fusionar  

🔹 Deshacer Cambios

git checkout -- archivo      # Revierte cambios no confirmados  
git reset HEAD archivo       # Deshace `git add`  
git reset --soft HEAD~1      # Deshace el último commit, pero mantiene los cambios  
git reset --hard HEAD~1      # Borra el último commit y sus cambios  
git revert HEAD              # Crea un nuevo commit que revierte el último  

🔹 Etiquetas (Tags)

git tag nombre_etiqueta        # Crea una etiqueta  
git tag -a nombre_etiqueta -m "Mensaje"  # Crea una etiqueta con anotación  
git push origin --tags         # Envía las etiquetas al remoto  

🔹 Stash (Guardar Cambios Temporalmente)

git stash       # Guarda cambios sin confirmarlos  
git stash pop   # Recupera los cambios guardados  
git stash list  # Muestra los cambios guardados en stash  

🔹 Otros Comandos Útiles

git show HEAD      # Muestra detalles del último commit  
git shortlog       # Resumen del historial de commits por autor  
git blame archivo  # Muestra quién modificó cada línea de un archivo  

Si necesitas más detalles sobre algún comando o una acción específica, dime. 😊

Comandos curiosos

Os traigo un par de comandos más  divertidos que practicos, pero que no dejan de ser curiosos. El primero comando es sl, una broma clásica en sistemas Unix/Linux. Es una variación del comando ls (listar archivos), pero en lugar de mostrar archivos en un directorio, muestra una animación de una locomotora de vapor en la terminal.

Se creó para "castigar" a quienes escriben ls demasiado rápido y se equivocan. Si no lo tienes instalado, puedes agregarlo en Debian/Ubuntu con:

sudo apt install sl

Y en Arch Linux con:

sudo pacman -S sl

Al ejecutarlo con sl, verás un tren moviéndose por la pantalla. También tiene opciones como:

• sl -F: Muestra un tren descarrilado.

• sl -l: Muestra un tren más lento.

• sl -a: Muestra un tren con diferentes efectos.

Aqui te paso algunos mas comandos similares que son bromas o simplemente divertidos en Unix/Linux. Aquí algunos ejemplos:

• cowsay: Muestra una vaca ASCII diciendo el texto que le pases.

  sudo apt install cowsay
  cowsay "Hola mundo"
  

• fortune: Muestra frases aleatorias y curiosas.

  sudo apt install fortune
  fortune
  

• cmatrix: Simula la lluvia de caracteres de la película The Matrix.

  sudo apt install cmatrix
  cmatrix
  

• lolcat: Aplica colores arcoíris al texto.

  sudo apt install lolcat
  echo "Texto colorido" | lolcat
  

Y por último el mas fascinante de todos: un video en modo asci, una demostracion del poderio del Ascii Art. Es un programa que muestra una animación ASCII impresionante en la terminal, con gráficos en movimiento y efectos visuales. Fue creado en 1997 por A.A. van Ruler y es una especie de demostración técnica del potencial del arte en ASCII.

Instalación

Si quieres probarlo, puedes instalarlo en Debian/Ubuntu con:

sudo apt install bb

En Arch Linux, se encuentra en el AUR:

yay -S bb

Uso

Una vez instalado, simplemente ejecútalo con:

bb

Disfrutarás de una animación en ASCII bastante elaborada, que muestra un espectáculo de efectos gráficos.

lectura de archivos por shell

cat archivo.txt

while IFS= read -r linea; do
    echo "Línea: $linea"
done < archivo.txt

awk '{print "Línea: " $0}' archivo.txt

sed -n 's/foo/bar/p' archivo.txt

echo "Nuevo contenido" > archivo.txt

echo "Otra línea más" >> archivo.txt

wc archivo.txt

grep "palabra" archivo.txt

sed -i 's/viejo/nuevo/g' archivo.txt

#!/bin/bash

archivo="datos.txt"

while IFS= read -r linea; do
    echo "Procesando: $linea"
    # Aquí puedes hacer más operaciones con cada línea
done < "$archivo"

Uso de getops para manejo de opciones

El comando getopts en shell script se usa para procesar opciones de línea de comandos de manera estructurada. Es útil cuando quieres manejar argumentos como -a, -b valor o combinaciones de ellos.

Funcionamiento de getopts

El comando analiza los argumentos pasados al script y asigna las opciones y valores a variables.

Ejemplo básico

#!/bin/bash

while getopts "a:b:" opt; do
  case $opt in
    a) echo "Opción -a con valor: $OPTARG" ;;
    b) echo "Opción -b con valor: $OPTARG" ;;
    *) echo "Uso: $0 -a valor -b valor" ;;
  esac
done

Si ejecutas:

./script.sh -a 10 -b 20

La salida será:

Opción -a con valor: 10
Opción -b con valor: 20

Explicación

• "a:b:" → Define dos opciones: -a y -b, ambas requieren un valor (por eso los :).

• $opt → Contiene la opción actual (a o b).

• $OPTARG → Contiene el valor asociado a la opción.

• El while recorre los argumentos hasta que se procesan todos.

Si quieres incluir esta información en tu documento, dime dónde la agrego.

Comando wc para contar

El comando wc -l cuenta el número de líneas en una entrada. Se puede usar de varias maneras en Zsh para contar múltiples entradas:

1. Contar líneas en un solo archivo

   wc -l archivo.txt
   

   Esto mostrará la cantidad de líneas en archivo.txt.

2. Contar líneas en varios archivos

   wc -l archivo1.txt archivo2.txt
   

   Esto devuelve el número de líneas en cada archivo y una suma total.

3. Contar líneas de la entrada estándar (stdin)

   cat archivo.txt | wc -l
   

   O de forma más eficiente:

   < archivo.txt wc -l
   

4. Contar líneas de múltiples archivos coincidentes

   wc -l *.txt
   

   Esto cuenta las líneas de todos los archivos .txt en el directorio actual.

5. Contar líneas en la salida de un comando

   ls -1 | wc -l
   

   Cuenta la cantidad de archivos y directorios en la carpeta actual.

6. Contar líneas en archivos dentro de subdirectorios

   find . -type f -name "*.txt" -exec wc -l {} +
   

   Esto busca archivos .txt en el directorio actual y subdirectorios, luego cuenta sus líneas.

Si quieres agregar una sección en el documento sobre wc -l, dime dónde te gustaría que la incluya.

Zsh y oh my Zsh

Zsh (Z Shell) es una consola de línea de comandos avanzada y altamente configurable, usada como intérprete de órdenes en sistemas operativos tipo Unix, como Linux y macOS. Es una alternativa mejorada a Bash (Bourne Again Shell), con características adicionales que la hacen popular entre desarrolladores y administradores de sistemas.

Características principales de Zsh

1. Autocompletado avanzado

   • Puede completar nombres de comandos, archivos, directorios, opciones de comandos y más.

   • Soporta sugerencias y corrección automática de errores tipográficos.

2. Historial mejorado

   • Permite buscar comandos previos de manera más eficiente con Ctrl + R.

   • Almacena comandos con más opciones de personalización que Bash.

3. Globos y expansiones de archivos mejoradas

   • Admite expresiones avanzadas para la selección de archivos (ejemplo: ls **/*.txt lista todos los archivos .txt en subdirectorios).

4. Alias y funciones avanzadas

   • Permite definir alias de comandos más flexibles y crear funciones para automatizar tareas.

5. Temas y personalización con Oh My Zsh

   • Oh My Zsh es un framework que facilita la configuración de Zsh, permitiendo añadir temas y plugins fácilmente.

   • Soporta temas visuales que modifican el prompt con información útil, como el estado de Git o la rama actual.

6. Mayor flexibilidad con scripts

   • Zsh ofrece más opciones y control sobre scripting en comparación con Bash.

7. Mejor integración con Git

   • Incluye plugins que mejoran la experiencia al trabajar con Git, mostrando información de estado en el prompt.

Cómo instalar y configurar Zsh

1. Instalar Zsh

   • En Ubuntu/Debian:

     sudo apt install zsh
     

   • En macOS (viene por defecto, pero puedes actualizarlo con Homebrew):

     brew install zsh
     

   • En Arch Linux:

     sudo pacman -S zsh
     

2. Cambiar la shell por defecto a Zsh

   chsh -s $(which zsh)
   

   Luego, cierra sesión y vuelve a iniciarla para aplicar los cambios.

3. Instalar Oh My Zsh (opcional, pero recomendado)

   sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
   

   Esto permite gestionar temas y plugins fácilmente.

4. Activar plugins útiles
   Edita el archivo ~/.zshrc y en la línea de plugins=(git) puedes añadir más, como:

   plugins=(git zsh-autosuggestions zsh-syntax-highlighting)
   

   Luego, recarga la configuración:

   source ~/.zshrc
   

Conclusión

Zsh es una alternativa poderosa y flexible a Bash, con muchas mejoras en autocompletado, personalización y funcionalidad. Si usas la terminal con frecuencia, especialmente para desarrollo o administración de sistemas, vale la pena probarla y configurarla con Oh My Zsh para aprovechar todas sus ventajas.

T-mux

Tmux (Terminal Multiplexer) es una herramienta poderosa que permite manejar múltiples sesiones de terminal dentro de una misma ventana. Es especialmente útil para desarrolladores, administradores de sistemas y usuarios que trabajan en servidores remotos.

¿Para qué sirve Tmux?

• Multiplexar terminales → Puedes tener varias sesiones dentro de una misma terminal.

• Dividir la pantalla → Permite dividir la terminal en paneles.

• Sesiones persistentes → Si la conexión SSH se cae, Tmux mantiene la sesión abierta.

• Trabajar con múltiples ventanas → Puedes cambiar entre diferentes ventanas fácilmente.

Comandos básicos de Tmux

1. Iniciar y administrar sesiones

• Iniciar una nueva sesión:

  tmux
  

• Iniciar una sesión con nombre:

  tmux new -s nombre_sesion
  

• Listar sesiones activas:

  tmux ls
  

• Reconectar a una sesión activa:

  tmux attach -t nombre_sesion
  

• Cerrar sesión de Tmux:

  exit
  

• Desvincular sesión sin cerrarla (para retomarla después):

  Ctrl + b, luego d
  

2. Manejo de ventanas y paneles

Tmux permite dividir la terminal en varias ventanas y paneles.

Ventanas (como pestañas en un navegador)

• Crear una nueva ventana:

  Ctrl + b, luego c
  

• Moverse entre ventanas:

  Ctrl + b, luego n  (siguiente ventana)
  Ctrl + b, luego p  (ventana anterior)
  

• Listar todas las ventanas:

  Ctrl + b, luego w
  

• Cerrar la ventana actual:

  Ctrl + b, luego &
  

Paneles (dividir la pantalla)

• Dividir la pantalla verticalmente:

  Ctrl + b, luego %
  

• Dividir la pantalla horizontalmente:

  Ctrl + b, luego "
  

• Moverse entre paneles:

  Ctrl + b, luego flecha izquierda/derecha/arriba/abajo
  

• Cerrar un panel:

  Ctrl + b, luego x
  

3. Guardar y restaurar sesiones

Si trabajas en un servidor remoto, es útil poder restaurar sesiones fácilmente.

• Guardar el estado de la sesión:

  tmux detach
  

• Restaurar una sesión desconectada:

  tmux attach -t nombre_sesion
  

Tmux es muy útil cuando necesitas trabajar con varias terminales al mismo tiempo sin abrir varias ventanas separadas. ¿Quieres algún truco más avanzado sobre Tmux? 🚀

Busqueda en Vim

Muchas veces echo en falta tener una referencia de busqueda y reemplazo en vim, aprovechando la circunstancia pongo aqui unas notas:

1. Búsqueda y reemplazo

• Buscar una palabra en el archivo:

  /palabra
  

• Reemplazar una palabra en todo el archivo:

  :%s/viejo/nuevo/g
  

• Confirmar cada reemplazo:

  :%s/viejo/nuevo/gc
  

2. Movimiento rápido

• gg → Ir al inicio del archivo.

• G → Ir al final del archivo.

• 5G → Ir a la línea 5.

• w → Moverse palabra por palabra hacia adelante.

• b → Moverse palabra por palabra hacia atrás.

3. Copiar, cortar y pegar

• yy → Copiar una línea.

• dd → Cortar una línea.

• p → Pegar después del cursor.

• P → Pegar antes del cursor.

Si quieres copiar o cortar varias líneas, usa un número antes:

• 5yy → Copiar 5 líneas.

• 5dd → Cortar 5 líneas.

4. Dividir la pantalla (split)

• :split archivo.txt → Abrir un archivo en una nueva ventana horizontal.

• :vsplit archivo.txt → Abrir un archivo en una nueva ventana vertical.

• Ctrl + w + w → Alternar entre ventanas.

• Ctrl + w + h/j/k/l → Moverse entre ventanas.

5. Macros (grabar y repetir comandos)

Si necesitas repetir una secuencia de comandos:

1. Presiona q seguido de una letra (ej. qa para grabar en el registro a).

2. Escribe los comandos que deseas grabar.

3. Presiona q nuevamente para detener la grabación.

4. Ejecuta la macro con @a.

5. Para repetirla varias veces, usa 3@a (repite 3 veces).

6. Uso de buffers

• :e archivo.txt → Abrir un archivo en un nuevo buffer.

• :ls → Ver la lista de buffers abiertos.

• :b2 → Cambiar al buffer número 2.

• :bd → Cerrar el buffer actual.

7. Modo visual para seleccionar texto

• v → Entrar en modo visual.

• V → Seleccionar líneas completas.

• Ctrl + v → Selección en bloque (columnas).

• y → Copiar la selección.

• d → Cortar la selección.

8. Autocompletado

Mientras escribes en modo insert (i):

• Ctrl + n → Sugerencias de palabras basadas en el archivo actual.

• Ctrl + p → Buscar coincidencias previas en el archivo.

Estas son solo algunas funciones esenciales. ¿Te interesa alguna en particular o necesitas algo más avanzado? 🚀

Sort -k n

El comando sort -k en shell se usa para ordenar archivos o listas de datos en función de una columna específica.

Sintaxis básica

sort -k N archivo.txt

Donde N es el número de la columna a partir de la cual se quiere ordenar.

Ejemplos de uso

1. Ordenar por la segunda columna

Supongamos que tenemos un archivo datos.txt con este contenido:

Carlos 35
Ana 28
Luis 40
Elena 22

Si ejecutamos:

sort -k 2 -n datos.txt

El resultado será:

Elena 22
Ana 28
Carlos 35
Luis 40

Aquí, -k 2 indica que queremos ordenar por la segunda columna, y -n asegura que la ordenación sea numérica.

2. Ordenar alfabéticamente por la primera columna

sort -k 1 datos.txt

Salida:

Ana 28
Carlos 35
Elena 22
Luis 40

3. Ordenar en orden inverso

Si queremos ordenar de mayor a menor, usamos -r:

sort -k 2 -n -r datos.txt

Salida:

Luis 40
Carlos 35
Ana 28
Elena 22

Opciones útiles

• -n → Ordenación numérica.

• -r → Orden inverso (de mayor a menor).

• -t → Especificar un delimitador si los campos están separados por otro símbolo en vez de espacios.

  sort -t ',' -k 2 archivo.csv
  

• -k N,M → Ordenar por un rango de columnas.

¿Quieres que adapte esta explicación a un caso específico que estés trabajando?

Funciones Syntax y TOhtml de vim

Vim es un editor de texto muy potente, y dos de sus funciones útiles son :syntax y :TOhtml. Aquí te explico cómo funcionan:

1. :syntax (Resaltado de Sintaxis)

La función :syntax se usa para habilitar, deshabilitar o configurar el resaltado de sintaxis en Vim. Vim tiene soporte para resaltar la sintaxis de muchos lenguajes de programación, lo que facilita la lectura y edición de código.

• Para activar el resaltado de sintaxis:

  :syntax on
  

• Para desactivar el resaltado de sintaxis:

  :syntax off
  

• Para refrescar el resaltado de sintaxis (útil si algo no se ve bien):

  :syntax enable
  

Si estás editando un archivo y Vim no detecta automáticamente el lenguaje, puedes forzar la sintaxis con:

:set syntax=python   " Para Python
:set syntax=html     " Para HTML

Puedes ver qué tipo de sintaxis está activa con:

:set syntax?

2. :TOhtml (Convertir Código en HTML con Colores)

El comando :TOhtml convierte el contenido del archivo actual en un archivo HTML con resaltado de sintaxis, útil si quieres compartir código en una página web con los mismos colores que ves en Vim.

¿Cómo usarlo?

1. Abre un archivo en Vim con sintaxis habilitada.

2. Ejecuta el comando:

   :TOhtml
   

3. Vim generará un archivo HTML con el mismo código y resaltado de colores.

4. Guarda el archivo HTML con:

   :w nombre_archivo.html
   

5. Ahora puedes abrir el archivo HTML en un navegador y ver tu código con resaltado de colores.

Usos comunes:

• Compartir código en blogs o páginas web con formato atractivo.

• Crear documentación con código resaltado.

• Guardar capturas de código en formato HTML para referencia.

Si usas Vim frecuentemente para programar, estas funciones pueden hacerte la vida más fácil. ¿Quieres más detalles sobre alguna en particular?

comparador [[..]]

Aquí va otro truco útil para Shell Scripting:

Usa [[ ... ]] en lugar de [ ... ] para comparaciones más potentes en Bash

Cuando necesitas hacer comparaciones en un script, es mejor usar [[ ... ]] en lugar de [ ... ], ya que es más seguro y flexible.

📌 Ejemplo con [ ... ] (forma tradicional, menos potente)

#!/bin/bash

read -p "Introduce un número: " num

if [ "$num" -gt 10 ]; then
    echo "El número es mayor que 10"
fi

⚠️ Problemas:

• Necesita -gt en lugar de > para números.

• Puede fallar si num está vacío.

📌 Ejemplo con [[ ... ]] (mejor opción)

#!/bin/bash

read -p "Introduce un número: " num

if [[ $num -gt 10 ]]; then
    echo "El número es mayor que 10"
fi

✅ Ventajas de [[ ... ]]:

• Soporta operadores lógicos (&&, ||) sin necesidad de -a o -o.

• Permite comparaciones de cadenas con > y <.

• No es necesario poner comillas en variables.

📌 Ejemplo con comparaciones de cadenas

cadena="Hola"

if [[ $cadena == "Hola" ]]; then
    echo "Las cadenas son iguales"
fi

✅ Más legible y seguro que [ "$cadena" = "Hola" ].

🔥 Conclusión: Usa [[ ... ]] para condiciones más seguras y limpias en Bash. 🚀

Uso de $( ) en lugar de `...`

Aquí va otro truco útil para Shell Scripting:

Usa $(...) en lugar de las comillas invertidas `...` para capturar la salida de un comando

En Bash, a veces necesitas capturar la salida de un comando y guardarla en una variable. Aunque se pueden usar comillas invertidas, es mejor usar $(), ya que es más legible y admite anidación.

📌 Ejemplo con comillas invertidas (forma antigua y menos legible)

archivo=`ls | grep "log"`
echo "Archivo encontrado: $archivo"

⚠️ Problemas: Difícil de leer y propensa a errores si anidas comandos.

📌 Ejemplo con $() (mejor forma)

archivo=$(ls | grep "log")
echo "Archivo encontrado: $archivo"

✅ Más fácil de leer y admite anidación sin problemas.

📌 Ejemplo con anidación

resultado=$(grep "$(date +%Y-%m-%d)" registro.log)

🔹 Aquí, $(date +%Y-%m-%d) se evalúa primero y luego grep usa el resultado.

🔥 Conclusión: Usa $() en lugar de `...` para un código más limpio y seguro. 🚀

Usar fd en lugar de find

Usar fd en lugar de find para búsquedas más rápidas y fáciles

El comando find en Linux puede ser lento y tedioso, pero fd es una alternativa más rápida y con mejor sintaxis.

📌 Ejemplo: Buscar archivos con find vs fd

Con find:

find . -name "*.py"

Con fd (mucho más simple y rápido):

fd ".py"

📌 Ejemplo: Buscar archivos ignorando los de .gitignore

fd --hidden --no-ignore "*.log"

Esto muestra archivos ocultos pero ignora los excluidos en .gitignore.

🔹 Instalación:

• Ubuntu/Debian: sudo apt install fd-find

• macOS (Homebrew): brew install fd

• Windows (Scoop): scoop install fd

¡Mucho más rápido y cómodo que find! 🚀

Usar bat en lugar de cat

Usar bat en lugar de cat para leer archivos con colores y numeración

El comando cat es útil, pero bat mejora la visualización con:
✅ Colores para sintaxis (ideal para leer código)
✅ Numeración de líneas
✅ Integración con git (resalta cambios en archivos versionados)

📌 Ejemplo: Comparación entre cat y bat

Con cat:

cat script.py

Salida monótona en blanco y negro.

Con bat:

bat script.py

Salida con colores resaltados y líneas numeradas.

📌 Ejemplo: Ver diferencias en archivos Git

bat --diff script.py

Resalta los cambios en comparación con la última versión en Git.

🔹 Instalación:

• Ubuntu/Debian:

  sudo apt install bat
  

  ⚠️ En algunos sistemas, se instala como batcat, así que usa batcat archivo.py.

• macOS (Homebrew):

  brew install bat
  

• Windows (Scoop):

  scoop install bat
  

Con bat, lmucho nejor para ver archivos !!

Usa entr para ejecutar comandos automáticamente cuando un archivo cambia

Usa entr para ejecutar comandos automáticamente cuando un archivo cambia

Cuando trabajas con scripts o configuraciones y necesitas probar cambios sin ejecutar el comando manualmente cada vez, usa entr.

📌 Ejemplo: Ejecutar un script de Python cada vez que se modifique

Cada vez que guardes script.py, entr lo ejecutará automáticamente.

📌 Ejemplo: Reiniciar un servicio cuando un archivo de configuración cambia

Cada vez que edites y guardes nginx.conf, nginx se reiniciará automáticamente.

🔹 Instalación:

• Ubuntu/Debian: sudo apt install entr

• macOS (Homebrew): brew install entr

• Windows:

🔥 ¡Ideal para desarrollo ágil sin estar repitiendo comandos manualmente! 🚀