Datadrivna formatuttryck (Android SDK)
Kommentar
Azure Maps Android SDK-tillbakadragning
Azure Maps interna 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 Maps Web SDK senast 3/31/25. Mer information finns i Migreringsguiden för Azure Maps 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 Maps Android SDK stöder nästan alla samma stiluttryck som Azure Maps Web SDK, så alla samma begrepp som beskrivs i datadrivna formatuttryck (Web SDK) kan överföras till en Android-app. Alla formatuttryck i Azure Maps 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 Maps 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 Maps.
Den här videon ger en översikt över datadriven formatering i Azure Maps.
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))
)
)
)
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 Maps 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: