blocks|key|880069|text|节省开发时间|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880070|通过提供集成调试、intellisense等功能，使生活变得更容易。|880071|有很多，但会推荐使用一个，他们是非常明显的。|880072|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Saves time to develop
 
Makes life easier by providing features like Integrated debugging, intellisense.

There are lot many, but will recommend to use one, they are more than obvious.

blocks|key|1225762|text|代码完成。它对探索代码有很大帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225763|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Code completion. It helps a lot with exploring code.

blocks|key|226642|text|拥有IDE有以下优点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|226643|编译通常是“动态的”，这意味着不再切换到命令行进行编译。|unordered-list-item|226644|调试是集成在IDE中的，这意味着步骤调试器实际上使用您的就地编辑器来直观地显示执行了哪些代码。|226645|IDE通常对您所使用的语言有更多的语义知识，并且可以在打字时显示出可能的问题。重构比“搜索替换”更强大。|226646|还有很多，也许你应该试一试。|226647|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|O|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Q|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|L|$]]

Having an IDE has the following advantages:

<ul>
<li>Compiling is usually "on the fly" which means no more switching to the command line to compile</li>
<li>Debugging is integrated, and having that in an IDE means that the step debugger actually uses your in-place editor to visually show you which code is executed</li>
<li>IDE's usually have more semantic knowledge of the language you're working in, and can show you possible problems while typing. Refactoring is much more powerfull than the "search replace".</li>
</ul>

There are much more, maybe you should give it a try.

blocks|key|1225864|text|这确实取决于您使用的是哪种语言，但在C#和Java中，我发现IDE对以下方面有好处：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1225865|快速导航到类型，而不需要担心命名空间、项目等|unordered-list-item|1225866|通过将成员视为超链接导航到成员|1225867|当您记不起所有成员的名称时，自动完成|1225868|自动代码生成|1225869|重构(大规模重构)|1225870|组织导入(使用C#中的指令，在Java中自动添加适当的导入)|1225871|警告类型(即有些错误甚至不需要编译周期)|1225872|盘旋在某物上看医生|1225873|以一种有用的方式将文件、错误/警告/控制台/单元测试等和源代码同时保存在屏幕上。|1225874|从同一个窗口运行单元测试的方便性|1225875|集成调试|1225876|集成源控制|1225877|导航到编译时错误或运行时异常直接从错误详细信息中发生的位置。|1225878|等!|1225879|所有这些都节省了时间。这是我可以手动做的事情，但更痛苦的是:我宁愿编码。|1225880|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|1A|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|1B|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1C|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|1D|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1E|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|1F|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1G|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1H|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1I|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1J|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1K|8|@]|9|@]|A|$]]|$1|10|3|11|5|D|7|1L|8|@]|9|@]|A|$]]|$1|12|3|13|5|D|7|1M|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1N|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|17|$]]

It really depends on what language you're using, but in C# and Java I find IDEs beneficial for:

<ul>
<li>Quickly navigating to a type without needing to worry about namespace, project etc</li>
<li>Navigating to members by treating them as hyperlinks</li>
<li>Autocompletion when you can't remember the names of all members by heart</li>
<li>Automatic code generation</li>
<li>Refactoring (massive one)</li>
<li>Organise imports (automatically adding appropriate imports in Java, using directives in C#)</li>
<li>Warning-as-you-type (i.e. some errors don't even require a compile cycle)</li>
<li>Hovering over something to see the docs</li>
<li>Keeping a view of files, errors/warnings/console/unit tests etc and source code all on the screen at the same time in a useful way</li>
<li>Ease of running unit tests from the same window</li>
<li>Integrated debugging</li>
<li>Integrated source control</li>
<li>Navigating to where a compile-time error or run-time exception occurred directly from the error details.</li>
<li>Etc!</li>
</ul>

All of these save time. They're things I could do manually, but with more pain: I'd rather be coding.

blocks|key|226757|text|不同的人可能有不同的原因。对我来说，这些是优势所在。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|226758|为项目提供一种集成的感觉。例如，我将把所有相关的项目文件放在一个视图中。|ordered-list-item|226759|提供更高的代码生产力，如。|226760|语法高亮|226761|组件的转介|226762|智能感知|226763|集中查看数据库和相关的UI文件。|226764|调试特性|226765|226766|​|226767|一天结束后，它帮助我比在记事本或写字板上编写代码的速度更快。这是我喜欢IDE的一个很好的理由。|226768|entityMap^0|0|0|1|1|1|1|1|1|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Y|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|14|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|16|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|17|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|W|$]]

There might be different reasons for different people. For me these are the advantages.

<ol>
<li>Provides an integrated feel to the project. For instance i will have all the related projects files in single view.</li>
<li>Provides increased code productivity like

<ol>
<li>Syntax Highlighting</li>
<li>Referring of assemblies</li>
<li>Intellisense</li>
<li>Centralized view of database and related UI files.</li>
<li>Debugging features</li>
</ol></li>
</ol>

End of the day, it helps me to code faster than i can do in a notepad or wordpad. That is a pretty good reason for me to prefer an IDE.

blocks|key|226815|text|关于我为什么使用IDE的简单答案是懒惰。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|226816|我是一个懒惰的人，当有一种简单的方法去做的时候，我不喜欢用困难的方式去做事情。艾德让生活变得轻松，对我们这些懒惰的人很有吸引力。|226817|当我键入代码时，IDE会自动检查代码的有效性，我可以高亮显示一个方法并点击F1获取帮助，右键单击并选择“转到定义”直接跳到定义它的位置。我点击一个按钮和应用程序，与调试器自动附加是为我启动。所以名单还在继续。开发人员每天做的所有事情都集中在一个屋檐下。|226818|没有必要使用IDE。这只是更困难的工作，而不是。|226819|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The short answer as to why I use an IDE is laziness.

I'm a lazy soul who doesn't like to do things a difficult way when there is an easy way to do it instead. IDE's make life easy and so appeal to us lazy folk.

