Datadrivna formatuttryck (Android SDK)

Med uttryck kan du tillämpa affärslogik på formatalternativ 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-instruktioner. De kan också 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 uttryck används med lager utvärderas de vid renderingstiden på en separat tråd. Den här funktionen ger bättre prestanda jämfört med utvärdering av affärslogik i UI-tråden.

Azure Kartor Android SDK stöder nästan samma formatuttryck som Azure Kartor Web SDK, så alla samma begrepp som beskrivs i datadrivna formatuttryck (Webb-SDK) kan föras över 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 Description
Booleska uttryck Booleska uttryck tillhandahåller en uppsättning booleska operatoruttryck för utvärdering av booleska jämförelser.
Färguttryck Färguttryck gör det enklare att skapa och ändra färgvärden.
Villkorliga uttryck Villkorsuttryck tillhandahåller logikåtgärder som är som if-instruktioner.
Datauttryck Ger åtkomst till egenskapsdata i en funktion.
Interpolera och stega uttryck Interpolerade uttryck 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 formatuttryck som skapats för Webb-SDK med Android SDK.
Skiktspecifika uttryck Specialuttryck 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, till exempel att sammanfoga och konvertera ärendet.
Typuttryck 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 till någon annanstans i ett uttryck flera gånger utan att behöva räkna om det lagrade värdet.
Zoomuttryck Hämtar den aktuella zoomningsnivån på kartan vid renderingstid.

Anteckning

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 av dokumentet använder följande funktion för att demonstrera olika sätt att använda dessa uttryck.

{
    "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 metoden Expression.raw(String rawExpression) . 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 Description
accumulated() antal 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 Anger 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) antal Hämtar längden på en sträng eller en matris.
properties() värde Hämtar egenskapsobjektet för funktionen.

Följande formatuttryck för Webb-SDK stöds inte i Android SDK:

  • index-of
  • Skiva

Exempel

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

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 zoneColor egenskapen . Om de inte gör det kommer färgen troligen att bli "svart". Om du vill ändra reservfärgen använder du switchCase ett uttryck i kombination med uttrycket för att kontrollera om egenskapen has 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 koordinaterna för alla former i en datakälla som standard. Det här beteendet kan markera hörnen för en polygon eller en linje. Skiktets alternativ kan användas för att begränsa geometritypen för de funktioner som återges med hjälp av ett uttryck filter geometryType i ett booleskt uttryck. I följande exempel begränsas ett bubbelskikt så att Point endast funktioner återges.

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

I följande exempel kan Point både MultiPoint - och -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 renderas konturen av Polygoner i radskikt. Om du vill inaktivera det här beteendet i ett linjeskikt lägger du till ett filter som endast LineString tillåter - och MultiLineString -funktioner.

Här följer några ytterligare 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 ger matematiska operatorer för att utföra datadrivna beräkningar inom uttrycksramverket.

