PlantUML包含了一些辅助性的预处理功能, 并且适用于所有的图.

这些功能与C language preprocessor很相似, 除了标记由#替换为!.


目前的预处理是由legacy preprocessor.升级而来.

虽然一些历史遗留功能仍被目前的预处理支持, 但是你不应该继续使用 (他们不久将会被移除).



虽然这还是必须的, 我们强烈建议变量名以 $开头. 有两类数据类型:

在函数外创建的变量作用域是global, 你可以在任何地方访问他们 (包括函数).当定义变量的时候你可以使用 global强调这一点.

!$ab = "foo1"
!$cd = "foo2"
!$ef = $ab + $cd

Alice -> Bob : $ab
Alice -> Bob : $cd
Alice -> Bob : $ef

Boolean expression

Boolean represention [0 is false]

There is not real boolean type, but PlantUML use this integer convention:

[Ref. QA-9702]

Boolean operation and operator [&&, ||, ()]

You can use boolean expression, in the test, with :

(See next example, within if test.)

Boolean builtin functions [%false(), %true(), %not(<exp>)]

For convenience, you can use those boolean builtin functions:

[See also Builtin functions]


!$a = 10
!$ijk = "foo"
Alice -> Bob : A
!if ($ijk == "foo") && ($a+10>=4)
Alice -> Bob : yes
Alice -> Bob : This should not appear
Alice -> Bob : B

While loop [!while, !endwhile]

You can use !while and !endwhile keywords to have repeat loops.

!procedure $foo($arg)
  :procedure start;
  !while $arg!=0
    !while $i!=0
      :arg=$arg and i=$i;
      !$i = $i - 1
    !$arg = $arg - 1
  :procedure end;


[Adapted from QA-10838]



!procedure msg($source, $destination)
$source --> $destination

!procedure init_class($name)
class $name {

!procedure $addCommonMethod()

msg("foo1", "foo2")

函数里定义的变量作用域为local. 意味着随函数一同销毁.


返回函数不输出任何东西. 它只是定义了一个你可以调用的函数:

!function $double($a)
!return $a + $a

Alice -> Bob : The double of 3 is $double(3)


!function $double($a) return $a + $a

Alice -> Bob : The double of 3 is $double(3)
Alice -> Bob : $double("This work also for strings.")

像空函数一样, 变量默认为'local'本地变量 (随函数退出销毁). 并且, 你可以在函数中访问'global'全局变量. 并且, 如何一个全局变量已存在,你仍可以使用 local 关键字创建一个同名的本地变量.

!procedure $dummy()
!local $ijk = "local"
Alice -> Bob : $ijk

!global $ijk = "foo"

Alice -> Bob : $ijk
Alice -> Bob : $ijk


在返回和空函数中, 你可以定义参数默认值.

!function $inc($value, $step=1)
!return $value + $step

Alice -> Bob : Just one more $inc(3)
Alice -> Bob : Add two to three : $inc(3, 2)


!procedure defaulttest($x, $y="DefaultY", $z="DefaultZ")
note over Alice
  x = $x
  y = $y
  z = $z
end note

defaulttest(1, 2, 3)
defaulttest(1, 2)


默认情况下, 调用一个函数需要引号. 可以使用 unquoted 关键字指明一个函数的参数不需要使用引号.

!unquoted function id($text1, $text2="FOO") return $text1 + $text2

alice -> bob : id(aa)
alice -> bob : id(ab,cd)

Keywords arguments

Like in Python, you can use keywords arguments :


!unquoted procedure $element($alias, $description="", $label="", $technology="", $size=12, $colour="green")
rectangle $alias as "


$element(myalias, "This description is\non several lines", $size=10, $technology="Java")

Including files or URL [!include, !include_many, !include_once]

Use the !include directive to include file in your diagram. Using URL, you can also include file from Internet/Intranet.

Imagine you have the very same class that appears in many diagrams. Instead of duplicating the description of this class, you can define a file that contains the description.


interface List
List : int size()
List : void clear()
List <|.. ArrayList

File List.iuml

interface List
List : int size()
List : void clear()

The file List.iuml can be included in many diagrams, and any modification in this file will change all diagrams that include it.

You can also put several @startuml/@enduml text block in an included file and then specify which block you want to include adding !0 where 0 is the block number. The !0 notation denotes the first diagram.

For example, if you use !include foo.txt!1, the second @startuml/@enduml block within foo.txt will be included.

You can also put an id to some @startuml/@enduml text block in an included file using @startuml(id=MY_OWN_ID) syntax and then include the block adding !MY_OWN_ID when including the file, so using something like !include foo.txt!MY_OWN_ID.

By default, a file can only be included once. You can use !include_many instead of !include if you want to include some file several times. Note that there is also a !include_once directive that raises an error if a file is included several times.

Including Subpart [!startsub, !endsub, !includesub]

You can also use !startsub NAME and !endsub to indicate sections of text to include from other files using !includesub. For example:



A -> A : stuff1
!startsub BASIC
B -> B : stuff2
C -> C : stuff3
!startsub BASIC
D -> D : stuff4

file1.puml would be rendered exactly as if it were:


A -> A : stuff1
B -> B : stuff2
C -> C : stuff3
D -> D : stuff4

However, this would also allow you to have another file2.puml like this:



title this contains only B and D
!includesub file1.puml!BASIC

This file would be rendered exactly as if:


title this contains only B and D
B -> B : stuff2
D -> D : stuff4

Builtin functions [%]

Some functions are defined by default. Their name starts by %

Name Description Example Return
%date Retrieve current date. You can provide an optional format for the date%date("yyyy.MM.dd' at 'HH:mm") Current date
%dirpath Retrieve current dirpath %dirpath() Current path
%false Return always false%false()false
%file_exists Check if a file exists on the local filesystem %file_exists("c:/foo/dummy.txt")true if the file exists
%filename Retrieve current filename %filename() Current filename
%function_exists Check if a function exists %function_exists("$some_function")true if the function has been defined
%get_variable_value Retrieve some variable value %get_variable_value("$my_variable") the value of the variable
%getenv Retrieve environment variable value %getenv("OS") The value of OS variable
%intval Convert a String to Int %intval("42") 42
%lower Return a lowercase string %lower("Hello")hello in that example
%not Return the logical negation of an expression %not(2+2==4)false in that example
%set_variable_value Set a global variable %set_variable_value("$my_variable", "some_value") An empty string
%string Convert an expression to String %string(1 + 2)3 in the example
%strlen Calculate the length of a String %strlen("foo")3 in the example
%strpos Search a substring in a string %strpos("abcdef", "ef") 4 (position of ef)
%substr Extract a substring. Takes 2 or 3 arguments %substr("abcdef", 3, 2)"de" in the example
%true Return always true%true()true
%upper Return an uppercase string %upper("Hello")HELLO in that example
%variable_exists Check if a variable exists %variable_exists("$my_variable")true if the variable has been defined exists
%version Return PlantUML current version %version()1.2020.08 for example

Logging [!log]

You can use !log to add some log output when generating the diagram. This has no impact at all on the diagram itself. However, those logs are printed in the command line's output stream. This could be useful for debug purpose.

!function bold($text)
!$result = "<b>"+ $text +"</b>"
!log Calling bold function with $text. The result is $result
!return $result

Alice -> Bob : This is bold("bold")
Alice -> Bob : This is bold("a second call")

Memory dump [!memory_dump]

You can use !memory_dump to dump the full content of the memory when generating the diagram. An optional string can be put after !memory_dump. This has no impact at all on the diagram itself. This could be useful for debug purpose.

!function $inc($string)
!$val = %intval($string)
!log value is $val
!return $val+1

Alice -> Bob : 4 $inc("3")
!unused = "foo"
!dump_memory EOF

Assertion [!assert]

You can put assertions in your diagram.

Alice -> Bob : Hello
!assert %strpos("abcdef", "cd")==3 : "This always fails"

Building custom library [!import, !include]

It's possible to package a set of included files into a single .zip or .jar archive. This single zip/jar can then be imported into your diagram using !import directive.

Once the library has been imported, you can !include file from this single zip/jar.



!import /path/to/
' This just adds "" in the search path

!include myFolder/myFile.iuml
' Assuming that myFolder/myFile.iuml is located somewhere
' either inside "" or on the local filesystem


Search path

You can specify the java property plantuml.include.path in the command line.

For example:

java -Dplantuml.include.path="c:/mydir" -jar plantuml.jar atest1.txt

Note the this -D option has to put before the -jar option. -D options after the -jar option will be used to define constants within plantuml preprocessor.

Argument concatenation [##]

It is possible to append text to a macro argument using the ## syntax.

!unquoted procedure COMP_TEXTGENCOMP(name)
[name] << Comp >>
interface Ifc << IfcType >> AS name##Ifc
name##Ifc - [name]

Dynamic invocation [%invoke_procedure(), %call_user_func()]

You can dynamically invoke a procedure using the special %invoke_procedure() procedure. This procedure takes as first argument the name of the actual procedure to be called. The optional following arguments are copied to the called procedure.

For example, you can have:

!procedure $go()
  Bob -> Alice : hello

!$wrapper = "$go"


!procedure $go($txt)
  Bob -> Alice : $txt

%invoke_procedure("$go", "hello from Bob...")

For return functions, you can use the corresponding special function %call_user_func() :

!function bold($text)
!return "<b>"+ $text +"</b>"

Alice -> Bob : %call_user_func("bold", "Hello") there

Evaluation of addition depending of data types [+]

Evaluation of $a + $b depending of type of $a or $b

<#LightBlue>|= |=  $a |=  $b |=  <U+0025>string($a + $b)|
<#LightGray>| type | str | str | str (concatenation) |
| example |= "a" |= "b" |= %string("a" + "b") |
<#LightGray>| type | str | int | str (concatenation) |
| ex.|= "a" |=  2  |= %string("a" + 2)   |
<#LightGray>| type | str | int | str (concatenation) |
| ex.|=  1  |= "b" |= %string(1 + "b")   |
<#LightGray>| type | bool | str | str (concatenation) |
| ex.|= <U+0025>true() |= "b" |= %string(%true() + "b") |
<#LightGray>| type | str | bool | str (concatenation) |
| ex.|= "a" |= <U+0025>false() |= %string("a" + %false()) |
<#LightGray>| type |  int  |  int | int (addition of int) |
| ex.|=  1  |=  2  |= %string(1 + 2)     |
<#LightGray>| type |  bool  |  int | int (addition) |
| ex.|= <U+0025>true() |= 2 |= %string(%true() + 2) |
<#LightGray>| type |  int  |  bool | int (addition) |
| ex.|=  1  |= <U+0025>false() |= %string(1 + %false()) |
<#LightGray>| type |  int  |  int | int (addition) |
| ex.|=  1  |=  <U+0025>intval("2")  |= %string(1 + %intval("2")) |
end title