var pat = /abc/;
pat.test('abc is before def'); //true
pat.test('ab'); //false
以上列的模式/abc/來比對字串時，只有要比對的字串中，一定包含著「abc」這個字串，匹配才會成功，test()函式才會回傳true。var pat1 = /[abc]/;
pat1.test('ab'); //true
pat1.test('apple'); //true
pat1.test('big'); //true
pat1.test('dig'); //false
由上列的範例，好像只要比對的字串中，只要含有比對模式中一個字元，就能匹配成功？
[]包起來時，只要比對的字串中，含有任何一個中括號內的字元，就能匹配成功。－來表示一個區間內的比對字元，如：
var pat2 = /[A-Z]/; //比對的字串中，要含有任一個由A至Z的「大寫」字母
pat2.test('apple'); //false
pat2.test('Apple'); //true
var pat3 = /[1-9]/; //比對的字串中，要含有任一個由1至9的數字
pat3.test('abc'); //false
pat3.test('1st'); //true
如果你想學好JavaScript，我推薦：
web.xml的配置：
主要意思是，將所有的回應，轉給Struts來做處理。mystruts struts2 org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter struts2 /*
struts.xml的配置：
需要注意的是第9至11行這邊，需要替我要回傳的JSON格式定義一個/index.jsp /pages/HelloWorld.jsp jsonString
result-type，在這裡就是json。org.apache.struts2.json.JSONResult類別。
execute方法處理好要轉成JSON字串的物件，並返回json_ok的結果就好，如上的第16至20行。
JsonAction.java的程式如下：
package org.apache.struts.helloworld.action;
import java.util.HashMap;
import java.util.Map;
import org.apache.struts.helloworld.model.JsonString;
import com.opensymphony.xwork2.ActionSupport;
public class JsonAction extends ActionSupport
{
/**
*
*/
private static final long serialVersionUID = 1645961153075600530L;
private JsonString jsonString;
public String execute() throws Exception {
Map map = new HashMap();
map.put("abc", "123");
map.put("def", "456");
this.getJsonString().setRes(map);
return "json_ok";
}
public JsonString getJsonString()
{
if(jsonString == null)
{
this.jsonString = new JsonString();
}
return jsonString;
}
public void setJsonString(JsonString jsonString)
{
this.jsonString = jsonString;
}
}
啟動伺服器後，送出要求後，就會得到下列的結果：
js.jar，如：
$ cd tools/JavaScript/rhino1_7R4 $ java -jar js.jar Rhino 1.7 release 4 2012 06 18 js>之後，我們就可以如在文字編輯器中寫JavaScript撰寫程式碼，如：
js> var a = 1, b = 2; js> a + b 3
remove.package()這個函式，如：
> remove.packages('actuar')
var pat1 = /java/; var str1 = 'javascript'; var str2 = 'i love java'; pat1.test(str1); //結果為 true pat1.test(str2); //結果為 true因為上列比對的兩個字串
str1和str2中，都有全為小寫的java，所以比對的結果都會回傳true。
java，就能匹配成功。
^的特殊字元：
var pat2 = /^java/; var str1 = 'javascript'; var str2 = 'I love java'; pat2.test(str1); //結果為 true pat2.test(str2); //結果為 false上列比對的兩個字串中，都有全為小寫的
java，但這次str1比對的結果回傳true，而str2比對的結果回傳false。
^後，則比對的目標字串的起始位置，要含有^後面的字元或字串，才能成功匹配，才會回傳true，例如上列的str1起始四個字元與定義的模式java匹配，而str2雖然含有java，但它不在一開頭的位置上。
java，才能匹配成功。
^要放在比對模式的第一個字元，若放在其他地方，則有「否定」的意思，這之後會去探討。
$，它若放在比對模式的「最後一個字元」，則表示要比對的字串，最後結尾的部份，要符合$符號前面定義的模式，才能匹配成功。
var pat3 = /java$/; pat3.test(str1); //結果為false pat3.test(str2); //結果為true，因為str2是java結尾，所以比對成功 var str3 = 'I love jave'; pat3.test(str3); //結果為 false var str4 = 'I love javaa'; pat3.test(str4); //結果為 false所以用白話文來講，使用這樣的比對模式時，就是比對的字串，結尾的最後四個字元一定要是
java，才能匹配成功。
^和$在正規表示中的意思了，那下列的比對模式，要怎樣的字串才能匹配成功呢？
var pat4 = /^java$/;有時間就try一下吧！
rm -r -f ~/.subversion/auth果然問題就解決了。
dim，它是一個函式(function)，它的功能在取得或設定一個物件的維度。
> ?dim文件中對於
dim()的描述是：取得或設定一個物件的維度。
> profit <- c(2.0, 2.1, 2.2, 2.1, 2.3, 2.4) > profit [1] 2.0 2.1 2.2 2.1 2.3 2.4再來使用
dim()函式把向量profit轉為矩陣：
> dim(profit) <- c(2, 3)
> profit
[,1] [,2] [,3]
[1,] 2.0 2.2 2.3
[2,] 2.1 2.1 2.4
上列指令把向量profit轉為一個2 X 3的矩陣，再來我們就可以下列指令，來取得矩陣中的資料：
> profit[1,] [1] 2.0 2.2 2.3上列會取得第一列的資料。
> profit[,2] [1] 2.2 2.1上列會取得第二欄的資料。
> profit[1,3] [1] 2.3上列會取得第一列、第三欄的資料。 你可以比較原來的向量和之後的矩陣，看資料是怎麼放的。
var pt = new RegExp(pattern, modifiers);或是
var pt = /pattern/modifiers; //我自己實作上比較常用這一方式上列語法中：
pattern是我們要定義的「表式示的模式」(pattern of expression)。
modifiers指明我們想要做是「不分大小寫」、「全部」或「多行」的比對，定義如下：i：做不分大小寫(case-0insensitvie matching)的比對。g：對全部要比對的字串，做比對，而不是比對成功後就停下來。m：做多行的比對。
//這個表示式的意思是，要找比對的字串中，有沒有含有字母「e」或「E」。
var reg1 = new RegExp('e', 'i');
//或者 var reg1 = /e/i; 請注意，這裡不用單引號或雙引號來包字串
//然後用來測試字串
reg1.test('e'); //結果 true
reg1.test('E'); //結果 true
這次若不加i再測試看看：
//這個表示式的意思是，要找比對的字串中，有沒有含有字母「e」，
//沒加「i」，所以有分大小寫
var reg1 = new RegExp('e');
reg1.test('e'); //結果為 true
reg1.test('E'); //結果為 false
從上列結果來看，若有加i的modifier的話，則在比對時，就不會去分大小寫。
g這個modifier，要看這個參數的功能我們要用String的match()函式來說明。
var reg = /has/; var para = 'He has a friend who has a dog that has long tail'; para.match(reg); //結果為has在上列程式中，
match()函式會以array object回傳比對成功的結果，雖然在我們比對的字串para中有三個has，但這裡回傳的陣列只包含了第一個比對成功的字串。
g參數：
var reg = /has/g; para.match(reg); //結果 has,has,has現在回傳的陣列長度為3，包含了三個「has」了。
var reg = /has/gi; //比對不分大小寫，而且要比對到字串結尾為止 para.match(reg); //結果 has,has,has至於
m這個modifier，目前還沒想到比較好的例子，在這裡先跳過了。
mode()，這個函數，它需要一個R物件當做參數，下列是一些例子：
1.41421，在 R 的模式是numberic：
> mode(1.141421) [1] "numeric"
"Hello R"的模式是character：
> mode("Hello R")
[1] "character"
當我們指定了一個向量(Vector)後，它的模式是由它所包含的元素來決定的：
> n <- c(1, 2, 3, 4, 5)
> mode(n)
[1] "numeric"
> n1 <- c("a", "b", "c")
> mode(n1)
[1] "character"
上列n變數所包含的元素的模式皆為numeric所以它的模式是numeric。
n1，它所包含的元素的模式皆為character所以它的模式是character。
> list2 <- list(1, 2, 3, "x", "y", "z") > mode(list2) [1] "list"因為我們在【R筆記】初探R資料結構-列表(List)中有提到，在列表所包含的元素，其模式可以不一樣，所以使用
mode()函式看模式時，有另一種list的模式。
print()函式的模式是function
> mode(print) [1] "function"在R中，每一個物件也有一個類別(class)，相對於模式來講，它具備的是比較抽象的概念，R根據一個物件類別，來決定以何種方式來做資料處理。 如我們看一個內建的資料集
mtcars的模式和類別：
> mode(mtcars) [1] "list" > class(mtcars) [1] "data.frame"上列結果說明，
mtcars這個資料集是以list型式儲存在記憶體中，而我們要處理它時，如使用print()函式將mtcars輸出，R會依據它的類別來做合適的處理。
> mylist <- list(1, 2, 3, 4, 5) > mylist [[1]] [1] 1 [[2]] [1] 2 [[3]] [1] 3 [[4]] [1] 4 [[5]] [1] 5跟向量(vector)不一樣的是，列表中的元素可以是異質 (heterogeneous) 的。
> list2 <- list(1, 2, 3, "x", "y", "z") > list2 [[1]] [1] 1 [[2]] [1] 2 [[3]] [1] 3 [[4]] [1] "x" [[5]] [1] "y" [[6]] [1] "z"我們可以使用索引(index)來取得或參照到列表中某一位置的元表 下列的指令，參照到
list2中第三個元素：
> list2[[3]] [1] 3鏘鏘鏘！這裡的中括號要有兩個，請記住，是兩個！
> list2[c(1, 3, 5)] [[1]] [1] 1 [[2]] [1] 3 [[3]] [1] "y"鏘鏘鏘！這裡的中括號只有一個！
> names(list2) <- c("le1", "le2", "le3", "le4", "le5", "le6")
> list2
$le1
[1] 1
$le2
[1] 2
$le3
[1] 3
$le4
[1] "x"
$le5
[1] "y"
$le6
[1] "z"
在指定元素名稱之後，要取得某一位置的元素，除了使用索引值之外，也可以使用「元素名稱」當索引來取得：
> list2[["le1"]] [1] 1或使用「list名稱$元素名稱」的方式來取得：
> list2$le1 [1] 1鏘鏘鏘！上列指令中，兩個名稱之間是一個「$」符號。 如果你需要進一步地認識 R，我推薦：
d，則在指定的元素中，需要是同型別的：
> d <- c(1, 2, 3, 4, 5) > d [1] 1 2 3 4 5若我們在指定 Vector 時，指定了不同型別的元素，則 R 會自動幫我們轉型：
> e <- c(1, 2, "a", "b") > e [1] "1" "2" "a" "b"或是
> f <- c(2.0, e) > f [1] "2" "1" "2" "a" "b"Vector可以使用索引 (index) 來取得某一位置的元素，如： > d[3] [1] 3 上列的指令取得
d中第三個元素的值，這裡要注意的是，在R中的索引，是由1算起，而不是0。> d <- c(2, 4, 6, 8, 10) > g <- d[c(1, 3, 5)] > g [1] 2 6 10Vector 中的元素可以被設定一個名稱，Vector 有一個
names的屬性，我們可以使用它來設定 Vector 的元素名稱，如：
> names(d) <- c("element1", "element2", "element3", "element4", "element5")
> d
element1 element2 element3 element4 element5
2 4 6 8 10
請注意，這裡的names有「s」。
一旦給了元素名稱之後，我們也就可以使用名稱來取得 Vector 的元素了：
> d["element1"]
element1
2
鏘！鏘！在中括號的元素名稱，請記得用兩個「"」 (雙引號) 包起來喔！
R中，有一些內建的資料集，在學習或練習時，可以用來當做原始資料，如：
> CO2 Plant Type Treatment conc uptake 1 Qn1 Quebec nonchilled 95 16.0 2 Qn1 Quebec nonchilled 175 30.4 3 Qn1 Quebec nonchilled 250 34.8 4 Qn1 Quebec nonchilled 350 37.2 (以下略)上列結果會列出
CO2這資料集中的欄位和資料，若只是要看某一欄位內的資料，可以使用「資料集名稱$欄位名稱」的指令來取得，如：
> CO2$Plant [1] Qn1 Qn1 Qn1 Qn1 Qn1 Qn1 Qn1 Qn2 Qn2 Qn2 Qn2 Qn2 Qn2 Qn2 Qn3 Qn3 Qn3 [18] Qn3 Qn3 Qn3 Qn3 Qc1 Qc1 Qc1 Qc1 Qc1 Qc1 Qc1 Qc2 Qc2 Qc2 Qc2 Qc2 Qc2 [35] Qc2 Qc3 Qc3 Qc3 Qc3 Qc3 Qc3 Qc3 Mn1 Mn1 Mn1 Mn1 Mn1 Mn1 Mn1 Mn2 Mn2 [52] Mn2 Mn2 Mn2 Mn2 Mn2 Mn3 Mn3 Mn3 Mn3 Mn3 Mn3 Mn3 Mc1 Mc1 Mc1 Mc1 Mc1 [69] Mc1 Mc1 Mc2 Mc2 Mc2 Mc2 Mc2 Mc2 Mc2 Mc3 Mc3 Mc3 Mc3 Mc3 Mc3 Mc3 12 Levels: Qn1 < Qn2 < Qn3 < Qc1 < Qc3 < Qc2 < Mn3 < Mn2 < ... < Mc1當我們要知道這些資料集中欄位意思等資訊，可以使用
help()這個函式來開啟資料的相關文件：
> help(CO2)或是
> ?CO2就可以看到資料集描述、欄位定義與用法等資訊：
data()這個函式：
> data()執行後，就會出現資料集的說明文件：
data()，但此時要傳入兩個參數，第一個參數是我們要引入的「資料集名稱」，第二個參數是該資料集所在的「套件名稱」，如在MASS套件中，有一名為Cars93的資料集，在引入之前使用他，會得這樣的結果：
> Cars93 錯誤: 找不到物件 'Cars93'若我們先執行下列指令：
> data(Cars93, package="MASS")再看一次
Cars93的內容，就會看到他的資料結構：
> Cars93
Manufacturer Model Type Min.Price Price Max.Price
1 Acura Integra Small 12.9 15.9 18.8
2 Acura Legend Midsize 29.2 33.9 38.7
3 Audi 90 Compact 25.9 29.1 32.3
4 Audi 100 Midsize 30.8 37.7 44.6
5 BMW 535i Midsize 23.7 30.0 36.2
6 Buick Century Midsize 14.2 15.7 17.3
7 Buick LeSabre Large 19.9 20.8 21.7
8 Buick Roadmaster Large 22.6 23.7 24.9
9 Buick Riviera Midsize 26.3 26.3 26.3
(以下略)
若我們己經有使用library()函式去引入MASS這個套件，則我們可以直接使用Cars93這個資料集。
> ?library它的功能就是「載入並掛載附加套件」。 這個函式主要功能在用來載入我們要用的R套件，比如我們要用一函式名稱為 lda，首先想要瞭解一下它的用法：
> ?lda No documentation for ‘lda’ in specified packages and libraries: you could try ‘??lda’但我們會得上列的錯誤訊息，意思是說，在目前的套件或函式庫找不到 lad 這個函式的說明，它又很好心地告訴我們，可以試試「??lda」，於是我們在 console 中輸入：
> ??lda就會跑出來搜尋的結果的說明文件：
> library(MASS)引入之後，我們再輸入「?lda」這個指令，說明文件就會直接開啟，而不會回傳任何錯誤訊息了。
> search() [1] ".GlobalEnv" "package:MASS" "tools:RGUI" [4] "package:stats" "package:graphics" "package:grDevices" [7] "package:utils" "package:datasets" "package:methods" [10] "Autoloads" "package:base"嗯哼！在結果中，可以看出目前引入的套件，也包含 MASS 這個套件。 在引入某個套件後，若要缷除 (detach) 它，可以使用 detach() 這個命令，它需要傳入一個參數，就是我們要缷除的套件名稱，如：
> detach(package:MASS)這裡要注意的是，在參數中，缷除的套件名稱前，需要加「package:」。 缷除後，我們再使用 search()，再次檢視引入的套件時，就看不到「MASS」這個套件了:
> detach(package:MASS) > > search() [1] ".GlobalEnv" "tools:RGUI" "package:stats" [4] "package:graphics" "package:grDevices" "package:utils" [7] "package:datasets" "package:methods" "Autoloads" [10] "package:base"如果你需要進一步地認識 R，我推薦：
$ ./redis-cli -h your_ip使用 Redis client 要關閉與伺服器的連線，使用下列指令：
isset($x, $y, $z);當所有傳入的變數都有被設置時，此函式才會回傳 true。
var_dump(empty($v0)); //若變數傳入 empty 前未宣告 ，empty 回傳：true
var_dump(is_null($v0)); //若變數傳入 is_null 前未宣告，
//is_null 會報「Undefined variable」的錯誤
var_dump(isset($v0)); //若變數傳入 isset 前未宣告 ，isset 回傳：false
$v1 = "";
var_dump(empty($v1)); //若變數值為 ""，empty 回傳：true
var_dump(is_null($v1)); //若變數值為 ""，is_null 回傳：false
var_dump(isset($v1)); //若變數值為 ""，isset 回傳：true
$v2 = NULL;
var_dump(empty($v2)); //若變數值為 NULL，empty 回傳：true
var_dump(is_null($v2)); //若變數值為 NULL，is_null 回傳：true
var_dump(isset($v2)); //若變數值為 NULL，isset 回傳：false
$v3 = array(); //（空陣列）
var_dump(empty($v3)); //若變數值為 array() (空陣列)，empty 回傳：true
var_dump(is_null($v3)); //若變數值為 array() (空陣列)，is_null 回傳：false
var_dump(isset($v3)); //若變數值為 array() (空陣列)，isset 回傳：true
$v4 = FALSE;
var_dump(empty($v4)); //若變數值為 FALSE，empty 回傳：true
var_dump(is_null($v4)); //若變數值為 FALSE，is_null 回傳：false
var_dump(isset($v4)); //若變數值為 FALSE，isset 回傳：true
$v5 = TRUE;
var_dump(empty($v5)); //若變數值為 TRUE，empty 回傳：false
var_dump(is_null($v5)); //若變數值為 TRUE，is_null 回傳：false
var_dump(isset($v5)); //若變數值為 TRUE，isset 回傳：true
$v6 = "FALSE";
var_dump(empty($v6)); //若變數值為 "FALSE"(字串)，empty 回傳：false
var_dump(is_null($v6)); //若變數值為 "FALSE"(字串)，is_null 回傳：false
var_dump(isset($v6)); //若變數值為 "FALSE"(字串)，isset 回傳：true
$v7 = "TRUE";
var_dump(empty($v7)); //若變數值為 "TRUE"(字串)，empty 回傳：false
var_dump(is_null($v7)); //若變數值為 "TRUE"(字串)，is_null 回傳：false
var_dump(isset($v7)); //若變數值為 "TRUE"(字串)，isset 回傳：true
$v8 = 0;
var_dump(empty($v8)); //若變數值為 0，empty 回傳：true
var_dump(is_null($v8)); //若變數值為 0，is_null 回傳：false
var_dump(isset($v8)); //若變數值為 0，isset 回傳：true
$v9 = "0";
var_dump(empty($v9)); //若變數值為"0"(字串)，empty 回傳：true
var_dump(is_null($v9)); //若變數值為"0"(字串)，is_null 回傳：false
var_dump(isset($v9)); //若變數值為 "0"(字串)，isset 回傳：true
package idv.jk.math;
import java.math.BigDecimal;
public class BigDecimalEx {
public static void main(String... args){
double a = 3.454;
double b = new BigDecimal(a)
.setScale(1, BigDecimal.ROUND_HALF_UP)
.doubleValue();
System.out.println("四捨五入到小數點下一位: " + b);
b = new BigDecimal(a)
.setScale(2, BigDecimal.ROUND_HALF_UP)
.doubleValue();
System.out.println("四捨五入到小數點下二位: " + b);
}
}
四捨五入到小數點下一位: 3.5 四捨五入到小數點下二位: 3.45
package idv.jk.math;
import java.math.BigDecimal;
public class BigDecimalEx {
public static void main(String... args){
double a = 3.45;
double b = new BigDecimal(a)
.setScale(1, BigDecimal.ROUND_HALF_UP)
.doubleValue();
System.out.println("四捨五入(ROUND_HALF_UP)到小數點下一位: " + b);
b = new BigDecimal(a)
.setScale(1, BigDecimal.ROUND_HALF_DOWN)
.doubleValue();
System.out.println("四捨五入(ROUND_HALF_DOWN)到小數點下一位: " + b);
}
}
四拾五入(ROUND_HALF_UP)到小數點下一位: 3.5 四拾五入(ROUND_HALF_DOWN)到小數點下一位: 3.5
package idv.jk.math;
import java.math.BigDecimal;
public class BigDecimalEx {
public static void main(String... args){
String a = "3.45";
double b = new BigDecimal(a)
.setScale(1, BigDecimal.ROUND_HALF_UP)
.doubleValue();
System.out.println("四捨五入(ROUND_HALF_UP)到小數點下一位: " + b);
b = new BigDecimal(a)
.setScale(1, BigDecimal.ROUND_HALF_DOWN)
.doubleValue();
System.out.println("四捨五入(ROUND_HALF_DOWN)到小數點下一位: " + b);
}
}
四捨五入(ROUND_HALF_UP)到小數點下一位: 3.5 四捨五入(ROUND_HALF_DOWN)到小數點下一位: 3.4
v <- (1, 2, 3, 4, 5)上列的指定中，v 這個變數被指定了含有五個數字的集合。
ch <- c('a', 'b', 'c')
上列的指定中，ch 這個變數被指定了含有三個字元的集合。help(c)來看如何使用他的說明。
v4 <- c(1, 2, 3, 6:10)這指定了「1, 3, 3, 6, 7, 8, 9, 10」給 v4 這個變數。
v4[1]這表示取得 v4 中的第一元素，這裡要注意的是 vector 的 index 是從 1 開始算的。
v4[v4 >=6]結果：
sd(v)或者使用 mean 函數來取得平均值，如：
mean(v)vector 另一個好用的地方，在於可以一次對 vector 中的所有元素 (element) 做運算，如：
1/v結果就會得到 v 中每一個元素的倒數。 也可以對兩個 vector 做加減乘除的運算，例如我們另外指定一個 v1 的變數：
v1 <- (2, 4, 6, 8, 10, 3, 6, 9, 12, 15)
v/v1依序就會得到 v 第1個元素除以 v1 第1個元素的值、 v 第2個元素除以 v4 第2個元素的值...， v 第1個元素除以 v4 第6個元素的值，以此類推。
警告訊息： In v/v1 : 較長的物件長度並非較短物件長度的倍數
x <- 168就是把「168」這個值指給「x」這個區域變數 (local variable)。
x = 168但這樣的方式可能會和「==」這個比較的運算子搞混，因此不建議這樣使用。
168 -> x但這樣程式碼一多的時候，會降低程式碼的可讀性，因此也不建議這樣使用。
x <<- 168這個指定方式是把「168」這個值指定給「x」這個「全域變數 (global variable)」。
x<-168但這樣擠在一起，程式看起來就不那麼易讀了。
> assign("y", 1234)
> y
[1] 1234
我在指定一個變數之後，直接在 console 中輸入該變數，就可以輸出該變數的值了：> x [1] 168這樣的結果，和使用 print 這個函數輸出的結果一樣：
> print(x) [1] 168當我要列出我有指定過的變數時，我可以用
> ls() [1] "x" "y"最後，當我離開 R 時，若有儲存工作空間，指定過的變數也會被儲存，再次開啟時，這些變數也一樣可以再被使用。
getwd();
