Datadrivna formatuttryck (Android SDK)

Kommentar

Azure Kartor Android SDK-tillbakadragning

Azure Kartor Native SDK för Android ä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 Android SDK.

Med uttryck kan du använda affärslogik för formateringsalternativ som observerar de egenskaper som definierats i varje form i en datakälla. Uttryck kan filtrera data i en datakälla eller ett lager. Uttryck kan bestå av villkorsstyrd logik, till exempel if-statements. Och de kan användas för att manipulera data med hjälp av: strängoperatorer, logiska operatorer och matematiska operatorer.

Datadrivna format minskar mängden kod som behövs för att implementera affärslogik kring formatering. När de används med lager utvärderas uttryck vid återgivningen i en separat tråd. Den här funktionen ger bättre prestanda jämfört med att utvärdera affärslogik i användargränssnittstråden.

Azure Kartor Android SDK stöder nästan alla samma formatuttryck som Azure Kartor Web SDK, så alla samma begrepp som beskrivs i datadrivna stiluttryck (Web SDK) kan överföras till en Android-app. Alla formatuttryck i Azure Kartor Android SDK är tillgängliga under com.microsoft.azure.maps.mapcontrol.options.Expression namnområdet. Det finns många olika typer av formatuttryck.

Typ av uttryck	beskrivning
Booleska uttryck	Booleska uttryck ger en uppsättning booleska operatoruttryck för att utvärdera booleska jämförelser.
Färguttryck	Färguttryck gör det enklare att skapa och ändra färgvärden.
Villkorsstyrda uttryck	Villkorsuttryck tillhandahåller logikåtgärder som liknar if-statements.
Datauttryck	Ger åtkomst till egenskapsdata i en funktion.
Interpolera och steguttryck	Interpolera och steguttryck kan användas för att beräkna värden längs en interpolerad kurva eller stegfunktion.
JSON-baserade uttryck	Gör det enkelt att återanvända JSON-baserade formatmallsbaserade uttryck som skapats för Web SDK med Android SDK.
Lagerspecifika uttryck	Särskilda uttryck som endast gäller för ett enda lager.
Matematiska uttryck	Tillhandahåller matematiska operatorer för att utföra datadrivna beräkningar inom uttrycksramverket.
Strängoperatoruttryck	Strängoperatoruttryck utför konverteringsåtgärder på strängar som att sammanfoga och konvertera skiftläget.
Skriv uttryck	Typuttryck tillhandahåller verktyg för att testa och konvertera olika datatyper som strängar, tal och booleska värden.
Variabelbindningsuttryck	Variabelbindningsuttryck lagrar resultatet av en beräkning i en variabel och refereras någon annanstans i ett uttryck flera gånger utan att behöva beräkna om det lagrade värdet.
Zoomuttryck	Hämtar kartans aktuella zoomnivå vid återgivningstiden.

Kommentar

Syntaxen för uttryck är i stort sett identisk i Java och Kotlin. Om du har angett dokumentationen till Kotlin, men ser kodblock för Java, är koden identisk på båda språken.

Alla exempel i det här avsnittet i dokumentet använder följande funktion för att visa 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.
Feature feature = Feature.fromGeometry(Point.fromLngLat(-100, 45));

//Add properties to the feature.
feature.addNumberProperty("id", 123);
feature.addStringProperty("entityType", "restaurant");
feature.addNumberProperty("revenue", 12345);
feature.addStringProperty("subTitle", "Building 40");
feature.addNumberProperty("temperature", 64);
feature.addStringProperty("title", "Cafeteria");
feature.addStringProperty("zoneColor", "purple");

JsonArray abcArray = new JsonArray();
abcArray.add("a");
abcArray.add("b");
abcArray.add("c");

feature.addProperty("abcArray", abcArray);

JsonArray array1 = new JsonArray();
array1.add("a");
array1.add("b");

JsonArray array2 = new JsonArray();
array1.add("x");
array1.add("y");

JsonArray array2d = new JsonArray();
array2d.add(array1);
array2d.add(array2);

feature.addProperty("array2d", array2d);

JsonObject style = new JsonObject();
style.addProperty("fillColor", "red");

feature.addProperty("_style", style);

//Create a point feature.
val feature = Feature.fromGeometry(Point.fromLngLat(-100, 45))

//Add properties to the feature.
feature.addNumberProperty("id", 123)
feature.addStringProperty("entityType", "restaurant")
feature.addNumberProperty("revenue", 12345)
feature.addStringProperty("subTitle", "Building 40")
feature.addNumberProperty("temperature", 64)
feature.addStringProperty("title", "Cafeteria")
feature.addStringProperty("zoneColor", "purple")

val abcArray = JsonArray()
abcArray.add("a")
abcArray.add("b")
abcArray.add("c")

feature.addProperty("abcArray", abcArray)

val array1 = JsonArray()
array1.add("a")
array1.add("b")

val array2 = JsonArray()
array1.add("x")
array1.add("y")

val array2d = JsonArray()
array2d.add(array1)
array2d.add(array2)

feature.addProperty("array2d", array2d)

val style = JsonObject()
style.addProperty("fillColor", "red")

feature.addProperty("_style", style)

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

String 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\"}}}";

Feature feature = Feature.fromJson(featureString);

val 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\"}}}"

val feature = Feature.fromJson(featureString)

JSON-baserade uttryck

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 Expression klassen i Android SDK. Alternativt kan dessa JSON-baserade uttryck konverteras till en sträng med hjälp av en webbfunktion som JSON.stringify och skickas till Expression.raw(String rawExpression) metoden. Ta till exempel följande JSON-uttryck.

var exp = ['get','title'];
JSON.stringify(exp); // = "['get','title']"

Den strängifierade versionen av uttrycket ovan skulle vara "['get','title']" och kan läsas in i Android SDK på följande sätt.

Expression exp = Expression.raw("['get','title']")

val exp = Expression.raw("['get','title']")

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.

Datauttryck

Datauttryck ger åtkomst till egenskapsdata i en funktion.

Uttryck	Returtyp	beskrivning
accumulated()	Nummer	Hämtar värdet för en klusteregenskap som ackumulerats hittills. Detta kan bara användas i clusterProperties alternativet för en klustrad DataSource källa.
at(number | Expression, Expression)	värde	Hämtar ett objekt från en matris.
geometryType()	sträng	Hämtar funktionens geometrityp: Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon.
get(string | Expression) | get(string | Expression, Expression)	värde	Hämtar egenskapsvärdet från egenskaperna för det angivna objektet. Returnerar null om den begärda egenskapen saknas.
has(string | Expression) | has(string | Expression, Expression)	boolean	Avgör om egenskaperna för en funktion har den angivna egenskapen.
id()	värde	Hämtar funktionens ID om den har ett.
in(string | number | Expression, Expression)	boolean	Avgör om ett objekt finns i en matris
length(string | Expression)	Nummer	Hämtar längden på en sträng eller en matris.
properties()	värde	Hämtar objektet för funktionsegenskaper.

Följande Web SDK-formatuttryck stöds inte i Android SDK:

• index-of
• sektor

Exempel

Egenskaper för en funktion kan nås direkt i ett uttryck med hjälp av ett get uttryck. I det zoneColor här exemplet används värdet för funktionen för att ange färgegenskapen för ett bubbellager.

BubbleLayer layer = new BubbleLayer(source,
    //Get the zoneColor value.
    bubbleColor(get("zoneColor"))
);

val layer = BubbleLayer(source,
    //Get the zoneColor value.
    bubbleColor(get("zoneColor"))
)

Exemplet ovan fungerar bra om alla punktfunktioner har egenskapen zoneColor . Om de inte gör det kommer färgen sannolikt att falla tillbaka till "svart". Om du vill ändra återställningsfärgen använder du ett switchCase uttryck i kombination med has uttrycket för att kontrollera om egenskapen finns. Om egenskapen inte finns returnerar du en reservfärg.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        //Use a conditional case expression.
        switchCase(
            //Check to see if feature has a "zoneColor" 
            has("zoneColor"), 

            //If it does, use it.
            get("zoneColor"), 

            //If it doesn't, default to blue.
            literal("blue")
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        //Use a conditional case expression.
        switchCase(
            //Check to see if feature has a "zoneColor" 
            has("zoneColor"), 

            //If it does, use it.
            get("zoneColor"), 

            //If it doesn't, default to blue.
            literal("blue")
        )
    )
)

Bubbel- och symbolskikt återger som standard koordinaterna för alla former 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 av ett geometryType uttryck i ett booleskt uttryck. I följande exempel begränsas ett bubbellager så att endast Point funktioner återges.

BubbleLayer layer = new BubbleLayer(source,
    filter(eq(geometryType(), "Point"))
);

val layer = BubbleLayer(source,
    filter(eq(geometryType(), "Point"))
)

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

BubbleLayer layer = new BubbleLayer(source,
    filter(any(eq(geometryType(), "Point"), eq(geometryType(), "MultiPoint")))
);

val layer = BubbleLayer(source,
    filter(any(eq(geometryType(), "Point"), eq(geometryType(), "MultiPoint")))
)

På samma sätt återges konturen av Polygoner i linjeskikt. Om du vill inaktivera det här beteendet i ett linjeskikt lägger du till ett filter som endast tillåter LineString och MultiLineString funktioner.

Här är fler exempel på hur du använder datauttryck:

//Get item [2] from an array "properties.abcArray[1]" = "c"
at(2, get("abcArray"))

//Get item [0][1] from a 2D array "properties.array2d[0][1]" = "b"
at(1, at(0, get("array2d")))

//Check to see if a value is in an array "properties.abcArray.indexOf('a') !== -1" = true
in("a", get("abcArray"))

