好多年没更新了，不知道这里面朋友们还多不？

http://www.developsense.com/blog/2014/04/ive-had-it-with-defects/

我留在测试行业的时间越长，思考越多，我越相信“缺陷”这个概念是不清楚且无益的。

上厕所、想测试Google Testing on the Toilet (TotT)：测试行为，而不是方法

由Erik Kuefler Monday, April 14, 2014
本文改编自谷歌测试上厕所（TOTT）插曲。你可以下载一个打印机友好的版本，这TOTT插曲并张贴在你的办公室。

2)    清理夹具卸载逻辑

我们已经清理了结果验证逻辑，现在将注意力转向测试用例末尾的finally语句块。这些代码是做什么的？

      } finally {

         // Teardown

         deleteObject(invoice);

         deleteObject(product);

         deleteObject(customer);

         deleteObject(billingAddress);

         deleteObject(shippingAddress);

      }

大多数现代语言都有类似的tyr/finally结构，这些结构用来保证即使有错误或者异常发生时，某些代码还是会被执行。在一个“测试方法”中，finally语句块用于保证不管测试用例通过或不通过，那些清理用的代码都会执行到。一个失败断言会抛出一个异常，它会将执行控制交回“测试自动框架”[Test Automatin Framework]的异常处理代码，所以，我们使用finally块先去执行清理操作。这种方式让我们不再需要先捕获异常，再将其重新抛出。

这个测试用例中，finally语句块对测试中创建的每一个对象调用了deleteObject方法。很不幸，代码有一个致命的缺陷，你注意到了吗？

问题出在卸载过程本身。如果第一次调用deleteObject时抛出一个异常，会发生什么？正如代码所示那样，其他deleteObject调用不会被执行。解决方法是使用一个嵌套的try/finally语句将第一个deleteObject给包起来，这样可以保证第二个deleteObject调用总会被执行。但是，如果第二个调用失败了呢？这个例子中，我们需要总共6层的try/finally嵌套行。那将会使得测试用例的长度翻倍，我们不可能在第一个测试用例中编写和维护这么多代码。

      } finally {

         //      Teardown

         try {

            deleteObject(invoice);

         } finally {

            try {

               deleteObject(product);

            } finally {

               try {

                  deleteObject(customer);

               } finally {

                  try {

                     deleteObject(billingAddress);

                  } finally {

                     deleteObject(shippingAddress);

                  }

               }

            }

         }

问题出在我们现在有了一个“复杂卸载”（见含糊测试Obscure Test），要如何使得这段代码变好？我们怎么去测试这些测试代码？很明显，现在的办法并不十分有效。

当然，我们可以将这些代码移到tearDown方法中去，这样就能将它们从“测试方法”中移出。另外，由于tearDown方法的作用类似finally语句块，我们就能摆脱最外层的try/finally。遗憾的是，这个策略并没有触及到问题的根本：需要在每个测试用例中编写细节化的卸载代码。

我们可能通过使用“共享夹具”的方法一开始就避免创建对象，这样就不用在每个用例执行切换过程中去将对象销毁。不过，此方法会带来不少测试坏味，包括“不可重复式测试（Unrepeatable Test）”（见不稳定测试Erratic Test）、由于夹具共享引起交互的“交互式测试(Interacting Test)”。另外，共享夹具中对象的引用常常导致“神秘访客（Mystery Guests）”(见含糊测试)。

最好的解决方案是使用“新鲜夹具”，同时避免为每个用例编写卸载代码。为达到这个目的，我们可以使用能被自动垃圾回收掉的内存中夹具。然而，当创建的对象是持久化时（如，他们被保存到数据库中），这个办法就失效了。

构建的系统架构能让大多数测试用例不依赖于数据库就能执行，这样最好了，但是我们还是经常遇到许多测试用例需要数据库的。在这种情况下，我们可以扩展测试自动化框架(Test Automation Framework)去完成大部份的工作。可以增加一种使用框架来进行创建对象注册的办法，这样，框架就能为进行删除操作。

首先，当创建对象时，我们需要注册它。

      //   Set up fixture

      billingAddress = new Address("1222 1st St SW", "Calgary",

                        "Alberta", "T2N 2V2", "Canada");

      registerTestObject(billingAddress);

      shippingAddress = new Address("1333 1st St SW", "Calgary",

                         "Alberta","T2N 2V2", "Canada");

      registerTestObject(shippingAddress);

      customer = new Customer(99, "John", "Doe",

                              new BigDecimal("30"),

                              billingAddress,

                              shippingAddress);

      registerTestObject(shippingAddress);

      product = new Product(88, "SomeWidget",

                            new BigDecimal("19.99"));

      registerTestObject(shippingAddress);

      invoice = new Invoice(customer);

      registerTestObject(shippingAddress);

注册过程由将对象加入到测试对象集合的操作构成：

   List testObjects;

   protected void setUp() throws Exception {

      super.setUp();

      testObjects = new ArrayList();

   }

   protected void registerTestObject(Object testObject) {

      testObjects.add(testObject);

   }

在tearDown方法中，我们遍历测试对象集合，并将每个对象删除：

 

   public void tearDown() {

      Iterator i = testObjects.iterator();

      while (i.hasNext()) {

         try {

            deleteObject(i.next());

         } catch (RuntimeException e) {

            // Nothing to do; we just want to make sure

            // we continue on to the next object in the list

         }

      }

   }

 

现在测试用例变成这样子：

   public void testAddItemQuantity_severalQuantity_v8(){

      Address billingAddress = null;

      Address shippingAddress = null;

      Customer customer = null;

      Product product = null;

      Invoice invoice = null;

      //   Set up fixture

      billingAddress = new Address("1222 1st St SW", "Calgary",

                        "Alberta", "T2N 2V2", "Canada");

      registerTestObject(billingAddress);

      shippingAddress = new Address("1333 1st St SW", "Calgary",

                         "Alberta","T2N 2V2", "Canada");

      registerTestObject(shippingAddress);

      customer = new Customer(99, "John", "Doe",

                              new BigDecimal("30"),

                              billingAddress,

                              shippingAddress);

      registerTestObject(shippingAddress);

      product = new Product(88, "SomeWidget",

                            new BigDecimal("19.99"));

      registerTestObject(shippingAddress);

      invoice = new Invoice(customer);

      registerTestObject(shippingAddress);

      // Exercise SUT

      invoice.addItemQuantity(product, 5);

      // Verify outcome

      LineItem expected =

         new LineItem(invoice, product, 5,

                      new BigDecimal("30"),

                      new BigDecimal("69.96"));

      assertContainsExactlyOneLineItem(invoice, expected);

   }

我们已经能够将try/finally语句块给移除。除了调用registerTestObject外，我们变得代码简单多了。但我们仍然可以进一步精简代码。为什么这样说？我们需要将声明变量，然后将它们初始化为null，再稍后对其重新初始化吗？之前的测试用例这样做是因为这样变量必须在finally语句块中可访问;现在我们将finally块移除了，所以我们可以将变量定义与初始化操作合并。

   public void testAddItemQuantity_severalQuantity_v9(){

      //   Set up fixture

      Address billingAddress = new Address("1222 1st St SW",

                  "Calgary", "Alberta", "T2N 2V2", "Canada");

      registerTestObject(billingAddress);

      Address shippingAddress = new Address("1333 1st St SW",

                  "Calgary", "Alberta", "T2N 2V2", "Canada");

      registerTestObject(shippingAddress);

      Customer customer = new Customer(99, "John", "Doe",

                                       new BigDecimal("30"),

                                       billingAddress,

                                       shippingAddress);

      registerTestObject(shippingAddress);

      Product product = new Product(88, "SomeWidget",

                                    new BigDecimal("19.99"));

      registerTestObject(shippingAddress);

      Invoice invoice = new Invoice(customer);

      registerTestObject(shippingAddress);

      // Exercise SUT

      invoice.addItemQuantity(product, 5);

      // Verify outcome

      LineItem expected =

         new LineItem(invoice, product, 5,

                      new BigDecimal("30"),

                      new BigDecimal("69.95"));

      assertContainsExactlyOneLineItem(invoice, expected);

   }

 

3)    清理夹具创建

我们已经清理好了断言及夹具卸载，现在来看看夹具创建。一个明显的“快速修复”就是，对构造函数和registerTestObject的调用，利用“方法抽取重构”来定义“生成方法”（Creation Method）。这样可以使得测试用例更易于读写。“生成方法”有另外一个好处：它们封装了SUT的API，使得当对象的构造函数发生改变时，我们不必每个测试用例都去更改，只需要去修改一个地方，减少了测试用例的维护成本。

   public void testAddItemQuantity_severalQuantity_v10(){

      //   Set up fixture

      Address billingAddress =

         createAddress( "1222 1st St SW", "Calgary", "Alberta",

                        "T2N 2V2", "Canada");

      Address shippingAddress =

         createAddress( "1333 1st St SW", "Calgary", "Alberta",

                        "T2N 2V2", "Canada");

      Customer customer =

         createCustomer( 99, "John", "Doe", new BigDecimal("30"),

                         billingAddress, shippingAddress);

      Product product =

         createProduct( 88,"SomeWidget",new BigDecimal("19.99"));

      Invoice invoice = createInvoice(customer);

      // Exercise SUT

      invoice.addItemQuantity(product, 5);

      // Verify outcome

      LineItem expected =

         new LineItem(invoice, product,5, new BigDecimal("30"),

                      new BigDecimal("69.96"));

      assertContainsExactlyOneLineItem(invoice, expected);

   }

 

这个夹具创建逻辑还是有其他问题。第一个问题是，很难明确这个夹具与测试预期输出之前的联系。Customer对象的细节会以某种方式影响到输出吗？customer的address域会影响到输出？这个用例真正想验证的是什么？

另一个问题是：这个测试用例展示了“硬编码测试数据”(Hard-Coded Test Data)（见模糊测试）。如果SUT将我们创建的所有对象持久化到数据库中，那硬编码数据就会导致:当customer，product或者invoice的某些域要求必须唯一时，会出现“不可重复式测试”、“交互式测试”或者“测试执行冲突Test Run War”(见不稳定测试)。

我们可以通过为每一个测试用例生成唯一的值并用这个值做为种子（seed）去产生用例中使用到的对象。这个办法能保证每次用例执行时，都会得到不同的对象。因为我们已经将对象产生逻辑移到了生成方法中，这一步修改相对容易。我们只要将上述逻辑放到生成方法中并去掉相应的参数就行了。抽取方法式重构还有另外一个用处，我们可以生成一个新的、无参数的新版生成方法。

   public void testAddItemQuantity_severalQuantity_v11(){

      final int QUANTITY = 5;

      //   Set up fixture

      Address billingAddress = createAnAddress();

      Address shippingAddress = createAnAddress();

      Customer customer = createACustomer(new BigDecimal("30"),

               billingAddress, shippingAddress);

      Product product = createAProduct(new BigDecimal("19.99"));

      Invoice invoice = createInvoice(customer);

      // Exercise SUT

      invoice.addItemQuantity(product, QUANTITY);

      // Verify outcome

      LineItem expected =

         new LineItem(invoice, product, 5, new BigDecimal("30"),

                      new BigDecimal("69.96"));

      assertContainsExactlyOneLineItem(invoice, expected);

   }

   private Product createAProduct(BigDecimal unitPrice) {

      BigDecimal uniqueId = getUniqueNumber();

      String uniqueString = uniqueId.toString();

      return new Product(uniqueId.toBigInteger().intValue(),

                         uniqueString, unitPrice);

   }

 

我们将这个模式称为“匿名生成方法”(Anonymous Creation Method)，因为这个模式表明我们并不关心对象本身的特性。如果SUT的预期行为依赖于特定的值，我们要么可以将这个值做为参数传到生成函数，要么可以在生成函数的函数名中暗示。

这个测试用例看上会好一些了，但是仍然没有做完。预期结果真的以某种方式依赖于customer对象的address？如果不依赖，我们可以通过抽取方法式重构（再一次）将它们的创建过程完全隐藏，这里用createACustomer方法来达到这个目的：

   public void testAddItemQuantity_severalQuantity_v12(){

      //  Set up fixture

      Customer cust = createACustomer(new BigDecimal("30"));

      Product prod = createAProduct(new BigDecimal("19.99"));

      Invoice invoice = createInvoice(cust);

      // Exercise SUT

      invoice.addItemQuantity(prod, 5);

      // Verify outcome

      LineItem expected = new LineItem(invoice, prod, 5,

            new BigDecimal("30"), new BigDecimal("69.96"));

      assertContainsExactlyOneLineItem(invoice, expected);

   }

 

将创建address对象的调用移到customer 查看(607) 评论(0) 收藏 分享 管理

       首先想骂一下《XUint 测试模式 -测试码重构》这本书的译者。多好一本书被不负责任的翻译给糟蹋了。 现在将最前面一部份试着翻译一下，希望能对写好UT有所帮助：

0.1              为什么要重构测试？

测试【这里指测试代码或用例】会迅速成为敏捷开发过程的瓶颈。对于从来没有体会过简单、易于理解的测试代码与复杂、迟钝、难以维护的测试代码之间区别的人来说，这可能不会马上显而易见。生产效率的差别会让人大吃一惊。

         本书的这部份会作为全书的一个“激发式例子”，它将给你展示重构测试代码能够带来多大的改变。这个例子将会从一个复杂的测试用例开始，一步步地，将它重构为简单而易懂的测试用例。在这个过程中，我将指出一些关键的坏味（smells）以及用于去除它们的模式。希望能提起你更多的胃口。

0.2              一个复杂的测试用例

这儿有一个我在多个项目到测试用例中经常出现的一类。

public void testAddItemQuantity_severalQuantity_v1(){

      Address billingAddress = null;

      Address shippingAddress = null;

      Customer customer = null;

      Product product = null;

      Invoice invoice = null;

      try {

         //   Set up fixture

         billingAddress = new Address("1222 1st St SW",

               "Calgary", "Alberta", "T2N 2V2","Canada");

         shippingAddress = new Address("1333 1st St SW",

               "Calgary", "Alberta", "T2N 2V2", "Canada");

         customer = new Customer(99, "John", "Doe",

                                 new BigDecimal("30"),

                                 billingAddress,

                                 shippingAddress);

         product = new Product(88, "SomeWidget",

                               new BigDecimal("19.99"));

         invoice = new Invoice(customer);

         // Exercise SUT

         invoice.addItemQuantity(product, 5);

         // Verify outcome

         List lineItems = invoice.getLineItems();

         if (lineItems.size() == 1) {

            LineItem actItem = (LineItem) lineItems.get(0);

            assertEquals("inv", invoice, actItem.getInv());

            assertEquals("prod", product, actItem.getProd());

            assertEquals("quant", 5, actItem.getQuantity());

            assertEquals("discount", new BigDecimal("30"),

                           actItem.getPercentDiscount());

            assertEquals("unit price",new BigDecimal("19.99"),

                              actItem.getUnitPrice());

            assertEquals("extended", new BigDecimal("69.96"),

                           actItem.getExtendedPrice());

         } else {

            assertTrue("Invoice should have 1 item", false);

         }

      } finally {

         // Teardown

         deleteObject(invoice);

         deleteObject(product);

         deleteObject(customer);

         deleteObject(billingAddress);

         deleteObject(shippingAddress);

      }

   }

这个用例有点长，也比应有的情况更加地复杂。这个“晦涩测试”（page186）难以理解，因为测试用例中那么多行代码使得看清全貌很困难。它还有很多其他问题，我们会一一叙述。

0.3              清理测试用例

先让我们来看看测试用例的几个部份。

1)    清理验证逻辑

首先让关注验证预期结果的那部份。我们或许可以从断言去推断这个用例去验证的条件。

       List lineItems = invoice.getLineItems();

         if (lineItems.size() == 1) {

            LineItem actItem = (LineItem) lineItems.get(0);

            assertEquals("inv", invoice, actItem.getInv());

            assertEquals("prod", product, actItem.getProd());

            assertEquals("quant", 5, actItem.getQuantity());

            assertEquals("discount", new BigDecimal("30"),

                           actItem.getPercentDiscount());

            assertEquals("unit price",new BigDecimal("19.99"),

                              actItem.getUnitPrice());

            assertEquals("extended", new BigDecimal("69.96"),

                           actItem.getExtendedPrice());

         } else {

            assertTrue("Invoice should have 1 item", false);

         }

一个需要修复的简单问题就是最后一行那个愚钝的断言。调用带有false参数的assertTrue就是想使得测试断言失败，那么为什么不直接一点呢？将其改为对fail的调用:

      List lineItems = invoice.getLineItems();

      if (lineItems.size() == 1) {

         LineItem actItem = (LineItem) lineItems.get(0);

         assertEquals("inv", invoice, actItem.getInv());

         assertEquals("prod", product, actItem.getProd());

         assertEquals("quant", 5, actItem.getQuantity());

         assertEquals("discount", new BigDecimal("30"),

                        actItem.getPercentDiscount());

         assertEquals("unit price",new BigDecimal("19.99"),

                           actItem.getUnitPrice());

         assertEquals("extended", new BigDecimal("69.96"),

                        actItem.getExtendedPrice());

      } else {

         fail("Invoice should have exactly one line item");

      }

         可以把这个改动看成是“方法提取”重构（Fowler），因为我们将一个带硬编码参数的“陈述预期式断言”用一个意图更明确的“单一预期断言”去封装来调用。

         当然，这组断言还有更多的问题，比如，我们为什么需要这么多断言？结果是许多断言都在测试通过LineItem的构造函数设置的成员变量，而这些测试应该由其他的单元测试来覆盖。那么为什么要在这里重复这些断言呢？重复断言只会产生更多当逻辑发生变化时需要维护的代码。

         我们的解决办法是使用针对“预期对象”的一个简单的断言来代替针对对象每一个字段的断言。首先我们定义一个与预期结果类似的对象。在这个例子中，我们创建一个预期的LineItem对象，它的每个字段都是预期的值，包括通过product初始化好的unitPrice和extenedPrice。

         List lineItems = invoice.getLineItems();

         if (lineItems.size() == 1) {

            LineItem expected =

               new LineItem(invoice, product, 5,

                            new BigDecimal("30"),

                            new BigDecimal("69.96"));

            LineItem actItem = (LineItem) lineItems.get(0);

            assertEquals("invoice", expected.getInv(),

                                    actItem.getInv());

            assertEquals("product", expected.getProd(),

                                    actItem.getProd());

            assertEquals("quantity",expected.getQuantity(),

                                    actItem.getQuantity());

            assertEquals("discount",

                         expected.getPercentDiscount(),

                         actItem.getPercentDiscount());

            assertEquals("unit pr", new BigDecimal("19.99"),

                                    actItem.getUnitPrice());

            assertEquals("extend pr",new BigDecimal("69.96"),

                                     actItem.getExtendedPrice());

         } else {

            fail("Invoice should have exactly one line item");

         }

一旦我们创建了“预期结果对象”，我们就可以使用针对对象的assertEquals：

       List lineItems = invoice.getLineItems();

       if (lineItems.size() == 1) {

          LineItem expected =

             new LineItem(invoice, product,5,

                          new BigDecimal("30"),

                          new BigDecimal("69.96"));

          LineItem actItem = (LineItem) lineItems.get(0);

          assertEquals("invoice", expected, actItem);

       } else {

          fail("Invoice should have exactly one line item");

       }

明显地，“保持对象完整”重构方法【Fowler】使得代码更加简洁。但是！为什么测试用例中会有if?如果一个用例中有多条路径分支，我们怎么知道它到底执行了哪个分支？最好能去掉这种“条件式测试逻辑”。幸运的是，“守卫式断言”这是用来处理此类情况。简单采用“卫语句代替条件表达式”重构方法【Fowler】，用针对相同条件的一个断言来代替if…else fail()语句序列。这种“守卫式断言”会在条件不满足时终止执行，而不用引入“条件式测试逻辑”。

      List lineItems = invoice.getLineItems();

      assertEquals("number of items", 1,lineItems.size());

      LineItem expected =

         new LineItem(invoice, product, 5,

                      new BigDecimal("30"),

                      new BigDecimal("69.96"));

      LineItem actItem = (LineItem) lineItems.get(0);

      assertEquals("invoice", expected, actItem);

         {52}至此，我们将11行验证语句缩减到4行，另外，这4行代码也更为简单（and those 4lines are a lot simpler code to boot to boot in addition to everything else you have mentioned）。（注：没有根据我们所写的代码行数来领取报酬，真是件好事啊！这也是为何说KLOC是生产效率糟糕度量的一个例子）。不少人认识这些重构已经足够好了，但是，我们还可以让这些断言更加明了吗？我们真正想验证的到底是什么？我们想说的是，只有一个lineItem，它应该与我们定义的expectedLineItem完全一致。我们可以使用“抽取方法”重构定义一个“自定义断言”来明白地将这种验证给表现出来。

         LineItem expected =

            new LineItem(invoice, product, 5,

                         new BigDecimal("30"),

                         new BigDecimal("69.96"));

         assertContainsExactlyOneLineItem(invoice, expected);

这样好多了！现在，测试用例的验证部份只有两行。当我们将用例完整地再看看：

   public void testAddItemQuantity_severalQuantity_v6(){

      Address billingAddress = null;

      Address shippingAddress = null;

      Customer customer = null;

      Product product = null;

      Invoice invoice = null;

      try {

         //   Set up fixture

         billingAddress = new Address("1222 1st St SW",

                "Calgary", "Alberta", "T2N 2V2", "Canada");

         shippingAddress = new Address("1333 1st St SW",

                "Calgary", "Alberta", "T2N 2V2", "Canada");

         customer = new Customer(99, "John", "Doe",

                                 new BigDecimal("30"),

                                 billingAddress,

                                 shippingAddress);

         product = new Product(88, "SomeWidget",

                               new BigDecimal("19.99"));

         invoice = new Invoice(customer);

         // Exercise SUT

         invoice.addItemQuantity(product, 5);

         // Verify outcome

         LineItem expected =

            new LineItem(invoice, product, 5,

                         new BigDecimal("30"),

                         new BigDecimal("69.96"));

         assertContainsExactlyOneLineItem(invoice, expected);

      } finally {

         // Teardown

         deleteObject(invoice);

         deleteObject(product);

         deleteObject(customer);

         deleteObject(billingAddress);

         deleteObject(shippingAddress);

      }

   }

2)    清理夹具卸载逻辑

我们已经清理了结果验证逻辑，现在将注意力转向测试用例末尾的finally语句块。这些代码是做什么的？

      } finally {

         // Teardown

         deleteObject(invoice);

         deleteObject(product);

         deleteObject(customer);

         deleteObject(billingAddress);

         deleteObject(shippingAddress);

      }

大多数现代语言都有类似的tyr/finally结构，这些结构用来保证即使有错误或者异常发生时，某些代码还是会被执行。在一个“测试方法”中，finally语句块用于保证不管测试用例通过或不通过，那些清理用的代码都会执行到。一个失败断言会抛出一个异常，它会将执行控制交回“测试自动框架”[Test Automatin Framework]的异常处理代码，所以，我们使用finally块先去执行清理操作。这种方式让我们不再需要先捕获异常，再将其重新抛出。

这个测试用例中，finally语句块对测试中创建的每一个对象调用了deleteObject方法。很不幸，代码有一个致命的缺陷，你注意到了吗？

