Datadrivna formatuttryck i iOS SDK (förhandsversion)

Artikel
04/07/2024

Kommentar

Azure Kartor iOS SDK-tillbakadragning

Azure Kartor Native SDK för iOS är nu inaktuell och kommer att dras tillbaka den 3/31/25. För att undvika tjänststörningar migrerar du till Azure Kartor Web SDK senast 3/31/25. Mer information finns i migreringsguiden för Azure Kartor iOS SDK.

Lager använder predikat och uttryck för att avgöra vad som ska visas och hur det ska formateras. Predikat representeras av samma NSPredicate klass som filtrerar resultat från Kärndata eller objekt i en NSArray i Objective-C. Predikat baseras på uttryck som representeras av NSExpression klassen.

I det här dokumentet beskrivs den specifika delmängden av predikat- och uttryckssyntaxen som stöds av denna SDK. En mer allmän introduktion till predikat och uttryck finns i dokumentationen om predikatprogrammering i Apple Developer.

Använda predikat för att filtrera vektordata

De flesta lagerklasser visar Feature objekt som du kan visa eller dölja baserat på funktionens egenskaper. Använd alternativet filter för att endast inkludera de funktioner i källlagret som uppfyller ett villkor som du definierar.

Operatorer

Följande jämförelseoperatorer stöds:

`NSPredicateOperatorType`	Formatera strängsyntax
`NSEqualToPredicateOperatorType`	`key = value` `key == value`
`NSGreaterThanOrEqualToPredicateOperatorType`	`key >= value` `key => value`
`NSLessThanOrEqualToPredicateOperatorType`	`key <= value` `key =< value`
`NSGreaterThanPredicateOperatorType`	`key > value`
`NSLessThanPredicateOperatorType`	`key < value`
`NSNotEqualToPredicateOperatorType`	`key != value` `key <> value`
`NSBetweenPredicateOperatorType`	`key BETWEEN { 32, 212 }`

Om du vill testa om en funktion har eller saknar en specifik egenskap jämför du attributet med NULL eller NIL. Predikat som skapas med initieraren NSPredicate(value:) stöds också. Strängoperatorer och anpassade operatorer stöds inte.

Följande sammansatta operatorer stöds:

`NSCompoundPredicateType`	Formatera strängsyntax
`NSAndPredicateType`	`predicate1 AND predicate2` `predicate1 && predicate2`
`NSOrPredicateType`	`predicate1 OR predicate2` `predicate1 \\|\\| predicate2`
`NSNotPredicateType`	`NOT predicate` `!predicate`

Följande aggregeringsoperatorer stöds:

`NSPredicateOperatorType`	Formatera strängsyntax
`NSInPredicateOperatorType`	`key IN { 'iOS', 'macOS', 'tvOS', 'watchOS' }`
`NSContainsPredicateOperatorType`	`{ 'iOS', 'macOS', 'tvOS', 'watchOS' } CONTAINS key`

Du kan använda operatorerna IN och CONTAINS för att testa om ett värde visas i en samling, om en sträng är en delsträng av en större sträng eller om den utvärderade funktionen (SELF) ligger inom en viss Feature.

Följande kombinationer av jämförelseoperatorer och modifierare stöds:

`NSComparisonPredicateModifier`	`NSPredicateOperatorType`	Formatera strängsyntax
`NSAllPredicateModifier`	`NSNotEqualToPredicateOperatorType`	`ALL haystack != needle`
`NSAnyPredicateModifier`	`NSEqualToPredicateOperatorType`	`ANY haystack = needle` `SOME haystack = needle`

Följande alternativ för jämförelsepredikat stöds för jämförelse- och aggregeringsoperatorer som används i predikatet:

`NSComparisonPredicateOptions`	Formatera strängsyntax
`NSCaseInsensitivePredicateOption`	`'QUEBEC' =[c] 'Quebec'`
`NSDiacriticInsensitivePredicateOption`	`'Québec' =[d] 'Quebec'`

Andra alternativ för jämförelsepredikat stöds inte, nämligen l (för språkkänslighet) och n (för normalisering). En jämförelse är språkkänslig så länge den är skiftlägeskänslig eller diakritisk. Alternativ för jämförelsepredikat stöds inte med jämförelsemodifierare som ALL och ANY.

Operander

Operander i predikat kan vara variabler, nyckelsökvägar eller nästan allt annat som kan visas i ett uttryck.

Automatisk typgjutning utförs inte. Därför matchar en funktion endast ett predikat om dess värde för egenskapen i fråga är av samma typ som det värde som anges i predikatet. Använd operatorn CAST() för att konvertera en nyckelsökväg eller variabel till en matchande typ:

Om du vill omvandla ett värde till ett tal använder du CAST(key, 'NSNumber').
Om du vill omvandla ett värde till en sträng använder du CAST(key, 'NSString').
Om du vill omvandla ett värde till en färg använder du CAST(key, 'UIColor').
Om du vill omvandla ett UIColor objekt till en matris använder du CAST(noindex(color), 'NSArray').

Mer information om strängsyntaxen för predikatformat finns i kapitlet "Predicate Format String Syntax" i dokumentationen om predikatprogrammering i Apple Developer.

Exempel på operander

Bubbel- och symbolskikt återger som standard koordinaterna för alla geometrier i en datakälla. Det här beteendet kan markera hörnen för en polygon eller en rad. Alternativet filter för lagret kan användas för att begränsa geometritypen för de funktioner som återges med hjälp NSExpression.geometryTypeAZMVariable av ett predikat. I följande exempel begränsas ett bubbellager så att endast Point funktioner återges.

let layer = BubbleLayer(source: source, options: [
    .filter(
        from: NSPredicate(format: "%@ == \"Point\"", NSExpression.geometryTypeAZMVariable)
    )
])

I följande exempel kan både Point och Polygon funktioner återges.

let layer = BubbleLayer(source: source, options: [
    .filter(
        from: NSCompoundPredicate(orPredicateWithSubpredicates: [
            NSPredicate(format: "%@ == \"Point\"", NSExpression.geometryTypeAZMVariable),
            NSPredicate(format: "%@ == \"Polygon\"", NSExpression.geometryTypeAZMVariable)
        ])
    )
])

Använda uttryck för att konfigurera lageralternativ

Ett uttryck kan innehålla underuttryck av olika typer. Varje typ av uttryck som stöds beskrivs nedan.

Några exempel i det här avsnittet av dokumentet använder följande funktion för att demonstrera olika sätt på vilka dessa uttryck kan användas.

{
    "type": "Feature",
    "geometry": {
        "type": "Point",
        "coordinates": [-122.13284, 47.63699]
    },
    "properties": {
        "id": 123,
        "entityType": "restaurant",
        "revenue": 12345,
        "subTitle": "Building 40", 
        "temperature": 64,
        "title": "Cafeteria", 
        "zoneColor": "purple",
        "abcArray": ["a", "b", "c"],
        "array2d": [["a", "b"], ["x", "y"]],
        "_style": {
            "fillColor": "red"
        }
    }
}

Följande kod visar hur du manuellt skapar den här GeoJSON-funktionen i en app.

// Create a point feature.
let feature = Feature(Point(CLLocationCoordinate2D(latitude: 45, longitude: -100)))

// Add properties to the feature.
feature.addProperty("id", value:  123)
feature.addProperty("entityType", value: "restaurant")
feature.addProperty("revenue", value:  12345)
feature.addProperty("subTitle", value: "Building 40")
feature.addProperty("temperature", value:  64)
feature.addProperty("title", value: "Cafeteria")
feature.addProperty("zoneColor", value: "purple")
feature.addProperty("abcArray", value: ["a", "b", "c"])
feature.addProperty("array2d", value: [["a", "b"], ["x", "y"]])
feature.addProperty("_style", value: ["fillColor": "red"])

Följande kod visar hur du deserialiserar den strängifierade versionen av JSON-objektet till en GeoJSON-funktion i en app.

let featureString = "{\"type\":\"Feature\",\"geometry\":{\"type\":\"Point\",\"coordinates\":[-122.13284,47.63699]},\"properties\":{\"id\":123,\"entityType\":\"restaurant\",\"revenue\":12345,\"subTitle\":\"Building 40\",\"temperature\":64,\"title\":\"Cafeteria\",\"zoneColor\":\"purple\",\"abcArray\":[\"a\",\"b\",\"c\"],\"array2d\":[[\"a\",\"b\"],[\"x\",\"y\"]],\"_style\":{\"fillColor\":\"red\"}}}"

let feature = Feature.fromJson(featureString)

JSON-baserad

Azure Kartor Web SDK stöder också datadrivna formatuttryck som representeras med hjälp av en JSON-matris. Samma uttryck kan återskapas med hjälp av den interna NSExpression klassen i iOS SDK. Alternativt kan dessa JSON-baserade uttryck delas till ios-appen (till exempel kopplat till svaret) och skickas till NSExpression(azmJSONObject:) metoden. Ta till exempel följande JSON-uttryck.

var exp = ['get','title'];

Den snabba versionen av ovanstående uttryck skulle vara ["get", "title"] och kan läsas in i iOS SDK på följande sätt.

let jsonResponse = ["get", "title"]
let exp = NSExpression(azmJSONObject: jsonResponse)

Med den här metoden kan du enkelt återanvända formatuttryck mellan mobila appar och webbappar som använder Azure Kartor.

Den här videon ger en översikt över datadriven formatering i Azure Kartor.

Internet of Things Show – datadriven formatering med Azure Kartor

Konstanta värden

Ett konstant värde kan vara av någon av följande typer:

UIColor
String
NSNumber.boolValue
NSNumber.doubleValue
[Float]
[String]
NSValue.cgVectorValue
NSValue.uiEdgeInsetsValue

Exempel på konstantvärden

NSExpression(forConstantValue: UIColor.red)
NSExpression(forConstantValue: "constant")
NSExpression(forConstantValue: true)
NSExpression(forConstantValue: 20)
NSExpression(forConstantValue: [20, 21, 22])
NSExpression(forConstantValue: ["constant1", "constant2"])
NSExpression(forConstantValue: NSValue(cgVector: CGVector(dx: 2, dy: -4)))
NSExpression(forConstantValue: NSValue(uiEdgeInsets: UIEdgeInsets(top: 8, left: 0, bottom: 8, right: 0)))

Nyckelsökvägar

Ett nyckelsökvägsuttryck refererar till en egenskap för objektet Feature som utvärderas för visning. Om en polygons Feature.properties ordlista till exempel innehåller floorCount nyckeln refererar nyckelsökvägen floorCount till värdet för egenskapen när du utvärderar just den polygonen floorCount .

Vissa tecken kanske inte används direkt som en del av en nyckelsökväg i en formatsträng. Om en funktions egenskap till exempel heter ISO 3166-1:2006, skulle en uttrycksformatsträng av lowercase(ISO 3166-1:2006) eller en predikatformatsträng ISO 3166-1:2006 == 'US-OH' för generera ett undantag. Använd i stället en %K platshållare eller NSExpression(forKeyPath:) initieraren:

NSPredicate(format: "%K == 'US-OH'", "ISO 3166-1:2006")
NSExpression(
   forFunction: "lowercase:",
   arguments: [NSExpression(forKeyPath: "ISO 3166-1:2006")]
)

Functions

Av de funktioner som fördefinierades av NSExpression(forFunction:arguments:) metoden stöds följande delmängd i lageralternativ:

