Style a feature layer

Learn how to use renderers to apply data-driven styling to feature layers.

A feature layer is a dataset within a hosted feature service. Each feature layer consists of features that share a single geometry type (point, line, or polygon), along with a set of attributes. Client-side, feature layers can be styled using a renderer. Renderers use attribute values to apply the appropriate symbols to each feature when the layer is displayed. Additionally, renderers can work with visual variables and expressions to create more complex, data-driven visualizations.

In this tutorial, you will use three different renderers to style three hosted feature layers.

Prerequisites

Steps

Create a new pen

To get started, either complete the Display a map tutorial or .

Get an access token

You need an access token with the correct privileges to access the location services used in this tutorial.

Go to the Create an API key tutorial and create an API key with the following privilege(s):
- Privileges
  - Location services > Basemaps
- Item access
  - Note: If you are using your own custom data layer for this tutorial, you need to grant the API key credentials access to the layer item. Learn more in Item access privileges.

In CodePen, set esriConfig.apiKey to your access token.

Use dark colors for code blocks
  var esriConfig = {
    apiKey: "YOUR_ACCESS_TOKEN"
  };

To learn about other ways to get an access token, go to Types of authentication.

Display a map

Follow the steps in the Display a map tutorial to add a map with the arcgis/topographic basemap layer, centered on Point Dume State Beach, Malibu, California.

Add script and modules

In a new <script> at the bottom of the <body>, use a require statement to add the FeatureLayer module.

The ArcGIS Maps SDK for JavaScript is available as AMD modules and ES modules, but this tutorial is based on AMD. The AMD require function uses references to determine which modules will be loaded – for example, you can specify "esri/layers/FeatureLayer" for loading the FeatureLayer module. After the modules are loaded, they are passed as parameters (e.g. FeatureLayer) to the callback function where they can be used in your application. It is important to keep the module references and callback parameters in the same order. To learn more about the API's different modules visit the Overview Guide page.

Expand
Use dark colors for code blocks
<script>
  require(["esri/layers/FeatureLayer"], (FeatureLayer) => {

  });
</script>
Expand

Style trailheads (points)

Use the SimpleRenderer, PictureMarkerSymbol, and LabelClass classes to style the points with an image, and then define label attributes to display for the Trailheads feature layer.

Create a trailheadsRenderer and define it as a simple renderer. Set the symbol property to draw a hiker image accessed from its url.

Expand
Use dark colors for code blocks
      // Define a simple renderer and symbol
      const trailheadsRenderer = {
        "type": "simple",
        "symbol": {
          "type": "picture-marker",
          "url": "http://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png",
          "width": "18px",
          "height": "18px"
        }
      }

Expand

Create a trailheadsLabels and set the symbol property to draw a label with the TRL_NAME.

Expand
Use dark colors for code blocks
      // Define a label for the trailheads
      const trailheadsLabels = {
        symbol: {
          type: "text",
          color: "#FFFFFF",
          haloColor: "#5E8D74",
          haloSize: "2px",
          font: {
            size: "12px",
            family: "Noto Sans",
            style: "italic",
            weight: "normal"
          }
        },

        labelPlacement: "above-center",
        labelExpressionInfo: {
          expression: "$feature.TRL_NAME"
        }
      };
Expand

Create a trailheads FeatureLayer. Set the url property to access its URL endpoint. Set the renderer and labelingInfo before adding trailheads to the map. The feature layer will autocast the renderer and labelingInfo to create class instances of the objects.

Expand
Use dark colors for code blocks
        labelPlacement: "above-center",
        labelExpressionInfo: {
          expression: "$feature.TRL_NAME"
        }
      };

      // Create the layer and set the renderer
      const trailheads = new FeatureLayer({
        url: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0",
        renderer: trailheadsRenderer,
        labelingInfo: [trailheadsLabels]
      });

      arcgisMap.map.add(trailheads);
Expand

Add trailheads layer to the map. When using the arcgis-map component, you need to add an event listener for arcgisViewReadyChange to wait until the component is ready before adding the layer.

Expand
Use dark colors for code blocks
      arcgisMap.map.add(trailheads);

Expand

View hiker symbols with trailhead names.

Style trails (lines)

Use the SimpleRenderer and VisualVariable classes to style trails in the Trails feature layer. Visual variables define the attribute to use to style trails with a greater elevation gain wider compared to trails with smaller elevation changes. This is one form of data-driven visualization.

Create a trailsRenderer and define it as a simple renderer.

Expand
Use dark colors for code blocks
      // Define a unique value renderer and symbols
      const trailsRenderer = {
        type: "simple",
        symbol: {
          color: "#BA55D3",
          type: "simple-line",
          style: "solid"
        },

Expand

In the visualVariables array, set the field to ELEV_GAIN to determine line width.

Expand
Use dark colors for code blocks
        visualVariables: [
          {
            type: "size",
            field: "ELEV_GAIN",
            minDataValue: 0,
            maxDataValue: 2300,
            minSize: "3px",
            maxSize: "7px"
          }
        ]
      };

Expand

Create a trails FeatureLayer. Set the url to access its URL endpoint.

Expand
Use dark colors for code blocks
      // Create the layer and set the renderer
      const trails = new FeatureLayer({
        url: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0",
        renderer: trailsRenderer,
        opacity: 0.75
      });

      arcgisMap.map.add(trails, 0);
Expand

Add trails layer to the map. Set the renderer and opacity properties before adding trails to the map. The feature layer will autocast the renderer a create class instances of the object.

Expand
Use dark colors for code blocks
      arcgisMap.map.add(trails, 0);

Expand

View trails of differing widths based on elevation gain.

Show bike-only trails (lines)

You can use a renderer and definition expression to style a subset of data from a feature layer. To style bike-only trails from the Trails feature layer, use the definitionExpression, SimpleRenderer and SimpleLineSymbol classes. The layer is added on top of the existing trails layer.

Create a bikeTrailsRenderer and define it as a simple renderer. Set the symbol to draw a line that is styled with dots in pink.

Expand
Use dark colors for code blocks
      // Add bikes only trails
      const bikeTrailsRenderer = {
        type: "simple",
        symbol: {
          type: "simple-line",
          style: "short-dot",
          color: "#FF91FF",
          width: "1px"
        }
      };

Expand

Create a bikeTrails FeatureLayer and set the url and renderer properties. Set the definitionExpression (a SQL where clause) to access bike trails from the Trails feature layer before adding bikeTrails to the map.

Expand
Use dark colors for code blocks
      const bikeTrails = new FeatureLayer({
        url:
          "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0",
        renderer: bikeTrailsRenderer,
        definitionExpression: "USE_BIKE = 'YES'"
      });

      arcgisMap.map.add(bikeTrails, 1);
Expand

Add bikeTrails layer to the map. The feature layer will autocast the renderer a create class instances of the object.

Expand
Use dark colors for code blocks
      arcgisMap.map.add(bikeTrails, 1);

Expand

View the location of bike trails in relation to other trails.

Style open spaces (polygons)

You can use renderers to style feature layer data by unique attribute values. Use the UniqueValueRenderer and SimpleFillSymbol classes to style polygon features with different fill colors, based on the TYPE attribute in the Parks and Open Spaces feature layer.

Create a createFillSymbol function with value and color as parameters. The function will return a solid, simple-fill symbol for each park type.

Expand
Use dark colors for code blocks
      // Add parks with a class breaks renderer and unique symbols
      function createFillSymbol(value, color) {
        return {
          "value": value,
          "symbol": {
            "color": color,
            "type": "simple-fill",
            "style": "solid",
            "outline": {
              "style": "none"
            }
          },
          "label": value
        };
      }

Expand

Create an openSpacesRenderer and define it as unique-value. Set the field property to TYPE. In the uniqueValueInfos array, set unique colors for each park type.

Expand
Use dark colors for code blocks
      const openSpacesRenderer = {
        type: "unique-value",
        field: "TYPE",
        uniqueValueInfos: [
          createFillSymbol("Natural Areas", "#9E559C"),
          createFillSymbol("Regional Open Space", "#A7C636"),
          createFillSymbol("Local Park", "#149ECE"),
          createFillSymbol("Regional Recreation Park", "#ED5151")
        ]
      };

Expand

Create an openspaces FeatureLayer. Set the url to access its URL endpoint. Set the renderer and opacity properties before adding openspacesto the map. The feature layer will autocast the renderer to create class instances of the object.

Expand
Use dark colors for code blocks
      // Create the layer and set the renderer
      const openspaces = new FeatureLayer({
        url: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0",
        renderer: openSpacesRenderer,
        opacity: 0.2
      });

      arcgisMap.map.add(openspaces, 0);
Expand

Add openspaces layer to the map. The feature layer will autocast the renderer to create class instances of the object.

Expand
Use dark colors for code blocks
      arcgisMap.map.add(openspaces, 0);
Expand

Run the app

In CodePen, run your code to display the map.

The completed map should display all of the layers with a unique, data-driven style.

What's next?

Learn how to use additional API features and ArcGIS services in these tutorials: