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

He escuchado de personas que han cambiado de una u otra forma y que juran por uno u otro.

Siendo un gran admirador de Eclipse pero no habiendo tenido el tiempo de probar IntelliJ, estoy interesado en escuchar de los usuarios de IntelliJ que son “ex eclipsianos” algunas cosas específicas que usted puede hacer con IntelliJ que no puede hacer con Eclipse.

Nota : Esta no es una pregunta subjetiva ni pretende convertirse en una guerra santa IDE. Por favor, rechaza cualquier respuesta flamebait .

CTRL-clic funciona en cualquier lugar

CTRL-clic que lo lleva al lugar donde se seleccionó el objeto funciona en todas partes, no solo en clases Java y variables en código Java, sino en configuración Spring (puede hacer clic en el nombre de la clase, propiedad o nombre del bean) en Hibernate ( puede hacer clic en el nombre o la clase de la propiedad, o en el recurso incluido), puede navegar dentro de un clic desde la clase Java hasta donde se utiliza como bean Spring o Hibernate; hacer clic en la etiqueta JSP o JSTL incluida también funciona, presionar ctrl-clic en la variable de JavaScript o la función 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 configuración de Hibernate (incluyendo clase, propiedad y nombres de columna DB), en configuración Spring

 

y le mostrará una lista de los granos que puede inyectar en esa propiedad.

Java

Autocompletar muy inteligente en código Java:

 interface Person { String getName(); String getAddress(); int getAge(); } //--- Person p; String name = p. 

y le muestra SÓLO getName () , getAddress () y toString () (solo que 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 autocompletar inteligente.

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

y lo autocompletará en silencio

 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; } 

y muestra SOLAMENTE getName () y getAddress () , sin importar cómo pueden 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 rutas a archivos, como

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

Ya sea depuración, refactorización, autocompletado … Intellij es mucho más fácil de usar con enlaces de teclas consistentes, opciones disponibles donde los busque, etc. En lo que respecta a las funciones, será difícil para intellij ponerse al día con Eclipse, ya que el este último tiene muchos más complementos disponibles que intellij, y es fácilmente extensible.

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

Por ejemplo, ambos tienen un editor rodeado de paneles dock para project, classpath, output, structure, etc. Pero en Idea cuando empiezo a escribir todos estos colapso automáticamente, permítanme centrarme en el código en sí mismo; En eclipse, todos estos paneles permanecen abiertos, dejando mi área de edición muy reducida, aproximadamente 1/5 del área total visible. 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 opuesto sucede exactamente con la ventana de salida de vista. En Idea, ejecutar un progtwig trae la ventana / panel de salida para ver la salida del progtwig, incluso si se minimizó perceptiblemente. En Eclipse tengo que agarrar el mouse nuevamente y buscar la pestaña de salida y hacer clic para ver la salida de mi progtwig, porque la ventana / panel de salida es solo otra, como el rest de las ventanas, pero en Idea se trata en de una manera especial: “Si el usuario desea ejecutar su progtwig, es muy probable que quiera ver el resultado de ese progtwig”. Parece muy natural cuando lo escribo, pero el eclipse falla en este concepto básico de interfaz de usuario.

Probablemente hay un atajo para esto en eclipse (ventana de salida de autohide mientras se edita y muestra automáticamente cuando se ejecuta el progtwig), pero como otras decenas de características, el atajo debe buscarse en foros, ayuda en línea, etc., mientras que en Idea es un poco más “. natural”.

Esto puede repetirse para casi todas las características que tienen, autocompletar, ajuste de palabras, 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 jar 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?

La Idea 8.0 tiene el adorable ctrl + shift + espacio x 2 que hace la siguiente autocompletar:

  City city = customer. 

resuelve a

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

a través de cualquier cantidad de niveles de getters / setters.

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-N le permite comenzar a escribir y actualizar las clases, nombres de métodos, nombres de variables, etc. de todo el proyecto.

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

Quiero crear una nueva SimpleTimeZone . SimpleTimeZone no tiene Constructor con cero argumentos.

Ctrl + espacio en Eclipse

enter image description here

Ctrl + espacio en IntelliJ

enter image description here

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

Después de entrar en Eclipse

enter image description here

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 scope actual y rellena el constructor con estos valores.

Después de Entrar en IntelliJ, nada sucede. Obtengo un constructor vacío. Tengo que presionar Ctrl + P para ver los argumentos esperados.

enter image description here

Si tiene el cursor sobre un método, presione CTRL + SHIFT + I para abrir la implementación del método. Si el método es un método de interface , puede usar flechas hacia arriba y hacia abajo para recorrer las implementaciones:

 Map m = ... m.contains|Key("Wibble"); 

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

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

Aunque echo de menos un complemento de FindBugs cuando uso IntelliJ (la integración de Eclipse / FindBugs es bastante buena).

Aquí hay una lista oficial de CodeInspections compatible con IntelliJ

EDITAR: Finalmente, hay un complemento de 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 refactorings.

Una cosa que utilizo regularmente es establecer un punto de interrupción, pero luego controlar lo que hace. (En mi último trabajo, casi todos los demás usaban 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, sino simplemente registrar un mensaje en la consola. Lo que significa que no tengo que ensuciar mi código con “System.out.println (…)” y luego volver a comstackr.

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

  • Acciones de autocompletar: al hacer ctrl + shift + a puede llamar cualquier acción de la idea desde el teclado sin recordar su combinación de teclas … ¡Piense en gnome-do o launchy en Windows, y ya tiene la idea! Además, esta característica es compatible con las abreviaturas de CamelCasing;)

  • Estantería: le permite mantener fácilmente separados algunos pedazos de código, y luego revisarlos a través del visor de diferencias.

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

  • Anotaciones e historial SVN: más fácil de inspeccionar, y también puede ver fácilmente el historial solo para una 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 integrada.

  • Refactores mucho más cerca de la mano, como la inserción de bucles, envoltura / fundición, cambio de nombre y agregar variables.

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

  • Mucho estable para trabajar con varias twigs de un gran proyecto al mismo tiempo (como un antiguo bifurcador de 1.5Gb por fonts de sucursal, y la necesidad de trabajar en ellas simultáneamente, la idea demostró sus capacidades sólidas)

  • Interfaz más simple y más limpia …

  • Y, más fácil de usar solo con el teclado, dejando de lado la necesidad de utilizar el mouse para muchas tomas simples, lo que le permite ahorrar tiempo y concentrarse más en el código … ¡donde importa!

Y ahora, al ser 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 reemplazar 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, usándolo 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 ha visto ni usado las listas de cambios , se está perdiendo la progtwigción del cielo.

La capacidad de rastrear mis archivos modificados (en mi twig de desarrollo ala clearcase) era algo que estaba buscando en un plugin para eclipse. Intellij realiza un seguimiento de todos sus cambios para una única confirmación, extremadamente fácil. Puede aislar archivos modificados con listas personalizadas. Lo uso para archivos de configuración que deben ser únicos a nivel local, pero se marcan constantemente cuando sincronizo o comparo contra el repository, enumerándolos en una lista de cambios, puedo monitorearlos, pero cuidadosamente los guardo para poder enfocarme 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. Al pegar el registro en el historial de trabajo de un ticket, se capturan los archivos, su versión, fecha / hora y la twig / tags. Es genial como el infierno.

Todo esto podría ser soportado a través de complementos (o mejoras futuras) en eclipse, apuesto; sin embargo, Intellij hace que esto sea una brisa.

Finalmente, estoy muy entusiasmado con el amor de la stream principal de 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 eclipses colgante. Tiene un código completo completo y lo considero en general “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 proyectos múltiples en ventanas diferentes en Eclipse. Puedo abrir proyectos múltiples, pero luego el sistema basado en vistas me intercambia un montón de cosas cuando cambio de archivos. Las inspecciones de código de IntelliJ parecen mejores. Sus ayudantes emergentes para arreglar problemas comunes son agradables. Hay 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 he tenido 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 raro.

Introducir variable ( Ctrl + Alt + V en Windows, Cmd + Alt + V en OSX)

Digamos que llamas a un método, service.listAllPersons() Presiona Ctrl + Alt + V y Enter , y se inserta la variable para el valor de retorno de la llamada al método:

 List list = service.listAllPersons(); 

Le ahorra tipeo, y no tiene que verificar el tipo de devolución del método al que está llamando. Especialmente útil cuando se usan generics, por ejemplo

 new ArrayList() 

[introducir variable]

 ArrayList stringArrayList = new ArrayList(); 

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

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

Para mí, es el soporte de maven 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 plug-in SVN muy superior que Subversive o Subclipse y funciona! La cantidad de tiempo que hemos desperdiciado fusionando archivos de origen usando Eclipse no tiene en cuenta. Esto no es un problema con IntelliJ porque el complemento te ayuda mucho más.

Además, el complemento de Subclipse no es confiable: regularmente tenemos casos en los que el complemento no cree que haya habido ningún código registrado en SVN por otros desarrolladores, pero sí lo ha hecho, ¡el servidor de CI lo ha procesado!

Emulador de VIM . Este complemento proporciona una emulación vi / vim / gvim casi completa al editar archivos en IDEA. La siguiente funcionalidad es compatible:

  • 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
  • Diagtwigs
  • Historial de línea de comando
  • Buscar Historia
  • Listas de salto
  • Ayuda de VIM

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

No puedo volver a ver ningún otro ide debido a este complemento. Lo mejor de ambos mundos … ¡Impresionante !. eso es lo que me faltaba en todos los IDEs.

Uno de los puntos buenos en mi opinión 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 stack de llamadas
  • La validación del código SQL en las cadenas pasó como argumentos a las llamadas jdbc (y todo el material de inyección del nuevo paquete)
  • implementado / sobreescrito en icons para interfaces y clases (y sus métodos) y la navegación de implementación inteligente (Ctrl + Alt + clic o Ctrl + Alt + B)
  • vinculación entre las interfaces EJB 2.1 y las clases de bean (incluido el soporte de refactorización); viejo, pero aún inmensamente valioso cuando se trabaja en proyectos más antiguos

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

Separadores de métodos: esas débiles líneas grises entre los 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 hacer esto un poco más claro, 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 mediante la técnica de superposición . Si está trabajando en una página web (ejecutándose 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 comstackción Maven, iniciar Jetty nuevamente y continuar. Este es el caso de Eclipse y casi todos los otros 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 le gustaría que se incluya en una comstackción de fondo. En consecuencia, terminas con un proceso que parece perfecto. You make a change to pretty much any code in the project and instantly it is available after you refresh the browser.

Very neat, and very fast.

I couldn’t imagine coding a front end in something like YUI backing onto DWR/SpringMVC without it.

Preamble to my answer: My use of Eclipse is limited. We needed a Java IDE to work on both Windows and Mac and the Mac port slowed down day by day. This was years ago and I’m sure it’s OK now. But that is what got us to switch to IntelliJ and we’ve been happy with it.

Now for my answer: One big difference I haven’t seen mentioned yet is that tech support is better with IntelliJ/Jet Brains. We send an e-mail to JetBrains and get a definitive answer back in less than an hour. Looking for answers to Eclipse problems results in the usual, “You stupid idiot” answers (usually a small number of the replies) along with the much larger number of insightful, helpful replies. But it takes some sorting through to get the real answer.

Something which I use in IntelliJ all the time is refactoring as I type. I have re-written classes from a printout (originally written in eclipse) using both IDEs and I used about 40% less key strokes/mouse clicks to write the same classes in IntelliJ than eclipse.

I wouldn’t want to use Eclipse until they support as much refactoring with incomplete pieces of code.

Here is a longer list of features in IntelliJ 8.0/8.1 [ http://www.jetbrains.com/idea/features/index.html%5D

There is one thing that IntelliJ does much much better than Eclipse and that is empty your pockets!

I do however prefer using it and one big advantage it has over Eclipce is the way it synchronises with the file system, for big projects and slow computers (yes in work environments the PC’s are a lot slower than our ones at home) Eclipse seems to struggle where IntelliJ seems to be quicker albeit with a slower initial indexing time.

IntelliJ Community edition obviously makes using it free but you soon want those extra refactoring and nice little goodies not included in the CC edition.

In my opinion, its generally a better user experience but whether its worth the cost is a question for each developer to answer themselves.

But lets be grateful we have up to three great IDEs for Java right now with NetBeans getting better all the time.

Data flow analysis : inter-procedural backward flow analysis and forward flow analysis, as described here . My experiences are based on Community Edition, which does data flow analysis fairly well. It has failed (refused to do anything) in few cases when code is very complex.

First of all I love intellij. There are at least a hundred features it has that eclipse lack. I’m talking magnitudes better in reliability and intelligence that no hyperbole can describe when it comes to refactoring, renaming, moving and others which have already been mentioned.

BUT, there is one thing that intellij does not allow which eclipse does. It does not allow running multiple projects at once under the same vm.

When you have separate projects for the front, middle, core, agents..etc, where they all have to interact with each other, you can not quickly modify and debug at the same time, afaik. The only way I current cope with this is to use ant scripts to deploy and update jars in dependent projects, or use maven.

Eclipse allows multiple projects to be debugged under one ide vm instance.