Bharathbol
diff --git a/‎content/powershell/concepts/arrays/arrays.md
Lines changed: 217 additions & 0 deletions b/‎content/powershell/concepts/arrays/arrays.md
Lines changed: 217 additions & 0 deletions
diff --git a/‎content/powershell/concepts/conditionals/conditionals.md
Lines changed: 136 additions & 0 deletions b/‎content/powershell/concepts/conditionals/conditionals.md
Lines changed: 136 additions & 0 deletions
@@ -0,0 +1,217 @@
+---
+Title: 'Arrays'
+Description: 'Arrays are a data structure that holds a collection of items. PowerShell provides many ways to access, update, and manipulate array items.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+  - 'Bash/Shell'
+Tags:
+  - 'Arrays'
+  - 'Data Types'
+  - 'Data Structures'
+  - 'Index'
+  - 'Lists'
+  - 'Operators'
+  - 'Variable Types'
+CatalogContent:
+  - 'learn-powershell'
+  - 'paths/computer-science'
+---
+
+**Arrays** are a [data structure](https://www.codecademy.com/resources/docs/general/data-structures) that holds a collection of items. Items can be of the same type or multiple types.
+
+## Creating an Array
+
+Separating items by commas (`,`) is the simplest way to create an array in PowerShell.
+
+```shell
+$my_arr = 25, "Codecademy", 1, $False
+```
+
+Alternatively, the array subexpression operator `@( )` can be used. Anything placed within the parentheses is treated as an item of the array.
+
+```shell
+$arr_1 = @($True, 5, (Get-Date).DateTime) # 3 elements
+$arr_2 = @( )                             # Empty Array
+$arr_3 = @(                               # Multi-line Array
+    "Uno"
+    "Dos"
+    "Tres"
+)
+```
+
+## Accessing Array Items
+
+The items in an array are accessed using their index, or their position in the array. Consider the array:
+
+```shell
+$colors = "red", "yellow", "black", "blue"
+```
+
+The indexes in PowerShell start at `0`.
+
+| Index |   Value    |
+| :---: | :--------: |
+|  `0`  |  `"red"`   |
+|  `1`  | `"yellow"` |
+|  `2`  | `"black"`  |
+|  `3`  |  `"blue"`  |
+
+Brackets `[ ]` are used to access an item in an array. To access `"black"` in the `$colors` array, for example:
+
+```shell
+PS > $colors[2]
+black
+```
+
+## Updating Array Items
+
+Items can be updated — or changed – by utilizing indexes. To change the color `yellow` to `brown`, for example:
+
+```shell
+PS > $colors[1] = "brown"
+PS > $colors
+red
+brown
+black
+blue
+```
+
+## Indexing
+
+PowerShell offers flexibility when indexing items, such as:
+
+- Multiple indexes: Separate indexes with commas to print multiple items.
+
+```shell
+PS > $colors[0,2]
+red
+black
+```
+
+- Range operator `..`: Print all items between two indexes (exclusive).
+
+> **Note:** This syntax is exclusive since the stop index `3` is not included.
+
+```shell
+PS > $colors[1..3]
+brown
+black
+blue
+```
+
+- Reverse range: Use range operator from a higher index to a lower index to print items in reverse order (inclusive).
+
+> **Note:** This syntax is inclusive since both the start and stop indexes, `2` and `1`, are included.
+
+```shell
+PS > $colors[2..1]
+black
+brown
+```
+
+- Negative indexes: Items are referenced in reverse order where the last item has an index of `-1`.
+
+```shell
+PS > $colors[-1]
+blue
+```
+
+## Iteration
+
+Each array object has a method called `ForEach` which can be utilized to perform the same action on each of its items. PowerShell defines the variable `$PSItem` or just underscore `_` to refer to each item in the array.
+
+```shell
+PS > $colors.ForEach({ $PSItem.Length }) # $_.Length also works
+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.
+
+## Array Operators
+
+### Addition Operator
+
+The addition operator `+` concatenates – or combines – two arrays.
+
+```shell
+PS > $fibonacci_1 = 0, 1, 1
+PS > $fibonacci_2 = 2, 3, 5
+PS > $fibonacci_1 + $fibonacci_2
+0
+1
+1
+2
+3
+5
+```
+
+### Multiplication Operator
+
+The multiplication operator `*` copies the array a specified number of times.
+
+```shell
+PS > $fibonacci_2 * 2
+2
+3
+5
+2
+3
+5
+```
+
+### Containment Operators
+
+Containment operators check whether or not an item is in an array and returns a boolean.
+
+|    Operator    |            Syntax             |                   Example                   |
+| :------------: | :---------------------------: | :-----------------------------------------: |
+|  `-contains`   |  `<array> -contains <item>`   |  `$fibonacci -contains 4` returns `False`.  |
+| `-notcontains` | `<array> -notcontains <item>` | `$fibonacci -notcontains 4` returns `True`. |
+|     `-in`      |     `<item> -in <array>`      |     `5 -in $fibonacci` returns `True`.      |
+|    `-notin`    |    `<item> -notin <array>`    |   `5 -notin $fibonacci` returns `False`.    |
+
+### `-join`
+
+The `-join` operator combines the items in an array into a string separated by a character or a string. Consider the following example:
+
+```shell
+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
+
+Types can be casted onto arrays to force each item in the array to adhere to that type.
+
+```shell
+PS > [String[]]$fruits = "apple", "banana", "kiwi"
+```
+
+## Objects Arrays
+
+Arrays can hold objects.
+
+```shell
+$dogs_arr = @(
+    [PSCustomObject]@{Name = 'Rufus'; Age = 10}
+    [PSCustomObject]@{Name = 'Miku'; Age = 2}
+)
+```
+
+Each object in the array as well as its properties and methods can be accessed individually.
+
+```shell
+PS > $dogs_arr.ForEach({ $PSItem.Name + " is " + $PSItem.Age + " years old."})
+Rufus is 10 years old.
+Miku is 2 years old.
+```
+
+> **Note:** `$PSItem` can be replaced with its shorthand alias `$_`.
@@ -0,0 +1,136 @@
+---
+Title: 'Conditionals'
+Description: 'The if, else, elseif, and switch conditionals in PowerShell are used for control flow. They allow the choice of which sections of code are executed based on conditions.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+  - 'Bash/Shell'
+Tags:
+  - 'Break'
+  - 'Conditionals'
+  - 'Control Flow'
+  - 'Else'
+  - 'If'
+  - 'Switch'
+CatalogContent:
+  - 'learn-powershell'
+  - 'paths/computer-science'
+---
+
+**Conditionals** enable execution of code based on provided conditions. They take in an expression and check if it is `True` or `False`. If the expression is `True`, one set of statements is executed. Otherwise, another set of instructions is performed. This control of flow makes programs more robust by enabling them to address multiple scenarios.
+
+There are four types of conditional statements in PowerShell:
+
+1. `if`
+2. `else`
+3. `elseif`
+4. `switch`
+
+## if
+
+The `if` statement executes a block of code if the condition expression is `True`.
+
+```shell
+$my_num = 2
+if($my_num -eq 2){
+  Write-Host "A True Statement"
+}
+Write-Host "After the if statement"
+```
+
+The example above prints `"A True Statement"` and `"After the if statement"` if `$my_num` is equal to `2`. Otherwise, it skips the statement within the `if` curly braces `{ }` and just prints `"After the if statement"`.
+
+## else
+
+The `else` clause always follows the `if` statement.
+
+- If the condition is `True`, the code in the `if` section is executed.
+- If the condition is `False`, the code in the `else` section is executed.
+
+```shell
+$my_num = 2
+if($my_num -gt 0) {
+  Write-Host "A positive number" # Prints if $my_num is more than 0
+}
+else {
+  Write-Host "A negative number" # Prints if $my_num is less than or equal to 0
+}
+```
+
+## elseif
+
+One or more `elseif` statements can be added between `if` and `else` to test multiple conditions.
+
+```shell
+$my_num = 2
+if($my_num -gt 0) {
+  Write-Host "A positive number" # Prints if $my_num is more than 0
+}
+elseif ($my_num -lt 0) {
+  Write-Host "A negative number" # Prints if $my_num is less than 0
+}
+else {
+  Write-Host "Zero"              # Prints if both of the previous conditions fail
+}
+```
+
+## switch
+
+The `switch` statement provides a simpler syntax for the same behavior as `if` / `elseif` expressions that check for equality.
+
+```shell
+$my_num = 2
+switch ($my_num) {
+  1 {
+    Write-Host "You chose 1"
+  }
+  2 {
+    Write-Host "You chose 2"
+  }
+  3 {
+    Write-Host "You chose 3"
+  }
+  default {
+    Write-Host "No match"
+  }
+}
+```
+
+The example above prints `"You chose 2"`. If `$my_num` was `4`, for example, it would print `"No match"` since the `default` clause is run if all other conditions fail.
+
+PowerShell allows conditional expressions to be used in `switch` statements.
+
+```shell
+$my_num = 10
+switch ($my_num) {
+  {$PSItem -gt 5} {
+    Write-Host "Greater than 5"
+  }
+  {$PSItem -gt 0} {
+    Write-Host "Greater than 0"
+  }
+  {$PSItem -lt 5} {
+    Write-Host "Less than 5"
+  }
+}
+```
+
+> **Note:** `$PSItem` is an automatic variable that contains the value passed to the `switch` statement. It can be replaced with its shorthand alias `$_`.
+
+The above example prints `"Greater than 5"` and `"Greater than 0"` since their corresponding conditions are `True`. Even if a condition is `True`, the following conditions are still tested unless a `break` statement is provided, as in the example below which only prints `"Greater than 5"`.
+
+```shell
+$my_num = 10
+switch ($my_num) {
+  {$_ -gt 5} {
+    Write-Host "Greater than 5"
+    break
+  }
+  {$_ -gt 0} {
+    Write-Host "Greater than 0"
+  }
+  {$_ -lt 5} {
+    Write-Host "Less than 5"
+  }
+}
+```