傳統上，Hibernate的配置依賴于外部 XML 文件：數據庫映射被定義為一組 XML 映射文件，并且在啟動時進行加載。創建這些映射有很多方法，可以從已有數據庫模式或Java類模型中自動創建，也可以手工創建。無論如何，您最終將獲得大量的 Hibernate 映射文件。此外，還可以使用工具，通過javadoc樣式的注釋生成映射文件，盡管這樣會給您的構建過程增加一個步驟。

　　在最近發布的幾個Hibernate版本中，出現了一種基于 Java 5 注釋的更為巧妙的新方法。借助新的 Hibernate Annotation 庫，即可一次性地分配所有舊映射文件——一切都會按照您的想法來定義——注釋直接嵌入到您的 Java 類中，并提供一種強大及靈活的方法來聲明持久性映射。籍由自動代碼完成和語法突出顯示功能，最近發布的Java IDE也為其提供了有力的支持。

　　Hibernate Annotation還支持新的 EJB 3 持久性規范。這些規范旨在提供一種標準化的 Java 持久性機制。由于 Hibernate 3 還提供了一些擴展，因此您可以十分輕松地遵從這些標準，并使用 EJB 3 編程模型來對 Hibernate 持久層進行編碼。

　　現在，讓我們來動手使用Hibernate Annotation。

安裝 Hibernate Annotation

　　要使用 Hibernate Annotation，您至少需要具備 Hibernate 3.2和Java 5。可以從 Hibernate 站點 下載 Hibernate 3.2 和 Hibernate Annotation庫。除了標準的 Hibernate JAR 和依賴項之外，您還需要 Hibernate Annotations .jar 文件（hibernate-annotations.jar）、Java 持久性 API （lib/ejb3-persistence.jar）。如果您正在使用 Maven，只需要向 POM 文件添加相應的依賴項即可，如下所示：

 ...

org.hibernate
hibernate
3.2.1.ga


org.hibernate
hibernate-annotations
3.2.0.ga


javax.persistence
persistence-api
1.0

...

　　下一步就是獲取 Hibernate 會話工廠。盡管無需驚天的修改，但這一工作與使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 類來建立會話工廠：

sessionFactory = new

AnnotationConfiguration().buildSessionFactory();

　　盡管通常使用 元素來聲明持久性類，您還是需要在 Hibernate 配置文件（通常是 hibernate.cfg.xml）中聲明持久性類：

　　近期的許多 Java 項目都使用了輕量級的應用框架，例如 Spring。如果您正在使用 Spring 框架，可以使用 AnnotationSessionFactoryBean 類輕松建立一個基于注釋的 Hibernate 會話工廠，如下所示：

org.hibernate.dialect.DerbyDialect
create
...




com.onjava.modelplanes.domain.PlaneType
com.onjava.modelplanes.domain.ModelPlane
...

第一個持久性類

　　既然已經知道了如何獲得注釋所支持的 Hibernate 會話，下面讓我們來了解一下帶注釋的持久性類的情況：

　　像在其他任何 Hibernate應用程序中一樣，帶注釋的持久性類也是普通 POJO。差不多可以說是。您需要向 Java 持久性 API （javax.persistence.*）添加依賴項，如果您正在使用任何特定于 Hibernate的擴展，那很可能就是 Hibernate Annotation 程序包（org.hibernate.annotations.*），但除此之外，它們只是具備了持久性注釋的普通 POJO 。下面是一個簡單的例子：

