Funciones de objeto para Bicep
En este artículo se describen las funciones de Bicep para trabajar con objetos.
contains
contains(container, itemToFind)
Comprueba si una matriz contiene un valor, un objeto contiene una clave o una cadena contiene una subcadena. La comparación de cadena distingue mayúsculas de minúsculas. Pero, cuando se prueba si un objeto contiene una clave, la comparación no distingue mayúsculas de minúsculas.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| contenedor | Sí | matriz, objeto o cadena | El valor que contiene el valor para buscar. |
| itemToFind | Sí | cadena o entero | El valor para buscar. |
Valor devuelto
True si el elemento se encuentra; en caso contrario, False.
Ejemplo
En el ejemplo siguiente se muestra cómo utilizar contains con diferentes tipos:
param stringToTest string = 'OneTwoThree'
param objectToTest object = {
one: 'a'
two: 'b'
three: 'c'
}
param arrayToTest array = [
'one'
'two'
'three'
]
output stringTrue bool = contains(stringToTest, 'e')
output stringFalse bool = contains(stringToTest, 'z')
output objectTrue bool = contains(objectToTest, 'one')
output objectFalse bool = contains(objectToTest, 'a')
output arrayTrue bool = contains(arrayToTest, 'three')
output arrayFalse bool = contains(arrayToTest, 'four')
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| stringTrue | Bool | True |
| stringFalse | Bool | False |
| objectTrue | Bool | True |
| objectFalse | Bool | False |
| arrayTrue | Bool | True |
| arrayFalse | Bool | False |
empty
empty(itemToTest)
Determina si una matriz, un objeto o una cadena están vacíos o null.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| itemToTest | Sí | matriz, objeto o cadena | Valor que se va a comprobar si está vacío o null. |
Valor devuelto
Devuelve True si el valor está vacío o null; de lo contrario, False.
Ejemplo
En el ejemplo siguiente se comprueba si una matriz, un objeto y una cadena están vacíos o null.
param testArray array = []
param testObject object = {}
param testString string = ''
param testNullString string?
output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(testString)
output stringNull bool = empty(testNullString)
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| arrayEmpty | Bool | True |
| objectEmpty | Bool | True |
| stringEmpty | Bool | True |
| stringNull | Booleano | True |
intersección
intersection(arg1, arg2, arg3, ...)
Devuelve una única matriz u objeto con los elementos comunes de los parámetros.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| arg1 | Sí | matriz u objeto | El primer valor que se utilizará para buscar elementos comunes. |
| arg2 | Sí | matriz u objeto | El segundo valor que se utilizará para buscar elementos comunes. |
| argumentos adicionales | No | matriz u objeto | Más valores que se utilizarán para buscar elementos comunes. |
Valor devuelto
Una matriz o un objeto con los elementos comunes.
Ejemplo
En el ejemplo siguiente se muestra cómo utilizar intersection con matrices y objetos:
param firstObject object = {
one: 'a'
two: 'b'
three: 'c'
}
param secondObject object = {
one: 'a'
two: 'z'
three: 'c'
}
param firstArray array = [
'one'
'two'
'three'
]
param secondArray array = [
'two'
'three'
]
output objectOutput object = intersection(firstObject, secondObject)
output arrayOutput array = intersection(firstArray, secondArray)
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| objectOutput | Object | {"one": "a", "three": "c"} |
| arrayOutput | Array | ["two", "three"] |
items
items(object)
Convierte un objeto de diccionario en una matriz. Consulta toObject sobre cómo convertir una matriz en un objeto.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Description |
|---|---|---|---|
| object | Sí | object | El objeto de diccionario que se va a convertir en una matriz. |
Valor devuelto
Una matriz de objetos para el diccionario convertido. Cada objeto de la matriz tiene una propiedad key que contiene el valor de clave para el diccionario. Además, cada objeto tiene una propiedad value que contiene las propiedades para el objeto.
Ejemplo
En el ejemplo siguiente se convierte un objeto de diccionario en una matriz. Para cada objeto de la matriz, crea un objeto con valores modificados.
var entities = {
item002: {
enabled: false
displayName: 'Example item 2'
number: 200
}
item001: {
enabled: true
displayName: 'Example item 1'
number: 300
}
}
var modifiedListOfEntities = [for entity in items(entities): {
key: entity.key
fullName: entity.value.displayName
itemEnabled: entity.value.enabled
}]
output modifiedResult array = modifiedListOfEntities
El ejemplo anterior devuelve:
"modifiedResult": {
"type": "Array",
"value": [
{
"fullName": "Example item 1",
"itemEnabled": true,
"key": "item001"
},
{
"fullName": "Example item 2",
"itemEnabled": false,
"key": "item002"
}
]
}
En el ejemplo siguiente se muestra la matriz que se devuelve de la función items.
var entities = {
item002: {
enabled: false
displayName: 'Example item 2'
number: 200
}
item001: {
enabled: true
displayName: 'Example item 1'
number: 300
}
}
var entitiesArray = items(entities)
output itemsResult array = entitiesArray
El ejemplo devuelve:
"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
}
}
]
}
En JSON, un objeto es una colección desordenada de cero o más pares clave-valor. El orden puede ser diferente en función de las implementaciones. Por ejemplo, la función Bicep items() ordena los objetos por orden alfabético. En otros lugares, se puede conservar la ordenación original. Debido a este no determinismo, evite realizar suposiciones sobre el orden de las claves de objeto al escribir código, que interactúa con los parámetros y salidas de implementación.
json
json(arg1)
Convierte una cadena JSON válida en un tipo de datos JSON.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| arg1 | Sí | string | Valor que se va a convertir en JSON. La cadena debe ser una cadena JSON con el formato correcto. |
Valor devuelto
El tipo de datos JSON de la cadena especificada o un valor vacío si se especifica null.
Observaciones
Si necesita incluir un valor de parámetro o variable en el objeto JSON, use la función concat para crear la cadena que se pasa a la función.
Ejemplo
En el ejemplo siguiente se muestra cómo usar la función json. Tenga en cuenta que puede pasar null para un objeto vacío.
param jsonEmptyObject string = 'null'
param jsonObject string = '{\'a\': \'b\'}'
param jsonString string = '\'test\''
param jsonBoolean string = 'true'
param jsonInt string = '3'
param jsonArray string = '[[1,2,3]]'
param concatValue string = 'demo value'
output emptyObjectOutput bool = empty(json(jsonEmptyObject))
output objectOutput object = json(jsonObject)
output stringOutput string =json(jsonString)
output booleanOutput bool = json(jsonBoolean)
output intOutput int = json(jsonInt)
output arrayOutput array = json(jsonArray)
output concatObjectOutput object = json(concat('{"a": "', concatValue, '"}'))
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| emptyObjectOutput | Boolean | True |
| objectOutput | Object | {"a": "b"} |
| stringOutput | String | test |
| booleanOutput | Boolean | True |
| intOutput | Entero | 3 |
| arrayOutput | Array | [ 1, 2, 3 ] |
| concatObjectOutput | Object | {"a": "demo value"} |
length
length(arg1)
Devuelve el número de elementos de una matriz, caracteres de una cadena o propiedades de nivel raíz de un objeto.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| arg1 | Sí | matriz, cadena u objeto | La matriz que se usará para obtener el número de elementos, la cadena que se usará para obtener el número de caracteres o el objeto que se usará para obtener el número de propiedades del nivel raíz. |
Valor devuelto
Un entero.
Ejemplo
En el ejemplo siguiente se muestra cómo utilizar length con una matriz y una cadena:
param arrayToTest array = [
'one'
'two'
'three'
]
param stringToTest string = 'One Two Three'
param objectToTest object = {
propA: 'one'
propB: 'two'
propC: 'three'
propD: {
'propD-1': 'sub'
'propD-2': 'sub'
}
}
output arrayLength int = length(arrayToTest)
output stringLength int = length(stringToTest)
output objectLength int = length(objectToTest)
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| arrayLength | Int | 3 |
| stringLength | Int | 13 |
| objectLength | Int | 4 |
objectKeys
objectKeys(object)
Devuelve las claves de un objeto, donde un objeto es una colección de pares clave-valor.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Description |
|---|---|---|---|
| object | Sí | objeto | El objeto, que es una colección de pares clave-valor. |
Valor devuelto
Matriz .
Ejemplo
El siguiente ejemplo se muestra cómo usar objectKeys con un objeto:
var obj = { a: 1, b: 2 }
output keyArray array = objectKeys(obj)
El resultado del ejemplo anterior es:
| Nombre | Tipo | Valor |
|---|---|---|
| keyArray | Matriz | [ "a", "b" ] |
keyArray devuelve una lista de claves del objeto de entrada.
En JSON, un objeto es una colección desordenada de cero o más pares clave-valor. El orden puede ser diferente en función de las implementaciones. Por ejemplo, la función Bicep items() ordena los objetos por orden alfabético. En otros lugares, se puede conservar la ordenación original. Debido a este no determinismo, evite realizar suposiciones sobre el orden de las claves de objeto al escribir código, que interactúa con los parámetros y salidas de implementación.
shallowMerge
shallowMerge(inputArray)
Combina una matriz de objetos, donde solo se combinan los objetos de nivel superior. Esto significa que si los objetos que se combinan contienen objetos anidados, esos objetos anidados no se combinan profundamente. En su lugar, se reemplazan completamente por la propiedad correspondiente del objeto de combinación.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| inputArray | Sí | array | Matriz de objetos . |
Valor devuelto
Objeto.
Ejemplo
En el siguiente ejemplo se muestra cómo usar shallowMerge:
var firstArray = [{ one: 'a' }, { two: 'b' }, { two: 'c'}]
var secondArray = [{ one: 'a', nested: {a: 1, nested: {c: 3}} }, { two: 'b', nested: {b: 2}}]
output firstOutput object = shallowMerge(firstArray)
output secondOutput object = shallowMerge(secondArray)
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| firstOutput | objeto | {"one":"a","two":"c"} |
| secondOutput | objeto | {"one":"a","nested":{"b":2},"two":"b"} |
firstOutput muestra las propiedades de los objetos de combinación combinadas en un nuevo objeto. Si hay propiedades en conflicto (es decir, propiedades con el mismo nombre) la propiedad del último objeto que se combina normalmente tiene prioridad.
secondOutput muestra que la combinación superficial no combina de manera recursiva estos objetos anidados. En su lugar, el objetivo anidado se reemplaza completamente por la propiedad correspondiente del objeto de combinación.
union
union(arg1, arg2, arg3, ...)
Devuelve una única matriz u objeto con todos los elementos de los parámetros. Para las matrices, los valores duplicados se incluyen una vez. Para los objetos, los nombres de propiedad duplicados solo se incluyen una vez.
Espacio de nombres: sys.
Parámetros
| Parámetro | Obligatorio | Type | Descripción |
|---|---|---|---|
| arg1 | Sí | matriz u objeto | El primer valor que se utiliza para unir elementos. |
| arg2 | Sí | matriz u objeto | El segundo valor que se utiliza para unir elementos. |
| argumentos adicionales | No | matriz u objeto | Más valores que se utilizan para unir elementos. |
Valor devuelto
Una matriz u objeto.
Comentarios
La función de unión usa la secuencia de los parámetros para determinar el orden y los valores del resultado.
Para las matrices, la función se itera por cada elemento del primer parámetro y lo agrega al resultado si no está presente. Después, repite el proceso para el segundo parámetro y los parámetros adicionales. Si un valor ya existe, se conserva su ubicación anterior en la matriz.
En el caso de los objetos, los nombres de propiedad y los valores del primer parámetro se agregan al resultado. Para los parámetros posteriores, se agregarán los nuevos nombres al resultado. Si un parámetro posterior tiene una propiedad con el mismo nombre, ese valor sobrescribe el valor existente. El orden de las propiedades no está garantizado.
La función union no solo combina los elementos de nivel superior, sino que también combina de forma recursiva los objetos anidados dentro de ellos. Los valores de matriz anidados no se combinan. Consulte el segundo ejemplo de la sección siguiente.
Ejemplo
En el ejemplo siguiente se muestra cómo utilizar union con matrices y objetos:
param firstObject object = {
one: 'a'
two: 'b'
three: 'c1'
}
param secondObject object = {
three: 'c2'
four: 'd'
five: 'e'
}
param firstArray array = [
'one'
'two'
'three'
]
param secondArray array = [
'three'
'four'
'two'
]
output objectOutput object = union(firstObject, secondObject)
output arrayOutput array = union(firstArray, secondArray)
La salida del ejemplo anterior con el valor predeterminado es:
| Nombre | Tipo | Value |
|---|---|---|
| objectOutput | Object | {"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"} |
| arrayOutput | Array | ["one", "two", "three", "four"] |
En el ejemplo siguiente se muestra la capacidad de combinación profunda:
var firstObject = {
property: {
one: 'a'
two: 'b'
three: 'c1'
}
nestedArray: [
1
2
]
}
var secondObject = {
property: {
three: 'c2'
four: 'd'
five: 'e'
}
nestedArray: [
3
4
]
}
var firstArray = [
[
'one'
'two'
]
[
'three'
]
]
var secondArray = [
[
'three'
]
[
'four'
'two'
]
]
output objectOutput object = union(firstObject, secondObject)
output arrayOutput array = union(firstArray, secondArray)
El resultado del ejemplo anterior es:
| Nombre | Tipo | Value |
|---|---|---|
| objectOutput | Object | {"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]} |
| arrayOutput | Array | [["one","two"],["three"],["four","two"]] |
Si se combinaron matrices anidadas, el valor de objectOutput.nestedArray sería [1, 2, 3, 4], y el valor de arrayOutput sería [["one", "two", "three"], ["three", "four", "two"]].
Pasos siguientes
- Puede encontrar una descripción de las secciones de un archivo de Bicep en Nociones sobre la estructura y la sintaxis de los archivos de Bicep.