Dictionary functions

1
2
3
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
Count(d);
// returns 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var data = {
  time: Date(2024, 0, 24, 12),
  weather: {
    precipitation: {
      type: "rain",
      value: 0.4,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

DefaultValue(data, "time", "No time logged")
// value of data.time is defined, so it is returned
// returns Jan 24, 2024, 12:00:00 PM system time

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var data = {
  time: '',
  weather: {
    precipitation: {
      type: "rain",
      value: 0.4,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

DefaultValue(data, "time", "No time logged")
// value of data.time is empty, so the default is returned
// returns "No time logged"

1
2
3
4
5
6
7
var data = {
  time: ''
}

DefaultValue(data, "conditions", "n/a")
// the conditions key does not exist, so the default is returned
// returns "n/a"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var data = {
  time: Date(2024, 0, 24, 12),
  weather: {
    precipitation: {
      type: "rain",
      value: 0.4,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

DefaultValue(data, ["weather", "precipitation", "value"], "No time logged")
// value of data.weather.precipitation.value is defined, so it is returned
// returns 0.4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var data = {
  time: Date(2024, 0, 24, 12),
  weather: {
    precipitation: {
      type: "rain",
      value: null,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

DefaultValue(data, ["weather", "precipitation", "value"], 0)
// value of data.weather.precipitation.value is null, so the default is returned
// returns 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var data = {
  time: Date(2024, 0, 24, 12),
  weather: {
    precipitation: {
      type: "rain",
      value: null,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

DefaultValue(data, ["weather", "wind", "value"], "n/a")
// the data.weather.wind key does not exist, so the default is returned
// returns "n/a"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
var data = {
  time: Date(2024, 0, 24, 12),
  interval: 1,
  intervalUnit: "days",
  weather: {
    precipitation: {
      type: "rain",
      values: [0.4, 0, 0, null, 0.1, 0.8, 1],
      unit: "inches"
    },
    temperature: {
      values: [50, 50, 51, 52, 55, 49, 51],
      unit: "f"
    },
  }
}

DefaultValue(data, ["weather", "precipitation", "values", 3], 0)
// the value data.weather.precipitation.values[3] is null, so the default is returned
// returns 0

1
2
var d = Dictionary('field1', 1, 'field2', 2)
return d.field1 + d.field2

1
2
3
var extraInfo = '{"id": 1, "population": 200, "city": "Spencer, ID"}'
var spencerIDdata = Dictionary(extraInfo)
spencerIDdata.population // Returns 200

1
2
3
4
5
6
7
// convert the $feature's geometry to a dictionary
if (TypeOf(Geometry($feature)) == "Point") {
  var ptDict = Dictionary(Geometry($feature));
  ptDict.x *= 2; // stretch horizontally
  // create a new geometry from the updated dictionary
  return Geometry(ptDict);
}

1
2
// convert $feature to a dictionary
var featureDict = Dictionary($feature);

1
2
3
4
5
6
7
8
9
10
11
var inputDict = {
  company: {
    name: "Esri",
    location: "Redlands, CA"
  },
  office: "M123"
};
var copiedDict = Dictionary(inputDict);
return inputDict.company == copiedDict.company
// returns true
// this is a shallow copy of the Dictionary, so the dictionaries share the same references

1
2
3
4
var deepCopy = Dictionary(inputDict, true);
return inputDict.company == deepCopy.company
// returns false
// this is a deep copy of the Dictionary, so the dictionaries do NOT share the same references

1
2
// convert $voxel to a dictionary
var voxelDict = Dictionary($voxel);

1
2
3
4
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
Erase(d, 'Grafton');
return d;
// returns {'Port Hope': 16214, 'Cobourg': 18519};

1
2
FromJSON("true")
// Returns true

1
2
fromJSON("731.1")
// returns 731.1

1
2
3
var d = fromJSON('{"kids": 3, "adults": 4 }')
d.kids + d.adults
// returns 7

1
2
fromJSON('["one", 2, "three", false]')
// returns [ "one", 2, "three", false ]

1
2
fromJSON("null")
// returns null

1
2
3
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
GetKeys(d);
// returns ['Cobourg', 'Grafton', 'Port Hope']

1
2
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
return GetValues(d);

1
2
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
HasKey(d, 'Cobourg');

1
2
3
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
HasValue(d, 'Cobourg');
// returns true

1
2
3
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', null);
HasValue(d, 'Cobourg');
// returns false

1
2
3
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000');
HasValue(d, 'Cobourg');
// returns false

1
2
3
if ( HasValue( Schema($feature).fields[0], "domain" ) ) {
  // Do something with the value if true
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var data = {
  time: Date(2024, 0, 24, 12),
  weather: {
    precipitation: {
      type: "rain",
      value: 0.4,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

if(HasValue(data, ["weather","precipitation","value"])){
  // if() evaluates to true, thus executing the return
  return data.weather.precipitation.value;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
var data = {
  time: Date(2024, 0, 24, 12),
  weather: {
    precipitation: {
      type: "rain",
      value: 0.4,
      unit: "inches"
    },
    temperature: {
      value: 50,
      unit: "f"
    },
    conditions: {
      description: "Overcast"
    }
  }
}

if(HasValue(data, ["weather","precipitation","values", 0])){
  // if() evaluates to false ("values" does not exist), thus avoiding the block
  return data.weather.precipitation.values;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
var data = {
  time: Date(2024, 0, 24, 12),
  interval: 1,
  intervalUnit: "days",
  weather: {
    precipitation: {
      type: "rain",
      values: [0.4, 0, 0, null, 0.1, 0.8, 1],
      unit: "inches"
    },
    temperature: {
      values: [50, 50, 51, 52, 55, 49, 51],
      unit: "f"
    },
  }
}

if(HasValue(data, ["weather","precipitation","values", 6])){
  // if() evaluates to true, thus executing the return
  return data.weather.precipitation.values[6];
}

1
2
3
4
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
Insert(d, 'Colborne', 1474);
return d;
// returns {'Port Hope': 16214,  'Grafton': '<1000', 'Cobourg': 18519, 'Colborne': 1474}

1
2
3
4
var d = Dictionary('Port Hope', 16214,  'Grafton', '<1000', 'Cobourg', 18519);
Insert(d, 'Grafton', 1200);
return d;
// returns {'Port Hope': 16214,  'Grafton': 1200, 'Cobourg': 18519}