Megosztás a következőn keresztül:


Objektumfüggvények ARM-sablonokhoz

A Resource Manager számos függvényt biztosít az Azure Resource Manager-sablonban (ARM-sablonban) található objektumok kezeléséhez:

Tipp.

A Bicep használatát javasoljuk, mert ugyanazokkal a képességekkel rendelkezik, mint az ARM-sablonok, és a szintaxis használata egyszerűbb. További információkért tekintse meg az objektumfüggvényeket .

contains

contains(container, itemToFind)

Ellenőrzi, hogy egy tömb tartalmaz-e értéket, egy objektum tartalmaz-e kulcsot, vagy egy sztring tartalmaz-e részsztringet. A sztringek összehasonlítása megkülönbözteti a kis- és nagybetűk értékét. Ha azonban egy objektum tartalmaz kulcsot, az összehasonlítás érzéketlen.

A Bicepben használja a contains függvényt.

Paraméterek

Paraméter Kötelező Típus Leírás
tároló Igen tömb, objektum vagy sztring A keresendő értéket tartalmazó érték.
itemToFind Igen sztring vagy int A keresendő érték.

Visszaadott érték

Igaz , ha az elem megtalálható; ellenkező esetben Hamis.

Példa

Az alábbi példa bemutatja, hogyan használható contains különböző típusokkal:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "stringToTest": {
      "type": "string",
      "defaultValue": "OneTwoThree"
    },
    "objectToTest": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c"
      }
    },
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "stringTrue": {
      "type": "bool",
      "value": "[contains(parameters('stringToTest'), 'e')]"
    },
    "stringFalse": {
      "type": "bool",
      "value": "[contains(parameters('stringToTest'), 'z')]"
    },
    "objectTrue": {
      "type": "bool",
      "value": "[contains(parameters('objectToTest'), 'one')]"
    },
    "objectFalse": {
      "type": "bool",
      "value": "[contains(parameters('objectToTest'), 'a')]"
    },
    "arrayTrue": {
      "type": "bool",
      "value": "[contains(parameters('arrayToTest'), 'three')]"
    },
    "arrayFalse": {
      "type": "bool",
      "value": "[contains(parameters('arrayToTest'), 'four')]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
stringTrue Bool Igaz
stringFalse Bool Hamis
objectTrue Bool Igaz
objectFalse Bool Hamis
arrayTrue Bool Igaz
arrayFalse Bool Hamis

createObject

createObject(key1, value1, key2, value2, ...)

Objektumot hoz létre a kulcsokból és értékekből.

A createObject Bicep nem támogatja a függvényt. Objektum létrehozása a következő használatával {}: . Lásd: Objektumok.

Paraméterek

Paraméter Kötelező Típus Leírás
1. kulcs Nem húr A kulcs neve.
érték1 Nem int, boolean, string, object vagy array A kulcs értéke.
további kulcsok Nem húr A kulcsok további nevei.
további értékek Nem int, boolean, string, object vagy array További értékek a kulcsokhoz.

A függvény csak páros számú paramétert fogad el. Minden kulcsnak egyező értékkel kell rendelkeznie.

Visszaadott érték

Egy objektum az egyes kulcsokkal és értékpárokkal.

Példa

Az alábbi példa egy objektumot hoz létre különböző típusú értékekből.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
  ],
  "outputs": {
    "newObject": {
      "type": "object",
      "value": "[createObject('intProp', 1, 'stringProp', 'abc', 'boolProp', true(), 'arrayProp', createArray('a', 'b', 'c'), 'objectProp', createObject('key1', 'value1'))]"
    }
  }
}

Az előző példában az alapértelmezett értékekkel rendelkező kimenet egy objektum, amelynek neve newObject a következő érték:

{
  "intProp": 1,
  "stringProp": "abc",
  "boolProp": true,
  "arrayProp": ["a", "b", "c"],
  "objectProp": {"key1": "value1"}
}

üres

empty(itemToTest)

Meghatározza, hogy egy tömb, objektum vagy sztring üres-e.

A Bicepben használja az üres függvényt.

Paraméterek

Paraméter Kötelező Típus Leírás
itemToTest Igen tömb, objektum vagy sztring Az az érték, amely ellenőrzi, hogy üres-e.

Visszaadott érték

Igaz értéket ad vissza, ha az érték üres; ellenkező esetben Hamis.

Példa

Az alábbi példa azt ellenőrzi, hogy egy tömb, objektum és sztring üres-e.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "testArray": {
      "type": "array",
      "defaultValue": []
    },
    "testObject": {
      "type": "object",
      "defaultValue": {}
    },
    "testString": {
      "type": "string",
      "defaultValue": ""
    }
  },
  "resources": [
  ],
  "outputs": {
    "arrayEmpty": {
      "type": "bool",
      "value": "[empty(parameters('testArray'))]"
    },
    "objectEmpty": {
      "type": "bool",
      "value": "[empty(parameters('testObject'))]"
    },
    "stringEmpty": {
      "type": "bool",
      "value": "[empty(parameters('testString'))]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
arrayEmpty Bool Igaz
objectEmpty Bool Igaz
stringEmpty Bool Igaz

Kereszteződés

intersection(arg1, arg2, arg3, ...)

Egyetlen tömböt vagy objektumot ad vissza a paraméterek gyakori elemeivel.

A Bicepben használja a metszetfüggvényt.

Paraméterek

Paraméter Kötelező Típus Leírás
arg1 Igen tömb vagy objektum A gyakori elemek megkereséséhez elsőként használandó érték.
arg2 Igen tömb vagy objektum A második érték, amelyet a gyakori elemek kereséséhez használunk.
további argumentumok Nem tömb vagy objektum További értékek a gyakori elemek megtalálásához.

Visszaadott érték

Egy tömb vagy objektum a közös elemekkel.

Példa

Az alábbi példa bemutatja, hogyan használható intersection tömbökkel és objektumokkal.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "firstObject": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c"
      }
    },
    "secondObject": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "z",
        "three": "c"
      }
    },
    "firstArray": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    },
    "secondArray": {
      "type": "array",
      "defaultValue": [ "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "objectOutput": {
      "type": "object",
      "value": "[intersection(parameters('firstObject'), parameters('secondObject'))]"
    },
    "arrayOutput": {
      "type": "array",
      "value": "[intersection(parameters('firstArray'), parameters('secondArray'))]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
objectOutput Objektum {"one": "a", "három": "c"}
arrayOutput Tömb ["two", "three"]

elemek

items(object)

Egy szótárobjektumot tömbté alakít át. Tekintse meg a tömb objektummá alakításáról szóló toObject című témakört.

A Bicepben használja az elemeket.

Paraméterek

Paraméter Kötelező Típus Leírás
object Igen object A tömbké konvertálandó szótárobjektum.

Visszaadott érték

A konvertált szótár objektumtömbje. A tömb minden objektuma rendelkezik egy key tulajdonságmal, amely tartalmazza a szótár kulcsértékét. Minden objektum rendelkezik egy value tulajdonsággal is, amely az objektum tulajdonságait tartalmazza.

Példa

Az alábbi példa egy szótárobjektumot tömbté alakít át. A tömb minden objektumához létrehoz egy új objektumot módosított értékekkel.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "copy": [
      {
        "name": "modifiedListOfEntities",
        "count": "[length(items(variables('entities')))]",
        "input": {
          "key": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].key]",
          "fullName": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].value.displayName]",
          "itemEnabled": "[items(variables('entities'))[copyIndex('modifiedListOfEntities')].value.enabled]"
        }
      }
    ],
    "entities": {
      "item002": {
        "enabled": false,
        "displayName": "Example item 2",
        "number": 200
      },
      "item001": {
        "enabled": true,
        "displayName": "Example item 1",
        "number": 300
      }
    }
  },
  "resources": [],
  "outputs": {
    "modifiedResult": {
      "type": "array",
      "value": "[variables('modifiedListOfEntities')]"
    }
  }
}

Az előző példa a következőt adja vissza:

"modifiedResult": {
  "type": "Array",
  "value": [
    {
      "fullName": "Example item 1",
      "itemEnabled": true,
      "key": "item001"
    },
    {
      "fullName": "Example item 2",
      "itemEnabled": false,
      "key": "item002"
    }
  ]
}

Az alábbi példa az elemek függvényből visszaadott tömböt mutatja be.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "entities": {
      "item002": {
        "enabled": false,
        "displayName": "Example item 2",
        "number": 200
      },
      "item001": {
        "enabled": true,
        "displayName": "Example item 1",
        "number": 300
      }
    },
    "entitiesArray": "[items(variables('entities'))]"
  },
  "resources": [],
  "outputs": {
    "itemsResult": {
      "type": "array",
      "value": "[variables('entitiesArray')]"
    }
  }
}

A példa a következőt adja vissza:

"itemsResult": {
  "type": "Array",
  "value": [
    {
      "key": "item001",
      "value": {
        "displayName": "Example item 1",
        "enabled": true,
        "number": 300
      }
    },
    {
      "key": "item002",
      "value": {
        "displayName": "Example item 2",
        "enabled": false,
        "number": 200
      }
    }
  ]
}

A JSON-ban az objektum nulla vagy több kulcs/érték pár rendezetlen gyűjteménye. A rendezés a megvalósítástól függően eltérő lehet. A Bicep items() függvény például betűrendbe rendezi az objektumokat. Más helyeken az eredeti sorrend megőrizhető. Emiatt a nem determinizmus miatt ne feltételezze az objektumkulcsok sorrendjét a kód írásakor, amely az üzembehelyezési paraméterekkel és kimenetekkel kommunikál.

json

json(arg1)

Egy érvényes JSON-sztringet JSON-adattípussá alakít át.

A Bicepben használja a json függvényt.

Paraméterek

Paraméter Kötelező Típus Leírás
arg1 Igen húr A JSON-ra konvertálandó érték. A sztringnek megfelelően formázott JSON-sztringnek kell lennie.

Visszaadott érték

A megadott sztring JSON-adattípusa, vagy null érték megadásakor üres érték.

Megjegyzések

Ha paraméterértéket vagy változót kell megadnia a JSON-objektumban, a formátumfüggvény használatával hozza létre a függvénynek átadott sztringet.

Null() érték lekéréséhez is használhatja a null() értéket.

Példa

Az alábbi példa a függvény használatát json mutatja be. Figyelje meg, hogy egy üres objektumot be tud adni null .

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "jsonEmptyObject": {
      "type": "string",
      "defaultValue": "null"
    },
    "jsonObject": {
      "type": "string",
      "defaultValue": "{\"a\": \"b\"}"
    },
    "jsonString": {
      "type": "string",
      "defaultValue": "\"test\""
    },
    "jsonBoolean": {
      "type": "string",
      "defaultValue": "true"
    },
    "jsonInt": {
      "type": "string",
      "defaultValue": "3"
    },
    "jsonArray": {
      "type": "string",
      "defaultValue": "[[1,2,3 ]"
    },
    "concatValue": {
      "type": "string",
      "defaultValue": "demo value"
    }
  },
  "resources": [
  ],
  "outputs": {
    "emptyObjectOutput": {
      "type": "bool",
      "value": "[empty(json(parameters('jsonEmptyObject')))]"
    },
    "objectOutput": {
      "type": "object",
      "value": "[json(parameters('jsonObject'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[json(parameters('jsonString'))]"
    },
    "booleanOutput": {
      "type": "bool",
      "value": "[json(parameters('jsonBoolean'))]"
    },
    "intOutput": {
      "type": "int",
      "value": "[json(parameters('jsonInt'))]"
    },
    "arrayOutput": {
      "type": "array",
      "value": "[json(parameters('jsonArray'))]"
    },
    "concatObjectOutput": {
      "type": "object",
      "value": "[json(concat('{\"a\": \"', parameters('concatValue'), '\"}'))]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
emptyObjectOutput Logikai Igaz
objectOutput Objektum {"a": "b"}
stringOutput Sztring teszt
booleanOutput Logikai Igaz
intOutput Egész 3
arrayOutput Tömb [ 1, 2, 3 ]
concatObjectOutput Objektum { "a": "demo value" }

length (hossz)

length(arg1)

Egy tömb elemeinek számát, egy sztringben szereplő karaktereket vagy egy objektum gyökérszintű tulajdonságait adja vissza.

A Bicepben használja a hosszfüggvényt.

Paraméterek

Paraméter Kötelező Típus Leírás
arg1 Igen tömb, sztring vagy objektum Az elemek számának lekéréséhez használandó tömb, a karakterek számának lekéréséhez használandó sztring vagy a gyökérszintű tulajdonságok számának lekéréséhez használni kívánt objektum.

Visszaadott érték

Egy int.

Példa

Az alábbi példa egy tömb és egy sztring használatát length mutatja be:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [
        "one",
        "two",
        "three"
      ]
    },
    "stringToTest": {
      "type": "string",
      "defaultValue": "One Two Three"
    },
    "objectToTest": {
      "type": "object",
      "defaultValue": {
        "propA": "one",
        "propB": "two",
        "propC": "three",
        "propD": {
          "propD-1": "sub",
          "propD-2": "sub"
        }
      }
    }
  },
  "resources": [],
  "outputs": {
    "arrayLength": {
      "type": "int",
      "value": "[length(parameters('arrayToTest'))]"
    },
    "stringLength": {
      "type": "int",
      "value": "[length(parameters('stringToTest'))]"
    },
    "objectLength": {
      "type": "int",
      "value": "[length(parameters('objectToTest'))]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
arrayLength Int 3
stringLength Int 13
objectLength Int 4

null

null()

Null értéket ad vissza.

A null függvény nem érhető el a Bicepben. Használja inkább a kulcsszót null .

Paraméterek

A null függvény nem fogad el paramétereket.

Visszaadott érték

Mindig null értékű érték.

Példa

Az alábbi példa a null függvényt használja.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "emptyOutput": {
      "type": "bool",
      "value": "[empty(null())]"
    }
  }
}

Az előző példa kimenete a következő:

Név Típus Érték
emptyOutput Bool Igaz

objectKeys

objectKeys(object)

Egy objektum kulcsait adja vissza, ahol az objektum kulcs-érték párok gyűjteménye.

A Bicepben használja az objectKeys függvényt .

Paraméterek

Paraméter Kötelező Típus Leírás
object Igen object Az objektum, amely kulcs-érték párok gyűjteménye.

Visszaadott érték

Egy tömb.

Példa

Az alábbi példa bemutatja, hogyan használható objectKeys egy objektummal:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "obj": {
      "a": 1,
      "b": 2
    }
  },
  "resources": [],
  "outputs": {
    "keyArray": {
      "type": "array",
      "value": "[objectKeys(variables('obj'))]"
    }
  }
}

Az előző példa kimenete a következő:

Név Típus Érték
keyArray Tömb [ "a", "b" ]

A JSON-ban az objektum nulla vagy több kulcs/érték pár rendezetlen gyűjteménye. A rendezés a megvalósítástól függően eltérő lehet. A Bicep items() függvény például betűrendbe rendezi az objektumokat. Más helyeken az eredeti sorrend megőrizhető. Emiatt a nem determinizmus miatt ne feltételezze az objektumkulcsok sorrendjét a kód írásakor, amely az üzembehelyezési paraméterekkel és kimenetekkel kommunikál.

shallowMerge

shallowMerge(inputArray)

Egyesít egy objektumtömböt, amelyben csak a legfelső szintű objektumok egyesülnek. Ez azt jelenti, hogy ha az egyesített objektumok beágyazott objektumokat tartalmaznak, a beágyazott objektumok nem lesznek mélyen egyesítve; ehelyett teljes egészében az egyesítési objektum megfelelő tulajdonsága váltja fel őket.

A Bicep-ben használja a shallowMerge függvényt .

Paraméterek

Paraméter Kötelező Típus Leírás
inputArray Igen array Objektumok tömbje.

Visszaadott érték

Egy objektum.

Példa

Az alábbi példa a használat módját shallowMergemutatja be:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "firstArray": [
      {
        "one": "a"
      },
      {
        "two": "b"
      },
      {
        "two": "c"
      }
    ],
    "secondArray": [
      {
        "one": "a",
        "nested": {
          "a": 1,
          "nested": {
            "c": 3
          }
        }
      },
      {
        "two": "b",
        "nested": {
          "b": 2
        }
      }
    ]
  },
  "resources": [],
  "outputs": {
    "firstOutput": {
      "type": "object",
      "value": "[shallowMerge(variables('firstArray'))]"
    },
    "secondOutput": {
      "type": "object",
      "value": "[shallowMerge(variables('secondArray'))]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
firstOutput object {"one":"a","two":"c"}
secondOutput object {"one":"a","nested":{"b":2},"two":"b"}

A firstOutput az egyesítő objektumok tulajdonságait egy új objektumba egyesíti. Ha ütköző tulajdonságok (azaz azonos nevű tulajdonságok) vannak, az utolsó egyesített objektum tulajdonsága általában elsőbbséget élvez.

a secondOutput azt mutatja, hogy a sekély egyesítés nem egyesíti újra a beágyazott objektumokat. Ehelyett a teljes beágyazott objektum helyébe az egyesítő objektum megfelelő tulajdonsága lép.

unió

union(arg1, arg2, arg3, ...)

Egyetlen tömböt vagy objektumot ad vissza a paraméterek összes elemével. Tömbök esetén a rendszer egyszer tartalmazza az ismétlődő értékeket. Objektumok esetén a rendszer csak egyszer tartalmazza a duplikált tulajdonságneveket.

A Bicepben használja az egyesítő függvényt.

Paraméterek

Paraméter Kötelező Típus Leírás
arg1 Igen tömb vagy objektum Az első elemillesztéshez használható érték.
arg2 Igen tömb vagy objektum Az elemek összekapcsolásához használt második érték.
további argumentumok Nem tömb vagy objektum További értékek az elemek összekapcsolásához.

Visszaadott érték

Tömb vagy objektum.

Megjegyzések

Az egyesítő függvény a paraméterek sorrendjét használja az eredmény sorrendjének és értékeinek meghatározásához.

Tömbök esetén a függvény végigfut az első paraméter minden elemén, és hozzáadja az eredményhez, ha még nincs jelen. Ezután megismétli a második paraméter és a további paraméterek folyamatát. Ha egy érték már jelen van, a tömb korábbi elhelyezése megmarad.

Objektumok esetén a rendszer hozzáadja az első paraméter tulajdonságneveit és értékeit az eredményhez. A későbbi paraméterek esetében a rendszer minden új nevet hozzáad az eredményhez. Ha egy későbbi paraméter azonos nevű tulajdonsággal rendelkezik, az az érték felülírja a meglévő értéket. A tulajdonságok sorrendje nem garantált.

Az egyesítő függvény nem csak a legfelső szintű elemeket egyesíti, hanem rekurzív módon egyesít minden beágyazott tömböt és objektumot bennük. Lásd a második példát a következő szakaszban.

Példa

Az alábbi példa a tömbök és objektumok használatát union mutatja be:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "firstObject": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c1"
      }
    },
    "secondObject": {
      "type": "object",
      "defaultValue": {
        "three": "c2",
        "four": "d",
        "five": "e"
      }
    },
    "firstArray": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    },
    "secondArray": {
      "type": "array",
      "defaultValue": [ "three", "four" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "objectOutput": {
      "type": "object",
      "value": "[union(parameters('firstObject'), parameters('secondObject'))]"
    },
    "arrayOutput": {
      "type": "array",
      "value": "[union(parameters('firstArray'), parameters('secondArray'))]"
    }
  }
}

Az előző példában szereplő kimenet az alapértelmezett értékekkel a következő:

Név Típus Érték
objectOutput Objektum {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput Tömb ["egy", "kettő", "három", "négy"]

Az alábbi példa a mélyegyesítési képességet mutatja be:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "firstObject": {
      "property": {
        "one": "a",
        "two": "b",
        "three": "c1"
      },
      "nestedArray": [
        1,
        2
      ]
    },
    "secondObject": {
      "property": {
        "three": "c2",
        "four": "d",
        "five": "e"
      },
      "nestedArray": [
        3,
        4
      ]
    },
    "firstArray": [
      [
        "one",
        "two"
      ],
      [
        "three"
      ]
    ],
    "secondArray": [
      [
        "three"
      ],
      [
        "four",
        "two"
      ]
    ]
  },
  "resources": [],
  "outputs": {
    "objectOutput": {
      "type": "Object",
      "value": "[union(variables('firstObject'), variables('secondObject'))]"
    },
    "arrayOutput": {
      "type": "Array",
      "value": "[union(variables('firstArray'), variables('secondArray'))]"
    }
  }
}

Az előző példa kimenete a következő:

Név Típus Érték
objectOutput Objektum {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]}
arrayOutput Tömb [["egy","két"],["három"],["négy","kettő"]]

Ha a beágyazott tömbök egyesítve lennének, akkor az objectOutput.nestedArray értéke [1, 2, 3, 4], a arrayOutput értéke pedig [["one", "two", "three"], ["three", "four", "two"]].

Következő lépések