How to avoid tags from try block in output on exceptions with kotlinx.html

Question

How to avoid tags from try block in output on exceptions with kotlinx.html

75 Views Asked by languitar At 16 April 2025 at 17:07

With kotlinx.html, exception handling looks counter-intuitive to me. In a try-catch block, tags created in the try block are still part of the HTML output even if an exception occurs. How can this be prevented.

Example code:

import kotlinx.html.ATarget
import kotlinx.html.a
import kotlinx.html.body
import kotlinx.html.div
import kotlinx.html.html
import kotlinx.html.stream.appendHTML

fun main() {
    System.out.appendHTML().html {
        body {
            try {
                div {
                    a("https://kotlinlang.org") {
                        target = ATarget.blank
                        +"Main site"
                        throw RuntimeException("test");
                    }
                }
            } catch (e: RuntimeException) {
                +"Exception handled"
            }
        }
    }
}

This produces:

<html>
  <body>
    <div><a href="https://kotlinlang.org" target="_blank">Main site</a></div>
Exception handled</body>
</html>

I wouldn't want to see the whole div-a combination.

Original Q&A

There are 1 best solutions below

**Benjamin Charais** · Answer 1

This is expected. All code until an exception is expected to run and have the full impact of being run. We can add mechanisms to work as you're expecting, but many languages use this as an error handling pattern, Kotlin does not have a unique method of error handling.

Kotlin has built the HTML wrappers to be a DSL that is line by line adding the fields as they are interpreted. This will mean anything up until an Exception will be a part of the resulting Element.

Writing a function like this will continue to show that case.

fun main() {
    val myDiv = document.create.div {
        try {
            a("https://kotlinlang.org") {
                target = ATarget.blank
                +"Main site"
                throw RuntimeException("test");
            }
        } catch (e: RuntimeException) {
            +"Exception handled"
        }
    }

    println(JSON.stringify(myDiv.outerHTML, null, 2))
}

Output:

<div>
  <a href="https://kotlinlang.org" target="_blank">
   Main site
  </a>
  Exception handled
</div>

If this functionality is not desired and you are looking for the output to be similar to:

<div>
  Exception handled
</div>

Then you will want to adopt a pattern like:

fun main() {
    val renderElement = with(document.create) {
        try {
            div {
                a("https://kotlinlang.org") {
                    target = ATarget.blank
                    +"Main Site"
                    throw RuntimeException("test")
                }
            }
        } catch (e: RuntimeException) {
            div {
                +"Exception Handled"
            }
        }
    }

    println(JSON.stringify(renderElement.outerHTML, null, 2))
}

In this I am using the scope function with to make the creation easier and more similar to the normal DSL calls. Then in either side of the try/catch, I add a div, because if it was a top level div in the try, it would still have everything that had been added before the exception itself. This is because of the DSL that is built into the library.

If you open the div definition you will see the visitAndFinalize call, which is what is having the DSL happen on every line that is called.

DIV(attributesMapOf("class", classes), this).visitAndFinalize(this, block)

If you must be working with a JVM based system rather than a JS based target, you can then create a document to get the similar syntax mentioned above:

fun main() {
    val renderElement = document {
        append.div {
            try {
                div {
                    a("https://kotlinlang.org") {
                        target = ATarget.blank
                        +"Main Site"
                        throw RuntimeException("test")
                    }
                }
            } catch (e: RuntimeException) {
                div {
                    +"Exception Handled"
                }
            }
        }
    }

    println(renderElement.serialize(true))
}

There are many ways this can be approached, but this should be one method to achieve what you are looking for

Documentation from the Library for reference: DOM-trees

How to avoid tags from try block in output on exceptions with kotlinx.html

There are 1 best solutions below

Related Questions in KOTLIN

Related Questions in KTOR

Related Questions in KOTLINX-HTML

Trending Questions

Popular # Hahtags

Popular Questions