JSON 没有要求的模式之一

Question

In JSON Schema draft 7 or 8 what is the right way to say that we want optionally either one of the attributes but not both. I can construct with required keyword, but then you have to include either one of the required attributes. This is what I can think of, is this correct?

In this example I'm trying to validate field_1 is required and we want either one of field_2 , field_3 or none of them. (see examples)

{
  "$schema": "http://json-schema.org/draft-08/schema#",
  "type": "object",
  "properties": {
    "field_1": {
      "type": "string"
    },
    "field_2": {
      "type": "string"
    },
    "field_3": {
      "type": "string"
    }
  },
  "required": [
    "field_1"
  ],
  "oneof": [
    {
      "properties": [
        "field_2"
      ]
    },
    {
      "properties": [
        "field_3"
      ]
    }
  ],
  "additionalProperties": false,
  "examples": [
    {
      "field_1": "1",
      "field_2": "2"
    },
    {
      "field_1": "1",
      "field_3": "3"
    },
    {
      "field_1": "1"
    }
  ]
}

Answer 1

[EDITED - SEE THIRD SOLUTION BELOW]

Solution 1 - At least one, but not both (verbose)

I would add an allOf with a nested oneOf :

{
  ...
  "allOf": [
    {
      "oneOf": [
        {"required": ["field_2"]},
        {"required": ["field_3"]}
      ],
    },
    {
      "not": {
        "required": ["field_2", "field_3"]
      }
    }
  ],
  ...
}

This requires that one of the two fields are present, but not both.

---

Solution 2 - At least one, but not both

I think this can be further simplified by using just the oneOf :

{
  ...
  "oneOf": [
    {"required": ["field_2"]},
    {"required": ["field_3"]}
  ],
  ...
}

• If neither are there, then these will both fail, and the oneOf fails.
• If one is there, then the oneOf passes.
• If both are there, then both of these will pass, and the oneOf fails.

Yeah, this is better. Looking at what you had, I think this is what you were trying to do, so you were really close!

---

Solution 3 - At most one

To pass when neither field are present you need the first solution, but change the allOf to an anyOf :

{
  ...
  "anyOf": [
    {
      "oneOf": [
        {"required": ["field_2"]},
        {"required": ["field_3"]}
      ],
    },
    {
      "not": {
        "required": ["field_2", "field_3"]
      }
    }
  ],
  ...
}

• If neither are there, then the not subschema will pass, and the anyOf passes.
• If one is there, then the oneOf subschema will pass, and the anyOf passes.
• If both are there, then
  • both of the oneOf subschemas will pass, so the oneOf fails
  • the not subschema will fail
  • so the anyOf fails

You can test these solutions here

Answer 2

Here's a couple more options to add to @gregdennis's answer.

Dependencies

This is a great use case for the dependencies keyword. This says, "if there is a "field_2" there can't be a "field_3" and, "if there is a "field_3" there can't be a "field_2". If neither "field_2" or "field_3" exist, no constraints apply and the schema passes.

"dependencies": {
  "field_2": { "not": { "required": ["field_3"] } },
  "field_3": { "not": { "required": ["field_2"] } }
}

maxProperties

This one is a bit hacky, but it has the benefit of being a one liner. If "field_1" is required and only one of "field_2" or "field_2" are allowed, there can not be more than two properties present in this object. Beware, this solution might be more clever than it's worth. Because this constraint works indirectly, it can be lead to maintenance difficulties in the future.

"maxProperties": 2

if/then

This is just a more verbose version of the dependencies options, but might be more descriptive for someone reading the schema.

"allOf": [
  {
    "if": { "required": ["field_2"] },
    "then": { "not": { "required": ["field_3"] } }
  },
  {
    "if": { "required": ["field_3"] },
    "then": { "not": { "required": ["field_2"] } }
  }
]

Answer 3

I had to try to figure this out for 3 fields where field 1 is also optional. Doing so revealed @gregdennis's answer to Solution 3 was slightly more than it needed to be, this accomplishes the same goal as there is no need to check for required single values as neither are required.

{
  ...
  "not": {
    "required": ["field_2", "field_3"]
  } 
  ...
}

To do this for 3, it looks like:

{
  ...
  "not": {
    "anyOf": [{
      "required": ["field_1", "field_2", "field_3"]
    },
    {
      "required": ["field_1", "field_2"]
    },
    {
      "required": ["field_2", "field_3"]
    },
    {
      "required": ["field_1", "field_3"]
    }]
  }
  ...
}

As you add more fields, this obviously becomes less useful. So a better solution with room to go to N is the following:

{
  ...
  "anyOf": [
    {
      "oneOf": [
        {"required": ["field_1"]},
        {"required": ["field_2"]},
        {"required": ["field_3"]}
      ]
    },
    {
      "not": {
        "anyOf": [
          {"required": ["field_1"]},
          {"required": ["field_2"]},
          {"required": ["field_3"]}
        ]
      }
    }
  ]
  ...
}

You can play with it here .

Answer 4

You can do this as follows:

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "field_1": {
      "type": "string"
    }
  },
  "oneOf": [
    {
      "properties": {

      },
      "additionalProperties": false
    },
    {
      "properties": {
        "field_2": {
          "type": "string"
        }
      },
      "required": ["field_2"],
      "additionalProperties": false
    },
    {
      "properties": {
        "field_3": {
          "type": "string"
        }
      },
      "required": ["field_3"],
      "additionalProperties": false
    }
  ],
  "required": [
    "field_1"
  ]
}

As stated in this book : "oneOf: (XOR) Must be valid against exactly one of the subschemas".

1. I added the field_1 to the "main" schema and marked this field as required.
2. I described three subschemas.

• The first schema without required fields.
• The second schema with required "field_2" field.
• The third schema with required "field_3" field.

3. For all subschemas I set the "additionalProperties" in the value false .