M语言-命令

目录

1.概述

2.赋值命令

2.1 set命令      

2.2 kill命令

2.3 zkill命令

2.4 New命令

2.5 Merge命令

3.条件命令

3.1 概述     

3.2 传统if和新if命令

3.3 使用quit

3.4 使用goto

4.循环命令

4.1 for命令

4.2 while命令

4.3 do while命令

5.退出命令

5.1 continue命令

5.2 quit命令

5.3 return命令

5.4 continue命令、quit命令和return命令的区别

6.输出命令

---

1.概述

•  命令以关键字开头
• 命令关键字不区分大小写，如下所示     

WRITE "hello"
write "hello"
W "hello"
w "hello"

• 命令关键字不是保留字，可以作为变量、标签或者其他标识符指定的名称

ClassMethod MyFunction()
{
	set write = "hello"
	//输出hello
	w write
}

• 命令列表

2.赋值命令

2.1 set命令      

• set命令表示为变量进行赋值。可以为单个或多个变量赋值，从左到右顺序执行。

ClassMethod MyFunction()
{
    //为单个变量赋值
	set x = "x"
    //为多个变量赋值
	set y = "y", z = "z", a = "a"
}

• 如果同时给多个变量赋值相同，则使用以下方式效率最高，括号里面的数量最高不超过128个

set (x, y, z, a) = "hello"

• 还可以赋值JSON对象和数组

ClassMethod MyFunction()
{
	//赋值JSON对象
	set json = {"name":"小明", "age":"12"}
	//输出{"name":"小明","age":"12"}
	w json.%ToJSON(),!
	
	//赋值JSON数组
	set json = ["小明", 12]
	//输出["小明",12]
	w json.%ToJSON(),!
	
	//嵌套JSON
	set json = {"name":"小明", "age":"12", "address":{"code":"1"}}
	//输出{"name":"小明","age":"12","address":{"code":"1"}}
	w json.%ToJSON(),!
}

• 可以将$piece和$extract函数和set一起使用。$piece表示使用指定分隔符提取字符串，$extract使用字符技术提取子字符串

ClassMethod MyFunction()
{
	set str = "a^b^c^d^e"
	set $piece(str, "^") = "xyz"
	//输出xyz^b^c^d^e
	w str
	
	set str = "abcde"
	set $extract(str) = "xyz"
	//输出xyzbcde
	w str
}

2.2 kill命令

• kill命令表示从内存中删除变量，并可用于从磁盘中删除它们
• 删除一个或多个变量如下所示：$d判断一个变量是否存在，存在返回1，不存在返回0      

ClassMethod MyFunction()
{
	set x = 1, y = 2, z = 3
	kill x
	kill y, z
	
	//输出a=0 b=0 c=0
	w "a=",$d(a), " b=",$d(b), " c=",$d(c)
}

• 删除多维数组、进程Global、Global节点时，会自动删除该节点的所有从属节点，以及仅包含指向已删除节点的指针的前一个节点。

ClassMethod MyFunction()
{
	kill a, ^b, ^||c
	
	set a = "a", a(1) = "a1", a(2) = "a2"
	set a(1,1) = "a11", a(1,1,1)="a111"
	
	set ^b = "^b", ^b(1) = "^b1", ^b(2) = "^b2"
	set ^b(1,1) = "^b11", ^b(1,1,1)="^b111"
	
	set ^||c = "^||c", ^||c(1) = "^||c1", ^||c(2) = "^||c2"
	set ^||c(1,1) = "^||c11", ^||c(1,1,1)="^||c111"
	
	w "kill之前",!
	zw a, ^b, ^||c
	kill a(1), ^b(1,1), ^||c(1)
	w "kill之后",!
	zw a, ^b, ^||c
}

        输出如下所示：

kill之前
a="a"
a(1)="a1"
a(1,1)="a11"
a(1,1,1)="a111"
a(2)="a2"
^b="^b"
^b(1)="^b1"
^b(1,1)="^b11"
^b(1,1,1)="^b111"
^b(2)="^b2"
^||c="^||c"
^||c(1)="^||c1"
^||c(1,1)="^||c11"
^||c(1,1,1)="^||c111"
^||c(2)="^||c2"
kill之后
a="a"
a(2)="a2"
^b="^b"
^b(1)="^b1"
^b(2)="^b2"
^||c="^||c"
^||c(2)="^||c2"

• kill(变量1，变量2...)，会删除除了指定局部变量之外的其他局部变量。注意，不能指定进程私有全局变量、全局变量或特殊变量、多维数组。

ClassMethod MyFunction()
{
	set a=1 ,b=2, c=3
	kill (a,c)
	
	//输出a=1 b=0 c=1
	w "a=",$d(a)," b=",$d(b)," c=",$d(c)
}

• kill会删除所有局部变量，但不会删除进程私有全局变量、全局变量或者用户定义的特殊变量

ClassMethod MyFunction()
{
	set ^color(1) = "red"
	set ^||color(1) = "black"
	
	set a=1, b=2
	w "kill之前",!
	kill
	w "kill之后",!
	
	//输出a=0 b=0
	w "a=",$d(a)," b=",$d(b),!
	//输出^color(1)="red"
	zw ^color
	//输出^||color(1)="black"
	zw ^||color
}

• 使用参数传递对kill的影响：分为按值传递变量和按引用传递变量

        ①按值传递变量：kill对按值传递的变量不会起任何效果。

ClassMethod MyFunction()
{
	set x = "1"
	//输出调用Sub之前x是否存在：1
	w "调用Sub之前x是否存在：",$data(x),!
	d ##class(User.Test).Sub(x)
	
	//输出调用Sub之后x是否存在：1
	w "调用Sub之后x是否存在：",$data(x),!
}
 
ClassMethod Sub(x)
{
	//输出kill之前，x是否存在：1
	w "kill之前，x是否存在：",$data(x),!
	kill x
	//输出kill之后，x是否存在：0
	w "kill之后，x是否存在：",$data(x),!
}

        ②按引用传递变量：kill会删除按引用传递的变量

ClassMethod MyFunction()
{
	set x = "1"
	//输出调用Sub之前x是否存在：1
	w "调用Sub之前x是否存在：",$data(x),!
	d Sub(.x)
	
	//输出调用Sub之后x是否存在：0
	w "调用Sub之后x是否存在：",$data(x),!
	
Sub(&x)
	//输出kill之前，x是否存在：1
	w "kill之前，x是否存在：",$data(x),!
	kill x
	//输出kill之后，x是否存在：0
	w "kill之后，x是否存在：",$data(x),!
}
}

2.3 zkill命令

• zkill命令删除指定数组节点的值， 而不会删除该节点的后代。

ClassMethod MyFunction()
{
	kill a, ^b, ^||c
	
	set a = "a", a(1) = "a1", a(2) = "a2"
	set a(1,1) = "a11", a(1,1,1)="a111"
	
	set ^b = "^b", ^b(1) = "^b1", ^b(2) = "^b2"
	set ^b(1,1) = "^b11", ^b(1,1,1)="^b111"
	
	set ^||c = "^||c", ^||c(1) = "^||c1", ^||c(2) = "^||c2"
	set ^||c(1,1) = "^||c11", ^||c(1,1,1)="^||c111"
	
	w "kill之前",!
	zw a, ^b, ^||c
	zkill a(1), ^b(1,1), ^||c(1)
	w "kill之后",!
	zw a, ^b, ^||c
}

        运行结果如下所示：

kill之前
a="a"
a(1)="a1"
a(1,1)="a11"
a(1,1,1)="a111"
a(2)="a2"
^b="^b"
^b(1)="^b1"
^b(1,1)="^b11"
^b(1,1,1)="^b111"
^b(2)="^b2"
^||c="^||c"
^||c(1)="^||c1"
^||c(1,1)="^||c11"
^||c(1,1,1)="^||c111"
^||c(2)="^||c2"
kill之后
a="a"
a(1,1)="a11"
a(1,1,1)="a111"
a(2)="a2"
^b="^b"
^b(1)="^b1"
^b(1,1,1)="^b111"
^b(2)="^b2"
^||c="^||c"
^||c(1,1)="^||c11"
^||c(1,1,1)="^||c111"
^||c(2)="^||c2"

