Funciones de objeto para Bicep

  • Artículo

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.

Espacio de nombres: sys.

Parámetros

Parámetro Obligatorio Type Descripción
itemToTest Sí matriz, objeto o cadena El valor para comprobar si está vacío.

Valor devuelto

Devuelve True si el valor está vacío; en caso contrario, False.

Ejemplo

En el ejemplo siguiente se comprueba si una matriz, un objeto y una cadena están vacíos.

param testArray array = []
param testObject object = {}
param testString string = ''

output arrayEmpty bool = empty(testArray)
output objectEmpty bool = empty(testObject)
output stringEmpty bool = empty(testString)

La salida del ejemplo anterior con el valor predeterminado es:

Nombre Tipo Value
arrayEmpty Bool True
objectEmpty Bool True
stringEmpty Bool 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 Valores adicionales 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 la intersección 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

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 Valores adicionales 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. A continuación, 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 combina no solo los elementos de nivel superior, sino que también combina recursivamente 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 la unión 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 funcionalidad 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