¿Cosas posibles en IntelliJ que no son posibles en Eclipse?

He escuchado de personas que han cambiado en ambos sentidos y que juran por uno u otro.

Como soy un gran fanático de Eclipse pero no he tenido tiempo de probar IntelliJ, estoy interesado en escuchar de los usuarios de IntelliJ que son "ex-eclipsianos" algunas cosas específicas que puedes hacer con IntelliJ que no puedes hacer con Eclipse.

Nota : Esta no es una pregunta subjetiva ni pretende convertirse en una guerra santa IDE. Por favor, rechace cualquier respuesta de cebo de llama .

CTRL-click funciona en cualquier lugar

CTRL-click que lo lleva a donde se define el objeto cliqueado funciona en todas partes, no solo en las clases y variables Java en el código Java, sino en la configuración Spring (puede hacer clic en el nombre de la clase, o la propiedad, o el nombre del bean), en Hibernate (usted puede hacer clic en el nombre de propiedad o clase, o en el recurso incluido), puede navegar con un clic desde la clase de Java hasta donde se utiliza como Spring o Hibernate bean; hacer clic en la etiqueta JSP o JSTL incluida también funciona, ctrl-clic en la variable o función de JavaScript lo lleva al lugar donde está definido o muestra un menú si hay más de un lugar, incluidos otros archivos .js y código JS en HTML o JSP archivos.

Autocompletar para muchos idiomas

Hibernar

Autocompletar en expresiones HSQL, en la configuración de Hibernate (incluidos los nombres de clase, propiedad y columna de base de datos), en la configuración de Spring

<property name="propName" ref="<hit CTRL-SPACE>"

y le mostrará una lista de esos beans que puede inyectar en esa propiedad.

Java

Autocompletado muy inteligente en código Java:

interface Person {
    String getName();
    String getAddress();
    int getAge();
}
//---
Person p;
String name = p.<CTRL-SHIFT-SPACE>

y muestra SOLO getName () , getAddress () y toString () (solo son compatibles por tipo) y getName () es el primero en la lista porque tiene un nombre más relevante. La última versión 8 que todavía está en EAP tiene aún más autocompletado inteligente.

interface Country{
}
interface Address {
    String getStreetAddress();
    String getZipCode();
    Country getCountry();
}
interface Person {
    String getName();
    Address getAddress();
    int getAge();
}
//--- 
Person p;
Country c = p.<CTRL-SHIFT-SPACE>

y silenciosamente lo completará automáticamente

Country c = p.getAddress().getCountry();

Javascript

Autocompletar inteligente en JavaScript.

function Person(name,address) {
    this.getName = function() { return name };
    this.getAddress = function() { return address };
}

Person.prototype.hello = function() {
    return "I'm " + this.getName() + " from " + this.get<CTRL-SPACE>;
}

y muestra SOLO getName () y getAddress () , no importa cómo puede obtener * los métodos que tiene en otros objetos JS en su proyecto, y ctrl-click en this.getName () lo lleva a donde está definido, incluso si Hay algunas otras funciones getName () en su proyecto.

HTML

¿Mencioné autocompletar y Ctrl-clic en las rutas a los archivos, como <script src = "", <img src = "", etc.

Autocompletar en atributos de etiqueta HTML. Autocompletar en el atributo de estilo de etiquetas HTML, tanto nombres de atributos como valores. Autocompletar en atributos de clase también.
Escriba <div class = "<CTRL-SPACE> y le mostrará una lista de las clases CSS definidas en su proyecto. Elija una, presione Ctrl y haga clic en ella y será redirigido a donde está definida.

Fácil resaltado de idioma propio

La última versión tiene inyección de idioma, por lo que puede declarar que su etiqueta JSTL personalizada generalmente contiene JavaScript y resaltará JavaScript dentro de ella.

<ui:obfuscateJavaScript>function something(){...}</ui:obfuscateJavaScript>

Búsqueda indexada en todos los proyectos.

