JSON模式oneof不需要

在

JSON模式中

草案7或草案8中，我们可以选择使用其中一个属性，而不是两个属性。我可以使用

required

关键字进行构造，但是您必须包含任何一个必需的属性。这就是我能想到的，对吗

在本例中，我试图验证

字段_1

是必需的，我们需要

字段_2

、

字段_3

中的一个，或者不需要它们。（见示例）

[已编辑-请参阅下面的第三种解决方案] 解决方案1-至少一个，但不是两个（详细） 我将添加一个

allOf

，其中嵌套一个

oneOf

：

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

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

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

这需要两个字段中的一个字段存在，但不能同时存在

---

解决方案2-至少一个，但不是两个 我认为这可以通过使用中的

来进一步简化：

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

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

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


如果两者都不存在，则这两个都将失败，其中一个将失败
如果有一个，则通过其中一个
如果两者都存在，则这两个都将通过，并且其中一个将失败

是的，这样更好。看看你所拥有的，我想这就是你想要做的，所以你真的很接近


解决方案3-最多一个
要在两个字段都不存在时通过，您需要第一个解决方案，但将
allOf
更改为
anyOf
：

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

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

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


如果两者都不存在，则
not
子模式将通过，而
anyOf
将通过
如果存在一个，则子模式中的
oneOf
将通过，而
anyOf
将通过
如果两者都存在，那么

两个
oneOf
子模式都将通过，因此
oneOf
将失败
not
子模式将失败
因此，
anyOf
失败


您可以测试这些解决方案
[已编辑-请参阅下面的第三个解决方案]
解决方案1-至少一个，但不是两个（详细）
我将添加一个
allOf
，其中嵌套一个
oneOf
：

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

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

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

这需要两个字段中的一个字段存在，但不能同时存在


解决方案2-至少一个，但不是两个
我认为这可以通过使用

中的

来进一步简化：

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

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

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


如果两者都不存在，则这两个都将失败，其中一个将失败
如果有一个，则通过其中一个
如果两者都存在，则这两个都将通过，并且其中一个将失败

是的，这样更好。看看你所拥有的，我想这就是你想要做的，所以你真的很接近


解决方案3-最多一个
要在两个字段都不存在时通过，您需要第一个解决方案，但将
allOf
更改为
anyOf
：

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

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

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


如果两者都不存在，则
not
子模式将通过，而
anyOf
将通过
如果存在一个，则子模式中的
oneOf
将通过，而
anyOf
将通过
如果两者都存在，那么

两个
oneOf
子模式都将通过，因此
oneOf
将失败
not
子模式将失败
因此，
anyOf
失败


您可以测试这些解决方案
这里还有几个选项可以添加到@gregdennis的答案中

依赖关系
这是
依赖项
关键字的一个很好的用例。这意味着，“如果有一个“场_2”，就不会有“场_3”，如果有一个“场_3”，就不会有“场_2”。如果“field_2”或“field_3”都不存在，则不应用任何约束，模式通过

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

maxProperties
这一条有点老套，但它的好处是它是一条单行线。如果需要“field_1”，并且只允许“field_2”或“field_2”中的一个，则此对象中不能存在两个以上的属性。注意，这个解决方案可能比它的价值更聪明。由于该约束间接起作用，因此可能导致将来的维护困难

"maxProperties": 2

如果/那么
这只是
依赖项
选项的更详细版本，但对于阅读模式的人来说可能更具描述性

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

在@gregdennis的答案中，还有几个选项需要添加

依赖关系
这是
依赖项
关键字的一个很好的用例。这意味着，“如果有一个“场_2”，就不会有“场_3”，如果有一个“场_3”，就不会有“场_2”。如果“field_2”或“field_3”都不存在，则不应用任何约束，模式通过

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

maxProperties
这一条有点老套，但它的好处是它是一条单行线。如果需要“field_1”，并且只允许“field_2”或“field_2”中的一个，则此对象中不能存在两个以上的属性。注意，这个解决方案可能比它的价值更聪明。由于该约束间接起作用，因此可能导致将来的维护困难

"maxProperties": 2

如果/那么
这只是
依赖项
选项的更详细版本，但对于阅读模式的人来说可能更具描述性

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

我的一个要求是，即使
字段2
或
字段3
都不存在，它也应该通过，我看第二个解决方案不会通过这个。在您的第一个解决方案中，我觉得
allof
块中的两个条件是矛盾的。任何意见…我已经编辑了答案，以适应“两者都不”的要求。谢谢你的第三个解决方案工作得很好。虽然有点冗长，但Jason提供的依赖项解决方案也非常方便。我意识到有多种方法可以实现这一点。使用JSON模式有多种方法可以实现大多数事情。我的要求之一是，即使不存在
field_2
或
field_3
，它也应该通过，我看不到第二种解决方案通过这一点。在第一个解决方案中，我觉得
allof
块中的两个条件是相反的