@Entity
public class ModelPlane {
private Long id;
private String name;
@Id
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

　　正像我們所提到的，這非常簡單。@Entity 注釋聲明該類為持久類。@Id 注釋可以表明哪種屬性是該類中的獨特標識符。事實上，您既可以保持字段（注釋成員變量），也可以保持屬性（注釋getter方法）的持久性。后文中將使用基于屬性的注釋。基于注釋的持久性的優點之一在于大量使用了默認值（最大的優點就是 “慣例優先原則（convention over configuration）”）。例如，您無需說明每個屬性的持久性——任何屬性都被假定為持久的，除非您使用 @Transient 注釋來說明其他情況。這簡化了代碼，相對使用老的 XML 映射文件而言也大幅地減少了輸入工作量。

生成主鍵

　　Hibernate 能夠出色地自動生成主鍵。Hibernate/EBJ 3 注釋也可以為主鍵的自動生成提供豐富的支持，允許實現各種策略。下面的示例說明了一種常用的方法，其中 Hibernate 將會根據底層數據庫來確定一種恰當的鍵生成策略：

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
public Long getId() {
return id;
}

定制表和字段映射

　　默認情況下，Hibernate 會將持久類以匹配的名稱映射到表和字段中。例如，前一個類可以與映射到以如下代碼創建的表中：

CREATE TABLE MODELPLANE
(
ID long,
NAME varchar
)

　　如果您是自己生成并維護數據庫，那么這種方法很有效，通過省略代碼可以大大簡化代碼維護。然而，這并不能滿足所有人的需求。有些應用程序需要訪問外部數據庫，而另一些可能需要遵從公司的數據庫命名慣例。如果有必要，您可以使用 @Table 和 @Column 注釋來定制您自己的持久性映射，如下所示：

@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name="PLANE_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

　　該內容將映射到下表中：

CREATE TABLE T_MODEL_PLANE
(
PLANE_ID long,
PLANE_NAME varchar
)

　　也可以使用其他圖和列的屬性來定制映射。這使您可以指定諸如列長度、非空約束等詳細內容。Hibernate支持大量針對這些注釋的屬性。下例中就包含了幾種屬性：

 ...
@Column(name="PLANE_ID", length=80, nullable=true)
public String getName() {
return name;
}
...

映射關系

　　Java 持久性映射過程中最重要和最復雜的一環就是確定如何映射表間的關系。像其他產品一樣， Hibernate 在該領域中提供了高度的靈活性，但卻是以復雜度的增加為代價。我們將通過研究幾個常見案例來了解如何使用注釋來處理這一問題。

　　其中一種最常用的關系就是多對一的關系。假定在以上示例中每個 ModelPlane 通過多對一的關系（也就是說，每個飛機模型只與一種飛機類型建立聯系，盡管指定的飛機類型可以與七種飛機模型建立聯系）來與 PlaneType 建立聯系。可如下進行映射：

 @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
public PlaneType getPlaneType() {
return planeType;
}

　　CascadeType 值表明 Hibernate 應如何處理級聯操作。

　　另一種常用的關系與上述關系相反：一對多再對一關系，也稱為集合。在老式的 Hibernate 版本中進行映射或使用注釋時，集合令人頭疼，這里我們將簡要加以探討，以使您了解如何處理集合，例如，在以上示例中每個 PlaneType 對象都可能會包含一個 ModelPlanes 集合。可映射如下：

 @OneToMany(mappedBy="planeType",
cascade=CascadeType.ALL,
fetch=FetchType.EAGER)
@OrderBy("name")
public List getModelPlanes() {
return modelPlanes;
}

命名查詢

　　Hibernate 最優秀的功能之一就在于它能夠在您的映射文件中聲明命名查詢。隨后即可通過代碼中的名稱調用此類查詢，這使您可以專注于查詢，而避免了 SQL 或者 HQL 代碼分散于整個應用程序中的情況。

　　也可以使用注釋來實現命名查詢，可以使用 @NamedQueries 和 @NamedQuery 注釋，如下所示：

@NamedQueries(
{
@NamedQuery(
name="planeType.findById",
query="select p from PlaneType p left join fetch p.modelPlanes where id=:id"
),
@NamedQuery(
name="planeType.findAll",
query="select p from PlaneType p"
),
@NamedQuery(
name="planeType.delete",
query="delete from PlaneType where id=:id"
)
}
)

　　一旦完成了定義，您就可以像調用其他任何其他命名查詢一樣來調用它們。

結束語

　　Hibernate 3 注釋提供了強大而精致的 API，簡化了 Java 數據庫中的持久性代碼，本文中只進行了簡單的討論。您可以選擇遵從標準并使用 Java 持久性 API，也可以利用特定于 Hibernate的擴展，這些功能以損失可移植性為代價提供了更為強大的功能和更高的靈活性。無論如何，通過消除對 XML 映射文件的需求，Hibernate 注釋將簡化應用程序的維護，同時也可以使您對EJB 3 有初步認識。來試試吧！

 1import javax.persistence.CascadeType;   
 2import javax.persistence.Column;   
 3import javax.persistence.Entity;   
 4import javax.persistence.FetchType;   
 5import javax.persistence.GeneratedValue;   
 6import javax.persistence.Id;   
 7import javax.persistence.OneToMany;   
 8import javax.persistence.Table;   
 9import javax.persistence.Temporal;   
10import javax.persistence.TemporalType;   
11   
12import org.hibernate.annotations.Formula;   
13import org.hibernate.annotations.GenericGenerator;   
14   
15@Entity   
16@Table(name = "school_info")   
17public class SchoolInfo implements java.io.Serializable {   
18   
19    @Id   
20    @GeneratedValue(generator = "system-uuid")   
21    @GenericGenerator(name = "system-uuid", strategy = "uuid")   
22    private String id;//hibernate的uuid機制,生成32為字符串   
23   
24    @Column(name = "actcodeId", updatable = false, nullable = true, length = 36)   
25    private String actcodeId;   
26   
27    @Formula("select COUNT(*) from school_info")   
28    private int count;   
29   
30    @Temporal(TemporalType.TIMESTAMP)//不用set,hibernate會自動把當前時間寫入   
31    @Column(updatable = false, length = 20)   
32    private Date createTime;   
33   
34    @Temporal(TemporalType.TIMESTAMP)   
35    private Date updateTime;// 剛開始我默認insertable=false,但會讀取出錯提示如下:   
36    // Value '0000-00-00' can not be represented as java.sql.Timestamp   
37   
38    // mappedBy="school"就相當于inverse=true,(mappedBy指定的是不需要維護關系的一端)   
39    // 應該注意的是mappedBy值對應@ManyToOne標注的屬性,我剛開始寫成"schoolId",讓我郁悶了好一會 
40    @OneToMany(mappedBy = "school", cascade = CascadeType.ALL, fetch = FetchType.EAGER, targetEntity = UserMember.class)   
41    // 用范性的話,就不用targetEntity了   
42    private List<usermember> users = </usermember>new ArrayList<usermember>();  </usermember> 
43       
44}   
45

JSON的結構基于下面兩點

• 1. "名稱/值"對的集合 不同語言中，它被理解為對象(object)，記錄(record)，結構(struct)，字典(dictionary)，哈希表(hash table)，鍵列表(keyed list)等
• 2. 值的有序列表 多數語言中被理解為數組(array)

 這里假設我們需要創建一個User對象，并具有以下屬性

{"UserID":11, "Name":"Truly", "Email":"zhuleipro◎hotmail.com"};

<script>

var User = {"UserID":11, "Name":"Truly", "Email":"zhuleipro◎hotmail.com"};
alert(User.Name);
</script>

{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"}

<script>

var User = {"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"};
alert(User.Name.FirstName);
</script>

[
{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"},
{"UserID":12, "Name":{"FirstName":"Jeffrey","LastName":"Richter"}, "Email":"xxx◎xxx.com"},
{"UserID":13, "Name":{"FirstName":"Scott","LastName":"Gu"}, "Email":"xxx2◎xxx2.com"}
]

<script>
var UserList = [
{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"},
{"UserID":12, "Name":{"FirstName":"Jeffrey","LastName":"Richter"}, "Email":"xxx◎xxx.com"},
{"UserID":13, "Name":{"FirstName":"Scott","LastName":"Gu"}, "Email":"xxx2◎xxx2.com"}
];
alert(UserList[0].Name.FirstName);
</script>

alert(UserList[0]["Name"]["FirstName"]); 或者 alert(UserList[0].Name["FirstName"]); 

轉載：http://blog.csdn.net/mtzai/archive/2009/05/24/4212490.aspx

在大多數情況下,為事件處理函數返回false,可以防止默認的事件行為.例如,默認情況下點擊一個<a>元素,頁面會跳轉到該元素href屬性指定的頁.
 Return False 就相當于終止符，Return True 就相當于執行符。

在js中return false的作用一般是用來取消默認動作的。比如你單擊一個鏈接除了觸發你的
onclick時間（如果你指定的話）以外還要觸發一個默認事件就是執行頁面的跳轉。所以如果
你想取消對象的默認動作就可以return false。return false應用比較多的場合有：
<form name="form1"  onsubmIT="return youfunction();">...... </form>
<a href="www.***.com" onclick="...;return false;">dddd </a>    .

<script>
function test()
{
  alert("test");
  return false();
}
</script>

</head>

<body>
1， <a href='a.JSP' onclick='test();'>超級鏈接 </a>
2， <input type="button" onclick='test()' value="提交">
3， <form name="form1"  onsubmIT="return test();">
內容
<input type="submIT" value="提交">
</form>
</body>

<a href="xxxx.do?....." target=dolink>連接abcd </a>
<iframe id=dolink src=about:blank style=display:none> </iframe>

 
點了上面的那個連接后，dolink幀執行頁面處理的事情（xxxx.do？...然傳遞參數到服務器），頁面不會跳轉。    .

最近做的項目，通過綁定在 button 的 onclick 事件的函數提交表單。發現 return false 也是很重要的。比如：

 <input type="submit" onclick="submitAction(); return false;" />

 submitAction 方法里面有提交表單的動作。如果不加 return false，在執行完 submitAction 之后，submit 按鈕還會繼續執行它的默認事件，就會再次提交表單。這可能就是很多錯誤的根源。

的確，return false的含義不是阻止事件繼續向頂層元素傳播，而是阻止瀏覽器對事件的默認處理。你可以這樣試驗：首先將所有的js腳本注釋掉，在IE瀏覽器中嘗試拖動一下圖片，你會發現鼠標會成為禁止操作的樣式，圖片是被禁止拖動的，它是瀏覽器針對mousemove事件所提供的默認行為。return false就是為了去掉這種行為，否則就會出現你描述的中斷事件連續執行。

另外，和return false等效的語句為：window.event.returnValue = false，你可以把return false替換為此語句并進行驗證。

最后說明一下，此種方式只適用于IE瀏覽器。

<html>
<head>
<script language="javascript">
function verifyForm(){
var ass=document.getElementsByName("assetName");
if(ass[0].value.length==0){
alert("名稱輸入為空！");
return false;
}

if(ass[0].value.length>15){
alert("名稱輸入長度不能超過15個字符！");
return false;
}
}
</script>
</head>
<body>
<form name="xx">
<input name="assetName" type="text"/>
                        <--根據return 返回值的TRUE或FALSE 判定是否提交表單--->
<input type="submit" onclick="return verifyForm()"/>
</form>
</body>
</html>

潛水看了眾大蝦的精彩帖子，今也貢獻一點心得。其聞共欣賞，疑義相與析。有不對之處請不吝拍磚。

眾所周知，在表單中加上onsubmit="return false;"可以阻止表單提交。
下面是簡單的一小段代碼：

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="submitTest();;">  
    <INPUT value="www">  
    <input type="submit" value="submit">  
</form>  
 
<SCRIPT LANGUAGE="JavaScript">  
<!--  
    function submitTest(); {  
        // 一些邏輯判斷  
     return false;  
    }  
//-->  
</SCRIPT> 

<form action="index.jsp" method="post" onsubmit="submitTest();;">
    <INPUT value="www">
    <input type="submit" value="submit">
</form>

<SCRIPT LANGUAGE="JavaScript">
<!--
    function submitTest(); {
        // 一些邏輯判斷
     return false;
    }
//-->
</SCRIPT>
大家判斷像上面的寫法，點擊submit按鈕該表單是否提交？

若答案為是，就不用往下看了。

若答案為否，錯了。實際情況是表單正常提交，若想它不提交，應該將

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="submitTest();;"> 

<form action="index.jsp" method="post" onsubmit="submitTest();;">改為

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="return submitTest();;"> 

<form action="index.jsp" method="post" onsubmit="return submitTest();;">

為何？

原來onsubmit屬性就像是<form>這個html對象的一個方法名，其值（一字符串）就是其方法體，默認返回true；

和Java一樣，在該方法體中你可以寫任意多個語句，包括內置函數和自定義函數，如

view plaincopy to clipboardprint?
onsubmit="  
    alert('haha');; // 內置函數   
    submitTest();;  // 自定義函數  
    alert(this.tagName);; // 用到了this關鍵詞  
    ......(任意多條語句);      
    return false;  
" 

onsubmit="
    alert('haha');; // 內置函數
    submitTest();;  // 自定義函數
    alert(this.tagName);; // 用到了this關鍵詞
    ......(任意多條語句);   
    return false;
"
就相當于

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {  
    alert('haha');; // 內置函數  
    submitTest();;  // 自定義函數  
    alert(this.tagName);; // 用到了this關鍵詞  
    ......(任意多條語句);      
    return false;  
}; 

Form.prototype.onsubmit = function(); {
    alert('haha');; // 內置函數
    submitTest();;  // 自定義函數
    alert(this.tagName);; // 用到了this關鍵詞
    ......(任意多條語句);   
    return false;
};
這樣的話你就覆寫了(override)其默認方法（默認返回true）
大家注意到方法體中可以用this這個關鍵詞，這里即代表了<form>的對象實例。

經過這樣的分析后，以上情況就不難理解了：

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="submitTest();;"> 

<form action="index.jsp" method="post" onsubmit="submitTest();;">這樣寫，override方法的效果為：

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {  
    submitTest();;  
}; 

Form.prototype.onsubmit = function(); {
    submitTest();;
};
在這里submitTest()雖然返回false，但我們只執行了此函數，沒有對其結果進行任何處理。而

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="return submitTest();;"> 

<form action="index.jsp" method="post" onsubmit="return submitTest();;">
override方法的效果為：

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {  
    return submitTest();;  
}; 

Form.prototype.onsubmit = function(); {
    return submitTest();;
};
這樣，我們利用到了它的返回值，達到了預期效果。
這樣理解的話我想印象會深刻得多，就不易出錯了

結論：
我們可以用Java里的思維方式來思考模擬JavaScript中的類似情況（JavaScript中基于prototype的面向對象技術也確實是這樣做的），但他們畢竟還是有本質上的區別，如Java是強類型的，有嚴格的語法限制，而JavaScript是松散型的。象上述方法：

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {    
}; 

Form.prototype.onsubmit = function(); { 
};
既可以有返回值，又可以沒有返回值，在Java里是通不過的，畢竟Java里面不能靠方法的返回值不同來重載(overload)方法，而JavaScript中的重載要松散得多。

一、 簡單的對比

request.getParameter用的比較多，相對熟悉

request.getParameterValues(String   name)是獲得如checkbox類（名字相同，但值有多個）的數據。   接收數組變量 ，如checkobx類型    
request.getParameter（String   name）是獲得相應名的數據，如果有重復的名，則返回第一個的值 . 接收一般變量 ，如text類型

例：

1. 三個名字相同的text標簽

<input type="text" name="test" value="1" />
<input type="text" name="test" value="2" />
<input type="text" name="test" value="3" />

request.getParameterValues("test")   ----------------- [1, 2, 3]

request.getParameter("test")             ------------------ 1

${paramValues.test}

${param.test}

2. checkbox

 <input type="checkbox" name="habit" value="read">看書

 <input type="checkbox" name="habit" value="movie">電影

 <input type="checkbox" name="habit" value="game">游戲

request.getParameterValues("habit")

二、與此相關的話題------隱含對象

1. JSP隱含對象(Implicit Object)

     所謂隱含對象，是指當編寫jsp網頁時，不必做任何聲明就可以直接使用的對象。 JSP2.0定義了九個隱含對象

request response pageContext session application out conifg page exception

這里只提一下request 和 response 兩個對象

       request 對象表示客戶端請求的內容，比如我們從request中取得了用戶輸入的內容，實現了javax.servlet.http.HttpServletRequest接口

      response對象表示響應客戶端的結果。

上面我們使用了request的兩個方法getParameter 和 getParameterValues，其實request還有其他幾個比較重要的方法，這里只涉及幾個獲取請求參數的方法

String getParameter(String name)                     取得name的參數值

String[] getParameterValues(String name)        取得所有name的參數值

Enumeration getParameterNames()                  取得所有的參數名稱

Map<String, String[]> getParameterMap()        取得request的所有參數的一個映射

//

Returns a java.util.Map of the parameters of this request. Request parameters are extra information sent with the request. For HTTP servlets, parameters are contained in the query string or posted form data.
Returns:
an immutable java.util.Map containing parameter names as keys and parameter values as map values. The keys in the parameter map are of type String. The values in the parameter map are of type String array.
//

response等其他幾個隱含對象也有非常重要的身份，有機會專門整理一下，宣揚一下它們的顯赫地位。

2. EL隱含對象

EL即Experssion Language，自JSP2.0后正式成為JSP的標準規范之一，支持Servlet2.4/JSP2.0的Container也就相應的支持EL語法。

一個常見的形式如，<c:out value="${ 3 + 7 * 4}" />

EL的隱藏對象有11個 PageContext PageScope RequestScope sessionScope applicationScope

param paramValues header headerValues cookie initParam

其中param 和 paramValues即對相應ServletRequest.getParameter(String name)和ServletRequest.getParameterValues(String name)

轉載：http://blog.csdn.net/moreorless/archive/2009/05/18/4199677.aspx

轉載：http://www.sucai.com/Tech/List2/17830.htm

javascript是弱類型的語言，所以強制類型轉換還是比較重要的，下面看一下它的幾個強制轉換的函數：

1. Boolean(value):把值轉換成Boolean類型；

2. Nnumber(value):把值轉換成數字（整型或浮點數）；

3. String(value):把值轉換成字符串。

我們先來看Boolean()：在要轉換的值為“至少有一字符的字符串”、“非0的數字”或“對象”，那么Boolean()將返回true，如果要轉換的值為“空字符串”、“數字0”、“undefined”，“null”這些話，那么Boolean()會返回false。你可以用以下代碼來測試

var　t1　=　Boolean("");//返回false,空字符串
var　t2　=　Boolean("s");//返回true，非空字符串
var　t3　=　Boolean(0);//返回false，數字0
var　t3　=　Boolean(1),t4　=　Boolean(-1);//返回true，非0數字
var　t5　=　Boolean(null),t6　=　Boolean(undefined);//返回false
var　t7　=　Boolean(new　Object());//返回true，對象

再來看看Number()：Number()與parseInt()和parseFloat()類似，它們區別在于Number()轉換是整個值，而parseInt()和parseFloat()則可以只轉換開頭的數字部分，例如：Number("1.2.3"),Number("123abc")會返回NaN，而parseInt("1.2.3")返回1、parseInt("123abc")返回123、parseFloat("1.2.3")返回1.2、parseFloat("123abc")返回123。Number()會先判斷要轉換的值能否被完整的轉換，然后再判斷是調用parseInt()或parseFloat()。下面列了一些值調用Number()之后的結果：

Number(false)　 0
Number(true)　 1
Number(undefined)　 NaN
Number(null)　 0
Number("1.2")　 1.2

Number("12")　 12
Number("1.2.3")　 NaN
Number(new Object())　 NaN
Number(123)　 123

最后是String()：這個以比較簡單了，它可以把所有類型的數據轉換成字符串，如：String(false)---"false"、String(1)---"1"。它和toString()方法有些不同，區別在于：

var　t1　=　null;
var　t2　=　String(t1);//t2的值　"null"
var　t3　=　t1.toString();//這里會報錯
var　t4;
var　t5　=　String(t4);//t5的值　"undefined"
var　t6　=　t4.toString();//這里會報錯