JSON对象的模式，当不同对象中的项类型不同时，具有相同类型的项数组

我想描述一个具有数组类型属性的对象的模式。该数组中的项必须为相同类型。但对于该数组中的项，两个不同的对象可以具有不同的类型：

// object_1
{
  <...>,
  "array_of_some_type": [1, 2, 3, 4, 5],
  <...>
}

// object_2
{
  <...>,
  "array_of_some_type": ["one", "two", "three"],
  <...>
}

但这是错误的，因为此架构对“在我的案例中无效”对象有效：

// invalid_object
{
  <...>,
  "array_of_some_type": [1, "two", 3],
  <...>
}

//无效的\u对象
{
,
“某种类型的数组”：[1，“2”，3]，
}

正确的架构可以如下所示：

{
  "type": "object",
  "properties": {
    <...>
    "array_of_some_type": {
      "oneOf": [
        {
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": { "type": "number" },
          "additionalItems": false
        },
        {
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": { "type": "string" },
          "additionalItems": false
        },
        {
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": { "type": "object" },
          "additionalItems": false
        }
      ]
    },
    <...>
  },
  "required": [ "array_of_some_type" ],
  "additionalProperties": false
}

{
“类型”：“对象”，
“财产”：{
“某种类型的数组”：{
“其中之一”：[
{
“类型”：“数组”，
“迷你项目”：1，
“唯一项”：正确，
“项目”：{“类型”：“编号”}，
“附加项”：false
},
{
“类型”：“数组”，
“迷你项目”：1，
“唯一项”：正确，
“项”：{“类型”：“字符串”}，
“附加项”：false
},
{
“类型”：“数组”，
“迷你项目”：1，
“唯一项”：正确，
“项”：{“类型”：“对象”}，
“附加项”：false
}
]
},
},
“必需”：[“数组类型”]，
“附加属性”：false
}

但是有许多相同数组属性的重复项。

---

有没有办法调整第二个模式以避免重复？或任何其他建议？

您只能将变化的部分放在

oneOf

子句中。我认为JSON模式必须支持类似于Java的泛型的东西，才能更清晰地表达这一点

{
  "type": "object",
  "properties": {
    "array_of_some_type": {
      "type": "array",
      "minItems": 1,
      "uniqueItems": true,
      "oneOf": [
        { "items": { "type": "number" } },
        { "items": { "type": "string" } },
        { "items": { "type": "object" } }
      ]
    }
  },
  "required": [ "array_of_some_type" ],
  "additionalProperties": false
}

---

您只能将变化的部分放入

oneOf

子句中。我认为JSON模式必须支持类似于Java的泛型的东西，才能更清晰地表达这一点

{
  "type": "object",
  "properties": {
    "array_of_some_type": {
      "type": "array",
      "minItems": 1,
      "uniqueItems": true,
      "oneOf": [
        { "items": { "type": "number" } },
        { "items": { "type": "string" } },
        { "items": { "type": "object" } }
      ]
    }
  },
  "required": [ "array_of_some_type" ],
  "additionalProperties": false
}

---

在大多数情况下，最好使用anyOf，因为在大多数实现中，它会更快地验证。其中一个选项只有在只有一个选项有效时才有效，所以验证器必须验证所有选项。如果任何选项有效，则anyOf有效，因此一旦验证程序找到有效的选项，它将停止。@esp，说得好。在这种情况下，

oneOf

和

anyOf

都可以工作，

anyOf

将具有更好的验证性能。但是带有

oneOf

的模式将验证像

{“array\u of_some\u type:[1，“two”，3]}

这样的对象，这在我的情况下是无效的。还是我错了？这就是为什么我用

anyOf

创建了一个模式，但它有很多重复项。因此，我正在寻找一种只验证正确对象且不会有太多重复项的解决方案。@OlegCh，尝试一下，您将看到我提出的模式符合您的要求。您的示例将不会使用此架构进行验证。使用

anyOf

和

oneOf

两种方法都可以尝试。你会发现它们的工作原理完全相同。@Jason，你说得对！这是我对使用

oneOf

进行验证的误解。因此，如果在数组定义中指定了

oneOf

或

anyOf

，则会为第一个元素选择一次，然后应用于所有其他项？在大多数情况下最好使用anyOf-在大多数实现中验证速度更快。其中一个选项只有在只有一个选项有效时才有效，所以验证器必须验证所有选项。如果任何选项有效，则anyOf有效，因此一旦验证程序找到有效的选项，它将停止。@esp，说得好。在这种情况下，

oneOf

和

anyOf

都可以工作，

anyOf

将具有更好的验证性能。但是带有

oneOf

的模式将验证像

{“array\u of_some\u type:[1，“two”，3]}

这样的对象，这在我的情况下是无效的。还是我错了？这就是为什么我用

anyOf

创建了一个模式，但它有很多重复项。因此，我正在寻找一种只验证正确对象且不会有太多重复项的解决方案。@OlegCh，尝试一下，您将看到我提出的模式符合您的要求。您的示例将不会使用此架构进行验证。使用

anyOf

和

oneOf

两种方法都可以尝试。你会发现它们的工作原理完全相同。@Jason，你说得对！这是我对使用

oneOf

进行验证的误解。因此，如果在数组定义中指定了

oneOf

或

anyOf

，则会为第一个元素选择一次，然后应用于所有其他项？在大多数情况下最好使用anyOf-在大多数实现中验证速度更快。其中一个选项只有在只有一个选项有效时才有效，所以验证器必须验证所有选项。如果任何选项有效，则anyOf有效，因此一旦验证程序找到有效的选项，它将停止。@esp，说得好。在这种情况下，

oneOf

和

anyOf

都可以工作，

anyOf

将具有更好的验证性能。但是带有

oneOf

的模式将验证像

{“array\u of_some\u type:[1，“two”，3]}

这样的对象，这在我的情况下是无效的。还是我错了？这就是为什么我用

anyOf

创建了一个模式，但它有很多重复项。因此，我正在寻找一种只验证正确对象且不会有太多重复项的解决方案。@OlegCh，尝试一下，您将看到我提出的模式符合您的要求。您的示例将不会使用此架构进行验证。使用

anyOf

和

oneOf

两种方法都可以尝试。你会发现它们的工作原理完全相同。@Jason，你说得对！这是我对使用

oneOf

进行验证的误解。因此，如果在数组定义中指定了

oneOf

或

anyOf

，那么它将为第一个元素选择一次，然后应用于所有其他项？