第三十四章 Caché 函數大全 $LISTSAME 函數 第三十四章 Caché 函數大全 $LISTSAME 函數 大綱 描述 示例

第三十四章 Caché 函數大全 $LISTSAME 函數

比較兩個列表並返回一個布爾值。

大綱

$LISTSAME(list1,list2)
$LS(list1,list2)

參數

• list1 任何計算結果爲列表的表達式。可以使用$LISTBUILD或$LISTFROMSTRING創建列表，或使用$LIST從另一個列表中提取列表。空字符串（“”）也被視爲有效列表。
• list2 任何計算結果爲列表的表達式。可以使用$LISTBUILD或$LISTFROMSTRING創建列表，或使用$LIST從另一個列表中提取列表。空字符串（“”）也被視爲有效列表。

描述

$LISTSAME比較兩個列表的內容，如果列表相同，則返回1。如果列表不相同，則$LISTSAME返回0。$LISTSAME使用其字符串表示形式比較列表元素。 $LISTSAME比較區分大小寫。

$LISTSAME按從左到右的順序逐個元素比較兩個列表。因此，$LISTSAME在遇到第一對不同的列表元素對時將返回值0；它不會檢查後續項目以確定它們是否是有效的列表元素。如果$LISTSAME比較遇到無效項目，則會發出<LIST>錯誤。

示例

下面的示例返回1，因爲兩個列表相同：

/// d ##class(PHA.TEST.Function).LISTSAME()
ClassMethod LISTSAME()
{
    SET x = $LISTBUILD("Red","Blue","Green")
    SET y = $LISTBUILD("Red","Blue","Green")
    WRITE $LISTSAME(x,y)
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME()
1

下面的示例返回0，因爲兩個列表不相同：

/// d ##class(PHA.TEST.Function).LISTSAME1()
ClassMethod LISTSAME1()
{
    SET x = $LISTBUILD("Red","Blue","Yellow")
    SET y = $LISTBUILD("Red","Yellow","Blue")
    WRITE $LISTSAME(x,y)
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME1()
0

相同LIST

如果兩個列表的字符串表示形式相同，則$LISTSAME認爲兩個列表相同。

比較數字列表元素和字符串列表元素時，字符串列表元素必須以規範形式表示數字。這是因爲Caché總是在執行比較之前將數字簡化爲規範形式。在下面的示例中，$LISTSAME比較字符串和數字。前三個$LISTSAME函數返回1（相同）；第四個$LISTSAME函數返回0（不相同），因爲字符串表示形式不是規範形式：

/// d ##class(PHA.TEST.Function).LISTSAME2()
ClassMethod LISTSAME2()
{
    WRITE $LISTSAME($LISTBUILD("365"),$LISTBUILD(365)),!
    WRITE $LISTSAME($LISTBUILD("365"),$LISTBUILD(365.0)),!
    WRITE $LISTSAME($LISTBUILD("365.5"),$LISTBUILD(365.5)),!
    WRITE $LISTSAME($LISTBUILD("365.0"),$LISTBUILD(365.0))
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME2()
1
1
1
0

$LISTSAME比較與其他列表操作使用的等效測試不同，後者使用列表的內部表示進行測試。比較數字和數字字符串時，很容易看出這種區別，如以下示例所示

/// d ##class(PHA.TEST.Function).LISTSAME3()
ClassMethod LISTSAME3()
{
    SET x = $LISTBUILD("365")
    SET y = $LISTBUILD(365)
    IF x=y { 
        WRITE !,"Equal sign: number/numeric string identical" 
    } ELSE { 
        WRITE !,"Equal sign: number/numeric string differ" 
    }
    IF 1=$LISTSAME(x,y) { 
        WRITE !,"$LISTSAME: number/numeric string identical" 
    } ELSE { 
        WRITE !,"$LISTSAME: number/numeric string differ" 
    }
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME3()
 
Equal sign: number/numeric string differ
$LISTSAME: number/numeric string identical

相等（=）比較測試這些列表的內部表示（不完全相同）。 $LISTSAME在兩個列表上執行字符串轉換，比較它們，然後發現它們相同。

下面的示例顯示兩個列表，其中包含數字元素的各種表示形式。 $LISTSAME認爲這兩個列表是相同的：

/// d ##class(PHA.TEST.Function).LISTSAME4()
ClassMethod LISTSAME4()
{
    SET x = $LISTBUILD("360","361","362","363","364","365","366")
    SET y = $LISTBUILD(00360.000,(19*19),+"362",363,364.0,+365,"3"_"66")
    WRITE !,$LISTSAME(x,y)," lists 相同"
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME4()
 
1 lists 相同

數值最大值

大於2**63 (9223372036854775810)）或小於 -2**63 (–9223372036854775808) 的數字超出了$LISTSAME列表比較的最大數值範圍。比較如此巨大的數字時，$LISTSAME返回0，如以下示例所示：

/// d ##class(PHA.TEST.Function).LISTSAME5()
ClassMethod LISTSAME5()
{
    SET bignum=$LISTBUILD(9223372036854775810)
    SET bigstr=$LISTBUILD("9223372036854775810")  
    WRITE $LISTSAME(bignum,bigstr),!
    SET bignum=$LISTBUILD(9223372036854775811)
    SET bigstr=$LISTBUILD("9223372036854775811")
    WRITE $LISTSAME(bignum,bigstr)
}

DHC-APP> d ##class(PHA.TEST.Function).LISTSAME5()
1
0

空字符串和空列表

包含空字符串（空字符串）作爲唯一元素的列表是有效列表。空字符串本身也被視爲有效列表。但是，這兩個值（一個空字符串和一個空列表）並不相同，如以下示例所示：

/// d ##class(PHA.TEST.Function).LISTSAME6()
ClassMethod LISTSAME6()
{
    WRITE !,$LISTSAME($LISTBUILD(""),$LISTBUILD(""))," null lists"
    WRITE !,$LISTSAME("","")," null strings"
    WRITE !,$LISTSAME($LISTBUILD(""),"")," null list and null string"
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME6()
 
1 null lists
1 null strings
0 null list and null string

通常，字符串不是有效的$LISTSAME參數，並且$LISTSAME發出<LIST>錯誤。但是，以下$LISTSAME比較成功完成並返回0（值不相同）。比較空字符串和字符串“abc”，發現不相同。這些空字符串比較不會發出<LIST>錯誤：

DHC-APP>WRITE !,$LISTSAME("","abc")
 
0
DHC-APP>WRITE !,$LISTSAME("abc","")
 
0

以下$LISTSAME比較確實會發出錯誤，因爲列表（甚至是空列表）無法與字符串進行比較：

/// d ##class(PHA.TEST.Function).LISTSAME7()
ClassMethod LISTSAME7()
{
    SET x = $LISTBUILD("")
    WRITE !,$LISTSAME("abc",x)
    WRITE !,$LISTSAME(x,"abc")
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME7()
 
 
 WRITE !,$LISTSAME("abc",x)
         ^
<LIST>zLISTSAME7+2^PHA.TEST.Function.1

比較“空”list

$LISTVALID將以下所有內容視爲有效列表：

/// d ##class(PHA.TEST.Function).LISTSAME8()
ClassMethod LISTSAME8()
{
    WRITE $LISTVALID(""),!
    WRITE $LISTVALID($LB()),!
    WRITE $LISTVALID($LB(UndefinedVar)),!
    WRITE $LISTVALID($LB("")),!
    WRITE $LISTVALID($LB($CHAR(0))),!
    WRITE $LISTVALID($LB(,))
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME8()
1
1
1
1
1
1

$LISTSAME僅將以下對視爲相同：

/// d ##class(PHA.TEST.Function).LISTSAME9()
ClassMethod LISTSAME9()
{
    WRITE $LISTSAME($LB(),$LB(UndefinedVar)),!
    WRITE $LISTSAME($LB(,),$LB(UndefinedVarA,UndefinedVarB)),!
    WRITE $LISTSAME($LB(,),$LB()_$LB())
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME9()
1
1
1

空元素

$LISTBUILD可以通過在元素之間包括多餘的逗號或將一個或多個逗號附加到元素列表的任一末端來創建空元素。 $LISTSAME知道空元素，並且不會將它們視爲等同於空字符串元素。

以下$LISTSAME示例全部返回0（不相同）：

/// d ##class(PHA.TEST.Function).LISTSAME10()
ClassMethod LISTSAME10()
{
    WRITE $LISTSAME($LISTBUILD(365,,367),$LISTBUILD(365,367)),!
    WRITE $LISTSAME($LISTBUILD(365,366,),$LISTBUILD(365,366)),!
    WRITE $LISTSAME($LISTBUILD(365,366,,),$LISTBUILD(365,366,)),!
    WRITE $LISTSAME($LISTBUILD(365,,367),$LISTBUILD(365,"",367))
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME10()
0
0
0
0

$DOUBLE列表元素

$LISTSAME認爲所有零形式都相同：0，–0，$DOUBLE（0）和$DOUBLE（-0）。

$LISTSAME認爲$DOUBLE（“NAN”）列表元素與另一個$DOUBLE（“NAN”）列表元素相同。但是，由於不能使用數值運算符對NAN（非數字）進行有意義的比較，因此嘗試將$DOUBLE（“NAN”）與另一個$DOUBLE（“NAN”）進行比較的Caché操作（例如，等於，小於或大於）失敗，如以下示例所示：

/// d ##class(PHA.TEST.Function).LISTSAME11()
ClassMethod LISTSAME11()
{
    SET x = $DOUBLE("NAN")
    SET a = $LISTBUILD(1,2,x)
    SET b = $LISTBUILD(1,2,x)
    WRITE !,$LISTSAME(a,b)    /* 1 (NAN list elements same) */
    WRITE !,x=x               /* 0 (NAN values not equal)   */
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME11()
 
1
0

嵌套列表和串聯列表

$LISTSAME不支持嵌套列表。它不能比較兩個包含列表的列表，即使它們的內容相同。

/// d ##class(PHA.TEST.Function).LISTSAME12()
ClassMethod LISTSAME12()
{
    SET x = $LISTBUILD("365")
    SET y = $LISTBUILD(365)
    WRITE !,$LISTSAME(x,y)," lists identical"
    WRITE !,$LISTSAME($LISTBUILD(x),$LISTBUILD(y))," nested lists not identical"
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME12()
 
1 lists identical
0 nested lists not identical

在下面的示例中，兩個$LISTSAME比較都返回0，因爲這些列表不被視爲相同：

/// d ##class(PHA.TEST.Function).LISTSAME13()
ClassMethod LISTSAME13()
{
    SET x=$LISTBUILD("Apple","Pear","Walnut","Pecan")
    SET y=$LISTBUILD("Apple","Pear",$LISTBUILD("Walnut","Pecan"))
    SET z=$LISTBUILD("Apple","Pear","Walnut","Pecan","")
    WRITE !,$LISTSAME(x,y)," nested list"
    WRITE !,$LISTSAME(x,z)," null string is list item"
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME13()
 
0 nested list
0 null string is list item

$LISTSAME不支持串聯列表。下面的示例返回1，因爲列表被認爲是相同的：

/// d ##class(PHA.TEST.Function).LISTSAME14()
ClassMethod LISTSAME14()
{
    SET x=$LISTBUILD("Apple","Pear","Walnut","Pecan")
    SET y=$LISTBUILD("Apple","Pear")_$LISTBUILD("Walnut","Pecan")
    WRITE !,$LISTSAME(x,y)," concatenated list"
}

DHC-APP>d ##class(PHA.TEST.Function).LISTSAME14()
 
1 concatenated list