问题出在卸载过程本身。如果第一次调用deleteObject时抛出一个异常，会发生什么？正如代码所示那样，其他deleteObject调用不会被执行。解决方法是使用一个嵌套的try/finally语句将第一个deleteObject给包起来，这样可以保证第二个deleteObject调用总会被执行。但是，如果第二个调用失败了呢？这个例子中，我们需要总共6层的try/finally嵌套行。那将会使得测试用例的长度翻倍，我们不可能在第一个测试用例中编写和维护这么多代码。

      } finally {

         //      Teardown

         try {

            deleteObject(invoice);

         } finally {

            try {

               deleteObject(product);

            } finally {

查看(406) 评论(0) 收藏 分享 管理

测试自动化的目标及原则
（摘自xUnit Test patterns Refactoring Test code）

“想通过更多的测试来改善软件的质量，就跟妄想通过更频繁的称重来减肥一样”

                                                                                          《代码大全(第二版)》

当第一次听到这句话的时候，很震惊，也很难理解：我们不是通过测试找到软件的很多bug，不是通过测试让开发对代码进行了修改吗？为什么作者会有如此说法？

 也许上面那句话说得有些绝对，但是，如果我们只把测试定义为软件质量度量的一种方式，把测试工作的目的定义为寻找缺陷，那么上面这句话就是正确的了。传统测试过多侧重于大规模的集成测试，处于的项目后期，太过被动。做为项目质量最后的守门员，它的责任太大，它也担当不起这个角色。因为，永远没有完备的测试!就算QA一天24小时都在写用例、执行用例，也保证不了产品上线之后没有问题！就算我们发现了很多缺陷，开发在做修改的时候，由于缺少更细粒度、更精确的对原有代码功能的保证，可能会引入更多的缺陷！辛辛苦苦发现的缺陷能否对软件最终质量提高起到积极作用，就要打个问号了。这让我想起来了测试领域一句名言------“测试永远只能证明代码有问题，而不能证明代码没有问题”。

 那测试对于代码质量的提高真的没有价值了吗？绝对不是！把我们的思想转变一下，把重点转换一下。测试的灵魂不在于去度量软件的质量，而在于按照下面的方式去保证和提高软件的质量：

1.       通过测试，从设计及代码层面去提高软件质量；

2.       通过测试，去加快每一次项目的发布周期；

3.       通过测试，去保证每次改动、每个新功能添加的正确性。

 

要如何达到这些作用呢？

1.       将测试（特别是能够快速反馈、准确定位的小测试）作为代码所要实现的功能的夹钳（也就是必须保证通过的条件），保证有变更时的代码的正确性; 保证代码对外功能不稳定性，也能放心大胆地对代码进行重构、优化。

2.       将可测试性作为测试对代码质量进行提升的途径。将测试作为添加功能或者修改代码时必须保证通过的条件，就能

3.       将测试作为体现业务需求、代码功能的说明文档。代码本身的功能及使用方式， 通过测试用例本身就能得到准确而形象的说明。

TDD的核心思想也就是这样子的。《修改代码的艺术》中也反复提到如何通过测试来保证修改，如何通过测试、为了测试去提高新老代码的质量。

 “不能被很好测试的代码，一定是设计糟糕、实现糟糕的代码！”，为了可以测试、方便测试而进行的代码可测试性方面的改善,对代码的封装性、可扩展性等方面会带来直接的提升。 只有这样的测试，才会对代码质量的提高起到至关重要的作用。

    测试人员应该与开发一起，提高代码的可测试性、提高设计的可测试性！在交付高质量软件产品的共同目标下，测试与开发的分工和界限会越来越模糊。

   为什么说可测试性与代码质量密切相关，测试对代码质量能产生积极影响呢？可以看看下面两个例子：

例子1：

糟糕的代码：

class Car {

public Car() {

             engine = new Engine();

             windshield = new Windshield();

       }

}

class Engine {

 public Engine() {

             sparkplugs.add(new Sparkplug());

             sparkplugs.add(new Sparkplug());

}

}

当要进行测试时，不管我们是否需要Car类的所包含的所有零件，我们都要花时间去实例化它们，这个过程可能代价会很大。如果某个零件的类还没有实现，我们就不能开展与其无关的关于CAR类的其他测试。

从开发角度来说，这个实现很脆弱：当我们想使用一个新的高性能的sparkplug时，当我们想给car换一种engine时，我们必须对原来的代码进行修改。

 

好的代码：

class Engine {

public Engine(Set<Sparkplug> sparkplugs) {

             this.sparkplugs = sparkplugs;

}

}

class Car {

public Car(Engine engine, Windshield windshield) {

this.engine = engine;

this.windshield = windshield;

}

}

 

可测试性上：非常方便地去进行mock或者fack。如可以做一个fackEngine，让它从来不会启动。这样测试用例就可以方便地模拟出各种情况。

灵活性方面：现在不管是想要一个HighPerformanceSparkplugs的Enging，还是要一个FuelEfficientEngine ，都变得很容易。

        

例子2

糟糕的代码：

class User {

    private Preferences prefs;

    public User(File preferenceFile) {

        prefs = parseFile(preferenceFile);

    }

    public void doSomething() {

        … // using prefs

    }

    private Preferences parseFile {. . . }

}

测试方面的问题：1.涉及到了文件系统，测试会变得很慢 2.很难去构造测试执行的条件：需要去构造一个格式符合规范的文件 3如果文件格式发生变化，必须更新所有相关的测试用例

灵活性方面的问题：不能够支持今后的扩展，当需要改变文件格式时，侵入性地修改User类，当需要支持更多perference版本时，User中要有更多的逻辑判断，等等问题

        

         好的代码：

class User {

    private Preferences prefs;

    public User(Preferences prefs) {

        this.prefs = prefs;

    }

    public void doSomething() {

        … // using prefs

    }

}

灵活性方面：1.数据可以很方便地来源于更多的地方，2.对于每个新的数据来源，可以单独生成一个将数据转换为Perference的工具类。这个工具类本身是很好测试的。

测试方面的好处：1，运行更快 2.preference对于初始化测试变得代价很小 3.测试不再与文件的格式相依赖。

（例子来源：《Flexible Design? Testable Design?You Don't Have to Choose!》Russ Rufer & Tracy Bialik Google, Inc. GTAC 2010。这份ppt中还有更多的例子来说明代码的可测试性就是代码质量一个非常重要的方面）

 

由上面这个简单的例子可以看出，可测试性好的代码，能够方便地写出运行快、耦合小、依赖少的测试用例，而代码本身的结构也更加合理，在可扩展性、可维护性上面大大提高。

当我们把测试与开发活动融合在一起，通过测试提高软件的可测试性，那测试就变成软件质量提高的重要因素了！不再是简单的称重。

 

注：关于测试如何作为修改代码时的保证，如何做为代码功能的描述，大家可以参考TDD方面的资料及《修改代码的艺术》。

1.贵在坚持，形成习惯

2.每天进步一点点，别急！

3.做好每天的事情，耐心等待

4.用心工作、用心生活

5.经常总结、多些独处、多些思考

   最后，引一段最近在看的书中一小段话，很有意思：“比如说，你正打算要告诉某人一则刚发生的新闻。“猜猜看发生什么事了？你还不知道吗？我来告诉你吧！”如果你够警觉、够临在的话，你可能在正要宣布这则新闻之前，感受到自己内在的短暂满足感，即使这是一则坏消息。这是因为在小我的眼中，那一刻你和他人之间产生了施与受的不平衡状态：在那短短的一刻，你知道的比别人多。那个满足感是来自于小我，而且是源自于你感觉到你的自我感此刻比别人强。即使对方是总统或教皇，你在那一刻有更多的优越感，因为你知道的比别人多。很多人对八卦特别上瘾，就是因为这个缘故。不但如此，八卦通常带着对他人恶意的批评和判断，因此它也经由一个暗喻的（但却是幻想出来的）道德优越感来强化小我——每当你对某人有负面评价的时候，就会产生这种优越感。”

   又看到一篇值得好好看看的文章！个人觉得，只有意识层面上、心态上的问题解决了，技术、能力、知识层面的东西才能够慢慢地去主动积累和沉淀！才能够与时间赛跑、与自己的惰性战斗、在努力中创造自己的命运！

   有人工作，有人继续上学，大家千万不要错过这篇文章，能看到这篇文章也是一种幸运，真的受益匪浅，对我有很大启迪，这篇文章将会改变我的一生，真的太好了，希望与有缘人分享，也希望对有缘人有所帮助！看完之后有种“相见恨晚”的感觉，特别激动，希望大家好好的珍藏这篇文章，相信多年以后，再来看这篇文章，一定有不同的感觉。
        正如"打工皇帝"唐骏说："我觉得有两种人不要跟别人争利益和价值回报。第一种人就是刚刚进入企业的人，头5年千万不要说你能不能多给我一点儿工资，最重要的是能在企业里学到什么，对发展是不是有利……"
        人总是从平坦中获得的教益少，从磨难中获得的教益多；从平坦中获得的教益浅，从磨难中获得的教益深。一个人在年轻时经历磨难，如能正确视之，冲出黑暗，那就是一个值得敬慕的人。最要紧的是先练好内功，毕业后这5年就是练内功的最佳时期，练好内功，才有可能在未来攀得更高。
        出路在哪里？出路在于思路！
　　其实，没有钱、没有经验、没有阅历、没有社会关系，这些都不可怕。没有钱，可以通过辛勤劳动去赚；没有经验，可以通过实践操作去总结；没有阅历，可以一步一步去积累；没有社会关系，可以一点一点去编织。但是，没有梦想、没有思路才是最可怕的，才让人感到恐惧，很想逃避!
　　人必须有一个正确的方向。无论你多么意气风发，无论你是多么足智多谋，无论你花费了多大的心血，如果没有一个明确的方向，就会过得很茫然，渐渐就丧失了斗志，忘却了最初的梦想，就会走上弯路甚至不归路，枉费了自己的聪明才智，误了自己的青春年华。
    荷马史诗《奥德赛》中有一句至理名言："没有比漫无目的地徘徊更令人无法忍受的了。"毕业后这5年里的迷茫，会造成10年后的恐慌，20年后的挣扎，甚至一辈子的平庸。如果不能在毕业这5年尽快冲出困惑、走出迷雾，我们实在是无颜面对10年后、20年后的自己。毕业这5年里，我们既有很多的不确定，也有很多的可能性。
　　毕业这5年里，我们既有很多的待定，也有很多的决定。
　　迷茫与困惑谁都会经历，恐惧与逃避谁都曾经有过，但不要把迷茫与困惑当作可以自我放弃、甘于平庸的借口，更不要成为自怨自艾、祭奠失意的苦酒。生命需要自己去承担，命运更需要自己去把握。在毕业这5年里，越早找到方向，越早走出困惑，就越容易在人生道路上取得成就、创造精彩。无头苍蝇找不到方向，才会四处碰壁；一个人找不到出路，才会迷茫、恐惧。
    生活中，面对困境，我们常常会有走投无路的感觉。不要气馁，坚持下去，要相信年轻的人生没有绝路，困境在前方，希望在拐角。只要我们有了正确的思路，就一定能少走弯路，找到出路！
        成功的人不是赢在起点，而是赢在转折点。
    不少刚刚毕业的年轻人，总是奢望马上就能找到自己理想中的工作。然而，很多好工作是无法等来的，你必须选择一份工作作为历练。职业旅程中的第一份工作，无疑是踏入社会这所大学的起点。也许你找了一份差强人意的工作，那么从这里出发，好好地沉淀自己，从这份工作中汲取到有价值的营养，厚积薄发。千里之行，始于足下，只要出发，就有希望到达终点。
    起点可以相同，但是选择了不同的拐点，终点就会大大不同！
    毕业这几年，我们的生活、感情、职业等都存在很多不确定的因素，未来也充满了各种可能。这个时候，必须学会选择，懂得放弃，给自己一个明确的定位，使自己稳定下来。如果你不主动定位，就会被别人和社会"定型"！
　　可以这么说：一个人在毕业这5年培养起来的行为习惯，将决定他一生的高度。我们能否成功，在某种程度上取决于自己对自己的评价，这就是定位。你给自己定位是什么，你就是什么。定位能决定人生，定位能改变命运。丑小鸭变成白天鹅，只要一双翅膀；灰姑娘变成美公主，只要一双水晶鞋。
    人的命，三分天注定，七分靠打拼，有梦就"会红"，爱拼才会赢。只要不把自己束缚在心灵的牢笼里，谁也束缚不了你去展翅高飞。
    现实情况远非他们所想的那样。于是，当优越感逐渐转为失落感甚至挫败感时，当由坚信自己是一块"金子"到怀疑自己是一粒"沙子"时，愤怒、迷茫、自卑就开始与日俱增。
    其实，应该仔细掂量一下自己，你是否真是金子？是真金，手中要有绝活，才能上要有过人之处才行。一句话：真金是要靠实力来证明的，只有先把自己的本领修炼好了，才有资格考虑伯乐的事情
   每颗珍珠原本都是一粒沙子，但并不是每一粒沙子都能成为一颗珍珠。
   想要卓尔不群，就要有鹤立鸡群的资本。忍受不了打击和挫折，承受不住忽视和平淡，就很难达到辉煌。年轻人要想让自己得到重用，取得成功，就必须把自己从一粒沙子变成一颗价值连城的珍珠。
        天有下雨与日出，人生高峰与低谷。
        莫为浮云遮望眼，风物长宜放眼量。
    只要拂去阴霾，就能亮出朗朗晴空。如果你在工作上有些不如意，要相信自己不会一直处于人生的低谷期，总有一天能冲破重重云层。告诉自己：我并没有失败，只是暂时没有成功！只要在内心点亮一盏希望之灯，一定能驱散黑暗中的阴霾，迎来光明。
    的确，论资历，他们是不折不扣的职场菜鸟，业务涉及不深，人脉一穷二白，在工作中经常碰壁。他们的压力并不一定都像千钧大石，而是像大雨来临前的天色，灰色低沉，明明有空间，却被灰色填满每个缝隙，只能等待大雨倾盆之后的晴空。
　　"起得比鸡早，睡得比狗晚，干得比驴多，吃得比猪差。"这是很多刚刚毕业的人喜欢用来调侃自己生活状态的话。虽然有点儿夸张，但是，他们中的很多人的确一直都被灰色心情所笼罩--心里永远是多云转阴。记得有位哲人曾说："我们的痛苦不是问题本身带来的，而是我们对这些问题的看法产生的。"换个角度看人生，是一种突破、一种解脱、一种超越、一种高层次的淡泊与宁静，从而获得自由自在的快乐。
    一位哲人说："人生就是一连串的抉择，每个人的前途与命运，完全把握在自己手中，只要努力，终会有成。"就业也好，择业也罢，创业亦如此，只要奋发努力，都会成功。你是不是准备把生命的承诺全部都交给别人？
　　毕业后这5年，是改变自己命运的黄金时期。在最能决定自己命运时，如果还不把握，那你还要等到什么时候呢？我的人生我做主，命运由己不由人。
　　不要活在别人的嘴里，不要活在别人的眼里，而是把命运握在自己手里。
　　别说你没有背景，自己就是最大的背景。美国作家杰克·凯鲁亚克说过一句话："我还年轻，我渴望上路。"在人生的旅途中，我们永远都是年轻人，每天都应该满怀渴望。每个人的潜能都是无限的，关键是要发现自己的潜能和正确认识自己的才能，并找到一个能充分发挥潜能的舞台，而不能只为舞台的不合适感到不快。要客观公正地看待自己的能力，结合自己的实际情况和爱好冷静选择，尽可能到最需要自己、最适合自己的地方。
　    在人力资源管理界，特别流行一个说法，即"骑马，牵牛，赶猪，打狗"理论：人品很好，能力又很强的，是千里马，我们要骑着他；人品很好但能力普通的，是老黄牛，我们要牵着他；人品、能力皆普通的，就是"猪"，我们要赶走他；人品很差能力很强的，那是"狗"，我们要打击他。
    我想，刚刚毕业几年的你，一样胸怀大志，一样想成为一匹被人赏识、驰骋沙场的千里马吧？那么，就好好沉淀下来。低就一层不等于低人一等，今日的俯低是为了明天的高就。所谓生命的价值，就是我们的存在对别人有价值。能被人利用是一件好事，无人问津才是真正的悲哀！
    能干工作、干好工作是职场生存的基本保障。
    任何人做工作的前提条件都是他的能力能够胜任这项工作。能干是合格员工最基本的标准，肯干则是一种态度。一个职位有很多人都能胜任，都有干好这份工作的基本能力，然而，能否把工作做得更好一些，就要看是否具有踏实肯干、苦于钻研的工作态度了。
    在能干的基础上踏实肯干。
    工作中，活干得比别人多，你觉得吃亏；钱拿得比别人少，你觉得吃亏；经常加班加点，你觉得吃亏……其实，没必要这样计较，吃亏不是灾难，不是失败，吃亏也是一种生活哲学。现在吃点儿小亏，为成功铺就道路，也许在未来的某个时刻，你的大福突然就来了。
    能吃亏是做人的一种境界，是处世的一种睿智。
    在工作中并不是多做事或多帮别人干点儿活就是吃亏。如果领导让你加加班、赶赶任务，别以为自己吃了大亏，反而应该感到庆幸，因为领导只叫了你，而没叫其他人，说明他信任你、赏识你。吃亏是一种贡献，你贡献得越多，得到的回报也就越多。乐于加班，就是这样的一种吃亏。
    舍得舍得，有舍才有得；学会在适当时吃些亏的人绝对不是弱智，而是大智。
　　给别人留余地就是给自己留余地，予人方便就是予己方便，善待别人就是善待自己。
　　傻人有傻福，因为傻人没有心计。和这样的人在一起，身心放松，没有太多警惕，就能相互靠近。傻在很多时候意味着执着和忠贞，也意味着宽厚和诚实，让人不知不觉站到他一边。傻人无意中得到的，比聪明人费尽心机得到的还多。毕业这几年，你的天空中只飘着几片雪花，这样你就满足了吗？成功需要坚持与积累，与其专注于搜集雪花，不如省下力气去滚雪球。巴菲特说："人生就像滚雪球，最重要的是发现很湿的雪和很长的坡。"让自己沉淀下来，学着发现"很湿的雪"，努力寻找"很长的坡"。记住：散落的雪花会很快融化，化为乌有，只有雪球才更实在，才能长久。
在毕业这几年里，你要是能做到比别人多付出一分努力，就意味着比别人多积累一分资本，就比别人多一次成功的机会。
    什么是职业化呢？职业化就是工作状态的标准化、规范化、制度化，即在合适的时间、合适的地点用合适的方式说合适的话、做合适的事，使知识、技能、观念、思维、态度、心理等符合职业规范和标准。"在每个行业里，都有很多出色的人才，他们之所以能存在，是因为比别人更努力、更智慧、更成熟。但是，最重要的是，他们比一般人更加职业化！这就是为什么我现在能当你老板的原因。一个人仅仅专业化是不够的，只有职业化的人才能飞在别人前面，让人难以超越！"不要以为我们现在已经生存得很安稳了。对于毕业5年的人来讲，一定要认清即将面临的五大挑战。

一、赡养父母。
二、结婚生子。
三、升职加薪。
四、工作压力。
五、生活质量。
    有的人为生存而雀跃，目光总是停在身后，三天打鱼两天晒网，有始无终。
　  有的人为发展而奋斗，目光总是盯在正前方，每天进步一点点，坚持不懈。
　　毕业这几年，不能没有追求和探索，不能没有理想和目标。人生如逆水行舟，不进则退。甘于现状的生活就是不再前行的船，再也无法追上时代前进的步伐。一定要抓紧每一秒钟的时间来学习，要明白学习不是学生的专利。小聪明的人最得意的是：自己做过什么？大智慧的人最渴望的是：自己还要做什么？
　　小聪明是战术，大智慧是战略；小聪明看到的是芝麻，大智慧看到的是西瓜。
　　在这个世界上，既有大人物，也有小角色，大人物有大人物的活法，小人物有小人物的潇洒，每个人都有自己的生活方式，谁也勉强不了谁。但是，小聪明只能有小成绩和小视野，大智慧才能有大成就和大境界。小企业看老板，中企业看制度，大企业看文化。
    小公司与大企业都有生存之道，没有好坏之分，但对一个人不同阶段的影响会不同。
　　小公司肯定想要发展为大企业，这是一种目标，年轻人也要给自己的职业生涯制定目标。毕业几年的你，是否经常会怯场或者是感到没有底气？居安思危绝对不是危言耸听！此刻打盹，你将做梦；此刻学习，你将圆梦。在竞争激烈的人生战场上，打盹的都是输家！
   每个人在年轻的时候似乎都豪情万丈，什么都不怕，可是随着年龄的增长，每天想着房子、工作、养家糊口这些俗事儿，再也没有年轻时那种敢于"上天探星、下海捞月"的勇气了。是我们改变了生活，还是生活改变了我们？我们的思想越来越复杂，因为有了越来越多的舍不得、越来越多的顾虑，我们总是在徘徊、总是在犹豫。毕业开始一两年，生活的重担会压得我们喘不过气来，挫折和障碍堵住四面八方的通口，我们往往在压迫得自己发挥出潜能后，才能杀出重围，找到出路。可是两三年后，身上的重担开始减轻，工作开始一帆风顺，我们就松懈了下来，渐渐忘记了潜在的危险。直到有一天危机突然降临，我们在手足无措中被击败……毕业这几年，仍然处于危险期，一定要有居安思危的意识，好好打拼，这样才能有一个真正的安全人生！
    生于忧患，死于安乐。如果你想跨越自己目前的成就，就不能画地自限，而是要勇于接受挑战。对畏畏缩缩的人来说，真正的危险正在于不敢冒险！
    年轻人在社会的重压下，适应能力已变得越来越强，只是他们不自觉地习惯被环境推着走。他们不敢冒险，怕给自己带来终身的遗憾，于是告慰自己："我对得起自己、对得起家人，因为我已竭尽全力。"其实，人只有不断挑战和突破才能逐渐成长。长期固守于已有的安全感中，就会像温水里的青蛙一样，最终失去跳跃的本能。
    经历了这几年社会生活，你应该明白：这个世界上有富也有贫，有阴也有亮，有丑也有美，到底看到什么，取决于自己是积极还是消极。在年轻时学会勤勉地工作，用一种光明的思维对待生活，那么，只要张开手掌，你就会发现，里面有一片灿烂的人生。
    把感恩刻在石头上，深深地感谢别人帮助过你，永远铭记，这是人生应有的一种境界；把仇恨写在沙滩上，淡淡忘掉别人伤害过你，学会宽容，让所有的怨恨随着潮水一去不复返，这也是一种人生境界。
    学会倒出水，才能装下更多的水。从毕业那天开始，学会把每天都当成一个新的起点，每一次工作都从零开始。如果你懂得把"归零"当成一种生活的常态，当成一种优秀的延续，当成一种时刻要做的事情，那么，经过短短几年，你就可以完成自己职业生涯的正确规划与全面超越。
　　在职业起步的短短道路上，想要得到更好、更快、更有益的成长，就必须以归零思维来面对这个世界。不要以大学里的清高来标榜自己，不要觉得自己特别优秀，而是要把自己的姿态放下，把自己的身架放低，让自己沉淀下来，抱着学习的态度去适应环境、接受挑战。放下"身段"才能提高身价，暂时的俯低终会促成未来的高就。
　　年轻人从校园或者从一个环境进入一个新环境，就要勇于将原来环境里熟悉、习惯、喜欢的东西放下，然后从零开始。我们想在职场上获得成功，首先就要培养适应力。从自然人转化为单位人是融入职场的基本条件。一个人起点低并不可怕，怕的是境界低。越计较自我，便越没有发展前景；相反，越是主动付出，那么他就越会快速发展。很多今天取得一定成就的人，在职业生涯的初期都是从零开始，把自己沉淀再沉淀、倒空再倒空、归零再归零，正因为这样，他们的人生才一路高歌，一路飞扬。
　　在毕业这几年里，我们要让过去归零，才不会成为职场上那只背着重壳爬行的蜗牛，才能像天空中的鸟儿那样轻盈地飞翔。请好好品味一下杰克·韦尔奇说过的一句话："纠正自己的行为，认清自己，从零开始，你将重新走上职场坦途。"　吐故才能纳新，心静才能身凉，有舍才能有得，杯空才能水满，放下才能超越。
    归零思维五大表现：心中无我，眼中无钱，念中无他，朝中无人，学无止境。
    年轻人难免带着几分傲气，认为自己无所不能、所向披靡，其实不然，初入职场的新人还是个"婴儿"，正处在从爬到走的成长阶段。在毕业这几年里，一定要让自己逐步培养起学徒思维、海绵思维、空杯思维，具有这样思维的人心灵总是敞开的，能随时接受启示和一切能激发灵感的东西，他们时刻都能感受到成功女神的召唤。

测试代码的坏味

Refactoring Test Code. xp2001,Arie van Deursen.. 

    1.神秘的客人

    2.资源乐观主义

    3.测试运行战争

    4.过于通用的运行必备

    5.过于热心的测试

    6.懒惰测试

    7.赌轮盘似的断言

    8.间接测试

    9.只为测试人员

    10.过于敏感的相等

    11.测试代码重复

如果这篇文章没有分享给你，那是我的错。
如果这篇文章分享给你了，你却没有读，继续走弯路的你不要怪我。
如果你看了这篇文章，只读了一半你就说没时间了，说明你已经是个“茫”人了。
如果你看完了，你觉得这篇文章只是讲讲大道理，说明你的人生阅历还不够，需要你把这篇文章珍藏，走出去碰几年壁，头破血流后再回来，再读，你就会感叹自己的年少无知。
如果你看完了，觉得很有道理，然后束之高阁，继续走进拥挤的地铁，依然用着自己昨日的观念来思考自己的未来，你的人生也将继续重复着昨日的状况。
如果你看完了，觉得那是一个过来人，对你的人生忠告，并你也愿意用他告诉你的思想去指导自己今后的生活，对你来讲成功不是很难，难的是你是否可以用这篇文章里的思想一直鞭策自己。
如果你看完了，觉得那是一个长辈用他的一生的时间来写的一篇对你忠告的文章，说明你已经有了和他相似的人生阅历，只要你继续努力，成就伟业并不难，难的是你是否可以把自己的人生经验和他人分享呢？
      体验决定深度，知识决定广度。你的人生是什么呢？

一、关于工作与生活

　　 我有个有趣的观察，外企公司多的是25-35岁的白领，40岁以上的员工很少，二三十岁的外企员工是意气风发的，但外企公司40岁附近的经理人是很尴尬的。我见过的40岁附近的外企经理人大多在一直跳槽，最后大多跳到民企，比方说，唐骏。外企员工的成功很大程度上是公司的成功，并非个人的成功，西门子的确比国美大，但并不代表西门子中国经理比国美的老板强，甚至可以说差得很远。而进外企的人往往并不能很早理解这一点，把自己的成功90％归功于自己的能力，实际上，外企公司随便换个中国区总经理并不会给业绩带来什么了不起的影响。好了问题来了，当这些经理人40多岁了，他们的薪资要求变得很高，而他们的才能其实又不是那么出众，作为外企公司的老板，你会怎么选择？有的是只要不高薪水的，要出位的精明强干精力充沛的年轻人，有的是，为什么还要用你？

　　 从上面这个例子，其实可以看到我们的工作轨迹，二三十岁的时候，生活的压力还比较小，身体还比较好，上面的父母身体还好，下面又没有孩子，不用还房贷，也没有孩子要上大学，当个外企小白领还是很光鲜的，挣得不多也够花了。但是人终归要结婚生子，终归会老，到了40岁，父母老了，要看病要吃药，要有人看护，自己要还房贷，要过基本体面的生活，要养小孩……那个时候需要挣多少钱才够花才重要。所以，看待工作，眼光要放远一点，一时的谁高谁低并不能说明什么。

　　 从这个角度上来说，我不太赞成过于关注第一份工作的薪水，更没有必要攀比第一份工作的薪水，这在刚刚出校园的学生中间是很常见的。正常人大概要工作
35年，这好比是一场马拉松比赛，和真正的马拉松比赛不同的是，这次比赛没有职业选手，每个人都只有一次机会。要知到，有很多人甚至坚持不到终点，大多数人最后是走到终点的，只有少数人是跑过终点的，因此在刚开始的时候，去抢领先的位置并没有太大的意义。刚进社会的时候如果进500强公司，大概能拿到3k
-6k/月的工资，有些特别技术的人才可能可以到8k/月，可问题是，5年以后拿多少？估计5k-10k了不起了。起点虽然高，但增幅有限，而且，后面的年轻人追赶的压力越来越大。

　　 我前两天问我的一个销售，你会的这些东西一个新人2年就都学会了，但新人所要求的薪水却只是你的一半，到时候，你怎么办？
　　职业生涯就像一场体育比赛，有初赛、复赛、决赛。初赛的时候大家都刚刚进社会，大多数都是实力一般的人，这时候努力一点认真一点很快就能让人脱颖而出，于是有的人二十多岁做了经理，有的人迟些也终于赢得了初赛，三十多岁成了经理。然后是复赛，能参加复赛的都是赢得初赛的，每个人都有些能耐，在聪明才智上都不成问题，这个时候再想要胜出就不那么容易了，单靠一点点努力和认真还不够，要有很强的坚忍精神，要懂得靠团队的力量，要懂得收服人心，要有长远的眼光……

　　 看上去赢得复赛并不容易，但，还不是那么难。因为这个世界的规律就是给人一点成功的同时让人骄傲自满，刚刚赢得初赛的人往往不知道自己赢得的仅仅是初赛，有了一点小小的成绩大多数人都会骄傲自满起来，认为自己已经懂得了全部，不需要再努力再学习了，他们会认为之所以不能再进一步已经不是自己的原因了。虽然他们仍然不好对付，但是他们没有耐性，没有容人的度量，更没有清晰长远的目光。就像一只愤怒的斗牛，虽然猛烈，最终是会败的，而赢得复赛的人则象斗牛士一样，不急不躁，跟随着自己的节拍，慢慢耗尽对手的耐心和体力。赢得了复赛以后，大约已经是一位很了不起的职业经理人了，当上了中小公司的总经理，大公司的副总经理，主管着每年几千万乃至几亿的生意。

　　最终的决赛来了，说实话我自己都还没有赢得决赛，因此对于决赛的决胜因素也只能凭自己的猜测而已，这个时候的输赢或许就像武侠小说里写得那样，大家都是高手，只能等待对方犯错了，要想轻易击败对手是不可能的，除了使上浑身解数，还需要一点运气和时间。世界的规律依然发挥着作用，赢得复赛的人已经不只是骄傲自满了，他们往往刚愎自用，听不进去别人的话，有些人的脾气变得暴躁，心情变得浮躁，身体变得糟糕，他们最大的敌人就是他们自己，在决赛中要做的只是不被自己击败，等着别人被自己击败。这和体育比赛是一样的，最后高手之间的比赛，就看谁失误少谁就赢得了决赛。

　　 二、 根源

　　 你工作快乐么？你的工作好么？

　　 有没有觉得干了一段时间以后工作很不开心？有没有觉得自己入错了行？有没有觉得自己没有得到应有的待遇？有没有觉得工作像一团乱麻每天上班都是一种痛苦？有没有很想换个工作？有没有觉得其实现在的公司并没有当初想象得那么好？有没有觉得这份工作是当初因为生存压力而找的，实在不适合自己？你从工作中得到你想要得到的了么？你每天开心么？

　　 天涯上愤怒的人很多，你有没有想过，你为什么不快乐？你为什么愤怒？

　　 其实，你不快乐的根源，是因为你不知道要什么！你不知道要什么，所以你不知道去追求什么，你不知道追求什么，所以你什么也得不到。

　　 我总觉得，职业生涯首先要关注的是自己，自己想要什么？大多数人大概没想过这个问题，唯一的想法只是——我想要一份工作，我想要一份不错的薪水，我知道所有人对于薪水的渴望，可是，你想每隔几年重来一次找工作的过程么？你想每年都在这种对于工作和薪水的焦急不安中度过么？不想的话，就好好想清楚。饮鸩止渴，不能因为口渴就拼命喝毒药。越是焦急，越是觉得自己需要一份工作，越饥不择食，越想不清楚，越容易失败，你的经历越来越差，下一份工作的人看着你的简历就皱眉头。于是你越喝越渴，越渴越喝，陷入恶性循环。最终只能哀叹世事不公或者生不逢时，只能到天涯上来发泄一把，在失败者的共鸣当中寻求一点心理平衡罢了。大多数人都有生存压力，我也是，有生存压力就会有很多焦虑，积极的人会从焦虑中得到动力，而消极的人则会因为焦虑而迷失方向。所有人都必须在压力下做出选择，这就是世道，你喜欢也罢不喜欢也罢。

　　一般我们处理的事情分为重要的事情和紧急的事情，如果不做重要的事情就会常常去做紧急的事情。比如锻炼身体保持健康是重要的事情，而看病则是紧急的事情。如果不锻炼身体保持健康，就会常常为了病痛烦恼。又比如防火是重要的事情，而救火是紧急的事情，如果不注意防火，就要常常救火。找工作也是如此，想好自己究竟要什么是重要的事情，找工作是紧急的事情，如果不想好，就会常常要找工作。往往紧急的事情给人的压力比较大，迫使人们去赶紧做，相对来说重要的事情反而没有那么大的压力，大多数人做事情都是以压力为导向的，压力之下，总觉得非要先做紧急的
事情，结果就是永远到处救火，永远没有停歇的时候。（很多人的工作也像是救火队一样忙碌痛苦，也是因为工作中没有做好重要的事情。）那些说自己活在水深火热为了生存顾不上那么多的朋友，今天找工作困难是当初你们没有做重要的事情，是结果不是原因。如果今天你们还是因为急于要找一份工作而不去思考，那么或许将来要继续承受痛苦找工作的结果。

　　 我始终觉得我要说的话题，沉重了点，需要很多思考，远比唐笑打武警的话题来的枯燥乏味，但是，天下没有轻松的成功，成功，要付代价。请先忘记一切的生存压力，想想这辈子你最想要的是什么？所以，最要紧的事情，先想好自己想要什么。

　　 三、什么是好工作

　　 当初微软有个唐骏，很多大学里的年轻人觉得这才是他们向往的职业生涯，我在清华bbs里发的帖子被这些学子们所不屑，那个时候学生们只想出国或者去外企，不过如今看来，我还是对的，唐骏去了盛大，陈天桥创立的盛大，一家民营公司。一个高学历的海归在500强的公司里拿高薪水，这大约是很多年轻人的梦想，问题是，每年毕业的大学生都在做这个梦，好的职位却只有500个。

　　 人都是要面子的，也是喜欢攀比的，即使在工作上也喜欢攀比，不管那是不是自己想要的。大家认为外企公司很好，可是好在哪里呢？好吧，他们在比较好的写字楼，这是你想要的么？他们出差住比较好的酒店，这是你想要的么？别人会羡慕一份外企公司的工作，这是你想要的么？那一切都是给别人看的，你干吗要活得那么辛苦给别人看？另一方面，他们薪水福利一般，并没有特别了不起，他们的晋升机会比较少，很难做到很高阶的主管，他们虽然厌恶常常加班，却不敢不加班，因为“你不干有得是人干”，大部分情况下会找个台湾人香港人新加坡人来管你，而这些人又往往有些莫名其妙的优越感。你想清楚了么？500强一定好么？找工作究竟是考虑你想要什么，还是考虑别人想看什么？

　　 我的大学同学们大多数都到美国了，甚至毕业这么多年了，还有人最近到国外去了。出国真的有那么好么？我的大学同学们，大多数还是在博士、博士后、访问学者地挣扎着，至今只有一个正经在一个美国大学里拿到个正式的教职。国内的教授很难当么？我有几个表亲也去了国外了，他们的父母独自在国内，没有人照顾，有好几次人在家里昏倒都没人知道，出国，真的这么光彩么？就像有人说的“很多事情就像看A片，看的人觉得很爽，做的人未必。”

　　 人总想找到那个最好的，可是，什么是最好的？你觉得是最好的那个，是因为你的确了解，还是因为别人说他是最好的？即使他对于别人是最好的，对于你也一定是最好的么？

　　 对于自己想要什么，自己要最清楚，别人的意见并不是那么重要。很多人总是常常被别人的意见所影响，亲戚的意见，朋友的意见，同事的意见……问题是，你究竟是要过谁的一生？人的一生不是父母一生的续集，也不是儿女一生的前传，更不是朋友一生的外篇，只有你自己对自己的一生负责，别人无法也负不起这个责任。自己做的决定，至少到最后，自己没什么可后悔。对于大多数正常智力的人来说，所做的决定没有大的对错，无论怎么样的选择，都是可以尝试的。比如你没有考自己上的那个学校，没有入现在这个行业，这辈子就过不下去了？就会很失败？不见得。

　　我想，好工作，应该是适合你的工作，具体点说，应该是能给你带来你想要的东西的工作，你或许应该以此来衡量你的工作究竟好不好，而不是拿公司的大小，规模，外企还是国企，是不是有名，是不是上市公司来衡量。小公司，未必不是好公司，赚钱多的工作，也未必是好工作。你还是要先弄清楚你想要什么，如果你不清楚你想要什么，你就永远也不会找到好工作，因为你永远只看到你得不到的东西，你得到的，都是你不想要的。
　　可能，最好的，已经在你的身边，只是，你还没有学会珍惜。人们总是盯着得不到的东西，而忽视了那些已经得到的东西。

　　四、普通人

　　我发现中国人的励志和国外的励志存在非常大的不同，中国的励志比较鼓励人立下大志愿，卧薪尝胆，有朝一日成富成贵。而国外的励志比较鼓励人勇敢面对现实生活，面对普通人的困境，虽然结果也是成富成贵，但起点不一样，相对来说，我觉得后者在操作上更现实，而前者则需要用999个失败者来堆砌一个成功者的故事。

　　 我们都是普通人，普通人的意思就是，概率这件事是很准的。因此，我们不会买彩票中500万，我们不会成为比尔盖茨或者李嘉诚，我们不会坐飞机掉下来，我们当中很少的人会创业成功，我们之中有30％的人会离婚，我们之中大部分人会活过65岁……

　　 所以请你在想自己要什么的时候，要得“现实”一点，你说我想要做李嘉诚，抱歉，我帮不上你。成为比尔盖茨或者李嘉诚这种人，是靠命的，看我写的这篇文章绝对不会让你成为他们，即使你成为了他们，也绝对不是我这篇文章的功劳。“王侯将相宁有种乎”但真正当皇帝的只有一个人，王侯将相，人也不多。目标定得高些对于喜欢挑战的人来说有好处，但对于大多数普通人来说，反而比较容易灰心沮丧，很容易就放弃了。

　　 回过头来说，李嘉诚比你有钱大致50万倍，他比你更快乐么？或许。有没有比你快乐50万倍，一定没有。他比你最多也就快乐一两倍，甚至有可能还不如你快乐。寻找自己想要的东西不是和别人比赛，比谁要得更多更高，比谁的目标更远大。虽然成为李嘉诚这个目标很宏大，但你并不见得会从这个目标以及追求目标的过程当中获得快乐，而且基本上你也做不到。你必须听听你内心的声音，寻找真正能够使你获得快乐的东西，那才是你想要的东西。
　　你想要的东西，或者我们把它称之为目标，目标其实并没有高低之分，你不需要因为自己的目标没有别人远大而不好意思，达到自己的目标其实就是成功，成功有大有小，快乐却是一样的。我们追逐成功，其实追逐的是成功带来的快乐，而非成功本身。职业生涯的道路上，我们常常会被攀比的心态蒙住眼睛，忘记了追求的究竟是什么，忘记了是什么能使我们更快乐。

   社会上一夜暴富的新闻很多，这些消息，总会在我们的心里面掀起很多涟漪，涟漪多了就变成惊涛骇浪，心里的惊涛骇浪除了打翻承载你目标的小船，并不会使得你也一夜暴富。“只见贼吃肉，不见贼挨揍。”我们这些普通人既没有当贼的勇气，又缺乏当贼的狠辣绝决，虽然羡慕吃肉，却更害怕挨揍，偶尔看到几个没挨揍的贼就按奈不住，或者心思活动，或者大感不公，真要叫去做贼，却也不敢。

      我还是过普通人的日子，要普通人的快乐，至少，晚上睡得着觉。

       五、跳槽与积累

      首先要说明，工作是一件需要理智的事情，所以不要在工作上耍个性，天涯上或许会有人觉得你很有个性而叫好，煤气公司电话公司不会因为觉得你很有个性而免了你的帐单。当你很帅地炒掉了你的老板，当你很酷地挖苦了一番招聘的HR，账单还是要照付，只是你赚钱的时间更少了，除了你自己，没人受损失。

       我并不反对跳槽，但跳槽决不是解决问题的办法，而且频繁跳槽的后果是让人觉得没有忠诚度可言，而且不能安心工作。现在很多人从网上找工作，很多找工作的网站常常给人出些馊主意，要知道他们是盈利性企业，当然要从自身盈利的角度来考虑，大家越是频繁跳槽频繁找工作他们越是生意兴隆，所以鼓动人们跳槽是他们的工作。所以他们会常常告诉你，你拿的薪水少了，你享受的福利待遇差了，又是“薪情快报”又是“赞叹自由奔放的灵魂”。至于是否会因此让你不能安心，你跳了槽是否解决问题，是否更加开心，那个，他们管不着。

       要跳槽肯定是有问题，一般来说问题发生了，躲是躲不开的，很多人跳槽是因为这样或者那样的不开心，如果这种不开心，在现在这个公司不能解决，那么在下一个公司多半也解决不掉。你必须相信，90%的情况下，你所在的公司并没有那么烂，你认为不错的公司也没有那么好。就像围城里说的，“城里的人拼命想冲出来，而城外的人拼命想冲进去。”每个公司都有每个公司的问题，没有问题的公司是不存在的。换个环境你都不知道会碰到什么问题，与其如此，不如就在当下把问题解决掉。很多问题当你真的想要去解决的时候，或许并没有那么难。有的时候你觉得问题无法解决，事实上，那只是“你觉得”。

      人生的曲线应该是曲折向上的，偶尔会遇到低谷但大趋势总归是曲折向上的，而不是象脉冲波一样每每回到起点，我见过不少面试者，30多岁了，四五份工作经历，每次多则3年，少则1年，30多岁的时候回到起点从一个初级职位开始干起，拿基本初级的薪水，和20多岁的年轻人一起竞争，不觉得有点辛苦么？这种日子好过么？

       资本靠的就是积累，这种积累包括人际关系，经验，人脉，口碑……如果常常更换行业，代表几年的积累付之东流，一切从头开始，如果换了两次行业，35岁的时候大概只有5年以下的积累，而一个没有换过行业的人至少有了10年的积累，谁会占优势？工作到2-3年的时候，很多人觉得工作不顺利，好像到了一个瓶颈，心情烦闷，就想辞职，乃至换一个行业，觉得这样所有一切烦恼都可以抛开，会好很多。其实这样做只是让你从头开始，到了时候还是会发生和原来行业一样的困难，熬过去就向上跨了一大步，要知道每个人都会经历这个过程，每个人的职业生涯中都会碰到几个瓶颈，你熬过去了而别人没有熬过去你就领先了。跑长跑的人会知道，开始的时候很轻松，但是很快会有第一次的难受，但过了这一段又能跑很长一段，接下来会碰到第二次的难受，坚持过了以后又能跑一段，如此往复，难受一次比一次厉害，直到坚持不下去了。大多数人第一次就坚持不了了，一些人能坚持到第二次，第三次虽然大家都坚持不住了，可是跑到这里的人也没几个了，这点资本足够你安稳活这一辈子了。

        一份工作到两三年的时候，大部分人都会变成熟手，这个时候往往会陷入不断的重复，有很多人会觉得厌倦，有些人会觉得自己已经搞懂了一切，从而懒得去寻求进步了。很多时候的跳槽是因为觉得失去兴趣了，觉得自己已经完成比赛了。其实这个时候比赛才刚刚开始，工作两三年的人，无论是客户关系，人脉，手下，和领导的关系，在业内的名气……还都是远远不够的，但稍有成绩的人总是会自我感觉良好的，每个人都觉得自己跟客户关系铁得要命，觉得自己在业界的口碑好得很。其实可以肯定地说，一定不是，这个时候，还是要拿出前两年的干劲来，稳扎稳打，积累才刚刚开始。

        你足够了解你的客户吗？你知道他最大的烦恼是什么吗？你足够了解你的老板么？你知道他最大的烦恼是什么吗？你足够了解你的手下么？你知道他最大的烦恼是什么吗？如果你不知道，你凭什么觉得自己已经积累够了？如果你都不了解，你怎么能让他们帮你的忙，做你想让他们做的事情？如果他们不做你想让他们做的事情，你又何来的成功？

     六、等待

       这是个浮躁的人们最不喜欢的话题，本来不想说这个话题，因为会引起太多的争论，而我又无意和人争论这些，但是考虑到对于职业生涯的长久规划，这是一个躲避不了的话题，还是决定写一写，不爱看的请离开吧。

       并不是每次穿红灯都会被汽车撞，并不是每个罪犯都会被抓到，并不是每个错误都会被惩罚，并不是每个贪官都会被枪毙，并不是你的每一份努力都会得到回报，并不是你的每一次坚持都会有人看到，并不是你每一点付出都能得到公正的回报，并不是你的每一个善意都能被理解……这个，就是世道。好吧，世道不够好，可是，你有推翻世道的勇气么？如果没有，你有更好的解决办法么？有很多时候，人需要一点耐心，一点信心。每个人总会轮到几次不公平的事情，而通常，安心等待是最好的办法。

有很多时候我们需要等待，需要耐得住寂寞，等待属于你的那一刻。周润发等待过，刘德华等待过，周星驰等待过，王菲等待过，张艺谋也等待过……看到了他们如今的功成名就的人，你可曾看到当初他们的等待和耐心？你可曾看到金马奖影帝在街边摆地摊？你可曾看到德云社一群人在剧场里给一位观众说相声？你可曾看到周星驰的角色甚至连一句台词都没有？每一个成功者都有一段低沉苦闷的日子，我几乎能想象得出来他们借酒浇愁的样子，我也能想象得出他们为了生存而挣扎的窘迫。在他们一生最中灿烂美好的日子里，他们渴望成功，但却两手空空，一如现在的你。没有人保证他们将来一定会成功，而他们的选择是耐住寂寞。如果当时的他们总念叨着“成功只是属于特权阶级的”，你觉得他们今天会怎样？

        曾经我也不明白有些人为什么并不比我有能力却要坐在我的头上，年纪比我大就一定要当我的领导么？为什么有些烂人不需要努力就能赚钱？为什么刚刚改革开放的时候的人能那么容易赚钱，而轮到我们的时候，什么事情都要正规化了？有一天我突然想，我还在上学的时候他们就在社会里挣扎奋斗了，他们在社会上奋斗积累了十几二十年，我们新人来了，他们有的我都想要，我这不是在要公平，我这是在要抢劫。因为我要得太急，因为我忍不住寂寞。二十多岁的男人，没有钱，没有事业，却有蓬勃的欲望。

         人总是会遇到挫折的，人总是会有低潮的，人总是会有不被人理解的时候的，人总是有要低声下气的时候，这些时候恰恰是人生最关键的时候，因为大家都会碰到挫折，而大多数人过不了这个门槛，你能过，你就成功了。在这样的时刻，我们需要耐心等待，满怀信心地去等待，相信，生活不会放弃你，机会总会来的。至少，你还年轻，你没有坐牢，没有生治不了的病，没有欠还不起的债。比你不幸的人远远多过比你幸运的人，你还怕什么？路要一步步走，虽然到达终点的那一步很激动人心，但大部分的脚步是平凡甚至枯燥的，但没有这些脚步，或者耐不住这些平凡枯燥，你终归是无法迎来最后的那些激动人心。

       逆境，是上帝帮你淘汰竞争者的地方。要知道，你不好受，别人也不好受，你坚持不下去了，别人也一样，千万不要告诉别人你坚持不住了，那只能让别人获得坚持的信心，让竞争者看着你微笑的面孔，失去信心，退出比赛。胜利属于那些有耐心的人。

         在最绝望的时候，我会去看电影《The Pursuit of Happyness》《Jerry Maguire》，让自己重新鼓起勇气，因为，无论什么时候，我们总还是有希望。当所有的人离开的时候，我不失去希望，我不放弃。每天下班坐在车里，我喜欢哼着《隐形的翅膀》看着窗外，我知道，我在静静等待，等待属于我的那一刻。

   七、入对行跟对人

       在中国，大概很少有人是一份职业做到底的，虽然如此，第一份工作还是有些需要注意的地方，有两件事情格外重要，第一件是入行，第二件事情是跟人。第一份工作对人最大的影响就是入行，现代的职业分工已经很细，我们基本上只能在一个行业里成为专家，不可能在多个行业里成为专家。很多案例也证明即使一个人在一个行业非常成功，到另外一个行业，往往完全不是那么回事情，“你想改变世界，还是想卖一辈子汽水？”是乔布斯邀请百事可乐总裁约翰•斯考利加盟苹果时所说的话，结果这位在百事非常成功的约翰，到了苹果表现平平。其实没有哪个行业特别好，也没有哪个行业特别差，或许有报道说哪个行业的平均薪资比较高，但是他们没说的是，那个行业的平均压力也比较大。看上去很美的行业一旦进入才发现很多地方其实并不那么完美，只是外人看不见。

        说实话，我自己都没有发大财，所以我的建议只是让人快乐工作的建议，不是如何发大财的建议，我们只讨论一般普通打工者的情况。我认为选择什么行业并没有太大关系，看问题不能只看眼前。比如，从前年开始，国家开始整顿医疗行业，很多医药公司开不下去，很多医药行业的销售开始转行。其实医药行业的不景气是针对所有公司的，并非针对一家公司，大家的日子都不好过，这个时候跑掉是非常不划算的，大多数正规的医药公司即使不做新生意撑个两三年总是能撑的，大多数医药销售靠工资撑个两三年也是可以撑的，国家不可能永远捏着医药行业不放的，两三年以后光景总归还会好起来的，那个时候别人都跑了而你没跑，那时的日子应该会好过很多。有的时候觉得自己这个行业不行了，问题是，再不行的行业，做得人少了也变成了好行业，当大家都觉得不好的时候，往往却是最好的时候。大家都觉得金融行业好，金融行业门槛高不说，有多少人削尖脑袋要钻进去，竞争激励，进去以后还要时时提防，一个疏忽，就被后来的人给挤掉了，压力巨大，又如何谈得上快乐？也就未必是“好”工作了。

         太阳能这个东西至今还不能进入实际应用的阶段，但是中国已经有7家和太阳能有关的公司在纽交所上市了，国美苏宁永乐其实是贸易型企业，也能上市，鲁泰纺织连续10年利润增长超过50%，卖茶的一茶一座，卖衣服的海澜之家都能上市……其实选什么行业真的不重要，关键是怎么做。事情都是人做出来的，关键是人。

         有一点是需要记住的，这个世界上，有史以来直到我们能够预见得到的未来，成功的人总是少数，有钱的人总是少数，大多数人是一般的，普通的，不太成功的。因此，大多数人的做法和看法，往往都不是距离成功最近的做法和看法。因此大多数人说好的东西不见得好，大多数人说不好的东西不见得不好。大多数人都去炒股的时候说明跌只是时间问题，大家越是热情高涨的时候，跌的日子越近。大多数人买房子的时候，房价不会涨，而房价涨的差不多的时候，大多数人才开始买房子。不会有这样一件事情让大家都变成功，发了财，历史上不曾有过，将来也不会发生。有些东西即使一时运气好得到了，还是会在别的时候别的地方失去的。

         年轻人在职业生涯的刚开始，尤其要注意的是，要做对的事情，不要让自己今后几十年的人生总是提心吊胆，更不值得为了一份工作赔上自己的青春年华。我的公司是个不行贿的公司，以前很多人不理解，甚至自己的员工也不理解，不过如今，我们是同行中最大的企业，客户乐意和我们打交道，尤其是在国家打击腐败的时候，每个人都知道我们做生意不给钱的名声，都敢于和我们做生意。而勇于给钱的公司，不是倒了，就是跑了，要不就是每天睡不好觉，人还是要看长远一点。很多时候，看起来最近的路，其实是最远的路，看起来最远的路，其实是最近的路。

        跟对人是说，入行后要跟个好领导好老师，刚进社会的人做事情往往没有经验，需要有人言传身教。对于一个人的发展来说，一个好领导是非常重要的。所谓“好”的标准，不是他让你少干活多拿钱，而是以下三个。

        首先，好领导要有宽广的心胸，如果一个领导每天都会发脾气，那几乎可以肯定他不是个心胸宽广的人，能发脾气的时候却不发脾气的领导，多半是非常厉害的领导。中国人当领导最大的毛病是容忍不了能力比自己强的人，所以常常可以看到的一个现象是，领导很有能力，手下一群庸才或者手下一群闲人。如果看到这样的环境，还是不要去的好。

        其次，领导要愿意从下属的角度来思考问题，这一点其实是从面试的时候就能发现的，如果这位领导总是从自己的角度来考虑问题，几乎不听你说什么，这就危险了。从下属的角度来考虑问题并不代表同意下属的说法，但他必须了解下属的立场，下属为什么要这么想，然后他才有办法说服你，只关心自己怎么想的领导往往难以获得下属的信服。

        第三，领导敢于承担责任，如果出了问题就把责任往下推，有了功劳就往自己身上揽，这样的领导不跟也罢。选择领导，要选择关键时刻能抗得住的领导，能够为下属的错误买单的领导，因为这是他作为领导的责任。

         有可能，你碰不到好领导，因为，中国的领导往往是屁股决定脑袋的领导，因为他坐领导的位置，所以他的话就比较有道理，这是传统观念官本位的误区，可能有大量的这种无知无能的领导，只是，这对于你其实是好事，如果将来有一天你要超过他，你希望他比较聪明还是比较笨？相对来说这样的领导其实不难搞定，只是你要把自己的身段放下来而已。多认识一些人，多和比自己强的人打交道，同样能找到好的老师，不要和一群同样郁闷的人一起控诉社会，控诉老板，这帮不上你，只会让你更消极。和那些比你强的人打交道，看他们是怎么想的，怎么做的，学习他们，然后跟更强的人打交道。

    八、选择

        我们每天做的最多的事情，其实是选择，因此在谈职业生涯的时候不得不提到这个话题。

        我始终认为，在很大的范围内，我们究竟会成为一个什么样的人，决定权在我们自己，每天我们都在做各种各样的选择，我可以不去写这篇文章，去别人的帖子拍拍砖头，也可以写下这些文字，帮助别人的同时也整理自己的思路，我可以多注意下格式让别人易于阅读，也可以写成一堆，我可以就这样发上来，也可以在发以前再看几遍，你可以选择不刮胡子就去面试，也可以选择出门前照照镜子……每天，每一刻我们都在做这样那样的决定，我们可以漫不经心，也可以多花些心思，成千上万的小选择累计起来，就决定了最终我们是个什么样的人。

         从某种意义上来说我们的未来不是别人给的，是我们自己选择的，很多人会说我命苦啊，没得选择阿，如果你认为“去微软还是去IBM”“上清华还是上北大”“当销售副总还是当厂长”这种才叫选择的话，的确你没有什么选择，大多数人都没有什么选择。但每天你都可以选择是否为客户服务更周到一些，是否对同事更耐心一些，是否把工作做得更细致一些，是否把情况了解得更清楚一些，是否把不清楚的问题再弄清楚一些……你也可以选择在是否在痛苦中继续坚持，是否抛弃掉自己的那些负面的想法，是否原谅一个人的错误，是否相信我在这里写下的这些话，是否不要再犯同样的错误……生活每天都在给你选择的机会，每天都在给你改变自己人生的机会，你可以选择赖在地上撒泼打滚，也可以选择咬牙站起来。你永远都有选择。有些选择不是立杆见影的，需要累积，比如农民可以选择自己常常去浇地，也可以选择让老天去浇地，诚然你今天浇水下去苗不见得今天马上就长出来，但常常浇水，大部分苗终究会长出来的，如果你不浇，收成一定很糟糕。

         每天生活都在给你机会，他不会给你一叠现金也不会拱手送你个好工作，但实际上，他还是在给你机会。我的家庭是一个普通的家庭，没有任何了不起的社会关系，我的父亲在大学毕业以后就被分配到了边疆，那个小县城只有一条马路，他们那一代人其实比我们更有理由抱怨，他们什么也没得到，年轻的时候文化大革命，书都没得读，支援边疆插队落户，等到老了，却要给年轻人机会了。他有足够的理由象成千上万那样的青年一样坐在那里抱怨生不逢时，怨气冲天。然而在分配到边疆的十年之后，国家恢复招研究生，他考回了原来的学校。研究生毕业，他被分配到了安徽一家小单位里，又是3年以后，国家第一届招收博士生，他又考回了原来的学校，成为中国第一代博士，那时的他比现在的我年纪还大。生活并没有放弃他，他也没有放弃生活。10年的等待，他做了他自己的选择，他没有放弃，他没有破罐子破摔，所以时机到来的时候，他改变了自己的人生。你最终会成为什么样的人，就决定在你的每个小小的选择之间。

         你选择相信什么？你选择和谁交朋友？你选择做什么？你选择怎么做？……我们面临太多的选择，而这些选择当中，意识形态层面的选择又远比客观条件的选择来得重要得多，比如选择做什么产品其实并不那么重要，而选择怎么做才重要。选择用什么人并不重要，而选择怎么带这些人才重要。大多数时候选择客观条件并不要紧，大多数关于客观条件的选择并没有对错之分，要紧的是选择怎么做。一个大学生毕业了，他要去微软也好，他要卖猪肉也好，他要创业也好，他要做游戏代练也好，只要不犯法，不害人，都没有什么关系，要紧的是，选择了以后，怎么把事情做好。

         除了这些，你还可以选择时间和环境，比如，你可以选择把这辈子最大的困难放在最有体力最有精力的时候，也可以走一步看一步，等到了40岁再说，只是到了40多岁，那正是一辈子最脆弱的时候，上有老下有小，如果在那个时候碰上了职业危机，实在是一件很苦恼的事情。与其如此不如在20多岁30多岁的时候吃点苦，好让自己脆弱的时候活得从容一些。你可以选择在温室里成长，也可以选择到野外磨砺，你可以选择在办公室吹冷气的工作，也可以选择40度的酷热下，去见你的客户，只是，这一切最终会累积起来，引导你到你应得的未来。

        我不敢说所有的事情你都有得选择，但是绝大部分事情你有选择，只是往往你不把这当作一种选择。认真对待每一次选择，才会有比较好的未来。

     九、选择职业

        职业的选择，总的来说，无非就是销售、市场、客服、物流、行政、人事、财务、技术、管理几个大类，有个有趣的现象就是，500强的CEO当中最多的是销售出身，第二多的人是财务出身，这两者加起来大概超过95%。现代IT行业也有技术出身成为老板的，但实际上，后来他们还是从事了很多销售和市场的工作，并且表现出色，公司才获得了成功，完全靠技术能力成为公司老板的，几乎没有。这是有原因的，因为销售就是一门跟人打交道的学问，而管理其实也是跟人打交道的学问，这两者之中有很多相通的东西，他们的共同目标就是“让别人去做某件特定的事情。”而财务则是从数字的层面了解生意的本质，从宏观上看待生意的本质，对于一个生意是否挣钱，是否可以正常运作有着最深刻的认识。

          公司小的时候是销售主导公司，而公司大的时候是财务主导公司，销售的局限性在于只看人情不看数字，财务的局限性在于只看数字不看人情。公司初期，运营成本低，有订单就活得下去，跟客户也没有什么谈判的条件，别人肯给生意做已经谢天谢地了，这个时候订单压倒一切，客户的要求压倒一切，所以当然要顾人情。公司大了以后，一切都要规范化，免得因为不规范引起一些不必要的风险，同时运营成本也变高，必须提高利润率，把有限的资金放到最有产出的地方。对于上市公司来说，股东才不管你客户是不是最近出国，最近是不是那个省又在搞严打，到了时候就要把业绩拿出来，拿不出来就抛股票，这个时候就是数字压倒一切。

         前两天听到有人说一句话觉得很有道理，开始的时候我们想“能做什么？”，等到公司做大了有规模了，我们想“不能做什么。”很多人在工作中觉得为什么领导这么保守，这也不行那也不行，错过很多机会。很多时候是因为，你还年轻，你想的是“能做什么”，而作为公司领导要考虑的方面很多，他比较关心“不能做什么”。

         我并非鼓吹大家都去做销售或者财务，究竟选择什么样的职业，和你究竟要选择什么样的人生有关系，有些人就喜欢下班按时回家，看看书听听音乐，那也挺好，但就不适合找个销售的工作了，否则会是折磨自己。有些人就喜欢出风头，喜欢成为一群人的中心，如果选择做财务工作，大概也干不久，因为一般老板不喜欢财务太积极，也不喜欢财务话太多。先想好自己要过怎样的人生，再决定要找什么样的职业。有很多的不快乐，其实是源自不满足，而不满足，很多时候是源自于心不定，而心不定则是因为不清楚究竟自己要什么，不清楚要什么的结果就是什么都想要，结果什么都没得到。

         我想，我们还是因为生活而工作，不是因为工作而生活，生活是最要紧的，工作只是生活中的一部分。我总是觉得生活的各方方面都是相互影响的，如果生活本身一团乱麻，工作也不会顺利。所以要有娱乐、要有社交、要锻炼身体，要有和睦的家庭……最要紧的，要开心，我的两个销售找我聊天，一肚子苦水，我问他们，2年以前，你什么都没有，工资不高，没有客户关系，没有业绩，处于被开的边缘，现在的你比那时条件好了很多，为什么现在却更加不开心了？如果你做得越好越不开心，那你为什么还要工作？首先的首先，人还是要让自己高兴起来，让自己心态好起来，这种发自内心的改变会让你更有耐心，更有信心，更有气质，更能包容……否则，看看镜子里的你，你满意么？

         有人会说，你说得容易，我每天加班，不加班老板就会把我炒掉，每天累得要死，哪有时间娱乐、社交、锻炼？那是人们把目标设定太高的缘故，如果你还在动不动就会被老板炒掉的边缘，那么你当然不能设立太高的目标，难道你还想每天去打高尔夫？你没时间去健身房锻炼身体，但是上下班的时候多走几步可以吧，有楼梯的时候走走楼梯不走电梯可以吧？办公的间隙扭扭脖子拉拉肩膀做做俯卧撑可以吧？谁规定锻炼就一定要拿出每天2个小时去健身房？你没时间社交，每月参加郊游一次可以吧，周末去参加个什么音乐班，绘画班之类的可以吧，去尝试认识一些同行，和他们找机会交流交流可以吧？开始的时候总是有些难的，但迈出这一步就会向良性循环的方向发展。而每天工作得很苦闷，剩下的时间用来咀嚼苦闷，只会陷入恶性循环，让生活更加糟糕。
     (后记：耐心把文章读过的人一定不会后悔，而认真读过的人能获得很多，真正领会思想并落实到生活中，我相信，是会改变工作和生活的！)

 第二章 开启自己的心智
    4.控制自己的情绪
    对痛苦的遗忘是人的本能。一个遗忘痛苦的能力特别强的一个具体表现就是，这个人会很轻易地原谅自己。有两种办法很简单却又非常有效，第一种办法是当你面临尴尬的时候，刻一定要拿出纸笔来，把你所遇到的尴尬记录下来。当然，最好是记录在同一个本子里，然后养成 定期拿出这个本子回顾一下。另外一个办法是，在面临尴尬的时候，尽量弱化你的痛苦，皑皑自己的情绪，不要被你的大脑的直接反应所左右。书中提到的背单词的事情很有意思，把一个平时觉得很难很痛苦的事情转换成为很开心去做的事情，减少痛苦的感觉之后，就不那么容易被遗忘。
    5.推迟满足感
    不劳而获是第个人心中所拥有的诸多梦想之一，甚至可能还是其中最大的梦想，如果不能做到不劳而获的话，那就最好尽量少劳但一定要多获，并且多多益善。更进一步，大多数人看法惊人地类似甚至相同：如果有收获的话，那最好要马上有收获；如果没有收获的话，那最好要马上有结果。“希望自己的欲望马上得到满足”是天性。平静接受并且正确认识自己的天性是改变天性的第一步。有时候成为高手需要愚钝。如郭靖。很多人或事情对别人来讲是诱惑，对他来讲干脆就是不存在的；于是，他可以用普通的智商长期只专注在一件最应该做的事情上，最终天下无敌。
    在学习和工作中控制这种天性是最为重要的。“推迟满足感”是心智成熟的人必备的能力，也是需要挣扎和锻炼才可以习得的能力。他们最终表现为比绝大多数人“更有耐心”---甚至是惊人的耐心。
    真正拥有耐心，甚至惊人耐心的你，生活就会从此发生天翻地覆的变化。
第三章 通过管理自己与时间做朋友
    1.逃避责任就会带来轻松，可那恰恰就是“生命不能承受之轻”。
    2.《奇特的一生》=》基于过程的记录要比基于结果的记录只会更为详尽。这样详细记录的好处：1.遇到结果不好的时候，更容易找到缘由。2.它会使你对时间的感觉越来越精确。在估算任何工作量的时候，都更容易确定“下下现实可行的目标”。
    3.养成任何非天生的习惯，都是需要挣扎才能做成的事情。我们只有一个习惯是天生的---“懒惰”。
    4.“心智开启”的起点是“意识到可以自律”，而心智发展的过程就是克服懒惰的过程。
    5.当我们决心改变的时候，“懒惰”便会指使我们的那个“大脑的自我保护功能”---“遗忘”----起作用，让我们不知不觉停止改变。与懒惰抗争、停止遗忘、坚持改变的工具，就是纸和笔笔。
    6.重要的事情和看起来重要的事情，不重要的事情和看起来不重要而实际却很重要的事情。
    7.使用列表减少失误：有意识了控制自己不要去做那些没有实际意义的事情---那是在浪费时间。
    8.真正最重要的任务永远只有一个--那个真正对你的目标实现有帮助的任务
    9.列表一旦开始执行就一定要执行到底。作者给出的例子很不错：走向成功的过程大抵上好像你的起点是南极，而成功路径的终点在北极，那么，无论你往哪个方向走，只要中途不改变方向，最终会到达北极，但是，如果你中途改变了方向，甚至经常改变方面，你就几乎无法到达北极，甚至可能返回出发点。
    10.失败只有一种，就是半途而废。坚持到底也不见得会成功，目标问题，时间问题。

    绝大多数的成功根本与智商没有任何关系，所有的失败都与且只与时间限制有关
    当你把时间花费到一个人身上的时候，相当于在他身上倾注了你生命的一段，哪管最终结果是如何，反正，那个人那件事成了你生命中的一部分，不管最后你喜欢还是不喜欢。
    一切都靠积累，一切都可以提前准备，越早醒悟越好。人的一生各有不同，有的人一生很伟大，有的人一生很琐碎。如果有一个伟大的理想，一颗善良的心，就能够把很多琐碎的日子堆砌起来，变成一个伟大的生命。反之则每天庸庸碌碌，停止进步，所有的日子规程起来将永远只是一堆琐碎。                  ----俞敏洪
    人生是马拉松，胜者不一定是跑得最快的。大家都知道GTSP的故事，但是认真想想其中含义并能在生活中落实的人是少之又少。
第一章 心智的力量
“不知道学习有什么用”-》1.学了也没用。拒绝学习 2.先学再说，不一定哪天就有用。努力学习
第二章 心智力量的差异
    1.上司真的很愚蠢吗？
    强大心智力量的人对这个问题的思考：
    他的这个缺点是否会阻碍团队目标的实现？
    是，能否补救？
        能，补救方法是什么？
        不能，作为团队成员，能否有效地提供帮助？
            能，想出一个有效的方式去沟通，并提供帮助--因为这其实是团队的义务之一
            不能，作为团队成员，有没有其他可行的建议，或者可实施的有效方案？
                有，想办法提交，并推进执行
                没有，暂时闭嘴---反正不是抱怨
    不是，能否平静地对待
        能，专心做自己的工作，完成自己的贡献
        不能，不要抱怨，应该安静地走开

    老是抱怨的人只不把“上司的愚蠢”作为自己偷懒的借口而已：他们的可笑与可悲自己并不知道：既然上司那么愚蠢，又为什么要用自己宝贵的生命中的大部分时间为这个愚蠢的上司打工呢？那些少数能够提出建设性意见的人，是不会抱怨的，因为他们要么想办法帮助上司解决问题，要么在爱莫能助的时候选择离开去自行其是。
    心智力量的不同，使得不同的人面对相同境遇时产生不同的反应，得到不同的结论，最后作出截然不同的选择。不同的选择后，这些人的时间质量有多大的天壤之别啊！
    2.你真的那么优秀吗？
    被猎头看上的人，呵呵，别高兴太早，你很有可能被定义为“二流人才”。也许你是“另外一只老虎”，也许不是。如果确信是，那么猎头对你没有什么用处--你是注定要做自己的事情，用不着他。如果你不确定自己是不是，或者就不是，那猪头对你也没有用---因为你听信他的话很有可能走入另一个困境。
    3.兴趣真的那么重要？
    我不喜欢做这件事情有没有可能仅仅是因为这件事情我并没有做好？如果是因为没有做好而不喜欢，就要分辨：做好这件事情对自己究竟有没有意义？如果有，就要努力做，直到做好，没有其他选择。
    兴趣并不是很重要，只要一件事你能做好，最好，或者比大多数人好，你就不会对那么事情没有兴趣。
    培养孩子兴趣：根据孩子情况，选出他最有可能做得比别人好的事情，然后 想出怎么才能帮助他做好--然后，兴趣就自然出现了。
    总结：往往并不是有兴趣才能做好，而是做好了才有兴趣
    4.学习方法真的至关重要吗？
    方法固然很重要---但是比起“用功”来说，方法几乎可以忽略不计。
    所有学习上的成功，都只靠两件事：策略和坚持，而坚持本身就应该是最重要的策略。
    与其不停地找更好的方法，还不如马上开始行动，省得虚度更多的时间。
    5.盲打空间是否值得学会
    体会到在电脑中做读书笔记的好处（方便查询和积累）。之前一个星期就可搞定的事情，我竟然只不过是出于懒惰而拒绝。如果当初就算花一个星期来学习，那么可以多出多少读书笔记，积累多少文字呢。“心智低下真可怕。。。”没有意识到没有去做的价值，没有意识到没去做是由于自己的懒惰，并且还振振有词。
    总结：一是我们的心智出现了问题，我们就会因为错误的理解而做出错误的判断，因此浪费的时间往往不仅无法估量，更可怕的是，这种错误的浪费甚至可能根本无从知晓。
 
   

    6.自定义选择符
        除了CSS和Xpath选择符之外，jQuery还添加了独有的完全不同的自定义选择符。自定义选择符的语法与CSS中的伪类选择符语法相同，即选择符以一个冒号：开头。如要从匹配的带有horizontal类的div集合中，选择第2个项，那么应该使用下面的代码：$('div.horizontal.eq(1)')。注意，因为javascript数组采用从0开始的编号方式，所以eq(1)取得的是集合中的第2个元素。而CSS则是从1开始的。因此CSS选择符$('div:nth-child(1)')取得的是作为其父元素第1 个子元素的所有div。
        交替地为表格行为添加样式的代码：
        $(document).ready(function(){
            $('tr.odd').addClass('odd');
            $('tr.even').addClass('even');
        })
        要让突出显示提到"Henry"的表格单元，使用语句：$('tr.contains("Henry")').addClass('highlight');
       
        DOM遍历方法的例子：a)$('th').parent().addClass('table-heading');    b)$('tr:not([th]:even').addClass('even');    c)$('td:contains("Henry")').next().addClass('highlight');
    三.事件---扣动扳机
    1.在页面加载后执行任务
        $(document).ready()与window.onload事件的微妙差别：当一个文档完全下载到浏览器中时，会触发window.onload事件，这意味着页面上的全部元素对javascript都是可访问的。而$(document).ready()注册的事件处理程序，会在DOM完全就绪并可以使用时调用。所有元素对脚本 而言可访问，但不意味着所有关联的文件都已经下载完毕。如图片，其高度等属性无法得到。
    2.基于一个页面执行多个脚本
        通过Javascript(而不是指直接在HTML中添加处理程序属性)注册事件处理程序的传统机制是，把一个函数指定给DOM元素的对应属性。如<body nload="doStuff;"> 和 window.onload = doStuff;第二种方式优点在于能使行为更清晰地从标记中分离出来。问题：当定义了第2个函数doOtherStaff，用window.onload = doOtherStaff;时，这次指定的函数会取代刚才指定的第1 个函数。因为.onload属性一次只能保存对一个函数的引用，所以不能在现有的行为基础上再增加新行为。通过$(document).ready()机制可很好处理。每次调用这个方法都会向内部的行为队列中添加一个函数，当页面完成加载后，所有函数都将得到执行，且是按照注册它们的顺序依次执行。
    3.简写方式：$(document).ready(function(){}); 可简写为$().ready(function(){});也可改写这$(funcion(){});但通常用较长的形式，因为能更清楚表示代码的含义。
    4.实现简单的样式转换器，即当按下某个按钮时，整个body的样式变化:
        $(document).ready(function(){
            $('#buttonId1').bind('click',function(){
                $('body').addClass('large');
            })
            $('#buttonId2').bind('click',function(){
                $('body').addClass('narrow');
            })
         })
    当有多个按钮进行多种样式变换时，为使得被选择的样式对应的按钮变样式来提示用户当前选择，可以使用
        $(document).ready(function(){
            $('#buttonId1').bind('click',function(){
                $('body').removeClass('narrow').addClass('large');
                $('#buttonId .button').removeClass('selected');//将以buttonId开头的button的样式去除selected
                $('this').addClass('slected');
            });
            $('#buttonId2').bind('click',function(){
                $('body').addClass('narrow').removeClass('large');
                $('#buttonId .button').removeClass('selected');//将以buttonId开头的button的样式去除selected
                $('this').addClass('slected');
            });
         })
    上述代码中，有重复的地方，我们可以将其提取到一个单独的处理程序中
        $(document).ready(function(){
            $('#buttonId1').bind('click',function(){
                $('body').removeClass('narrow').addClass('large');
            });
            $('#buttonId2').bind('click',function(){
                $('body').addClass('narrow').removeClass('large');
            });
            $('#buttonId .button').bind('click,function(){
                $('#buttonId .button').removeClass('selected');//将以buttonId开头的button的样式去除selected
                $('this').addClass('slected');
            }')
         })
         这一步优化利用了三种jQuery特性：1.通过.bind对一次调用的每个按钮都绑定了相同的单击事件处理程序，隐匿迭代机制发挥作用。2.行为队列机制让我们在同一单击事件上绑定两个函数，且第2 个函数不会覆盖第1 个函数。3.使用jQuery的连缀能力将每次添加和移除类的操作压缩到一行代码中。
        进一步，removeClass('narrow')可以简化为removeClass()。因为不带参数表示删除所有样式。
        还有些重复的代码，可以提取到通用的按钮单击处理程序中，如下：
        $(document).ready(function(){
            $('#buttonId').bind('click',function(){
                $('body').removeClass();
                $('#buttonId .button').removeClass('selected');
                $(this).addClass('select');
            });
            $('#buttonId1').bind('click',function(){
                $('body').addClass('large');
            });
            $('#buttonId2').bind('click',function(){
                $('body').addClass('narrow');
            });
         })
        更可以使用事件执行环境来简化
        $(document).ready(function(){
            $('#buttonId').bind('click',function(){ //可以使用事件简化方法改写为
                $('#buttonId').click(function(){
                if(this.id=='buttonId1'){
                    $('body').addClass('large');
                }else if( this.id=='buttonId2'){
                    $('body').addClass('narrow');
                }
                $('#buttonId .button').removeClass('selected');
                $(this).addClass('select');
         })
    5.复合事件。.toggle()和.hover()方法。
    6.toggle()接受两个均为函数的参数，第1次在元素上单击会调用第1 个函数，第2次会触发第2个函数。这样就可以实现可折叠的样式转换器了（点击一下之后，所有按键隐藏，再点一下，都显示出来）
        $(document).ready(function(){
            $('#switcher h3').toggle(function(){
                $('#switcher .button').addClass('hidden');
            }),function(){
                $('#switcher .button').removeClass('hidden');
            });
        })
    7.;.hover接受两个函数参数，第1个为鼠标指针进入被选择的元素时进行，而第2个在指针离开该元素时触发。

待续.....

    
 一.入门
    1.javascript是解释型语言，所以使用它不用编译或构建，只要在使用到jquery时，在相关的html文档中简单地引用该库文件的位置。一般，jquery应用示例包括三个部分：html文档、为文档添加样式的css文件和为文档添加行为的javascript文件。
    2.文件中指向另一个文件的引用，使用相对路径（../images/foo.pgn）而不是绝对路径（/images/foo.png），这样，不需要使用web服务器就能在本地运行代码。
    3.使用jquery埋页面样式修改的简单例子：
    只需要三行代码：
    $(document).ready(function(){
        $('.poem-stanza').addClass('emphasized');
    }) 其中包括三个步骤
        a)查找要操作的页面元素
            通过$()结构来完成，这个结构需要一个字符串参数，参数中可以包含任何CSS选择符表达式。如要找所有应用了poem-stanza类的文档元素，使用$('.poem-stanza')即可。$()函数实际上是jquery对象的一个制造工厂，jquery对象会封装0个或多个dom元素。
        b)指定操作，这里为添加样式
            用.addClass()将一个CSS类应用到之前选择的页面元素。调用一次就可以对选择的所有元素进行修改而不是一个个的去迭代。
        c)执行代码
            如果将上面两步的代码放到页面头部，javascript代码在浏览器初次遇到它们时会执行，但在浏览器处理头部时，HTML还不会呈现样式。因此，我们需要将代码延迟到DOM可用时再执行。
            控制javascript代码何时执行的传统机制是在事件处理函数中调用代码。如果没有jquery，需要依靠onload处理函数。先将先前代码放到一个函数中，再用<body nload="emphasizePoem();">来完成调用。这种方法的缺点在于：为了添加行为，我们修改了HTML代码，这种结构与功能紧密耦合的做法，会导致代码混乱。很多页面都可能需要重复调用相同的函数，或者在处理鼠标单击之类的事件时，页面每个元素的实例也可能需要反复调用相同的函数。这样，添加新的行为涉及到两个不同位置的改动。
            jquery允许我们使用$(document).ready()结构预定DOM加载完成后（不必等待图像加载完成）触发的函数调用。这种技术不需要对HTML进行任何修改，所有行为完全从javascrpipt文件内部添加。
            定义只使用一次的函数有点低效率，使用匿名函数来解决这个问题。当在另一个函数主体内使用这种语法定义了一个匿名函数时，就创建了一个闭包。

