Unfortunately, for now, I think the only way is to use try catch in a script block and re-throw the error after performing the error handling. See example below:

pipeline {
    agent any
    stages {
        stage('1') {
            steps {
                sh 'exit 0'
            }
        }
        stage('2') {
            steps {
                catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
                    script {
                        try {
                            sh "exit 1"
                        } catch (e) {
                            echo 'send email'
                            throw e
                        }
                    }
                }
            }
        }
        stage('3') {
            steps {
                sh 'exit 0'
            }
        }
    }
}

It's the java/groovy Exception object. Try error.message for a brief trace.

To ignore a failed step in declarative pipeline you basically have two options:

1. Use script step and try-catch block (similar to previous proposition by R_K but in declarative style)

stage('someStage') {
    steps {
        script {
            try {
                build job: 'system-check-flow'
            } catch (err) {
                echo err.getMessage()
            }
        }
        echo currentBuild.result
    }
}

2. Use catchError

stage('someStage') {
    steps {
        catchError {
            build job: 'system-check-flow'
        }
        echo currentBuild.result
    }
}

In both cases the build won't be aborted upon exception in build job: 'system-check-flow'. In both cases the echo step (and any other following) will be executed.

But there's one important difference between these two options. In first case if the try section raises an exception the overall build status won't be changed (so echo currentBuild.result => SUCCESS). In the second case you overall build will fail (so echo currentBuild.result => FAILURE).

This is important, because you can always fail the overall build in first case (by setting currentBuild.result = 'FAILURE') but you can't repair build in second option (currentBuild.result = 'SUCCESS' won't work).

This is addressed in the official documentation, which provides two suggestions: the Pipeline step catchError { } and the native Groovy try-catch-finally syntax for handling exceptions.

Since it sounds like you may want your code to repeat on many different nodes, another option may be to put your nodes into parallel blocks. A failure in one parallel branch will not halt execution in any of the other parallel branches.

This worked for me by setting catchInterruptions to false:

catchError(buildResult: 'UNSTABLE', stageResult: 'UNSTABLE', catchInterruptions: false) {
    // Do some stuff here and continue the build if anything fails
}

Now, all stages are aborted with one click when we abort a build. Where previously, we would have to abort each stage individually.

try like this (no pun intended btw)

script {
  try {
      sh 'do your stuff'
  } catch (Exception e) {
      echo 'Exception occurred: ' + e.toString()
      sh 'Handle the exception!'
  }
}

The key is to put try...catch in a script block in declarative pipeline syntax. Then it will work. This might be useful if you want to say continue pipeline execution despite failure (eg: test failed, still you need reports..)