表達式引擎aviator

Aviator是一個輕量級、高性能的Java表達式執行引擎, 本文內容主要來自於官方文檔html

簡介

Aviator是一個高性能、輕量級的 java 語言實現的表達式求值引擎, 主要用於各類表達式的動態求值。如今已經有不少開源可用的 java 表達式求值引擎,爲何還須要 Avaitor 呢?
Aviator的設計目標是輕量級和高性能,相比於Groovy、JRuby的笨重, Aviator很是小, 加上依賴包也才450K,不算依賴包的話只有 70K; 固然, Aviator的語法是受限的, 它不是一門完整的語言, 而只是語言的一小部分集合。
其次, Aviator的實現思路與其餘輕量級的求值器很不相同, 其餘求值器通常都是經過解釋的方式運行, 而Aviator則是直接將表達式編譯成Java 字節碼, 交給JVM去執行。簡單來講, Aviator的定位是介於Groovy這樣的重量級腳本語言和IKExpression這樣的輕量級表達式引擎之間。
Aviator支持大部分運算操做符, 包括算術操做符、關係運算符、邏輯操做符、位運算符、正則匹配操做符(=~)、三元表達式(?:), 而且支持操做符的優先級和括號強制優先級, 具體請看後面的操做符列表, 支持自定義函數.java

包依賴

Aviator依賴了commons-beanutils, 使用Aviator能夠添加下面的maven依賴:正則表達式

<dependency> <groupId>com.googlecode.aviator</groupId> <artifactId>aviator</artifactId> <version>2.3.3</version> </dependency>

使用手冊

執行表達式

Aviator的使用都是集中經過com.googlecode.aviator.AviatorEvaluator這個入口類來處理, 最簡單的例子, 執行一個計算1+2+3的表達式:express

import com.googlecode.aviator.AviatorEvaluator; public class TestAviator { public static void main(String[] args) { Long result = (Long) AviatorEvaluator.execute("1+2+3"); System.out.println(result); } }

細心的朋友確定注意到結果是Long,而不是Integer。這是由於Aviator的數值類型僅支持Long和Double, 任何整數都將轉換成Long, 任何浮點數都將轉換爲Double, 包括用戶傳入的變量數值。這個例子的打印結果將是正確答案6。編程

使用變量

想讓Aviator對你say hello嗎? 很簡單, 傳入你的名字, 讓Aviator負責字符串的相加:數組

public class TestAviator { public static void main(String[] args) { String yourName = "Michael"; Map<String, Object> env = new HashMap<String, Object>(); env.put("yourName", yourName); String result = (String) AviatorEvaluator.execute(" 'hello ' + yourName ", env); System.out.println(result); // hello Michael } }

上面的例子演示了怎麼向表達式傳入變量值, 表達式中的yourName是一個變量, 默認爲null, 經過傳入Map<String,Object>的變量綁定環境, 將yourName設置爲你輸入的名稱。 env 的key是變量名, value是變量的值。
上面例子中的'hello '是一個Aviator的String, Aviator的String是任何用單引號或者雙引號括起來的字符序列, String能夠比較大小(基於unicode順序), 能夠參與正則匹配, 能夠與任何對象相加, 任何對象與String相加結果爲String。 String中也能夠有轉義字符,如\n、\\、\' 等。緩存

AviatorEvaluator.execute(" 'a\"b' "); // 字符串 a"b AviatorEvaluator.execute(" \"a\'b\" "); // 字符串 a'b AviatorEvaluator.execute(" 'hello ' + 3 "); // 字符串 hello 3 AviatorEvaluator.execute(" 'hello '+ unknow "); // 字符串 hello null

exec 方法

Aviator 2.2 開始新增長一個exec方法, 能夠更方便地傳入變量並執行, 而不須要構造env這個map了:maven

String name = "dennis"; AviatorEvaluator.exec(" 'hello ' + yourName ", name); // hello dennis

只要在exec中按照變量在表達式中的出現順序傳入變量值就能夠執行, 不須要構建Map了。ide

調用函數

Aviator 支持函數調用, 函數調用的風格相似 lua, 下面的例子獲取字符串的長度:函數式編程

AviatorEvaluator.execute("string.length('hello')"); // 5

string.length('hello')是一個函數調用, string.length是一個函數, 'hello'是調用的參數。
再用string.substring來截取字符串:

AviatorEvaluator.execute("string.contains(\"test\", string.substring('hello', 1, 2))"); // true

經過string.substring('hello', 1, 2)獲取字符串'e', 而後經過函數string.contains判斷e是否在'test'中。能夠看到, 函數能夠嵌套調用。
Aviator 的內置函數列表請看後面。

自定義函數

Aviator 除了內置的函數以外,還容許用戶自定義函數,只要實現com.googlecode.aviator.runtime.type.AviatorFunction接口, 並註冊到AviatorEvaluator便可使用. AviatorFunction接口十分龐大, 一般來講你並不須要實現全部的方法, 只要根據你的方法的參數個數, 繼承AbstractFunction類並override相應方法便可。

能夠看一個例子,咱們實現一個add函數來作數值的相加:

public class TestAviator { public static void main(String[] args) { //註冊函數 AviatorEvaluator.addFunction(new AddFunction()); System.out.println(AviatorEvaluator.execute("add(1, 2)")); // 3.0 System.out.println(AviatorEvaluator.execute("add(add(1, 2), 100)")); // 103.0 } } class AddFunction extends AbstractFunction { @Override public AviatorObject call(Map<String, Object> env, AviatorObject arg1, AviatorObject arg2) { Number left = FunctionUtils.getNumberValue(arg1, env); Number right = FunctionUtils.getNumberValue(arg2, env); return new AviatorDouble(left.doubleValue() + right.doubleValue()); } public String getName() { return "add"; } }

註冊函數經過AviatorEvaluator.addFunction方法, 移除能夠經過removeFunction。

編譯表達式

上面提到的例子都是直接執行表達式, 事實上 Aviator 背後都幫你作了編譯並執行的工做。你能夠本身先編譯表達式, 返回一個編譯的結果, 而後傳入不一樣的env來複用編譯結果, 提升性能, 這是更推薦的使用方式:

public class TestAviator { public static void main(String[] args) { String expression = "a-(b-c)>100"; // 編譯表達式 Expression compiledExp = AviatorEvaluator.compile(expression); Map<String, Object> env = new HashMap<String, Object>(); env.put("a", 100.3); env.put("b", 45); env.put("c", -199.100); // 執行表達式 Boolean result = (Boolean) compiledExp.execute(env); System.out.println(result); // false } }

經過compile方法能夠將表達式編譯成Expression的中間對象, 當要執行表達式的時候傳入env並調用Expression的execute方法便可。表達式中使用了括號來強制優先級, 這個例子還使用了>用於比較數值大小, 比較運算符!=、==、>、>=、<、<=不只能夠用於數值, 也能夠用於String、Pattern、Boolean等等, 甚至是任何用戶傳入的兩個都實現了java.lang.Comparable接口的對象之間。

編譯後的結果你能夠本身緩存, 也能夠交給 Aviator 幫你緩存, AviatorEvaluator內部有一個全局的緩存池, 若是你決定緩存編譯結果, 能夠經過:

public static Expression compile(String expression, boolean cached)

將cached設置爲true便可, 那麼下次編譯同一個表達式的時候將直接返回上一次編譯的結果。
使緩存失效經過:

public static void invalidateCache(String expression)

方法。

訪問數組和集合

能夠經過中括號去訪問數組和java.util.List對象, 能夠經過map.key訪問java.util.Map中key對應的value, 一個例子:

public static void main(String[] args) { final List<String> list = new ArrayList<String>(); list.add("hello"); list.add(" world"); final int[] array = new int[3]; array[0] = 0; array[1] = 1; array[2] = 3; final Map<String, Date> map = new HashMap<String, Date>(); map.put("date", new Date()); Map<String, Object> env = new HashMap<String, Object>(); env.put("list", list); env.put("array", array); env.put("mmap", map); System.out.println(AviatorEvaluator.execute("list[0]+list[1]", env)); // hello world System.out.println(AviatorEvaluator.execute("'array[0]+array[1]+array[2]=' + (array[0]+array[1]+array[2])", env)); // array[0]+array[1]+array[2]=4 System.out.println(AviatorEvaluator.execute("'today is ' + mmap.date ", env)); // today is Wed Feb 24 17:31:45 CST 2016 }

三元操做符

Aviator 不提供if else語句, 可是提供了三元操做符?:用於條件判斷,使用上與 java 沒有什麼不一樣:

AviatorEvaluator.exec("a>0? 'yes':'no'", 1); // yes

Aviator 的三元表達式對於兩個分支的結果類型並不要求一致,能夠是任何類型,這一點與 java 不一樣。

正則表達式匹配

Aviator 支持類 Ruby 和 Perl 風格的表達式匹配運算,經過=~操做符, 以下面這個例子匹配 email 並提取用戶名返回:

public static void main(String[] args) { String email = "killme2008@gmail.com"; Map<String, Object> env = new HashMap<String, Object>(); env.put("email", email); String username = (String) AviatorEvaluator.execute("email=~/([\\w0-8]+)@\\w+[\\.\\w+]+/ ? $1 : 'unknow' ", env); System.out.println(username); // killme2008 }

email與正則表達式/([\\w0-8]+@\\w+[\\.\\w+]+)/經過=~操做符來匹配,結果爲一個 Boolean 類型, 所以能夠用於三元表達式判斷,匹配成功的時候返回$1,指代正則表達式的分組 1,也就是用戶名,不然返回unknown。

Aviator 在表達式級別支持正則表達式,經過//括起來的字符序列構成一個正則表達式,正則表達式能夠用於匹配(做爲=~的右操做數)、比較大小,匹配僅能與字符串進行匹配。匹配成功後, Aviator 會自動將匹配成功的分組放入$num的變量中,其中$0 指代整個匹配的字符串,而$1表示第一個分組,以此類推。

Aviator 的正則表達式規則跟 Java 徹底同樣,由於內部其實就是使用java.util.regex.Pattern作編譯的。

變量的語法糖

Aviator 有個方便用戶使用變量的語法糖, 當你要訪問變量a中的某個屬性b, 那麼你能夠經過a.b訪問到, 更進一步, a.b.c將訪問變量a的b屬性中的c屬性值, 推廣開來也就是說 Aviator 能夠將變量聲明爲嵌套訪問的形式。
TestAviator類符合JavaBean規範, 而且是 public 的，咱們就可使用語法糖:

public class TestAviator { int i; float f; Date date; // 構造方法 public TestAviator(int i, float f, Date date) { this.i = i; this.f = f; this.date = date; } // getter and setter public static void main(String[] args) { TestAviator foo = new TestAviator(100, 3.14f, new Date()); Map<String, Object> env = new HashMap<String, Object>(); env.put("foo", foo); System.out.println(AviatorEvaluator.execute("'foo.i = '+foo.i", env)); // foo.i = 100 System.out.println(AviatorEvaluator.execute("'foo.f = '+foo.f", env)); // foo.f = 3.14 System.out.println(AviatorEvaluator.execute("'foo.date.year = '+(foo.date.year+1990)", env)); // foo.date.year = 2106 } }

nil 對象

nil是 Aviator 內置的常量,相似 java 中的null,表示空的值。nil跟null不一樣的在於,在 java 中null只能使用在==、!=的比較運算符,而nil還可使用>、>=、<、<=等比較運算符。 Aviator 規定,任何對象都比nil大除了nil自己。用戶傳入的變量若是爲null,將自動以nil替代。

AviatorEvaluator.execute("nil == nil"); //true AviatorEvaluator.execute(" 3> nil"); //true AviatorEvaluator.execute(" true!= nil"); //true AviatorEvaluator.execute(" ' '>nil "); //true AviatorEvaluator.execute(" a==nil "); //true, a 是 null

nil與String相加的時候,跟 java 同樣顯示爲 null

日期比較

Aviator 並不支持日期類型,若是要比較日期,你須要將日期寫字符串的形式,而且要求是形如「yyyy-MM-dd HH:mm:ss:SS」的字符串,不然都將報錯。字符串跟java.util.Date比較的時候將自動轉換爲Date對象進行比較:

public static void main(String[] args) { Map<String, Object> env = new HashMap<String, Object>(); final Date date = new Date(); String dateStr = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS").format(date); env.put("date", date); env.put("dateStr", dateStr); Boolean result = (Boolean) AviatorEvaluator.execute("date==dateStr", env); System.out.println(result); // true result = (Boolean) AviatorEvaluator.execute("date > '2010-12-20 00:00:00:00' ", env); System.out.println(result); // true result = (Boolean) AviatorEvaluator.execute("date < '2200-12-20 00:00:00:00' ", env); System.out.println(result); // true result = (Boolean) AviatorEvaluator.execute("date==date ", env); System.out.println(result); // true }

也就是說String除了能跟String比較以外,還能跟nil和java.util.Date對象比較。

大數計算和精度

從 2.3.0 版本開始,aviator 開始支持大數字計算和特定精度的計算, 本質上就是支持java.math.BigInteger和java.math.BigDecimal兩種類型, 這兩種類型在 aviator 中簡稱爲big int和decimal類型。相似99999999999999999999999999999999這樣的數字在 Java 語言裏是沒辦法編譯經過的, 由於它超過了Long類型的範圍, 只能用BigInteger來封裝。可是 aviator 經過包裝,可以直接支持這種大整數的計算,例如:

public static void main(String[] args) { System.out.println(AviatorEvaluator.exec("99999999999999999999999999999999 + 99999999999999999999999999999999")); }

結果爲類型big int的: 199999999999999999999999999999998

字面量表示

big int和decimal的表示與其餘數字不一樣,兩條規則:

以大寫字母N爲後綴的整數都被認爲是big int,如1N,2N,9999999999999999999999N等, 都是big int類型。
超過long範圍的整數字面量都將自動轉換爲big int類型。
以大寫字母M爲後綴的數字都被認爲是decimal, 如1M,2.222M, 100000.9999M等, 都是decimal類型。

用戶也能夠經過變量傳入這兩種類型來參與計算。

運算

big int和decimal的運算,跟其餘數字類型long,double沒有什麼區別,操做符仍然是同樣的。 aviator重載了基本算術操做符來支持這兩種新類型:

public static void main(String[] args) { Object rt = AviatorEvaluator.exec("9223372036854775807100.356M * 2"); System.out.println(rt + " " + rt.getClass()); // 18446744073709551614200.712 class java.math.BigDecimal rt = AviatorEvaluator.exec("92233720368547758074+1000"); System.out.println(rt + " " + rt.getClass()); // 92233720368547759074 class java.math.BigInteger BigInteger a = new BigInteger(String.valueOf(Long.MAX_VALUE) + String.valueOf(Long.MAX_VALUE)); BigDecimal b = new BigDecimal("3.2"); BigDecimal c = new BigDecimal("9999.99999"); rt = AviatorEvaluator.exec("a+10000000000000000000", a); System.out.println(rt + " " + rt.getClass()); // 92233720368547758089223372036854775807 class java.math.BigInteger rt = AviatorEvaluator.exec("b+c*2", b, c); System.out.println(rt + " " + rt.getClass()); // 20003.19998 class java.math.BigDecimal rt = AviatorEvaluator.exec("a*b/c", a, b, c); System.out.println(rt + " " + rt.getClass()); // 2.951479054745007313280155218459508E+34 class java.math.BigDecimal }

類型轉換和提高

當big int或者decimal和其餘類型的數字作運算的時候,按照long < big int < decimal < double的規則作提高, 也就是說運算的數字若是類型不一致, 結果的類型爲二者之間更「高」的類型。例如:

1 + 3N, 結果爲big int的4N
1 + 3.1M,結果爲decimal的4.1M
1N + 3.1M,結果爲decimal的 4.1M
1.0 + 3N,結果爲double的4.0
1.0 + 3.1M,結果爲double的4.1

decimal 的計算精度

Java 的java.math.BigDecimal經過java.math.MathContext支持特定精度的計算,任何涉及到金額的計算都應該使用decimal類型。

默認 Aviator 的計算精度爲MathContext.DECIMAL128,你能夠自定義精度, 經過:

AviatorEvaluator.setMathContext(MathContext.DECIMAL64);

便可設置,更多關於decimal的精度問題請看java.math.BigDecimal的 javadoc 文檔。

強大的 seq 庫

aviator 擁有強大的操做集合和數組的 seq 庫。整個庫風格相似函數式編程中的高階函數。在 aviator 中, 數組以及java.util.Collection下的子類都稱爲seq,能夠直接利用 seq 庫進行遍歷、過濾和聚合等操做。

例如,假設我有個 list:

public static void main(String[] args) { Map<String, Object> env = new HashMap<String, Object>(); ArrayList<Integer> list = new ArrayList<Integer>(); list.add(3); list.add(20); list.add(10); env.put("list", list); Object result = AviatorEvaluator.execute("count(list)", env); System.out.println(result); // 3 result = AviatorEvaluator.execute("reduce(list,+,0)", env); System.out.println(result); // 33 result = AviatorEvaluator.execute("filter(list,seq.gt(9))", env); System.out.println(result); // [10, 20] result = AviatorEvaluator.execute("include(list,10)", env); System.out.println(result); // true result = AviatorEvaluator.execute("sort(list)", env); System.out.println(result); // [3, 10, 20] AviatorEvaluator.execute("map(list,println)", env); }

咱們能夠:

求長度: count(list)
求和: reduce(list,+,0), reduce函數接收三個參數,第一個是seq,第二個是聚合的函數,如+等,第三個是聚合的初始值
過濾: filter(list,seq.gt(9)), 過濾出list中全部大於9的元素並返回集合; seq.gt函數用於生成一個謂詞,表示大於某個值
判斷元素在不在集合裏: include(list,10)
排序: sort(list)
遍歷整個集合: map(list,println), map接受的第二個函數將做用於集合中的每一個元素,這裏簡單地調用println打印每一個元素

兩種運行模式

默認 AviatorEvaluator 以執行速度優先:

AviatorEvaluator.setOptimize(AviatorEvaluator.EVAL);

你能夠修改成編譯速度優先,這樣不會作編譯優化:

AviatorEvaluator.setOptimize(AviatorEvaluator.COMPILE);

調試信息

從 2.1.1.版本開始,Aviator容許設置輸出每一個表達式生成的字節碼,只要設置trace爲true便可:

AviatorEvaluator.setTrace(true);

方便用戶作跟蹤和調試。默認是輸出到標準輸出,你能夠改變輸出指向:

AviatorEvaluator.setTraceOutputStream(new FileOutputStream(new File("aviator.log")));

語法手冊

下面是 Aviator 詳細的語法規則定義。

數據類型

Number類型: 數字類型,支持四種類型,分別是long,double,java.math.BigInteger(簡稱 big int)和java.math.BigDecimal(簡稱 decimal),規則以下:
- 任何以大寫字母 N 結尾的整數都被認爲是 big int
- 任何以大寫字母 M 結尾的數字都被認爲是 decimal
- 其餘的任何整數都將被轉換爲 Long
- 其餘任何浮點數都將被轉換爲 Double
- 超過 long 範圍的整數字面量都將自動轉換爲 big int 類型

其中 big int 和 decimal 是 2.3.0 版本開始引入的。數字還支持十六進制(以0x或者0X開頭的數字), 以及科學計數法,如1e-3等。不支持其餘進制。

String類型: 字符串類型,單引號或者雙引號括起來的文本串,如'hello world', 變量若是傳入的是String或者Character也將轉爲String類型
Bool類型: 常量true和false,表示真值和假值,與 java 的Boolean.TRUE和Boolean.False對應
Pattern類型: 正則表達式, 以//括起來的字符串,如/\d+/,內部實現爲java.util.Pattern
變量類型: 與 Java 的變量命名規則相同,變量的值由用戶傳入
nil類型: 常量nil,相似 java 中的null,可是nil比較特殊,nil不只能夠參與==、!=的比較, 也能夠參與>、>=、<、<=的比較,Aviator 規定任何類型都大於nil除了nil自己,nil==nil返回true。用戶傳入的變量值若是爲null,那麼也將做爲nil處理,nil打印爲null

操做符

算術運算符

Aviator 支持常見的算術運算符,包括+ - * / %五個二元運算符,和一元運算符-(負)。其中- * / %和一元的-僅能做用於Number類型。
+不只能用於Number類型,還能夠用於String的相加,或者字符串與其餘對象的相加。
Aviator 規定,任何類型與String相加,結果爲String。

邏輯運算符

Avaitor 的支持的邏輯運算符包括,一元否認運算符!,以及邏輯與的&&,邏輯或的||。邏輯運算符的操做數只能爲Boolean。
&&和||都執行短路規則。

關係運算符

Aviator 支持的關係運算符包括<, <=, >, >=以及==和!= 。
關係運算符能夠做用於Number之間、String之間、Pattern之間、Boolean之間、變量之間以及其餘類型與nil之間的關係比較, 不一樣類型除了nil以外不能相互比較。

位運算符

Aviator 支持全部的 Java 位運算符,包括&, |, ^, ~, >>, <<, >>>。

匹配運算符

匹配運算符=~用於String和Pattern的匹配,它的左操做數必須爲String,右操做數必須爲Pattern。匹配成功後,Pattern的分組將存於變量$num,num爲分組索引。

三元運算符

Aviator 沒有提供if else語句,可是提供了三元運算符?:,形式爲bool ? exp1: exp2。其中bool必須爲Boolean類型的表達式, 而exp1和exp2能夠爲任何合法的 Aviator 表達式,而且不要求exp1和exp2返回的結果類型一致。

內置函數

函數名稱	說明
sysdate()	返回當前日期對象 java.util.Date
rand()	返回一個介於 0-1 的隨機數,double 類型
print([out],obj)	打印對象,若是指定 out,向 out 打印, 不然輸出到控制檯
println([out],obj)	與 print 相似,可是在輸出後換行
now()	返回 System.currentTimeMillis
long(v)	將值的類型轉爲 long
double(v)	將值的類型轉爲 double
str(v)	將值的類型轉爲 string
date_to_string(date,format)	將 Date 對象轉化化特定格式的字符串,2.1.1 新增
string_to_date(source,format)	將特定格式的字符串轉化爲 Date 對象,2.1.1 新增
string.contains(s1,s2)	判斷 s1 是否包含 s2,返回 Boolean
string.length(s)	求字符串長度,返回 Long
string.startsWith(s1,s2)	s1 是否以 s2 開始,返回 Boolean
string.endsWith(s1,s2)	s1 是否以 s2 結尾,返回 Boolean
string.substring(s,begin[,end])	截取字符串 s,從 begin 到 end,若是忽略 end 的話,將從 begin 到結尾,與 java.util.String.substring 同樣。
string.indexOf(s1,s2)	java 中的 s1.indexOf(s2),求 s2 在 s1 中的起始索引位置,若是不存在爲-1
string.split(target,regex,[limit])	Java 裏的 String.split 方法一致,2.1.1 新增函數
string.join(seq,seperator)	將集合 seq 裏的元素以 seperator 爲間隔鏈接起來造成字符串,2.1.1 新增函數
string.replace_first(s,regex,replacement)	Java 裏的 String.replaceFirst 方法, 2.1.1 新增
string.replace_all(s,regex,replacement)	Java 裏的 String.replaceAll 方法 , 2.1.1 新增
math.abs(d)	求 d 的絕對值
math.sqrt(d)	求 d 的平方根
math.pow(d1,d2)	求 d1 的 d2 次方
math.log(d)	求 d 的天然對數
math.log10(d)	求 d 以 10 爲底的對數
math.sin(d)	正弦函數
math.cos(d)	餘弦函數
math.tan(d)	正切函數
map(seq,fun)	將函數 fun 做用到集合 seq 每一個元素上, 返回新元素組成的集合
filter(seq,predicate)	將謂詞 predicate 做用在集合的每一個元素上,返回謂詞爲 true 的元素組成的集合
count(seq)	返回集合大小
include(seq,element)	判斷 element 是否在集合 seq 中,返回 boolean 值
sort(seq)	排序集合,僅對數組和 List 有效,返回排序後的新集合
reduce(seq,fun,init)	fun 接收兩個參數,第一個是集合元素, 第二個是累積的函數,本函數用於將 fun 做用在集合每一個元素和初始值上面,返回最終的 init 值
seq.eq(value)	返回一個謂詞,用來判斷傳入的參數是否跟 value 相等,用於 filter 函數,如filter(seq,seq.eq(3)) 過濾返回等於3 的元素組成的集合
seq.neq(value)	與 seq.eq 相似,返回判斷不等於的謂詞
seq.gt(value)	返回判斷大於 value 的謂詞
seq.ge(value)	返回判斷大於等於 value 的謂詞
seq.lt(value)	返回判斷小於 value 的謂詞
seq.le(value)	返回判斷小於等於 value 的謂詞
seq.nil()	返回判斷是否爲 nil 的謂詞
seq.exists()	返回判斷不爲 nil 的謂詞