2.4 New命令

        new命令会创建一个新的局部变量上下文。它在旧的上下文中保留现有的局部变量值，然后启动一个新的上下文，在新的上下文中没有为局部变量赋值。

        在程序中，一般使用new初始化整个应用程序或应用程序的主要子系统的变量。

• 语法

• NEW命令不能用于以下内容，使用的话就会报错<SYNTAX>错误

1.Globals全局变量
2.Process-Private Globals私有进程全局变量
3.局部变量下标
4.一些特殊变量，$ESTACK、$ETRAP、$NAMESPACE和$ROLES除外

• new命令经常在do命令调用的例程或者方法中使用，一般在方法开头使用，进行初始化变量。
• 在类程序中，默认都是私有变量，不能进行new。如果要使用new命令，则需要在类上添加关键字Not ProcedureBlock

Class User.Test3 Extends %RegisteredObject [ Not ProcedureBlock ]
{
    ...
}

        ①使用new命令初始化所有变量

ClassMethod MyFunction()
{
	set a=1, b=2, c=3
	w "new 之前",!
	zw
	new
	w "new 之后",!
	zw
}
 
程序运行结果如下：
new 之前
a=1
b=2
c=3
new 之后

        ②使用new命令初始化指定变量

ClassMethod MyFunction()
{
	set a=1, b=2, c=3, d=4
	w "new 之前",!
	zw
	new b, d
	w "new 之后",!
	zw
}
 
程序运行结果如下：
new 之前
a=1
b=2
c=3
d=4
new 之后
a=1
c=3

          ③使用new命令初始化除了指定变量之外的全部变量

ClassMethod MyFunction()
{
	set a=1, b=2, c=3, d=4
	w "new 之前",!
	zw
	new (b, d)
	w "new 之后",!
	zw
}
程序运行结果如下：
new 之前
a=1
b=2
c=3
d=4
new 之后
b=2
d=4

• 程序里面不能使用超过31个独占new或者无参数new，否则会报错<MAXSCOPE)错误

ClassMethod MyFunction()
{
	for i=1 : 1 : 32{
		new (i)	
	}
}
 
运行报错：Error <MAXSCOPE>

2.5 Merge命令

        Merge命令将全部变量或者多维数组节点复制到指定变量。

ClassMethod MyFunction25()
{
	kill ^x, ^y
	set ^x(2,2) = "x22"
	set ^x(2,2,4) = "x224"
	set ^y(3,6,7) = "y367"
	set ^y(3,6,8) = "y368"
	set ^y(3,6,7,8,4) = "y36784"
	set ^y(3,6,7,8,9) = "y36789"
	
	merge ^x(2,3) = ^y(3,6,7,8)
	zw ^x
	zw ^y
}
 
程序运行结果：
^x(2,2)="x22"
^x(2,2,4)="x224"
^x(2,3,4)="y36784"
^x(2,3,9)="y36789"
^y(3,6,7)="y367"
^y(3,6,7,8,4)="y36784"
^y(3,6,7,8,9)="y36789"
^y(3,6,8)="y368"

        图示如下：

         复制后^x为：

3.条件命令

3.1 概述     

        条件命令包含：if命令、elseif命令和else命令。

• 可以有一个或多个if命令
• 可以有一个或多个elseif命令
• 最多只能有一个else命令

ClassMethod MyFunction()
{
	set x = 10
	
	if x = 1{
		w "1"	
	}elseif(x = 2){
		w "2"
	}elseif(x = 3){
		w "3"
	}else{
		w "其他"
	}
}

3.2 传统if和新if命令

• 传统的if命令（不推荐使用）是面向行的（点语法），即要执行的命令必须在同一行，不使用{}，且行格式是固定的。
• 新的if命令（推荐使用）是块结构的（块语法），使用{}，行格式没有限制，不使用$TEST特殊变量

        如下所示，传统的if命令：

ClassMethod MyFunction()
{
	set x= 1
	if x=1 w "进入if",! d Sub1(x)
	else  w "进入else",! d Sub2(x)
	q
	
Sub1(num)
	w "$TEST=",$TEST,!
	if num=2
	w "$TEST=",$TEST,!
	w "进入Sub1",!
	q
Sub2(num)
	w "进入Sub2",!
	q
}
 
运行结果：
进入if
$TEST=1
$TEST=0
进入Sub1
进入else
进入Sub2

        如果去掉Sub1里面的if num=2，则运行结果如下：

进入if
$TEST=1
$TEST=1
进入Sub1

3.3 使用quit

• 如果在条件命令未嵌套在循环结构（for、while、do...while）、try或者catch结构中，则使用quit会退出当前例程（方法）

ClassMethod MyFunction()
{
	set x = 3
	if x#2 = 0{
		w "偶数"
		q
		w "if退出"
	}else{
		w "奇数"
		q
		w "else退出"	
	}
	w "此处永远不会执行"
}
 
程序运行结果：
奇数

• 如果条件命令嵌套在循环结构中，使用quit会退出循环结构，并往后执行循环结构后面的代码

ClassMethod MyFunction()
{
	for x=1 : 1 :8{
		if x#2 = 0{
			w "偶数",!
		}else{
			w "奇数",!
			q:x=3
		}
	}
	w "循环执行完成"
}
 
程序运行结果：
奇数
偶数
奇数
循环执行完成

• 如果条件命令嵌套在try或者catch内，使用quit则会退出try或者catch，并往后执行try或者catch后面的代码

ClassMethod MyFunction()
{
	try{
		set x = 2
		if x#2 = 0{
			w "偶数",!
			q
			w "退出if"	
		}else{
			w "奇数",!	
			q
			w "退出else"	
		}	
		w "此处永远不会执行"
	}catch ex{
		w "当程序发生错误时执行"
		w "Error Name:",$zcvt(ex.name, "O", "HTML"),!
	}
	w "执行完try catch"
}
 
程序运行结果：
偶数
执行玩try catch

3.4 使用goto

       如果在条件命令中使用goto，要注意死循环

ClassMethod MyFunction6()
{
	set x = 1
	
Loop
	if x >= 1{
		w "无限循环",!	
		set x = x + 1
		goto Loop
	}
}

        程序会一直打印：无限循环

4.循环命令

        包含：do while、for、while命令

4.1 for命令

• 不带参数的for命令，会无限循环执行，直至代码块内部有退出命令（quit、goto、return）被执行

Class Demo.Test1 Extends %RegisteredObject
{
ClassMethod MyFunction(x)
{
	for{
		w "x=",x,!
		set x = x - 1
		q:(x = 2)	
	}
	q "结束"
}
}

        执行w ##class(Demo.Test1).MyFunction(3），运行结果如下：

x=3
结束

        执行w ##class(Demo.Test1).MyFunction(2），会一直循环运行，如下：

x=2

x=1

x=-1

x=-2

...

• 当程序执行发生错误时，会中断for循环。可以通过try catch捕获错误

ClassMethod MyFunction(x)
{
	try{
		for{
			set y = 2 / x
			w "2/",x,"=",y,!
			set x = x - 1	
		}	
	}catch e{
		w "程序执行发生错误",!
		if 1 = e.%IsA("%Exception.SystemException"){
			w "Name:",e.Name,!
			w "Location:",e.Location,!
			w "Code:",e.Code,!
		}else{
			w "其他异常",!
		}
	}
}

        执行w ##class(Demo.Test1).MyFunction(3），运行结果如下：

2/3=.6666666666666666667
2/2=1
2/1=2
程序执行发生错误
Name:<DIVIDE>
Location:zMyFunction2+3^Demo.Test1.1
Code:18

• 使用for var=expr时，for循环执行的次数，等于expr中逗号分隔值的次数（逗号变成冒号:时，也会依次按顺序执行）

ClassMethod MyFunction()
{
	for x = 1{
		w "x=",x,!	
	}
 
	for color = "red","orange","yellow"{
		w "color =",color ,!	
	}
}
运行结果如下：
x=1
color=red
color=orange
color=yellow

• 使用for var=start:increment:end时。参数start、increment和end分别指的是起始值、增量值、结束值。

ClassMethod MyFunction()
{
	set str = "hello world"
	set len = $length(str)
	for i=1 : 1 : len{
		w i," ",$extract(str, i),!
	}
}
程序运行结果：
1 h
2 e
3 l
4 l
5 o
6  
7 w
8 o
9 r
10 l
11 d

• 使用for var=start:increment时，这种形式的for命令中，没有结束值，则循环必须包含quit、return或者goto命令才能终止循环。

ClassMethod MyFunction()
{
	for i(1) = 0 : 3{
		//如果长度等于2就退出
		q:$length(i(1))=2
		w i(1),!
	}
}
程序运行结果：
0
3
6
9

• 点语法（不推荐使用）：传统点语法的for命令是面向行的，它执行的循环由同一行程序中跟随它的命令组成，不使用花括号{}，并且格式是固定的，如下所示，第一方式为点语法，推荐使用第二种方式块语法：

ClassMethod MyFunction()
{
	set color(1) = "red"
	set color(2) = "orange"
	set color(3) = "blue"
	
	set id = ""
	
	//方式一：点语法
	for  set id = $o(color(id)) q:(id = "")  d
	 .w "点语法：",color(id),!
	 
	//方式二：块语法
	for{
		set id = $o(color(id))
		q:(id = "")
		w "块语法：",color(id),!	
	}
}

        运行结果为：

点语法：red
点语法：orange
点语法：blue
块语法：red
块语法：orange
块语法：blue

        注意事项：如果方式一点语法的for命令中，set id=$o(color(id))如果写成id=$o(color(id))的话，for循环只会运行一次，即运行结果为->点语法：red

• for与监视点的使用。

4.2 while命令

• 格式为：while 表达式{代码}

ClassMethod MyFunction()
{
	set x = 1
	while x < 3{
		w x,!
		set x = x + 1	
	}
}
程序运行结果：
1
2

4.3 do while命令

• 格式为：do{代码}while (表达式)

ClassMethod MyFunction()
{
	set x = 1
	
	do{
		w x,!
		set x = x + 1	
	}while (x < 2)
}
程序运行结果：
1

        注意事项：程序会先do，然后再进入while判断，所以说程序会至少执行一次

5.退出命令

        退出命令包含：continue、quit和return命令

5.1 continue命令

• continue命令只在块级语法中使用。在循环命令for、while和do while命令中使用的话，会终止本次循环（不会继续往continue所在行下面的程序执行，也不会退出循环），重新继续执行下一次循环
• continue命令与后置条件一起使用

ClassMethod MyFunction()
{
    for i=1 : 1 : 3{
		continue:i=2
		w i,!	
	}
}
运行结果：
1
3

5.2 quit命令

• 当quit命令在循环命令（for、while、do while）、try catch或传统的do结构内使用的话，使用quit会退出当前的循环命令、try catch和do结构，并继续往后执行代码；如果不是在这些里面使用的话，quit会终止当前程序，并不会往后继续执行代码。

ClassMethod MyFunction()
{
	w "在主程序中",!
	d sub
	w "返回主程序",!
	q
	w "程序终止"
sub
	w "在sub中",!
	for i=1 : 1 : 5{
		w "i=",i,!	
		if i=3 q
	}
	w "停止循环",!
	q
	w "sub退出",!
}
程序运行结果：
在主程序中
在sub中
i=1
i=2
i=3
停止循环
返回主程序

• 在传统for循环的点语法中，quit相当于continue命令，会退出本次循环（不会退出循环），并继续下一次循环。

