检查参数的更好方法？

Question

In various situations I'm confronted with the problem, that I need to check the parameters of a function to guarantee a correct program flow.

I found that it is becoming to be a bit tedious to create if-else blocks just to check for nullpointer, ranges of numbers, correct strings, correct objects and so on. Besides the code becomes more difficult to read and thus it becomes more difficult to have the overview.

So I thought what if there is a way in java/javascript/c#... (programming languages with functions in it) where you can define some pre-conditions.

So for eg in java:

  void doSomething( int a {0 <= a < 10}, String b {b != "wrong" && b != [1-9]}){
   ...
  }

or something like this:

  §a: 0 <= a && 10 > a || a == 25 ...
  §b: ...
  §ifWrongPreConditions: return; //or throw a new default Exception or whatever
  void doSomething( int a, String b){
    §a: 0 <= a && 10 > a || a == 25 ...
    §b: ...
    §ifWrongPreConditions: return; //or throw a new default Exception or whatever
  ...Code...
  }

or above the method head. Basically the second idea could help for post-conditions too and you only need one look at the function to know what you need to do so that the function is working correct.

But I'm not sure if there is something like already implemented, but I want to have it a little easier to become an overview over the "meta-info" of a function so can anticipate the desired and undesired behavior and it might be easier to make it work with OCL.

So back to the question: Is there a good way to define Pre-, Post-Conditions, maybe Invariants for methods (maybe classes and similar stuff) that are easy to read in the respective language?

(PS Im not sure if the tags I set here are "correct", because it is a practical question for different languages about a concept that might confront programmers in those languages. Sorry in advance for that)

Answer 1

Java has no argument validation feature in the JDK. However, there is specification for Bean Validation which has similar capabilities. and there are 3rd party libraries and frameworks that implement above mentioned specification. One of the popular frameworks is Spring which has a module for annotation based Validation

Here is an example for such validation:

package hello;

import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Size;

public class PersonForm {

    @NotNull
    @Size(min=2, max=30)
    private String name;

    @NotNull
    @Min(18)
    private Integer age;

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String toString() {
        return "Person(Name: " + this.name + ", Age: " + this.age + ")";
    }
}

Answer 2

Answering for Java first. There we have bean validation :

• you use a declarative approach, by using annotations on the "data structures" that your code will be using
• you then have some framework "in the background" that takes care of validating actual data against the declared expectations

The essential thought here: you absolutely do not validate data structures "manually". Instead, you establish a notation that can be applied to such structures, and then you have a generic framework to turn declarations into runtime checks.

JavaScript has similar ideas, see the validatejs library for example.

And of course, same things exist in C#, too. See this SO question for example.

Answer 3

Assertions are a fairly standard cross-language approach. The nice thing about assertions is that, in most environments, you can include them for testing, but turn them off for release builds on the theory you've found the bugs they defend against. For that reason, assertions are not the way to handle user input, of course.

Java has direct support for them ( assert ), as does the .Net platform ( Debug.Assert ). JavaScript doesn't have direct support for assertions, but they're readily added with a utility function, or you could write a Babel plug-in for them that compiles the assertion to nothing for release builds.

assert example:

void doSomething(int a, String b) {
    assert a >= 0 && a < 10;
    assert !b.equals("wrong") && /*...your second condition didn't make sense for strings */;
}