二.选择符--取得你想要的一切
    1.jquery利用了CSS和Xpath选择符的能力，让我们在DOM中快捷轻松地获取元素或元素组。无论使用哪种类型的选择符（CSS、Xpath、还是自定义选择符），都要从一个美元符号和一对圆括号开始：$()。
    2.常用简单例子：
    标签名：$('p')会取得文档中所有的段落
    ID：$('#some-id')取得文档中具有对应的some-id的一个元素
    类：$（'.some-class'）取得文档中带有some-class类的所有元素
    3.复杂一点的例子
    $('#selected-plays > li')的含义：查找ID为selected-plays的元素(#secected-plays)的子元素（>）中所有的列表项(li)
    $('#slected-plays li:not(.horizontal)')的含义：
        取得的每个列表项（li）：
        a)是ID为selected-plays的元素(#secected-plays）的后代元素
        b)没有horiaontal类
    3.XPath（XML路径语言）是在XML文档中识别不同元素或元素值的一种语言。
    4.简单例子：
    $('a[@title]')：选择所有带有title属性的链接。这是[]来指定属性选择符的办法，使用了@符号
    $('div[ol]'):取得包含一个ol元素的所有div元素。[]的另一种用法，在不带前置@符号情况下，用来指定包含在另一个元素中的元素。
    5.属性选择符允许以类似正则表达式的语法来标识字符串的开始（^）和结尾($)，而且，也可以使用(*)表示字符串的任意位置。如
    $('a[@href^="mailto:"]')：寻找所有带有href属性（[@href]）且以mailto开头(^="mailto:")的锚元素。
    $('a[@href$=".pdf"]'):录供所有带有href属性且以.pdf结尾的锚元素
   

待续.......
  
   

 

  改变思维的七种因素
  Reason
  reserach
  resonance
  representation redescriptions
  Resources and rewards
  real world event
  Resistances
 
  思维可以更清楚地分为：观念 概念 故事 理论 技能

  多元智能，至少包括：语言智能/逻辑-数学智能/音乐智能/空间智能/身体智能/博物学智能/人际智能和自我认知智能。
  作者的智能定义： 采取特别的方式去处理特定形式的信息的生物心理前能 智能帮助人们解决问题、制造产品。取得价值认同。取得认同就决定了智能是一个动态的概念，随着时间、环境的不同会有不同的定义。
  一个人聪明还是愚笨，在不同的环境下存在不同的结论，人们拥有不同的智能，而不同的环境会决定这种智能受到何种程度的珍视或者漠视
  追求正确性是人类为了改变想法而自觉进行的努力。
  "我们不仅要提出完整的实施计划，还要努力学习如何推销，把一个错综复杂的用简单、直接明了的语言表达出来"（撒切尔）
  在书中提到的对于儿童思维的研究很有意思。
  去改变思维，影响他人、影响自己。讲故事、拿出理论、身体力行。多种表述方法来表达同一概念、理论。

一、成长的寓言：做一棵永远成长的苹果树51Testing软件测试网*n4sL[B\
I^

 

)[5z V?zY ^g*RO0

　　一棵苹果树，终于结果了。51Testing软件测试网�s.C3G9q/e1|

 51Testing软件测试网h6^EhDjH

　　第一年，它结了10个苹果，9个被拿走，自己得到1个。对此，苹果树愤愤不平，于是自断经脉，拒绝成长。第二年，它结了5个苹果，4个被拿走，自己得到1个。“哈哈，去年我得到了10％，今年得到20％！翻了一番。”这棵苹果树心理平衡了。51Testing软件测试网&m)R7xd+I$d

 

Yw}?-@1?(J9`0

　　但是，它还可以这样：继续成长。譬如，第二年，它结了100个果子，被拿走90个，自己得到10个。51Testing软件测试网&C/o3l&[j^

 

-c'jS"x i9hN!q0

　　很可能，它被拿走99个，自己得到1个。但没关系，它还可以继续成长，第三年结1000个果子……51Testing软件测试网7p-h;pgc{O+{

 51Testing软件测试网 Eqa4s
~3gj0d9Z ?

　　其实，得到多少果子不是最重要的。最重要的是，苹果树在成长！等苹果树长成参天大树的时候，那些曾阻碍它成长的力量都会微弱到可以忽略。真的，不要太在乎果子，成长是最重要的。51Testing软件测试网J]8UT~;^3]

　　

;XpB5F8bf0

【心理点评】你是不是一个已自断经脉的打工族？51Testing软件测试网Z Ui*iF?S)f

 51Testing软件测试网Q9a;ZJd!K.~ p`

　　刚开始工作的时候，你才华横溢，意气风发，相信“天生我才必有用”。但现实很快敲了你几个闷棍，或许，你为单位做了大贡献没人重视；或许，只得到口头重视但却得不到实惠；或许……总之，你觉得就像那棵苹果树，结出的果子自己只享受到了很小一部分，与你的期望相差甚远。

:SZI|mxC{s'k&?0

 51Testing软件测试网KAR!Q.fD

　　于是，你愤怒、你懊恼、你牢骚满腹……最终，你决定不再那么努力，让自己的所做去匹配自己的所得。几年过去后，你一反省，发现现在的你，已经没有刚工作时的激情和才华了。51Testing软件测试网KD#S'j7Dg

 51Testing软件测试网LU|F"|1Eo xZ

　　“老了，成熟了。”我们习惯这样自嘲。但实质是，你已停止成长了。

Z5x&K/p Z k\
b9~2Z0

 51Testing软件测试网4~
N3a ^|)Fv]W(a

　　这样的故事，在我们身边比比皆是。51Testing软件测试网 Y.zn;}9Y

 51Testing软件测试网"?2C4H{G

　　之所以犯这种错误，是因为我们忘记生命是一个历程，是一个整体，我们觉得自己已经成长过了，现在是到该结果子的时候了。我们太过于在乎一时的得失，而忘记了成长才是最重要的。51Testing软件测试网+e6zMuZ,K

 51Testing软件测试网G5h�zny,PK,H*sS

　　好在，这不是金庸小说里的自断经脉。我们随时可以放弃这样做，继续走向成长之路。

8g'E9g:f;Y+^F TB;L6y0

 

fR9i;xl}�Z0

　　切记：如果你是一个打工族，遇到了不懂管理、野蛮管理或错误管理的上司或企业文化，那么，提醒自己一下，千万不要因为激愤和满腹牢骚而自断经脉。不论遇到什么事情，都要做一棵永远成长的苹果树，因为你的成长永远比每个月拿多少钱重要。51Testing软件测试网m M_H&f2e4y Bd+W

　　

aqc jU#}0

二、动机的寓言：孩子在为谁而玩

1IeA6\5al0

 51Testing软件测试网/s:hoo*G

　　一群孩子在一位老人家门前嬉闹，叫声连天。几天过去，老人难以忍受。

)N2r`cg].W0

 51Testing软件测试网ls_9aR6E.V b

　　于是，他出来给了每个孩子25美分，对他们说：“你们让这儿变得很热闹，我觉得自己年轻了不少，这点钱表示谢意。”51Testing软件测试网]j1Rh8A:l3K ^`#\2}4o

 

Tt"Y9_)C�[VE0

　　孩子们很高兴，第二天仍然来了，一如既往地嬉闹。老人再出来，给了每个孩子15美分。他解释说，自己没有收入，只能少给一些。15美分也还可以吧，孩子仍然兴高采烈地走了。51Testing软件测试网A'A(x^3luUT?

 51Testing软件测试网+j&iD9hq$p8^q$_9m�{

　　第三天，老人只给了每个孩子5美分。51Testing软件测试网T9zk I$u{

 51Testing软件测试网6S P,K.w@^^SD9[,S;s E

　　[孩子们勃然大怒，“一天才5美分，知不知道我们多辛苦！”他们向老人发誓，他们再也不会为他玩了！

v
|S(_5GGt$D�H0

 

2cH+e(d0N2q$Q0

【心理点评】你在为谁而“玩”

`9OWM�V0

 51Testing软件测试网1I1N!QD c9q

　　这个寓言是苹果树寓言的更深一层的答案：苹果树为什么会自断经脉，因为它不是为自己而“玩”。51Testing软件测试网b#_i,|_#C)}{-n:u8a

 51Testing软件测试网
G7J\1~v]+d!cx

　　人的动机分两种：内部动机和外部动机。如果按照内部动机去行动，我们就是自己的主人。如果驱使我们的是外部动机，我们就会被外部因素所左右，成为它的奴隶。51Testing软件测试网#C,Mk.I n{g j F

 51Testing软件测试网+T,DZ5oMCb#S

　　在这个寓言中，老人的算计很简单，他将孩子们的内部动机“为自己快乐而玩”变成了外部动机“为得到美分而玩”，而他操纵着美分这个外部因素，所以也操纵了孩子们的行为。寓言中的老人，像不像是你的老板、上司？而美分，像不像是你的工资、奖金等各种各样的外部奖励？51Testing软件测试网(A+d!rsS

 51Testing软件测试网4{,]_;VM

　　如将外部评价当作参考坐标，我们的情绪就很容易出现波动。因为，外部因素我们控制不了，它很容易偏离我们的内部期望，让我们不满，让我们牢骚满腹。不满和牢骚等负性情绪让我们痛苦，为了减少痛苦，我们就只好降低内部期望，最常见的方法就是减少工作的努力程度。

?G9O([D.|PM a0

 

vXOQB6Hc0

　　一个人之所以会形成外部评价体系，最主要的原因是父母喜欢控制他。父母太喜欢使用口头奖惩、物质奖惩等控制孩子，而不去理会孩子自己的动机。久而久之，孩子就忘记了自己的原初动机，做什么都很在乎外部的评价。上学时，他忘记了学习的原初动机———好奇心和学习的快乐；工作后，他又忘记了工作的原初动机———成长的快乐，上司的评价和收入的起伏成了他工作的最大快乐和痛苦的源头。51Testing软件测试网8rM@%fC3Y

 51Testing软件测试网"jz%Ympc

　　切记：外部评价系统经常是一种家族遗传，但你完全可以打破它，从现在开始培育自己的内部评价体系，让学习和工作变成“为自己而玩”。 

这篇英文短诗来自, 南非黑白种族隔离政策曾让非洲原住民黑人遭到许多不平等的待遇，而本诗作者即以天生肤色的差异，来表达心中的不满与无奈。
　　
　　Dear white, something you got to know
　　亲爱的白种人，有几件事你必须知道。
　　
　　
　　When I was born, I was black.
　　当我出生时，我是 黑色 的
　　
　　
　　When I grow up, I am black.
　　我长大了，我是 黑色 的
　　
　　
　　When I’m under the sun, I’m black.
　　我在阳光下，我是 黑色 的
　　
　　
　　When I’m cold, I’m black.
　　我寒冷时，我是 黑色 的
　　
　　
　　When I’m afraid, I’m black.
　　我害怕时，我是 黑色 的
　　
　　
　　When I’m sick, I’m black.
　　我生病了，我是 黑色 的
　　
　　
　　When I die, I’m still black.
　　当我死了，我仍是 黑色 的。
　　
　　
　　you---white people,
　　你--- 白种人
　　
　　
　　When you were born, you were pink.
　　当你出生时，你是 粉红色 的
　　
　　
　　When you grow up, you become white.
　　你长大了，变成 白色 的
　　
　　
　　You’re red under the sun.
　　你在阳光下，你是 红色 的
　　
　　
　　You’re blue when you’re cold.
　　你寒冷时，你是 青色 的
　　
　　
　　You are yellow when you’re afraid.
　　你害怕时，你是 黄色 的
　　
　　
　　You’re green when you’re sick.
　　你生病时，你是 绿色 的
　　
　　
　　You’re gray when you die.
　　当你死时，你是 灰色 的
　　
　　
　　And you, call me " c o l o r " ?
　　而你，却叫我「有色人种」？