第三十四章 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