//Get the length of an array "properties.abcArray.length" = 3
length(get("abcArray"))

//Get the value of a subproperty "properties._style.fillColor" = "red"
get("fillColor", get("_style"))

//Check that "fillColor" exists as a subproperty of "_style".
has("fillColor", get("_style"))

Matematiska uttryck

Matematiska uttryck tillhandahåller matematiska operatorer för att utföra datadrivna beräkningar inom uttrycksramverket.

Uttryck	Returtyp	beskrivning
abs(number | Expression)	Nummer	Beräknar det absoluta värdet för det angivna talet.
acos(number | Expression)	Nummer	Beräknar arccosinus för det angivna talet.
asin(number | Expression)	Nummer	Beräknar arcsinus för det angivna talet.
atan(number | Expression)	Nummer	Beräknar arctangensen för det angivna talet.
ceil(number | Expression)	Nummer	Avrundar talet upp till nästa heltal.
cos(number | Expression)	Nummer	Beräknar cos för det angivna talet.
division(number, number) | division(Expression, Expression)	Nummer	Dividerar det första talet med det andra talet. Motsvarande uttryck för Web SDK: /
e()	Nummer	Returnerar den matematiska konstanten e.
floor(number | Expression)	Nummer	Avrundar talet nedåt till föregående heltal.
log10(number | Expression)	Nummer	Beräknar bas-tio logaritmen för det angivna talet.
log2(number | Expression)	Nummer	Beräknar bas-två logaritmen för det angivna talet.
ln(number | Expression)	Nummer	Beräknar den naturliga logaritmen för det angivna talet.
ln2()	Nummer	Returnerar den matematiska konstanten ln(2).
max(numbers... | expressions...)	Nummer	Beräknar det maximala talet i den angivna uppsättningen tal.
min(numbers... | expressions...)	Nummer	Beräknar det minsta talet i den angivna uppsättningen tal.
mod(number, number) | mod(Expression, Expression)	Nummer	Beräknar resten när det första talet divideras med det andra talet. Motsvarande uttryck för Web SDK: %
pi()	Nummer	Returnerar den matematiska konstanten PI.
pow(number, number) | pow(Expression, Expression)	Nummer	Beräknar värdet för det första värdet som höjs till kraften i det andra talet.
product(numbers... | expressions...)	Nummer	Multiplicerar de angivna talen tillsammans. Motsvarande uttryck för Web SDK: *
round(number | Expression)	Nummer	Avrundar talet till närmaste heltal. Halvvägsvärden avrundas bort från noll. Utvärderas till exempel round(-1.5) till -2.
sin(number | Expression)	Nummer	Beräknar sinus för det angivna talet.
sqrt(number | Expression)	Nummer	Beräknar kvadratroten för det angivna talet.
subtract(number | Expression	Nummer	Subtraherar 0 med det angivna talet.
subtract(number | Expression, number | Expression)	Nummer	Subtraherar de första talen med det andra talet.
sum(numbers... | expressions...)	Nummer	Beräknar summan av de angivna talen.
tan(number | Expression)	Nummer	Beräknar tangensen för det angivna talet.

Booleska uttryck

Booleska uttryck ger en uppsättning booleska operatoruttryck för att utvärdera booleska jämförelser.

När du jämför värden skrivs jämförelsen strikt. Värden av olika typer anses alltid vara ojämlika. Fall där typerna är kända för att vara olika vid parsningstillfället anses vara ogiltiga och ger upphov till ett parsfel.

Uttryck	Returtyp	beskrivning
all(Expression...)	boolean	Returnerar true om alla indata är true, false annars.
any(Expression...)	boolean	Returnerar true om någon av indata är true, false annars.
eq(Expression compareOne, Expression | boolean | number | string compareTwo) | eq(Expression compareOne, Expression | string compareTwo, Expression collator)	boolean	Returnerar true om indatavärdena är lika, false annars. Argumenten måste vara antingen båda strängarna eller båda talen.
gt(Expression compareOne, Expression | boolean | number | string compareTwo) | gt(Expression compareOne, Expression | string compareTwo, Expression collator)	boolean	Returnerar true om den första indatan är strikt större än den andra, false annars. Argumenten måste vara antingen båda strängarna eller båda talen.
gte(Expression compareOne, Expression | boolean | number | string compareTwo) | gte(Expression compareOne, Expression | string compareTwo, Expression collator)	boolean	Returnerar true om den första indatan är större än eller lika med den andra, false annars. Argumenten måste vara antingen båda strängarna eller båda talen.
lt(Expression compareOne, Expression | boolean | number | string compareTwo) | lt(Expression compareOne, Expression | string compareTwo, Expression collator)	boolean	Returnerar true om den första indatan är strikt mindre än den andra, false annars. Argumenten måste vara antingen båda strängarna eller båda talen.
lte(Expression compareOne, Expression | boolean | number | string compareTwo) | lte(Expression compareOne, Expression | string compareTwo, Expression collator)	boolean	Returnerar true om den första indatan är mindre än eller lika med den andra, false annars. Argumenten måste vara antingen båda strängarna eller båda talen.
neq(Expression compareOne, Expression | boolean | number | string compareTwo) | neq(Expression compareOne, Expression | string compareTwo, Expression collator)	boolean	Returnerar true om indatavärdena inte är lika med, false annars.
not(Expression | boolean)	boolean	Logisk negation. Returnerar true om indata är false, och false om indata är true.

Villkorliga uttryck

Villkorsuttryck tillhandahåller logikåtgärder som liknar if-statements.

Följande uttryck utför villkorsstyrda logikåtgärder på indata. Uttrycket tillhandahåller till exempel switchCase "if/then/else"-logik medan match uttrycket är som en "switch-statement".

Växla skiftlägesuttryck

Ett switchCase uttryck är en typ av villkorsuttryck som tillhandahåller logiken "if/then/else". Den här typen av uttryck går igenom en lista över booleska villkor. Det returnerar utdatavärdet för det första booleska villkoret som ska utvärderas till sant.

Följande pseudokod definierar uttryckets switchCase struktur.

switchCase(
    condition1: boolean expression, 
    output1: value,
    condition2: boolean expression, 
    output2: value,
    ...,
    fallback: value
)

Exempel

I följande exempel går vi igenom olika booleska villkor tills det hittar ett som utvärderas till trueoch returnerar sedan det associerade värdet. Om inget booleskt villkor utvärderas till truereturneras ett återställningsvärde.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        switchCase(
            //Check to see if the first boolean expression is true, and if it is, return its assigned result.
            //If it has a zoneColor property, use its value as a color.
            has("zoneColor"), toColor(get("zoneColor")),

            //Check to see if the second boolean expression is true, and if it is, return its assigned result.
            //If it has a temperature property with a value greater than or equal to 100, make it red.
            all(has("temperature"), gte(get("temperature"), 100)), color(Color.RED),

            //Specify a default value to return. In this case green.
            color(Color.GREEN)
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        switchCase(
            //Check to see if the first boolean expression is true, and if it is, return its assigned result.
            //If it has a zoneColor property, use its value as a color.
            has("zoneColor"), toColor(get("zoneColor")),

            //Check to see if the second boolean expression is true, and if it is, return its assigned result.
            //If it has a temperature property with a value greater than or equal to 100, make it red.
            all(has("temperature"), gte(get("temperature"), 100)), color(Color.RED),

            //Specify a default value to return. In this case green.
            color(Color.GREEN)
        )
    )
)

Matcha uttryck

Ett match uttryck är en typ av villkorsuttryck som tillhandahåller switch-statement som logik. Indata kan vara valfritt uttryck som get( "entityType") returnerar en sträng eller ett tal. Varje stopp måste ha en etikett som antingen är ett enda literalvärde eller en matris med literalvärden, vars värden måste vara alla strängar eller alla tal. Indata matchar om något av värdena i matrisen matchar. Varje stoppetikett måste vara unik. Om indatatypen inte matchar typen av etiketter är resultatet standardåterställningsvärdet.

Följande pseudokod definierar uttryckets match struktur.

match(Expression input, Expression defaultOutput, Expression.Stop... stops)

Exempel

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.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" return "red".
            stop("restaurant", color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" return "red".
            stop("restaurant", color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
)

I följande exempel används en matris för att visa en uppsättning etiketter som alla ska returnera samma värde. Den här metoden är mycket effektivare än att lista varje etikett individuellt. I det här fallet returneras färgen "röd" om egenskapen entityType är "restaurang" eller "grocery_store".

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" or "grocery_store" return "red".
            stop(Arrays.asList("restaurant", "grocery_store"), color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        match(
            //Get the input value to match.
            get("entityType"),

            //Specify a default value to return if no match is found.
            color(Color.BLACK),

            //List the values to match and the result to return for each match.

            //If value is "restaurant" or "grocery_store" return "red".
            stop(arrayOf("restaurant", "grocery_store"), color(Color.RED)),

            //If value is "park" return "green".
            stop("park", color(Color.GREEN))
        )
    )
)

Sammansejningsuttryck

Ett coalesce uttryck går igenom en uppsättning uttryck tills det första värdet som inte är null hämtas och returnerar det värdet.

Följande pseudokod definierar uttryckets coalesce struktur.

coalesce(Expression... input)

Exempel

I följande exempel används ett coalesce uttryck för att ange textField alternativet för ett symbolskikt. Om egenskapen title saknas i funktionen eller är inställd nullpå försöker uttrycket leta efter egenskapen, om den subTitle saknas eller null, kommer den sedan att återgå till en tom sträng.

SymbolLayer layer = new SymbolLayer(source,
    textField(
        coalesce(
            //Try getting the title property.
            get("title"),

            //If there is no title, try getting the subTitle. 
            get("subTitle"),

            //Default to an empty string.
            literal("")
        )
    )
);

val layer = SymbolLayer(source,
    textField(
        coalesce(
            //Try getting the title property.
            get("title"),

            //If there is no title, try getting the subTitle. 
            get("subTitle"),

            //Default to an empty string.
            literal("")
        )
    )
)

Typuttryck

Typuttryck tillhandahåller verktyg för att testa och konvertera olika datatyper som strängar, tal och booleska värden.

Uttryck	Returtyp	beskrivning
array(Expression)	Object[]	Hävdar att indata är en matris.
bool(Expression)	boolean	Hävdar att indatavärdet är ett booleskt värde.
collator(boolean caseSensitive, boolean diacriticSensitive) | collator(boolean caseSensitive, boolean diacriticSensitive, java.util.Locale locale) | collator(Expression caseSensitive, Expression diacriticSensitive) | collator(Expression caseSensitive, Expression diacriticSensitive, Expression locale)	collator	Returnerar en sorterare för användning i språkberoende jämförelseåtgärder. De skiftlägeskänsliga och diakritiska-känsliga alternativen är som standard falska. Språkargumentet för nationella inställningar anger IETF-språktaggen för språkvarianten som ska användas. Om inget anges används standardspråket. Om det begärda språket inte är tillgängligt använder sorteraren ett systemdefinierat återställningsspråk. Använd löst språk för att testa resultatet av nationella återställningsbeteenden.
literal(boolean \| number \| string \| Object \| Object[])	booleskt | nummer | sträng | Objekt | Object[]	Returnerar en literalmatris eller ett objektvärde. Använd det här uttrycket för att förhindra att en matris eller ett objekt utvärderas som ett uttryck. Detta är nödvändigt när en matris eller ett objekt måste returneras av ett uttryck.
number(Expression)	Nummer	Anger att indatavärdet är ett tal.
object(Expression)	Objekt	Hävdar att indatavärdet är ett objekt.
string(Expression)	sträng	Anger att indatavärdet är en sträng.
toArray(Expression)	Object[]	Konverterar uttrycket till en JSON-objektmatris.
toBool(Expression)	boolean	Konverterar indatavärdet till ett booleskt värde.
toNumber(Expression)	Nummer	Konverterar indatavärdet till ett tal, om möjligt.
toString(Expression)	sträng	Konverterar indatavärdet till en sträng.
typeoOf(Expression)	sträng	Returnerar en sträng som beskriver typen av angivet värde.

Färguttryck

Färguttryck gör det enklare att skapa och ändra färgvärden.

Uttryck	Returtyp	beskrivning
color(int)	color	Konverterar ett färg heltalsvärde till ett färguttryck.
rgb(Expression red, Expression green, Expression blue) | rgb(number red, number green, number blue)	color	Skapar ett färgvärde från röda, gröna och blå komponenter som måste ligga mellan 0 och 255, och en alfakomponent i 1. Om någon komponent ligger utom räckhåll är uttrycket ett fel.
rgba(Expression red, Expression green, Expression blue, Expression alpha) | rgba(number red, number green, number blue, number alpha)	color	Skapar ett färgvärde från röda, gröna, blå komponenter som måste ligga mellan 0 och 255, och en alfakomponent inom ett intervall av 0 och 1. Om någon komponent ligger utom räckhåll är uttrycket ett fel.
toColor(Expression)	color	Konverterar indatavärdet till en färg.
toRgba(Expression)	color	Returnerar en matris med fyra element som innehåller indatafärgens röda, gröna, blå och alfakomponenter i den ordningen.

Exempel

I följande exempel skapas ett RGB-färgvärde som har ett rött värde på 255, och gröna och blå värden som beräknas genom att 2.5 multiplicera med värdet för temperature egenskapen. När temperaturen ändras ändras färgen till olika nyanser av rött.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            //Set red value to 255. Wrap with literal expression since using expressions for other values.
            literal(255f),    

            //Multiple the temperature by 2.5 and set the green value.
            product(literal(2.5f), get("temperature")), 

            //Multiple the temperature by 2.5 and set the blue value.
            product(literal(2.5f), get("temperature")) 
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            //Set red value to 255. Wrap with literal expression since using expressions for other values.
            literal(255f),    

            //Multiple the temperature by 2.5 and set the green value.
            product(literal(2.5f), get("temperature")), 

            //Multiple the temperature by 2.5 and set the blue value.
            product(literal(2.5f), get("temperature")) 
        )
    )
)

Om alla färgparametrar är tal behöver du inte omsluta literal dem med uttrycket. Till exempel:

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            255f,  //Set red value to 255.

            150f,  //Set green value to 150.

            0f     //Set blue value to 0.
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        //Create a RGB color value.
        rgb(
            255f,  //Set red value to 255.

            150f,  //Set green value to 150.

            0f     //Set blue value to 0.
        )
    )
)

Dricks

Strängfärgvärden kan konverteras till en färg med hjälp av android.graphics.Color.parseColor metoden . Följande konverterar en hexfärgsträng till ett färguttryck som kan användas med ett lager.

color(parseColor("#ff00ff"))

Strängoperatoruttryck

Strängoperatoruttryck utför konverteringsåtgärder på strängar som att sammanfoga och konvertera skiftläget.

Uttryck	Returtyp	beskrivning
concat(string...) | concat(Expression...)	sträng	Sammanfogar flera strängar. Varje värde måste vara en sträng. toString Använd typuttrycket för att konvertera andra värdetyper till strängar om det behövs.
downcase(string) | downcase(Expression)	sträng	Konverterar den angivna strängen till gemener.
isSupportedScript(string) | isSupportedScript(Expression)	boolean	Avgör om indatasträngen använder en teckenuppsättning som stöds av den aktuella teckensnittsstacken. Till exempel: isSupportedScript("ಗೌರವಾರ್ಥವಾಗಿ")
resolvedLocale(Expression collator)	sträng	Returnerar IETF-språktaggen för språkvarianten som används av den tillhandahållna sortatorn. Detta kan användas för att fastställa standardinställningen för systemet eller för att avgöra om ett begärt språk har lästs in.
upcase(string) | upcase(Expression)	sträng	Konverterar den angivna strängen till versaler.

Exempel

I följande exempel konverteras temperature egenskapen för punktfunktionen till en sträng och sammanfogar sedan "°F" till slutet av den.

SymbolLayer layer = new SymbolLayer(source,
    textField(
        concat(Expression.toString(get("temperature")), literal("°F"))
    ),

    //Some additional style options.
    textOffset(new Float[] { 0f, -1.5f }),
    textSize(12f),
    textColor("white")
);

val layer = SymbolLayer(source,
    textField(
        concat(Expression.toString(get("temperature")), literal("°F"))
    ),

    //Some additional style options.
    textOffset(new Float[] { 0f, -1.5f }),
    textSize(12f),
    textColor("white")
)

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

Interpolera och steguttryck