Puede usar Buscar usos de cualquier clase o método Java y encontrará dónde se usa, incluidas no solo las clases Java, sino también Hibernate, Spring, JSP y otros lugares. El método de cambio de nombre refactoriza el método de cambio de nombre no solo en las clases de Java, sino también en cualquier lugar, incluidos los comentarios (no se puede estar seguro de si la cadena en los comentarios es realmente el nombre del método, por lo que preguntará). Y encontrará solo su método, incluso si hay métodos de otra clase con el mismo nombre. Buena integración de control de fuente (¿SVN admite listas de cambios? IDEA las admite para cada control de fuente), capacidad de crear un parche con sus cambios para que pueda enviar sus cambios a otro miembro del equipo sin comprometerlos.

Depurador mejorado

Cuando miro HashMap en la ventana de observación del depurador, veo una vista lógica: claves y valores, la última vez que lo hice en Eclipse mostraba entradas con hash y campos siguientes. Realmente no estoy depurando HashMap , solo quiero mirar Contiene.

Validación de configuración de Spring e Hibernate

Valida la configuración de Spring e Hibernate justo cuando la edita, por lo que no necesito reiniciar el servidor para saber que escribí mal el nombre de la clase o agregué el parámetro del constructor para que mi Spring cfg no sea válido.

La última vez que lo intenté, no pude ejecutar Eclipse en Windows XP x64.

y le sugerirá person.name o person.address . Presione Ctrl y haga clic en person.name y lo llevará al método getName () de la clase Person .

Escriba Pattern.compile("");put \\ allí, presione CTRL-SPACE y vea sugerencias útiles sobre lo que puede poner en su expresión regular. También puede usar la inyección de idioma aquí: defina su propio método que toma el parámetro de cadena, declare en el cuadro de diálogo de opciones de IntelliLang que su parámetro es una expresión regular, y también le dará autocompletar allí. No hace falta decir que resalta las expresiones regulares incorrectas.

Otras características

Hay pocas características que no estoy seguro están presentes en Eclipse o no. Pero al menos cada miembro de nuestro equipo que usa Eclipse, también usa alguna herramienta de fusión para fusionar cambios locales con cambios del control de origen, generalmente WinMerge. Nunca lo necesito, fusionarme en IDEA es suficiente para mí. Con 3 clics puedo ver la lista de versiones de archivos en el control de código fuente, con 3 clics más puedo comparar versiones anteriores o anteriores y actuales, y posiblemente fusionarlas.

Permite especificar que necesito todos los archivos .jars dentro de la WEB-INF\libcarpeta, sin elegir cada archivo por separado, por lo que cuando alguien confirma un nuevo archivo .jar en esa carpeta, lo recoge automáticamente.

Lo mencionado anteriormente es probablemente el 10% de lo que hace. No uso Maven, Flex, Swing, EJB y muchas otras cosas, por lo que no puedo decir cómo ayuda con ellos. Pero lo hace.

Solo hay una razón por la que uso intellij y no eclipse: usabilidad

Ya sea que se trate de depuración, refactorización, autocompletado ... Intellij es mucho más fácil de usar con combinaciones de teclas consistentes, opciones disponibles donde las busca, etc. este último tiene muchos más complementos disponibles que intellij, y es fácilmente extensible.

Probablemente no se trata de lo que se puede / no se puede hacer, sino de cómo .

Por ejemplo, ambos tienen un editor rodeado de paneles de acoplamiento para proyecto, classpath, salida, estructura, etc. Pero en Idea, cuando empiezo a escribir, todos estos colapsos automáticamente me permiten centrarme en el código; En eclipse, todos estos paneles se mantienen abiertos, dejando el área de mi editor muy reducida, aproximadamente 1/5 del área visible total. Así que tengo que agarrar el mouse y hacer clic para minimizar en esos paneles. Hacer esto todo el día es una experiencia muy frustrante en eclipse.

Lo exactamente opuesto sucede con la ventana de salida de la vista. En Idea, ejecutar un programa trae la ventana / panel de salida para ver la salida del programa, incluso si se minimizó previamente. En eclipse, tengo que agarrar mi mouse nuevamente y buscar la pestaña de salida y hacer clic para ver la salida de mi programa, porque la ventana / panel de salida es solo otra, como todas las demás ventanas, pero en Idea se trata en una forma especial: "¡Si el usuario quiere ejecutar su programa, es muy probable que quiera ver la salida de ese programa!" Parece tan natural cuando lo escribo, pero eclipse falla en este concepto básico de interfaz de usuario.

Probablemente hay un acceso directo para esto en eclipse (ventana de salida de ocultación automática mientras se edita y muestra automáticamente cuando se ejecuta el programa), pero como algunas otras decenas de características, el acceso directo debe buscarse en foros, ayuda en línea, etc., mientras que en Idea es un poco más " natural".

Esto se puede repetir para casi todas las características que ambos tienen, autocompletar, ajuste de texto, vista rápida de documentación, todo. Creo que la experiencia del usuario es mucho más agradable en Idea que en eclipse. Entonces el lema se hace realidad "Desarrollar con placer"

Eclipse maneja proyectos más grandes y más rápidos (+300 frascos y +4000 clases) y creo que IntelliJ Idea 8 está trabajando en esto.

Todo esto, por supuesto, es subjetivo. ¿Cómo podemos medir la experiencia del usuario?

Idea 8.0 tiene la encantadora ctrl+shift+spacex 2 que realiza el siguiente autocompletado:

 City city = customer.<ctrl-shift-space twice>

resuelve a

 City city = customer.getAddress().getCity();

a través de cualquier número de niveles de captadores / establecedores.

No olvides "comparar con el portapapeles".

Algo que uso todo el tiempo en IntelliJ y que no tiene equivalente en Eclipse.

Mi atajo favorito en IntelliJ que no tiene equivalente en Eclipse (que he encontrado) se llama 'Ir al símbolo'. CTRL-ALT-SHIFT-Nle permite comenzar a escribir y englobar clases, nombres de métodos, nombres de variables, etc., de todo el proyecto.

Traté de cambiar a IntelliJ debido al nuevo Android Studio. Pero ahora estoy muy decepcionado. Estoy usando Eclipse con el complemento de Recommanders de código . Aquí hay un ejemplo simple de por qué Eclipse es tan increíble:

Quiero crear una nueva SimpleTimeZone. SimpleTimeZoneno tiene constructor con cero argumentos.

Ctrl + Space en Eclipse

Ctrl + Space en IntelliJ

En IntelliJ no obtengo información sobre qué tipo de constructores SimpleTimeZonetiene.

Después Enteren Eclipse

Obtengo el constructor previamente seleccionado lleno de nombres de variables predefinidos. Y puedo ver el tipo de cada argumento. Con Code Recommanders, Eclipse adivina el constructor correcto por los tipos de variables previamente definidos en el alcance actual y llena el constructor con estos vars.

Después Enteren IntelliJ no pasa nada. Tengo un constructor vacío. Tengo que presionar Ctrl + Ppara ver los argumentos esperados.

Si tiene el cursor en un método, CTRL+SHIFT+Iaparecerá la implementación del método. Si el método es un interfacemétodo, puede usar las flechas hacia arriba y hacia abajo para recorrer las implementaciones:

Map<String, Integer> m = ...
m.contains|Key("Wibble");

Donde | es (por ejemplo) donde está su cursor.

IntelliJ tiene algunas inspecciones de código bastante avanzadas (comparables pero diferentes a FindBugs).

Aunque realmente extraño un complemento FindBugs cuando uso IntelliJ (La integración Eclipse / FindBugs es bastante genial).

Aquí hay una lista oficial de CodeInspections compatible con IntelliJ

EDITAR: Finalmente, hay un complemento findbugs para IntelliJ. Todavía es un poco beta, ¡pero la combinación de Code Inspections y FindBugs es simplemente increíble!

Mucho, mucho, mucho más refactorizaciones.

Una cosa que uso regularmente es establecer un punto de interrupción, pero luego controlar lo que hace. (En mi último trabajo, la mayoría de los demás usaron Eclipse ... Recuerdo que me sorprendió que nadie pudiera encontrar cómo hacer esto en Eclipse).

Por ejemplo, puede hacer que el punto de interrupción no se detenga realmente, sino que simplemente registre un mensaje en la consola. Lo que significa que no tengo que llenar mi código con "System.out.println (...)" y luego volver a compilar.

Hay muchas cosas que la idea resuelve de una manera mucho más simple, o no hay equivalente:

• Acciones de autocompletar: Al hacer esto ctrl+shift+a, puedes llamar a cualquier acción de idea desde el teclado sin recordar su combinación de teclas ... Piensa en gnome-do o launchy en windows, ¡y tienes la idea! Además, esta función admite las abreviaturas CamelCasing;)

• Shelf: le permite guardar fácilmente algunos fragmentos de código y luego revisarlos a través del visor de diferencias.

• Historia local: se maneja mucho mejor y es más simple.

• Anotaciones e historial SVN: más fáciles de inspeccionar, y también puede ver fácilmente el historial solo para esa parte de un archivo fuente completo.

• Autocompletar en todas partes, como la expresión de evaluación y las ventanas de condición de punto de interrupción.

• Integración de Maven ... mucho, mucho más simple y bien integrado.

• Refactores mucho más cercanos a la mano, como inserción de bucles, ajuste / conversión, cambio de nombre y agregar variables.

• Encuentra mucho más poderoso y bien organizado. Incluso en grandes proyectos.

• Muy estable para trabajar con varias ramas de un gran proyecto al mismo tiempo (como un antiguo solucionador de errores de 1.5 Gb por fuentes de sucursales, y la necesidad de trabajar en ellas simultáneamente, la idea muestra sus capacidades sólidas)

• Interfaz más limpia y simple ...

• Y, más fácil de usar solo con el teclado, dejando de lado la necesidad de usar el mouse para muchas tareas simples, ahorrándole tiempo y concentrándose más en el código ... ¡donde importa!

Y ahora, siendo de código abierto ... la base de usuarios de Idea crecerá exponencialmente.

Búsqueda estructural y reemplazo.

Por ejemplo, busque algo como:

  System.out.println($string$ + $expr$);

Donde $ string $ es un literal y $ expr $ es una expresión de tipo my.package.and.Class, y luego reemplace con:

  $expr$.inspect($string$);

Mi tiempo puede estar un poco apagado en términos de este hilo, pero solo tuve que responder.

Soy un gran fanático del eclipse, lo uso desde su primera aparición. Un amigo me dijo entonces (hace más de 10 años) que sería un jugador. Él estaba en lo correcto.

¡Sin embargo! Acabo de empezar a usar IntelliJ y si no has visto o usado listas de cambios , te estás perdiendo la programación del cielo.

La capacidad de rastrear mis archivos modificados (en mi rama de desarrollo ala clearcase) era algo que estaba buscando en un complemento para eclipse. Intellij rastrea todos sus cambios para una sola confirmación, extremadamente fácil. Puede aislar archivos modificados con listas personalizadas. Lo uso para los archivos de configuración que deben ser únicos localmente, pero se marcan constantemente cuando sincronizo o comparo con el repositorio: enumerándolos en una lista de cambios, puedo monitorearlos, pero los guardo cuidadosamente para poder concentrarme en las adiciones reales Estoy haciendo.

Además, hay un complemento Commit Log que genera un texto de todos los cambios para aquellos SCCS que no están integrados con su software de seguimiento de errores. Pegar el registro en el historial de trabajo de un ticket captura los archivos, su versión, fecha / hora y la rama / etiquetas. Es genial como el infierno.

Apuesto a que todo esto podría ser soportado a través de complementos (o mejoras futuras) en eclipse; Sin embargo, Intellij hace que esto sea fácil.

Finalmente, estoy realmente entusiasmado con el amor principal por este producto: las pulsaciones de teclas, por lo que es doloroso, pero divertido.

El depurador IntelliJ tiene una característica muy útil llamada "Evaluar expresión", que es mucho mejor que el colgante eclipse. Tiene código completo completo y considero que generalmente es "más útil".

Bueno, para mí son mil cosas pequeñas. Algunas de las macros, el diseño de la GUI en general en Eclipse me parece horrible. No puedo abrir varios proyectos en diferentes ventanas en Eclipse. Puedo abrir varios proyectos, pero luego su sistema basado en la vista intercambia un montón de cosas cuando cambio los archivos. Las inspecciones de código de IntelliJ parecen mejores. Sus ayudantes emergentes para solucionar problemas comunes son agradables. Muchas cosas sencillas de usabilidad como la barra lateral donde puedo pasar el cursor sobre un punto caliente y me dirá cada subclase de implementación de un método o el método que estoy implementando y desde dónde.

Cada vez que tengo que usar, o ver a alguien usar, Eclipse parece que pueden hacer la mayoría de las cosas que puedo hacer en IntelliJ, pero les lleva más tiempo y es más complicado.

Introducir variable. ( Ctrl+Alt+Ven Windows, Cmd+Alt+Ven OSX)

Digamos que usted llama a un método, service.listAllPersons() Hit Ctrl+Alt+Vy Enter, y se inserta una variable para el valor de retorno de la llamada al método:

List<Person> list = service.listAllPersons();

Le ahorra escribir y no tiene que verificar el tipo de devolución del método al que está llamando. Especialmente útil cuando se usan genéricos, p. Ej.

new ArrayList<String>()

[introducir variable]

ArrayList<String> stringArrayList = new ArrayList<String>();

(por supuesto, puede cambiar fácilmente el nombre de la variable antes de presionar Enter)

IntelliJ tiene soporte intellisense y refactorización de código en documentos jspx.

Para mí, el soporte experto de IDEA, especialmente en la versión 9, es insuperable. La sincronización sobre la marcha del proyecto con el modelo maven es simplemente fantástica y hace que el desarrollo sea agradable.

¡Intellij tiene un complemento SVN muy superior al de Subversive o Subclipse y funciona! La cantidad de tiempo que hemos perdido fusionando archivos fuente usando Eclipse no tiene que pensar. Esto no es un problema con IntelliJ porque el complemento te ayuda mucho más.

Además, el complemento Subclipse no es confiable: regularmente tenemos casos en los que el complemento no cree que otros desarrolladores hayan ingresado ningún código en SVN, pero el servidor de CI los ha procesado.

VIM Emulator. Este complemento proporciona una emulación vi / vim / gvim casi completa al editar archivos en IDEA. Se admite la siguiente funcionalidad:

• Teclas de movimiento
• Eliminación / Cambio
• Insertar comandos de modo
• Marcas
• Registros
• VIM deshacer / rehacer
• Comandos de modo visual
• Algunos comandos Ex
• Algunos: establecer opciones
• Expresiones regulares VIM completas para búsqueda y búsqueda / reemplazo
• Macros
• Diagramas
• Historial de línea de comando
• Buscar Historia
• Listas de salto
• Ayuda VIM

algunos comentarios sobre este complemento de http://plugins.jetbrains.net/plugin/?id=164

En mi opinión, uno de los puntos positivos es la Matriz de estructura de dependencia : http://www.jetbrains.com/idea/features/dependency_analysis.html#link0

Hay una buena introducción al uso y los beneficios de DSM en el sitio web de Lattix (un producto independiente): http://www.lattix.com/files/dl/slides/s.php?directory=4tour

Algunas otras cosas:

• propagar parámetros / excepciones al cambiar la firma del método, muy útil para actualizar métodos en el interior de la pila de llamadas
• La validación del código SQL en las cadenas pasadas como argumentos a las llamadas jdbc (y todo el material de inyección de lenguaje recientemente incluido)
• implementado en / sobreescrito en iconos para interfaces y clases (y sus métodos) y la navegación de implementación inteligente (Ctrl + Alt + Click o Ctrl + Alt + B)
• vinculación entre las interfaces EJB 2.1 y las clases de bean (incluido el soporte de refactorización); antiguo, pero aún inmensamente valioso cuando se trabaja en proyectos más antiguos

Dos cosas que IntelliJ hace que Eclipse no hace son muy valiosas para mí:

Separadores de métodos: esas líneas grises débiles entre métodos hacen que el código sea mucho más legible

Anti-aliasing de texto: hace que el código se vea tan bien en el IDE

Una característica muy útil es la capacidad de construir parcialmente un proyecto de reactor Maven para que solo se incluyan las piezas que necesita.

Para aclarar esto un poco, considere el caso de una colección de archivos WAR con muchos recursos comunes (por ejemplo, JavaScript, archivos de configuración de Spring, etc.) que se comparten entre ellos utilizando la técnica de superposición . Si está trabajando en alguna página web (que se ejecuta en Jetty) y desea cambiar parte del código de superposición que se encuentra en un módulo separado, normalmente esperaría tener que detener Jetty, ejecutar la compilación Maven, iniciar Jetty nuevamente y Seguir. Este es el caso con Eclipse y casi todos los demás IDE con los que he trabajado. No es así en IntelliJ. Usando la configuración del proyecto, puede definir qué faceta de qué módulo desea que se incluya en una compilación en segundo plano. En consecuencia, terminas con un proceso que parece perfecto. Realiza un cambio en casi cualquier código del proyecto e instantáneamente está disponible después de actualizar el navegador.

