Step 4: The struts-config.xml file

Up to now it has been simple and straightforward, right? Now I\'ll need to explain a few things. First I\'ll tell you what services the servlet offers to us, and then we\'ll see how we give it the instructions for a specific request. If you look at figure 1--the MVC architecture--you\'ll notice the arrows marked 2 and 3. This is the interaction between the servlet controller and the model, including the business logic. When you use Struts then part of this interaction is as follows:

1. First of all the Struts servlet will automatically transfer the data from your form into a JavaBean that you should supply. This bean is called the ActionForm bean, because your bean must extend the Struts ActionForm class. You may think of this bean as a buffer between the browser and your database. The ActionForm bean may also be used to initialize form controls and to validate the data entered by the user.
2. Secondly the Struts servlet will call a class which you specify and it is referred to as the Action class. This class may use the data in the ActionForm bean. The Action class is where your application coding starts. When your class finishes it returns control to the Struts servlet.

 some-name>.do) to a specific Action and ActionForm class is done in the struts-config.xml file. I have edited the file from struts-blank to suit our one-page application:

<?xml version=1.0 encoding=ISO-8859-1 ?>


<!DOCTYPE struts-config PUBLIC
 -//Apache Software Foundation//DTD Struts Configuration 1.0//EN


http://jakarta.apache.org/struts/dtds/struts-config_1_0.dtd>


<struts-config>


  <!-- ========== Form Bean Definitions ================= -->
  <form-beans>


    <form-bean
                    type=hansen.playground.SubmitForm/>


  </form-beans>


  <!-- ========== Action Mapping Definitions ============ -->
  <action-mappings>


    <action   path=/submit
              type=hansen.playground.SubmitAction


              input=/submit.jsp
              scope=request>
    <forward  path=/submit.jsp/>
    <forward  path=/submit.jsp/>
    </action>


  </action-mappings>


</struts-config>

- Figure 6: The struts-config.xml file -

As you can see the file contains two sections: the form-beans section, that lists the ActionForm beans, and the action-mappings.

In the form-beans section you give the bean a logical name (referred to in the action-mapping) and specify the path for the class file.

The action-mappings are the most interesting. The attributes given are these:

path - name of the request: submit.do. You don\'t enter the .do-part here.
type - the path for the Action class file
name - is the logical name of the form bean (from the form-bean section)
input - validation errors should be shown on this page
scope - specifies how long the form bean should live. You may specify session instead.

The forward tag tells the servlet where to go if it receives either success or failure from the Action class. We\'ll return to this feature. In our simple case we always return to the same page.

It\'s wise to standardize on class names. I\'ve used these simple conventions:

We\'re now ready to code the ActionForm and the Action classes--and the jsp view.

Step 1: The directories and files of a Struts application

You\'ll need to know the directory structure of a Struts application, and what\'s put in the directories. The struts-blank application is well-suited for this presentation, since it contains a minimum number of files:

- Table 1: The files and directories in a Struts application -

Step 2: Starting on a new Struts application

The easiest way to start on a new Struts application is to take an existing one--for example struts-blank--and make a copy of it in the webapps directory. When you get more experienced with Struts you\'ll probably add your own standard classes and files to your setup, and you\'d then start taking a copy of this directory structure. For our first application we simply copy all files and directories in the folder struts-blank and rename the folder to myproject. The contents of some of the files must now be edited.

Step 3: The web.xml file

The web.xml file is where servlets and other stuff are defined to the servlet container. We\'ll remove some unnecessary things from the web.xml file so it looks like this:

<?xml version=1.0 encoding=ISO-8859-1?>


<!DOCTYPE web-app
  PUBLIC -//Sun Microsystems, Inc.//DTD Web Application 2.2//EN


http://java.sun.com/j2ee/dtds/web-app_2_2.dtd>


<web-app>


  <!-- Standard Action Servlet Configuration (with debugging) -->
  <servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>
   org.apache.struts.action.ActionServlet
 </servlet-class>
    <init-param>
      <param-name>application</param-name>
      <param-value>ApplicationResources</param-value>
    </init-param>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
      <param-name>debug</param-name>
      <param-value>2</param-value>
    </init-param>
    <init-param>
      <param-name>detail</param-name>
      <param-value>2</param-value>
    </init-param>
    <init-param>
      <param-name>validate</param-name>
      <param-value>true</param-value>
    </init-param>
    <load-on-startup>2</load-on-startup>
  </servlet>


 
  <!-- Standard Action Servlet Mapping -->
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>


 
  <!-- Struts Tag Library Descriptors -->
  <taglib>
    <taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>
    <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
  </taglib>


  <taglib>
    <taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>
    <taglib-location>/WEB-INF/struts-html.tld</taglib-location>
  </taglib>


  <taglib>
    <taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>
    <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
  </taglib>


</web-app>

- Figure 4: The web.xml file -

The file contains three sections:

1. the definition of the Struts servlet named ActionServlet
2. the URL mapping for the calls to this servlet
3. the definitions of the Struts tag libraries

You\'ll see that the servlet will be called if our browser requests a file called <some-name>.do. So when we submit the form in our one-page application we\'ll decide to use the action-name submit.do. How the Struts servlet knows what to do with this request we\'ll discover next.

by Keld H. Hansen

What is Struts?

Struts, from the Jakarta Project, is a development framework for Java servlet applications based upon the Model-View-Controller (MVC) design paradigm. The purpose of this article is to give you a quick intro to Struts, covering the necessary details to make it possible to build a simple one-page example containing an HTML form. Then I\'ll refine this example to show you additional features of Struts. I\'ll assume that you are familiar with Java servlet programming and the MVC architecture - if not I\'d recommend that you read this article from JavaWorld.

- Figure 1: The MVC architecture -

Struts is comprised of a controller servlet, beans and other Java classes, configuration files, and tag libraries. This means that when you have downloaded Struts (and I\'ll come back to how this is done) you have available:

• a controller for your application (the Struts servlet acts as a common controller for the whole application)
• a collection of Java beans and other helper classes that you use in the Model part of your application
• a collection of tag libraries used in your jsp-pages

To glue these things together Struts uses a set of configuration files. Together this gives you the skeleton that you can use to strut your application.

Struts has been designed to give you modularity and loose couplings in your application. If you\'re building a simple, small application you might find it complicated to have to create and handle so many files. You might even be tempted to put all your code in a single jsp-file. My advice to you is: don\'t do it! I\'m sure you can build a single-page application faster using only one jsp-page, but if we\'re talking about more complex applications, the extra effort put in by using a modular framework will soon be rewarded.

If you hang on I\'ll guide you through the complete Struts application setup and hopefully show you how each piece fits in.

Our first Struts application

Our first small application will be a page with an HTML form containing all the well-known controls. As you can see I have not tried to make the GUI look nice - we\'re architects now - not graphical designers:

- Figure 2: The first, simple application -

When we submit this page it should redisplay itself without loosing the data that we have entered. Such an application is always a good first exercise if you want to learn about new tools or technologies.

But before we start building the application we need to download and install Struts.

Step 0: Downloading and installing Struts

Struts is downloaded from the Jakarta Project at http://jakarta.apache.org/struts/. The download address for the current version - 1.0.2 - is http://jakarta.apache.org/builds/jakarta-struts/release/v1.0.2. The simplest way to install Struts is to copy a small Struts application, packed in struts-blank.war, from the download file to your Servlet container. If you\'re using Tomcat and many other servlet containers you place the war-file in the webapps folder and you now only need to restart your server and you\'ll have struts-blank running. On Tomcat you can check your installation with this URL: http://localhost:8080/struts-blank/index.jsp. The download contains an install file which contains installation tips for several containers.

This should emphasize that Struts can be seen as the core of a normal servlet application - it\'s not a modification to your servlet container or anything like that.

While picking up the struts-blank application you might as well take and install the struts-documentation.war application, which contains a lot of Struts documentation - for example the User Guide.

如果你上djangoproject.com你会发现对Django的如下解释：
“Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design.”
让我们展开来看

Django是高级Web框架
高级Web框架免去了勾践动态Web站点的痛苦，它把常见的Web开发的问题抽象出来并提供了对频繁的编程任务的捷径
一个优秀的Web框架有下列关注点：
提供URL映射
很容易显示，验证和重显示HTML表单
对用户提交的东西转换成容易操控的数据结构
通过模板系统分离内容和显示
方便同持久化层集成
更高的抽象，提升生产率
去除你的程序瑕疵
Django具有所有这些特点
Django是一个用Python写的，Python是一门优雅，简明，高级的编程语言
如果你用Django开发站点，你将用Django库写Python代码

Django提供快速开发
Django的哲学就是竭尽所能提升开发速度
用Django开发站点用的时间是几小时，而不是几天，几星期，几年
这很大程度上要感谢Python：
Python是解释型语言，不需要编译代码，可以在浏览器里马上看到结果
Python是动态类型的，不必声明变量类型
Python的语法简明而富有表达力，更少的代码来完成同样的事情，一行Python代码通常等于10行Java代码，更少的代码带来更少的bug
Python提供优秀的自省和元编程能力，可以在运行时视察对象和添加行为

Django带来干净实效的设计
Django严谨的维护干净的设计，它所有的代码让你开发的Web程序遵循最佳实践
它这里的哲学是：Django让你很轻松的做“对”事情
Django提供松耦合架构，它的编程哲学是不同的程序片段可以互换，相互通过干净，简明的API交流
Django遵循MVC架构

Django不做的事情
帮你喂猫
帮你理解需求并且在明确的时间内实现以便愚弄你的老板认为你没有在家看“The Price is Right”
需要注意的是，Django不会导致全球变暖

为什么会开发Django
Django起源于真实世界遇到的种种问题和解决方案，它不是为卖给开发人员赢得市场而做，也不是在某人的页面时间为了完成学校作业而做
它是为工业上Web开发团队解决每天的问题而构建的
Django开始于2003，在堪萨斯州一个小镇的一份叫劳伦斯的Web开发报纸，web版本为World Online
2003的秋季，World Online的两位开发人员Adrian Holovaty和Simon Willison计划创建Django框架

谁使用Django
World Online的所有站点
http://www.ljworld.com
http://www.lawrence.com
http://www.6newslawrence.com
http://www.visitlawrence.com
http://www.lawrencechamber.com
http://www2.kusports.com/stats
http://projects.washingtonpost.com/congress
http://projects.washingtonpost.com/fallen
Django的站点更新列表：
http://code.djangoproject.com/wiki/DjangoPoweredSites

关于本书
本书的目标是解释Django所做的所有事情并且让你成为使用Django的专家
通过阅读本书，你将学习使用干净和容易维护的代码快速开发强大的Web站点

很高兴您在这里!

　　这篇文章已经有些日子了，现在因为自己的开发需要想选一款容易上手的PHP Framework，所以重新找了出来，看完以后顺便翻译了一下，由于原文是写于今年三月底，故而其中的很多框架的现状也发生了较大的变化，本篇译文也只是方便大家阅读，对于正在寻找这方面资料的读者做个参考，也给自己一个知识备份......

引言：
　　随着Ruby on Rails的火爆，PHP这个流行的Web应用脚本语言也出现了大量的新一代开发框架。与此同时，国内PHP开发者也开始紧跟国外发展，推出了不同的开发框架。

Ruby on Rails催生变革
　　在RoR流行之前，PHP领域也有不少开发框架，例如Mojavi、WACT、PHPMvc和Seagull等。这些框架虽然也采用了MVC模式、数据库抽象层等技术。但由于当时PHP本身不像现在这样流行，所以这些框架都没有得到大量应用，最终归于沉寂。
　　而在感受到RoR提供的快速开发能力后，PHP社区像被注入了兴奋剂。各种应用技术和开发框架层出不穷。

新一代框架的诞生
　　PHP社区在被RoR震晕后，没有陷入过多的争论。而是立即行动起来，开始了新一代框架的设计。首先出现的第一批框架几乎都是RoR的克隆。例 如PHP on Trax（连名字都借鉴Ruby on Rails）和TaniPHP、Akelos等。这些框架最大的特点就是力求100％克隆RoR，不管是采用的架构、设计模式，还是使用方法。
　　这几个框架一开始确实吸引了开发者的注意，但随着开发者的深入了解，这些框架头上的光环逐步褪色。晦涩难懂的架构、糟糕的性能，以及太多的限制，让这些框架难以在实际项目中运用。
　　此时，许多PHP开发者认为可以借鉴RoR的设计思想，但不应照搬RoR的结构和实现。为此，一些同样推崇快速开发的框架开始在PHP社区出现。这些框架中，CakePHP和Symfony可谓佼佼者。

CakePHP（http://www.cakephp.org/）
　　CakePHP充满了RoR的影子，从ActiveRecord模式到视图的布局管理都和RoR非常相似。而且CakePHP一开始也尝试实现与 RoR一样的许多东西。但CakePHP的开发团队后来发现PHP语言和Ruby语言存在巨大区别，因此RoR中的许多设计即便能够在PHP中实现，也是 缺乏实用价值的。
　　CakePHP在发展中逐步走出了RoR的阴影，开始探索更能发挥PHP语言本身优势的架构和实现。因此有一段时间CakePHP的API发生了剧烈的变化，以致其他开发者纷纷停下脚步处于观望状态。
　　但由于前期一些架构的不合理和对RoR太多的模仿，导致CakePHP的核心部分越来越难以理解，运行性能也不尽人意。而且CakePHP将一个庞大的数据库操作对象作为所有业务对象的基础。这虽然利于快速开发，但却导致对业务逻辑对象的测试非常困难。
　　对于较小型的项目，CakePHP非常理想。出色的快速开发能力、丰富的API和详尽的文档都可以帮助开发者很快完成工作。但随着项目规模的增加，CakePHP的局限性也变得突出。

Symfony（http://www.symfony-project.com/）
　　Symfony是一个非常成熟的框架，大量利用了已有的开源项目。Symfony使用Mojavi的核心代码实现了框架的MVC模式，利用 Propel作为数据库抽象层。Symfony不仅功能强大，而且对Ajax有全面的支持。加上官方网站提供的大量文档和教程，并拥有一个活跃的社区，因 此受到许多开发者的欢迎。
　　但是，Symfony最大的问题也在于使用了太多风格迥异的开源项目来组合成框架。由于Mojavi和Propel本身都相当复杂，因此Symfony的结构非常复杂，难以理解和学习。
　　不过对于希望选择一个框架作为企业内部系统基础架构的企业来说，Symfony的成熟度、丰富的文档和活跃的社区都是值得考虑的。毕竟企业内部系统更为看重的是稳定性和长期的支持。

商业利益与大道至简
　　看到PHP开发框架的潜在商业价值后，Zend.com联合IBM宣布将要推出一个真正能够发挥PHP优势的开发框架。一时间，这个消息在整个PHP社区引起了地薄雾浓云愁永昼震。大家都开始期盼这个具有“官方”背景的开发框架能够为PHP开发者指出一条正确的道路。
　　不过世事难测，就在Zend Framework团队公布几个代码片断后，立即就有开发者指出这些代码片段是不可能实现的。事实证明这些代码片段不过是美好的理想。限于PHP语言本身 的能力，Zend Framework最终没有实现当初承诺提供的类似RoR中ActiveRecord模式的实现品。

Zend Framework（http://framework.zend.com/）
　　Zend Framework大量应用了PHP5中面向对象的新特征：接口、异常、抽象类、SPL等等。这些东西的应用让Zend Framework具有高度的模块化和灵活性。同时，因为严格遵循“针对接口编程”和“单一对象职责”等原则，让Zend Framework很有希望成为一个出色的企业应用开发框架。
　　但不幸的是Zend Framework直到今天，也没有做出更多的突破。在使用Zend Framework开发时，框架对应用程序自身最重要的领域逻辑分离没有提供任何帮助。如果希望开发出真正健壮的企业应用，仍然需要开发者做出相当的努 力，并且在Zend Framework之上建造自己的基础设施。
　　针对这点，批评者指出Zend Framework虽然大量应用PHP5的新特征，但却没有将这些相对于PHP4的优势转化为能够为开发者提供帮助的东西。

　　对于简单和小型的项目来说，Zend Framework不但不能提高开发效率。反而因为在框架中应用了大量面向对象设计和PHP5的新特征，对开发者提出了更高的要求，间接增加了项目的开发 成本。而对于较大的项目和企业应用，Zend Framework倒是一个不错的基础。但要创建一个成功的应用，仍然需要付出不小的努力。并且要时刻注意Zend Framewok的性能问题。

Code Igniter（http://www.codeigniter.com/）
　　Code Igniter可以说是一匹黑马。Code Igniter出现之时正是Symfony和CakePHP大行其道、Zend Framework万众期待的时刻。可凭借着独特的设计思想，Code Igniter吸引了大批开发者。这点从其火爆的官方论坛就可得到证实。
　　Code Igniter推崇“简单就是美”这一原则。没有花哨的设计模式、没有华丽的对象结构，一切都是那么简单。几行代码就能开始运行，再加几行代码就可以进行 输出。大部分日常开发中用到的东西都可以立即找到，并且可以很容易的使用。Code Igniter可谓是“大道至简”的典范。
　　但是，Code Igniter本身的实现不太理想。内部结构过于混乱，虽然简单易用，但缺乏扩展能力。因此在发展到1.5系列版本时，作者不得不通过增加各种hooks来为框架提供扩展能力。

国内PHP开发框架

　　国内虽然过去也曾有开发者发布过一些框架，但这些框架要么太过简单，要么和某一类型的应用紧密耦合，缺乏通用性。直到进入2006年，随着PHP在国内的大量应用和追捧，真正的国产PHP开发框架才陆续发布。

FCS（http://fcs.org.cn/） 
　　FCS是从Java的Struts结构移植过来的中文PHP开发框架，使用面向对象的开发结构和MVC模式，并且模拟实现了Struts的标签库，借
　　FleaPHP从发展上看，是一个具有一定历史的框架。在过去三年中，FleaPHP是作者发布了从PFC1到PFC3系列和flea1试验框架后，推出的第一个真正成熟、稳定的开发框架。
　　与许多其他框架不同，FleaPHP设计之初，就是围绕快速开发和充分利用PHP自身优势两个重点展开的。因此FleaPHP最大的特点就是极高的模块化程度和扩展能力。
　　FleaPHP框架的核心非常小，但通过灵活的配置，可以组合出各种类型的基础架构。对于简单的脚本页面，FleaPHP不需要载入MVC模式，只需 要为应用程序提供业务逻辑和数据库服务。而对于复杂的应用程序，FleaPHP可以完成从MVC模式调用、访问控制、数据验证到文件上传、图片处理等各种 各样的任务。
　　正是因为这种出色的定制和扩展能力，FleaPHP真正接近了“满足从简单应用到企业开发的各种需求”这个目标。而且与许多其他框架不同， FleaPHP是一个完全在实际开发中精炼出来的框架。因此伴随着FleaPHP的发展，各种各样的实际应用也相继出现。在FleaPHP官方网站上，可 以看到各种各样的实际应用。从最简单的企业宣传网站，到复杂的社区网站、企业内部系统等等，不一而足。

　　FleaPHP作为一个完全国产的框架，具有完全中文化的文档、代码注释，并且在扩展功能上也注重考虑国内开发者的实际需求。因此相对于国外的各种框架，FleaPHP更容易被国内开发者所接受。
　　但是，也正因为处在国内，FleaPHP面临比国外同行多得多的困难。缺乏足够的贡献者、无礼的责难，以及充满怀疑的眼光，这些都让FleaPHP的 开发团队成员需要更多的奉献精神。而且由于缺乏足够的贡献者，FleaPHP框架目前在文档和扩展功能方面，与其他成熟框架相比还有不小的差距。
　　并且与其他所有的PHP开发框架一样，FleaPHP也没有找到帮助开发者分离应用程序领域逻辑的途径。虽然有指导文档，但对于初级开发者来说，一个可以拿来就用的领域逻辑基础会显得很实用。

反思与进取

　　RoR带来的冲击波还远为平息，但PHP开发者们已经在开始反思一味追随RoR的脚步是否真的能够为PHP开发带来质变？
　　RoR之所以能够取得如此巨大的成功，除了RoR本身的设计思想外，还有一个重要原因就是RoR充分利用了Ruby这种语言的特长。将Ruby动态语 言的优势发挥得淋漓尽致。而在PHP中如果只是单纯照搬RoR中设计，则要处处遇到PHP语言本身的限制。为了绕开这些限制，开发者不得不用一些难以理解 的技巧来解决问题。但这样一来通常会导致框架的结构变得晦涩难懂、性能受到损害。
　　在这种反思中，Code Igniter、FleaPHP等框架就是对这个问题的最好回答。只有充分利用PHP语言本身的优势，才能真正让PHP开发变得更简单、更有趣。

　　发展到今天，各种PHP开发框架虽然具有各自的特色，但几乎都是为了提高开发效率而努力。但是，虽然其中部分框架注意到了提高应用程序可维护性的问题，但都没有为领域逻辑分离这个至关重要的问题提出解决方案。而这正是这些框架在未来的发展目标。
　　对于简单的Web应用和复杂的企业应用，两者之间的差别就注定了采用一种固定的架构是无法满足需求的。因此像FleaPHP这样能够提供自定义架构能力的框架，可以让开发者尝试用一个框架的不同组合来解决从简单到复杂的不同程度的需求。

　　未来，PHP将成为Web开发领域中越来越重要的平台。因此我们相信会出现更多更好的开发框架。虽然作为开发者来说，并不一定需要采用某一个框架来解决问题。但正是因为这些不断出现的框架，我们对使用PHP开发Web应用的理解和把握得到了一次次的推动

官方提供的工具：
  MySQL Administrator GUI client 
下载地址：   
  http://dev.mysql.com/downloads/administrator/index.html

官方数据察看：
MySQL Query Browser graphical client
下载地址：
  http://dev.mysql.com/downloads/query-browser/1.1.html

SQLyog MySQL GUI
  分为企业版本和普通版本：
  http://www.webyog.com/index.php

Navicat MySQL database administration and development tool 
  http://www.navicat.com/download.html

MySQL Maestro
http://www.dignitysoftware.com/mysql-management.html

web based phpMyAdmin 
  http://www.phpmyadmin.net/home_page/

EMS MySQL Manager? MySQL? Database Server administration and evelopment
http://sqlmanager.net/products/mysql/manager/

Toad for MySQL
  http://www.toadsoft.com/toadmysql/mysql_lic_agree.html

Zope: 一个开源的web应用服务器

VIM和Emacs的相似之处:

    首先都是全功能的编辑器
    缩进,重新编排格式
    语法高亮
    无限制的撤消和重做
    多个剪切,粘贴板
    拼写检查
    多语言支持
    可扩展性强
        宏,函数
        自定义键
        自己定制.emacs和.vimrc(很多人的这两个文件都写得跟天书似的,可能主要考察一下记忆力)
    操作文本串,多行,矩形块
    几乎可以识别任何文本文件类型
    没有行有暗香盈袖长度和文件大小的限制(操作系统有限制除外)
    自动识别UNIX,MAC,MSWIN的行结尾符
    二进制文件编辑
    都有很好的帮助和用户手册以及免费的电子书
    都有TTY和GUI版本
    可以在很多操作系统上运行(*nix,win32,Mac...)
   VIM有其老头子VI和兄弟Nvi,Vile,Elvis等
      vim主要设计用来写程序的,当然也可操作众多的文本文件;Emacs主要设计用来文本操作的
    vim体积小启动快;相反,Emacs体积大,启动慢
    VIM专注于文本编辑;而Emacs功能强大:除了VIM常干的事外,还有排版,收发邮件,IDE,播放MP3,日程安排,系统管理,浏览网页,甚至教你做一道精美的川菜....,功能强大到BT的地步. 故若说VIM是一种工具的话,则Emacs则可认为是一种生活平台
    VIM学习曲线陡峭而较短;Emacs 学习曲线平缓而较长
    VIM是有模式的编辑器;而Emacs是没有模式的(现在的很多编辑器和word处理器都是无模式的)
    无模式的优缺点
        常见而显得亲近
        对于标准的下拉菜单式GUI程序,容易适应
        其命令有复杂的语法和很难敲的多个键的组合,因键盘上的键是有限的,所以恨不得加个脚踏
        甚至有些键在标准键盘上都没有
    有模式的优缺点
        ^X mode, operator-pending mode, Replace mode, Insert normal mode, Insert Visual mode, Insert Select mode我能想起的mode就这些---这么多,头都大了.
        在模式间频繁转换是令人讨厌的
        可以有更多的按键用于命令
        几乎所有的时间手指一般都停留在normal position,故而效率高
    Emacs的GUI更容易操作大体积的文本工作;gvim与Xwindow接合得更好--看起来感觉更舒服一些:好看一些的字体,好一点的语法高亮,好看一点的工具条等等. Emacs的TTY版本与GUI版本看起来非常相似, 而VIM的TTY版本和GUI版本(gvim)就有很大的不同,这也是我几乎不用gvim的原因(个人习惯)