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

Next lesson playing in 5 seconds

Cancel
  • Overview
  • Transcript

6.8 Default and Rest Parameters

In this lesson, we can take a look at two additional function features, both to do with parameters: default parameters and rest parameters.

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


6.8 Default and Rest Parameters

Hi folks, in this session, we're going to learn about a couple of features that we have with regards to function parameters. These features are called Default Parameters and Rest Parameters. Let's start out by looking at default parameters. Default parameters are a way to specify a value for a parameter when that parameter doesn't get past as an argument to the function when the function gets invoked. So we specify the default value for a parameter when defining the function. We use assignments within the function's parameter list to specify the default value for the parameter. When we invoke the function, if we don't pass a value or if we pass undefined, the default value will be used. If we do supply a value for the parameter, as an argument, it will overwrite the default. So we can see the first time the function gets invoked and we don’t pass an argument, it uses the default value of the parameter. But when we invoke it a second time and we do pass a value in, that value then overrides the default. We can use default parameters with function expressions as well as regular functions like this, and we can specify multiple default parameters. We can even use the default value of one parameter as part of an expression for another default parameter. Let's change the example code to add a second default parameter that makes use of the first one. And let's update the log message inside the function. So we've added a new invocation of our function as well, just with some different parameters there so we can see the different behavior. So you can see the different variations and the different arguments that we were passing when we invoke the function and how that interacts with the default parameters. So let's move on to look at rest parameters now. We looked at the spread operator right back near the start of the course. We can also use the spread operator in a functions parameter list. And when we do this, the arguments are received as an array rather than an array like object, like the arguments object. So let's create a new function now. So we can now invoke this function with any number of string arguments and the function will join them all together, And actually there's a syntax error, I've missed a parentheses. Let's just add that inside the function. And instead of just joining all of the strings together, let's add a space in between them. Okay, so let's just take a look at the output and that's probably what we were expecting. So the reason why rest parameters are awesome is because for many years we've had to endure the fact that while the argument subject looks like an array, it isn't an array and so we can't actually use array methods like join with it. So let's just illustrate this point by changing the console log. So remember the arguments objects is available within all functions, and it is an array like collection, but it's not a true array. And we see that it's not a true array because we see an error in the console if we try to use array methods, such as join on an array like object. So that's really why rest params are so awesome, just because we've had to do without them for so long and now they're finally here. Previously we might have had to convert arguments into an array somehow. And although that wasn't particularly difficult it was an extra thing that we would have to do inside functions if we wanted to treat the arguments object as if it were a true array. So now we don't have to do any of that messing about stuff. We can just use a rest param. So in this lesson, we learned about default parameters and rest parameters. We saw the default parameters are simply a way to specify a default value for a function parameter, which we do in the parameter list when we declare the function. When the function is invoked, if an argument isn't passed, the default parameter value will be used instead. We also saw that rest parameters are a way to use an arbitrary number of arguments passed to a function as a true array, rather than as an array like objects, like the argument's objects. So this now brings us to the end of the section on functions. In the next section, we'll move on to look at some miscellaneous JavaScript features, starting with the structuring assignment. Thanks for watching.

Back to the top
View on GitHub