Muy ordenado y muy rápido.

No podía imaginarme codificar una interfaz en algo así como YUI retrocediendo en DWR / SpringMVC sin ella.

Preámbulo de mi respuesta: mi uso de Eclipse es limitado. Necesitábamos un IDE de Java para trabajar tanto en Windows como en Mac y el puerto de Mac se ralentizó día a día. Esto fue hace años y estoy seguro de que está bien ahora. Pero eso es lo que nos hizo cambiar a IntelliJ y estamos contentos con eso.

Ahora para mi respuesta: una gran diferencia que aún no he mencionado es que el soporte técnico es mejor con IntelliJ / Jet Brains. Enviamos un correo electrónico a JetBrains y recibimos una respuesta definitiva en menos de una hora. La búsqueda de respuestas a los problemas de Eclipse da como resultado las respuestas habituales de "Estúpido idiota" (generalmente una pequeña cantidad de respuestas) junto con una cantidad mucho mayor de respuestas útiles y perspicaces. Pero toma un poco de clasificación para obtener la respuesta real.

Algo que uso en IntelliJ todo el tiempo está refactorizando a medida que escribo. He reescrito las clases de una copia impresa (originalmente escrita en eclipse) usando ambos IDEs y usé aproximadamente 40% menos pulsaciones de teclas / clics del mouse para escribir las mismas clases en IntelliJ que eclipse.

No quisiera usar Eclipse hasta que admitan tanta refactorización con piezas de código incompletas.

Aquí hay una lista más larga de características en IntelliJ 8.0 / 8.1 [ http://www.jetbrains.com/idea/features/index.html]

¡Hay una cosa que IntelliJ hace mucho mucho mejor que Eclipse y es vaciar sus bolsillos!

Sin embargo, prefiero usarlo y una gran ventaja que tiene sobre Eclipce es la forma en que se sincroniza con el sistema de archivos, para grandes proyectos y computadoras lentas (sí, en entornos de trabajo, las PC son mucho más lentas que las nuestras en casa) Eclipse parece lucha donde IntelliJ parece ser más rápido, aunque con un tiempo de indexación inicial más lento.

La edición de IntelliJ Community obviamente hace que usarlo sea gratis, pero pronto querrás esas refactorizaciones adicionales y pequeñas cosas buenas no incluidas en la edición CC.

En mi opinión, generalmente es una mejor experiencia de usuario, pero si cada uno de los desarrolladores se merece la pena el costo es una pregunta que deben responderse.

Pero agradezcamos que tenemos hasta tres IDE excelentes para Java en este momento con NetBeans mejorando todo el tiempo.

Análisis de flujo de datos : análisis de flujo hacia atrás entre procedimientos y análisis de flujo hacia adelante, como se describe aquí . Mis experiencias se basan en Community Edition, que hace bastante bien el análisis del flujo de datos. Ha fallado (se negó a hacer nada) en algunos casos cuando el código es muy complejo.

En primer lugar me encanta intellij. Hay al menos un centenar de características que tiene esa falta de eclipse. Estoy hablando de magnitudes mejores en confiabilidad e inteligencia que ninguna hipérbole puede describir cuando se trata de refactorizar, renombrar, mover y otros que ya se han mencionado.

PERO, hay una cosa que intellij no permite qué eclipse sí. No permite ejecutar múltiples proyectos a la vez bajo el mismo vm.

Cuando tiene proyectos separados para el frente, el medio, el núcleo, los agentes, etc., donde todos tienen que interactuar entre sí, no puede modificar y depurar rápidamente al mismo tiempo, afaik. La única forma en que actualmente me las arreglo es usar scripts de hormigas para implementar y actualizar archivos jar en proyectos dependientes, o usar maven.

Eclipse permite la depuración de múltiples proyectos bajo una instancia ide vm.