El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Estilo de Código y Convenciones

Siguiente ►
►

En este módulo, aprenderemos sobre las mejores prácticas y convenciones de estilo de código en Groovy. Seguir estas convenciones no solo hace que tu código sea más legible y mantenible, sino que también facilita la colaboración con otros desarrolladores.

  1. Importancia del Estilo de Código

El estilo de código es crucial por varias razones:

  • Legibilidad: Un código bien estructurado y consistente es más fácil de leer y entender.
  • Mantenibilidad: Facilita la actualización y el mantenimiento del código.
  • Colaboración: Ayuda a que los equipos de desarrollo trabajen de manera más eficiente y coherente.

  1. Convenciones de Nomenclatura

2.1. Nombres de Variables y Métodos

  • CamelCase: Utiliza camelCase para nombres de variables y métodos. 
    def firstName = "John"
def calculateTotalPrice() {
    // código
}

2.2. Nombres de Clases y Interfaces

  • PascalCase: Utiliza PascalCase para nombres de clases e interfaces. 
    class CustomerAccount {
    // código
}

interface PaymentProcessor {
    // código
}

2.3. Nombres de Constantes

  • UPPER_CASE: Utiliza UPPER_CASE con guiones bajos para constantes. 
    final int MAX_RETRIES = 5

  1. Formato de Código

3.1. Sangría

  • Espacios: Utiliza 4 espacios para la sangría. Evita el uso de tabulaciones. 
    if (condition) {
    println "Condition met"
}

3.2. Longitud de Línea

  • 80-120 caracteres: Mantén las líneas de código dentro de un rango de 80 a 120 caracteres para mejorar la legibilidad. 
    def longMethodNameWithManyParameters(param1, param2, param3, param4, param5) {
    // código
}

3.3. Espacios en Blanco

  • Espacios alrededor de operadores: Utiliza espacios alrededor de operadores para mejorar la legibilidad.

    def sum = a + b

  • Espacios después de comas: Utiliza espacios después de comas en listas y argumentos de métodos.

    def list = [1, 2, 3, 4]

  1. Comentarios

4.1. Comentarios de Línea

  • Uso moderado: Utiliza comentarios de línea para explicar partes complejas del código. 
    // Calcula el precio total con impuestos
def totalPrice = calculateTotalPrice()

4.2. Comentarios de Bloque

  • Documentación: Utiliza comentarios de bloque para documentar métodos y clases. 
    /**
 * Calcula el precio total de los productos en el carrito.
 *
 * @param cart Lista de productos en el carrito
 * @return Precio total
 */
def calculateTotalPrice(cart) {
    // código
}

  1. Estructura del Código

5.1. Declaraciones de Importación

  • Orden alfabético: Organiza las declaraciones de importación en orden alfabético y agrúpalas por paquetes. 
    import groovy.json.JsonSlurper
import java.util.Date
import java.util.List

5.2. Organización de Clases

  • Estructura lógica: Organiza las clases de manera lógica, agrupando métodos relacionados y manteniendo una estructura coherente. 
    class Order {
    String orderId
    Date orderDate

    def calculateTotal() {
        // código
    }

    def printOrderDetails() {
        // código
    }
}

  1. Ejemplo Práctico

A continuación, se muestra un ejemplo práctico que sigue las convenciones de estilo de código en Groovy:

// Importaciones
import groovy.json.JsonSlurper

// Clase principal
class ShoppingCart {
    List<Item> items = []

    // Agrega un artículo al carrito
    def addItem(Item item) {
        items << item
    }

    // Calcula el precio total de los artículos en el carrito
    def calculateTotalPrice() {
        items.sum { it.price }
    }

    // Imprime los detalles del carrito
    def printCartDetails() {
        items.each { item ->
            println "Item: ${item.name}, Price: ${item.price}"
        }
        println "Total Price: ${calculateTotalPrice()}"
    }
}

// Clase Item
class Item {
    String name
    double price
}

// Uso de la clase ShoppingCart
def cart = new ShoppingCart()
cart.addItem(new Item(name: 'Laptop', price: 999.99))
cart.addItem(new Item(name: 'Mouse', price: 25.50))
cart.printCartDetails()

  1. Ejercicio Práctico

Ejercicio

Crea una clase Library que gestione una colección de libros. Cada libro debe tener un título, un autor y un año de publicación. La clase Library debe tener métodos para agregar un libro, eliminar un libro por título y listar todos los libros.

Solución

class Book {
    String title
    String author
    int year
}

class Library {
    List<Book> books = []

    // Agrega un libro a la biblioteca
    def addBook(Book book) {
        books << book
    }

    // Elimina un libro por título
    def removeBook(String title) {
        books = books.findAll { it.title != title }
    }

    // Lista todos los libros
    def listBooks() {
        books.each { book ->
            println "Title: ${book.title}, Author: ${book.author}, Year: ${book.year}"
        }
    }
}

// Uso de la clase Library
def library = new Library()
library.addBook(new Book(title: 'Groovy in Action', author: 'Dierk König', year: 2007))
library.addBook(new Book(title: 'Programming Groovy 2', author: 'Venkat Subramaniam', year: 2013))
library.listBooks()
library.removeBook('Groovy in Action')
library.listBooks()

Conclusión

En esta sección, hemos cubierto las convenciones de estilo de código en Groovy, incluyendo la nomenclatura, el formato de código, los comentarios y la estructura del código. Seguir estas convenciones te ayudará a escribir código más limpio, legible y mantenible. En el próximo módulo, exploraremos la optimización del rendimiento en Groovy.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados