• 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.概述

    •  命令以关键字开头
    • 命令关键字不区分大小写，如下所示     
    1. WRITE "hello"
    2. write "hello"
    3. W "hello"
    4. w "hello"
    • 命令关键字不是保留字，可以作为变量、标签或者其他标识符指定的名称
    1. ClassMethod MyFunction()
    2. {
    3. 	set write = "hello"
    4. 	//输出hello
    5. 	w write
    6. }
    • 命令列表
    条件命令

    if

    eiseif

    else

    循环命令

    do while

    for

    while

    调用命令

    do

    goto

    job

    xecute

    退出命令

    continue

    quit

    return

    赋值命令

    new：为变量赋值建立新的上下文

    kill：删除变量

    merge：将全局变量节点或多维数组合并到目标变量

    set：为变量赋值

    zkill：删除节点，同时保留该节点的子代

    输出命令

    write

    zwrite

    zzdump

    zzwrite

    异常命令

    try

    catch

    throw

    ztrap

    事务命令

    tcommit

    trollback

    tstart

    调试命令

    break

    zbreak

    IO命令

    close

    open

    read

    use

    挂起命令

    hang

    halt

    其他命令

    lock

    view

    znspace

    例程命令

    print

    zprint

    zinsert

    zload

    zremovve

    zsave

    zzprint

    2.赋值命令

    2.1 set命令      

    • set命令表示为变量进行赋值。可以为单个或多个变量赋值，从左到右顺序执行。
    1. ClassMethod MyFunction()
    2. {
    3.     //为单个变量赋值
    4. 	set x = "x"
    5.     //为多个变量赋值
    6. 	set y = "y", z = "z", a = "a"
    7. }
    • 如果同时给多个变量赋值相同，则使用以下方式效率最高，括号里面的数量最高不超过128个
    set (x, y, z, a) = "hello"
    • 还可以赋值JSON对象和数组
    1. ClassMethod MyFunction()
    2. {
    3. 	//赋值JSON对象
    4. 	set json = {"name":"小明", "age":"12"}
    5. 	//输出{"name":"小明","age":"12"}
    6. 	w json.%ToJSON(),!
    7. 	
    8. 	//赋值JSON数组
    9. 	set json = ["小明", 12]
    10. 	//输出["小明",12]
    11. 	w json.%ToJSON(),!
    12. 	
    13. 	//嵌套JSON
    14. 	set json = {"name":"小明", "age":"12", "address":{"code":"1"}}
    15. 	//输出{"name":"小明","age":"12","address":{"code":"1"}}
    16. 	w json.%ToJSON(),!
    17. }
    • 可以将$piece和$extract函数和set一起使用。$piece表示使用指定分隔符提取字符串，$extract使用字符技术提取子字符串
    1. ClassMethod MyFunction()
    2. {
    3. 	set str = "a^b^c^d^e"
    4. 	set $piece(str, "^") = "xyz"
    5. 	//输出xyz^b^c^d^e
    6. 	w str
    7. 	
    8. 	set str = "abcde"
    9. 	set $extract(str) = "xyz"
    10. 	//输出xyzbcde
    11. 	w str
    12. }

    2.2 kill命令

    • kill命令表示从内存中删除变量，并可用于从磁盘中删除它们
    • 删除一个或多个变量如下所示：$d判断一个变量是否存在，存在返回1，不存在返回0      
    1. ClassMethod MyFunction()
    2. {
    3. 	set x = 1, y = 2, z = 3
    4. 	kill x
    5. 	kill y, z
    6. 	
    7. 	//输出a=0 b=0 c=0
    8. 	w "a=",$d(a), " b=",$d(b), " c=",$d(c)
    9. }
    • 删除多维数组、进程Global、Global节点时，会自动删除该节点的所有从属节点，以及仅包含指向已删除节点的指针的前一个节点。
    1. ClassMethod MyFunction()
    2. {
    3. 	kill a, ^b, ^||c
    4. 	
    5. 	set a = "a", a(1) = "a1", a(2) = "a2"
    6. 	set a(1,1) = "a11", a(1,1,1)="a111"
    7. 	
    8. 	set ^b = "^b", ^b(1) = "^b1", ^b(2) = "^b2"
    9. 	set ^b(1,1) = "^b11", ^b(1,1,1)="^b111"
    10. 	
    11. 	set ^||c = "^||c", ^||c(1) = "^||c1", ^||c(2) = "^||c2"
    12. 	set ^||c(1,1) = "^||c11", ^||c(1,1,1)="^||c111"
    13. 	
    14. 	w "kill之前",!
    15. 	zw a, ^b, ^||c
    16. 	kill a(1), ^b(1,1), ^||c(1)
    17. 	w "kill之后",!
    18. 	zw a, ^b, ^||c
    19. }

            输出如下所示：

    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...)，会删除除了指定局部变量之外的其他局部变量。注意，不能指定进程私有全局变量、全局变量或特殊变量、多维数组。
    1. ClassMethod MyFunction()
    2. {
    3. 	set a=1 ,b=2, c=3
    4. 	kill (a,c)
    5. 	
    6. 	//输出a=1 b=0 c=1
    7. 	w "a=",$d(a)," b=",$d(b)," c=",$d(c)
    8. }
    • kill会删除所有局部变量，但不会删除进程私有全局变量、全局变量或者用户定义的特殊变量
    1. ClassMethod MyFunction()
    2. {
    3. 	set ^color(1) = "red"
    4. 	set ^||color(1) = "black"
    5. 	
    6. 	set a=1, b=2
    7. 	w "kill之前",!
    8. 	kill
    9. 	w "kill之后",!
    10. 	
    11. 	//输出a=0 b=0
    12. 	w "a=",$d(a)," b=",$d(b),!
    13. 	//输出^color(1)="red"
    14. 	zw ^color
    15. 	//输出^||color(1)="black"
    16. 	zw ^||color
    17. }
    • 使用参数传递对kill的影响：分为按值传递变量和按引用传递变量

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

    1. ClassMethod MyFunction()
    2. {
    3. 	set x = "1"
    4. 	//输出调用Sub之前x是否存在：1
    5. 	w "调用Sub之前x是否存在：",$data(x),!
    6. 	d ##class(User.Test).Sub(x)
    7. 	
    8. 	//输出调用Sub之后x是否存在：1
    9. 	w "调用Sub之后x是否存在：",$data(x),!
    10. }
    11.  
    12. ClassMethod Sub(x)
    13. {
    14. 	//输出kill之前，x是否存在：1
    15. 	w "kill之前，x是否存在：",$data(x),!
    16. 	kill x
    17. 	//输出kill之后，x是否存在：0
    18. 	w "kill之后，x是否存在：",$data(x),!
    19. }

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

    1. ClassMethod MyFunction()
    2. {
    3. 	set x = "1"
    4. 	//输出调用Sub之前x是否存在：1
    5. 	w "调用Sub之前x是否存在：",$data(x),!
    6. 	d Sub(.x)
    7. 	
    8. 	//输出调用Sub之后x是否存在：0
    9. 	w "调用Sub之后x是否存在：",$data(x),!
    10. 	
    11. Sub(&x)
    12. 	//输出kill之前，x是否存在：1
    13. 	w "kill之前，x是否存在：",$data(x),!
    14. 	kill x
    15. 	//输出kill之后，x是否存在：0
    16. 	w "kill之后，x是否存在：",$data(x),!
    17. }
    18. }

    2.3 zkill命令

    • zkill命令删除指定数组节点的值， 而不会删除该节点的后代。
    1. ClassMethod MyFunction()
    2. {
    3. 	kill a, ^b, ^||c
    4. 	
    5. 	set a = "a", a(1) = "a1", a(2) = "a2"
    6. 	set a(1,1) = "a11", a(1,1,1)="a111"
    7. 	
    8. 	set ^b = "^b", ^b(1) = "^b1", ^b(2) = "^b2"
    9. 	set ^b(1,1) = "^b11", ^b(1,1,1)="^b111"
    10. 	
    11. 	set ^||c = "^||c", ^||c(1) = "^||c1", ^||c(2) = "^||c2"
    12. 	set ^||c(1,1) = "^||c11", ^||c(1,1,1)="^||c111"
    13. 	
    14. 	w "kill之前",!
    15. 	zw a, ^b, ^||c
    16. 	zkill a(1), ^b(1,1), ^||c(1)
    17. 	w "kill之后",!
    18. 	zw a, ^b, ^||c
    19. }

            运行结果如下所示：

    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为所有局部变量启动新的上下文
    NEW x, y, z...为指定的局部变量(x, y, z,,,)启动新的上下文
    NEW(x, y, z...)

    1.也称为独占new

    2.为除了指定变量(x, y, z...)之外的所有局部变量启动新的上下文

    3.括号里面的变量最多可以指定255个

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

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

    • new命令经常在do命令调用的例程或者方法中使用，一般在方法开头使用，进行初始化变量。
    • 在类程序中，默认都是私有变量，不能进行new。如果要使用new命令，则需要在类上添加关键字Not ProcedureBlock
    1. Class User.Test3 Extends %RegisteredObject [ Not ProcedureBlock ]
    2. {
    3.     ...
    4. }

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

    1. ClassMethod MyFunction()
    2. {
    3. 	set a=1, b=2, c=3
    4. 	w "new 之前",!
    5. 	zw
    6. 	new
    7. 	w "new 之后",!
    8. 	zw
    9. }
    10.  
    11. 程序运行结果如下：
    12. new 之前
    13. a=1
    14. b=2
    15. c=3
    16. new 之后

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

    1. ClassMethod MyFunction()
    2. {
    3. 	set a=1, b=2, c=3, d=4
    4. 	w "new 之前",!
    5. 	zw
    6. 	new b, d
    7. 	w "new 之后",!
    8. 	zw
    9. }
    10.  
    11. 程序运行结果如下：
    12. new 之前
    13. a=1
    14. b=2
    15. c=3
    16. d=4
    17. new 之后
    18. a=1
    19. c=3

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

    1. ClassMethod MyFunction()
    2. {
    3. 	set a=1, b=2, c=3, d=4
    4. 	w "new 之前",!
    5. 	zw
    6. 	new (b, d)
    7. 	w "new 之后",!
    8. 	zw
    9. }
    11. 程序运行结果如下：
    12. new 之前
    13. a=1
    14. b=2
    15. c=3
    16. d=4
    17. new 之后
    18. b=2
    19. d=4
    • 程序里面不能使用超过31个独占new或者无参数new，否则会报错
    1. ClassMethod MyFunction()
    2. {
    3. 	for i=1 : 1 : 32{
    4. 		new (i)	
    5. 	}
    6. }
    7.  
    8. 运行报错：Error

    2.5 Merge命令

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

    1. ClassMethod MyFunction25()
    2. {
    3. 	kill ^x, ^y
    4. 	set ^x(2,2) = "x22"
    5. 	set ^x(2,2,4) = "x224"
    6. 	set ^y(3,6,7) = "y367"
    7. 	set ^y(3,6,8) = "y368"
    8. 	set ^y(3,6,7,8,4) = "y36784"
    9. 	set ^y(3,6,7,8,9) = "y36789"
    10. 	
    11. 	merge ^x(2,3) = ^y(3,6,7,8)
    12. 	zw ^x
    13. 	zw ^y
    14. }
    15.  
    16. 程序运行结果：
    17. ^x(2,2)="x22"
    18. ^x(2,2,4)="x224"
    19. ^x(2,3,4)="y36784"
    20. ^x(2,3,9)="y36789"
    21. ^y(3,6,7)="y367"
    22. ^y(3,6,7,8,4)="y36784"
    23. ^y(3,6,7,8,9)="y36789"
    24. ^y(3,6,8)="y368"

            图示如下：

             复制后^x为：

    3.条件命令

    3.1 概述     

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

    • 可以有一个或多个if命令
    • 可以有一个或多个elseif命令
    • 最多只能有一个else命令
    1. ClassMethod MyFunction()
    2. {
    3. 	set x = 10
    4. 	
    5. 	if x = 1{
    6. 		w "1"	
    7. 	}elseif(x = 2){
    8. 		w "2"
    9. 	}elseif(x = 3){
    10. 		w "3"
    11. 	}else{
    12. 		w "其他"
    13. 	}
    14. }

    3.2 传统if和新if命令

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

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

    1. ClassMethod MyFunction()
    2. {
    3. 	set x= 1
    4. 	if x=1 w "进入if",! d Sub1(x)
    5. 	else  w "进入else",! d Sub2(x)
    6. 	q
    7. 	
    8. Sub1(num)
    9. 	w "$TEST=",$TEST,!
    10. 	if num=2
    11. 	w "$TEST=",$TEST,!
    12. 	w "进入Sub1",!
    13. 	q
    14. Sub2(num)
    15. 	w "进入Sub2",!
    16. 	q
    17. }
    18.  
    19. 运行结果：
    20. 进入if
    21. $TEST=1
    22. $TEST=0
    23. 进入Sub1
    24. 进入else
    25. 进入Sub2

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

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

    3.3 使用quit

    • 如果在条件命令未嵌套在循环结构（for、while、do...while）、try或者catch结构中，则使用quit会退出当前例程（方法）
    1. ClassMethod MyFunction()
    2. {
    3. 	set x = 3
    4. 	if x#2 = 0{
    5. 		w "偶数"
    6. 		q
    7. 		w "if退出"
    8. 	}else{
    9. 		w "奇数"
    10. 		q
    11. 		w "else退出"	
    12. 	}
    13. 	w "此处永远不会执行"
    14. }
    15.  
    16. 程序运行结果：
    17. 奇数
    • 如果条件命令嵌套在循环结构中，使用quit会退出循环结构，并往后执行循环结构后面的代码
    1. ClassMethod MyFunction()
    2. {
    3. 	for x=1 : 1 :8{
    4. 		if x#2 = 0{
    5. 			w "偶数",!
    6. 		}else{
    7. 			w "奇数",!
    8. 			q:x=3
    9. 		}
    10. 	}
    11. 	w "循环执行完成"
    12. }
    13.  
    14. 程序运行结果：
    15. 奇数
    16. 偶数
    17. 奇数
    18. 循环执行完成
    • 如果条件命令嵌套在try或者catch内，使用quit则会退出try或者catch，并往后执行try或者catch后面的代码
    1. ClassMethod MyFunction()
    2. {
    3. 	try{
    4. 		set x = 2
    5. 		if x#2 = 0{
    6. 			w "偶数",!
    7. 			q
    8. 			w "退出if"	
    9. 		}else{
    10. 			w "奇数",!	
    11. 			q
    12. 			w "退出else"	
    13. 		}	
    14. 		w "此处永远不会执行"
    15. 	}catch ex{
    16. 		w "当程序发生错误时执行"
    17. 		w "Error Name:",$zcvt(ex.name, "O", "HTML"),!
    18. 	}
    19. 	w "执行完try catch"
    20. }
    21.  
    22. 程序运行结果：
    23. 偶数
    24. 执行玩try catch

    3.4 使用goto

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

    1. ClassMethod MyFunction6()
    2. {
    3. 	set x = 1
    4. 	
    5. Loop
    6. 	if x >= 1{
    7. 		w "无限循环",!	
    8. 		set x = x + 1
    9. 		goto Loop
    10. 	}
    11. }

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

    4.循环命令

            包含：do while、for、while命令

    4.1 for命令

    • 不带参数的for命令，会无限循环执行，直至代码块内部有退出命令（quit、goto、return）被执行
    1. Class Demo.Test1 Extends %RegisteredObject
    2. {
    3. ClassMethod MyFunction(x)
    4. {
    5. 	for{
    6. 		w "x=",x,!
    7. 		set x = x - 1
    8. 		q:(x = 2)	
    9. 	}
    10. 	q "结束"
    11. }
    12. }

            执行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捕获错误
    1. ClassMethod MyFunction(x)
    2. {
    3. 	try{
    4. 		for{
    5. 			set y = 2 / x
    6. 			w "2/",x,"=",y,!
    7. 			set x = x - 1	
    8. 		}	
    9. 	}catch e{
    10. 		w "程序执行发生错误",!
    11. 		if 1 = e.%IsA("%Exception.SystemException"){
    12. 			w "Name:",e.Name,!
    13. 			w "Location:",e.Location,!
    14. 			w "Code:",e.Code,!
    15. 		}else{
    16. 			w "其他异常",!
    17. 		}
    18. 	}
    19. }

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

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

    • 使用for var=expr时，for循环执行的次数，等于expr中逗号分隔值的次数（逗号变成冒号:时，也会依次按顺序执行）
    1. ClassMethod MyFunction()
    2. {
    3. 	for x = 1{
    4. 		w "x=",x,!	
    5. 	}
    6.  
    7. 	for color = "red","orange","yellow"{
    8. 		w "color =",color ,!	
    9. 	}
    10. }
    11. 运行结果如下：
    12. x=1
    13. color=red
    14. color=orange
    15. color=yellow
    • 使用for var=start:increment:end时。参数start、increment和end分别指的是起始值、增量值、结束值。
    1. ClassMethod MyFunction()
    2. {
    3. 	set str = "hello world"
    4. 	set len = $length(str)
    5. 	for i=1 : 1 : len{
    6. 		w i," ",$extract(str, i),!
    7. 	}
    8. }
    9. 程序运行结果：
    10. 1 h
    11. 2 e
    12. 3 l
    13. 4 l
    14. 5 o
    15. 6  
    16. 7 w
    17. 8 o
    18. 9 r
    19. 10 l
    20. 11 d
    • 使用for var=start:increment时，这种形式的for命令中，没有结束值，则循环必须包含quit、return或者goto命令才能终止循环。
    1. ClassMethod MyFunction()
    2. {
    3. 	for i(1) = 0 : 3{
    4. 		//如果长度等于2就退出
    5. 		q:$length(i(1))=2
    6. 		w i(1),!
    7. 	}
    8. }
    9. 程序运行结果：
    10. 0
    11. 3
    12. 6
    13. 9
    • 点语法（不推荐使用）：传统点语法的for命令是面向行的，它执行的循环由同一行程序中跟随它的命令组成，不使用花括号{}，并且格式是固定的，如下所示，第一方式为点语法，推荐使用第二种方式块语法：
    1. ClassMethod MyFunction()
    2. {
    3. 	set color(1) = "red"
    4. 	set color(2) = "orange"
    5. 	set color(3) = "blue"
    6. 	
    7. 	set id = ""
    8. 	
    9. 	//方式一：点语法
    10. 	for  set id = $o(color(id)) q:(id = "")  d
    11. 	 .w "点语法：",color(id),!
    12. 	 
    13. 	//方式二：块语法
    14. 	for{
    15. 		set id = $o(color(id))
    16. 		q:(id = "")
    17. 		w "块语法：",color(id),!	
    18. 	}
    19. }

            运行结果为：

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

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

    • for与监视点的使用。

    4.2 while命令

    • 格式为：while 表达式{代码}
    1. ClassMethod MyFunction()
    2. {
    3. 	set x = 1
    4. 	while x < 3{
    5. 		w x,!
    6. 		set x = x + 1	
    7. 	}
    8. }
    9. 程序运行结果：
    10. 1
    11. 2

    4.3 do while命令

    • 格式为：do{代码}while (表达式)
    1. ClassMethod MyFunction()
    2. {
    3. 	set x = 1
    4. 	
    5. 	do{
    6. 		w x,!
    7. 		set x = x + 1	
    8. 	}while (x < 2)
    9. }
    10. 程序运行结果：
    11. 1

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

    5.退出命令

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

    5.1 continue命令

    • continue命令只在块级语法中使用。在循环命令for、while和do while命令中使用的话，会终止本次循环（不会继续往continue所在行下面的程序执行，也不会退出循环），重新继续执行下一次循环
    • continue命令与后置条件一起使用
    1. ClassMethod MyFunction()
    2. {
    3.     for i=1 : 1 : 3{
    4. 		continue:i=2
    5. 		w i,!	
    6. 	}
    7. }
    8. 运行结果：
    9. 1
    10. 3

    5.2 quit命令

    • 当quit命令在循环命令（for、while、do while）、try catch或传统的do结构内使用的话，使用quit会退出当前的循环命令、try catch和do结构，并继续往后执行代码；如果不是在这些里面使用的话，quit会终止当前程序，并不会往后继续执行代码。
    1. ClassMethod MyFunction()
    2. {
    3. 	w "在主程序中",!
    4. 	d sub
    5. 	w "返回主程序",!
    6. 	q
    7. 	w "程序终止"
    8. sub
    9. 	w "在sub中",!
    10. 	for i=1 : 1 : 5{
    11. 		w "i=",i,!	
    12. 		if i=3 q
    13. 	}
    14. 	w "停止循环",!
    15. 	q
    16. 	w "sub退出",!
    17. }
    18. 程序运行结果：
    19. 在主程序中
    20. 在sub中
    21. i=1
    22. i=2
    23. i=3
    24. 停止循环
    25. 返回主程序
    • 在传统for循环的点语法中，quit相当于continue命令，会退出本次循环（不会退出循环），并继续下一次循环。
    1. ClassMethod MyFunction()
    2. {
    3. 	for i=1 : 1 : 3 d
    4. 	 //quit相当于退出本次的do结构，并不会退出循环
    5. 	 .q:i=2
    6. 	 .w "点语法i=",i,!	 
    7. 	
    8. 	for i=1 : 1 : 3{
    9. 		continue:i=2
    10. 		w "块语法i=",i,!	
    11. 	}
    12. }
    13. 程序运行结果：
    14. 点语法i=1
    15. 点语法i=3
    16. 块语法i=1
    17. 块语法i=3

    5.3 return命令

    • return命令简写为ret
    • return命令用于终止例程或程序的执行。
    • 当return命令在循环命令（for、while、do while）、try catch或传统的do结构内使用的话，使用return会终止当前例程或程序，并不会往后继续执行代码，这与quit命令有所不同。
    1. ClassMethod MyFunction()
    2. {
    3. 	w "在主程序中",!
    4. 	d sub
    5. 	w "返回主程序",!
    6. 	return
    7. 	w "程序终止"
    8. sub
    9. 	w "在sub中",!
    10. 	for i=1 : 1 : 5{
    11. 		w "i=",i,!	
    12. 		if i=3 return
    13. 	}
    14. 	w "停止循环",!
    15. 	return
    16. 	w "sub退出",!
    17. }
    18. 程序运行结果：
    19. 在主程序中
    20. 在sub中
    21. i=1
    22. i=2
    23. i=3
    24. 返回主程序
    • 在传统for循环的点语法中，return命令和quit命令效果一样，会退出本次循环（不会退出循环），并继续下一次循环。
    1. ClassMethod MyFunction()
    2. {
    3. 	for i=1 : 1 : 3 d
    4. 	 .ret:i=2
    5. 	 .w "点语法i=",i,!
    6. 	
    7. 	for i=1 : 1 : 3{
    8. 		ret:i=2
    9. 		w "块语法i=",i,!	
    10. 	}
    11. }
    12. 程序运行结果：
    13. 点语法i=1
    14. 点语法i=3
    15. 块语法i=1

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

    • 在for循环块语法，非传统for循环点语法中
    continue退出本次循环，继续下一次循环
    quit退出循环
    return退出循环，并结束当前运行方法（例程或程序）
    • 对于for循环块语法和点语法中，return和quit的不同
    块语法中，return可以直接退出并返回值
    点语法中，则需要在循环外定义一个变量，去接受并判断，才能返回值
    1. /// w ##class(User.Test4).MyFunction1(1)
    2. ClassMethod MyFunction17(x)
    3. {
    4. 	//定义一个变量，接收返回值
    5. 	set err = 0
    6. 	for i=1 : 1 : 3 q:err  d
    7. 	 .w "i=",i,!
    8. 	 .s err = ..Return(x)
    9. 	 
    10. 	 q:err "程序错误"
    11. 	 q "程序正确"
    12. }
    13.  
    14. /// w ##class(User.Test4).MyFunction2(1)
    15. ClassMethod MyFunction18(x)
    16. {
    17. 	for i=1 : 1 : 3{
    18. 		w "i=",i,!
    19. 		ret:..Return(x) "程序错误" 
    20. 	}
    21. 	q "程序正确"
    22. }
    23.  
    24. /// 1代表错误，0代表正确
    25. ClassMethod Return(x) As %Boolean
    26. {
    27. 	quit x
    28. }

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

    i=1
    程序错误

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

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

    • quit和return区别
    位置quitreturn
    方法或例程代码（非块结构）退出方法或例程，返回到调用方法或例程退出方法或例程，返回到调用方法或例程
    try或catch块退出方法或例程，返回到调用方法或例程
    do或者xecute退出方法或例程，返回到调用方法或例程退出方法或例程，返回到调用方法或例程
    if

    退出方法或例程，返回到调用方法或例程。

    如果嵌套在循环命令中，则退出循环，继续执行循环代码块后面代码

    		退出方法或例程，返回到调用方法或例程
    for、while、do while则退出循环，继续执行循环代码块后面代码退出方法或例程，返回到调用方法或例程

    6.输出命令

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

     6.1 write命令

            显示输出内容到当前设备

            1）后置表达式（可选）

    1. // 输出空
    2. w:(1>3) 1
    3.  
    4. // 输出3
    5. w:(3>1) 3

            2）有参数的write

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

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

            3）无参的write

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

            如下所示：

    1. /// w ##class(User.Test4).MyFunction19()
    2. ClassMethod MyFunction19()
    3. {
    4. 	set str1 = "red"
    5. 	set str2 = +123.40
    6. 	set str3 = "456.7"
    7. 	set str4 = "456.0"
    8. 	set str5 = "-999"
    9. 	w
    10. }

           输出如下：

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

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

     6.2 zwrite命令

            输出变量名称及其值

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

  • 相关阅读:
    Spring6 - ioc
    Python 全栈测试开发 Chapter8：接口测试
    大话设计模式之抽象工厂模式
    利用存储过程造测试数据
    MySQL针对数据库-基本操作
    【QT】TCP简易聊天框
    FlowUs息流开启知识管理的新纪元｜FlowUs息流公开知识库
    Spring封装数据结果
    图扑数字孪生空冷机组，助推智慧电厂拥抱“双碳”
    VulnHub | Web_Machine-N7
  • 原文地址：https://blog.csdn.net/qq_35507234/article/details/126573873