Collection

let gpc = new Graphic();  // Creates a new graphic
let layer = new GraphicsLayer(); // Creates a new graphics layer
layer.graphics.add(gpc);  // Adds graphic to layer's graphics collection

// Creates two new graphics
let gpc1 = new Graphic();
let gpc2 = new Graphic();

let layer = new GraphicsLayer(); // Creates a new graphics layer

// Adds both graphics to layer's graphics collection
layer.graphics.addMany([gpc1, gpc2]);

// get the layer at the first position
let firstLayer = map.layers.at(0);
// get the layer at the last position
let lastLayer = map.layers.at(-1);

// slides is a clone of the scene slides
let slides = scene.presentation.slides.clone();

// creating a collection of all the basemap's layers.
let basemap = map.basemap;
let basemapLayers = basemap.baseLayers.concat(basemap.referenceLayers);

let meetsStandardSize = graphicsLayer.graphics.every(function(item, i){
  // Tests each geometry's area to see if it is greater than 1,000 acres
  return calculateArea(item.geometry) > 1000;
});

// filteredLayers is a Collection of all the non-visible layers in the map
let filteredLayers = map.layers.filter(function(layer){
  return !layer.visible;
});

// If the id of a map layer is already known, get the layer that matches the id
let myLayer = map.layers.find(function(layer){
  return layer.id === "speciesLyr01";
});
// myLayer references the layer in map with ID "speciesLyr01"

// gpcIndex is assigned the index of the first graphic whose name
// property is 'Redlands'. This result can be used in getItemAt()
let gpcIndex = graphicsLyr.graphics.findIndex(function(item){
  return item.attributes.name === "Redlands";
});

// create a MapImageLayer with several sublayers and add to a map
// containing another GraphicsLayer
let layer = new MapImageLayer({ sublayers: [ ... ] });
let map = new Map({
  layers: [ layer, new GraphicsLayer() ]
});

// A flat collection of all layers and sublayers
// (if layer is a MapImageLayer) in the map.
// This collection may be searched or used for other purposes
let allLayersAndSublayers = map.layers.flatten(function(item){
  return item.layers || item.sublayers;
});

graphicsLayer.graphics.forEach(function(item, i){
  // Do something here to each graphic like calculate area of its geometry
  calculateArea(item.geometry);
});

// Assigns the base layer at index 0 to baseLayer
let baseLayer = map.basemap.baseLayers.getItemAt(0);

// check if a layer is in the map's operational layers.
if (view.map.layers.includes(myLayer)) {
  // ...
}

// index is the index of the first graphic in the
// graphics layer that matches the input graphic
let index = graphicsLayer.graphics.indexOf(graphic);

let stringCollection = new Collection(["how", "are", "you", "doing?"]);
let phrase = stringCollection.join(" ");

// Prints "how are you doing?"
console.log(phrase);

// index is the index of the first graphic in the
// graphics layer that matches the input graphic
let index = graphicsLayer.graphics.lastIndexOf(graphic);

// Gets the geometries of the graphics and assigns them to a new Collection
let geometries = graphicsLayer.graphics.map(function(item, i){
  return item.geometry;
});

require(["esri/core/Collection", "esri/geometry/Point"],
  function(Collection, Point){
    let PointCollection = Collection.ofType(Point);
    let collection = new PointCollection();
    collection.add([-100,40]);
    let point = collection.at(0);
    // point.x = -100; point.y = 40
});

view.on("click", function(event){
  // event is the event handle returned after the event fires.
  console.log(event.mapPoint);
});

// Removes the last layer in the map and stores it in lastLayer
let lastLayer = map.layers.pop();

// Adds a new graphic to the end of the graphics collection on a GraphicsLayer
graphicsLyr.graphics.push(newGraphic);

// Adds three new graphics to the end of the GraphicsLayer's graphics collection
graphicsLyr.graphics.push(g1, g2, g3);

let layer = map.layers.at(4);
// Removes the fifth layer from the map
map.layers.remove(layer);

// Removes all layers from the map
map.layers.removeAll();

// Removes the layer at index 4 of the map
map.layers.removeAt(4);

let refLayers = [refLyr1, refLyr2, refLyr3];
// Removes three reference layers in the refLayers
// collection from the basemap's referenceLayers
map.basemap.referenceLayers.removeMany(refLayers);

// Get the first two layers in a map
let layer1 = map.layers.at(0);
let layer2 = map.layers.at(1);

// Moves the second layer to the first position in the map.layers Collection
// effectively swapping the positions of layer1 and layer2
map.layers.reorder(layer2, 0);

// Reverse layers from the map
map.layers.reverse();

// Removes the first layer in the map and stores it in firstLyr
let firstLyr = map.layers.shift();

// get the graphics from index 50 to 100;
let selection = graphicsLayer.graphics.slice(50, 100);

// If at least one of the point graphics has a geometry whose
// elevation is above 1000m, then passes will have a value of true.
// Otherwise, it will be false.
let passes = graphicsLayer.graphics.some(function(item, i){
  return item.geometry.z > 1000;
});

// Sort graphics based on their elevation or z-value
let sortedGraphics = graphicsLayer.graphics.sort(function(a, b){
  if(a.geometry.z > b.geometry.z){
    return 1;
  }
  else if (a.geometry.z < b.geometry.z){
    return -1;
  }
  else {
    return 0;
  }
});

// map.layers is a collection of 6 layers
// Adds a seventh layer to the map at index 3
map.layers.splice(3, 0, layer7);

// Removes two layers starting from index 2 and adds the
// specified layers in the positions of the former layers
let oldLayers = map.layers.splice(2, 2, layer8, layer9, layer10);

// oldLayers = [layer2, layer3]

// Creates an array populated with the map's layers
let mapLayersArray = map.layers.toArray();

// If a map's basemap has 3 baseLayers: baseLyr0, baseLyr1, baseLyr2
map.basemap.baseLayers.unshift(baseLyr3);

// Now the baseLayers collection is: baseLyr3, baseLyr0, baseLyr1, baseLyr2

// indicates a layer has been added to the map
map.layers.on("after-add", function(event){
  console.log(event.item, " has been added to the map.");
});

map.layers.on("after-changes", function(event){
  console.log(event, " layer was added/removed from the map.");
});

// indicates a layer has been removed from the map
map.layers.on("after-remove", function(event){
  console.log(event.item, " has been removed from the map.");
});

// prevents a layer from being added to the map more than once.
map.layers.on("before-add", function(event){
   if(map.layers.includes(event.item)){
     event.preventDefault();
     console.log("layer already exists in map.");
   }
});

map.layers.on("before-changes", function(event){
  // prevents layers from being added/removed from the map
  event.preventDefault();
});

// prevents a layer from being removed from the basemap
map.basemap.baseLayers.on("before-remove", function(event){
   if(map.basemap.baseLayers.includes(event.item)){
     event.preventDefault();
     console.log("layer cannot be removed from basemap.");
   }
});

// This function will fire each time a layer is either added,
// moved, or removed from the map.layers Collection
// make a copy of the collection event object for processing
map.layers.on("change", function(event){
  const copiedEvent = JSON.parse(JSON.stringify(event));
  let newLayers = copiedEvent.added; // An array of layers added to the map.layers Collection
  let reorderedLayers = copiedEvent.moved;  // An array of layers moved in the Collection
  let removedLayers = copiedEvent.removed;  // An array of layers removed from map
});