ENDS 12/4: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn about objects and arrays in PowerShell, including usage and creation.

Objects and Arrays

Some of the operators that work on variables also work on arrays. Let’s start with addition.

##### Adding Arrays
The addition operator `+` concatenates – or combines – two arrays.
```PowerShell
PS > $fibonacci = 0, 1, 1, 2, 3, 5
PS > $fib_2 = 8, 13, 21, 34
PS > $fibonacci + $fib_2
0
1
1
2
3
5
8
13
21
34
```

##### Multiplying Arrays
The multiplication operator `*` copies the array a specified number of times.
```PowerShell
PS > $fib_2 * 2
8
13
21
34
8
13
21
34
```

We could also use the addition `+=` or multiplication `*=` assignment operators to assign the resulting array back to the main array. 

##### Containment Operators
Containment operators check whether or not an item is in an array and returns a boolean. There are four operators:
- `-contains`: `<array> -contains <item>`
- `-notcontains`: `<array> -notcontains <item>`
- `-in`: `<item> -in <array>`
- `-notin`: `<item> -notin <array>`

Let’s look at a few examples:
```PowerShell
PS > $fibonacci -contains 4
False
PS > 5 -in $fibonacci
True
```

The `-contains` and `-in` operators do not differ in functionality, only the order of the operands.

##### `-join`
The `-join` operator combines the items in an array into a string separated by a character or a string. Consider the following example:
```PowerShell
PS > $fibonacci = 0, 1, 1, 2, 3, 5
PS > $fibonacci = $fibonacci -join "->"
PS > $fibonacci
0->1->1->2->3->5
PS > $fibonacci.GetType().Name
String
```

##### Strongly Typed Arrays
Similar to how we can force a type on a variable to create constrained variables. We can force a type onto an array so that each item has to adhere to that type. For example, if we wanted to force an array only to have strings, we can use the following notation:
```PowerShell
PS > [String[]]$fruits = "apple", "banana", "kiwi"
```

##### Arrays of Objects
Arrays can hold objects too! Consider the following array:
```PowerShell
$dogs_arr = @(
    [PSCustomObject]@{Name = 'Rufus'; Age = 10}
    [PSCustomObject]@{Name = 'Miku'; Age = 2}
)
```

We utilize the multiline format of creating an array and hashtables to populate the array with `dog` objects. We can then access objects individually, including their properties and methods.
```PowerShell
PS > $dogs_arr.ForEach({ $_.Name + " is " + $_.Age + " years old."})
Rufus is 10 years old.
Miku is 2 years old.
```

Operators for Arrays

Now that we are familiar with what an object is, what it's made up of – properties and methods – and how we can work with them, it's time to create our own objects! 

To create an object, we use the `New-Object` cmdlet like so:
```PowerShell
$dog = New-Object -TypeName PSCustomObject
```

The `-TypeName PSCustomObject` means the object has the type of `PSCustomObject`, a class used for creating custom objects. 

![Screenshot of a PowerShell terminal in which Get-Member cmdlet is run on the dog object. The output shows four pre-defined methods.](https://static-assets.codecademy.com/Courses/learn-powershell/Creating-Objects-1.png)

By default, the new `dog` custom object has no properties and four methods.

##### Adding Properties
With the object created, we can now use the `Add-Member` cmdlet to add methods and properties. We must specify the type of member we wish to add. 

In the case of a property with key-value pair, we use a `NoteProperty`. Consider the example below.
```PowerShell
$dog | Add-Member -MemberType NoteProperty -Name "Name" -Value "Rufus"
$dog | Add-Member -MemberType NoteProperty -Name "Age" -Value 10
```

Our custom `dog` object now has two properties:
1. `Name` with the string value of `Rufus`
2. `Age` with the integer value of `10`

##### Adding Methods
The syntax for adding a method is very similar to that of properties. However, for the `MemberType` parameter, we use `ScriptMethod`. 
```PowerShell
$dog | Add-Member -MemberType ScriptMethod -Name "speak" -Value { Write-Host "Woof!"}
```
Just like a property, we name the method `"speak"` using `-Name`. For `-Value` we enclose a line of code, which outputs the string `Woof!`.

![Screenshot of a PowerShell terminal in which Get-Member cmdlet is run on the dog object. This time, the output includes 2 Note Properties and the speak ScriptMethod. When the speak method is called, the output displays "Woof!".](https://static-assets.codecademy.com/Courses/learn-powershell/Creating-Objects-2.png)

Now we can use the newly created method:
```PowerShell
$dog.speak()
# outputs: Woof!
```

Creating Objects

A newer method of creating a custom object and easily adding properties to it is by using a _hashtable_.

A hashtable holds multiple key-value pairs enclosed in `@{ }`. We can use these pairs to define properties for our custom object. Consider the following syntax:
```PowerShell
$dog = [PSCustomObject]@{
    Name = "Rufus"
    Age = 10
}
```

The `[PSCustomObject]` casts a type onto the hashtable, just as we constrain variables. Creating a custom object this way is identical to the previous object creation process. It is a little less work and supports more readable code.

Creating Objects Using Hashtables

Good job making it to the end of the *Objects and Arrays* lesson! Objects are everywhere in PowerShell, and arrays are one of the most popular data structures in programming. We hope you will feel comfortable when you encounter them.

We learned the following in this lesson:
- PowerShell objects
- Properties and methods of objects
- Creating custom objects using `New-Object` and hashtables
- Adding properties and methods to custom objects
- What arrays are and how to create them in multiple ways
- Accessing and updating array items
- Operators for arrays such as addition `+`, multiplication `*`, containment, and -`join`


Review

PowerShell is an object-oriented scripting language, meaning that much of the data in PowerShell is in the form of an object. In this lesson, we will dive into what an object exactly is, explore the properties and methods that make up an object, and even create our own objects!

In addition to objects, we will introduce a new type of data structure called an array. We will discover how to create, update, and access items from an array and go over the operators we can use to manipulate arrays.

Let’s get started!

Text image with the title, Objects and Arrays, and a quote, Objects are everywhere in PowerShell, and arrays are one of the most popular data structures in programming.

Introduction

*Arrays* are a data structure that holds a collection of items. Items can be of the same type or multiple types. We can think of arrays as a variable that can hold more than one value. Consider the example below:
```PowerShell
$my_arr = 25, "Codecademy", 1, $False
```

`my_arr` is an array that holds the integer `25`, the string `Codecademy`, the integer `1`, and the boolean `False` – in that order. Referencing the variable will output each item one at a time.
```PowerShell
PS > $my_arr
25
Codecademy
1
False
```

Separating items by commas is the simplest way to create an array, but it's not the only way. Another way is to use the array subexpression operator `@( )`. Anything placed within the parentheses is treated as an item of the array. It can be anything from a single element to output from commands. The following examples best illustrate its usage.
```PowerShell
$arr_1 = @($True, 5, (Get-Date).DateTime) # 3 elements
$arr_2 = @( )                             # Empty Array
$arr_3 = @(                               # Multi-line Array
    "Uno"
    "Dos"
    "Tres"
) 
```

In the next exercise, we will go over different ways to access items in an array.

Understanding and Creating Arrays

Methods are another piece of what makes up an object. Methods are the actions we can take on an object, just like how a circle can grow or shrink, or a car can accelerate or brake.

When we use `Get-Member` on a string-type object, we can see several methods available.

##### Object Method: `Contains()`
The `Contains()` method of a string-type object returns a boolean whether or not a string contains the specified substring.
```PowerShell
PS > $my_string = "Codecademy"
PS > $my_string.Contains("Code")
True
```

##### Object Method: `Replace()`
The `Replace()` method of a string-type object replaces the specified substring on a string with another specified substring. It can also be used to delete a substring by replacing it with an empty string.
```PowerShell
PS > $my_string = "Hello, World!"
PS > $my_string.Replace("World", "Codecademy")
Hello, Codecademy!
PS > $my_string.Replace(", World", "")
Hello!
```

##### Object Method: `GetType()`
The `GetType()` method gets the type of an object, and therefore it is not exclusive to just string-type objects. It returns an object with several methods and properties, including the name of the type. 

If we want to get the name of the type, we can access the `Name` property. To print the type of an object, we used `GetType().Name`.
```PowerShell
PS > $num = 4
PS > $num.GetType().Name
Int
```

We encourage you to run `Get-Member -MemberType Method` on all types of objects and learn about their methods with various useful functionalities.

Object Methods

Many shells, such as the Linux Bash shell, have limited capabilities since they focus on strings as output. Plaintext output forces us to use other commands for additional functionality, such as formatting and filtering. 

On the other hand, PowerShell is an [object-oriented](https://www.codecademy.com/resources/docs/general/programming-paradigms/object-oriented-programming) shell. Since almost everything in PowerShell is an object, including the output of commands, further data processing is much easier.

An *object* is a combination of variables and functions. Each object has the following:
- **Properties**: variables that describe the object (characteristics)
- **Methods**: functions that describe how to use the object (actions)

Each object is an instance of a blueprint called a *type*, or *[class](https://www.codecademy.com/resources/docs/general/data-structures/class)*. 

Let us describe these terms using a real-world example. Assume we have an object based on an animal called `$dog`. We can describe `$dog` using properties such as `name`, `breed`, `age`, etc. All the actions a dog can perform are methods such as `speak()`, `eat()`, `play()`, etc.

All information associated with an object is called a *member*. We can discover the members of an object with the `Get-Member` cmdlet. It also shows the type of an object. In the following example, the object is a string:
```PowerShell
Get-Member -InputObject "Codecademy"
```

A more common way to use `Get-Member` is by piping an object to `Get-Member` like so:
```PowerShell
"Codecademy" | Get-Member
```
Both approaches produce the same result.

In the following few exercises, we will dive deeper into the properties and methods of objects.

The string Codecademy is pipelined to the Get-Member cmdlet. The output shows many methods and 2 properties.

Understanding Objects

Now that we have an array, how do we access items from it? 

##### Indexing
The easiest way to access an item from an array is to use its index number. An *index* is the position number of an item. Consider the example below:
```PowerShell
$colors = "red", "yellow", "black", "blue"
#.          0       1         2       3
``` 

The numbers underneath the items represent their indices. An array’s indices always start at `0`. If we want to access `black`, for example, we must offset – or skip – `2` times. 
```PowerShell
PS > $colors[2]
black
```
As shown above, the syntax for accessing an array item in PowerShell involves brackets `[ ]`. If we provide an index that is out of bounds, such as `10`, PowerShell will not create an error but instead return `$null`. The `$null` value would result in no output if printed to the terminal but has other behaviors depending on the situation.

Each array object has a `Length` property that gives us the number of items in that array. The property `Count` will return the same value.

##### Updating Items
We can also update items by utilizing indices. To change the color `yellow` to `brown`, for example:
```PowerShell
PS > $colors[1] = "brown"
PS > $colors
red
brown
black
blue
```

##### Special Index Tricks
PowerShell offers much more flexibility when indexing items such as
- Multiple indices: separate indices with commas to print multiple items:
```PowerShell
PS > $colors[0,2]
red
black
```
The example above displays the values at index `0` and `2`.

- Range operator `..`: print all items between two indices:
```PowerShell
PS > $colors[1..3]
brown
black
blue
```
The above example displays the values from index `1` to index `3`.

- Reverse range: use range operator from a higher index to a lower index to print items in reverse order (inclusive)
```PowerShell
PS > $colors[2..1]
black
brown
```
The above example displays the values from index `2` to index `1`.

- Negative indices: items are referenced in reverse order where the last item has index `-1`
```PowerShell
PS > $colors[-1]
blue
```
The above example displays the value in the last index, `3`.

##### Iteration
Each array object has a method called `ForEach` that allows us to perform the same action on each array item. We can use the variable `PSItem` or underscore `_` to refer to each item in the array.
```PowerShell
PS > $colors.ForEach({ $PSItem.Length })
3
5
5
4
```

The example above is printing the length of each string of our `colors` array. `red` has a length of `3`, `brown` is `5`, and so on.

Accessing Array Items

As stated in the previous exercise, properties are characteristics of an object. Just like a radius is an attribute that describes a circle and horsepower describes a car, we have properties that describe an object.

To discover just the properties of an object, we can add `-MemberType Property` to the `Get-Member` cmdlet. For example, consider the string `"hello"`:
```PowerShell
PS > "hello" | Get-Member -MemberType Property

   TypeName: System.String

Name   MemberType Definition
----   ---------- ----------
Length Property   int Length {get;}
```
The example above pipes the string "hello" to `Get-Member -MemberType Property`. As we can see, string-type objects have a property called `Length`, which holds the number of characters in a string, as shown below.
```PowerShell
PS > "hello".Length
5
```