Uttryck Returtyp Description
abs(number | Expression) antal Beräknar det absoluta värdet för det angivna talet.
acos(number | Expression) antal Beräknar arccosinus för det angivna talet.
asin(number | Expression) antal Beräknar arcsinus för det angivna talet.
atan(number | Expression) antal Beräknar arctangens för det angivna talet.
ceil(number | Expression) antal Avrundar talet uppåt till nästa heltal.
cos(number | Expression) antal Beräknar cos för det angivna talet.
division(number, number) | division(Expression, Expression) antal Dividerar det första talet med det andra talet. Likvärdigt uttryck för Webb-SDK: /
e() antal Returnerar den matematiska konstanten e .
floor(number | Expression) antal Avrundar talet nedåt till föregående heltal.
log10(number | Expression) antal Beräknar base-ten-logaritmen för det angivna talet.
log2(number | Expression) antal Beräknar den base-two-logaritmen för det angivna talet.
ln(number | Expression) antal Beräknar den naturliga logaritmen för det angivna talet.
ln2() antal Returnerar den matematiska konstanten ln(2) .
max(numbers... | expressions...) antal Beräknar det maximala antalet i den angivna uppsättningen tal.
min(numbers... | expressions...) antal Beräknar det minsta talet i den angivna uppsättningen tal.
mod(number, number) | mod(Expression, Expression) antal Beräknar resten när det första talet dividerar med det andra talet. Likvärdigt uttryck för Webb-SDK: %
pi() antal Returnerar den matematiska konstanten PI .
pow(number, number) | pow(Expression, Expression) antal Beräknar värdet för det första värdet upphöjt till det andra talets kraft.
product(numbers... | expressions...) antal Multiplicerar de angivna talen tillsammans. Likvärdigt uttryck för Webb-SDK: *
round(number | Expression) antal Avrundar talet till närmaste heltal. Halvvägs avrundas värdena bort från noll. Utvärderar till round(-1.5) exempel till -2 .
sin(number | Expression) antal Beräknar sinus för det angivna talet.
sqrt(number | Expression) antal Beräknar kvadratroten för det angivna talet.
subtract(number | Expression antal Subtraherar 0 med det angivna talet.
subtract(number | Expression, number | Expression) antal Subtraherar de första talen med det andra talet.
sum(numbers... | expressions...) antal Beräknar summan av de angivna talen.
tan(number | Expression) antal Beräknar tangensen för det angivna talet.

Booleska uttryck

Booleska uttryck tillhandahåller en uppsättning booleska operatoruttryck för utvärdering av booleska jämförelser.

När du jämför värden är jämförelsen strikt typad. Värden av olika typer anses alltid vara ojämna. Fall där typerna är kända för att vara olika vid parsningstid betraktas som ogiltiga och producerar ett parse-fel.

Uttryck Returtyp Description
all(Expression...) boolean Returnerar true om alla indata är , true false annars.
any(Expression...) boolean Returnerar true om något 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 indata ä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 indata ä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 indata ä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 indata ä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, false annars.
not(Expression | boolean) boolean Logisk negation. Returnerar true om indata false är och false om indata är true .

Villkorliga uttryck

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

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

Switch case-uttryck

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

Följande pseudokod definierar strukturen för switchCase uttrycket.

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 true och returnerar sedan det associerade värdet. Om inget booleskt villkor utvärderas true till returneras 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)
        )
    )
)

Matchningsuttryck

Ett match uttryck är en typ av villkorsuttryck som tillhandahåller switch-instruktion som logik. Indata kan vara ett uttryck som get( "entityType") som 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 blir resultatet standardvärdet för återställning.

Följande pseudokod definierar strukturen för match uttrycket.

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

Exempel

I följande exempel tittar på egenskapen entityType för en punktfunktion i ett bubbelskikt söker efter en matchning. Om den hittar en matchning returneras det angivna värdet, eller så returneras å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 lista en uppsättning etiketter som alla ska returnera samma värde. Den här metoden är mycket effektivare än att visa varje etikett individuellt. Om egenskapen i det här fallet är "restaurang" eller "grocery_store" returneras färgen entityType "röd".

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))
        )
    )
)

Coalesce-uttryck

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

Följande pseudokod definierar strukturen för coalesce uttrycket.

coalesce(Expression... input)

Exempel

I följande exempel används ett coalesce uttryck för att ange alternativet för ett textField symbolskikt. Om egenskapen saknas i funktionen eller är inställd på försöker uttrycket leta efter egenskapen. Om egenskapen saknas eller , kommer den sedan att gå tillbaka till title null en tom subTitle null 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 Description
array(Expression) Objekt[] Anger att indata är en matris.
bool(Expression) boolean Anger 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) sortering Returnerar en sortering för användning i språkberoende jämförelseåtgärder. De fallkänsliga och diakritiska känsliga alternativen är som standard false. Argumentet locale anger språktaggen IETF för de språk som ska användas. Om inget anges används standardspråket. Om de begärda språken inte är tillgängliga använder sorteringen ett systemdefinierat återställningsspråk. Använd resolved-locale för att testa resultatet av återställningsbeteendet för lokala språk.
literal(boolean \| number \| string \| Object \| Object[]) boolesk | | nummersträng | object | 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) antal Anger att indatavärdet är ett tal.
object(Expression) Objekt Anger att indatavärdet är ett -objekt.
string(Expression) sträng Anger att indatavärdet är en sträng.
toArray(Expression) Objekt[] Konverterar uttrycket till en JSON-objektmatris.
toBool(Expression) boolean Konverterar indatavärdet till ett booleskt värde.
toNumber(Expression) antal 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 det angivna värdets typ.

Färguttryck

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

Uttryck Returtyp Description
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 variera mellan 0 och och en 255 alfakomponent i 1 . Om någon komponent ligger utanför intervallet ä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 variera mellan 0 och och en 255 alfakomponent inom ett intervall av och 0 1 . Om någon komponent ligger utanför intervallet ä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 alfa-komponenter i den ordningen.

Exempel

I följande exempel skapas ett RGB-färgvärde som har det röda värdet , och gröna och blå värden som beräknas genom att multiplicera med värdet för egenskapen 255 2.5 temperature . 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 siffror behöver du inte omsluta dem med literal uttrycket . 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.
        )
    )
)

Tips

Strängfärgvärden kan konverteras till en färg med hjälp av android.graphics.Color.parseColor metoden . Följande konverterar en hexadexfä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, till exempel att sammanfoga och konvertera ärendet.

Uttryck Returtyp Description
concat(string...) | concat(Expression...) sträng Sammanfogar flera strängar. Varje värde måste vara en sträng. Använd toString typuttrycket för att konvertera andra värdetyper till sträng om det behövs.
downcase(string) | downcase(Expression) sträng Konverterar den angivna strängen till gemener.
isSupportedScript(string) | isSupportedScript(Expression) boolean Anger om indatasträngen använder en teckenuppsättning som stöds av den aktuella teckensnittsstacken. Exempelvis: isSupportedScript("ಗೌರವಾರ್ಥವಾಗಿ")
resolvedLocale(Expression collator) sträng Returnerar språktaggen IETF för det språk som används av den angivna sorteringen. Detta kan användas för att fastställa systemets standardspråk 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 punktfunktionens egenskap till en sträng och sammanfogar temperature 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")
)

Uttrycket ovan renderar en kartnål på kartan med texten "64°F" ovanpå, som du ser i bilden nedan.

Exempel på strängoperatoruttryck

<a name="interpolate-and-step-expressions">Interpolera och steguttryck

