第四十二章 Caché 函数大全 $NCONVERT 函数

最新推荐文章于 2022-02-18 09:32:01 发布

原创最新推荐文章于 2022-02-18 09:32:01 发布 · 592 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Caché #Cache #Nconvert #转换字节编码 #8位字符

Caché 函数大全专栏收录该内容

126 篇文章

订阅专栏

本文详细介绍了Caché数据库中$NCONVERT函数的功能与用法，包括如何将数字转换为不同格式的8位字符串编码，如整数与浮点数等，并展示了多个示例代码。

文章目录

第四十二章 Caché 函数大全 $NCONVERT 函数
大纲
- 参数
描述
示例

第四十二章 Caché 函数大全 $NCONVERT 函数

将数字转换为编码为8位字符串的二进制值。

大纲

$NCONVERT(n,format,endian)
$NC(n,format,endian)

参数

n 任何数字，可以指定为值、变量或表达式。所选格式对有效值施加了其他限制。
format 以下格式代码之一，指定为带引号的字符串：S1、S2、S4、S8、U1、U2、U4、F4或F8。
endian 可选-布尔值，其中0=小端，1=大端。默认值为0。

描述

$NCONVERT使用指定的格式将数字n转换为8位字符的编码字符串。这些字符的值在$CHAR(0)到$CHAR(255)之间。

以下是支持的格式代码:

S1 编码成一个8位字节字符串的有符号整数。该值必须在-128到127(含)的范围内。
S2 编码成两个8位字节字符串的有符号整数。该值必须在-32768到32767(含)的范围内.
S4 编码成四个8位字节字符串的有符号整数。该值必须在-2147483648到2147483647(含)的范围内。
S8 编码成八个8位字节字符串的有符号整数。该值必须在-9223372036854775808到9223372036854775807(含)的范围内。
U1 编码成一个8位字节字符串的无符号整数。最大值为255。
U2 编码成两个8位字节字符串的无符号整数。最大值为65535。
U4 编码成四个8位字节字符串的无符号整数。最大值为4294967295。
F4 IEEE浮点数编码成4个8位字节的字符串。
F8 编码成八个8位字节字符串的IEEE浮点数。

超出格式限制范围的值会导致<VALUE OUT OF RANGE>错误。为无符号格式指定负数会导致<VALUE OUT OF RANGE>错误。如果n是非数字值(包含任何非数字字符)，Caché会将字符串转换为数字值。以非数字字符开头的字符串被转换为0。

对于除F4和F8以外的所有格式，Caché将小数四舍五入为整数值。

可以使用IsBigEndian()类方法来确定在操作系统平台上使用哪种位顺序:1 =大端位顺序；0 =小端位顺序。

DHC-APP>WRITE $SYSTEM.Version.IsBigEndian()
0

$SCONVERT提供了$NCONVERT操作的逆操作。

示例

以下示例将一系列无符号数字转换为双字节编码值:

/// d ##class(PHA.TEST.Function).NCONVERT1()
ClassMethod NCONVERT1()
{
	FOR x=32:1:50 {
		ZZDUMP $NCONVERT(x,"U2") 
	}
	QUIT
}

DHC-APP>d ##class(PHA.TEST.Function).NCONVERT1()
 
0000: 20 00                                                    .
0000: 21 00                                                   !.
0000: 22 00                                                   ".
0000: 23 00                                                   #.
0000: 24 00                                                   $.
0000: 25 00                                                   %.
0000: 26 00                                                   &.
0000: 27 00                                                   '.
0000: 28 00                                                   (.
0000: 29 00                                                   ).
0000: 2A 00                                                   *.
0000: 2B 00                                                   +.
0000: 2C 00                                                   ,.
0000: 2D 00                                                   -.
0000: 2E 00                                                   ..
0000: 2F 00                                                   /.
0000: 30 00                                                   0.
0000: 31 00                                                   1.
0000: 32 00                                                   2.

超出255范围

/// d ##class(PHA.TEST.Function).NCONVERT()
ClassMethod NCONVERT()
{
	FOR x=254:1:256{
		ZZDUMP $NCONVERT(x,"U1") 
	}
	QUIT
}

DHC-APP>d ##class(PHA.TEST.Function).NCONVERT()
 
0000: FE                                                      ??
0000: FF                                                      ??
  ZZDUMP $NCONVERT(x,"U1")
  ^
<VALUE OUT OF RANGE>zNCONVERT+2^PHA.TEST.Function.1

以下示例按大端顺序执行相同的操作:

/// d ##class(PHA.TEST.Function).NCONVERT2()
ClassMethod NCONVERT2()
{
	FOR x=250:1:260 {
		ZZDUMP $NCONVERT(x,"U2",1) 
	}
	QUIT
}

DHC-APP>d ##class(PHA.TEST.Function).NCONVERT2()
 
0000: 00 FA                                                   .ú
0000: 00 FB                                                   .??
0000: 00 FC                                                   .ü
0000: 00 FD                                                   .??
0000: 00 FE                                                   .??
0000: 00 FF                                                   .??
0000: 01 00                                                   ..
0000: 01 01                                                   ..
0000: 01 02                                                   ..
0000: 01 03                                                   ..
0000: 01 04                                                   ..

U1,U2,U4对比

/// d ##class(PHA.TEST.Function).NCONVERT3()
ClassMethod NCONVERT3()
{
	FOR x=48:1:58 {
		ZZDUMP $NCONVERT(x,"U1")
	}
	QUIT
}

/// d ##class(PHA.TEST.Function).NCONVERT4()
ClassMethod NCONVERT4()
{
	FOR x=48:1:58 {
		ZZDUMP $NCONVERT(x,"U2")
	}
	QUIT
}

/// d ##class(PHA.TEST.Function).NCONVERT5()
ClassMethod NCONVERT5()
{
	FOR x=48:1:58 {
		ZZDUMP $NCONVERT(x,"U4")
	}
	QUIT
}

DHC-APP> d ##class(PHA.TEST.Function).NCONVERT3()
 
0000: 30                                                      0
0000: 31                                                      1
0000: 32                                                      2
0000: 33                                                      3
0000: 34                                                      4
0000: 35                                                      5
0000: 36                                                      6
0000: 37                                                      7
0000: 38                                                      8
0000: 39                                                      9
0000: 3A                                                      :
DHC-APP> d ##class(PHA.TEST.Function).NCONVERT4()
 
0000: 30 00                                                   0.
0000: 31 00                                                   1.
0000: 32 00                                                   2.
0000: 33 00                                                   3.
0000: 34 00                                                   4.
0000: 35 00                                                   5.
0000: 36 00                                                   6.
0000: 37 00                                                   7.
0000: 38 00                                                   8.
0000: 39 00                                                   9.
0000: 3A 00                                                   :.

DHC-APP> d ##class(PHA.TEST.Function).NCONVERT5()
 
0000: 30 00 00 00                                             0...
0000: 31 00 00 00                                             1...
0000: 32 00 00 00                                             2...
0000: 33 00 00 00                                             3...
0000: 34 00 00 00                                             4...
0000: 35 00 00 00                                             5...
0000: 36 00 00 00                                             6...
0000: 37 00 00 00                                             7...
0000: 38 00 00 00                                             8...
0000: 39 00 00 00                                             9...
0000: 3A 00 00 00                                             :...