Parametern Initializer	Formatera strängsyntax
`average:`	`average({1, 2, 2, 3, 4, 7, 9})`
`sum:`	`sum({1, 2, 2, 3, 4, 7, 9})`
`count:`	`count({1, 2, 2, 3, 4, 7, 9})`
`min:`	`min({1, 2, 2, 3, 4, 7, 9})`
`max:`	`max({1, 2, 2, 3, 4, 7, 9})`
`add:to:`	`1 + 2`
`from:subtract:`	`2 - 1`
`multiply:by:`	`1 * 2`
`divide:by:`	`1 / 2`
`modulus:by:`	`modulus:by:(1, 2)`
`sqrt:`	`sqrt(2)`
`log:`	`log(10)`
`ln:`	`ln(2)`
`raise:toPower:`	`2 ** 2`
`exp:`	`exp(0)`
`ceiling:`	`ceiling(0.99999)`
`abs:`	`abs(-1)`
`trunc:`	`trunc(6378.1370)`
`floor:`	`floor(-0.99999)`
`uppercase:`	`uppercase('Elysian Fields')`
`lowercase:`	`lowercase('DOWNTOWN')`
`noindex:`	`noindex(0 + 2 + c)`
`length:`	`length('Wapakoneta')`
`castObject:toType:`	`CAST(ele, 'NSString')` `CAST(ele, 'NSNumber')`

Följande fördefinierade funktioner stöds inte :

Parametern Initializer	Formatera strängsyntax
`median:`	`median({1, 2, 2, 3, 4, 7, 9})`
`mode:`	`mode({1, 2, 2, 3, 4, 7, 9})`
`stddev:`	`stddev({1, 2, 2, 3, 4, 7, 9})`
`random`	`random()`
`randomn:`	`randomn(10)`
`now`	`now()`
`bitwiseAnd:with:`	`bitwiseAnd:with:(5, 3)`
`bitwiseOr:with:`	`bitwiseOr:with:(5, 3)`
`bitwiseXor:with:`	`bitwiseXor:with:(5, 3)`
`leftshift:by:`	`leftshift:by:(23, 1)`
`rightshift:by:`	`rightshift:by:(23, 1)`
`onesComplement:`	`onesComplement(255)`
`distanceToLocation:fromLocation:`	`distanceToLocation:fromLocation:(there, here)`

Villkorssatser

Villkor stöds via den inbyggda NSExpression(forAZMConditional:trueExpression:falseExpression:) metoden och TERNARY() operatorn. Om du behöver uttrycka flera fall ("else-if") kan du antingen kapsla en villkorsstyrd i en villkorsstyrd eller använda matchningsuttrycket.

Exempel på villkorsstyrda villkor

I följande exempel går vi igenom olika predikat tills det hittar ett som utvärderas till trueoch sedan returnerar dess sanna uttryck. Om inga predikat utvärderas till truereturneras det sista falska uttrycket.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                // Check to see whether a feature has a zoneColor property
                forAZMConditional: NSPredicate(format: "zoneColor != NIL"),
                // If it has a zoneColor property, use its value as a color.
                trueExpression: NSExpression(forKeyPath: "zoneColor"),
                // if not, do another check
                falseExpression: NSExpression(
                    // Check to see whether it has a temperature property with a value greater than or equal to 100.
                    forConditional: NSPredicate(format: "temperature != nil && temperature >= 100"),
                    // If it has, use red color.
                    trueExpression: NSExpression(forConstantValue: UIColor.red),
                    // If not, use green color.
                    falseExpression: NSExpression(forConstantValue: UIColor.green)
                )
            )
        )
    ]
)

Aggregeringar

Aggregerade uttryck kan innehålla uttrycksmatriser. I vissa fall är det möjligt att använda själva matrisen i stället för att omsluta matrisen i ett aggregerat uttryck.

Variabler

Th iOS SDK definierar följande variabler för användning med lageralternativ.

Funktionsidentifierare

En funktions ID. Den här variabeln motsvarar NSExpression.featureIdentifierAZMVariable egenskapen.

Formatera strängsyntax: $featureIdentifier

Funktionsegenskaper

En funktions egenskapsobjekt. Den här variabeln motsvarar NSExpression.featurePropertiesAZMVariable egenskapen.

Formatera strängsyntax: $featureAttributes

Funktion ackumulerad

Värdet för en klusteregenskap som ackumulerats hittills. Detta kan bara användas i clusterProperties alternativet för en klustrad DataSource källa. Den här variabeln motsvarar NSExpression.featureAccumulatedAZMVariable egenskapen.

Formatera strängsyntax: $featureAccumulated

Geometrityp

Typen av geometri som representeras av funktionen. En funktionstyp är en av följande strängar:

Point för punktfunktioner som motsvarar Point klassen.
MultiPoint för punktsamlingsfunktioner som motsvarar PointCollection klassen.
LineString för polylinefunktioner som motsvarar Polyline klassen.
MultiLineString för flera polylines-funktioner som motsvarar MultiPolyline klassen.
Polygon för polygonfunktioner som motsvarar Polygon klassen.
MultiPolygon för flera polygonfunktioner som motsvarar MultiPolygon klassen.
GeometryCollection för geometrisamlingsfunktioner som motsvarar GeometryCollection klassen.

Den här variabeln motsvarar NSExpression.geometryTypeAZMVariable egenskapen.

Formatera strängsyntax: $geometryType

Exempel på variabler

Se Operands-exempel.

Zooma

Den aktuella zoomnivån. I lagrets formatalternativ kan den här variabeln bara visas som mål för en interpolering på översta nivån eller ett steguttryck. Den här variabeln motsvarar NSExpression.zoomLevelAZMVariable egenskapen.

Formatera strängsyntax: $zoomLevel

Zooma exempel

Som standard har radien av datapunkter som återges i värmekartlagret en fast punktradie för alla zoomnivåer. När kartan zoomas aggregeras data och värmekartlagret ser annorlunda ut. Ett zoom uttryck kan användas för att skala radien för varje zoomnivå så att varje datapunkt täcker samma fysiska område på kartan. Det gör att värmekartlagret ser mer statiskt och konsekvent ut. Varje zoomningsnivå på kartan har dubbelt så många punkter lodrätt och vågrätt som den tidigare zoomnivån. Om du skalar radien, så att den fördubblas med varje zoomnivå, skapas en värmekarta som ser konsekvent ut på alla zoomnivåer. Det kan utföras med uttrycket zoom med ett base 2 exponential interpolation uttryck, med punktradien inställd för den minsta zoomnivån och en skalad radie för den maximala zoomnivå som beräknas enligt pow(2, maxZoom - minZoom) * radius nedan.

let layer = HeatMapLayer(
   source: source,
   options: [
      .heatmapRadius(
         from: NSExpression(
            forAZMInterpolating: .zoomLevelAZMVariable,
            curveType: .exponential,
            parameters: NSExpression(forConstantValue: 2),
            stops: NSExpression(forConstantValue: [
               // For zoom level 1 set the radius to 2 points.
               1: 2,

               // Between zoom level 1 and 19, exponentially scale the radius from 2 points to 2 * 2^(maxZoom - minZoom) points.
               19: pow(2, 19 - 1) * 2
            ])
         )
      )
   ]
)

HeatMap-densitet

Kerneldensitetens uppskattning av en skärmpunkt i ett heatmap-lager, med andra ord ett relativt mått på hur många datapunkter som trängs runt en viss pixel. Den här variabeln utvärderas till ett tal mellan 0 och 1. Den används i kombination med ett interpolation eller step ett uttryck för att definiera den färgtoning som används för att färglägga värmekartan. Kan endast användas i heatmapColor alternativet för termisk kartskikt. Den här variabeln motsvarar NSExpression.heatmapDensityAZMVariable egenskapen.

Formatera strängsyntax: $heatmapDensity

Dricks

Färgen vid index 0, i ett interpolationsuttryck eller standardfärgen för en stegfärg, definierar färgen på det område där det inte finns några data. Färgen på index 0 kan användas för att definiera en bakgrundsfärg. Många föredrar att ange det här värdet till transparent eller halvtransparent svart.

Exempel på HeatMap-densitet

I det här exemplet används ett linerinterpolationsuttryck för att skapa en jämn färgtoning för återgivning av värmekartan.

