Výrazy stylu řízené daty (Android SDK)

Výrazy umožňují použít obchodní logiku na možnosti stylů, které sledují vlastnosti definované v jednotlivých tvarech ve zdroji dat. Výrazy mohou filtrovat data ve zdroji dat nebo vrstvě. Výrazy se mohou skládat z podmíněné logiky, jako jsou příkazy if. A lze je použít k manipulaci s daty pomocí řetězcových operátorů, logických operátorů a matematických operátorů.

Styly řízené daty omezují množství kódu potřebného k implementaci obchodní logiky kolem stylů. Při použití s vrstvami se výrazy vyhodnocují v době vykreslení na samostatném vlákně. Tato funkce poskytuje vyšší výkon v porovnání s vyhodnocením obchodní logiky ve vlákně uživatelského rozhraní.

Azure Mapy Android SDK podporuje téměř všechny výrazy ve stylu jako sada Azure Mapy Web SDK, takže všechny stejné koncepty popsané v sadě Data-driven Style Expressions (Web SDK) je možné přenést do aplikace pro Android. Všechny výrazy stylu v azure Mapy Android SDK jsou k dispozici v rámci oboru com.microsoft.azure.maps.mapcontrol.options.Expression názvů . Existuje mnoho různých typů výrazů stylu.

Typ výrazů Description
Logické výrazy Logické výrazy poskytují sadu logických operátorů pro vyhodnocení logických porovnání.
Výrazy barev Výrazy barev usnadňují vytváření hodnot barev a manipulaci s nimi.
Podmíněné výrazy Podmíněné výrazy poskytují logické operace, které jsou jako příkazy if.
Výrazy dat Poskytuje přístup k datům vlastností ve funkci.
Interpolace a krokové výrazy Interpolační a krokové výrazy lze použít k výpočtu hodnot podél interpolované křivky nebo krokové funkce.
Výrazy založené na formátu JSON Umožňuje snadno opakovaně používat stylově nezpracované výrazy založené na json vytvořené pro webovou sadu SDK pomocí Android SDK.
Výrazy specifické pro vrstvu Speciální výrazy, které se vztahují pouze na jednu vrstvu.
Matematické výrazy Poskytuje matematické operátory pro provádění výpočtů řízených daty v rámci architektury výrazů.
Výrazy operátorů řetězců Výrazy operátorů řetězců provádějí operace převodu na řetězce, jako je zřetězování a převod případu.
Výrazy typu Výrazy typů poskytují nástroje pro testování a převod různých datových typů, jako jsou řetězce, čísla a logické hodnoty.
Výrazy vazeb proměnných Výrazy vazby proměnných ukládají výsledky výpočtu do proměnné a odkazují se vícekrát na jiné místo ve výrazu, aniž by se museli přepočítat uložená hodnota.
Výraz lupy Načte aktuální úroveň přiblížení mapy při vykreslování.

Poznámka

Syntaxe výrazů je v Javě a Kotlinu z velké části identická. Pokud máte dokumentaci nastavenou na Kotlin, ale podívejte se na bloky kódu pro Javu, je kód v obou jazycích stejný.

Všechny příklady v této části dokumentu používají následující funkci k předvedení různých způsobů použití těchto výrazů.

{
    "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"
        }
    }
}

Následující kód ukazuje, jak ručně vytvořit tuto funkci GeoJSON v aplikaci.

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

Následující kód ukazuje, jak deserializovat řetězcovou verzi objektu JSON do funkce GeoJSON v aplikaci.

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)

Výrazy založené na formátu JSON

Sada Azure Mapy Web SDK také podporuje výrazy stylu řízené daty, které jsou reprezentované pomocí pole JSON. Stejné výrazy lze znovu vytvořit pomocí nativní třídy Expression v Android SDK. Alternativně je možné tyto výrazy založené na json převést na řetězec pomocí webové funkce, jako je a předá JSON.stringify se do Expression.raw(String rawExpression) metody . Vezměte si například následující výraz JSON.

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

Řetězcová verze výše uvedeného výrazu by byla a lze ji načíst do "['get','title']" Android SDK následujícím způsobem.

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

Pomocí tohoto přístupu můžete snadno opakovaně používat výrazy stylu mezi mobilními a webovými aplikacemi, které používají Azure Mapy.

Toto video poskytuje přehled stylů řízených daty v Azure Mapy.


Výrazy dat

Datové výrazy poskytují přístup k datům vlastností ve funkci.

Výraz Návratový typ Description
accumulated() číslo Získá hodnotu vlastnosti clusteru kumulované doposud. Tuto možnost je možné použít clusterProperties pouze v případě clusterového DataSource zdroje.
at(number | Expression, Expression) hodnota Načte položku z pole.
geometryType() řetězec Získá typ geometrie prvku: Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon.
get(string | Expression) | get(string | Expression, Expression) hodnota Získá hodnotu vlastnosti z vlastností poskytnutého objektu. Pokud chybí požadovaná vlastnost, vrátí hodnotu null.
has(string | Expression) | has(string | Expression, Expression) boolean Určuje, zda vlastnosti funkce mají zadanou vlastnost.
id() hodnota Získá ID funkce, pokud ji má.
in(string | number | Expression, Expression) boolean Určuje, jestli položka existuje v poli.
length(string | Expression) číslo Získá délku řetězce nebo pole.
properties() hodnota Získá objekt vlastností funkce.

Následující výrazy stylu webové sady SDK nejsou podporovány v Android SDK:

  • index-of
  • Plátek

Příklady

Vlastnosti funkce jsou přístupné přímo ve výrazu pomocí get výrazu. Tento příklad používá hodnotu funkce k zoneColor určení vlastnosti barvy vrstvy bubliny.

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

Výše uvedený příklad bude fungovat správně, pokud mají všechny funkce bodu vlastnost zoneColor . Pokud ne, barva se pravděpodobně vrátí k "černé". Pokud chcete změnit záložní barvu, použijte výraz v kombinaci s výrazem a switchCase has zkontrolujte, jestli vlastnost existuje. Pokud vlastnost neexistuje, vraťte záložní barvu.

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

Vrstvy bublin a symbolů ve výchozím nastavení vykreslí souřadnice všech tvarů ve zdroji dat. Toto chování může zvýraznit vrcholy mnohoúhelníku nebo čáry. Pomocí možnosti vrstvy můžete omezit typ geometrie prvků, které vykresluje, pomocí filter geometryType výrazu v logickém výrazu. Následující příklad omezuje vrstvu bublin tak, aby Point se vykreslují jenom funkce.

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

Následující příklad umožňuje vykreslování funkcí i Point MultiPoint .

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

Podobně se obrys mnohoúhelníků vykreslí ve vrstvách čar. Pokud chcete toto chování ve vrstvě řádků zakázat, přidejte filtr, který povolí jenom funkce a LineString MultiLineString .

Tady je několik dalších příkladů použití datových výrazů:

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

Matematické výrazy

Matematické výrazy poskytují matematické operátory k provádění výpočtů řízených daty v rámci architektury výrazů.

Výraz Návratový typ Description
abs(number | Expression) číslo Vypočítá absolutní hodnotu zadaného čísla.
acos(number | Expression) číslo Vypočítá arkuscosinus zadaného čísla.
asin(number | Expression) číslo Vypočítá arkus sinus zadaného čísla.
atan(number | Expression) číslo Vypočítá arkus kotangens zadaného čísla.
ceil(number | Expression) číslo Zaokrouhlí číslo nahoru na další celé číslo.
cos(number | Expression) číslo Vypočítá cos zadaného čísla.
division(number, number) | division(Expression, Expression) číslo Vydělí první číslo druhým číslem. Ekvivalentní výraz webové sady SDK: /
e() číslo Vrátí matematickou konstantu e .
floor(number | Expression) číslo Zaokrouhlí číslo dolů na předchozí celé celé číslo.
log10(number | Expression) číslo Vypočítá logaritmus 10 základních hodnot zadaného čísla.
log2(number | Expression) číslo Vypočítá logaritmus se základem 2 zadaného čísla.
ln(number | Expression) číslo Vypočítá přirozený logaritmus zadaného čísla.
ln2() číslo Vrátí matematickou konstantu ln(2) .
max(numbers... | expressions...) číslo Vypočítá maximální počet v zadané sadě čísel.
min(numbers... | expressions...) číslo Vypočítá minimální číslo v zadané sadě čísel.
mod(number, number) | mod(Expression, Expression) číslo Zbytek vypočítá při vydělení prvního čísla druhým číslem. Ekvivalentní výraz webové sady SDK: %
pi() číslo Vrátí matematickou konstantu PI .
pow(number, number) | pow(Expression, Expression) číslo Vypočítá hodnotu první hodnoty uvolané mocnou druhého čísla.
product(numbers... | expressions...) číslo Vynásobí zadaná čísla dohromady. Ekvivalentní výraz webové sady SDK: *
round(number | Expression) číslo Zaokrouhlí číslo na nejbližší celé číslo. Hodnoty v polovině jsou zaokrouhleny od nuly. Například se round(-1.5) vyhodnotí jako -2 .
sin(number | Expression) číslo Vypočítá sinus zadaného čísla.
sqrt(number | Expression) číslo Vypočítá odmocninu zadaného čísla.
subtract(number | Expression číslo Odečte 0 zadaným číslem.
subtract(number | Expression, number | Expression) číslo Odečte první čísla druhým číslem.
sum(numbers... | expressions...) číslo Vypočítá součet zadaných čísel.
tan(number | Expression) číslo Vypočítá tangens zadaného čísla.

Logické výrazy

Logické výrazy poskytují sadu logických operátorů pro vyhodnocení logických porovnání.

Při porovnávání hodnot je porovnání striktně typované. Hodnoty různých typů se vždy považují za nerovné. Případy, kdy je známo, že se typy v době analýzy liší, jsou považovány za neplatné a dojde k chybě analýzy.

Výraz Návratový typ Description
all(Expression...) boolean Vrátí true hodnotu , pokud jsou všechny vstupy , jinak vrátí hodnotu true false .
any(Expression...) boolean Vrátí true hodnotu , pokud je některý ze vstupů , jinak vrátí hodnotu true false .
eq(Expression compareOne, Expression | boolean | number | string compareTwo) | eq(Expression compareOne, Expression | string compareTwo, Expression collator) boolean Vrátí true hodnotu , pokud jsou vstupní hodnoty stejné, jinak vrátí hodnotu false . Argumenty musí být buď oba řetězce, nebo obě čísla.
gt(Expression compareOne, Expression | boolean | number | string compareTwo) | gt(Expression compareOne, Expression | string compareTwo, Expression collator) boolean Vrátí true hodnotu , pokud je první vstup striktně větší než druhý, jinak vrátí hodnotu false . Argumenty musí být buď oba řetězce, nebo obě čísla.
gte(Expression compareOne, Expression | boolean | number | string compareTwo) | gte(Expression compareOne, Expression | string compareTwo, Expression collator) boolean Vrátí hodnotu , pokud je první vstup true větší než nebo roven false sekundě, jinak vrátí hodnotu . Argumenty musí být buď oba řetězce, nebo obě čísla.
lt(Expression compareOne, Expression | boolean | number | string compareTwo) | lt(Expression compareOne, Expression | string compareTwo, Expression collator) boolean Vrátí true hodnotu , pokud je první vstup striktně menší než druhý vstup, jinak vrátí hodnotu false . Argumenty musí být buď oba řetězce, nebo obě čísla.
lte(Expression compareOne, Expression | boolean | number | string compareTwo) | lte(Expression compareOne, Expression | string compareTwo, Expression collator) boolean Vrátí hodnotu , pokud je první vstup menší než nebo true roven false sekundě, jinak vrátí hodnotu . Argumenty musí být buď oba řetězce, nebo obě čísla.
neq(Expression compareOne, Expression | boolean | number | string compareTwo) | neq(Expression compareOne, Expression | string compareTwo, Expression collator) boolean Vrátí true hodnotu , pokud se vstupní hodnoty nerovnají, jinak vrátí hodnotu false .
not(Expression | boolean) boolean Logická negace. Vrátí true hodnotu , pokud je vstup , a pokud je vstup false false true .

Podmíněné výrazy

Podmíněné výrazy poskytují logické operace, které jsou jako příkazy if.

Následující výrazy provádějí podmíněné logické operace se vstupními daty. Výraz například poskytuje switchCase logiku "if/then/else", zatímco výraz je match jako "switch-statement".

Přepnutí výrazu případu

Výraz switchCase je typ podmíněného výrazu, který poskytuje logiku "if/then/else". Tento typ výrazu prochází seznam logických podmínek. Vrátí výstupní hodnotu první logické podmínky, která se vyhodnotí jako true.

Následující pseudokód definuje strukturu switchCase výrazu.

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

Příklad

Následující příklad provádí v rámci různých logických podmínek, dokud nenajde ten, který je vyhodnocen jako true a následně vrací přidruženou hodnotu. Pokud se vyhodnotí žádná logická podmínka true , vrátí se záložní hodnota.

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

Výraz shody

matchVýraz je typ podmíněného výrazu, který poskytuje příkaz typu Switch-Logic. Vstup může být libovolný výraz get( "entityType") , například, který vrátí řetězec nebo číslo. Každé zastavení musí mít popisek, který je buď hodnotou jediného literálu, nebo polem hodnot literálů, jejichž hodnoty musí být všechny řetězce nebo všechna čísla. Vstup se shoduje, pokud kterákoli z hodnot v poli odpovídá. Každé označení zastavení musí být jedinečné. Pokud typ vstupu neodpovídá typu popisků, bude výsledkem výchozí záložní hodnota.

Následující pseudokódu definuje strukturu match výrazu.

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

Příklady

Následující příklad prohlíží entityType vlastnost bodu v bublinové vrstvě vyhledává shodu. Pokud najde shodu, je vrácena zadaná hodnota nebo vrátí záložní hodnotu.

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

Následující příklad používá pole k vypsání sady popisků, které by měly vracet stejnou hodnotu. Tento přístup je mnohem efektivnější než uvedení každého popisku jednotlivě. V takovém případě, pokud entityType je vlastnost "restaurace" nebo "grocery_store", bude vrácena barva "Red".

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

Výraz COALESCE

coalesceKroky výrazu pomocí sady výrazů, dokud není získána první hodnota, která není null, a vrátí tuto hodnotu.

Následující pseudokódu definuje strukturu coalesce výrazu.

coalesce(Expression... input)

Příklad

Následující příklad používá coalesce výraz pro nastavení textField Možnosti pro vrstvu symbolů. Pokud title vlastnost ve funkci chybí nebo je nastavená na null , výraz se pak pokusí vyhledat subTitle vlastnost, pokud chybí, nebo se null vrátí do prázdného řetězce.

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

Výrazy typu

Výrazy typu poskytují nástroje pro testování a převod různých typů dat, jako jsou řetězce, čísla a logické hodnoty.

Výraz Návratový typ Description
array(Expression) Objekt [] Vyhodnotí, že vstup je pole.
bool(Expression) boolean Vyhodnotí, že vstupní hodnota je logická hodnota.
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 Vrátí komplet pro použití v operacích porovnání závislých na národním prostředí. Možnosti s rozlišením velkých a malých písmen a s diakritikou jsou výchozí na false. Argument locale určuje značku jazyka IETF národního prostředí, které se má použít. Pokud není zadáno, použije se výchozí národní prostředí. Pokud požadované národní prostředí není k dispozici, komplet bude používat základní národní prostředí definované systémem. K otestování výsledků nouzového chování národního prostředí použijte vyřešený-locale.
literal(boolean \| number \| string \| Object \| Object[]) datový | objekt řetězce logického čísla | | | [] Vrátí literálovou hodnotu pole nebo objektu. Tento výraz použijte k zabránění vyhodnocení pole nebo objektu jako výrazu. To je nezbytné, pokud musí být pole nebo objekt vráceny výrazem.
number(Expression) číslo Vyhodnotí, že vstupní hodnota je číslo.
object(Expression) Objekt Vyhodnotí, že vstupní hodnota je objekt.
string(Expression) řetězec Vyhodnotí, že vstupní hodnota je řetězec.
toArray(Expression) Objekt [] Převede výraz na pole objektu JSON.
toBool(Expression) boolean Převede vstupní hodnotu na logickou hodnotu.
toNumber(Expression) číslo Pokud je to možné, převede vstupní hodnotu na číslo.
toString(Expression) řetězec Převede vstupní hodnotu na řetězec.
typeoOf(Expression) řetězec Vrátí řetězec popisující typ dané hodnoty.

Výrazy barev

Výrazy s barvami usnadňují vytváření a manipulaci s hodnotami barev.

Výraz Návratový typ Description
color(int) color Převede celočíselnou hodnotu barvy na výraz barvy.
rgb(Expression red, Expression green, Expression blue) | rgb(number red, number green, number blue) color Vytvoří hodnotu barvy z červených, zelených a modrých komponent, které musí být v rozsahu mezi 0 a 255 a komponentou alfa 1 . Pokud je některá součást mimo rozsah, je výraz chybou.
rgba(Expression red, Expression green, Expression blue, Expression alpha) | rgba(number red, number green, number blue, number alpha) color Vytvoří hodnotu barvy z červené, zelené a modré komponenty, která musí být v rozsahu od do 0 255 a. alfa komponenta v rámci rozsahu 0 a 1 . Pokud je některá součást mimo rozsah, je výraz chybou.
toColor(Expression) color Převede vstupní hodnotu na barvu.
toRgba(Expression) color Vrátí pole se čtyřmi prvky obsahující červenou, zelenou, modrou a alfa komponentu vstupní barvy v tomto pořadí.

Příklad

Následující příklad vytvoří hodnotu barvy RGB s červenou hodnotou 255 a zelenou a modrou hodnotou, která je vypočítána vynásobením 2.5 hodnotou temperature Vlastnosti. Při změně teploty se barva změní na různé odstíny červené.

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

Pokud jsou všechny parametry barev čísla, není nutné je zabalit pomocí literal výrazu. Příklad:

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

Tip

Hodnoty barvy řetězce lze převést na barvu pomocí android.graphics.Color.parseColor metody. Následující převede hexadecimální řetězec barvy na barevný výraz, který lze použít s vrstvou.

color(parseColor("#ff00ff"))

Výrazy operátorů řetězce

Výrazy operátoru řetězce provádějí operace převodu na řetězcích, jako je zřetězení a převod případu.

Výraz Návratový typ Description
concat(string...) | concat(Expression...) řetězec Zřetězí více řetězců dohromady. Každá hodnota musí být řetězec. Použijte toString výraz Type pro převod ostatních typů hodnot na řetězec v případě potřeby.
downcase(string) | downcase(Expression) řetězec Převede zadaný řetězec na malá písmena.
isSupportedScript(string) | isSupportedScript(Expression) boolean Určuje, zda vstupní řetězec používá znakovou sadu podporovanou aktuálním zásobníkem písem. Příklad: isSupportedScript("ಗೌರವಾರ್ಥವಾಗಿ")
resolvedLocale(Expression collator) řetězec Vrátí značku jazyka IETF národního prostředí, které používá poskytnutý řadicí modul. Dá se použít k určení výchozího národního prostředí systému nebo k určení, jestli se požadované národní prostředí úspěšně načetlo.
upcase(string) | upcase(Expression) řetězec Převede zadaný řetězec na velká písmena.

Příklad

Následující příklad převede temperature vlastnost bodu na řetězec a poté zřetězí "°F" na konci.

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

Výše uvedený výraz vykreslí kód PIN na mapě s textem "64 °F", jak je znázorněno na obrázku níže.

Příklad výrazu řetězce operátoru

<a name="interpolate-and-step-expressions">Interpolovat a krokovat výrazy

Výrazy interpolování a Step lze použít k výpočtu hodnot podél interpolované křivky nebo funkce kroku. Tyto výrazy přebírají výraz, který jako vstup vrátí číselnou hodnotu, například get(&quot;temperature") . Vstupní hodnota je vyhodnocena proti dvojicím vstupních a výstupních hodnot, aby bylo možné určit hodnotu, která nejlépe odpovídá interpolované křivce nebo funkci kroku. Výstupní hodnoty se nazývají "zastaví". Vstupní hodnoty pro každou stopu musí být číslo ve vzestupném pořadí. Výstupní hodnoty musí být číslo, pole čísel nebo barva.

Výraz interpolování

interpolateVýraz lze použít k výpočtu souvislé a hladké sady hodnot interpolací mezi hodnotami zastavení. interpolateVýraz, který vrací hodnoty barvy, vytváří barevný přechod, ve kterém jsou hodnoty výsledků vybrány z. interpolateVýraz má následující formáty:

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

Existují tři typy metod interpolace, které lze použít ve interpolate výrazu:

Název Description
linear() Interpoluje linearitu mezi dvojicí zastávky.
exponential(number) | exponential(Expression) Interpoluje exponenciálně mezi zastávkami. Je určena "základní" a určuje rychlost, s jakou se výstup zvyšuje. Vyšší hodnoty zvyšují objem výstupu směrem k hornímu konci rozsahu. "Základní" hodnota blížící se 1 vytvoří výstup, který se zvýší lineárně.
cubicBezier(number x1, number y1, number x2, number y2) | cubicBezier(Expression x1, Expression y1, Expression x2, Expression y2) Interpoluje použití Bézierovy křivky krychle definované danými řídicími body.

stopVýraz má formát stop(stop, value) .

Tady je příklad toho, jak tyto různé typy interpolace vypadají.

Lineární Exponenciální Krychlová Bézierova krychle
Graf lineární interpolace Graf exponenciální interpolace Graf interpolace Bézierovy křivky krychle

Příklad

Následující příklad používá linear interpolate výraz pro nastavení bubbleColor vlastnosti bublinové vrstvy na základě temperature vlastnosti funkce Point. Pokud temperature je hodnota menší než 60, bude vrácena "modrá". Pokud je mezi 60 a menší než 70, vrátí se žlutá. Pokud je mezi 70 a menší než 80, vrátí se "oranžová" ( #FFA500 ). Pokud je 80 nebo větší, vrátí se "Red".

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

Následující obrázek ukazuje, jak jsou vybrány barvy pro výše uvedený výraz.

Příklad interpolování výrazu

Výraz kroku

stepVýraz lze použít pro výpočet diskrétních a nejovlivněných výsledných hodnot vyhodnocením funkce konstantní , která je definována funkcí zastavení.

interpolateVýraz má následující formáty:

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)

Výrazy kroku vracejí výstupní hodnotu ukončení těsně před vstupní hodnotou nebo první vstupní hodnotu, pokud je vstup menší než první zarážka.

Příklad

Následující příklad používá step výraz pro nastavení bubbleColor vlastnosti bublinové vrstvy na základě temperature vlastnosti funkce Point. Pokud temperature je hodnota menší než 60, bude vrácena "modrá". Pokud je mezi 60 a menší než 70, vrátí se "žlutá". Pokud je mezi 70 a menší než 80, bude vrácena "oranžová". Pokud je 80 nebo větší, vrátí se "Red".

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

Následující obrázek ukazuje, jak jsou vybrány barvy pro výše uvedený výraz.

Příklad výrazu kroku

Výrazy specifické pro vrstvu

Speciální výrazy, které se vztahují pouze na konkrétní vrstvy.

Výraz hustoty tepelné mapy

Výraz hustoty tepelné mapy načte hodnotu hustoty tepelné mapy pro každý pixel v vrstvě Heat mapy a je definován jako heatmapDensity . Tato hodnota je číslo mezi 0 a 1 . Používá se v kombinaci s interpolation step výrazem or k definování barevného přechodu, který slouží k zabarvovatí Heat mapy. Tento výraz lze použít pouze v heatmapColor Možnosti vrstvy Heat mapy.

Tip

Barva v indexu 0, ve výrazu interpolace nebo ve výchozí barvě barvy kroku, definuje barvu oblasti, kde nejsou žádná data. Barva na indexu 0 se dá použít k definování barvy pozadí. Mnoho preferuje nastavení této hodnoty na transparentní nebo částečně průhlednou černou.

Příklad

Tento příklad používá výraz interpolace linie k vytvoření hladkého barevného přechodu pro vykreslování Heat mapy.

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

Kromě použití hladkého přechodu na zabarvovat Heat mapy lze barvy zadat v rámci sady rozsahů pomocí step výrazu. Použití step výrazu pro Colorizing Heat mapy vizuálně rozdělí hustotu do rozsahů, které se podobají obrysu nebo rozvržení paprskového stylu.

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

Další informace najdete v dokumentaci k Přidání vrstvy Heat mapy .

Výraz průběhu řádku

Výraz průběhu řádku načítá průběh čáry přechodu v čárové vrstvě a je definován jako lineProgress() . Tato hodnota je číslo mezi 0 a 1. Používá se v kombinaci s interpolation step výrazem or. Tento výraz lze použít pouze s strokeGradient možností čáry vrstvy.

Poznámka

strokeGradientMožnost čáry spojnice vyžaduje lineMetrics možnost nastavení zdroje dat na hodnotu true .

Příklad

V tomto příkladu se používá lineProgress() výraz pro použití barevného přechodu na tah čáry.

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

Zobrazit příklad v reálném čase

Výraz formátu textového pole

formatVýraz lze použít s textField možností vrstvy symbolů pro zajištění smíšeného formátování textu. Tento výraz trvá v jednom nebo více formatEntry výrazech, které určují řetězec a sadu formatOptions pro připojení k textovému poli.

Výraz Popis
format(Expression...) Vrátí formátovaný text obsahující poznámky pro použití v položkách textových polí ve smíšeném formátu.
formatEntry(Expression text) | formatEntry(Expression text, Expression.FormatOption... formatOptions) | formatEntry(String text) | formatEntry(String text, Expression.FormatOption... formatOptions) Vrátí položku formátovaného řetězce pro použití ve format výrazu.

K dispozici jsou následující možnosti formátu:

Výraz Popis
formatFontScale(number) | formatFontScale(Expression) Určuje faktor škálování pro velikost písma. Je-li tento parametr zadán, tato hodnota přepíše textSize vlastnost pro jednotlivé řetězce.
formatTextFont(string[]) | formatTextFont(Expression) Určuje barvu, která má být použita pro text při vykreslování.

Příklad

Následující příklad formátuje textové pole přidáním tučného písma a vertikálního navýšení velikosti písma title vlastnosti funkce. Tento příklad také přidá subTitle vlastnost funkce na nový řádek, se zvětšenou velikostí písma.

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

Tato vrstva bude vykreslovat funkci bodu, jak je znázorněno na následujícím obrázku:

Obrázek funkce Point s formátovaným textovým polem

Výraz lupy

zoomVýraz se používá k načtení aktuální úrovně přiblížení mapy v době vykreslování a je definován jako zoom() . Tento výraz vrací číslo mezi minimálním a maximálním rozsahem úrovně přiblížení mapy. Azure Maps interaktivní ovládací prvky mapování pro web a Android podporují 25 úrovní přiblížení s čísly 0 až 24. Použití zoom výrazu umožňuje dynamicky upravovat styly při změně úrovně přiblížení mapy. zoomVýraz lze použít pouze s interpolate step výrazy a.

Příklad

Ve výchozím nastavení mají poloměry datových bodů vykreslených v vrstvě Heat mapy u všech úrovní přiblížení pevný obraz v pixelech. Jak je mapa zvětšena, agregace dat a vrstva Heat mapy vypadá jinak. zoomVýraz lze použít k horizontálnímu škálování poloměru pro každou úroveň přiblížení tak, že každý datový bod pokrývá stejnou fyzickou oblast mapy. Vrstva Heat mapy bude mít víc statických a konzistentních. Každá úroveň přiblížení mapy má dvakrát a vodorovně tolik pixelů jako předchozí úroveň přiblížení. Změna velikosti poloměru, například při zdvojnásobení s každou úrovní přiblížení, vytvoří Heat mapu, která bude vypadat konzistentně na všech úrovních přiblížení. Dá se to provést pomocí zoom výrazu s base 2 exponential interpolation výrazem, který má nastavené poloměru pixelů pro minimální úroveň přiblížení a poloměr škálování pro maximální úroveň přiblížení, jak je 2 * Math.pow(2, minZoom - maxZoom) znázorněno níže.

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

Výrazy vazeb proměnných

Výrazy vazeb proměnných ukládají výsledky výpočtu v proměnné. Takže je možné výsledky výpočtů odkazovat jinde ve výrazu vícekrát. Je užitečná optimalizace pro výrazy, které zahrnují mnoho výpočtů.

Výraz Návratový typ Description
let(Expression... input) Ukládá jednu nebo více hodnot jako proměnné pro použití var výrazem v podřízeném výrazu, který vrací výsledek.
var(Expression expression) | var(string variableName) Objekt Odkazuje na proměnnou, která byla vytvořena pomocí let výrazu.

Příklad

V tomto příkladu se používá výraz, který vypočítá tržby vzhledem k poměru teploty a pak použije case výraz k vyhodnocení různých logických operací s touto hodnotou. letVýraz se používá k uložení výnosů vzhledem k poměru teploty, aby jej bylo nutné vypočítat pouze jednou. varVýraz odkazuje na tuto proměnnou tak často, jak je potřeba, aniž by bylo nutné je přepočítat.

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

Další kroky

Přečtěte si další informace o vrstvách, které podporují výrazy: