myJavaBlog

EXEC DBMS_REDEFINITION.CAN_REDEF_TABLE(USER, 'T1', DBMS_REDEFINITION.CONS_USE_PK);

EXEC DBMS_REDEFINITION.START_REDEF_TABLE(USER, 'T1', 'T1_NEW',DBMS_REDEFINITION.CONS_USE_PK);
（转载请注明出处：[url=http://www.k6567.com]e世博[/url]

许多人对于程序、进程、线程这几个概念许多人都分的不是很清楚，下面我们就简单的介绍一下它们的区别。

程序是计算机指令的集合，它以文件的形式存储在磁盘上。程序是通常我们所写好的存储于计算机上没有执行的指令的集合，通俗的讲就是我们自己写的代码。我们写的代码不可能只是为了存储吧，必须运行才不会浪费我们的辛苦，等到我们将我们的代码运行了，就产生了进程。

进程：是一个程序在其自身的地址空间中的一次执行活动。通常的程序是不能并发执行的。为了使程序能够独立运行，应该为之配置一些进程控制块，即PCB；而由程序段，相关数据段和PCB三部分构成了进程实体。通常我们并不区分进程和进程实体，基本上就代表同一事物。进程是资源申请、调度和独立运行的单位，因此，它使用系统中的运行资源；而程序不能申请系统资源，不能被系统调度，也不能作为独立运行的单位，因此，它不占用系统的运行资源。

20世纪60年代人们提出了进程的概念，在OS中一直都是以进程作为能独立运行和拥有资源的基本单位。但是进程间的切换比较麻烦费时，所以在20世纪80年代人们为了提高系统内程序并发执行的程度，进一步提高系统的吞吐量，提出了比进程更小的能独立运行的基本单位。线程又称为轻量级进程，它和进程一样拥有独立的执行控制，由操作系统负责调度，区别在于线程没有独立的存储空间，而是和所属进程中的其它线程共享一个存储空间，这使得线程间的通信远较进程简单。一个进程可以同时拥有一个或者多个线程，这几个线程共享同样的数据。

现在的CPU几乎都是多核的了，这样多线程的程序，运行起来就更加流畅。下面我们通过图片来比较一下单线程和多线程：

这个就好比我们算一道数学题（2+3）*（5-3），如果我们使用左边的单线程，只能是先算2+3然后算5-3，最后结果相加。但是如果我们使用右边的多线程，我们可以同时对2+3和5-3进行运算，然后再对最后的结果相加。我想哪个运行的比较快就不用说了，另外多线程在图像处理，多用户通信等方面用户都很多。

可能读者会说如果我们用的是单CPU的PC那么他们就差别不大了，但是现在的事实是现在的PC基本都是多核了，所以多线程是为了我们更好的将程序移植到多核的CPU上。还有一点就是对于线程的切换，比进程的切换速度快的多，多线程更好的发挥CPU的效率。

写的不好，如果哪里错了希望大家指出。希望对你有帮助。
(转载请注明出处：[url=http://www.6rfd.com]澳门博彩[/url]

当面临一个问题，有多种实现算途径的时候，要想到java中的核心：多态。

多态的思想：

概括地讲，在运用父类引用指向子类对象的情况下，基本上就用到了多态了。

最简单的多态应该是继承：

public class Tank {
public void move() {
System.out.println("I am father");
}
}

public class Tank2 extends Tank{
@Override
public void move(){
System.out.println("I am child a");
}

}

}

接口和抽象类的例子：

对于抽象类和接口，有许多类实现这个接口(或者继承这个抽象类)。
在调用的时候，用父类引用指向子类对象的方法。然后，调用对象的方法，编译器就会自动根据这个对象实际属于哪个实现类，
来调出这个类对于接口或者抽象类的具体实现。

例：
public class Address {
private String name;
public Address(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

定义基类(抽象类)：
public abstract class Vehicle {
abstract void go(Address address);
}

Car对于基类的实现：
public class Car extends Vehicle{
@Override
public void go(Address address){
System.out.println("Car to " + address.getName());
}
}

Plane对于基类的实现：
public class Plane extends Vehicle{
@Override
void go(Address address) {
System.out.println("Plane to " + address.getName());
}
}


Driver中多态：
public void drive(Vehicle v){ ///多态，父类引用指向子类对象，实际传过来的是抽象类Vehicle的子类，或者实现类，然后编译器会根据具体实现类，来找实现方法。
v.go(new Address("杭州(abstract)")); ///此方法在具体的实现中被重写
}

Test:
public static void main(String[] args) {
Driver d = new Driver();
d.drive(new Plane()); //实际是Plane对象，则编译器就会找到Plane中，对go的实现
d.drive(new Car()); //实际是Car对象，则编译器就会找到Plane中，对go的实现
}

输出结果：
Plane to 杭州(abstract)
Car to 杭州(abstract)

事实上，这就是多态所起的作用，可以实现控制反转这在大量的J2EE轻量级框架中被用到，比如Spring的依赖注射机制。
（通过注入不同的bean，来得到不同的实现类）

接口与抽象类的区别：

有个概念，但还没有想到具体实现。
对于一些共用的，已经有实现了，可以设计成接口。

上面是抽象类，下面把它转化为接口：

IVehicle.java
public interface IVehicle {
public void go(Address address);
}

CarImpl.java
public class CarImpl implements IVehicle{
public void go(Address address) {
System.out.println("CarImpl to " +address.getName());
}
}

PlameImpl.java
public class PlaneImpl implements IVehicle{
public void go(Address address) {
System.out.println("PlaneImpl to " + address.getName());
}
}

Driver.java
////多态之接口
public void driveI(IVehicle v){
v.go(new Address("杭州(interface)"));
}

Test.java
////用接口实现
d.driveI(new PlaneImpl());
d.driveI(new PlaneImpl());

打印结果：
PlaneImpl to 杭州(interface)
PlaneImpl to 杭州(interface)

多态的三要素：1.继承 2.重写 3.父类引用指向子类对象

以上就是我目前学习中的总结，如有不足之处，还望多多赐教。
(转载请注明出处：[url=http://www.k8764.com]博彩通[/url]

用JAVA/JSP做开发很久了,也见过许多朋友做过,有很大一部分用的是MYSQL的数据库,现在MYSQL数据库版本5.0及以上的都已经被用的很广泛了,但一直有一个问题,使刚入门的朋友费劲心思.就是JSP连接MYSQL5数据库的时候的一些中文问题.于是网络上也出现了很多相关的帖子.由些大家对MYSQL5数据库的配制文件MY.INI也有了些了解.甚至一些朋友就直接问:你们的MYSQL是什么编码的?你们的TOMCAT是什么样的编码,可能不是很规范的问法,但说明了编码问题的确影响了大家的使用.

下面的讲解是在MYSQL5.0.18,TOMCAT5.0.28,驱动为mysql-connector-java-3.2.0-alpha-bin.jar及以上版本的情况下测试的

JSP连接数据库的乱码问题,分两部分来看

1 数据库中是不是乱码?

我们需要保证数据库保存的不是"?????"形式的乱码,如何保证呢?

我们在管理MYSQL数据库的时候,需要用一个客户端,无论你用MYSQL-FRONT,EMS SQL Manager for MySQL,还是MYSQL命令行,这些都是客户端,也是程序连接了数据库,我们现在用客户端EMS SQL Manager for MySQL连接数据库,连接的时候一定要设置客户端字符集为GBK或者GB2312,这样你才能知道数据库里面是不是乱码.这一编码设置很重要,不然,就算数据库里是中文,你看到的还是乱码

这样连接后,我们看下我们做测试的表格,里面的汉字就是正常的,这个时候也可以直接在上面的记录中进入中文的修改

若这里没有选择编码的话,一般默认的就是UTF8的了,连接后再看这个表格,就会出现乱码

而这个时候就会出现不能插入中文的问题,若您插入中文的话,就会出现下列错误

这个时候大家什么不要误解,不是不能插入中文,也不是你插入的字符太长,

更改下连接编码就OK了.下面是这个表格的SQL语句

二.程序连接数据时,也要设置好连接时候的编码,JSP连接MYSQL数据库时候,有个URL参数,jdbc:mysql://localhost:3307/sssdb?user=demoUser&password=demoPwd&useUnicode=true&characterEncoding=UTF-8,在这里需要设置成UTF-8,

下面是连接数据库的程序代码

上面的经验是经过多次尝试总结出来的,不管是MYSQL的客户端还是程序连接MYSQL数据库,在本质上都是程序连接数据库,可以自己在本地多试验下,有时候有可能是驱动太旧.
（转载请注明出处：[url=http://www.a9832.com]博彩网[/url]
[url=http://www.tswa.org]博彩通[/url]）

众所周知，当多个消息消费者(MessageConsumer)同时监听同一个消息队列(Queue)的时候，JMS提供者会在它们之间提供一种负载均衡机制，从而达到可以同时处理多个消息的目的。图一是一个简单的示意图，当消息生产者发送多个消息时，JMS提供者会把这些消息均匀的分发到不同的消息消费者。　　

　　图一 JMS负载均衡示意图

　　一、WebService负载均衡
　　要在原来的WebService上应用负载均衡，首先应该明确一个前提，就是客户端和服务端应尽可能的不做修改。另外还需要确保可以方便的添加和删除一个Service节点，而不会影响整个应用的运行。庆幸的是WebService调用通常都是无状态的，类似于无状态会话 Bean(Stateless Session Bean)的远程调用，服务端和客户端不需要维持一个会话，也就是说同一个客户端调用多次WebService请求，每个请求可以由不同的Service 为它服务，这样就可以避免Session复制的问题，如果一个Service崩溃了，另一个Service可以继续为客户端服务。
　　二、将JMS负载均衡应用到WebService中
　　接下来就把JMS的负载均衡机制应用到WebService当中去，图二是一个整体的框架图，Proxy作为一个WebService的代理来和客户端交互， 而Listener会去掉用具体的WebService，来完成一次WebService方法的调用。

　　图二 整体框架图

　　与客户端直接交互的是Proxy，它是一个简单的Servlet，它的作用就是拦截客户端发送过来的请求，提取请求中的SOAP包的内容，然后把它封装成一个消息发送到指定的Queue中去，同时它会等待消息的回复，因为回复的消息中包含着WebService调用返回的结果，后面会详细讲到。当Proxy收到回复消息之后，读取其中的内容并把它返回给客户端，从而完成一个WebService的调用。另外需要注意的是，在这里Proxy需要区分出客户端发出的是GET请求，还是POST请求。如果是GET请求，就有可能是客户端正在获取WebService的WSDL。如果是POST请求，那么通常就是客户端在调用一个WebService方法了。下面是一个简单的Proxy实现：
　　1 　　public class ServiceProxy extends HttpServlet {
　　2
　　3 　　private ConnectionFactory factory;
　　4
　　5 　　private Connection connection;
　　6
　　7 　　private Queue queue;
　　8
　　9 　　public void init() throws ServletException {
　　10
　　11 　　super.init();
　　12
　　13 　　try {
　　14
　　15 　　//在这里为了简单起见，采用了ActiveMQ。在实际的J2EE应用中应通过JNDI查找相应的ConnectionFactory和Queue。|||
　　16
　　17 　　factory = new ActiveMQConnectionFactory("vm://localhost");
　　18
　　19 　　connection = factory.createConnection();
　　20
　　21 　　connection.start();
　　22
　　23 　　queue = new ActiveMQQueue("testQueue");
　　24
　　25 　　} catch (JMSException e) {
　　26
　　27 　　e.printStackTrace();
　　28
　　29 　　}
　　30
　　31 　　}
　　32
　　33 　　protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
　　34
　　35 　　if (req.getQueryString().endsWith("wsdl") || req.getQueryString().endsWith("WSDL")) {
　　36
　　37 　　try {
　　38
　　39 　　Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
　　40
　　41 　　Message message = session.createMessage();
　　42
　　43 　　//这个属性用来标示请求是否是WSDL请求，后面的Listener会根据它来调用具体的WebService。
　　44
　　45 　　message.setBooleanProperty("isWsdl", true);
　　46
　　47 　　message.setJMSReplyTo(session.createTemporaryQueue());
　　48
　　49 　　session.createProducer(queue).send(message);
　　50
　　51 　　//等待回复消息，它里面包含Service返回的WSDL，这里使用了一个选择器。
　　52
　　53 　　String selector = String.format("JMSCorrelationID=‘%s‘", message.getJMSMessageID());
　　54
　　55 　　MessageConsumer consumer = session.createConsumer(message.getJMSReplyTo(), selector);
　　56
　　57 　　TextMessage replyMessage = (TextMessage) consumer.receive();
　　58
　　59 　　//将WSDL返回给客户端。
　　60
　　61 　　resp.getWriter().write(replyMessage.getText());
　　62
　　63 　　} catch (Exception e) {
　　64
　　65 　　e.printStackTrace();
　　66
　　67 　　}
　　68
　　69 　　}
　　70
　　71 　　}
　　72
　　73 　　protected void doPost(HttpServletRequest req, HttpServletResponse resp) {
　　74
　　75 　　try {
　　76
　　77 　　//首先从客户端请求中得到SOAP请求部分。
　　78
　　79 　　StringBuffer payLoad = new StringBuffer();
　　80
　　81 　　BufferedReader reader = req.getReader();
　　82
　　83 　　String temp;
　　84
　　85 　　while ((temp = reader.readLine()) != null) {
　　86
　　87 　　payLoad.append(temp);
　　88
　　89 　　}
　　90
　　91 　　//将SOAP请求封装成一个消息，发送到Queue。
　　92
　　93 　　Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
　　94
　　95 　　Message message = session.createTextMessage(payLoad.toString());
　　96
　　97 　　message.setBooleanProperty("isWsdl", false);
　　98
　　99 　　message.setJMSReplyTo(session.createTemporaryQueue());
　　100|||
　　101 　　session.createProducer(queue).send(message);
　　102
　　103 　　//等待回复，回复的消息中包含着服务端返回的SOAP响应。
　　104
　　105 　　String selector = String.format("JMSCorrelationID=‘%s‘", message.getJMSMessageID());
　　106
　　107 　　MessageConsumer consumer = session.createConsumer(message.getJMSReplyTo(), selector);
　　108
　　109 　　TextMessage replyMessage = (TextMessage) consumer.receive();
　　110
　　111 　　//将SOAP响应返回给客户端。
　　112
　　113 　　resp.getWriter().write(replyMessage.getText());
　　114
　　115 　　} catch (Exception e) {
　　116
　　117 　　e.printStackTrace();
　　118
　　119 　　}
　　120
　　121 　　}
　　122
　　123 　　}
　　接下来需要看一下Listener了。对于每一个Service都有一个Listener与之相对应，当一个Listener从Queue中取得一个消息之后，首先应该判断是否是WSDL请求。如果是WSDL请求，则向WebService发送一个GET请求，并将请求的结果，也就是WSDL封装成一个Message回复给Proxy。如果是SOAP请求，则从中取出SOAP请求部分并通过POST方法发送给Service，所得到的返回结果即为Service的SOAP响应，把它回复给Proxy，进而回复给客户端。
　　下面是Listener的一个简单实现，在这里我们使用了HttpClient来发送GET和POST请求。
　　1 　　public class Listener {
　　2
　　3 　　private ConnectionFactory factory;
　　4
　　5 　　private Connection connection;
　　6
　　7 　　private Queue queue;
　　8
　　9 　　private Session session;
　　10
　　11 　　public Listener() throws Exception {
　　12
　　13 　　//为了简单，还是采用了ActiveMQ。
　　14
　　15 　　factory = new ActiveMQConnectionFactory("vm://localhost");
　　16
　　17 　　connection = factory.createConnection();
　　18
　　19 　　connection.start();
　　20
　　21 　　queue = new ActiveMQQueue("testQueue");
　　22
　　23 　　session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
　　24
　　25 　　}
　　26
　　27 　　public void startUp() throws Exception {
　　28
　　29 　　MessageConsumer consumer = session.createConsumer(queue);
　　30
　　31 　　consumer.setMessageListener(new MessageListener() {
　　32
　　33 　　public void onMessage(Message message) {
　　34
　　35 　　try {
　　36
　　37 　　String response;
　　38
　　39 　　//通过判断isWSDL这个属性来判断是否是WSDL请求。
　　40
　　41 　　if (message.getBooleanProperty("isWsdl")) {
　　42
　　43 　　//如果是WSDL请求，则向服务器发送一个GET请求，并等待WSDL响应结果。
　　44
　　45 　　HttpClient client = new HttpClient();|||
　　46
　　47 　　//具体Service的地址，可以使用properties文件等。
　　48
　　49 　　GetMethod m = new GetMethod("http://localhost:8081/hello?wsdl");
　　50
　　51 　　client.executeMethod(m);
　　52
　　53 　　response = m.getResponseBodyAsString();
　　54
　　55 　　} else {
　　56
　　57 　　//如果是SOAP请求，则将SOAP包发送给服务器，并等待SOAP响应。
　　58
　　59 　　HttpClient client = new HttpClient();
　　60
　　61 　　PostMethod m = new PostMethod("http://localhost:8081/hello");
　　62
　　63 　　m.setRequestBody(((TextMessage) message).getText());
　　64
　　65 　　client.executeMethod(m);
　　66
　　67 　　response = m.getResponseBodyAsString();
　　68
　　69 　　}
　　70
　　71 　　//将WSDL响应或SOAP响应封装成一个消息，回复给Proxy。
　　72
　　73 　　MessageProducer producer = session.createProducer(message.getJMSReplyTo());
　　74
　　75 　　TextMessage replyMessage = session.createTextMessage(response);
　　76
　　77 　　//设置JMSCorrelationID，Proxy通过它来得到该回复消息。
　　78
　　79 　　replyMessage.setJMSCorrelationID(message.getJMSCorrelationID());
　　80
　　81 　　producer.send(replyMessage);
　　82
　　83 　　} catch (Exception ex) {
　　84
　　85 　　ex.printStackTrace();
　　86
　　87 　　}
　　88
　　89 　　}
　　90
　　91 　　});
　　92
　　93 　　}
　　94
　　95 　　}
　　三、还需要考虑的
　　1，如果其中一个Service崩溃，我们需要停止相应的Listener，这一点可以在Listener中做到，例如当Listener访问 Service时出错，它可以等待一段时间以后再去监听Queue，同时把已经取得的消息重新发回到Queue中去，以便让其他的Listener处理。当然也可以将Listener放置到Service端，这样Service崩溃，Listener也就跟着不可用了。
　　2，如果某一时刻，所有的Service都不可用，Proxy也不应该无限等待下去，而应该设置一个等待回复消息的超时期限，如果这个期限内没有收到回复消息，则表明Service都不可用，同时通知客户端。
　　3，过期消息的处理，如同上一点，当Service不可用时，Proxy通知客户端出错，但是此时Proxy已经向Queue中发送了一条消息，当Service恢复时，这条消息会被重新处理。我们应该避免这种情况发生，因为这条消息已经过期了。可以设置消息的过期期限小于Proxy等待回复消息的期限，以确保它不会被重新处理。
　　4，最糟糕的情况就是，Proxy或者Queue崩溃，这样就算Service正常，客户端也会调用失败。
　　5，效率，既然我们选择了WebService和负载均衡，那就表示我们应该接受它效率相对低下的弱点，在这里需要说明的是JMS并不是效率的瓶颈，因为Listener只负责拿到消息并发送给Service，这时Service还是运行在多线程下的。
（转载请注明出处：[url=http://www.6rfd.com]澳门博彩[/url]

hashCode就是我们所说的散列码，使用hashCode算法可以帮助我们进行高效率的查找，例如HashMap，说hashCode之前，先来看看Object类。

我们知道，Object类是java程序中所有类的直接或间接父类，处于类层次的最高点。在Object类里定义了很多我们常见的方法，包括我们要讲的hashCode方法，如下

Java代码  

1. public final native Class<?> getClass();  
2. public native int hashCode();  
3. public boolean equals(Object obj) {  
4.   return (this == obj);  
5. }   
6. public String toString() {  
7.  return getClass().getName() + "@" +  Integer.toHexString(hashCode());  
8. }  

注意到hashCode方法前面有个native的修饰符，这表示hashCode方法是由非java语言实现的，具体的方法实现在外部，返回内存对象的地址。

在java的很多类中都会重写equals和hashCode方法，这是为什么呢？最常见的String类，比如我定义两个字符相同的字符串，那么对它们进行比较时，我想要的结果应该是相等的，如果你不重写equals和hashCode方法，他们肯定是不会相等的，因为两个对象的内存地址不一样。

String类的重写的hashCode方法

Java代码  

1. public int hashCode() {  
2.     int h = hash;  
3.     if (h == 0) {  
4.         int off = offset;  
5.         char val[] = value;  
6.         int len = count;  
7.   
8.             for (int i = 0; i < len; i++) {  
9.                 h = 31*h + val[off++];  
10.             }  
11.             hash = h;  
12.         }  
13.         return h;  
14.     }  

1、这段代码究竟是什么意思？

其实这段代码是这个数学表达式的实现

Java代码  

1. s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]  

 s[i]是string的第i个字符，n是String的长度。那为什么这里用31，而不是其它数呢?《Effective Java》是这样说的：之所以选择31，是因为它是个奇素数，如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价于移位运算。使用素数的好处并不是很明显，但是习惯上都使用素数来计算散列结果。31有个很好的特性，就是用移位和减法来代替乘法，可以得到更好的性能：31*i==(i<<5)-i。现在的VM可以自动完成这种优化。

2、它返回的hashCode有什么特点呢？

可以看到，String类是用它的value值作为参数来计算hashCode的，也就是说，相同的value就一定会有相同的hashCode值。这点也很容易理解，因为value值相同，那么用equals比较也是相等的，equals方法比较相等，则hashCode一定相等。反过来不一定成立。它不保证相同的hashCode一定有相同的对象。

一个好的hash函数应该是这样的：为不相同的对象产生不相等的hashCode。

在理想情况下，hash函数应该把集合中不相等的实例均匀分布到所有可能的hashCode上，要想达到这种理想情形是非常困难的，至少java没有达到。因为我们可以看到，hashCode是非随机生成的，它有一定的规律，就是上面的数学等式，我们可以构造一些具有相同hashCode但value值不一样的，比如说：Aa和BB的hashCode是一样的。

说到这里，你可能会想，原来构造hash冲突那么简单啊，那我是不是可以对HashMap函数构造很多<key,value>不都一样，但具有相同的hashCode，这样的话可以把HashMap函数变成一条单向链表，运行时间由线性变为平方级呢？虽然HashMap重写的hashCode方法比String类的要复杂些，但理论上说是可以这么做的。这也是最近比较热门的Hash Collision DoS事件。

HashMap里重写的hashCode方法

Java代码  

1. public final int hashCode() {  
2.     return (key==null   ? 0 : key.hashCode()) ^  
3.             (value==null ? 0 : value.hashCode());  
   
4.  } 
   （转载请注明出处：[url=http://www.k8764.com]博彩通[/url]
   
   
   [url=http://www.5sfd.com]e世博[/url]）

由于工作需要，要在JS端将JSON对象转化为字符串，并写到用户的COOKIE中，用来保存用户的一些个人操作习惯。便在网上搜寻了一遍，发现方法有很多，有些代码不清晰，看得乱，有些考虑不周全，生成的字符串有问题，便整合了一些好的写法，自己改进了一下。可能还是考虑得不周全，但是感觉常用的类型都考虑了，望大家多多拍砖指点！

JSON.stringify(jsonobj)，本来是最简便的方法，可是存在浏览器兼容问题（仅适用于IE8+，Chrome 1+，FF 3+）。

var O2String = function (O) {
        //return JSON.stringify(jsonobj);

        var S = [];
        var J = "";
        if (Object.prototype.toString.apply(O) === '[object Array]') {
            for (var i = 0; i < O.length; i++)
                S.push(O2String(O[i]));
            J = '[' + S.join(',') + ']';
        }
        else if (Object.prototype.toString.apply(O) === '[object Date]') {
            J = "new Date(" + O.getTime() + ")";
        }
        else if (Object.prototype.toString.apply(O) === '[object RegExp]' || Object.prototype.toString.apply(O) === '[object Function]') {
            J = O.toString();
        }
        else if (Object.prototype.toString.apply(O) === '[object Object]') {
            for (var i in O) {
                O[i] = typeof (O[i]) == 'string' ? '"' + O[i] + '"' : (typeof (O[i]) === 'object' ? O2String(O[i]) : O[i]);
                S.push(i + ':' + O[i]);
            }
            J = '{' + S.join(',') + '}';
        }

        return J;
    };




/*-----------------------以下是测试代码-----------------------*/

var jsonStr = O2String(
                [
                    {
                        "Page": "plan",
                        "Custom":
                        [
                            {
                                "ItemName": "CustomLabel1",
                                "ItemContent": 1, 
                                "IsItem": true,
                                "ItemDate": new Date(1320774905467),
                                "ItemReg": /[\w]*?/gi,
                                "ItemFunc": function () { alert("ItemFunc"); }
                            },
                            {
                                "ItemName": "CustomLabel1",
                                "ItemContent": 1,
                                "IsItem": true,
                                "ItemDate": new Date(1320774905467),
                                "ItemReg": /[\w]*?/gi,
                                "ItemFunc": function () { alert("ItemFunc"); }
                            }
                        ]
                    },
                    {
                        "Page": "project",
                        "Custom":
                        [
                            {
                                "ItemName": "CustomLabel2",
                                "ItemContent": 2,
                                "IsItem": false,
                                "ItemDate": new Date(1320774905467),
                                "ItemReg": /[\w]*?/gi,
                                "ItemFunc": function () { alert("ItemFunc"); }
                            },
                            {
                                "ItemName": "CustomLabel2",
                                "ItemContent": 2,
                                "IsItem": false,
                                "ItemDate": new Date(1320774905467),
                                "ItemReg": /[\w]*?/gi,
                                "ItemFunc": function () { alert("ItemFunc"); }
                            }
                        ]
                    }
                ]
            );
            alert(jsonStr);
            var jsonObj = eval("(" + jsonStr + ")");
            alert(jsonObj.length);
（转载请注明出处：[url=http://www.tdtf.org]易博网
[/url]  [url=http://www.k5048.com]博彩网[/url]）

现象：
突然系统报警负载过高
下面的处理步骤：
1、找到占用cpu高的进程
select tc.sql_text,tb.machine from v$process ta,v$session tb,
v$sql tc
where ta.addr=tb.PADDR
and tb.SQL_HASH_VALUE=tc.HASH_VALUE
and ta.SPID=31128
2、找到进程执行的sql






可以看到使用的了索引跳跃扫描


查看
select * from table(dbms_xplan.display_cursor('7b0908u6wx1ab'));




从这个就可以看到进行了隐式转换导致index skip scan的选择性过低，导致负载急升
（转载请注明出处：[url=http://www.a9832.com]博彩网[/url]

[url=http://www.tswa.org]博彩通[/url]）

#include <windows.h>
#include <stdio.h>

LRESULT CALLBACK WinSunProc(//名字可以更改。参数类型不能变
HWND hwnd, // handle to window 窗口句柄
UINT uMsg, // message identifier 
WPARAM wParam, // first message parameter 消息参数
LPARAM lParam // second message parameter
);
/*
int WINAPI WinMain(
HINSTANCE hInstance, // handle to current instance
HINSTANCE hPrevInstance, // handle to previous instance
LPSTR lpCmdLine, // pointer to command line
int nCmdShow // show state of window
);

*/
int WINAPI WinMain(//Windows程序的入口函数
HINSTANCE hInstance, // handle to current instance 当前实例句柄
HINSTANCE hPrevInstance, // handle to previous instance 前次实例句柄
LPSTR lpCmdLine, // command line 命令行参数
int nCmdShow // show state 显示方式
)
{
/*
创建一个完整的窗口需要经过下面四个操作步骤：
1、设计一个窗口类；
2、注册窗口类；
3、创建窗口；
4、显示及更新窗口。

typedef struct _WNDCLASS { 
UINT style; //类的类型
WNDPROClpfnWndProc; //longpointfunction函数指针
int cbClsExtra; //类的附加内存
int cbWndExtra; //窗口附加内存
HANDLE hInstance; //实例号（句柄）
HICON hIcon; //图标句柄
HCURSOR hCursor; //光标句柄
HBRUSH hbrBackground; //画刷句柄
LPCTSTR lpszMenuName; //菜单的名字
LPCTSTR lpszClassName; //类的名字
} WNDCLASS; 
*/
//1、设计一个窗口类；
WNDCLASS wndcls;//窗口类
wndcls.style=CS_HREDRAW | CS_VREDRAW;//重画垂直方向、水平方向
wndcls.lpfnWndProc=WinSunProc;//函数地址
wndcls.cbClsExtra=0;//类的附加内存
wndcls.cbWndExtra=0;//窗口的附加内存
wndcls.hInstance=hInstance;//实例号
wndcls.hIcon=LoadIcon(NULL,IDI_ERROR);//图标 设置
wndcls.hCursor=LoadCursor(NULL,IDC_CROSS);//光标 设置
wndcls.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);//画刷的句柄
wndcls.lpszMenuName=NULL;//(菜单名字)
wndcls.lpszClassName="VCXTU";//注册类名（longpoint命令行参数）

//2、注册窗口类；
RegisterClass(&wndcls);//注册类

/*
HWND CreateWindow(
LPCTSTR lpClassName, // pointer to registered class name
LPCTSTR lpWindowName, // pointer to window name
DWORD dwStyle, // window style
int x, // horizontal position of window
int y, // vertical position of window
int nWidth, // window width
int nHeight, // window height
HWND hWndParent, // handle to parent or owner window
HMENU hMenu, // handle to menu or child-window identifier
HANDLE hInstance, // handle to application instance
LPVOID lpParam // pointer to window-creation data
);
*/
//3、创建窗口；
HWND hwnd;//窗口句柄
hwnd=CreateWindow(
"VCXTU",//注册类名（lpszClassName）
"湖南省湘潭市湘潭大学",//窗口名字
/*
WS_OVERLAPPEDWINDOW：
窗口风格 
WS_OVERLAPPED 层叠的 具有标题栏和边框
WS_CAPTION 有标题栏
WS_SYSMENU 带有系统菜单
WS_THICKFRAME 具有可调边框
WS_MINIMIZEBOX 具有最小化按钮
WS_MAXIMIZEBOX) 具有最大化按钮
*/
WS_OVERLAPPEDWINDOW,//窗口风格 
CW_USEDEFAULT,//窗口水平坐标(缺省的)
CW_USEDEFAULT,//窗口垂直坐标(缺省的)
600,//窗口宽度
400,//窗口高度
NULL,// 父窗口句柄(hWndParent/handle to parent or owner window)
NULL,// 菜单句柄(handle to menu or child-window identifier)
hInstance,//句柄(handle to application instance)
NULL//窗口参数(pointer to window-creation data)
);

/*
BOOL ShowWindow(
HWND hWnd, // handle to window
int nCmdShow // show state of window
);
*/
//4、显示及更新窗口。
ShowWindow(
hwnd,//窗口句柄
SW_SHOWNORMAL//显示状态 show state of window
);
UpdateWindow(hwnd);//可有可无

/*
操作系统将每个事件都包装成一个称为消息的结构体MSG来传递给应用程序
MSG结构定义如下： 
typedef struct tagMSG { 
HWND hwnd; 
UINT message;
WPARAM wParam;
LPARAM lParam;
DWORD time;
POINT pt;
} MSG; 
*/
//消息循环
MSG msg;
/*
BOOL GetMessage(
LPMSG lpMsg, // address of structure with message
HWND hWnd, // handle of window
UINT wMsgFilterMin, // first message
UINT wMsgFilterMax // last message
);
*/
while(
GetMessage(
&msg,
NULL,
0,//设成0。表示对所有消息都有兴趣
0
)
)
{
/*
转换消息。可以将WM_KEYUP/WM_KEYDOWN转换为WM_CHAR消息、产生新消息并放到队列中
BOOL TranslateMessage(
CONST MSG *lpMsg // address of structure with message
);
*/
TranslateMessage(&msg);
/*
将收到的消息传到窗口的回调函数：wndcls.lpfnWndProc=WinSunProc;回调函数：WinSunProc
LONG DispatchMessage(
CONST MSG *lpmsg // pointer to structure with message
);
*/
DispatchMessage(&msg);
}
return 0;
}

LRESULT CALLBACK WinSunProc(
HWND hwnd, // handle to window
UINT uMsg, // message identifier
WPARAM wParam, // first message parameter
LPARAM lParam // second message parameter
)
{
switch(uMsg)
{
case WM_CHAR://表示按下了某个字符按键
char szChar[20];
sprintf(szChar,"char is %d",wParam);//格式化消息。WM_CHAR中的wParam参数
/*
int MessageBox(
HWND hWnd, //拥有消息的父窗口 handle of owner window
LPCTSTR lpText, //文本 address of text in message box
LPCTSTR lpCaption, //标题 address of title of message box
UINT uType //消息框的风格 style of message box
);
*/
MessageBox(
hwnd,
szChar,
"湘潭大学",//标题
MB_OKCANCEL//MB_YESNO//消息框的风格
);
break;
case WM_LBUTTONDOWN:
MessageBox(hwnd,"鼠标左键点击了","湘潭大学",MB_OKCANCEL);
HDC hdc;//句柄 handle to device context
/*
HDC GetDC(
HWND hWnd // handle to a window
);
*/
hdc=GetDC(hwnd);
/*
BOOL TextOut(
HDC hdc, // handle to device context
int nXStart, // x-coordinate of starting position
int nYStart, // y-coordinate of starting position
LPCTSTR lpString, // pointer to string
int cbString // number of characters in string
); 
*/
TextOut(hdc,0,50,"湖南省湘潭市湘潭大学1",strlen("湖南省湘潭市湘潭大学1"));
ReleaseDC(hwnd,hdc);//释放DC
break;
case WM_PAINT://窗口重绘
HDC hDC;
PAINTSTRUCT ps;
/*
HDC BeginPaint(
HWND hwnd, // handle to window
LPPAINTSTRUCT lpPaint
// pointer to structure for paint information
);
*/
hDC=BeginPaint(hwnd,&ps);//只能在WM_PAINT里面使用
TextOut(hDC,0,0,"湖南省湘潭市湘潭大学hDC",strlen("湖南省湘潭市湘潭大学hDC"));
EndPaint(hwnd,&ps);//只能在WM_PAINT里面使用
break;
case WM_CLOSE://关闭窗口时响应
if(IDYES==MessageBox(hwnd,"是否真的结束？","湘潭大学",MB_YESNO))
{
DestroyWindow(hwnd);//销掉hwnd窗口 还会发送 WM_DESTROY、WM_NCDESTROY 消息
}
break;
case WM_DESTROY:
PostQuitMessage(0);//退出程序
break;
default:
return DefWindowProc(hwnd,uMsg,wParam,lParam);
}
return 0;
}
（转载请注明出处：[url=http://www.live588.org]淘金盈[/url]

1、查询v$sql视图
selectsql_id, sql_text, bind_data,HASH_VALUE from v$sql where sql_text Like '%select * from test where id1%';
它的记录频率受_cursor_bind_capture_interval 隐含参数控制，默认值900，表示每900秒记录一次绑定值，可以通过alter system set "_cursor_bind_capture_interval"=10;

此时查询到的data值得形式是这样的：BEDA0B2002004F8482D10065FFFF0F00000000000000000000C0021602C102C0021602C102F0018003691532303132303431313032504F443834363135313635F0018003691532303132303431313032504F443834363135313730F0018003691532303132303431313032504F443834363135313731F0018003691532303132303431313032504F443834363135313734F0018003691532303132303431313032504F443834363135313735F0018003691532303132303431313032504F443834363135313739F0018003691532303132303431313032504F443834363135313830F0018003691532303132303431313032504F443834363135313833F0018003691532303132303431313032504F443834363135313834F0018003691532303132303431313032504F443834363135313838F0018003691532303132303431313032504F443834363135313839F0018003691532303132303431313032504F443834363135313933F0018003691532303132303431313032504F443834363135313934F0018003691532303132303431313032504F443834363135313937F0018003691532303132303431313032504F443834363135313938F0018003691532303132303431313032504F443834363135323033F0018003691532303132303431313032504F443834363135323034F0018003691532303132303431313032504F443834363135323037
这样肯定是没法看懂的

需哟进行转换
select dbms_sqltune.extract_binds(bind_data) bind from v$sql WHERE SQL_TEXT LIKE '%FROM TEST11%';


2、查询SELECT VALUE_STRING FROM V$SQL_BIND_CAPTURE WHERE SQL_ID='abhf6n1xqgrr0';
通过v$sql_bind_capture视图，可以查看绑定变量，但是这个视图不太给力，只能捕获最后一次记录的绑定变量值。

而且两次捕获的间隔有一个隐含参数控制。默认是900秒，才会重新开始捕获。在900内，绑定变量值的改变不会反应在这个视图中。

10G以后可以通过如下方法查看AWR报告里记录的SQL的绑定变量值。

select snap_id, name, position, value_string,last_captured,WAS_CAPTUREDfrom dba_hist_sqlbind where sql_id = '576c1s91gua19' and snap_id='20433';

----------SNAP_ID就是AWR报告的快照ID。

----------name,绑定变量的名称

----------position，绑定值在SQL语句中的位置，以1，2，3进行标注

---------value_string，就是绑定变量值

---------,last_captured，最后捕获到的时间

---------WAS_CAPTURED，是否绑定被捕获，where子句前面的绑定不进行捕获。

dba_hist_sqlbind视图强大的地方在于，它记录了每个AWR报告里的SQL的绑定变量值，当然这个绑定变量值也是AWR生成的时候从v$sql_bind_capture采样获得的。

通过这个视图，我们能够获得比较多的绑定变量值，对于我们排查问题，这些值一般足够了。

还有一个需要注意的地方是，这两个视图中记录的绑定变量只对where条件后面的绑定进行捕获，这点需要使用的时候注意。

DBA_HIST_SQLBIND是视图V$SQL_BIND_CAPTURE历史快照

“软件编程中最重要的操作之一在于判断俩个变量是不是相同” - 来自Nicholas Zakas的书JavaScript for Web Developers.

换句话说，可能在你的编程中，你可能用过这些代码片段吧：

if (x == y) {
     // do something here
 }

或者你使用最佳实践方式：

if (x === y) {
     // do something here
 }

以上代码片段中不同的地方在于第二个例子使用了“===”操作符，也叫“严格等于”或者“绝对等于”。

对于Javascript新手来说呢，什么时候使用双等于号，或者什么时候使用三等于号确实有点儿迷糊。这里今天这篇文章我们将帮助大家了解这背后的故事。

有没有区别？

使用双等于号操作符的话，如果两者相等的话，结果会返回true。但是大家要注意：如果是不同类型的变量比较的话，变量强制变换就会发生。当然，这也是javascript语法的特点之一。

每 一个javascript的变量都属于一个指定的类型。例如，数字，boolean，功能和对象。如果你比较一个字符串和数字，浏览器就会在比较之前将字 符串强制的转化为数字。同样，如果你将true或者false和数字比较的话。true和false会被强制转化为数字1或者0。

这将会带来不可预知的结果，如下：

console.log(99 == "99"); // true
 console.log(0 == false); // true

当然，以上例子非常不错，因为浏览器将帮助你自动转化，省了你不少劲儿。但是这有可能出错，如下：

console.log(' \n\n\n' == 0); // true
 console.log(' ' == 0); // true

因为如上原因，javascript的高手都推荐你使用“===”来执行等于操作。永远不要使用“==”。

“===”永远不执行类型转化。因为你使用它来执行等于操作非常安全。

以下例子将都产生正确的结果：

console.log(99 === "99"); // false
console.log(0 === false); // false
console.log(' \n\n\n' === 0); // false
console.log(' ' === 0); // false

不等于如何操作呢？

类似，只不过这里我们使用“!==”来执行。如下：

console.log(99 !== "99"); // true
console.log(0 !== false); // true
console.log(' \n\n\n' !== 0); // true
console.log(' ' !== 0); // true
（转载请注明出处：[url=http://www.k8764.com]博彩通[/url] 
 [url=http://www.5sfd.com]e世博[/url]）

1. 创建一个嵌套的过滤器

.filter(":not(:has(.selected))") //去掉所有不包含class为.selected的元素 

2. 重用你的元素查询

var allItems = $("div.item");   var keepList = $("div#container1 div.item");  <div>class names:  $(formToLookAt + " input:checked").each(function() {     keepListkeepList = keepList.filter("." + $(this).attr("name")); }); </div> 

3. 使用has()来判断一个元素是否包含特定的class或者元素

//jQuery 1.4.* includes support for the has method. This method will find   //if a an element contains a certain other element class or whatever it is   //you are looking for and do anything you want to them.  $("input").has(".email").addClass("email_icon"); 

4. 使用jQuery切换样式

//Look for the media-type you wish to switch then set the href to your new style sheet   $('link[media='screen']').attr('href', 'Alternative.css');   

5. 限制选择的区域

//Where possible, pre-fix your class names with a tag name   //so that jQuery doesn't have to spend more time searching   //for the element you're after. Also remember that anything   //you can do to be more specific about where the element is   //on your page will cut down on execution/search times   var in_stock = $('#shopping_cart_items input.is_in_stock'); 

<ul id="shopping_cart_items">   <li>   <input value="Item-X" name="item" class="is_in_stock" type="radio"> Item X</li>   <li>   <input value="Item-Y" name="item" class="3-5_days" type="radio"> Item Y</li>   <li>   <input value="Item-Z" name="item" class="unknown" type="radio"> Item Z</li>   </ul>  

6. 如何正确使用ToggleClass

//Toggle class allows you to add or remove a class   //from an element depending on the presence of that   //class. Where some developers would use:   a.hasClass('blueButton') ? a.removeClass('blueButton') : a.addClass('blueButton');   //toggleClass allows you to easily do this using   a.toggleClass('blueButton');  

7. 设置IE指定的功能

if ($.browser.msie) { // Internet Explorer is a sadist. }  

8. 使用jQuery来替换一个元素

$('#thatdiv').replaceWith('fnuh'); 

9. 验证一个元素是否为空

if ($('#keks').html()) { //Nothing found ;}   

10. 在无序的set中查找一个元素的索引

$("ul > li").click(function () {       var index = $(this).prevAll().length;   }); 

11. 绑定一个函数到一个事件

$('#foo').bind('click', function() {     alert('User clicked on "foo."');   });  

12. 添加HTML到一个元素

$('#lal').append('sometext'); 

13. 创建元素时使用对象来定义属性

var e = $("", { href: "#", class: "a-class another-class", title: "..." }); 

14. 使用过滤器过滤多属性

//This precision-based approached can be useful when you use   //lots of similar input elements which have different types   var elements = $('#someid input[type=sometype][value=somevalue]').get();  

15. 使用jQuery预加载图片

jQuery.preloadImages = function() { for(var i = 0; i').attr('src', arguments[i]); } };   // Usage $.preloadImages('image1.gif', '/path/to/image2.png', 'some/image3.jpg');    

16. 设置任何匹配一个选择器的事件处理程序

$('button.someClass').live('click', someFunction);   //Note that in jQuery 1.4.2, the delegate and undelegate options have been   //introduced to replace live as they offer better support for context     //For example, in terms of a table where before you would use..   // .live()   $("table").each(function(){     $("td", this).live("hover", function(){     $(this).toggleClass("hover");     });   });   //Now use..   $("table").delegate("td", "hover", function(){   $(this).toggleClass("hover"); }); 

17. 找到被选择到的选项(option)元素

$('#someElement').find('option:selected'); 

18. 隐藏包含特定值的元素

$("p.value:contains('thetextvalue')").hide(); 

19. 自动的滚动到页面特定区域

jQuery.fn.autoscroll = function(selector) {   $('html,body').animate(     {scrollTop: $(selector).offset().top},     500   ); } //Then to scroll to the class/area you wish to get to like this: $('.area_name').autoscroll(); 

20. 检测各种浏览器

Detect Safari (if( $.browser.safari)), Detect IE6 and over (if ($.browser.msie && $.browser.version > 6 )), Detect IE6 and below (if ($.browser.msie && $.browser.version <= 6 )), Detect FireFox 2 and above (if ($.browser.mozilla && $.browser.version >= '1.8' )) 

21. 替换字符串中的单词

var el = $('#id'); el.html(el.html().replace(/word/ig, '')); 

22. 关闭右键的菜单

$(document).bind('contextmenu',function(e){ return false; }); 

23. 定义一个定制的选择器

$.expr[':'].mycustomselector = function(element, index, meta, stack){ // element- is a DOM element // index - the current loop index in stack // meta - meta data about your selector // stack - stack of all elements to loop // Return true to include current element // Return false to explude current element }; // Custom Selector usage: $('.someClasses:test').doSomething(); 

24. 判断一个元素是否存在

if ($('#someDiv').length) {//hooray!!! it exists...} 

25. 使用jQuery判断鼠标的左右键点击

$("#someelement").live('click', function(e) {     if( (!$.browser.msie && e.button == 0) || ($.browser.msie && e.button == 1) ) {         alert("Left Mouse Button Clicked");     }     else if(e.button == 2)         alert("Right Mouse Button Clicked"); });
(转载请出处：[url=http://www.a9832.com]博彩网[/url]  
[url=http://www.tswa.org]博彩通[/url])

项目经理的“势能”培养

我很早之前就听说过，做为一个项目经理，至少要在公司工作两年以上，且年龄不小于三十岁。我当时还年轻，对这两点很不屑。而现在，我却很理解。在公司工作时间短，对人员不熟悉，将很难横向协调资源；年纪过轻则不够沉稳、练达，难以实现快速沟通。

作为IT企业，很多项目经理都是由基层做起的，技术好、经验丰富、熟悉行业知识。作为项目经理本人，也觉得自己对团队的领导能力勿庸置疑。并不会认为自己沟通上会有问题。在这里，我也不想讲什么大道理，只举例子、讲故事。

举一个例子。

去财务报帐，出纳说票贴的不对，公司财务制度上要求餐费与交通费分开贴，退回来重贴。贴完让出纳整好单子，找老总签字，老总出去了，没办法，只好到明天。而到明天，老总回来，自己却要出差了。

好不容易等老总签了字，拿到财务室，出纳说，财务上没有钱，票先放这里，等两天吧。一拖好几天，票压一堆报不了，项目中各项开销还得支出，严重影响工作情绪。这里要说明一下，财务上没有现金是很正常的，当然也不是完全没有，还是要留一些费用应对日常开销的，至于给不给你，就看财务的心情了。

如果换一个场景。

发票拿到财务室，出纳一看不合格，直接开涮：“你怎么搞的呀，刚公布的财务制度都没看吗，整天忙啥哩？算了，算了，放这吧，反正老总不在，等会儿还是我整一下吧，指望你干这活也没指望。你该干啥干啥去吧，下一回再这样我就给你扔出去。”

过两天，财务电话过来：“你的钱还要不要呀？公司有回款了，要拿钱的赶紧啦。”然后项目经理直接到财务签字拿钱，发票老总已经签过字，整个流程出纳都帮做了。

一个空降的项目经理与一个老员工项目经理，在协调资源时，差别是很明显的。

为什么空降的项目经理不能很好的协调资源。因为他跟同事不熟悉，他的团队会很支持他，其它人员则不一定。人家只给你照章办事，或许不会影响你工作，但同样不会推动你的工作。

而老员工项目经理，与各部门人员都很熟悉，老总也很信任他。这样处理工作就比较顺利，例如前面说的，出纳帮助你贴票，然后替你拿到老总那里，老总出于对项目经理与出纳的信任，就直接把字签了。项目经理出差回来签字就能领钱，效率高多了。

再举一个例子。

项目临近结束，各个功能都差不多要做完了，项目完成进度也被标到90%。而项目经理心里很清楚，后面的修修补补，测试、调整会占用大量时间。公司项目管理不够完善，很多隐性的东西都无法显现出来。而客户此时又提出了一些新的要求，急切要完成。

如果告诉老总说，现在还需增加三个月的工作时间，老总肯定不同意，因为既然都完成90%了，剩下的工作还不加把劲在两星期内搞定，竟然还要增加三个月，挨批是难免的。如果给客户说，实在没有精力做新功能，客户要挟说，不做就不验收。

项目经理谁也不敢得罪，心里明白问题关键，却不知道该如何说服别人。只有硬着头皮往下做。结果项目延期，质量下降，勉强验收了，还有一大堆问题。最主要是因为工作强度加大，加班加点，透支团队成员工作激情，项目最终结束后，大批成员离职。

而如果项目经理换种思路。首先向团队成员灌输“行百里者半九十”，越到后面，繁杂琐事越多，越不能放松冲刺。要尽可能保持成员的工作积极性。一方面，向公司说明情况，通过项目管理的知识来讲解问题的具体原因，尤其是项目收尾管理，并不是代码写完就是项目结束，还有很多事情要做。总之，摆事实讲道理，积极向公司申请资源，尤其是宽限项目时间（此时单独强调增加开发人手并不明智）。

再一方面，与客户方负责人沟通，甚至私人宴请以促进感情。尽可能把一些新功能放到项目运营维护中来实现，或是项目二期中实现。如果客户仍然坚持，则最好说服他降低质量要求，在验收时放自己一马。向其承诺，在运维中提升质量。

整个情况要向团队成员说明，争取成员的理解与支持。也要向公司说明情况，尽可能多申请些额外福利。

从这个例子中可以看出，项目经理所做的工作，都不是“高科技”的，非技术的却又是重要的。针对不同对象，例如团队成员、公司高层、客户方负责人等，分析利害与关注点，权衡利益，各个击破。

一个年轻的项目经理与一个老成的项目经理，在处理这些事情时，风格会大不相同。就像上个例子，客户方负责人一般也不会太年轻，三十来岁才会担当个负责人，如果项目经理太年轻，阅历浅薄，则不太容易与对方平等交流。即便他明白道理，也很难影响他人支持自己工作。

讲一个故事

很多年前，我还年少的时候，喜欢下象棋，在学校里基本上我能下赢的，我总能下赢，我下不赢的，总也下不赢。不得其解，也慢慢懒得操练了。

后来有次学校搞业余活动，有个老师是省象棋协会的，组织了一节棋课。我去晚了，只听了半节。大致意思是讲，下棋要讲全局观，要有战略，例如中局五种策略，中局成杀、不成杀则优、不占优占先、不占先则多子、不多子则求和。还有什么炮破士、马破相、残局炮归家等等。却没有讲如何下棋，课堂上也没有摆个象棋，或是什么棋谱。

我并没有把这些当回事儿，之后也很少下棋。

又过多年，毕业后同学聚一起，闲来无事，与一个同学下了两盘。刚开始，他问我这两年有没有下棋，我说没有。他调侃我，“那你以前下不赢我，今天你也难赢了”。我也笑着认同，反正只是玩玩，何必认真。

可是一开局，他就傻眼了，一直处在下风，且每局必输。他很吃惊，我也很吃惊。之后我认真思考了这件事，觉得是那节棋课影响了我，人的思考能力、计算能力都差不多，而思维方式不同，结果也会有很大不同。他看到的是“棋”，我看到的是“局”。决定胜败的不是棋艺。

又过了几年，我已经不再年少，但还算年轻吧。有一次找一个朋友玩，正好他的一个朋友也在，吃完饭没事儿做，恰巧有副象棋，就与他的朋友下了几局。他们都比我年龄大，已经三十多岁了。不过我也没有放在眼里，自以为水平相当可以，三局我两胜，颇为自得。

等他走后，我朋友问我：“他水平怎么样呀？”我带着些“谦虚”，洋洋自得：“他水平挺可以的，我差点就输了，还好我三局两胜，略胜那么一点点。”

我朋友听完哈哈大笑：“你知道他是干吗的吗？他是卖保险的。卖保险的吗，任何人都可能是他的潜在客户，他自然不会去赢你，不光让你赢，还要让你赢得有面子，这才是高手。他原来是在象棋协会的，论象棋，那叫牛×死了。”

我听完之后，惭愧至极。我关注的是“棋局”，人家所关注的，则超脱棋局之外。眼界不一样，看到的也不一样，操控点也不一样，输赢已经不重要，重要的是输与赢，哪个更有利于自己，然后才是“如何去输”与“如何去赢”。棋局只是一个棋子。决定成败的不是棋艺。

我讲这个故事，是想说明，一个项目经理，对自己操作的项目要有全局观；而且，视角不能仅限于项目本身。明确自身定位，了解外部环境，才能最大成度影响到整个“局”中的各个元素，而这个影响力，就叫“势”。可以这么说，你明确的势力范围，可以只是你的团队，但你的影响力却不能仅限于团队本身。

做到这些，容易吗？当然不容易。如文章开头所说，“做为一个项目经理，至少要在公司工作两年以上，且年龄不小于三十岁。”这样，才有可能会做得好一些。
(转载请注明出处：[url=http://www.a9832.com]博彩网[/url]
[url=http://www.tswa.org]博彩通[/url])

 网站通常都是由很多非专业网站运营专员在管理和打理，由于他们的专业知识和综合技能都不合格，所以导致没有科学的网站运营管理。

      下面就列出网站运营专员的网站运营管理七宗罪（看名字感觉是陈腔滥调但是我想内容还是非常具有意义的，要不然我也不会写出来作为自己以后巩固和回忆的博文了）：

       第一，使用开源程序和第三方插件，导致网站出现诸多安全漏洞，由于专业知识不够，并不能察觉和防范这些网站存在的安全漏洞，可能当网站比较有商业价值的时候，你的竞争对手或者无聊的黑客们就把你网站当成了练手靶子。

      第二，服务器的组件长期不升级更新，如PHP、MYSQL、第三方组件。

      第三，服务器密码和数据库密码、网站后台密码过于简单，或者很少更改新的密码，网站密码备份在网络里或者主机的电脑里面，网络密码涉及到自己的生日电话号码等容易被猜测到的数字或者字母，网站用户名和密码和网络上自己经常使用的用户名和密码是一致的，这些都是影响网站安全的因素，如果你还有支付宝、网银等涉及到主机人身财产等帐号和密码都要善于管理和维护更新，不可偷懒。

      第四，程序的代码不够严谨，造成诸多的网站漏洞或者执行超时引起用户反感。所以作为一个网站运营人员可以不要求任何语言的代码都要懂，但是开发逻辑和安全方面都要有一定的了解。主要漏洞是在用户提交信息，如注册和上传文件、上传图片等。

      第五，数据库安全管理方便不够完善，在开发的过程中没有考虑到数据库安全，如数据库名称和密码没有经过加密，数据库没有独立的控制权，如虚拟空间的数据库，其代理商和管理员都可以随便查看你的数据库资料，如果公司网站涉及到很多客户资料等信息是非常不安全的。其实是程序开发是否防SQL注入，这些都是最基本的技术了。

      第六，服务器密码知道的人太多了，防火墙阻碍最好不要关闭。然后就是阻止其他不相关人员访问服务器上面的资源。加强服务器的管理和维护，时常查看服务器的登录日志，让你了解服务器最近的状况和应该怎么修复或者维护。

      第七，从不记录服务器管理日志，导致服务器出现问题不知道该从何查起。老莫觉得其实无论是维护服务器还是网站开发、网站维护都需要记录操作步骤和过程，当网站或者服务器出现问题的时候，我们就能够好的排查和检测，对具体问题进行修改。

      所以对于网站运营管理要求也是非常的高，这就要求网站运营专员要有足够强的网站运营管理知识。
（转载请注明出处：[url=http://www.live588.org]淘金盈[/url]

“谁也无法改变现状，唯有无数程序员血洒大地，才能使项目重建天日。”这一点也不夸张，软件项目做烂了就是个坑，参与者也不过是填坑的。就像是在魔兽世界战场遇到国家队一样，你赢也赢不了，出也出不去。

一 坑有多深？

　　当我们进入一个项目时，通过不断观察我们可以发现我们的项目到底是不是一个坑。造坑的项目，往往具有某些“臭味”，以下是我的一些认识，这些“臭味”即是项目健康状态不佳的明显标志：

• 编码规范形同废纸，代码质量低下 每个项目都有编码规范，但真正严格实施却是另一回事。太多的项目把编码规范作为形式的存在，没人在乎让开发人员写出“人能读懂的程序”，注释和命名也成了开发人员的随心所欲。project上永远只有开发任务，而几乎找不到单元测试的时间和代码审查的时间。在高压进度之下的项目，显得如此山寨。当我们还在抱怨自己工资低的时候，就先看看我们的程序还能称作OOP吗。
• 缺乏文档或文档质量低下 前期文档很重要，不论是框架的API使用手册，还是需求或设计文档，以及各种既定流程的规范，不同种类的模板及核对表，等等这些文档，对于项目来说都是非常重要的资源。而往往有些项目，这类文档就是交由非软件行业的人员来编写，或者前期根本不打算在文档上浪费时间。这就导致了，缺少相关文档或文档质量低下，在软件构建过程中，开发者和团队，不得不为这种“表面工程”的产物而纠结。甚至会退回到前期准备工作，完成所需的文档。有些文档可以在后期补，但有些必须在前期进行准备，以保住团队降低风险，减少缺陷引人的几率并提高编码质量，如果前期这类文档没有做好，那么就会像考前不复习一样，自食恶果。
• 无尽的需求变更，永远追不上的进度 这是最常见也是最可怕的，因为无论怎样，我们都无法完成它。客户可能认为改个程序，就像改个Excel一样简单省事，甚至会使用可动用的一切权利和资源来推行变更。好吧，我承认这样的客户我遇到过很多。当我向客户解释过变更的代价并提供备选方案后，也就只能等待客户的选择了，这多少有些运数的成分，但也是无奈之举。
• 仅仅靠加班应对进度落后 进度落后并不可怕，可怕的是仅靠加班来追赶进度。这是问题的关键，长时间的赶工仍然无法赶上进度，这只意味着项目有某种更深层次的问题，已经不是单开赶工可以解决的了。留意那些长时间加班的项目，他们往往在管理上存在很大问题，发现这些问题，在你成为PM时，不要犯类似错误。
• 沟通无门 如果你在一个“叫天天不应，叫地地不灵”的项目里，那你最好省心吧。项目中沟通很重要，但总有些项目，领导的工作太忙，人就是找不到，发出去的邮件就是没人回，遇到问题就是自己扛。在这样的项目里也有一些好处，比如锻炼自己的自学能力，以及磨练意志与根性。不过这些，也都是我的自嘲。低效的沟通将导致不必要的返工，这才是我所痛恨之处。我最为恼火的一段经历是，甲方要进行变更，开了一周的会没人通知我，我的小组在这一周里完成了原计划的数个需求并进入到测试阶段， 但这些需求均被砍掉 。本来只有甲方告知是可以调整进度开发其它模块的，但最终演变为资源的浪费。可见，沟通是多么的重要。
• 没人关心质量 因为软件构建属于专业领域，客户并不具备相应领域的知识，由于这种信息不对称，助长了软件的质量低下。我们开发的软件可以是“低等级高质量”的，但不能够是“高等级低质量”的。但是，太多的项目不在注重编码质量，这与软件构建的复杂度有关，也与整个行业的风气有关。但不管何种原因，提高代码质量仍然应该作为团队的努力方向。团队应该奖励那些，编写高质量代码的程序员。如果你的团队奖励的是那些，“BUG杀手”（每天修改上百个BUG），而冷落那些缺陷检出数量很低的程序员，那么，你的PM是个不懂技术的，至少我本人认为，任何有技术背景的PM都应该奖励那些正在保持职业操守，认真对待需求，保证代码质量的程序员。他们为项目付出了更多，更多的异常处理， 更多的测试调试，更多的检查，更多的重构，虽然他们的进度并不快，但他们引人的缺陷数量很少。每个做过开发的人都会在质量和进度上做出取舍，而我敬佩那些选择质量程序员，因为他们才是真正拿开发当事业的人。在此，向所有努力提高代码质量的程序员致敬！
• 没人为缺陷买单 没人为自己的成果负责。需求产出了低质量的文档，设计没有进行充分的迭代，开发可以怎么简单怎么写，测试可以随意测测，没人为自己的成果中的缺陷买单，除了项目经理，他为项目承担唯一责任。当项目组所有人员都在混时，就是在给自己挖坑。这种缺陷的堆积，会像放射性元素在食物链中的堆积一样，早晚项目会因此而崩溃。
• 过高的离职率 这个是最明显的“臭味”，这说明我们的同行已经在这里无法忍受了。它所带来的恶略影响不光体现在可用资源的减少，还体现在对成员士气的极大影响。如果不及时改善，这将是一个非常恶性的循环，当往一个进度落后的项目中添加资源只会使进度进一步落后，而非正离职导致必须补充新的资源，资源从入职到培训都会对对团队产生震荡，并降低现行团队的生产力。一个频繁处于形成阶段的团队，很难要求其有什么凝聚力，团队问题将会凸显，尤其是在沟通上，在项目忙的时候很少能照顾到新人。花费在对新人进行培训，和与其沟通上的时间，很可能得不偿失。
• 团队中的不良情绪 不同团队开始扎堆并相互敌视，例如开发组认为设计组是一帮搞业务的白痴，根本不懂编程；测试组认为开发组的人就是垃圾，BUG提交了多少便还是无法关闭；PM开始抱怨，自己的成员不配合；成员开始抱怨，PM是个纯管理没资格指挥内行做事。等等，诸如此类的怨念会在团队中积累，并以某个导火索为契机爆发。面对现实吧，至少，我远没有自己想象的那样高尚。我承认我曾经会和别的程序员说：“你看XX他们写的代码...什么呀...”，这样的话。在过去我也吐槽过别人代码，这种做法是错误的，我为此表示歉意。现在，如果有必要，我会说代码有缺陷，但绝不会说他的代码不好。我希望，我们能彼此尊重。对于技术人来说，不尊重他的成果就是不尊重他的人，所以我还是建议PM在管理工作中，多用“缺陷”，少用“不行”、“不对”。但是，项目中也总是有些人，靠鄙视别人的成果来彰显自己的实力。这些人，有，但很少。至少我遇到的很少，遇到过几个，让他们的话语成为你学习的动力吧。我曾经被人讽刺UI做的太丑，之后我学会了SL和FLEX；被人鄙视基础太差，之后开始阅读《CLR Via C#》；我朋友被人嘲笑过数据库设计，现在人家也开始买书深造。团队中就是这样，我们无法管住别人的嘴，但我们可以管住自己的。少说多听，一鸣惊人，乃上上之策。不要受情绪的影响，保持一个平静的心。
• 没有项目或阶段的后评价 不对项目的阶段进行后评价，也意味着没人在乎你到底干了些什么，所有人都只是进度是否完成，而没有对完成的好坏进行评价。这也意味了，仅靠做好你的工作，你是无法得到领导的重视的。最终只有那些加班时间最长的程序员被领导认可。而能力强，口碑好的成员也只能在团队和客户中间留下传说。

二 谁在造坑？

　　软件项目涉众众多，造坑的多为项目实施团队内部，而究其原因也是多方面的，但是始终离不了项目的四个维度——时间、范围、成本、质量。很多时候客户并不具备软件项目的实施经验，而实施团队为了迎合客户意愿，也会多多少少的在这四了维度上做文章。资源、时间不足，轻质量重功能，往往成为造坑的契机。所以，不用怀疑，造坑的往往是我们自己。很难理解，真正挖出大坑的人，最后也是填坑的人。一个人很容易被外部事务所左右，就如“同假的多了，真的到成假的了一样”，多数人不愿意在一个新环境中表现得特立独行。但也有老的程序员对我说过：“当别人做错了，你就不要跟着去做！”所以，我认为工作就是工作，不需要我们在其中融合多少兴趣，也不要求我们有过多的付出，但对于工作的成果则要求我们认真的对待。俗话说：“拿多少钱，办多少事！”如果多少有些团队意识，能够对自己的工作负责，那至少在意识上，我们能给自己少造些坑。

三 如何免坑？

（一） 清除盲区

　　以下观点，仅是我对软件项目中一些错误认识的归纳：

• 写出能用的程序就行啦！ 我们应该首先清楚我们做的是什么，一个成熟的团队产出的可交付成果应该包括软件编程产品，相关文档，项目实施过程中的经验教训已经其它一些非形式的成果（培训）。这里，我们必须清楚的认识到，我们所开发是是编程产品，而不是我们个人的技术实践或大学的毕设。对于编程产品，我们必须认识到，其是产品级别的，必须保证质量，必须提高用户体验，必须考虑系统的诸多特性或维度。这一过程远比我们自己写个程序要复杂的多。设计需要不断地进行迭代；开发人员需要遵守严苛的规范，编写大量的注释和大量的异常处理；测试人员需要不断地进行各种重复测试，但是正是这种全局的规范，全体团队的不懈努力，才保证了我们的编程产物可以称之为产品。所以，一定要明确，我们要完成的是一个产品，而不是一个毕业设计，它不是一个人的技术实践，而是整个团队倾注精力去完成的最佳成果。我们可以轻松的实现客户的某些需求，但需求背后的某些东西，需要我们认真对待，比如安全性和性能等。实现功能的程序谁都会写，而写出高质量的程序的才是真正的艺术。
• 尽快开始编码吧 ！ 软件构件是一个精心设计的过程，其前期准备十分重要。在后期修复缺陷的成本要远远高于前期。因此，在项目执行前，前期的规化十分必要。在前期每发现一个缺陷，都会为后期节省大量的成本。
• 需求怎么变了！ 没有不变的需求。
• 进度落后了就招人呗！ 这是种典型的错误认识，《人月神话》中已经说明的很清楚了——往一个进度落后的项目中注入资源，只会使进度进一步落后。虽然，这本著作成为PM必读之作，其思想也被业界所广泛认可，但是，还是会有很多管理者单纯的认为，通过注入资源能解决问题。对于这些人，只能让实践来检验真理了。
• 软件质量保证是测试的工作！这是一种逃避责任的说辞。如果把代码质量比喻为减肥，那么测试无疑是一个磅秤，减肥工作还是要有开发人员来完成。所以，不要将代码质量都寄希望于测试工作上。即使是大规模的用户测试，其错误检出率也不足五成。而真正挑起代码质量重担的是代码审查。
• 程序员你8小时就写了这么点代码？ 让开发人员将全部时间都花在编码上是不可能的。开发人员需要时间预读文档，需要与相关干系人进行沟通，需要花时间来搜索资源。此外，可能还需要编写文档，参加会议，培训以及处理个人事务等等。这些时间都会无情的夺走编码的时间。程序员大约有近似20%的时间甚至更多会用在与编码无关的事情上（不算上班或聊QQ），所以不要错误的以为每个程序员每天能写8小时的程序。
• 你今天写了这么多行代码真有效率！ 编码不是在扫地，比谁扫的面积大。不能单纯用行数来评价开发人员的工作量。评判的标准应该结合模块的复杂度，编码的缺陷检出量以及最终交付时可用代码的比例（实践表明，我们报废了大量的无用代码）。
• 他今天把自己100多个BUG都改了，我们得在组里表扬下他！ 在我看来这样的领导不跟也罢，这就是让人相当无语的行为。好的开发者在提交测试前，觉得会对自己的代码进行走查和调试，甚至使用单元测试工具，因此其代码的缺陷检出量很小。这样的程序员，才值得被表扬。而那个一天改了自己100多个BUG的人，作为管理者应该想想，流程哪里错了，需要进行改进。
• 设计我来定，开发你闭嘴！ 这样的例子也不少，这种做法有一种听起来非常合理的理由——保证项目架构的概念完整性。其解释为，如果将设计人员从开发人员剥离，那么就可以将架构的概念完整性统一，因为设计人员的数量比开发人员是数量要少的多，更容易统一认识。而这样做的项目组，也默认地认为设计组的技术实力要明显高于开发组。他们往往从开发组中选择优秀的设计人员到设计组，但也会有走眼的时候。其一，硬手没有被提拔。这时候多半是硬手对设计不满，并对团队管理层产生质疑，并想法设法进行沟通。如果处理的好，可能硬手会被重视，如果沟通无门，那之后，可能会充斥着抱怨和不满，以及人际关系的恶化。有些强硬些的可能会选择拒绝不合理的设计或更为极端的是离职。走眼的另一种情况是，挑的人干不了设计。这样往往就是让他锻炼，而不是撤换（彼得原理——每个人都会被晋升到他不适合的岗位）。这就郁闷到极点了，设计者将会与相应的数名开发人员进行一场旷日持久的暗战。其中，已经不只是个人的抱怨，甚至会演变成成员集体的士气低落，并最终促成小组的重组。我认为，有必要将开发人员纳入设计活动。应该参考开发人员的意见，其原因有三：其一，开发人员对实现相当熟悉，往往发现设计中的不足；其二，通过授权开发者参与设计，能让其感受到认同感，提升其参与项目的欲望，和责任心；其三，让开发参与设计，可以对设计人员进行储备，在需要时作为备选资源使用。
• 客户（领导）说必须完成，我也没办法！ 这就是“领导一句话，劳动人民跑断腿！”这是非常典型的加班借口。软件构建过程如同耕种，你每次只处理它的一小部分，一点一点的加到整个系统，使系统一点一点的“生长”。这也暗示了，工作应该按部就班，正如春种秋收一样，各个环节有强硬的逻辑存在。所以，我们必须学会对不合理的要求说“不”。这里并不是说要拒绝客户的需求，而是指应该向客户说明情况并提出相应的备选方案以供参考。例如通过通过削减范围来达到按时完工的目的。PM需要向客户说明情况，并向其提供几套可行的解决方案，以促成项目向良性发展。
• 我是领导我来排进度！ 工作进度的安排不能是领导的单方决策，而应该参考做了解这项工作的人的意见。
• 系统上线了，项目就算结束了！ 只有当可交付成果成功移交，项目进行的相应的收尾工作，项目的经验教训文档被总结和归纳，一个项目才算真正意义上的完成。

（二） 参考建议

• 做好前期准备 前期准备很重要，如果在开始构建之前认真的地进行适当的准备活动，那么项目会运作的良好。充足的准备防止我们制造一个错误的产品。前期工作的好坏，多少会为这个项目的成功和失败打下基础。即使进入构建阶段，如果我们发现前期工作做的不好，也完全有理由退回去。前期准备工作和核心目标就是降低风险——一个好的项目规划者能够尽可能早地将主要的风险清除掉，以使项目的大部分工作能够尽可平稳地进行。目前，对后期影响最严重的风险是糟糕的需求分析和项目规划，因此准备工作就倾向于集中改进需求分析和项目规划。
• 预先行其事，必先利其器 用软件武装团队提高生产效率，例如：版本控制，错误跟踪，信息发布，自动发布，CASE工具，调试工具，测试工具，文档管理，代码生成工具等等。
• 分析项目类型，在管理和构建之间找寻平衡 商业系统、使命攸关的系统、性命攸关的系统在整个项目阶段具备不同的控制粒度。需要根据项目的具体类型来确定管理的严谨程度，避免“过度控制”或“控制不足”。
• 需求必须被冻结 需求必须被冻结，如果需求不能冻结，那么谁来了都没有用。再强的团队也无法完成一个无尽的任务。
• 变更必须走流程 正确应对变更，变更并不可怕，可怕的是失控的变更。以下建议希望对读者有所帮助：

 在构建期间处理需求变更

1. 核对需求，评估质量：如果需求不够好，停下来，把它做好再开始。
2. 确保每一个人都知道需求变更的代价：让客户知道需求办更并不像在Excel上进行几个修改那样容易，“进度”和“成本”是你最有力的武器。
3. 建立一套变更控制程序：固定的变更控制程序让你知道在什么时候处理变更，让客户知道你会处理他们的提议。
4. 使用能适应变更的开发方法：迭代与增量。
5. 放弃这个项目：如果以上提议没有一条奏效，需求变更极其频繁，那么，评估你的项目，考虑放弃它吧，继续下去你只会越陷越深。
6. 注意项目的商业案例：性价比，没必要满足超出项目成本的需求。

• 关于加班 做IT的加班是很正常的，但加班要加的有意义，而且不应该长期加班。必须针对关键路径上的工作进行赶工，而不是做些无法加快整体进度的工作。而且，应当安排调休，而不是支付加班费。其主要原因也是我不赞成加班的原因——疲劳更容易引人缺陷。加班无疑会使人疲劳，每个人都想尽快结束手上的工作后回家休息。在长期疲惫的情况下，人员的工作效率会下降，士气会低落，非正常离职率增加，最重要的是疲惫的团队很难保证软件的质量，缺陷在不知不觉中引人，在后期无疑会为此付出代价。项目的总成本和周期，都会随着引人缺陷的数量的增加而倍增，而且发现的越晚越严重。
• 做好版本控制和配置管理 版本控制和配置管理是必须有的，即便是再小的项目也不能忽视，必须加以重视，一旦版本混乱，多多少少会对构活动造成影响。所以，平时不要偷懒，管理好每个基线。
• 授权的好处 授权好处多多，包括：一，减少管理者工作量；二，对人员有意识地进行锻炼，培养储备人才；三，提高人员对项目的参与度，从而提高士气。
• 乐观管理与悲观管理 乐观与悲观完全取决于人的性格，一般来讲多数倾向于乐观，应该清楚这两种性格在项目中的优势与劣势。我本人倾向于悲观，可能是性格使然，但悲观的管理至少不会误事。乐观管理的优势在于，很容易营造气氛，擅长给客户或领导描绘一个美好的未来。这种作风，前期很舒服，但后期可能要吃苦了。乐观管理容易出现的问题是对风险的预计不足，不能预留充足的缓冲时间，没有准备足够的预防措施。其表现就是，在进行进度计划时，总是认为今天的问题今天可以解决，已经修复的BUG将不会再次出现，用户需求是最后一次变更，等等诸如此类的乐观想法会使管理者蒙蔽双眼，而没有做足风险应对，其结果就是不管怎么加班就是赶不上进度，因为进度计划被设计为最顺利的情形，而不是现实场景。悲观管理的好处是，为潜在风险做足了准备。但悲观管理有一个非常大的缺陷，就是“过度控制”，可以比喻为“疑心病”（小心的都有些病态了）。其表现是为：按照之前的措施，发现遗漏了一个问题，那么悲观管理者会在之前措施基础上增加新的保障措施，然后又发现遗漏了一个问题，之后会继续追加保障措施。乍看之下没啥问题，因为是在不断地进行过程改进，但问题出在保障措施的增长速度过于惊人，称其为“疑心病”一点也不为过，悲观管理者容易在很小的地方施加过多的控制，造成人日的浪费，而忽略掉本应该关注的更为重要的问题。不管那种性格的管理，清楚自己的弱点总是好的。
• 有效的沟通，不要踢皮球 软件项目因为其本身的复杂度和涉众众多，所以更加需要沟通。沟通问题是所有大型项目都共用的问题，在大多数团队中往往也不认为沟通是个问题。但我还是想请读者认真对待沟通，比如邮件。邮件可以回复的慢，但请回复邮件。当我在一个连发出的邮件都没人回复的团队中工作时，除了无法解决问题，让我感受到的只有无奈以及冷漠。
• 客户是我们的朋友 把你的客户当成朋友，客户是我们做重要的资源之一。在每个客户背后往往隐藏着更多潜在的客户。我们必须清楚，客户作为非专业人士，其可能并不理解我们的工作，在项目执行阶段产生摩擦是难免的。但是，这些都不能成为我们迁怒客户或故意在工作中放水的借口。即便是为了项目能成功收尾，我们也必须维护好与客户的关系。
• 不要超前设计，不要项目镀金 超前设计和项目镀金都是不可取的，因为他是在浪费资源。满足需求以外的东西，不会对你的项目有任何好处，但是却可能引人缺陷。
• 总结经验教训 必须对阶段进行经验教训总结，没有什么比这些收获更有价值。这样文档就是组织的资产，是以后类似项目的参考和依据，并在持续优化方面发挥更为重要的作用。
• 不要让会议和文档拖了团队的后腿 “当船快要沉的时候，我们需要的是一个发号施令的领袖，而不是开会。”软件项目的核心问题是降低复杂度，越是复杂的项目就越需要沟通，但别让开会拖了我们的后腿。没有必要的会尽量少开或不开，要常开会，开小会，每次会议就几个相关干系人碰头沟通下就可以了，没有必要扩大为全员参与。冗长的讨论应该适时的终止，毕竟会议室上只能做出决策，而解决问题还得在会下。所以我认为应该精简那些冗长的会议，别然开会成为我们的工作。此外，要时刻谨记客户最终需要的是可以良好运行的软件产品而不是华丽的文档。所以，文档要恰到好处，写的再漂亮的文档没有完备的系统也不过是废纸一堆，别丢了西瓜捡芝麻，可以正常工作的软件才是我们的工作重心。
• 核对表的你的好助手 就像飞机工程师在检查飞机时使用核对表一样，软件项目也可以大量使用核对表。核对表可以帮助检验文档的质量，降低缺陷数量，以及改进项目管理。好的核对表，是你工作中的好助手。
• 小范围的受控好过大范围的失控 要注意控制的粒度，事无巨细。根据项目规模，人员构成，要采用不同的控制粒度。评估可控范围，并不是控制越广越好，控制不了就是失控。 对无暇顾及的地方授权别人管理是个可行的做法。 即便是小范围是受控，也好过大范围的失控。一个失控的项目，谁也不知道其会走向何方。
  (转载请注明出处：[url=http://www.6rfd.com]澳门博彩[/url]
  [url=http://www.9gds.com]易博网[/url])

Javascript没有任何内建的格式化函数，这里我们通过Google收集了5个javascript的数字格式化函数，希望对于大家的web开发能够带来方便。

十进制四舍五入

这两段代码帮助你做到四舍五入，对于你显示价格或者订单比较有用：

代码1：

function CurrencyFormatted(amount) {
    var i = parseFloat(amount);
    if(isNaN(i)) { i = 0.00; }
    var minus = '';
    if(i < 0) { minus = '-'; }
    i = Math.abs(i);
    i = parseInt((i + .005) * 100);
    i = i / 100;
    s = new String(i);
    if(s.indexOf('.') < 0) { s += '.00'; }
    if(s.indexOf('.') == (s.length - 2)) { s += '0'; }
    s = minus + s;
    return s;
}
 
/**
*   Usage:  CurrencyFormatted(12345.678);
*   result: 12345.68
**/

代码2：

function format_number(pnumber,decimals){
    if (isNaN(pnumber)) { return 0};
    if (pnumber=='') { return 0};
     
    var snum = new String(pnumber);
    var sec = snum.split('.');
    var whole = parseFloat(sec[0]);
    var result = '';
     
    if(sec.length > 1){
        var dec = new String(sec[1]);
        dec = String(parseFloat(sec[1])/Math.pow(10,(dec.length - decimals)));
        dec = String(whole + Math.round(parseFloat(dec))/Math.pow(10,decimals));
        var dot = dec.indexOf('.');
        if(dot == -1){
            dec += '.';
            dot = dec.indexOf('.');
        }
        while(dec.length <= dot + decimals) { dec += '0'; }
        result = dec;
    } else{
        var dot;
        var dec = new String(whole);
        dec += '.';
        dot = dec.indexOf('.');    
        while(dec.length <= dot + decimals) { dec += '0'; }
        result = dec;
    }  
    return result;
}
 
/**
*   Usage:  format_number(12345.678, 2);
*   result: 12345.68
**/

添加逗号

这俩段代码帮助你添加逗号到每三位数字中，这让大的数字比较容易查看。

代码1： 
 
function CommaFormatted(amount) {
    var delimiter = ","; // replace comma if desired
    amount = new String(amount);
    var a = amount.split('.',2)
    var d = a[1];
    var i = parseInt(a[0]);
    if(isNaN(i)) { return ''; }
    var minus = '';
    if(i < 0) { minus = '-'; }
    i = Math.abs(i);
    var n = new String(i);
    var a = [];
    while(n.length > 3)
    {
        var nn = n.substr(n.length-3);
        a.unshift(nn);
        n = n.substr(0,n.length-3);
    }
    if(n.length > 0) { a.unshift(n); }
    n = a.join(delimiter);
    if(d.length < 1) { amount = n; }
    else { amount = n + '.' + d; }
    amount = minus + amount;
    return amount;
}
 
/**
*   Usage:  CommaFormatted(12345678);
*   result: 12,345,678
**/

代码2：

function addCommas(nStr) {
    nStr += '';
    var x = nStr.split('.');
    var x1 = x[0];
    var x2 = x.length >; 1 ? '.' + x[1] : '';
    var rgx = /(d+)(d{3})/;
     
    while (rgx.test(x1)) {
        x1 = x1.replace(rgx, '$1' + ',' + '$2');
    }
     
    return x1 + x2;
}
 
/**
*   Usage:  addCommas(12345678);
*   result: 12,345,678
**/

数字格式化，来自PHP

这段javascript代码功能设计来自PHP的nubmer_format功能。能够四舍五入并且加入逗号分隔。而且可以自定义10进制分隔。

function number_format (number, decimals, dec_point, thousands_sep) {
 
    number = (number + '').replace(/[^0-9+-Ee.]/g, '');
    var n = !isFinite(+number) ? 0 : +number,
        prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),
        sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep,
        dec = (typeof dec_point === 'undefined') ? '.' : dec_point,
        s = '',
        toFixedFix = function (n, prec) {
            var k = Math.pow(10, prec);
            return '' + Math.round(n * k) / k;
        };
    // Fix for IE parseFloat(0.55).toFixed(0) = 0;
    s = (prec ? toFixedFix(n, prec) : '' + Math.round(n)).split('.');
    if (s[0].length > 3) {
        s[0] = s[0].replace(/B(?=(?:d{3})+(?!d))/g, sep);
    }
    if ((s[1] || '').length < prec) {
        s[1] = s[1] || '';
        s[1] += new Array(prec - s[1].length + 1).join('0');
    }
    return s.join(dec);
}
 
/**
*   Usage:  number_format(123456.789, 2, '.', ',');
*   result: 123,456.79
**/

添加一个英文的排序后缀 

Number.prototype.toOrdinal = function() {
    var n = this % 100;
    var suffix = ['th', 'st', 'nd', 'rd', 'th'];
    var ord = n < 21 ? (n < 4 ? suffix[n] : suffix[0]) : (n % 10 > 4 ? suffix[0] : suffix[n % 10]);
    return this + ord;
}
 
/*
*   Usage:
*   var myNumOld = 23
*   var myNumNew = myNumOld.toOrdinal()
*   Result: 23rd
*/
 

除去非数字的字符

function stripNonNumeric( str )
{
  str += '';
  var rgx = /^d|.|-$/;
  var out = '';
  for( var i = 0; i < str.length; i++ )
  {
    if( rgx.test( str.charAt(i) ) ){
      if( !( ( str.charAt(i) == '.' && out.indexOf( '.' ) != -1 ) ||
             ( str.charAt(i) == '-' && out.length != 0 ) ) ){
        out += str.charAt(i);
      }
    }
  }
  return out;
}
 
/*
*   Usage: stripNonNumeric('123et45dhs6.789');
*   Result: 123456.789
*/ 
 

希望对大家有帮助！
（转载请注明出处：[url=http://www.tdtf.org]易博网[/url]

我们在做网页开发时候，相信使用ajax请求对页面进行局部刷新的技术，大家应该都很熟悉了吧。 
   有时候我们需要动态的请求服务器，这时服务器如果发过一段带有 
<script> 
//there are some codes here. 
</script> 
这样的脚本，我们如何让他客户端生效呢？ 
    好吧，我承认我是用的jquery，需且很实现起来很简单，很多人也都是用一些js库实现的吧。如果我需要写js的源码呢？昨天同事碰到了这个问题，我就去深入地了解了一下，结果收获了一些以前不太明确的，不知道的知识。
    一开始不能使脚本生效的方法： 
    在服务器端请求得到了带有<script>code...<script>的html的片段，然后直接使用document.getElementById("target_div").innerHTML = responseText,很好，得到的html内容都进来了，而且页面显示也正确。可以在触发刚请求到<script></script>中功能的时候，发现这里的代码失效了，无论如何也执行不了。于是我就去找使script生效的方法。 
    后来，想到我看看jquery是怎么实现的不就行了吗？jqury的代码如下： 

这个函数就是实现动态加载执行script的关键，函数中的参数data指的就是<script>data</script>这里的data,函数代码很简单，意思就是在<head>这个节点中的第一个位置插入<script>data</script>，这时候data就会被浏览器执行。最后再把这个节点给删了。 
    刚看到这个代码的时候，我就想，难道把<script>data</script>插入到<head>的第一个位置就会生效吗？而我放到自已的target_div里就不会生效，一直就搞不明白这个问题。因为没有听过哪本书，或哪个资料上这么说过啊。笨笨的我想了一下午，晚上回家的时候突然想明白了，jquery这里的插入script，和我写的插入script是不一样的,jquery是先创建一个script节点（这里是关键），然后将插入到html页面中。再看看我的插入，是直接用的innerHTML进行赋值。然而这是为什么呢？大家应该知道script的执行顺序吧，script在html文档加载的时候会执行一次。这里区别就在于，虽然是ajax请求来的script,jquery的实现方法是属于文档加载，另一个却只是文本的插入。浏览器会区分出这两种方式，所以只有jquery的方法才是正确的。 
     那么我们还看到为什么非要插入到head的第一个元素位置呢，这里面应该有点学问吧，我还不知道这里有什么原因。希望哪位高手可以帮我解惑。 
    最后删掉这个结点，是因为我们已经把script代码插入到target_div了，为了不让我们觉得莫名其秒，所以从外表的html代码中是看不到任何端倪的。 
    如果你已经看到这段文字，我想你应该交学费了，哈哈。当然，我也学别人东西也不交学费的。这样就算了。不过欢迎大家一起讨论、交流，能有新的想法，新的问题。
(转载请注明出处：

Flex与Javascript互相通信。
（1）：在Flex中有这么一个类：ExternalInterface.在这个类中它给我们：call和addCallback

Flex中As调用Js的方法是：
     1、导入包 （import flash.external.ExternalInterface;）
     2、使用ExternalInterface.call("Js函数名称",参数)进行调用，其返回的值就是Js函数所返回的值
 
Js调用As的方法是：
     1、导入包 （import flash.external.ExternalInterface;）
     2、在initApp中使用ExternalInterface.addCallback("用于Js调用的函数名",As中的函数名)进行注册下
     3、js中 就可以用document.getElementById("Flas在Html中的ID").注册时设置的函数名（参数）进行调用.

（2）：实例演习：
[1]:flex调用javascript中的函数：
mxml：
<mx:Script>
 <![CDATA[
  import mx.controls.Alert;
  internal function jspHello():void {
   var taStr:String = this.ta.text;
   var s:String = ExternalInterface.call("hello", taStr);
   Alert.show(s);    
  }
 ]]>
</mx:Script>

<mx:Button x="480" y="84" label="flex call javascript" click="jspHello()"/>
<mx:TextArea id="ta" x="265" y="85" height="80" width="199"/>

javascript中的函数：
js:
 <script type="text/javascript">
   function hello(param) {
    return "Hello： + param;
   }
  </script>

打印出来是:Hello: *****.
[2]:javascript调用Flex中的函数
mxml:
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" initialize="initApp();">
 <mx:Script>
  <![CDATA[
   import mx.controls.TextArea;
   internal function initApp():void {
    ExternalInterface.addCallback("callBackFlex", testJavascript);
   }
   
   public function testJavascript():String {
    var taStr:String = "中俄实弹演习成功!";
    return taStr;    
   }
  ]]>
 </mx:Script>
</mx:Application>

js:

<script type="text/javascript">
 function callApp() {
  var str = testJavascriptCallFlex.callBackFlex();
  alert("javascript调用flex成功  ： + str);
 }
</script>
打印出来：javascript调用flex成功：中俄实弹演习成功。
(转载请注明出处：[url=http://www.k6567.com]e世博[/url])

前阵子，公司项目开发的时候，有个xxx.mxml编译后的swf始终加载不出来。开发环境是MyEclipse，后来仔细一看。原来是因为对xxx.mxml使用了flex applications 和 flex modules两种编译方式，导致mxml编译冲突，而无法编译成正确的swf文件。

正确做法：每个项目只用一个flex application，然后各个业务项里的mxml文件做成modules加入进来即可。
（转载请注明出处：[url=http://www.tswa.org]博彩通[/url]）

软件开发人员是一个日新月异的领域—–IT中的大师，今天的编程方式与明天的编程或许截然不同，技术在不断地革新，新语言、新平台的如雨后春笋般出现、更好的解决方案的冒出，因此我们需要跟得上节奏，我们别无选择，唯有努力提高自己。

下面的几点建议或许能帮助你成为一个优秀的开发者。

你是否听说过Kaizen这个词呢？简单地说就是“改良”的意思。当然它不仅仅是一个单词，同时代表着一种哲学，一个不断完善自我的理念。它需要客观的监督和改善。更多的细节可以从这里了解。

当然下面的建议是没有先后顺序的。

0. 阅读代码：

经常认真阅读他人的代码。寻找大家公认的优秀软件作品，学习其背后的运作原理，领悟他人解决问题的方法，有时候你也会遇到同样的问题，试着对比其技术和解决方案。

1. 编写代码：

在一个你还从未解决过的问题上多花点时间，尝试着培养自己的思考方法以及思维模式，你会因此而获得很多的乐趣。其实这样做并不难，而且它还是很好的问题反馈源。对于每个问题几乎任何时候都有不同的解决方法，学着用不同的方法解决问题，对比它们之间的优点和弊端，使用诸如模块化和系统集成的方式编程，因为那样写代码非常的简洁、清晰。

2. 跟上技术潮流：

在twitter和facebook、weibo等社交网络关注技术大牛，订阅你的RRS。及时了解新语言，对技术要有深入研究而不是仅仅停留在只会调用API的层面上。技术是要靠实力说话的，光忽悠没用，所以尽可能早的去深入了解。

3. 从不同的角度思考问题：

没错，你就是一个开发者，但是你会把自己的作品当做普普通通的产品吗？商业价值怎么样？写出来的软件能给你带来什么样的价值？需要用到哪些资源？有比软件带来更多价值还重要的事情吗？软件所表达的思想是什么？用户在使用过程中软件能扮演什么样的角色？这些问题看似很老套或者微不足道，其实不然，我们应该不断地去回答这些问题，开始不同角度思考问题。

4. 测试是开发者的工作：

未测试的代码就像一个未知的承诺，不去测试代码，编程技巧很难得到提高。作为用户，你会因为一个得不到保证的承诺而把钱交给一个完全陌生的人吗？用测试单元做功能和集成测试，证明你的代码可以正确执行，使他人放心地使用。把代码放到GitHub资源库上去。记住：扩大代码测试覆盖范围，减少代码的复杂度、去除代码的异味，不断调整、提高。

5. 在社区和开发者交流

向他人学习，和他人探讨问题。通过阅读他人代码提高自己的水平，同时尽可能去帮助他人，用一种开放地思维接受和分析他人的解决方案以及思想。

6. 每天交付可使用的部分

学会把大项目分解成为更小的，变成可交付使用的部分。做里程碑、做测试证明、做进度规划。分析和总结是必不可少的，此刻就把它记录下来，注意前后细节的变化，长期的积累将使你更加自信，外人对你会刮目相看，做一个快乐的程序员。

7. 忙里偷闲：

参加娱乐、体育活动、接触大自然。你的身体和大脑需要休息，经常站起来活动活动，切忌一直坐着盯着屏幕。
（转载请注明出处：[url=http://www.a9832.com]博彩网[/url]）