let layer = HeatMapLayer(
   source: source,
   options: [
      .heatmapColor(
         from: NSExpression(
            forAZMInterpolating: .heatmapDensityAZMVariable,
            curveType: .linear,
            parameters: nil,
            stops: NSExpression(forConstantValue: [
               0: UIColor.magenta.withAlphaComponent(0),
               0.01: UIColor.magenta,
               0.5: UIColor(red: 251 / 255, green: 0, blue: 251 / 255, alpha: 1),
               1: UIColor(red: 0, green: 195 / 255, blue: 1, alpha: 1)
            ])
         )
      )
   ]
)

Förutom att använda en jämn toning för att färglägga en värmekarta kan färger anges inom en uppsättning intervall med hjälp av ett steguttryck. Om du använder ett steguttryck för att färglägga värmekartan bryts densiteten visuellt upp i områden som liknar en kontur- eller radarformatkarta.

let layer = HeatMapLayer(
   source: source,
   options: [
      .heatmapColor(
         from: NSExpression(
            forAZMStepping: .heatmapDensityAZMVariable,
            from: NSExpression(forConstantValue: UIColor.clear),
            stops: NSExpression(forConstantValue: [
               0.01: UIColor(red: 0, green: 0, blue: 128 / 255, alpha: 1),
               0.25: UIColor.cyan,
               0.5: UIColor.green,
               0.75: UIColor.yellow,
               1: UIColor.red
            ])
         )
      )
   ]
)

Mer information finns i artikeln Lägg till ett termisk kartskikt .

Radförlopp

Ett tal som anger det relativa avståndet längs en linje vid en viss punkt längs linjen. Den här variabeln utvärderas till 0 i början av raden och 1 i slutet av raden. Den kan bara användas med LineLayerOption.strokeGradient alternativet för linjeskiktet. Den motsvarar NSExpression.lineProgressAZMVariable egenskapen.

Formatera strängsyntax: $lineProgress

Kommentar

Alternativet strokeGradient för linjeskiktet kräver lineMetrics att alternativet för datakällan anges till true.

Exempel på radförlopp

I det NSExpression.lineProgressAZMVariable här exemplet används uttrycket för att tillämpa en färgtoning på linjestrecket.

let layer = LineLayer(
   source: source,
   options: [
      .strokeGradient(
         from: NSExpression(
            forAZMInterpolating: NSExpression.lineProgressAZMVariable,
            curveType: .linear,
            parameters: nil,
            stops: NSExpression(forConstantValue: [
               0: UIColor.blue,
               0.1: UIColor(red: 0.25, green: 0.41, blue: 1, alpha: 1), // Royal Blue
               0.3: UIColor.cyan,
               0.5: UIColor(red: 0, green: 1, blue: 0, alpha: 1), // Lime
               0.7: UIColor.yellow,
               1: UIColor.red
            ])
         )
      )
   ]
)

Se liveexempel

Azure Kartor-specifika metoder

I följande avsnitt visas specifika för Azure Kartor metoder som utökar NSExpression klassen

Matcha uttryck

Ett matchningsuttryck är en typ av villkorsuttryck som tillhandahåller switch-statement som logik. Indata kan vara valfritt uttryck som NSExpression(forKeyPath: "entityType") returnerar en sträng eller ett tal. Det matchade uttrycket är en ordlista som ska ha nycklar som uttryck som utvärderas antingen till en sträng eller ett tal eller till en matris med alla strängar eller alla tal och värden som alla uttryck. Om indatauttryckstypen inte matchar typen av nycklar är resultatet standardåterställningsvärdet.

Exempel på matchningsuttryck

I följande exempel tittar vi på entityType egenskapen för en Point funktion i ett bubbellager och söker efter en matchning. Om den hittar en matchning returneras det angivna värdet eller returnerar återställningsvärdet.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                // Get the input value to match.
                forAZMMatchingKey: NSExpression(forKeyPath: "entityType"),
                // List the keys to match and the value to return for each match.
                in: [
                    // If value is "restaurant" return red color.
                    NSExpression(forConstantValue: "restaurant"): NSExpression(forConstantValue: UIColor.red),
                    // If value is "park" return green color.
                    NSExpression(forConstantValue: "park"): NSExpression(forConstantValue: UIColor.green)
                ],
                // Specify a default value to return if no match is found.
                default: NSExpression(forConstantValue: UIColor.black)
            )
        )
    ]
)

I följande exempel används ett uttryck som utvärderar till strängmatris för att ange en uppsättning etiketter som alla ska returnera samma värde. Den här metoden är mycket effektivare än att lista varje etikett individuellt. Om egenskapen entityType i det här fallet är "restaurant" eller "grocery_store"returneras röd färg.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                // Get the input value to match.
                forAZMMatchingKey: NSExpression(forKeyPath: "entityType"),
                // List the keys to match and the value to return for each match.
                in: [
                    // If value is "restaurant" or "grocery_store" return red color.
                    NSExpression(forConstantValue: ["restaurant", "grocery_store"]): NSExpression(forConstantValue: UIColor.red),
                    // If value is "park" return green color.
                    NSExpression(forConstantValue: "park"): NSExpression(forConstantValue: UIColor.green)
                ],
                // Specify a default value to return if no match is found.
                default: NSExpression(forConstantValue: UIColor.black)
            )
        )
    ]
)

Sammansejningsuttryck

Ett sammansejsningsuttryck stegar genom en uppsättning uttryck tills det första värdet som inte är null hämtas och returnerar det värdet.

Exempel på sammansejsningsuttryck

I följande exempel används ett sammanslåst uttryck för att ange textField alternativet för ett symbolskikt. Om egenskapen title saknas i funktionen eller är inställd på nilsöker uttrycket efter egenskapen, om den subTitle saknas eller nilreturnerar den en tom sträng.

let layer = SymbolLayer(
    source: source,
    options: [
        .textField(
            from: NSExpression(forAZMFunctionCoalesce: [
                // Try getting the title property.
                NSExpression(forKeyPath: "title"),

                // If there is no title, try getting the subTitle.
                NSExpression(forKeyPath: "subTitle"),

                // Default to an empty string.
                NSExpression(forConstantValue: "")
            ])
        )
    ]
)

Kopplingsuttryck

Sammanfogar flera strängar. Varje värde måste vara en sträng eller ett tal.

Exempel på kopplingsuttryck

I följande exempel kopplas temperature egenskapen för punktfunktionen och "°F".

let layer = SymbolLayer(
    source: source,
    options: [
        .textField(
            from: NSExpression(forAZMFunctionJoin: [
                NSExpression(forKeyPath: "temperature"),
                NSExpression(forConstantValue: "°F")
            ])
        ),

        // Some additional style options.
        .textOffset(CGVector(dx: 0, dy: -1.5)),
        .textSize(12),
        .textColor(.white)
    ]
)

Ovanstående uttryck renderar en pin-kod på kartan med texten "64°F" överlagrad ovanpå den som visas i följande bild.

Exempel på kopplingsuttryck

Interpolering och steguttryck

Interpolerings- och steguttryck kan användas för att beräkna värden längs en interpolerad kurva eller stegfunktion. Dessa uttryck tar in ett uttryck som returnerar ett tal som indata, till exempel NSExpression(forKeyPath: "temperature"). Indatavärdet utvärderas mot par med indata- och utdatavärden för att fastställa det värde som bäst passar den interpolerade kurvan eller stegfunktionen. Utdatavärdena kallas "stopp". Indatavärdena för varje stopp måste vara ett tal och vara i stigande ordning. Utdatavärdena måste vara ett tal, en matris med tal eller en färg.

Interpolationsuttryck

Ett interpolationsuttryck kan användas för att beräkna en kontinuerlig, smidig uppsättning värden genom att interpolera mellan stoppvärden.

Det finns tre typer av interpoleringsmetoder som kan användas i ett interpolationsuttryck:

Name	beskrivning	Parametrar
`ExpressionInterpolationMode.linear`	Interpolerar linjärt mellan stoppparet.	`nil`
`ExpressionInterpolationMode.exponential`	Interpolerar exponentiellt mellan stoppen. En bas anges och styr den hastighet med vilken utdata ökar. Högre värden gör att utdata ökar mer mot den övre änden av intervallet. Ett basvärde nära 1 ger en utdata som ökar linjärt.	Ett uttryck som utvärderas till ett tal och som anger basen för exponentiell interpolation.
`ExpressionInterpolationMode.cubicBezier`	Interpolerar med hjälp av en kubisk Bezier-kurva som definieras av de angivna kontrollpunkterna.	En matris eller ett aggregeringsuttryck som innehåller fyra uttryck, var och en utvärderar till ett tal. De fyra talen är kontrollpunkter för Bézier-kubikkurvan.

Här är ett exempel på hur dessa olika typer av interpolationer ser ut.

Linjär	Exponentiellt	Kubik bezier

Exempel på interpoleringsuttryck

I följande exempel används ett linjärt interpolationsuttryck för att ange bubbleColor egenskapen för ett bubbellager baserat på temperature egenskapen för punktfunktionen. Om värdet temperature är mindre än 60 returneras den blå färgen. Om den är mellan 60 och mindre än 70 returneras gult. Om det är mellan 70 och mindre än 80 returneras orange. Om den är 80 eller högre returneras rött.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                forAZMInterpolating: NSExpression(forKeyPath: "temperature"),
                curveType: .linear,
                parameters: nil,
                stops: NSExpression(forConstantValue: [
                    50: UIColor.blue,
                    60: UIColor.yellow,
                    70: UIColor.orange,
                    80: UIColor.red
                ])
            )
        )
    ]
)

Följande bild visar hur färgerna väljs för ovanstående uttryck.

Exempel på interpolera uttryck

Steguttryck

Ett steguttryck kan användas för att beräkna diskreta, stegvisa resultatvärden genom att utvärdera en bitvis konstant funktion som definieras av stopp.

Steguttryck returnerar utdatavärdet för stoppet precis före indatavärdet, eller från-värdet om indata är mindre än det första stoppet.

Exempel på steguttryck

I följande exempel används ett steguttryck för att ange bubbleColor egenskapen för ett bubbellager baserat på temperature egenskapen för punktfunktionen. Om värdet temperature är mindre än 60 returneras blått. Om den är mellan 60 och mindre än 70 returneras gult. Om det är mellan 70 och mindre än 80 returneras orange. Om den är 80 eller högre returneras rött.

let layer = BubbleLayer(
    source: source,
    options: [
        .bubbleColor(
            from: NSExpression(
                forAZMStepping: NSExpression(forKeyPath: "temperature"),
                from: NSExpression(forConstantValue: UIColor.blue),
                stops: NSExpression(forConstantValue: [
                    50: UIColor.blue,
                    60: UIColor.yellow,
                    70: UIColor.orange,
                    80: UIColor.red
                ])
            )
        )
    ]
)

Följande bild visar hur färgerna väljs för ovanstående uttryck.

Exempel på steguttryck

Ytterligare information

Läs mer om de lager som stöder uttryck:

Dela via

Datadrivna formatuttryck i iOS SDK (förhandsversion)

Använda predikat för att filtrera vektordata

Operatorer

Operander

Exempel på operander

Använda uttryck för att konfigurera lageralternativ

JSON-baserad

Konstanta värden

Exempel på konstantvärden

Nyckelsökvägar

Functions

Villkorssatser

Exempel på villkorsstyrda villkor

Aggregeringar

Variabler

Funktionsidentifierare

Funktionsegenskaper

Funktion ackumulerad

Geometrityp

Exempel på variabler

Zooma

Zooma exempel

HeatMap-densitet

Exempel på HeatMap-densitet

Radförlopp

Exempel på radförlopp

Azure Kartor-specifika metoder

Matcha uttryck

Exempel på matchningsuttryck

Sammansejningsuttryck

Exempel på sammansejsningsuttryck

Kopplingsuttryck

Exempel på kopplingsuttryck

Interpolering och steguttryck

Interpolationsuttryck

Exempel på interpoleringsuttryck

Steguttryck

Exempel på steguttryck

Ytterligare information

Feedback

Ytterligare resurser