Unlimited WordPress themes, graphics, videos & courses! Unlimited asset downloads! From $16.50/m

Next lesson playing in 5 seconds

Cancel
  • Overview
  • Transcript

3.1 Arrays

Arrays are one of the most commonly used structures for storing data, and you will use them all the time. In this lesson we’ll focus on the basics: what arrays are and how they can be created, accessed, and modified.

Syntax

  • Array
  • []

1.Introduction
2 lessons, 07:42

1.1
Introduction
02:12

1.2
Setup
05:30

2.Language Fundamentals
8 lessons, 1:00:53

2.1
Variables
06:33

2.2
Data Types
11:28

2.3
Arithmetic, Assignment, and Comparison Operators
10:24

2.4
Unary, Logical, Comma, and Spread Operators
09:02

2.5
Operator Precedence
03:50

2.6
Reserved Words
04:17

2.7
Strict Mode
04:34

2.8
Functions
10:45

3.Data Structures
5 lessons, 22:52

3.1
Arrays
04:29

3.2
Objects
04:30

3.3
Sets
04:57

3.4
Maps
04:21

3.5
Weak Maps and Weak Sets
04:35

4.Controlling Program Execution
7 lessons, 37:06

4.1
Conditionals
07:49

4.2
Switch Statements
04:41

4.3
The For Loop
06:39

4.4
The `for .. in` Loop
05:17

4.5
The `for .. of` Loop
04:02

4.6
Iterators
05:03

4.7
While Loops
03:35

5.Using JavaScript
13 lessons, 1:44:36

5.1
Working With Strings
09:32

5.2
Template Literals
05:46

5.3
Working With Numbers
06:57

5.4
Working With Arrays
12:53

5.5
Iterating and Transforming Arrays
07:33

5.6
Working With the Object Type
13:55

5.7
Object Literal Extensions
06:45

5.8
Working With Object Instances
06:45

5.9
Getters and Setters
05:00

5.10
Custom Objects
11:28

5.11
The `Math` API
04:54

5.12
Working With Dates and Times
08:10

5.13
The `Array` Constructor
04:58

6.Functions
8 lessons, 56:07

6.1
The `this` Object
06:15

6.2
Working With Functions
10:11

6.3
Scope
07:37

6.4
Arrow Functions
06:59

6.5
Generator Functions
08:13

6.6
Closures
05:00

6.7
Prototypes
06:26

6.8
Default and Rest Parameters
05:26

7.Miscellaneous
6 lessons, 52:39

7.1
Destructuring Assignments
08:09

7.2
AJAX
08:30

7.3
Regular Expressions
10:51

7.4
More About Regular Expressions
08:38

7.5
Classes
06:48

7.6
ES Modules
09:43

8.Working With the DOM
6 lessons, 37:39

8.1
Selecting HTML Elements
05:02

8.2
Manipulating HTML Elements
07:40

8.3
DOM Traversal
05:25

8.4
Adding and Removing Elements
04:45

8.5
Creating Elements and Other Nodes
04:39

8.6
DOM Events
10:08

9.Web APIs
4 lessons, 17:41

9.1
The Selector API
03:03

9.2
Geolocation
05:29

9.3
Web Storage
05:24

9.4
Web Workers
03:45

10.Asynchronous JavaScript
5 lessons, 26:23

10.1
Promises
09:52

10.2
Promise Chaining
05:11

10.3
The async Keyword
03:21

10.4
The await Keyword
04:04

10.5
More About async and await
03:55

11.Conclusion
1 lesson, 00:43

11.1
Conclusion
00:43


3.1 Arrays

Hi, folks. Let's start Section 3 by looking at arrays. Arrays are very commonly used in JavaScript and have a rich and extensive API for manipulating them. We'll look at these APIs later in the course. So an array is a single object which can contain multiple values. A variable is a container for a single value, but an array is a container for multiple values. As I mentioned before, we can create arrays in a number of different ways. There is the array constructor, but we can also create literal arrays. Now I mentioned earlier that it was encouraged to use the literal form. Let's just look at why. So we saw earlier that there is an array constructor. Let's just remind ourselves what that looks like. The array constructor receives an argument, and that argument is the number of items that we want the array to have. So in this case, we have specified that we want to create an array with one item in it. So at this point, the myArray variable contains an array which has one value. Now the constructor doesn't let us specify what that value is. And so, when we use the array constructor, the values inside the array will be initialized as undefined. This is why it is recommended to use the literal form. In this case, we’ve also created a new array that has a single value, but instead of that value being undefined, we’ve given it a string value. This is why it is recommended to always create arrays using the array literal form rather than the array constructor to avoid having an array full of undefined values. Arrays do have an upper limit on the maximum number of elements that we can store in them. But this limit is so high that for all intents and purposes, we can assume that they have an unlimited capacity. To add multiple items to an array, we just separate them with commas. Arrays use numerical indexes to address the elements within them. And these indexes always start at zero. So the first element in the array is at index zero, the second is at index one, and so on and so forth. To access an individual array element, we also use square brackets and specify the index of the element that we would like to get. So by specifying the index 1, we will get access to the second element in the array. An array's length is always one greater than the index of its last element. So if we want to get the last element in an array and we don't know how many elements there are inside it, we can do this. In this case, we get the same value that we got before, but if there were more elements inside the array, this would give us the last one. We don't have to know how many items there are in the array in order to add new items to it. For example, In this case, the array will have 100 values, but all of the values in between the first two values that we gave the array when we declared it, and the one-hundredth item that we just added. All of the values in between those values will undefined. They'll still exist, but they'll be undefined. So in these lesson we've learned some of the basics of arrays in JavaScript. We've seen that we should declare arrays using the literal syntax. And we've seen we can access individual elements with in an array using square brackets and the numerical index of the element that we want to get. We've also seen that we can add new items to the array by specifying the index that we'd like the new value to be inserted at and using the assignment operator. Arrays are capable of a lot more functionality, and we'll come back and look at them in much more detail later in the course. In the next lesson, we can take a look at another fundamental concept of JavaScript, objects. Thanks for watching.

Back to the top