## Update For Node.js / NPM

Add [`"type": "module"`][1] to your [`package.json`][2] file.

```json
{
  // ...
  "type": "module",
  // ...
}
```

**Note**: When using modules, if you get `ReferenceError: require is not defined`,  you'll need to use the [`import` syntax][3] instead of [`require`][5]. You can't natively mix and match between them, so you'll need to pick one or [use a bundler if you need to use both][4].

  [1]: https://nodejs.org/api/esm.html#esm_enabling
  [2]: https://nodejs.org/api/packages.html#packages_type
  [3]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import
  [4]: https://stackoverflow.com/a/56068668/1366033
  [5]: https://nodejs.org/en/knowledge/getting-started/what-is-require/



I'm using ArcGIS JSAPI 4.12 and wish to use [Spatial Illusions][1] to draw military symbols on a map.

When I add `milsymbol.js` to the script, the console returns error

> Uncaught SyntaxError: Cannot use import statement outside a module`

so I add `type="module"` to the script, and then it returns

> Uncaught ReferenceError: ms is not defined

Here's my code:

    <link rel="stylesheet" href="https://js.arcgis.com/4.12/esri/css/main.css">
    <script src="https://js.arcgis.com/4.12/"></script>
    <script type="module" src="milsymbol-2.0.0/src/milsymbol.js"></script>

    <script>
        require([
            "esri/Map",
            "esri/views/MapView",
            "esri/layers/MapImageLayer",
            "esri/layers/FeatureLayer"
        ], function (Map, MapView, MapImageLayer, FeatureLayer) {

            var symbol = new ms.Symbol("SFG-UCI----D", { size: 30 }).asCanvas(3);
            var map = new Map({
                basemap: "topo-vector"
            });

            var view = new MapView({
                container: "viewDiv",
                map: map,
                center: [121, 23],
                zoom: 7
            });
        });
    </script>

So, whether I add `type="module"` or not, there are always errors. However, in the official document of Spatial Illusions, there isn't any `type="module"` in the script. I'm now really confused. How do they manage to get it work without adding the type?

### File *milsymbol.js*

    import { ms } from "./ms.js";

    import Symbol from "./ms/symbol.js";
    ms.Symbol = Symbol;

    export { ms };

  [1]: https://github.com/spatialillusions/milsymbol




"Uncaught SyntaxError: Cannot use import statement outside a module" when importing ECMAScript 6

### Update 2021

You can use the [`Array.at()`][1] method, which was moved to [Stage 4  in Aug, 2021][9]

```js
['a','b','c'].at(-1) // 'c'
```

### Further Reading

* **Docs**
  * [MDN - Array.prototype.at()][1]
  * [Proposal - Relative Indexing Method][5]
  * [tc39 spec - Array.at][6]
  * [CanIUse - JavaScript built-in: Array: at][7]

* **Stack Overflow**
  * [Get the last item in an array][2]
  * [Selecting last element in JavaScript array][3]
  * [Destructuring to get the last element of an array in es6][4]


[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at
[2]: https://stackoverflow.com/q/3216013/1366033
[3]: https://stackoverflow.com/q/9050345/1366033
[4]: https://stackoverflow.com/q/33064377/1366033
[5]: https://github.com/tc39/proposal-relative-indexing-method
[6]: https://tc39.es/ecma262/#sec-array.prototype.at
[7]: https://caniuse.com/mdn-javascript_builtins_array_at
[8]: https://tc39.es/proposal-relative-indexing-method/#sec-array-prototype-additions
[9]: https://github.com/tc39/proposals/blob/main/finished-proposals.md

I have a list of array items like this:

```js
const items = [
  { a: 1 },
  { b: 2 },
  { c: 3 },
]
```

How can I return / log the last element: `{ c: 3 }`


Here's what I've tried so far:

```js
let newarray = items.map((item) => {
    console.log(item);
})

console.log(newarray);
```




How the get the last element in an array items using JavaScript

The [**official guidance**][1] is to use the [**`runtimeArgs`** attribute][2] like this:

```json
{
    "name": "Launch Program",
    "request": "launch",
    "type": "node",
    "runtimeArgs": ["--experimental-modules"],
    "program": "${workspaceFolder}\\bin\\www"
}
```

Which will run the following terminal command:

```bash
node.exe --experimental-modules .\bin\www
```

**See Also**: [How to start nodejs with custom params from vscode][3]


[1]: https://code.visualstudio.com/docs/nodejs/nodejs-debugging#_how-do-i-debug-ecmascript-modules
[2]: https://code.visualstudio.com/docs/nodejs/nodejs-debugging#_launch-configuration-attributes
[3]: https://stackoverflow.com/q/29968919/1366033

I can run my node.js application with `es6` modules with the `--experimental-modules` flag as follows:

    node --experimental-modules ./bin/www

How can I do the same when debuggging the application from VS Code, which uses the launch.json configuration file? 

    {
        "version": "0.2.0",
        "configurations": [
            {
              "type": "node",
              "request": "launch",
              "name": "Launch Program",
              "program": "${workspaceFolder}\\bin\\www",
            }
        ]
    }

VS Code debug with --experimental-modules flag

Refactored [Nina Scholz's answer][1] with longer variable names, comments, and slightly different control of flow:





    const combineAdjacentElements = array => array.reduce((acc, val, i) => {
        // if cur is different from prev value, add raw number
        if (val !== array[i - 1]) {
          acc.push(val)
          return acc
        }

        // if first repetition, replace val with grouped array
        if (typeof acc.at(-1) === 'number') {
            acc[acc.length - 1] = [val, 2];
            return acc
        }

        // if multiple repetition, increment counter in grouped array
        acc.at(-1)[1]++;
        return acc;
    }, []);


    const output = combineAdjacentElements([3, 2, 2, 2, 5, 1, 1, 7, 1])

    console.log(JSON.stringify(output, null, 0))
    // [3,[2,3],5,[1,2],7,1]




### Further Reading

* [Check whether variable is number][2]
* [How the get the last element in an array][3]
* [How to replace the last index value in array javascript][4]

[1]: https://stackoverflow.com/a/61756370/1366033
[2]: https://stackoverflow.com/q/1303646/1366033
[3]: https://stackoverflow.com/a/69563549/1366033
[4]: https://stackoverflow.com/q/48744911/1366033

I'd like to combine identical elements in an array, into a single term with how many times the value appears



```js
function combineArrayElements(arr) {
  return arr.map((e, i, ar) => {
    if (e === ar[i + 1] || (e[0] && e[0] === ar[i + 1])) {
      return [e, e[1] + 1]
    }
    return e;
  })
}
```

Some example input and output:

```js
// input  [3, 2, 2, 5, 1, 1, 7, 1]
// output [3,[2,2],5,[1,2],7,1]

// input  [1, 1, 1, 2, 1]
// output [[1,3], 2, 1]
```


How to reduce JS array length if next elements equal previous

As logically concluded by the linq example

> `None` is the same as `!Any`, so you could define your own extension method as follows:

```js
let none = (arr, callback) => !arr.some(callback)
```

And then call like this:

```js
let arr = ["a","b","c"]
let noBs = none(arr, el => el === "b")
```

---

*Or* if you want to [*extend `Array.proto`*][1], you can add the following method:


```js
Object.defineProperty(Array.prototype, 'none', {
    value: function (callback) { return !this.some(callback) }
});
```

Then call like this:

```js
let arr = ["a","b","c"]
let noBs = arr.none(el => el === "b")
```

[1]: https://stackoverflow.com/a/35518127/1366033

There's a similar question for LINQ: [Is there an equivalent of `None()` in LINQ?][5]

There are some boolean methods on collections / arrays:

* [`Array.some`][1] (similar to [`linq.Any`][3])
* [`Array.every`][2] (similar to [`linq.All`][4])

Can I check if no elements in array match a given function callback

A possible workaround is to `.filter` and then check `.length` and make sure it's zero:

```js
let arr = ["a","b","c"]
// make sure that no item in array = "b"
let noBs = arr.filter(el => el === "b").length === 0
```


[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every
[3]: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.any?view=netcore-3.1
[4]: https://learn.microsoft.com/en-us/dotnet/api/system.linq.enumerable.all?view=netcore-3.1
[5]: https://stackoverflow.com/q/19338122/1366033