IntelliJ IDEA: consejos y trucos para usar en la vida cotidiana
IntelliJ es un entorno de desarrollo integrado con reconocimiento de contexto para trabajar con Java y otros lenguajes que se ejecutan en JVM, como Kotlin, Scala y Groovy.
Un punto importante a considerar al crear código es la elección del IDE. Por eso, este artículo proporcionará un conjunto completo de información sobre IntelliJ IDEA, crearemos un nuevo proyecto, navegaremos por él, utilizaremos técnicas de refactorización y el modo de depuración para analizar el código.
Veremos las facilidades que IntelliJ nos ofrece al declarar variables, controlar el flujo y en las propias estructuras de código.
También aprenderemos algunos consejos y trucos que podemos utilizar en IntelliJ IDEA en el día a día como personas desarrolladoras, aumentando la productividad en proyectos Java.
Uno de los primeros pasos al utilizar IntelliJ es configurar el esquema de teclas, el mapa de accesos directos que podemos utilizar durante el desarrollo con el IDE. La razón principal para hacer esto es familiarizarnos con los accesos directos disponibles, ya que pueden ahorrarnos tiempo de trabajo.
La forma tradicional de acceder al esquema de teclas es a través del menú File > Settings..., luego filtramos por "keymap":
Además de verificar los accesos directos a través de la opción "Settings", también podemos acceder al PDF que contiene todos los accesos directos de todos los sistemas operativos seleccionando "Help > Keymap Reference". Siéntete libre de consultar los accesos directos de la manera que te resulte más cómoda.
En general, tenemos los siguientes valores predeterminados según los diferentes sistemas operativos:
Por defecto, al presentar los accesos directos, los escribiremos primero como se pueden usar en Windows y luego, con una barra, como se pueden usar en Linux o Mac.
Windows y Linux / Mac
Una configuración realizada por muchas personas antes de comenzar a escribir códigos es la personalización de la apariencia de IntelliJ. Para ello, seleccione "File > Settings" y filtre por "Appearance":
En esta ventana, puede hacer los cambios que considere más adecuados para tu uso. En mi día a día, suelo mantener el valor de "Theme" como Darcula.
Como estamos iniciando nuestro desarrollo con la herramienta, vamos a seleccionar la opción "New Project":
Así se abrirá una nueva ventana en la que podemos configurar el proyecto. Seleccionaremos la opción "Java" en las opciones de proyecto.
Durante el artículo trabajaremos en un proyecto de un banco digital, por lo tanto, lo nombraremos en el campo "Project name" como "bytebank". En "Project location" se encuentra la ruta donde se encuentra nuestro proyecto.
En "Project SDK" dejamos la versión que está. En caso de que esta opción no aparezca en tu proyecto, simplemente haz clic en "New" y selecciona el directorio de instalación de tu JDK.
Después de esta configuración, simplemente haz clic en "Create".
A medida que todo se vaya cargando, tendremos una vista llamada "Project" y podremos visualizar toda la estructura de carpetas del proyecto.
El primer directorio es el nuestro, llamado bytebank. Dentro de él hay otro, el directorio .idea donde quedan todas las configuraciones de IntelliJ. También tenemos la carpeta src (source) donde pondremos todas nuestras clases Java.
Para crear una clase, simplemente haga clic derecho en la carpeta src y seleccione la opción "New" y luego "Java Class". Pero la gran ventaja de la IDE es poder hacer los mismos pasos con atajos. ¿Vamos a empezar?
Para manipular la vista (en inglés, view) del proyecto, podemos usar el acceso directo Alt + 1, ya que de esta manera es posible ocultar o mostrar la view. Después de la visualización, una buena opción es navegar por los directorios con las flechas del teclado.
Seleccionando la carpeta src con los accesos directos, podemos hacer clic Alt + insert para crear algún archivo. En esta carpeta, IntelliJ mostrará las opciones de archivos que tienen sentido en ese directorio.
Seleccionando la opción "Java Class", colocaremos el nombre de la clase de "Principal".
¿Pero cómo haremos para ejecutar la clase? Sabemos que para ejecutar, necesitamos un método main(). Podríamos escribir toda la firma del método, pero el IDE también consigue ayudarnos, simplemente escribiendo directamente dentro de un archivo. En el caso, dentro de la clase Principal escriba "psvm" y presione la tecla Tab para que la firma se escriba automáticamente:
public class Principal {
public static void main(String[] args) {
}
}
Después de implementar el método main(), utilice el template sout dentro de su cuerpo para implementar el método de impresión System.out.println(). La descripción de este template es Prints a string to System.out. Después de implementarla, agregue el mensaje "Bienvenido a Bytebank".
public class Principal {
public static void main(String[] args) {
System.out.println("Bienvenido a bytebank");
}
}
Ahora que tenemos la clase con el método main() listo, vamos a ejecutarla. Dentro de la clase Principal, utilice el atajo Alt + Shift + F10 / Ctrl + Shift + F10. De esta forma, IntelliJ interpretará que queremos ejecutar nuestra clase actual.
Tenga en cuenta que al principio enumerará algunas opciones de ejecución, así que elija la clase Principal. IntelliJ ejecutará e imprimirá: "Bienvenido a bytebank". ¡Ya has dado tus primeros pasos con intelliJ!
Inicialmente creamos nuestra clase Principal dentro del directorio raíz src. Sin embargo, al desarrollar programas en Java, seguimos la convención de usar paquetes que generalmente definen el dominio de nuestra aplicación.
Así que vamos a crear el paquete en nuestro proyecto para que nuestra clase Principal, así como otras clases que vamos a crear, estén organizadas.
Para crear los paquetes, accede a la vista del proyecto Alt + 1 / CMD + 1 y navega hasta el directorio src. Luego, utiliza la opción generate Alt + Insert / CMD + N. Con la opción "New" visible, escribe p... (o package) y verás que aparece la opción "Package". Presiona Enter y agrega el siguiente valor para el paquete: "br.com.alura.bytebank". Finalmente, haz clic en OK o presiona Enter nuevamente.
Ahora que tenemos el paquete, solo necesitamos mover nuestra clase Principal dentro de él. Para hacerlo, vaya al view project y navega hasta la clase. Luego, utiliza la feature "Move" de IntelliJ con el acceso directo "F6".
En este momento, se abrirá la ventana con el título "Move", opción para mover archivos dentro del proyecto. En este caso, indica que estamos moviendo la clase Principal. Define la ubicación de destino a través del campo "to package" y coloca el valor del paquete que creamos, br.com.alura.bytebank. Luego, presiona "Enter".
Observa que la clase se ha movido al paquete br.com.alura.bytebank, lo cual es fácil de notar por la instrucción "package" dentro del archivo:
package br.com.alura.bytebank;
public class Principal {
// código implementado
}
Ahora, cuando creamos nuevas clases haremos uso de ese paquete como raíz.
Ya hemos organizado nuestro proyecto, por lo tanto, haremos que el programa Bytebank sea capaz de almacenar empleados. Es decir, crearemos una clase que represente a un empleado en la vida real.
Debajo del código que muestra el mensaje de bienvenida, escribe "new Funcionario();". IntelliJ mostrará una advertencia indicando que no reconoce el símbolo "Funcionario". Esto significa que inicialmente no sabe cómo manejar esta parte del código.
Sin embargo, al tratarse de una expresión de creación de instancia, IntelliJ será lo suficientemente inteligente como para entender que existe la posibilidad de que queramos crear una clase.
Considerando esta y otras posibilidades, el IDE nos presenta sugerencias de acciones a través de la función "Show Intention Action" o mejor dicho, a través de sus sugerencias.
Para acceder a ellas, coloca el cursor sobre el símbolo que IntelliJ no reconoce, "Funcionario", y utiliza el acceso directo Alt + Enter.
Verás que aparece la opción "Crear clase 'Funcionario'", presiona "Enter" y luego se mostrará la posibilidad de definir el paquete en el cual queremos crear la clase. Esto ocurre porque IntelliJ no está completamente seguro de que queremos crear una clase en el mismo paquete.
Por lo tanto, define el paquete como br.com.alura.bytebank.model, ya que el empleado en sí forma parte de un modelo de nuestro proyecto. Por último, presiona "Enter".
El resultado después de crear la clase Funcionario es el mismo que cuando creamos la clase Principal:
package br.com.alura.bytebank.model;
public class Funcionario {
}
La diferencia está en que vamos a utilizar menos pasos para llegar a la solución.
Ahora que tenemos nuestra clase Funcionario, vamos a añadir algunos miembros a ella, los atributos, y encapsularlos como lo hacemos en varios modelos en nuestro día a día.
Para esa clase vamos a considerar los atributos de nombre, matricula y fecha de nacimiento. Al principio, Funcionario quedará así:
public class Funcionario {
String nombre;
int matricula;
LocalDate fechaNacimiento;
}
Según el principio de la programación orientada a objetos, debemos asegurarnos de que los atributos de las clases estén encapsulados, evitando el acceso directo. De esta manera, evitamos comportamientos no deseados.
Por lo tanto, debemos establecer el modificador de acceso como private, es decir, privado, para cada uno de los atributos en primer lugar. Sin embargo, al escribir la palabra clave private para cada uno de ellos, nos damos cuenta de que esta tarea no es eficiente, ya que simplemente tenemos que repetir el proceso.
Por lo tanto, vamos a cambiar al modo de selección de columna, lo que nos permitirá seleccionar toda una columna y modificar todos sus puntos a la vez. Para utilizar este modo de selección, haz clic en el atajo Alt + Shift + Insert / CMD + Shift + 8.
Observa que en la parte inferior derecha de la pantalla, IntelliJ mostrará el mensaje "Columna".
Antes:
Después:
Esto indica que el modo de selección por columna está habilitado. Ahora seleccione con el ratón o con las flechas + Shift la columna que deja el cursor delante de todos los atributos, algo próximo al siguiente ejemplo:
Ahora cuando escribas, nota que el "private" será escrito para todos. Después de realizar esta edición utilice el mismo atajo para alternar el modo de selección por línea que es el más común durante la edición de código de modo general:
public class Funcionario {
private String nombre;
private int matricula;
private LocalDate fechaNacimiento;
}
Ahora que todos los atributos son privados, solo necesitamos agregar los métodos de acceso, es decir, tanto los getters como los setters.
Considerando este contexto, tenemos la posibilidad de agilizar el proceso utilizando la función generate a través del atajo (Alt + Insert / CMD + N). Dentro de la clase Funcionario, utiliza generate y elige la opción "Getter and Setter", luego selecciona todos los atributos y presiona "Enter".
Después de seguir todos los pasos, tendremos una clase Funcionario de la siguiente manera:
public class Funcionario {
private String nombre;
private int matricula;
private LocalDate fechaNacimiento;
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getMatricula() {
return matricula;
}
public void setMatricula(int matricula) {
this.matricula = matricula;
}
public LocalDate getFechaNacimiento() {
return fechaNacimiento;
}
public void setFechaNacimiento(LocalDate fechaNacimiento) {
this.fechaNacimiento = fechaNacimiento;
}
Ahora que tenemos nuestro empleado listo, vamos a utilizarlo volviendo a nuestra clase Principal. Sin embargo, en lugar de utilizar la pestaña "Project", vamos a acceder directamente a ella.
Dado que vamos a acceder directamente a la clase, no tiene sentido mantener abierta la ventana de "view project", por lo tanto, podemos ocultarla.
Nuevamente, podríamos usar el mismo atajo que abre la vista (Alt + 1 / CMD + 1), ya que es parte de un atajo alternativo (abrir o cerrar). Sin embargo, también podemos ocultar todas las ventanas de una vista con el atajo Ctrl + Shift + F12 / CMD + Shift + F12.
Ahora, para acceder a la clase Principal, utilizaremos la función de búsqueda de clases de IntelliJ. Utilizaremos el atajo Ctrl + N / CMD + O, luego comienza a escribir "Pri" y verás cómo la herramienta ya filtrará la clase Principal. Presiona Enter y observa cómo IntelliJ se dirige directamente a la clase Principal.
Dentro del método main(), agrega el empleado "José" con la siguiente información:
Ten en cuenta que para realizar esta tarea debemos utilizar setters, algo poco objetivo considerando que toda la información es necesaria.
En otras palabras, para crear y agregar la información de un empleado simultáneamente, utilizaremos constructores personalizados que reciban todos los parámetros necesarios.
Por ejemplo, podemos agregar los parámetros al momento de la instancia:
Funcionario jose = new Funcionario("José", 1, LocalDate.of(1990, 2, 12));
Entonces, utilizamos las sugerencias de IntelliJ ("Alt + Enter") y elegimos la opción "Crear constructor".
Aunque funcione, debes tener en cuenta que el constructor creado no realiza automáticamente un proceso de bind, es decir, vincular los valores recibidos por el constructor con los atributos de la clase.
Pensando precisamente en facilitar este proceso, también podemos utilizar recursos que ya hemos visto, como el propio generate (Alt + Insert / CMD + N).
Para ello, accede nuevamente a la clase Funcionario y dentro de ella utiliza el generate.
Luego, elige la opción "Constructor" y selecciona todos los campos presionando "Shift + flechas" o haciendo clic con el mouse, y luego presiona "Enter".
Ahora, crea un toString() con el generate que muestre todos los atributos de la clase Funcionario.
Por último, imprime el empleado creado en la clase Principal y verifica si todo funciona correctamente.
Después de implementar todos los pasos, obtendremos el siguiente resultado:
public class Principal {
public static void main(String[] args) {
Funcionario jose = new Funcionario("José", 1, LocalDate.of(1990, 2, 12));
System.out.println(jose);
}
}
Clase Funcionario:
public class Funcionario {
private String nombre;
private int matricula;
private LocalDate fechaNacimiento;
public Funcionario(String nombre, int matricula, LocalDate fechaNacimiento) {
this.nombre = nombre;
this.matricula = matricula;
this.fechaNacimiento = fechaNacimiento;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public int getMatricula() {
return matricula;
}
public void setMatricula(int matricula) {
this.matricula = matricula;
}
public LocalDate getFechaNacimiento() {
return fechaNacimiento;
}
public void setFechaNacimiento(LocalDate fechaNacimiento) {
this.fechaNacimiento = fechaNacimiento;
}
@Override
public String toString() {
return "Funcionario{" +
"nombre='" + getNombre() + '\'' +
", matricula=" + getMatricula() +
", fechaNacimiento=" + getFechaNacimiento() +
'}';
}
}
Resultado después de ejecutar la clase principal:
Funcionario{nombre='José', matricula=1, fechaNacimiento=1990-02-12}
Para practicar, vamos a manipular el siguiente código:
import java.util.Scanner;
public class Saldo{
public static void main(String[] args) {
Scanner lectura = new Scanner(System.in);
System.out.println("Escribe el saldo:");
var saldo = lectura.nextDouble();double p = saldo * (10.0 / 100);
var valor = saldo + p;System.out.println("El saldo con el reajuste del 10% es: " + valor);
}
}
Observa que inicialmente es bastante difícil entender qué hace esta clase. Necesitamos realizar algunos procesos de refactorización para que el código sea más comprensible para los desarrolladores.
Antes de comenzar con las técnicas de refactorización, haremos una copia de la clase Saldo para compararla con el resultado final en los ejercicios siguientes. Coloca el cursor del mouse sobre el nombre de la clase o seleccionarla en la view project y utiliza el atajo "F5".
Luego, nombra la copia como SaldoCopia y déjala en el mismo paquete. Por último, presiona "Enter" o haz clic en OK. ¡Listo! Hemos logrado copiarla. Ahora podemos comenzar con nuestro proceso de refactorización en la clase Saldo.
La primera de las técnicas que podemos aplicar en este momento es la conocida formateación automática del código (lo que en IntelliJ se conoce como Reformat Code). Con esto ajustamos la indentación. Para formatear el código, simplemente utiliza el atajo Ctrl + Alt + L / Alt + CMD + L.
Con el código ajustado, necesitamos renombrar las variables. De esta manera, serán legibles para cualquier persona que programe. En otras palabras, realiza los siguientes cambios:
Para realizar este ajuste, pensando en el proceso de refactorización, podemos utilizar la opción de Renombrar (Rename) de IntelliJ con el atajo Shift + F6.
Con los cambios realizados, la clase Saldo tendrá el siguiente código:
import java.util.Scanner;
public class Saldo {
public static void main(String[] args) {
Scanner lectura = new Scanner(System.in);
System.out.println("Escribe el saldo:");
var saldo = lectura.nextDouble();
double porcentaje = saldo * (10.0 / 100);
var valorFinal = saldo + porcentaje;
System.out.println("El saldo con el reajuste del 10% es: " + valorFinal);
}
}
Así es más fácil comprender que estamos tratando directamente con pagos, ya que ya no tenemos aquellas variables que no dejan claro para qué sirven.
Search Everywhere nos permite buscar cualquier cosa dentro del proyecto, ya sean clases, archivos, símbolos y configuraciones.
Shift + Shift
Esto puede ser útil en escenarios que pasamos por varios archivos y tenemos muchas pestañas, pudiendo visualizar aquellos últimos que fueron abiertos.
Ctrl + E / CMD + E
Además de la búsqueda de cualquier elemento ("search Everywhere") y la búsqueda de archivos, también podemos hacer uso de la búsqueda de símbolos. En general, hacemos uso de este tipo de búsqueda cuando queremos encontrar clases, interfaces o miembros de ambas, es decir, atributos o métodos.
Ctrl + Shift + Alt + N/ CMD + Alt + O
Para realizar búsquedas de palabras clave, utilizamos Feature "Find in Path" a través del acceso directo:
Ctrl + Shift + F/ CMD + Shift + F
Y al realizar la búsqueda, es posible seguir para la próxima ocurrencia de la palabra clave a través del siguiente acceso directo:
Alt + J / Ctrl + G
Para realizar la búsqueda de archivos por el nombre en todo proyecto, utilizamos el acceso directo:
Ctrl + Shift + N / Meta + Shift + N
Entre dentro de una clase cualquiera y utilice el atajo "Ctrl + H". Tenga en cuenta que se abrirá la vista "Hierarchy", que representa la jerarquía de nuestras clases.
Ctrl + H
A través de "Find Usages" tenemos la capacidad de saber dónde se está utilizando nuestro código.
Tenga en cuenta que IntelliJ abrirá una ventana en la parte inferior, indicando un Overview de uso del punto de código en el que se utilizó el acceso directo. Esta Feature funciona para cualquier miembro de una clase, incluida ella misma.
Alt + F7
Esta es una característica que le permite buscar cualquier funcionalidad de IntelliJ. El acceso directo a ella es:
Ctrl + Shift + A / CMD + Shift + A
Podemos copiar líneas utilizando el siguiente atajo:
Ctrl + D / CMD + D
El recurso "declaration" verifica la implementación del código mediante el atajo. Con él, podemos navegar directamente hasta la parte en la que se implementó el código.
Ctrl + B / CMD + B
Como hemos visto, podemos tomar acciones según las sugerencias del IDE. Otra función interesante es "Introducir en variable local" (Introduce to Local Variable), que sugiere introducir una variable y luego solo necesitamos darle un nombre.
Alt + Enter
Una de las técnicas más comunes para verificar el comportamiento de nuestro código es la ejecución en modo de depuración (debug). Con ella, tenemos la capacidad de inspeccionar nuestro código línea por línea para verificar el resultado de la ejecución.
Cuando queremos ejecutar en este modo, debemos indicar en qué momento de nuestro código queremos realizar la inspección. Para ello, utilizamos puntos de interrupción (breakpoints). Para establecer un punto de interrupción, haz clic en el lado derecho del número de línea del código que deseas inspeccionar con el botón izquierdo del mouse.
A partir del momento en que se ejecuta en modo debug, observa que IntelliJ muestra una view de depuración.
Para ejecutar en modo de depuración, realizamos el mismo procedimiento que para las ejecuciones normales con "Run...", pero cambiamos el atajo final. Por lo tanto, utiliza el siguiente atajo: Alt + Shift + F9 / Ctrl + Shift + D.
El IntelliJ se detendrá exactamente en el punto del punto de interrupción y es posible utilizar las funcionalidades disponibles en este modo.
La primera de ellas es precisamente "Step Into", que ejecuta cada parte del código. Lo hacemos utilizando el atajo F7.
Este modo es muy efectivo en el punto del código que queremos entender en detalle lo que está sucediendo.
Aunque podemos navegar por todo el proyecto solo utilizando "Step Into", en algunos momentos puede no ser tan deseado, ya que durante la ejecución en modo de depuración, puede que no nos interese comprender ese código en tanto detalle.
Por lo tanto, también tenemos la capacidad de ejecutar toda la línea de código con "Step Over" utilizando el atajo F8. Esta funcionalidad es útil precisamente en las partes en las que solo queremos avanzar sin profundizar más en la información interna.
Otro escenario común es cuando entramos, sin querer, en un método que no queremos inspeccionar. Para casos como estos, podemos utilizar "Step Out" para salir del método con el atajo Shift + F8.
Para crear una variable utilizando atajos, tenemos las siguientes posibilidades:
Ten en cuenta que los atajos son muy similares, la única diferencia es la letra final.
Consejo: Para recordar fácilmente el atajo, recuerda que C proviene de constant (constante), F de field (campo o atributo) y V de variable (variable, en este caso variable local).
Para ayudarte, aquí tienes una tabla que muestra los principales atajos que hemos visto durante el estudio de IntelliJ:
| Atajo | Funcionalidad |
|---|---|
| Alt + 1 | Ocultar y mostrar la vista |
| Alt + Insert | Permite crear un archivo |
| "psvm" + Tab | Escribe automáticamente el método main |
| Alt + Shift + F10 / Ctrl + Shift + F10 | Ejecuta la clase actual |
| Alt + Enter | Opciones de acción mediante la función "Show Intention Action" - a través de sus sugerencias |
| Alt + Shift + Insert / CMD + Shift + 8 | Cambia al modo de selección de columna |
| Ctrl + N / CMD + O | Búsqueda de clase |
| Alt + Shift + flechas arriba o abajo | Mover líneas de código |
| Ctrl + Y / CMD + Delete/Backspace | Eliminar líneas de código |
| Ctrl + Shift + A / CMD + Shift + A | Búsqueda de acción: permite buscar cualquier funcionalidad de IntelliJ |
| Ctrl + B / CMD + B | Navegación por declaración |
| Alt + flechas (derecha o izquierda) / CMD + Shift + O | Navegación por pestañas |
| Ctrl + F4 / CMD + W | Cerrar la pestaña actual |
| Alt + Shift + X | Cerrar todas las pestañas |
| F5 | Copiar una clase |
| Ctrl + Alt + L / Alt + CMD + L | Formatear el código automáticamente, ajustando la identación |
| Shift + F6 | Renombrar variables con Rename |
| Ctrl + Alt + M / CMD + Alt + M | Extracción de método |
| Shift + Shift | Búsqueda en todas partes: permite buscar cualquier cosa dentro del proyecto |
| Ctrl + E / CMD + E | Ver todos los archivos recientes |
| Ctrl + Shift + Alt + N / CMD + Alt + O | Búsqueda de símbolos |
| Ctrl + Shift + F / CMD + Shift + F | Búsqueda de palabras clave |
| Alt + J / Ctrl + G | Seguir para la próxima ocurrencia de la palabra clave |
| Ctrl + Shift + N / Meta + Shift + N | Búsqueda de archivos |
| Ctrl + H | Visualización de jerarquía |
| Alt + F7 | Buscar usos |
| Alt + Home / CMD + flecha arriba | Navegación por barra |
| Ctrl + D / CMD + D | Copiar líneas |
| Ctrl + Shift + A / CMD + Shift + A | Búsqueda de acción |
| F7 | Paso a paso (Step Into) |
| F8 | Paso a paso siguiente (Step Over) |
| Shift + F8 | Salir del método actual (Step Out) |
| Ctrl + barra(/) / CMD + barra(/) | Comentarios |
| Ctrl + Alt + V / CMD + Alt + V | Variable local |
| Ctrl + Alt + F / CMD + Alt + F | Atributo |
| Ctrl + Alt + C / CMD + Alt + C | Constante |
En este artículo, hemos visto que podemos realizar las acciones que usamos con frecuencia de manera más objetiva mediante accesos directos. Aprendimos a crear un proyecto, navegar por él, utilizar técnicas de refactorización y el modo de depuración para analizar el código de manera más precisa.
Conocer el IDE que utilizas en tus proyectos es fundamental en la programación, ya que su uso impacta directamente en la productividad y optimización. Al utilizarlo de la mejor manera, el tiempo de trabajo puede reducirse porque el proceso se vuelve más ágil.
¿Tienes algún acceso directo que utilices con más frecuencia? ¡Buenos estudios y hasta luego!
Si este contenido te ha interesado, puedes acceder a los siguientes enlaces para potenciar tu aprendizaje:
Este artículo se basa en un contenido desarrollado por Alex Felipe en 2017.
Artículo hecho por Akemi Alice.
Artículo traducido por Brenda Souza.
Cursos de Programación, Front End, Data Science, Innovación y Gestión.
Luri es nuestra inteligencia artificial que resuelve dudas, da ejemplos prácticos y ayuda a profundizar aún más durante las clases. Puedes conversar con Luri hasta 100 mensajes por semana
Paga en moneda local en los siguientes países
Cursos de Programación, Front End, Data Science, Innovación y Gestión.
Luri es nuestra inteligencia artificial que resuelve dudas, da ejemplos prácticos y ayuda a profundizar aún más durante las clases. Puedes conversar con Luri hasta 100 mensajes por semana
Paga en moneda local en los siguientes países
Puedes realizar el pago de tus planes en moneda local en los siguientes países:
| País | | | | | | | |
|---|---|---|---|---|---|---|---|
| Plan Semestral |
485.97
BOB |
67481.43
CLP |
272188.41
COP |
65.90
USD |
262.33
PEN |
1196.40
MXN |
2678.90
UYU |
| Plan Anual |
736.71
BOB |
102297.35
CLP |
412619.46
COP |
99.90
USD |
397.68
PEN |
1813.67
MXN |
4061.03
UYU |
Acceso a todos
los cursos
Estudia las 24 horas,
dónde y cuándo quieras
Nuevos cursos
cada semana