Interpolerade uttryck och steguttryck kan användas för att beräkna värden längs en interpolerad kurva eller stegfunktion. De här uttrycken tar ett uttryck som returnerar ett numeriskt värde som indata, till exempel get(&quot;temperature") . Indatavärdet utvärderas mot par av 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.

Interpolera uttryck

Ett interpolate uttryck kan användas för att beräkna en kontinuerlig, jämn uppsättning värden genom att interpolera mellan stoppvärden. Ett interpolate uttryck som returnerar färgvärden skapar 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 med vilken hastighet utdata ökar. Högre värden gör att utdata ökar mer mot den högre delen av intervallet. Ett "basvärde" nära 1 ger utdata som ökar mer 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 bezierkurva som definierats av de givna kontrollpunkterna.

Uttrycket stop har formatet stop(stop, value) .

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

Linjär Exponentiellt Cubic Bezier
Graf för linjär interpolering Diagram över exponentiell interpolering Graf för Bezier-interpolering

Exempel

I följande exempel används ett linear interpolate uttryck för att ange egenskapen för ett bubbleColor bubbelskikt baserat på temperature punktfunktionens egenskap. Om temperature värdet är mindre än 60 returneras "blå". Om det är mellan 60 och mindre än 70 returneras gult. Om det är mellan 70 och mindre än 80 returneras "orange" ( #FFA500 ). Om det ä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 uttrycket ovan.

Exempel på interpolerat uttryck

Steguttryck

Ett step uttryck kan användas för att beräkna diskreta stegvisa resultatvärden genom att utvärdera en funktion med en bitvis konstant 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 egenskapen för ett bubbleColor bubbelskikt baserat på temperature punktfunktionens egenskap. Om temperature värdet är mindre än 60 returneras "blå". Om det är mellan 60 och mindre än 70 returneras "gul". Om det är mellan 70 och mindre än 80 returneras "orange". Om det ä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 uttrycket ovan.

Exempel på steguttryck

Skiktspecifika uttryck

Specialuttryck som endast gäller för specifika lager.

Uttryck för densitet för heat map

Ett uttryck för densitet för en heat map hämtar densitetsvärdet för en heat map för varje pixel i ett heat map-lager och definieras som heatmapDensity . Det här värdet är ett tal mellan 0 och 1 . Den används i kombination med ett - eller interpolation step -uttryck för att definiera den färgtoning som används för att färglägga den värmekartan. Det här uttrycket kan bara användas i heatmapColor alternativet för det heat map-skiktet.

Tips

Färgen vid index 0, i ett interpolationsuttryck eller standardfärgen för en stegfärg, definierar färgen på området där det inte finns några data. Färgen vid 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 interpolationsuttryck för att skapa en jämn färgtoning för att återge den 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. Med hjälp av ett uttryck för färgläggning av den värmekartan delar den visuellt upp densiteten i intervall som liknar en step karta av klassiskt format eller radarformat.

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 Om att lägga till ett heat map-lager.

Linje förloppsuttryck

Ett linje fö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. Det används i kombination med ett interpolation - eller step -uttryck. Det här uttrycket kan bara användas strokeGradient med alternativet för linjeskiktet.

Anteckning

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

Exempel

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

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 live-exempel

Formatuttryck för textfält

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

Uttryck Beskrivning
format(Expression...) Returnerar formaterad text som innehåller anteckningar för användning i textfältposter 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 format uttrycket.

Följande formatalternativ är:

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

Exempel

I följande exempel formateras textfältet genom att lägga till ett fetstil och skala upp teckenstorleken för title egenskapen för funktionen. Det här exemplet lägger också subTitle till egenskapen för funktionen på en ny linje, med en nedskalade 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 bilden nedan:

Bild av punktfunktionen med formaterat textfält

Zoomuttryck

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

Exempel

Som standard har radi av datapunkter som återges i det heat map-lagret en fast pixelradie för alla zoomningsnivåer. När kartan zoomas aggregeras data och det heat map-lagret ser annorlunda ut. Ett uttryck kan användas för att skala radien för varje zoomningsnivå så att zoom varje datapunkt täcker samma fysiska område på kartan. Det gör att det heat map-lagret ser mer statiskt och konsekvent ut. Varje zoomningsnivå på kartan har dubbelt så många bildpunkter lodrätt och vågrätt som den föregående zoomningsnivån. Om radien skalas, så att den dubblas med varje zoomningsnivå, skapas en värmekarta som ser konsekvent ut på alla zoomnivåer. Det kan åstadkommas med hjälp av uttrycket med ett uttryck, med pixelradien inställd för den minsta zoomningsnivån och en skalad radie för den maximala zoomningsnivån beräknad enligt zoom base 2 exponential interpolation 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äkningsresultatet kan refereras till 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 Description
let(Expression... input) Lagrar ett eller flera värden som variabler för användning av uttrycket var i det underordnade uttryck som returnerar resultatet.
var(Expression expression) | var(string variableName) Objekt Refererar till en variabel som har skapats med let uttrycket .

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 uttryck för att utvärdera olika case booleska åtgärder för det här värdet. Uttrycket let används för att lagra intäkten 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 det behövs utan att behöva rä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: