# Arrays

A JavaScript array works like a C# List<T>. It grows and shrinks with push, pop, shift and unshift, and has length, includes and indexOf. Its filter, map, find and reduce methods do the jobs of LINQ's Where, Select, First and Sum.

Apprentice · JavaScript · Updated November 3, 2026

## After this lesson you can

- Add and remove array items with push, pop, shift and unshift, and look them up with length, includes and indexOf
- Filter, transform and total arrays with filter, map, find and reduce, like LINQ's Where, Select, First and Sum

## Key takeaways

- A JavaScript array works like a C# `List<T>`: `length` counts the items, `includes` checks for one, and `indexOf` finds it or gives `-1`.
- `push` and `pop` add and remove at the end; `unshift` and `shift` add and remove at the start.
- `filter`, `map`, `find` and `reduce` do the jobs of LINQ's `Where`, `Select`, `FirstOrDefault` and `Sum`, and never change the original array.
- `reduce` takes a function and a starting value. The function gets the running total and the next item, and returns the new total.
- `sort()` on its own sorts as text, so sort numbers with a compare function: `numbers.sort((a, b) => a - b)`.

A JavaScript array is written with square brackets, and it behaves much more like a C# **`List<T>`** than a C# array: it grows and shrinks as you go.

```javascript
const names = ['Emma', 'Liam', 'Olivia'];

console.log(names[0]);
console.log(names.length);
console.log(names.includes('Liam'));
console.log(names.indexOf('Olivia'));
console.log(names.indexOf('Noah'));
```

```text
Emma
3
true
2
-1
```

| JavaScript | C# `List<T>` |
|---|---|
| `names[0]` | `names[0]` |
| `names.length` | `names.Count` |
| `names.includes('Liam')` | `names.Contains("Liam")` |
| `names.indexOf('Olivia')`, `-1` when it isn't there | `names.IndexOf("Olivia")`, also `-1` |

One difference: reading past the end, such as `names[10]`, gives `undefined` instead of throwing an exception.

## Adding and removing

Four methods add and remove items at the two ends:

| Method | Does | Returns |
|---|---|---|
| `push(item)` | Adds to the **end** | The new length |
| `pop()` | Removes from the **end** | The item it removed |
| `unshift(item)` | Adds to the **start** | The new length |
| `shift()` | Removes from the **start** | The item it removed |

```javascript
const numbers = [];

numbers.push(7);
numbers.push(21);
numbers.push(3);
console.log(numbers.join(', '));

const last = numbers.pop();
console.log(`${last} came off the end: ${numbers.join(', ')}`);

numbers.unshift(35);
console.log(numbers.join(', '));

const first = numbers.shift();
console.log(`${first} came off the start: ${numbers.join(', ')}`);
```

```text
7, 21, 3
3 came off the end: 7, 21
35, 7, 21
35 came off the start: 7, 21
```

`join(', ')` turns an array into one string, with `', '` between the items, like C#'s `string.Join`. And the array is a `const`, yet it changed: `const` only stops `numbers` being given a whole new array.

`push` and `pop` together make a stack, like C#'s `Stack<T>`; `push` and `shift` make a queue, like `Queue<T>`.

## Looping

`for...of` goes through the items, like `foreach`:

```javascript
const names = ['Emma', 'Liam', 'Olivia'];

for (const name of names) {
    console.log(`Hello, ${name}`);
}
```

```text
Hello, Emma
Hello, Liam
Hello, Olivia
```

Careful: it's `of`. There's also a `for...in`, which goes through the **positions** (`'0'`, `'1'`, `'2'`) instead of the items.

## LINQ, JavaScript style

Arrays have methods that take a function, just like LINQ's take a lambda:

```javascript
const scores = [72, 95, 48, 88, 61];

const passes = scores.filter(score => score >= 60);
const curved = scores.map(score => score + 5);
const firstFail = scores.find(score => score < 60);
const total = scores.reduce((sum, score) => sum + score, 0);

console.log(passes.join(', '));
console.log(curved.join(', '));
console.log(firstFail);
console.log(total);
console.log(scores.some(score => score > 90));
console.log(scores.every(score => score > 40));
```

```text
72, 95, 88, 61
77, 100, 53, 93, 66
48
364
true
true
```

| JavaScript | LINQ | Gives |
|---|---|---|
| `filter(...)` | `Where(...)` | The items the function is true for, as a new array |
| `map(...)` | `Select(...)` | A new array, each item changed by the function |
| `find(...)` | `FirstOrDefault(...)` | The first match, or `undefined` |
| `reduce(...)` | `Sum(...)`, `Aggregate(...)` | One value, built up item by item |
| `some(...)`, `every(...)` | `Any(...)`, `All(...)` | `true` or `false` |

`score => score >= 60` is an **arrow function**: JavaScript's lambda. The next lesson looks at them closely.

**`reduce`** takes two arguments: a function, and the **starting value** (`0` here). The function gets the running total so far and the next item, and returns the new running total: `0 + 72`, then `72 + 95`, and so on.

Unlike LINQ, these methods run **at once** and return real arrays; there's no deferred execution, and no `ToList()` needed. They never change the original array.

## Sorting needs a function

One trap for C# developers: `sort()` on its own sorts items as **text**, and changes the array itself:

```javascript
const numbers = [10, 9, 100, 1];

numbers.sort();
console.log(numbers.join(', '));

numbers.sort((a, b) => a - b);
console.log(numbers.join(', '));
```

```text
1, 10, 100, 9
1, 9, 10, 100
```

As text, `'100'` comes before `'9'`, just as *apple* comes before *banana*. To sort numbers, give `sort` a function that compares two items: negative when `a` goes first, positive when `b` does. `a - b` is exactly that.

## Check yourself

2 questions to try on the lesson page.

## So what

A JavaScript array is a `List<T>` with LINQ built in: `push` and `pop` to change it, `filter`, `map`, `find` and `reduce` to ask it questions. Just remember to give `sort` a compare function for numbers.

## Key terms

- [Array](https://www.ask-codey.com/glossary/array-javascript-2)
- [push()](https://www.ask-codey.com/glossary/push)
- [filter()](https://www.ask-codey.com/glossary/filter-javascript)
- [map()](https://www.ask-codey.com/glossary/map-javascript)
- [reduce()](https://www.ask-codey.com/glossary/reduce-javascript)
- [sort()](https://www.ask-codey.com/glossary/sort-javascript)

## Cheat sheets

- [Arrays](https://www.ask-codey.com/cheat-sheets/csharp-vs-javascript-arrays-cheat-sheet)

Source: https://www.ask-codey.com/lessons/csharp-vs-javascript-arrays