As I type code, the IDE automatically checks the validity of the code, I can highlight a method and hit F1 to get help, right click and select "go to to definition" to jump straight to where it is defined. I hit one button and the application, with debugger automatically attached is launched for me. And so the list goes on. All the things that a developer does on a day to day basis is gathered under one roof.

There is no need to use an IDE. It is just much harder work not to.

blocks|key|875648|text|我喜欢IDE，因为它在我的指尖上有很多功能。项目中文件的编辑/编译/可见性都是我在IDE中所看重的。我现在使用Visual，但在以前的生活中，我使用了SlickEdit，发现它使我的开发过程比不使用它时更加简化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|875649|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I like an IDE because it puts a lot of functionality at my fingertips. Editing/Compilation/visibility of files in the project are all things I value in an IDE. I use Visual Studio now but in a former life I used SlickEdit and found that it made my development process more streamlined than when I wasn't using it.

blocks|key|1226044|text|IDEs基本上是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226045|编辑器w/代码完成、重构和文档|unordered-list-item|1226046|调试器|1226047|文件系统浏览器|1226048|SCMS客户端|1226049|构建工具|1226050|都在一个包裹里。|1226051|您可以使用单独的工具，或者只是一个很好的可编程编辑器和额外的工具，比如Emacs+(Vim也可以，但是IDEbility+IMO要少一点)。|1226052|如果您发现自己在可能集成到环境中的一个实用程序和另一个实用程序之间切换了很多，或者如果您缺少这里列出的一些功能(更完整的是在其他文章中)，那么可能是时候迁移到IDE了(或者是通过添加宏来改进环境的IDEbility+)。如果您已经使用多个程序构建了一个“IDE”(在我前面提到的意义上)，那么就不需要使用实际的IDE了。|1226053|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|W|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|X|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Y|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|Z|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|10|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|11|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|12|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|T|$]]

IDEs are basically:

<ul>
<li>Editor w/code completion, refactoring and documentation</li>
<li>Debugger</li>
<li>Filesystem explorer</li>
<li>SCMS client</li>
<li>Build tool</li>
</ul>

all in a single package.

You can have all this (and some more) using separate tools or just a great programmable editor and extra tools, like Emacs (Vim as well but has a little less IDEbility IMO).

If you find yourself switching a lot between one utility and the next that could be integrated in the environment or if you are missing some of the abilities listed here (and more completely in other posts), maybe it's time to move to an IDE (or to improve the IDEbility of your environment by adding macros or what not). If you have built yourself an 'IDE' (in the sense I mention above) using more than one program, then there's no need to move to an actual IDE.

blocks|key|226984|text|当“文本编辑器”真的是emacs时，我认为做经典的“文本编辑器和控制台窗口与IDE”是不公平的。IDE:s的大多数典型特性也在emacs中。或者它们甚至起源于那里，而现代IDE:s主要是接口改进/简化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|226985|这意味着，对于最初的问题，答案并不是那么明确。这取决于站点上的人如何使用emacs，如果他们主要使用emacs作为文本编辑器，或者他们完全使用自定义脚本，学习相关模式的命令，了解代码标记等等。|226986|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I don't think it's fair to do the classic "text editor and console window vs IDE" when "text editor" is really emacs. Most features that are typical for IDE:s are also in emacs. Or perhaps they even originated there, and modern IDE:s are mainly interface improvements/simplifications.

This means that for the original question, the answer is not so clear-cut. It depends on how people at the site in question use emacs, if they mainly use it as a text editor, or if they go all out and use custom scripting, learn the commands for the relevant modes, know about code tagging and so on.

blocks|key|1226144|text|使用IDE的一个很好的理由是，它们是生产现代软件的公认方式。如果您不使用一个，那么您可能使用“老式”的东西，如vi和emacs。这可能导致人们得出--可能是错误的--你固守自己的方式，无法适应新的工作方式的结论。在软件开发这样的行业里，思想可能在短短几个月内就过时了，这是一种危险的状态。会严重损害你未来的工作前景..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226145|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A very good reason for using IDEs is that they are the accepted way of producing modern software. If you do not use one, then you likely use "old fashioned" stuff like vi and emacs. This can lead people to conclude - possibly wrongly - that you are stuck in your ways and unable to adapt to new ways of working. In an industry such as software development - where ideas can be out of date in mere months - this is a dangerous state to get into. It could seriously damage your future job prospects...

blocks|key|1226287|text|日食：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226288|代码高调，在后台编译，指出我的错误。|1226289|与javadoc集成，用ctrl表示变量名。|1226290|当我编译时，我就会看到错误。我可以双击一个错误，它会显示适当的行。|1226291|与JUnit集成得很好，ctrl-F11运行测试，告诉我测试失败了。如果输出窗口中有异常，我可以双击一行，并带我到失败的行。不仅如此，ctrl-F11还确保在运行测试之前对所有内容进行编译(这意味着我永远不会忘记这样做)。|1226292|与蚂蚁整合。构建和部署应用程序的一个命令。|1226293|与调试器的集成，包括web服务器的远程调试。|1226294|出色的重构工具，搜索对一段代码的引用。帮助我了解变化的影响。|1226295|总之，这让我更有效率。|1226296|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|S|$]]

Eclipse:

Having code higlighting, compiling in the background, pointing out my errors as I go along.

Integration with javadoc, suggesting variable names with ctrl-Space.

When I compile, I get errors right there. I can double click on an error, and it displays the appropriate line.

Really well integrated with JUnit, ctrl-F11 runs the test, tells me the tests have failed. If there is an exception in the output window, I can double click on a line, and takes me to the line that failed. Not only that, but ctrl-F11 makes sure everything is compiled before it runs the tests (which means I never forget to do that).

Integration with ant. One command to build and deploy the application.

Integration with debuggers, including remote debugging of web servers.

FANTASTIC refactoring tools, searching for references to a section of code. Helps me know the impact of a change.

All in all, it makes me more productive.

blocks|key|227115|text|在决定是否使用IDE时，只有一件事需要考虑，那就是它是否使您更有效率。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227116|简短的问题答案:)|227117|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

There's only one thing to consider when deciding whether to use an IDE or not, and that's whether it makes you more productive or not.

Short question so short answer :)

blocks|key|227187|text|我可以想到使用IDE的几个原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227188|综合帮助是最受欢迎的。|unordered-list-item|227189|带有Visual预览的内置重构|227190|IntelliSense、语法高亮、大型项目的易于导航、集成调试等(虽然我知道通过加载项，埃马克斯和维姆可能会得到很多这样的信息)。|offset|length|227191|另外，我认为现在IDE拥有更广泛的用户基础，而且可能有更多的人为他们开发插件，但我可能错了。|227192|坦白地说，我喜欢我的老鼠。当我使用纯文本编辑器时，就会感到孤独。|227193|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Intelli-sense|1|http://en.wikipedia.org/wiki/Emacs|2|http://en.wikipedia.org/wiki/Vim_%2528text_editor%2529^0|0|0|0|0|C|0|19|4|1|1E|2|2|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|12|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|13|8|@]|9|@$I|14|J|15|1|16]|$I|17|J|18|1|19]|$I|1A|J|1B|1|1C]]|A|$]]|$1|K|3|L|5|D|7|1D|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1E|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]|Y|$5|R|S|T|A|$U|Z]]]]

A couple of reasons I can think of for using an IDE:

<ul>
<li>Integrated help is a favorite. </li>
<li>The built-in Refactor with Preview of the Visual Studio</li>
<li><a href="https://en.wikipedia.org/wiki/Intelli-sense" rel="nofollow noreferrer">IntelliSense</a>, syntax hightlighting, ease of navigation for large projects, integrated debugging, etc. (although I know with addins you can probably get a lot of this with <a href="http://en.wikipedia.org/wiki/Emacs" rel="nofollow noreferrer">Emacs</a> and <a href="http://en.wikipedia.org/wiki/Vim_%28text_editor%29" rel="nofollow noreferrer">Vim</a>).</li>
<li>Also, I think IDEs these days have a wider user-base, and probably more people developing add-ins for them, but I might be wrong.</li>
</ul>

And quite frankly, I like my mouse. When I use pure text-based editors it gets lonely.

blocks|key|1226406|text|这肯定会提高我的工作效率。甚至在Vista上，我在Visual中编写Linux应用程序，然后使用Linux虚拟机来构建它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226407|您不必记住函数或方法调用的所有参数，一旦开始键入它，IDE将向您显示需要哪些参数。您可以获得向导来设置项目属性、编译器选项等。您可以搜索整个项目的内容，而不仅仅是文件夹中的当前文档或文件。如果您得到一个编译器错误，双击它，它会带您到违规行。|1226408|集成诸如模型编辑器、连接和浏览外部数据库、管理代码集“片断”、GUI建模工具等工具。所有这些都可以单独使用，但在相同的开发环境中都可以节省大量时间，并使开发过程更加有效。|1226409|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It definitely leads to an improvement in productivity for me. To the point where I even code Linux applications in Visual Studio on Vista and then use a Linux virtual machine to build them. 

You don't have to memorize all of the arguments to a function or method call, once you start typing it the IDE will show you what arguments are needed. You get wizards to set project properties, compiler options, etc. You can search for things throughout the entire project instead of just the current document or files in a folder. If you get a compiler error, double-click it and it takes you right to the offending line.

Integration of tools like model editors, connecting to and browsing external databases, managing collections of code "snippets", GUI modeling tools, etc. All of these things could be had separately, but having them all within the same development environment saves a lot of time and keeps the development process flowing more efficiently.

blocks|key|880376|text|我不确定文本编辑器和IDE之间是否有明确的分界线。你有像记事本这样的尺寸，另一端有最好的现代IDE，但两者之间有很多东西。大多数文本编辑器都有语法突出显示；针对程序员的编辑器通常具有其他各种特性，如简单的代码导航和自动完成。Emacs甚至允许您集成调试器。即使是十年前的IDE，现在帮助程序员的功能也比你想象的严肃的文本编辑器要少得多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880377|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I'm not sure there's a clear dividing line between a text editor and an IDE. You have the likes of Notepad at one end of the scale, and the best modern IDEs at the other, but there are a lot of thing in between. Most text editors have syntax highlighting; editors aimed at programmers often have various other features such as easy code navigation and auto complete. Emacs even lets you integrate a debugger. The IDEs of even ten years ago had far less features to help programmers than you'd expect of a serious text editor these days.

blocks|key|875882|text|简单地说，IDE提供了比简单编辑器更节省时间的特性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|875883|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Simply put, an IDE offers additional time-saving features over a simple editor.

blocks|key|227315|text|这在很大程度上取决于你在做什么，你用的是什么语言。就我个人而言，我倾向于在大部分工作中不使用IDE+(或者“我的IDE由运行vim的3个xterms组成，一个运行数据库客户端，一个带有bash提示符或跟踪日志”，这取决于您对“IDE”的定义有多广)，但是，如果我发现自己开发了一个平台--原生GUI，那么我就会立即获得一种语言--适当的IDE--+IMO、IDE和图形形式编辑显然是为对方做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227316|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It depends highly on what you're doing and what language you're doing it in. Personally, I tend to not use an IDE (or "my IDE consists of 3 xterms running vim, one running a database client, and one with a bash prompt or tailing logs", depending on how broadly you define "IDE") for most of my work, but, if I were to find myself developing a platform-native GUI, then I'd reach for a language-appropriate IDE in an instant - IMO, IDEs and graphical form editing are clearly made for each other.

blocks|key|1226524|text|IDE处理节省时间的繁重工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226525|它将所有相关的项目文件放在一起，这使得协作变得很容易。|1226526|您通常可以将源代码管理集成到IDE中，节省更多繁重的工作，并进一步加强协作。|1226527|如果它有自动完成的功能，它可以帮助您探索您选择的语言，还可以节省一些打字。|1226528|基本上，IDE减少了程序员的非编程工作.|1226529|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

An IDE handles grunt work that saves you time.

It keeps all associated project files together which makes it easy to collaborate.

You can usually integrate your source control into your IDE saving more grunt work and further enhancing collaboration.

If it has auto complete features, it can help you explore your language of choice and also save some typing.

Basically, an IDE reduces non-programming work for the programmer.

blocks|key|1226564|text|IDE可以是一个“高级”的选择，这取决于开发人员想要完成什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226565|文本编辑器可以是“高级”的，因为IDE通常面向一种语言(或一种小的选择)。|1226566|如果开发人员将大部分时间花在一种语言或一组相关语言(如C#和tools+)上，在一个操作系统中，那么一个好的IDE提供的GUI设计、调试、智能感知、重构等工具可能非常引人注目。例如，如果您大部分时间都在VB.NET中工作，偶尔在Windows环境中使用一点Visual，那么如果您不看Visual或类似的IDE，那就太傻了。|1226567|我对那些喜欢IDEs或文本编辑的人没有偏见，如果学得好，两者都可以非常有效率和有用！|1226568|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

An IDE can be a 'superior' choice based depending upon what a developer is trying to accomplish. 

A text editor can be 'superior' because IDEs are typically geared toward one (or a small selection) of languages. 

If a developer spends most of his/her time in a single languge or a 'cluster' of related languages (like C# and T-SQL), in one OS, then the GUI design, debug, intellisense, refactoring etc. tools offered by a good IDE can be very compelling. If, for instance, you spend most of your time working in VB.NET, with maybe a little T-SQL now and then, in a Windows environment, then you'd be pretty silly to not look at Visual Studio or a comparable IDE.

I have no prejudice towards those who prefer IDEs or text editors, both can be very productive and useful if learned well!

blocks|key|880475|text|作为你在问题中强调的答案的作者，我不得不说，在列出的众多原因中，专业开发人员的生产力是最受重视的技能之一。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880476|所谓生产力，我指的是能够以最好的结果高效地完成你的工作。IDEs在许多层面上都能实现这一点。我不是Emacs专家，但我怀疑它缺乏主要IDE的任何特征。|880477|设计、文档、跟踪、开发、构建、分析、部署和维护，企业应用程序中的关键垫脚石，都可以在IDE中完成。|880478|如果你有选择的话，你为什么不使用如此强大的东西呢？|880479|作为一个实验，承诺自己使用IDE，比如说30天，看看你的感受。我很想看看你对这次经历的看法。|880480|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Being the author of the response that you highlight in your question, and admittedly coming to this one a bit late, I'd have to say that among the many reasons that have been listed, the productivity of a professional developer is one of the most highly-regarded skills.

By productivity, I mean the ability to do your job efficiently with the best-possible results. IDEs enable this on many levels. I'm not an Emacs expert, but I doubt that it lacks any of the features of the major IDEs.

Design, documentation, tracking, developing, building, analyzing, deploying, and maintenance, key stepping stones in an enterprise application, can all be done within an IDE.

Why you wouldn't use something so powerful if you have the choice?

As an experiment, commit yourself to use an IDE for, say, 30 days, and see how you feel. I would love to read your thoughts on the experience.

blocks|key|227490|text|我认为这主要与开发商的意识范围有关。IDE提供了开发人员工作上下文的宏观视图。您可以同时看到类层次结构、引用的资源、数据库模式、SDK帮助引用等。由于有这么多因素影响和影响您的击键，以及体系结构和体系结构交叉点的不断扩展，因此一次只从一个代码岛上工作变得越来越困难。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227491|OTOH，“只有我，维姆和手册”给了我一个更精简的微观-但紧张和精确的-我的工作视图。如果我有一个以一种语言构建的具有良好设计、良好分区、稀疏耦合、具有一组静态库可供使用的代码基，这是可以接受的--而不是典型的情况，特别是随着开发团队规模的增长和随着时间、距离和个人偏好的增加，代码结构会发生变化。|227492|我目前正在从事Flex和.NET的项目。Flex的一个更好的地方是，很少有不同的方法可以完成标准的事情--从数据库中提取数据、打开/关闭/读/写文件等等(然而，我使用的是Flex+/Eclipse-一个典型的重负荷示例，比如VS，因为我仍然在学习基础知识，我需要训练车轮。我希望一旦我对自己的模式有信心，就会进化回vim。)在这个观点下，我可以做我需要做的专业工作，因为我知道一些事情真的真的很好。|227493|OTOH，我无法想象用.NET实现这一点，因为人们期望我保持的观点不断扩展和变化。在几个月的时间里，一个项目中的概念完整性和几个开发人员之间的概念完整性要少得多，更不用说一致性了--但是IDE支持这一点，也许会鼓励它。因此，开发人员确实需要(而且更容易)了解更多的事情。这也有利于帮助他们回答(甚至理解)+StackOverflow上更高比例的问题。也就是说，我们可以有一个更深的知识栈。我们可以对各种各样的招聘广告做出回应。|227494|事情在两个方向都可能走得太远了。也许用“只编辑”的范围，它就像“如果你只有一个锤子，一切看起来就像钉子”。使用IDE方法，无论您想要将什么东西固定在一起，您都可以选择各种紧固件和相关的工具--nals/锤子、螺钉/螺丝起子、螺栓/扳手、粘合剂/胶水、枪支/夹子、磁铁等等--所有这些都在您的指尖(有向导帮助您入门)。|227495|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I think it has mostly to do with scope of awareness for the developer. The IDE provides a macroscopic view of the developer's work context. You can simultaneously see class hierarchies, referenced resources, database schemas, SDK help references, etc. And with so many things affected by, and affecting, your keystrokes, and the expanding volume of architectures and architectural intersections, it gets more and more difficult to work solely from one island of code at a time.

OTOH, "just me and vim and the man pages" gives me a much leaner microscopic - but intense and precise - view of my work. This is ok if I have a well-designed, well-partitioned, sparsely coupled highly cohesive codebase built in one language with one set of static libraries to work from - not your typical situation, especially as dev team sizes grow and reshape the code structure over time, distance, and personal preference.

I'm currently working on projects in Flex and .NET. One of the nicer things about Flex is how few different ways there are to accomplish a standard thing - pull data from a database, open/close/read/write a file, etc. (Yet I'm using the Flex Builder/Eclipse IDE - a typical heavy-weight example like VS, because I'm still learning the basics and I need the training wheels. I expect to evolve back to vim once I'm confident of my patterns.) In this view, I can do what I need to do professionally by knowing a few things really really well.

OTOH, I can't imagine getting to that point with .NET because the view I'm expected to maintain keeps expanding and shifting. There much less conceptual integrity, and over several developers on a project over several months, much less consistency - but the IDE supports that, maybe encourages it. So the developer really needs to (and can more easily) know many more things adequately. Which also has the benefit of helping them answer (or even understand) a lot higher percentage of the questions on StackOverflow. I.e. we can have a deeper knowledge stack. And we can respond to a wider variety of help-wanted ads.

Things can go too far in both directions. Maybe with the "editor-only" scope, it's like "if you only have a hammer, everything looks like a nail". With the IDE approach, for whatever you want to fasten together, you have a broad selection of fasteners and associated ranges of tools to choose from - nals/hammers, screws/screwdrivers, bolts/wrenches, adhesives/glue-guns/clamps, magnets, and on and on - all at your fingertips (with a wizard to help you get started).

blocks|key|1226730|text|我使用Emacs作为开发和邮件/新闻的主要环境已经有10年了(1994-2004年)。2004年，当我强迫自己学习Java时，我发现了IDE的强大功能，令我惊讶的是，我实际上喜欢IDE+(IntelliJ理念)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1226731|我不会讨论具体的原因，因为这里已经提到了很多原因--请记住，不同的人喜欢不同的特征。我和一位同事使用相同的IDE，我们都只使用了一小部分可用的特性，而且我们都不喜欢使用IDE的方式(但我们都喜欢IDE本身)。|1226732|但是，与Emacs/Vim相关的环境相比，IDE有一个优势:您花费更少的时间安装/配置您想要的特性。|1226733|使用翼IDE+(用于Python)，我可以在安装后15-20分钟开始开发。不知道我需要多少个小时才能使用Emacs/Vim运行的特性。:)|1226734|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/IntelliJ_IDEA|1|https://en.wikipedia.org/wiki/Wing_IDE^0|2M|A|0|0|0|0|2|4|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|M|N|O|C|$P|S]]]]

I have used Emacs as my primary environment for both development and mail/news for about 10 year (1994-2004). I discovered the power of IDEs when I forced myself to learn Java in 2004, and to my surprise that I actually liked the IDE (<a href="http://en.wikipedia.org/wiki/IntelliJ_IDEA" rel="nofollow noreferrer">IntelliJ IDEA</a>).

I will not go into specific reasons since a lot of them have already been mentioned here -- just remember that the different people love different features. Me and a colleague used the same IDE, both of us used just a fraction of the features available, and we disliked each others way of using the IDE (but we both liked the IDE itself).

But there is one advantage with IDEs over Emacs/Vim related environments I want to focus on: You spend less time installing/configuring the features you want.

With <a href="https://en.wikipedia.org/wiki/Wing_IDE" rel="nofollow noreferrer">Wing IDE</a> (for Python) I'm ready to start developing 15-20 minutes after installation. No idea how many hours I would need to get the features I use up and running with Emacs/Vim. :)

blocks|key|880525|text|我不明白你在问什么。您会问“我是否应该使用IDE而不是.”，但是我不知道替代方法是什么--+维姆和Emacs实现了任何IDE都能提供给您的许多功能。他们唯一不能处理的方面是更大的IDE可能是类似UI设计器的东西。然后，您的问题归结为简单的“我应该使用什么IDE”，并为更简单的Vim和Emacs领域设置参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|880526|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Vim_%2528text_editor%2529^0|1A|2|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

I do not understand what you are asking. You ask "Should I use an IDE instead of...", but I don't understand what the alternative is - <a href="http://en.wikipedia.org/wiki/Vim_%28text_editor%29" rel="nofollow noreferrer">Vim</a> and Emacs fulfil many functions any IDE will give you. The only aspect they do not handle that a larger IDE may are things like UI designers. Then your question boils down to simply "what IDE should I use" with arguments to be made for the simpler realm of Vim and Emacs.

blocks|key|880531|text|别把它当成独家新闻。利用IDE提供的好处，并在需要重点关注时切换到vim/首选文本编辑器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|880532|我发现IDE更适合于重构、浏览和调试以及确定应该做什么。然后，在IDE中正确地完成一些小事情，然后我翻转到vim来完成这项工作。|880533|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Don't think of it as exclusive. Use the IDE for the benefits it provides, and switch to vim/preferred text editor when you need some serious focus.

I find the IDE better for refactoring and browsing and debugging and for figuring out what to do. Small things are then done right in the IDE, large things I flip to vim to finish the job.

blocks|key|880560|text|除了其他答案之外，我还喜欢将IDE的开发能力与使用类似于ViPlugin+for+月食的Vim的编辑功能结合起来。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|880561|entityMap|0|LINK|mutability|MUTABLE|url|http://www.satokar.com/viplugin/|1|http://en.wikipedia.org/wiki/Eclipse_%2528software%2529^0|S|8|0|15|2|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

In addition to the other answers, I love combining the developing power of an IDE with the editing power of Vim using something like the <a href="http://www.satokar.com/viplugin/" rel="nofollow noreferrer">ViPlugin</a> for <a href="http://en.wikipedia.org/wiki/Eclipse_%28software%29" rel="nofollow noreferrer">Eclipse</a>.

blocks|key|1226885|text|我使用它的主要原因是当代码超过100个文件时。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226886|虽然ctag可以完成这项工作，但是一些IDE有一种很好的方法来轻松地导航文件--超级快。|offset|length|1226887|当你有很多工作要做的时候，它可以节省时间。|1226888|entityMap|0|LINK|mutability|MUTABLE|url|http://www.jetbrains.com/idea/index.html^0|0|H|5|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

My main reason to use one is when the code goes beyond 100 files.

Although ctags can do the work, <a href="http://www.jetbrains.com/idea/index.html" rel="nofollow noreferrer">some IDEs</a> have a pretty good way to navigate the files easily an super fast.

It saves time when you have a lot of work to do.

blocks|key|1226922|text|我是从相反的方向回答这个问题的。我是在编程中长大的，在Makefile%2BEmacs的土地上很少有陷阱。从我在DOS上最早的编译器Microsoft开始，我就有了一个IDE来实现自动化。我花了很多年在VisualEclipse6.0中工作，当我毕业于Enterprise时，我使用了C%2B%2B+JBuilder，然后在JBuilder上定居下来，这对我来说是非常有效率的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1226923|在我最初的自学、大学和现在的职业生涯中，我逐渐了解到，任何仅仅在IDE中完成的主要软件开发都会适得其反。我这么说是因为大多数IDE都希望你采用他们独特的I-控制-如何世界-工作风格。你必须按照他们的思路切分你的项目。您已经使用它们的奇怪对话框管理您的项目生成。大多数IDE很难在项目之间管理复杂的构建依赖关系，而且依赖关系很难100%25工作。我所处的情况是，除非我完成了清理/重新构建所有代码，否则IDE的IDE不会生成我的代码。最后，很少有一种干净的方法将您的软件从开发中转移到其他环境中，比如QA或IDE中的产品。构建所有的部署单元通常是一种笨拙的做法，或者IDE供应商为您提供了一些笨拙的工具来打包。但是，这个工具通常要求您的项目和构建结构完全符合它们的规则--有时，这对您的项目的需求是行不通的。|1226924|我已经了解到，要对团队进行大规模开发，如果我们使用IDE开发代码并使用手工编写的命令行脚本进行所有构建，那么我们可以是最有效率的。(我们喜欢Apache用于Java开发。)我们已经发现，在IDE之外运行脚本对于复杂的构建来说只是一个点击节或者是一个自动化的噩梦，将alt%2Btab输出到一个shell中并在那里运行脚本要容易得多(而且破坏性小得多)。|1226925|手工构建要求我们忽略现代IDE中的一些细节，比如背景编译，但是我们获得的更重要的是:干净和容易的构建，可以在多个环境中使用。所有那些敏捷的家伙都在谈论“一键构建”吗？我们拿到了。我们的构建脚本也可以由连续集成系统直接调用。通过持续集成管理构建，使我们能够更正式地将您的代码部署迁移到不同的环境，并且几乎可以在有人签入破坏构建或单元测试的错误代码时立即通知我们。|1226926|事实上，我把构建的角色从IDE中移开并没有对我们造成太大的伤害。Eclipse中的intellisense和重构工具仍然是完全有用和有效的--后台编译只是用来支持这些工具。而且，Eclipse独特的项目切片是一种非常好的方法，可以以每个人都能理解的方式从精神上分解我们的问题集(不过，对我的口味来说还是有点冗长)。我认为Eclipse最重要的事情之一是优秀的SCM集成，这使得团队开发如此令人愉快。我们使用Subversion%2BEclipse，这是非常有成效和非常容易培训我们的人成为专家。|1226927|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

I come at this question from the opposite direction. I was brought up in programming with very few pitstops in Makefile+Emacs land. From my very earliest compiler on DOS, Microsoft Quick C, I had an IDE to automate things. I spent many years working in Visual C++ 6.0, and as I graduated into Enterprise Java, I worked with Borland JBuilder and then settled on Eclipse, which has become very productive for me. 

Throughout my initial self-teaching, college, and now professional career, I have come to learn that any major software development done solely within the IDE becomes counterproductive. I say this because most IDE's wants you to work in their peculiar I-control-how-the-world-works style. You have to slice and dice your projects along their lines. You have manage your project builds using their odd dialog boxes. Most IDE's manage complex build dependencies between projects poorly, and dependencies can be difficult to get working 100%. I have been in situations where IDE's would not produce a working build of my code unless I did a Clean/Rebuild All. Finally, there's rarely a clean way to move your software out of development and into other environments like QA or Production from an IDE. It's usually a clicky fest to get all your deployment units built, or you've got some awkward tool that the IDE vendor gives you to bundle stuff up. But again, that tool usually demands that your project and build structure absolutely conforms to their rules - and sometimes that just won't work for your projects' requirements.

I have learned that, to do large-scale development with a team, we can be the most productive if we develop our code using an IDE and do all of our builds using manually written command line scripts. (We like Apache Ant for Java development.) We've found that running our scripts out of the IDE is just a click fest or an automation nightmare for complex builds, it's much easier (and less disruptive) to alt+tab out to a shell and run the scripts there.

Manual builds requires us to miss out on some of the niceties in the modern IDE like background compilation, but what we gain is much more critical: clean and easy builds that can live in multiple environments. The "one click build" all those agile guys talk about? We have it. Our build scripts can be directly invoked by continuous integration systems as well. Having builds managed through continuous integration allows us to more formally stage and migrate your code deployments to different environments, and lets us know almost immediately when someone checks in bad code that breaks the build or unit tests.

In truth, my taking the role of build away from the IDE hasn't hurt us too badly. The intellisense and refactoring tools in Eclipse are still completely useful and valid - the background compilation simply serves to support those tools. And, Eclipse's peculiar slicing of projects has served as a very nice way to mentally break down our problem sets in a way everyone can understand (still a tad bit verbose for my tastes though). I think one of the most important things about Eclipse is the excellent SCM integrations, that's what makes team development so enjoyable. We use Subversion+Eclipse, and that has been very productive and very easy to train our people to become experts at.

blocks|key|227740|text|集成调试器IntelliSense和即时窗口使我的工作效率大大提高(Visual+Studio+2008)。所有事情都在我的指尖上，我可以在编写代码时将一个庞大项目的绝大部分保留在我的头脑中。微软可能会继续在他们的操作系统上丢球，但是Visual是有史以来最优秀的产品之一。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|227741|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Intelli-sense|1|http://en.wikipedia.org/wiki/Microsoft_Visual_Studio#Visual_Studio_2008^0|5|C|0|Y|I|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

<a href="https://en.wikipedia.org/wiki/Intelli-sense" rel="nofollow noreferrer">IntelliSense</a>, the integrated debugger, and the immediate window make me enormously more productive (<a href="http://en.wikipedia.org/wiki/Microsoft_Visual_Studio#Visual_Studio_2008" rel="nofollow noreferrer">Visual&nbsp;Studio&nbsp;2008</a>). With everything at my fingertips, I can keep the vast majority of an enormous project inside of my head while writing code. Microsoft may keep dropping the ball on their OSs, but Visual Studio is one of the finest products ever developed.

blocks|key|227776|text|IDE可以让人工作得更快更容易.我注意到我花了很多时间在简单的文本编辑器中浏览代码.|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|227777|在一个好的IDE中，如果IDE支持跳转到函数、以前的编辑位置和变量，那么时间就会减少.此外，一个好的IDE减少了试验不同语言特性和项目的时间，因为启动时间可能很短。|227778|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Integrated_development_environment^0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

An <a href="http://en.wikipedia.org/wiki/Integrated_development_environment" rel="nofollow noreferrer">IDE</a> allows one to work faster and more easily... I noticed I spent a lot of time navigating in the code in a simple text editor...

In a good IDE, that time goes down if the IDE supports jumping to functions, to previous editing position,to variables... Also, a good IDE reduces the time to experiment with different language features and projects, as the start-up time can be small.

blocks|key|227801|text|对我来说，IDE更好，因为它允许在代码中进行更快的导航，如果您有需要实现的东西，这一点很重要。假设您不使用IDE，则到达目的地需要更长的时间。你的想法可能会更频繁地被打断。这意味着更多的点击/更多的按键必须按下。人们必须更多地集中精力思考如何实现事物。当然，您也可以写下一些东西，但是必须在设计和实现之间进行切换。另外，GUI设计人员也有很大的不同。如果你用手做的话，可能要花更长的时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227802|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

For me, an IDE is better because it allows faster navigation in code which is important if you have something in your mind to implement.
Supposed you do not use an IDE, it takes longer to get to the destination. Your thoughts may be interupted more often. It means more clicks/more keys have to be pressed.
One has to concentrate more on the thought how to implement things.
Of course, you can write down things too but then one must jump between the design and implementation.
Also, a GUI designer makes a big difference. If you do that by hand, it may take longer.

blocks|key|227856|text|基于GUI的IDE(如Visual和Eclipse+)与基于文本的IDE(如Emacs或vim+)相比有几个优点，因为它们具有显示功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|227857|用于GUI设计的WYSIWYG预览和实时编辑|unordered-list-item|227858|高效率的财产编辑器(如使用GUI调色板选择颜色，包括定位梯度停止等)|227859|代码大纲、文件间关系等的图形描述|227860|更有效地使用屏幕房地产显示断点、书签、错误等。|227861|更好地支持操作系统和其他应用程序的拖放|227862|图形、图像、三维模型等的综合编辑|227863|数据库模型的显示和编辑|227864|基本上，使用基于GUI的IDE，您可以立即在屏幕上获得更多有用的信息，并且可以像查看/编辑应用程序的图形部分一样轻松地查看/编辑文本部分。|227865|作为一名开发人员，最酷的事情之一就是编辑一种计算某些数据的方法，并在另一个窗口中看到代码的实时输出，就像用户在运行应用程序时看到的那样。这是WYSIWYG编辑！|227866|基于文本的IDE(如Emacs和vim+)可以随着时间的推移添加代码完成和重构等功能，因此从长远来看，它们的主要限制是基于文本的显示模型。|227867|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|13|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|14|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|15|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|16|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|17|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|18|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|X|$]]

GUI-based IDEs like Visual Studio and Eclipse have several advantages over text-based IDEs like Emacs or vim because of their display capabilities:

<ul>
<li>WYSIWYG preview and live editing for GUI design</li>
<li>Efficient property editors (eg. color selection using a GUI palette, including positioning gradient stops etc)</li>
<li>Graphical depiction of code outlines, file interrelationships, etc</li>
<li>More efficient use of screen real-estate to show breakpoints, bookmarks, errors, etc</li>
<li>Better drag and drop support with OS and other applications</li>
<li>Integrated editing of drawings, images, 3D models, etc</li>
<li>Display and edit of database models</li>
</ul>

Basically with a GUI-based IDE you can get more useful information on screen at once and you can view/edit graphical portions of of your application as easily as text portions.

One of the coolest things to experience as a developer is editing a method that computes some data and seeing the live output of your code displayed graphically in another window, just as your user will see it when you run the app. Now that's WYSIWYG editing!

Text-based IDEs like Emacs and vim can add features like code completion and refactoring over time, so in the long run their main limitation is their text-based display model.

blocks|key|227925|text|真的很简单。但这个答案有点自相矛盾，因为我正在讨论的只是嵌入式开发人员所遇到的一些东西。这是一个奇怪的观点，因为坦率地说，当我做嵌入式工作时(我赚了很多钱)，一个IDE会很奇怪，而且你的大多数同事都会想，为什么你对SNMP/ASN.1或者你正在处理的任何协议没有足够的记忆，只想知道你的工作/。但据我所知，您不能对您的微控制器在类似于/real时间/没有"IDE“的情况下所做的事情进行图形模拟。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|227926|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol|1|https://en.wikipedia.org/wiki/Abstract_Syntax_Notation_One|2|http://en.wikipedia.org/wiki/Microcontroller^0|2Z|4|0|34|5|1|4F|4|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

It's really VERY simple. But this answer is a bit of a paradox in that I am
discussing something only EMBEDDED level developers ever encounter. The reason this is an odd view is that frankly when I was doing embedded work (the brief time I was making any real money) an IDE would be down right STRANGE and most of your coworkers would wonder why you can't remember enough about <a href="https://en.wikipedia.org/wiki/Simple_Network_Management_Protocol" rel="nofollow noreferrer">SNMP</a>/<a href="https://en.wikipedia.org/wiki/Abstract_Syntax_Notation_One" rel="nofollow noreferrer">ASN.1</a> or whatever protocol you were dealing with to just /do your job/. BUT you can NOT, as far as I know, do a graphical simulation of what your <a href="http://en.wikipedia.org/wiki/Microcontroller" rel="nofollow noreferrer">microcontroller</a> is doing in something like /real time/ without an "IDE".

blocks|key|228000|text|对我来说，这只是我们在终端过去的美好时光中所做的一切的GUI版本。我总是同意IDE并不是很优越，因为它们隐藏了很多东西，特别是关于链接的东西，但是在某些情况下，它们有一个显著的优势，例如在某些开发平台上，比如Qt。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|228001|有些IDE甚至像其他IDE一样，在键入代码时解析代码，甚至在编译之前检测错误:似乎只有IDE才能与编译器密切合作，立即检测类型化源代码中的问题。|228002|我的回答是IDE+/命令行火焰之战之所以存在，仅仅是因为C/C%2B%2B的可执行构建从标准化的角度来看处理得不太好，与D语言不同；每个平台都以自己的方式处理编译/链接/等等，因此，为了使其不那么凌乱，他们制作了IDE。|228003|从您的观点来看，使用命令行可能更简单，如果只有一个带有标准选项的编译器，它本来会很容易，但事实是C/C%2B%2B是灵活的，所以最终，所有平台都是以自己的方式完成的，因此IDE不必浪费时间来解释如何实现它。|228004|如果您能够了解可执行文件如何与内核对话，或者您是否了解编译器设计，也许有一种方法可以使用适当的命令行，但我怀疑您是否知道。|228005|无论是微软还是苹果，他们都必须提出一种直接的方式来构建应用程序，而不需要输入细节，而且由于应用程序的构建直接依赖于操作系统的体系结构，所以它很难像命令行那样成为“标准”。|228006|简单、大型和复杂的应用程序不想深入研究它所做的->+IDE、一些小软件或简单的系统软件--设计->命令行。当然，除了那些嵌入Makefile的漂亮库之外，这是另一个故事。|228007|我还认为，当交付的应用程序与GUI或具有界面或直接绑定到OS的东西有关时，使用IDE也是如此，同样，它也适用于那些在不知道UI/GUI如何工作的情况下使用UI/GUI的人，而编程系统的人则不会完全需要它。|228008|艾德只是个现代化的混蛋，但我认为100年后指挥系统还会存在。|228009|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|10|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|11|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|S|$]]

To me it's just the the GUI version of everything we did in the good old days of the terminal. I will always agree that IDE are not very superior because they hide a lot of stuff, especially concerning the linking stuff, but they have a notable advantage in some cases, for example with certain development platforms like Qt.

Some IDE like visual of others even seem to parse your code as you type it, and detect errors before you even compile: it seems logics that only an IDE can work closely with a compiler to immediately detect problem in the typed source.

My wild answer that the IDE/Command-line flame war exists is just because the C/C++ executable building is not very well handled from a standardized point of view, unlike with the D language; every platform handles compiling/linking/etc its own way, so to make it less messy they make an IDE.

From your viewpoint it might be more simple to use the command-line, if there would have been only one compiler with standard options, it would have been easy, but the truth is C/C++ is flexible, so in the end, all platform do it their own way, hence the IDE to not waste explaining how to do it.

If you can learn how an executable talks to the kernel or if you know anything about compiler design, maybe there is a way to work with a proper command-line, but I doubt you have.

Microsoft or Apple, all evil they would be, have to propose a straight-forward way to build application without entering in the details, and since building an application depends directly on the architecture of the OS, it will hardly be "standard" as the command-line is.

To put it simple, big and complex applications where you don't want to dig too deep into what it does -> IDE, little pieces of software or simple system software-design -> command-line. Except of course those nifty libraries that embed a Makefile, but that's another story.

Also I think IDE are used when the application delivered has something to do with, ironically, a GUI or something that has an interface or is directly bound to an OS, so again, it's also for people who will use a UI/GUI without knowing how it works, while people who will program systems won't need it all.

IDE is just modern shit, but I think in 100 years the command-line will still exist.

blocks|key|228038|text|我也几乎完全使用Vim+(几乎因为我现在正在尝试学习emacs+)来开发我的所有东西。我认为纯粹的直觉(当然来自GUI+)是人们喜欢使用IDE的主要原因。通过直观，几乎不需要学习该工具的开销。学习开销越小，他们完成的工作就越多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|228039|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I also almost exclusively use Vim (almost because I'm trying to learn emacs now) for all my development stuff. I think sheer intuitiveness (from the GUI of course) is the primary reason why people like to use IDEs. By being intuitive, little to no learning overhead of the tool is required. The lesser the learning overhead, the more they can get work done.

In another question, <a href="https://stackoverflow.com/users/26310/mark">Mark</a> speaks highly of IDEs, saying "some people still just dont know "why" they should use one...". As someone who uses vim for programming, and works in an environment where most/all of my colleagues use either vim or emacs for all of their work, what are the advantages of IDEs? Why should I use one?

I'm sure this is a charged issue for some people, and I'm not interested in starting a flame war, so please only reply with the reasons you believe an IDE-based approach is superior. I'm not interested in hearing about why I shouldn't use an IDE; I already don't use one. I'm interested in hearing from "the other side of the fence", so to speak.

If you think that IDEs may be suitable for some types of work but not others, I'm also interested to hear why.

Why should I use an IDE?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在另一个问题上，高度评价IDE，说“有些人仍然不知道”为什么“他们应该使用一个.”。作为一个使用vim进行编程的人，并且在一个大多数/所有同事都使用vim或emacs进行所有工作的环境中工作，IDEs的优点是什么？我为什么要用一个？我确信这对一些人来说是个很棘手的问题，我不想发动一场火焰之战，所以只会回答你认为基于ID...

问我为什么要使用IDE？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我为什么要使用IDE？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我为什么要使用IDE？
EN