ClassMethod MyFunction()
{
	for i=1 : 1 : 3 d
	 //quit相当于退出本次的do结构，并不会退出循环
	 .q:i=2
	 .w "点语法i=",i,!	 
	
	for i=1 : 1 : 3{
		continue:i=2
		w "块语法i=",i,!	
	}
}
程序运行结果：
点语法i=1
点语法i=3
块语法i=1
块语法i=3

5.3 return命令

• return命令简写为ret
• return命令用于终止例程或程序的执行。
• 当return命令在循环命令（for、while、do while）、try catch或传统的do结构内使用的话，使用return会终止当前例程或程序，并不会往后继续执行代码，这与quit命令有所不同。

ClassMethod MyFunction()
{
	w "在主程序中",!
	d sub
	w "返回主程序",!
	return
	w "程序终止"
sub
	w "在sub中",!
	for i=1 : 1 : 5{
		w "i=",i,!	
		if i=3 return
	}
	w "停止循环",!
	return
	w "sub退出",!
}
程序运行结果：
在主程序中
在sub中
i=1
i=2
i=3
返回主程序

• 在传统for循环的点语法中，return命令和quit命令效果一样，会退出本次循环（不会退出循环），并继续下一次循环。

ClassMethod MyFunction()
{
	for i=1 : 1 : 3 d
	 .ret:i=2
	 .w "点语法i=",i,!
	
	for i=1 : 1 : 3{
		ret:i=2
		w "块语法i=",i,!	
	}
}
程序运行结果：
点语法i=1
点语法i=3
块语法i=1

5.4 continue命令、quit命令和return命令的区别

• 在for循环块语法，非传统for循环点语法中

• 对于for循环块语法和点语法中，return和quit的不同

/// w ##class(User.Test4).MyFunction1(1)
ClassMethod MyFunction17(x)
{
	//定义一个变量，接收返回值
	set err = 0
	for i=1 : 1 : 3 q:err  d
	 .w "i=",i,!
	 .s err = ..Return(x)
	 
	 q:err "程序错误"
	 q "程序正确"
}
 
/// w ##class(User.Test4).MyFunction2(1)
ClassMethod MyFunction18(x)
{
	for i=1 : 1 : 3{
		w "i=",i,!
		ret:..Return(x) "程序错误" 
	}
	q "程序正确"
}
 
/// 1代表错误，0代表正确
ClassMethod Return(x) As %Boolean
{
	quit x
}

        运行w ##class(User.Test4).MyFunction1(1)，结果如下：

i=1
程序错误

        运行w ##class(User.Test4).MyFunction1(0)，结果如下：

i=1
i=2
i=3
程序正确

• quit和return区别

6.输出命令

        输出命令包含：write、zwrite、zzdump和zzwrite命令。

 6.1 write命令

        显示输出内容到当前设备

        1）后置表达式（可选）

// 输出空
w:(1>3) 1
 
// 输出3
w:(3>1) 3

        2）有参数的write

        write + 表达式（任何有效的ObjectScript表达式，包括文字、变量、对象方法和对象属性），输出结果均为数字或带引号的字符串

// 输出3
w 1+2
// 输出ab
w "a"_"b"

        3）无参的write

•   无参数的write会输出所有定义的局部变量的名称和值。不列出进程私有全局变量、全局变量和特殊变量。按照以下格式输出定义的局部变量，每行一个变量：

变量1 = 变量1值
变量2 = 变量2值

        如下所示：

/// w ##class(User.Test4).MyFunction19()
ClassMethod MyFunction19()
{
	set str1 = "red"
	set str2 = +123.40
	set str3 = "456.7"
	set str4 = "456.0"
	set str5 = "-999"
	w
}

       输出如下：

str1="red"
str2=123.4
str3=456.7
str4="456.0"
str5=-999

        注意：小数以0结尾的字符串，会被认为是字符串，如str4

 6.2 zwrite命令

        输出变量名称及其值

感谢：第十七讲 赋值命令_哔哩哔哩_bilibili