Interpolera 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 numeriskt värde som indata, till exempel get("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 och en matris med tal eller en färg.

Interpolera uttryck

Ett interpolate uttryck kan användas för att beräkna en kontinuerlig, smidig uppsättning värden genom att interpolera mellan stoppvärden. Ett interpolate uttryck som returnerar färgvärden ger en färgtoning där resultatvärden väljs från. Uttrycket interpolate har följande format:

//Stops consist of two expressions.
interpolate(Expression.Interpolator interpolation, Expression number, Expression... stops)

//Stop expression wraps two values.
interpolate(Expression.Interpolator interpolation, Expression number, Expression.Stop... stops)

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

Name	beskrivning
linear()	Interpolerar linjärt mellan stoppparet.
exponential(number) | exponential(Expression)	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.
cubicBezier(number x1, number y1, number x2, number y2) | cubicBezier(Expression x1, Expression y1, Expression x2, Expression y2)	Interpolerar med hjälp av en kubisk Bezier-kurva som definieras av de angivna kontrollpunkterna.

Uttrycket stop har formatet stop(stop, value).

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

Linjär	Exponentiellt	Kubik bezier

Exempel

I följande exempel används ett linear interpolate uttryck 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å". Om den är mellan 60 och mindre än 70 returneras gult. Om det är mellan 70 och mindre än 80 returneras "orange" (#FFA500). Om den är 80 eller högre returneras "röd".

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        interpolate(
            linear(),
            get("temperature"),
            stop(50, color(Color.BLUE)),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        interpolate(
            linear(),
            get("temperature"),
            stop(50, color(Color.BLUE)),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
)

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

Steguttryck

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

Uttrycket interpolate har följande format:

step(Expression input, Expression defaultOutput, Expression... stops)

step(Expression input, Expression defaultOutput, Expression.Stop... stops)

step(Expression input, number defaultOutput, Expression... stops)

step(Expression input, number defaultOutput, Expression.Stop... stops)

step(number input, Expression defaultOutput, Expression... stops)

step(number input, Expression defaultOutput, Expression.Stop... stops)

step(number input, number defaultOutput, Expression... stops)

step(number input, number defaultOutput, Expression.Stop... stops)

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

Exempel

I följande exempel används ett step uttryck 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å". Om den är mellan 60 och mindre än 70 returneras "gul". Om det är mellan 70 och mindre än 80 returneras "orange". Om den är 80 eller högre returneras "röd".

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(
        step(
            get("temperature"),
            color(Color.BLUE),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(
        step(
            get("temperature"),
            color(Color.BLUE),
            stop(60, color(Color.YELLOW)),
            stop(70, color(parseColor("#FFA500"))),
            stop(80, color(Color.RED))
        )
    )
)

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

Lagerspecifika uttryck

Särskilda uttryck som endast gäller för specifika lager.

Uttryck för värmekartadensitet

Ett uttryck för värmekartans densitet hämtar värdet för värmekartans densitet för varje pixel i ett termisk kartskikt och definieras som heatmapDensity. Det här värdet är 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. Det här uttrycket kan bara användas i heatmapColor alternativet för termisk kartskikt.

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

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

HeatMapLayer layer = new HeatMapLayer(source,
    heatmapColor(
        interpolate(
            linear(),
            heatmapDensity(),
            stop(0, color(Color.TRANSPARENT)),
            stop(0.01, color(Color.MAGENTA)),
            stop(0.5, color(parseColor("#fb00fb"))),
            stop(1, color(parseColor("#00c3ff")))
        )
    )
);

val layer = HeatMapLayer(source,
    heatmapColor(
        interpolate(
            linear(),
            heatmapDensity(),
            stop(0, color(Color.TRANSPARENT)),
            stop(0.01, color(Color.MAGENTA)),
            stop(0.5, color(parseColor("#fb00fb"))),
            stop(1, color(parseColor("#00c3ff")))
        )
    )
)

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 step uttryck. Om du använder ett step uttryck för att färglägga värmekartan bryts densiteten visuellt upp i områden som liknar en kontur- eller radarkarta.

HeatMapLayer layer = new HeatMapLayer(source,
    heatmapColor(
        step(
            heatmapDensity(),
            color(Color.TRANSPARENT),
            stop(0.01, color(parseColor("#000080"))),
            stop(0.25, color(parseColor("#000080"))),
            stop(0.5, color(Color.GREEN)),
            stop(0.5, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
);

val layer = HeatMapLayer(source,
    heatmapColor(
        step(
            heatmapDensity(),
            color(Color.TRANSPARENT),
            stop(0.01, color(parseColor("#000080"))),
            stop(0.25, color(parseColor("#000080"))),
            stop(0.5, color(Color.GREEN)),
            stop(0.5, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
)

Mer information finns i dokumentationen Lägg till en termisk karta.

Linjeförloppsuttryck

Ett linjeförloppsuttryck hämtar förloppet längs en toningslinje i ett linjeskikt och definieras som lineProgress(). Det här värdet är ett tal mellan 0 och 1. Den används i kombination med ett interpolation eller step ett uttryck. Det här uttrycket kan bara användas med strokeGradient alternativet för linjeskiktet.

Kommentar

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

Exempel

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

LineLayer layer = new LineLayer(source,
    strokeGradient(
        interpolate(
            linear(),
            lineProgress(),
            stop(0, color(Color.BLUE)),
            stop(0.1, color(Color.argb(255, 65, 105, 225))), //Royal Blue
            stop(0.3, color(Color.CYAN)),
            stop(0.5, color(Color.argb(255,0, 255, 0))), //Lime
            stop(0.7, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
);

val layer = LineLayer(source,
    strokeGradient(
        interpolate(
            linear(),
            lineProgress(),
            stop(0, color(Color.BLUE)),
            stop(0.1, color(Color.argb(255, 65, 105, 225))), //Royal Blue
            stop(0.3, color(Color.CYAN)),
            stop(0.5, color(Color.argb(255,0, 255, 0))), //Lime
            stop(0.7, color(Color.YELLOW)),
            stop(1, color(Color.RED))
        )
    )
)

Se liveexempel

Textfältformatuttryck

Uttrycket format kan användas med textField alternativet för symbolskiktet för att ge blandad textformatering. Det här uttrycket tar in ett eller flera formatEntry uttryck som anger en sträng och uppsättning formatOptions som ska läggas till i textfältet.

Uttryck	beskrivning
format(Expression...)	Returnerar formaterad text som innehåller anteckningar för användning i textfältsposter i blandat format.
formatEntry(Expression text) | formatEntry(Expression text, Expression.FormatOption... formatOptions) | formatEntry(String text) | formatEntry(String text, Expression.FormatOption... formatOptions)	Returnerar en formaterad strängpost för användning i uttrycket format .

Följande formatalternativ är:

Uttryck	beskrivning
formatFontScale(number) | formatFontScale(Expression)	Anger skalningsfaktorn för teckenstorleken. Om det här värdet anges åsidosätter det textSize egenskapen för den enskilda strängen.
formatTextFont(string[]) | formatTextFont(Expression)	Anger en färg som ska tillämpas på en text vid återgivning.

Exempel

Följande exempel formaterar textfältet genom att lägga till ett fetstilt teckensnitt och skala upp teckenstorleken för title egenskapen för funktionen. Det här exemplet lägger också till subTitle egenskapen för funktionen på en ny rad, med en nedskalad teckenstorlek.

SymbolLayer layer = new SymbolLayer(source,
    textField(
        format(
            //Bold the title property and scale its font size up.
            formatEntry(
                get("title"),
                formatTextFont(new String[] { "StandardFont-Bold" }),
                formatFontScale(1.25)),

            //Add a new line without any formatting.
            formatEntry("\n"),

            //Scale the font size down of the subTitle property.
            formatEntry(
                get("subTitle"),
                formatFontScale(0.75))
        )
    )
);

val layer = SymbolLayer(source,
    textField(
        format(
            //Bold the title property and scale its font size up.
            formatEntry(
                get("title"),
                formatTextFont(arrayOf("StandardFont-Bold")),
                formatFontScale(1.25)),

            //Add a new line without any formatting.
            formatEntry("\n"),

            //Scale the font size down of the subTitle property.
            formatEntry(
                get("subTitle"),
                formatFontScale(0.75))
        )
    )
)

Det här lagret återger punktfunktionen enligt följande bild:

Zoomuttryck

Ett zoom uttryck används för att hämta kartans aktuella zoomnivå vid återgivningstiden och definieras som zoom(). Det här uttrycket returnerar ett tal mellan kartans minsta och högsta zoomnivåintervall. Azure Kartor interaktiva kartkontroller för webben och Android stöder 25 zoomnivåer, numrerade 0 till och med 24. Med uttrycket zoom kan format ändras dynamiskt när kartans zoomnivå ändras. Uttrycket zoom får endast användas med interpolate och step uttryck.

Exempel

Som standard har radien av datapunkter som återges i värmekartans lager en fast pixelradie 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 bildpunkter lodrätt och vågrätt som föregående zoomnivå. 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 åstadkommas med uttrycket zoom med ett base 2 exponential interpolation uttryck, med pixelradien inställd för den minsta zoomnivån och en skalad radie för den maximala zoomnivå som beräknas enligt 2 * Math.pow(2, minZoom - maxZoom) nedan.

HeatMapLayer layer = new HeatMapLayer(source,
    heatmapRadius(
        interpolate(
            exponential(2),
            zoom(),

            //For zoom level 1 set the radius to 2 pixels.
            stop(1, 2),

            //Between zoom level 1 and 19, exponentially scale the radius from 2 pixels to 2 * (maxZoom - minZoom)^2 pixels.
            stop(19, 2 * Math.pow(2, 19 - 1))
        )
    )
);

val layer = HeatMapLayer(source,
    heatmapRadius(
        interpolate(
            exponential(2),
            zoom(),

            //For zoom level 1 set the radius to 2 pixels.
            stop(1, 2),

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

Variabelbindningsuttryck

Variabelbindningsuttryck lagrar resultatet av en beräkning i en variabel. Så att beräkningsresultaten kan refereras någon annanstans i ett uttryck flera gånger. Det är en användbar optimering för uttryck som omfattar många beräkningar.

Uttryck	Returtyp	beskrivning
let(Expression... input)		Lagrar ett eller flera värden som variabler för användning av var uttrycket i det underordnade uttrycket som returnerar resultatet.
var(Expression expression) | var(string variableName)	Objekt	Refererar till en variabel som skapades med uttrycket let .

Exempel

I det här exemplet används ett uttryck som beräknar intäkten i förhållande till temperaturförhållandet och sedan använder ett case uttryck för att utvärdera olika booleska åtgärder för det här värdet. Uttrycket let används för att lagra intäkter i förhållande till temperaturförhållandet, så att det bara behöver beräknas en gång. Uttrycket var refererar till den här variabeln så ofta som det behövs utan att behöva beräkna om den.

BubbleLayer layer = new BubbleLayer(source,
    bubbleColor(           
        let(
            //Divide the point features `revenue` property by the `temperature` property and store it in a variable called `ratio`.
            literal("ratio"), division(get("revenue"), get("temperature")),

            //Evaluate the child expression in which the stored variable will be used.
            switchCase(
                //Check to see if the ratio is less than 100, return 'red'.
                lt(var("ratio"), 100), color(Color.RED),

                //Check to see if the ratio is less than 200, return 'green'.
                lt(var("ratio"), 200), color(Color.GREEN),

                //Return `blue` for values greater or equal to 200.
                color(Color.BLUE)
            )
        )
    )
);

val layer = BubbleLayer(source,
    bubbleColor(           
        let(
            //Divide the point features `revenue` property by the `temperature` property and store it in a variable called `ratio`.
            literal("ratio"), division(get("revenue"), get("temperature")),

            //Evaluate the child expression in which the stored variable will be used.
            switchCase(
                //Check to see if the ratio is less than 100, return 'red'.
                lt(var("ratio"), 100), color(Color.RED),

                //Check to see if the ratio is less than 200, return 'green'.
                lt(var("ratio"), 200), color(Color.GREEN),

                //Return `blue` for values greater or equal to 200.
                color(Color.BLUE)
            )
        )
    )
)

Nästa steg

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

Lägg till ett symbolskikt

Lägga till ett bubbellager

Lägga till ett linjeskikt

Lägga till ett polygonskikt

Lägga till en värmekarta