```
⚠️ **Caution:** `eval()` can execute arbitrary code, so use it carefully.
{% endtab %}
{% tab title="PowerShell" %}
**Basic Type Conversion**
| Description | Code Examples |
| -------------------------------- | --------------------------------------- |
| Convert string to integer | `[int]"42"` → `42` |
| Convert string to float | `[double]"3.14"` → `3.14` |
| Convert integer to string | `[string]42` → `"42"` |
| Convert ASCII value to character | `[char]65` → `'A'` |
| Convert boolean to integer | `[int]$true` → `1`, `[int]$false` → `0` |
***
**Collection Type Conversion**
| Description | Code Examples |
| ------------------------- | -------------------------------------------------- |
| Convert string to array | `@("Hello", "World")` |
| Convert list to hashtable | `@{Key1="Value1"; Key2="Value2"}` |
| Convert array to string | `-join @("Hello", "World")` becomes `"HelloWorld"` |
***
**Advanced Explicit Type Casting**
| Description | Code Examples |
| ------------------------ | ------------------------------------------------- |
| Force integer conversion | `[int]"3.9"` (becomes `3` i.e. truncates decimal) |
| Convert object to XML | `[xml]$xmlString` |
| Convert object to JSON | `$object \| ConvertTo-Json` |
| Convert JSON to object | `$json \| ConvertFrom-Json` |
***
**Handling Type Conversion Errors**
Use `try-catch` blocks to handle conversion errors gracefully.
```powershell
try {
$num = [int]"hello" # Invalid conversion
} catch {
Write-Output "Error: Cannot convert 'hello' to an integer."
}
```
***
**Potential Pitfalls**
Similar to Python, there are a number of potential pitfalls to be aware of when comverting between different data types:
* 🚨 **Loss of Precision:** Converting floats to integers removes decimals.
* 🚨 **Unexpected Boolean Behavior:** Non-empty strings evaluate as `$true`.
* 🚨 **Implicit Conversions:** Mixing types can lead to unintended results.
PowerShell’s type conversion system is powerful but requires careful handling to avoid unexpected behavior.
You can explore more details on PowerShell type conversion [here](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_type_conversion?view=powershell-7.5) and [here](https://adamtheautomator.com/powershell-convert-string-to-int/).
{% endtab %}
{% tab title="Bash" %}
Bash scripting does not have built-in type casting like some other languages, but it provides ways to convert and manipulate data types using arithmetic operations, commands, and built-in functions. Bash’s type conversion typically relies on **workarounds** and external tools like `bc`, `awk`, and `jq`.
***
**Basic Type Conversion**
| Description | Code Examples |
| ------------------------------------ | -------------------------------------------------- |
| Convert string to integer | `num=$(( "42" ))` → `42` |
| Convert string to float (using `bc`) | `echo "3.14" \| bc` → `3.14` |
| Convert integer to string | `str="$num"` → `"42"` |
| Convert ASCII value to character | `printf \\$(printf '%o' 65)` → `'A'` |
| Convert boolean-like values | `[[ -n "$var" ]] && echo "True" \|\| echo "False"` |
***
**Collection Type Conversion**
| Description | Code Examples |
| ---------------------------------- | ----------------------------------------------- |
| Convert string to array | `IFS="," read -ra arr <<< "apple,banana,grape"` |
| Convert array to string | `echo "${arr[*]}"` → `"apple banana grape"` |
| Convert list to associative array | `declare -A myDict; myDict[key]="value"` |
| Convert array to JSON (using `jq`) | `echo '{"name":"Alice","age":30}' \| jq` |
***
**Explicit Type Casting**
| Description | Code Examples |
| ----------------------------------- | -------------------------------------------- |
| Force integer conversion | `num=$(( "3.9" ))` → `3` (truncates decimal) |
| Convert object to JSON (using `jq`) | `echo '{"name":"Alice"}' \| jq` |
| Convert JSON to object (using `jq`) | `echo '{"name":"Alice"}' \| jq -r '.name'` |
***
**Handling Type Conversion Errors**
Use regex to validate integer conversions before processing.
```bash
if [[ "$var" =~ ^[0-9]+$ ]]; then
echo "Valid integer: $var"
else
echo "Error: Not a number"
fi
```
***
**Potential Pitfalls**
* 🚨 **Loss of Precision:** Bash does not support floating-point arithmetic natively.
* 🚨 **Unexpected Boolean Behavior:** Non-empty strings evaluate as `true`.
* 🚨 **Implicit Conversions:** Mixing types can lead to unintended results.
You can explore more details on Bash type conversion [here](https://stackoverflow.com/questions/11268437/how-to-convert-string-to-integer-in-unix-shelll) and [here](https://1library.net/article/type-casting-unix-shell-scripting.yex493rq).
{% endtab %}
{% tab title="CMD .bat" %}
Windows Batch scripting does not have built-in type casting like higher-level languages, but it provides ways to **convert and manipulate data types** using arithmetic operations and string manipulation.
***
**Basic Type Conversion**
| Description | Code Examples |
| -------------------------------- | ---------------------------------------------------------- |
| Convert string to integer | `set /A num="42"` → `42` |
| Convert integer to string | `set str=%num%` → `"42"` |
| Convert ASCII value to character | `for /F %%A in ('cmd /c echo 65') do set char=%%A` → `'A'` |
| Convert boolean-like values | `if "%var%"=="" (echo False) else (echo True)` |
***
**Collection Type Conversion**
| Description | Code Examples |
| ----------------------------------------- | ----------------------------------- |
| Convert comma-separated string to array | `for %%A in (%list%) do echo %%A` |
| Convert array to string | `set str=%array[*]%` |
| Convert list to dictionary-like structure | `set key1=value1 & set key2=value2` |
***
**Handling Type Conversion Errors**
Uses error redirection (`2>nul`) to handle conversion errors gracefully.
```bat
@echo off
set var=hello
set /A num=%var% 2>nul
if "%num%"=="" echo "Error: Cannot convert '%var%' to an integer."
```
***
**Potential Pitfalls**
* 🚨 **Loss of Precision:** Batch does not support floating-point arithmetic natively.
* 🚨 **Unexpected Boolean Behavior:** Non-empty strings evaluate as `true`.
* 🚨 **Implicit Conversions:** Mixing types can lead to unintended results.
You can explore more details on Batch type conversion [here](https://stackoverflow.com/questions/25166704/convert-a-string-to-integer-in-a-batch-file) and [here](https://stackoverflow.com/questions/14475829/convert-a-string-to-number).
{% endtab %}
{% endtabs %}
### Arrays
{% tabs %}
{% tab title="Python" %}
Python does not have built-in support for Arrays as so termed, but Python **Lists** and **Tuples** can be used instead, and work much in the same way.
**Working with Lists in Python**
| Activity | Code Examples |
| ------------------------------- | -------------------------------------------------------- |
| **Define** | `arr = ['Hello', 'World']` |
| **Access Elements** | `arr[0]` → `'Hello'` |
| **Get Length** | `len(arr)` → `2` |
| **Add Elements** | `arr.append('New')` → `['Hello', 'World', 'New']` |
| **Insert at Specific Position** | `arr.insert(1, 'there')` → `['Hello', 'there', 'World']` |
| **Remove Last Element** | `arr.pop()` → `['Hello']` |
| **Remove Specific Index** | `arr.pop(1)` → `['Hello']` |
| **Remove Element by Value** | `arr.remove('Hello')` → `['World']` |
| **Sort Elements** | `arr.sort()` (Alphabetical order) |
| **Reverse Elements** | `arr.reverse()` → `['World', 'Hello']` |
| **Check if Element Exists** | `'Hello' in arr` → `True` |
| **Loop Through Elements** | `for item in arr: print(item)` |
| **Copy List** | `copy_arr = arr.copy()` |
| **Concatenate Lists** | `new_arr = arr + ['Python', 'Rocks']` |
| **Convert List to String** | `', '.join(arr)` → `'Hello, World'` |
| **Convert String to List** | `arr = 'Hello World'.split()` → `['Hello', 'World']` |
**Looping Through Lists**
```python
arr = ['apple', 'banana', 'cherry']
for item in arr:
print(item) # Outputs each fruit
```
**Filtering Elements in a List**
```python
arr = [1, 2, 3, 4, 5]
filtered = [x for x in arr if x > 2]
print(filtered) # Output: [3, 4, 5]
```
***
**Nested Lists**
| Description | Code Example |
| ------------------------- | --------------------------------------------------------------------------------------- |
| Define a nested list | `nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]` |
| Access an element | `nested_list[1][2]` → `6` |
| Loop through nested lists | `for sublist in nested_list: print(sublist)` |
| Flatten a nested list | `[item for sublist in nested_list for item in sublist]` → `[1, 2, 3, 4, 5, 6, 7, 8, 9]` |
**Tuples**
A **tuple** is an ordered collection of items, similar to a **list**, but with one key difference—**tuples are immutable**. This means once a tuple is created, its contents **cannot be changed**, added to, or removed.
***
**Key Differences Between Lists and Tuples**
| Feature | List (`list`) | Tuple (`tuple`) |
| ---------------- | -------------------------------------------- | ------------------------------------------ |
| **Mutability** | ✅ Mutable (can modify, add, remove elements) | ❌ Immutable (cannot change after creation) |
| **Syntax** | Defined using `[]` (square brackets) | Defined using `()` (parentheses) |
| **Performance** | Slower due to dynamic resizing | Faster due to fixed structure |
| **Memory Usage** | Uses more memory | Uses less memory |
| **Intended Use** | Dynamic, frequently modified data | Static, unchangeable data |
***
**Defining a List and a Tuple**
```python
# List (Can be modified)
my_list = ["apple", "banana", "cherry"]
my_list.append("date") # Adding a new element
print(my_list) # Output: ['apple', 'banana', 'cherry', 'date']
# Tuple (Cannot be modified)
my_tuple = ("apple", "banana", "cherry")
# my_tuple.append("date") # ❌ This will raise an error!
print(my_tuple) # Output: ('apple', 'banana', 'cherry')
```
**Nested Tuples**
| Description | Code Example |
| ----------------------------- | ----------------------------------------------- |
| Define a nested tuple | `nested_tuple = ((1, 2), (3, 4), (5, 6))` |
| Access an element | `nested_tuple[2][1]` → `6` |
| Iterate through nested tuples | `for subtuple in nested_tuple: print(subtuple)` |
**When to Use Tuples vs. Lists**
* **Use a List** when you need a **dynamic** data structure that will change during program execution.
* **Use a Tuple** when you need a **fixed, unchangeable collection** (e.g., **coordinates, config settings, database records**).
{% endtab %}
{% tab title="PowerShell" %}
**Arrays in PowerShell**
**Arrays** are fixed-size collections used to store ordered data. They allow indexed access but cannot dynamically resize. Arrays are ideal for storing structured lists that don’t change frequently.
| Activity | Code Examples |
| --------------------------- | ------------------------------------------------- |
| **Define an Array** | `$arr = @('Hello', 'World')` |
| **Access Elements** | `$arr[0]` → `'Hello'` |
| **Get Length** | `$arr.Length` → `2` |
| **Add Elements** | `$arr += 'New'` → `@('Hello', 'World', 'New')` |
| **Remove Last Element** | `$arr = $arr[0..($arr.Length - 2)]` |
| **Remove Specific Index** | `$arr = $arr \| Where-Object {$_ -ne 'World'}` |
| **Sort Elements** | `$arr = $arr \| Sort-Object` |
| **Reverse Elements** | `$arr = $arr \| Sort-Object -Descending` |
| **Check if Element Exists** | `if ('Hello' -in $arr) { Write-Output 'Exists' }` |
| **Loop Through Elements** | `foreach ($item in $arr) { Write-Output $item }` |
***
**ArrayLists in PowerShell**
**ArrayLists** are dynamically resizable collections, making them more flexible than arrays. They allow elements to be added or removed without needing to reassign the entire structure, which is useful for scripts handling dynamic data.
| Activity | Code Examples |
| ----------------------- | -------------------------------------------------------------- |
| **Define an ArrayList** | `$arrList = [System.Collections.ArrayList]@('Hello', 'World')` |
| **Add Elements** | `$arrList.Add('New')` |
| **Remove Elements** | `$arrList.Remove('Hello')` |
| **Remove by Index** | `$arrList.RemoveAt(1)` |
| **Sort Elements** | `$arrList.Sort()` |
| **Reverse Elements** | `$arrList.Reverse()` |
***
**Tuples in PowerShell**
**Tuples** store multiple values in a single object, maintaining a fixed structure. Unlike arrays or ArrayLists, tuples are immutable, meaning their values cannot be changed after creation. They are ideal for grouping related values when modification isn’t needed.
| Activity | Code Examples |
| ----------------------------- | ----------------------------------------------------- |
| **Define a Tuple** | `$tuple = [Tuple]::Create('Alice', 30, 'Engineer')` |
| **Access Elements** | `$tuple.Item1` → `'Alice'` |
| **Tuple with Multiple Types** | `$tuple = [Tuple[int, string]]::Create(42, 'Answer')` |
***
**Choosing Between Arrays, ArrayLists, and Tuples**
| Feature | Arrays | ArrayLists | Tuples |
| ----------------- | ------------------ | ------------------------ | --------------------- |
| **Mutability** | ❌ Fixed size | ✅ Dynamic resizing | ❌ Immutable |
| **Performance** | ✅ Fast | ❌ Slower due to resizing | ✅ Fast |
| **Best Use Case** | Static collections | Dynamic lists | Fixed structured data |
| | | | |
| {% endtab %} | | | |
{% tab title="Bash" %}
**Basic Array Operations in Bash**
| Description | Code Example |
| ----------------------------------------------------------------------------- | ---------------------------------------------------------------- |
| **Define an Array:** Creates an array with multiple values. | `arr=("Hello" "World")` |
| **Access Elements:** Retrieves an element by index. | `echo ${arr[0]}` → `"Hello"` |
| **Get Array Length:** Gets the number of elements in the array. | `echo ${#arr[@]}` → `2` |
| **Add Elements:** Appends new elements to the array. | `arr+=("NewElement")` |
| **Insert at Specific Index:** Adds an element at a specific position. | `arr=( "${arr[@]:0:1}" "Insert" "${arr[@]:1}" )` |
| **Remove Elements by Index:** Deletes an element from the array. | `unset arr[1]` |
| **Remove Elements by Value:** Searches and removes elements matching a value. | `arr=( "${arr[@]/"World"}" )` |
| **Loop Through an Array:** Iterates over array elements. | `for item in "${arr[@]}"; do echo "$item"; done` |
| **Check if Element Exists:** Searches an array for a specific value. | `[[ "Hello" == "${arr[*]}" ]] && echo "Exists"` |
| **Concatenate Arrays:** Merges multiple arrays into one. | `arr3=( "${arr1[@]}" "${arr2[@]}" )` |
| **Sort an Array:** Sorts array elements alphabetically. | `IFS=$'\n' sorted=($(sort <<<"${arr[*]}")); echo "${sorted[@]}"` |
| **Reverse an Array:** Prints elements in reverse order. | `for ((i=${#arr[@]}-1; i>=0; i--)); do echo "${arr[i]}"; done` |
| **Convert Array to String:** Joins array elements into a single string. | `echo "${arr[*]}"` |
| **Convert String to Array:** Splits a string into an array. | `IFS="," read -r -a arr <<< "Hello,World"` |
**Advanced Bash Array Operations**
| Description | Command |
| ------------------------------------------------------------ | --------------------------------------------------------------------- |
| Access the **first** element in the array. | `${arr[0]}` |
| Access the **last** element in the array. | `${arr[-1]}` |
| Print **all elements**, space-separated. | `${arr[@]}` |
| Get the **total number of elements** in the array. | `${#arr[@]}` |
| Get the **string length** of the first element. | `${#arr}` |
| Get the **string length** of the fourth element (index `3`). | `${#arr[3]}` |
| Extract a **subarray** (starting at index `3`, length `2`). | `${arr[@]:3:2}` |
| Print all **keys (indices)** of the array, space-separated. | `${!arr[@]}` |
| Convert a **comma-separated string** into an array. | `IFS="," read -r -a new_arr <<< "One,Two,Three"` |
| Convert an **array to a comma-separated string**. | `echo "${arr[*]}" \| tr ' ' ','` |
| Sort an array **alphabetically**. | `sorted=($(for val in "${arr[@]}"; do echo "$val"; done \| sort))` |
| Print an array **in reverse order**. | `for ((i=${#arr[@]}-1; i>=0; i--)); do echo "${arr[i]}"; done` |
| **Search for a pattern** in the array elements. | `for i in "${arr[@]}"; do echo "$i" \| grep "pattern"; done` |
| **Remove elements** matching `"unwanted"` from the array. | `filtered=($(echo "${arr[@]}" \| tr ' ' '\n' \| grep -v "unwanted"))` |
| Load an array **from a file** line by line. | `mapfile -t arr < file.txt` |
**Bash Array Manipulation**
| Description | Command |
| --------------------------------------------------------------- | ------------------------------------------- |
| **Push** (Add an element to the array) | `Numbers=("${Numbers[@]}" 99)` |
| **Also Push** (Alternate way to add an element) | `Numbers+=('42')` |
| **Remove by Regex Match** (Removes elements matching a pattern) | `Words=( ${Words[@]/Te*/} )` |
| **Remove One Item** (Delete element at index `2`) | `unset Names[2]` |
| **Duplicate** (Create a copy of the array) | `Cities=("${Cities[@]}")` |
| **Concatenate** (Merge two arrays) | `Items=("${Fruits[@]}" "${Vegetables[@]}")` |
| **Read from File** (Store lines of a file into an array) | `logs=($(cat "system.log"))` |
**Iteration**
You can iterate through all of the items in an array to do some action on all them with a `for` loop.
```bash
for i in "${arrayName[@]}"; do
echo $i
done
```
**Advanced Bash Array Manipulation**
**Sorting an Array**
Sorting an array in Bash requires using the `sort` command to preserve the array structure.
```bash
arr=("banana" "apple" "cherry")
IFS=$'\n' sorted=($(sort <<<"${arr[*]}"))
unset IFS
echo "${sorted[@]}" # Output: apple banana cherry
```
* **Uses `IFS` to handle spaces properly.**
* **Sorts elements alphabetically.**
***
**Filtering an Array**
Filtering an array involves removing unwanted elements using `grep` or `awk`.
```bash
arr=("apple" "banana" "cherry" "grape")
filtered=($(echo "${arr[@]}" | tr ' ' '\n' | grep -v "banana"))
echo "${filtered[@]}" # Output: apple cherry grape
```
* **Removes `"banana"` from the array dynamically.**
* **Uses `grep -v` to exclude elements.**
***
**Multi-Dimensional Arrays in Bash**
Bash does not support true multi-dimensional arrays, but associative arrays (See Dictionaries) can simulate them.
```bash
declare -A matrix
matrix[0,0]="A"
matrix[0,1]="B"
matrix[1,0]="C"
matrix[1,1]="D"
echo "${matrix[0,1]}" # Output: B
```
* **Uses associative arrays (`declare -A`) to store matrix-like data.**
* **Access elements using `key,value` pairs.**
***
**Reversing an Array**
Print elements in reverse order dynamically.
```bash
arr=("one" "two" "three")
for ((i=${#arr[@]}-1; i>=0; i--)); do
echo "${arr[i]}"
done
```
{% endtab %}
{% tab title="CMD.bat" %}
**Using Arrays in Batch Scripts**
Batch scripting does not have built-in array support like other programming languages, but arrays can be simulated using indexed variables and loops.
**Limitations of Arrays in Batch**
* **Each element is stored as a separate variable** using indexed names (`arr[0]`, `arr[1]`, etc.).
* **Loops are required** to iterate through array elements.
* **Elements must be manually managed**, including adding, removing, and modifying values.
* **Limited functionality compared to other scripting languages**, but useful for handling lists of data.
***
**Batch Script Arrays**
| Activity | Code Examples |
| ----------------------------- | ------------------------------------------------------------------------------------------- |
| **Define an Array** | `set arr[0]=Hello` |
| **Access Elements** | `echo %arr[0]%` |
| **Get Length** | `set count=0 & for /L %%i in (0,1,9) do if defined arr[%%i] set /A count+=1 & echo %count%` |
| **Adding Elements** | `set arr[1]=World` |
| **Appending Elements** | `set arr[%count%]=NewItem` (Using a counter to add dynamically) |
| **Removing Elements** | `set arr[1]=` (Clears the value but does not shift indices) |
| **Remove Element by Value** | `for /F "tokens=*" %%i in ('set arr') do if not "%%i"=="World" echo %%i` |
| **Iterate Over Array** | `for /L %%i in (0,1,%count%) do echo !arr[%%i]!` |
| **Check if Element Exists** | `if defined arr[2] echo "Exists"` |
| **Concatenate Arrays** | `set arr[0]=Hello & set arr[1]=World & set arr[2]=Batch` |
| **Sort Elements** | `for /F "tokens=*" %%A in ('set arr') do echo %%A \| sort` |
| **Reverse Elements** | `for /L %%i in (%count%,-1,0) do echo !arr[%%i]!` |
| **Read from File into Array** | `for /F "tokens=*" %%A in (data.txt) do set arr[%count%]=%%A & set /A count+=1` |
***
**Example: Iterating Over an Array**
```batch
@echo off
setlocal enabledelayedexpansion
set arr[0]=Apple
set arr[1]=Banana
set arr[2]=Cherry
for /L %%i in (0,1,2) do (
echo !arr[%%i]!
)
```
* Batch arrays require **manual management**, but they are useful for handling lists of data in automation scripts.
* Each element of the array needs to be defined with the set command.
* A `for` loop is required to iterate through the values of the array.
* Use `enabledelayedexpansion` to handle dynamic variables.
**Alternative Array Definition**
Another way to implement arrays is to define a space-separated list of values.
```bat
@echo off
set list = 1 2 3 4
(for %%a in (%list%) do (
echo %%a
))
```
**Accessing Array Values**
You can retrieve a value from the array by using subscript syntax, passing the index of the value you want to retrieve within square brackets immediately after the name of the array.
```bat
@echo off
set a[0]=1
echo %a[0]%
```
**Modifying an Array**
To add an element to the end of the array, you can use the `set` command along with the new final index of the array element. There is no append function as in other languages.
```bat
@echo off
set a[0] = 1
set a[1] = 2
set a[2] = 3
Rem Adding an element at the end of an array
Set a[3] = 4
echo The last element of the array is %a[3]%
```
You can also modify an existing element of an Array by assigning a new value at a given index.
```bat
@echo off
set a[0] = 1
set a[1] = 2
set a[2] = 3
Rem Setting the new value for the second element of the array
Set a[1] = 5
echo The new value of the second element of the array is %a[1]%
```
**Iterating Over an Array's values**
Iterating over an array is achieved by using a `for` loop and stepping through each element of the array.
```bat
@echo off
setlocal enabledelayedexpansion
set category[0] = fruits
set category[1] = vegetables
set category[2] = dairy
set category[3] = grains
set category[4] = protein
for /l %%i in (0,1,4) do (
echo !category[%%i]!
)
```
**Notes:**
* Each element of the array needs to be specifically defined using the `set` command.
* A `for` loop with the `/L` parameter iterates through a sequence of values, allowing traversal of the array-like list.
**Length of an Array**
The length of an array is found by iterating over the list of values in the array since there is no direct function to determine the number of elements in an array.
```bat
@echo off
set Arr[0] = 1
set Arr[1] = 2
set Arr[2] = 3
set Arr[3] = 4
set "x = 0"
:LenLoop
if defined Arr[%x%] (
call echo %%Arr[%x%]%%
set /a "x+=1"
GOTO :LenLoop
)
echo "The length of the array is" %x%
```
{% endtab %}
{% endtabs %}
### Conditionals
{% tabs %}
{% tab title="Python" %}
| Switch | Code Examples |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| If / ElseIf / Else | a = 42
b = 420
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
|
| Case | |
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Switch | Code Examples |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| If / ElseIf / Else | a = 42
b = 420
if b > a:
print("b is greater than a")
elif a == b:
print("a and b are equal")
else:
print("a is greater than b")
|
| Case | |
| | |
| {% endtab %} | |
{% tab title="Bash" %}
**Case/switch**
```bash
case "$1" in
start | up)
vagrant up
;;
*)
echo "Usage: $0 {start|stop|ssh}"
;;
esac
```
```bash
# String
if [[ -z "$string" ]]; then
echo "String is empty"
elif [[ -n "$string" ]]; then
echo "String is not empty"
else
echo "This never happens"
fi
```
{% endtab %}
{% tab title="CMD.bat" %}
| Switch | Code Examples |
| ------------------ | ------------------------------------------------------- |
| If / ElseIf / Else | `if "%var%"=="value" (echo Match) else (echo No Match)` |
| Case | `REM Not natively supported in CMD` |
The first decision-making statement is the 'if' statement. The general form of this statement is as follows:
```bash
if(condition) do_something
```
First, a condition is evaluated in the 'if' statement. If the condition is true, it then executes the statements.
#### Checking Variables
One of the common uses for the 'if' statement in Batch Script is for checking variables which are set in the Batch Script itself. The evaluation of the 'if' statement can be done for both strings and numbers.
**Checking Integer Variables**
The following example shows how the 'if' statement can be used for numbers.
**Example**
```bat
@echo off
SET /A a = 5
SET /A b = 10
SET /A c = %a% + %b%
if %c%==15 echo "The value of variable c is 15"
if %c%==10 echo "The value of variable c is 10"
```
The key things to note about the above script are:
* The first 'if' statement checks if the value of the variable c is 15. If so, then it echo's a string to the command prompt.
* Since the condition in the statement - `if %c% == 10 echo "The value of variable **c** is 10` evaluates to false, the echo part of the statement will not be executed.
**Output**
The above command produces the following output.
```
15
```
**Checking String Variables**
The following example shows how the 'if' statement can be used for strings.
**Example**
```bat
@echo off
SET str1 = String1
SET str2 = String2
if %str1%==String1 echo "The value of variable String1"
if %str2%==String3 echo "The value of variable c is String3"
```
The key thing to note about the above program is −
* The first 'if' statement checks if the value of the variable str1 contains the string “String1”. If so, then it echo's a string to the command prompt.
* Since the condition of the second 'if' statement evaluates to false, the echo part of the statement will not be executed.
**Output**
The above command produces the following output.
```
"The value of variable String1"
```
**Note** − The evaluation in the 'if' statement is case-sensitive. The same program as above is modified a little as shown in the following example. In the first statement, we have changed the comparison criteria. Because of the different casing, the output of the following program would yield nothing.
```bat
@echo off
SET str1 = String1
SET str2 = String2
if %str1%==StrinG1 echo "The value of variable String1"
if %str2%==String3 echo "The value of variable c is String3"
```
{% endtab %}
{% endtabs %}
### Loops
{% tabs %}
{% tab title="Python" %}
| Loop Type | Code Examples |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| For | fruits = \["apple", "banana", "cherry"]
for x in fruits:
print(x)
|
| While | i = 1
while i < 6:
print(i)
i += 1
|
| Break | i = 1
while i < 6:
print(i)
if i == 3:
break
i += 1
|
| Continue | i = 1
while i < 6:
print(i)
if i == 3:
continue
i += 1
|
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Loop Type | Code Examples |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| For | $fruits = @("apple", "banana", "cherry")
foreach($x in $fruits)
{
Write-Host $x
}
|
| While | $i = 1
while ($i -lt 6)
{
Write-Host $i
$i++
}
|
| Break | $i = 1
while ($i -lt 6)
{
Write-Host $i
if ($i -eq 3)
{
break
}
$i++
}
|
| Continue | $i = 1
while ($i -lt 6)
{
Write-Host $i
if ($i -eq 3)
{
continue
}
$i++
}
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
| Loop Type | Code Examples |
| --------- | -------------------------------------------------------------- |
| For | `for i in 1 2 3; do echo $i; done` |
| While | `while [ "$var" != "stop" ]; do echo $var; done` |
| Break | `for i in 1 2 3; do [ "$i" = "2" ] && break; echo $i; done` |
| Continue | `for i in 1 2 3; do [ "$i" = "2" ] && continue; echo $i; done` |
**Basic for loop**
```bash
for i in /etc/rc.*; do
echo $i
done
```
**C-like for loop**
```bash
for ((i = 0 ; i < 100 ; i++)); do
echo $i
done
```
**Ranges**
```bash
for i in {1..5}; do
echo "Welcome $i"
done
```
**With step size**
```bash
for i in {5..50..5}; do
echo "Welcome $i"
done
```
**Reading lines**
```bash
cat file.txt | while read line; do
echo $line
done
```
**Forever**
```bash
while true; do
$commands_here
done
```
{% endtab %}
{% tab title="CMD. bat" %}
TODO: this
| Loop Type | Code Examples |
| --------- | ------------- |
| For | |
| While | |
| Break | |
| Continue | |
#### Loops
In the decision making chapter, we have seen statements which have been executed one after the other in a sequential manner. Additionally, implementations can also be done in Batch Script to alter the flow of control in a program's logic. They are then classified into flow of control statements.
#### `While` Statement Implementation
There is no direct `while` statement available in Batch Scripting but we can do an implementation of this loop very easily by using the if statement and labels.
The first part of the while implementation is to set the counters which will be used to control the evaluation of the 'if' condition. We then define our label which will be used to embody the entire code for the while loop implementation. The 'if' condition evaluates an expression. If the expression evaluates to true, the code block is executed. If the condition evaluates to false then the loop is exited. When the code block is executed, it will return back to the label statement for execution again.
**Syntax**
```bat
Set counters
:label
If (expression) (
Do_something
Increment counter
Go back to :label
)
```
* The entire code for the while implementation is placed inside of a label.
* The counter variables must be set or initialized before the while loop implementation starts.
* The expression for the while condition is done using the 'if' statement. If the expression evaluates to true then the relevant code inside the 'if' loop is executed.
* A counter needs to be properly incremented inside of 'if' statement so that the while implementation can terminate at some point in time.
* Finally, we will go back to our label so that we can evaluate our 'if' statement again.
Following is an example of a while loop statement.
**Example**
```bat
@echo off
SET /A "index = 1"
SET /A "count = 5"
:while
if %index% leq %count% (
echo The value of index is %index%
SET /A "index = index + 1"
goto :while
)
```
In the above example, we are first initializing the value of an index integer variable to 1. Then our condition in the 'if' loop is that we are evaluating the condition of the expression to be that index should it be less than the value of the count variable. Till the value of index is less than 5, we will print the value of index and then increment the value of index.
#### `For` Statement - `List Implementations`
The "FOR" construct offers looping capabilities for batch files. Following is the common construct of the 'for' statement for working with a list of values.
**Syntax**
```bat
FOR %%variable IN list DO do_something
```
The classic 'for' statement consists of the following parts −
* Variable declaration – This step is executed only once for the entire loop and used to declare any variables which will be used within the loop. In Batch Script, the variable declaration is done with the %% at the beginning of the variable name.
* List – This will be the list of values for which the 'for' statement should be executed.
* The do\_something code block is what needs to be executed for each iteration for the list of values.
Following is an example of how the 'goto' statement can be used.
**Example**
```bat
@echo off
FOR %%F IN (1 2 3 4 5) DO echo %%F
```
The key thing to note about the above program is −
* The variable declaration is done with the %% sign at the beginning of the variable name.
* The list of values is defined after the IN clause.
* The do\_something code is defined after the echo command. Thus for each value in the list, the echo command will be executed.
#### Looping through Ranges
The 'for' statement also has the ability to move through a range of values. Following is the general form of the statement.
#### Syntax
```bat
FOR /L %%variable IN (lowerlimit,Increment,Upperlimit) DO do_something
```
Where
* The /L switch is used to denote that the loop is used for iterating through ranges.
* Variable declaration – This step is executed only once for the entire loop and used to declare any variables which will be used within the loop. In Batch Script, the variable declaration is done with the %% at the beginning of the variable name.
* The IN list contains of 3 values. The lowerlimit, the increment, and the upperlimit. So, the loop would start with the lowerlimit and move to the upperlimit value, iterating each time by the Increment value.
* The do\_something code block is what needs to be executed for each iteration.
Following is an example of how the looping through ranges can be carried out.
**Example**
```bat
@ECHO OFF
FOR /L %%X IN (0,1,5) DO ECHO %%X
```
#### Classic for Loop Implementation
Following is the classic 'for' statement which is available in most programming languages.
**Typical 'for' loop Syntax**
```
for(variable declaration;expression;Increment) {
statement #1
statement #2
…
}
```
The Batch Script language does not have a direct 'for' statement which is similar to the above syntax, but one can still do an implementation of the classic 'for' loop statement using if statements and labels.
Let's look at the general syntax implementation of the classic for loop in batch scripting.
```bat
Set counter
:label
If (expression) exit loop
Do_something
Increment counter
Go back to :label
```
* The entire code for the 'for' implementation is placed inside of a label.
* The counters variables must be set or initialized before the 'for' loop implementation starts.
* The expression for the 'for' loop is done using the 'if' statement. If the expression evaluates to be true then an exit is executed to come out of the loop.
* A counter needs to be properly incremented inside of the 'if' statement so that the 'for' implementation can continue if the expression evaluation is false.
* Finally, we will go back to our label so that we can evaluate our 'if' statement again.
Following is an example of how to carry out the implementation of the classic 'for' loop statement.
**Example**
```bat
@echo off
SET /A i = 1
:loop
IF %i%==5 GOTO END
echo The value of i is %i%
SET /a i=%i%+1
GOTO :LOOP
:END
```
#### Looping through Command Line Arguments
The 'for' statement can also be used for checking command line arguments. The following example shows how the 'for' statement can be used to loop through the command line arguments.
**Example**
```bat
@ECHO OFF
:Loop
IF "%1"=="" GOTO completed
FOR %%F IN (%1) DO echo %%F
SHIFT
GOTO Loop
:completed
```
**Output**
Let's assume that our above code is stored in a file called Test.bat. The above command will produce the following output if the batch file passes the command line arguments of 1,2 and 3 as Test.bat 1 2 3.
```
1
2
3
```
#### `Break` Statement Implementation
The break statement is used to alter the flow of control inside loops within any programming language. The break statement is normally used in looping constructs and is used to cause immediate termination of the innermost enclosing loop.
The break statement is used to alter the flow of control inside loops within any programming language. The break statement is normally used in looping constructs and is used to cause immediate termination of the innermost enclosing loop.
The Batch Script language does not have a direct 'for' statement which does a break but this can be implemented by using labels. The following example shows the diagrammatic explanation of the break statement implementation in Batch Script.
**Example**
```bat
@echo off
SET /A "index=1"
SET /A "count=5"
:while
if %index% leq %count% (
if %index%==2 goto :Increment
echo The value of index is %index%
:Increment
SET /A "index=index + 1"
goto :while
)
```
The key thing to note about the above implementation is the involvement of two 'if' conditions. The second 'if' condition is used to control when the break is implemented. If the second 'if' condition is evaluated to be true, then the code block is not executed and the counter is directly implemented.
Following is an example of how to carry out the implementation of the break statement.
The key thing to note about the above script is the addition of a label called :Increment. When the value of index reaches 2, we want to skip the statement which echoes its value to the command prompt and directly just increment the value of index.
{% endtab %}
{% endtabs %}
### Functions
{% tabs %}
{% tab title="Python" %}
| Functions | Code Examples |
| ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Definition | def hello\_function():
print("Hello from my function!")
\\
hello\_function()
|
| Arguments | def my\_name(fname, lname):
print("My name is " + fname + " " + lname)
\\
my\_function("Wolf", "Zweiler")
|
| Variable Arguments | def second\_arg(\*children):
print("The youngest child is " + children\[1])
\\
my\_function("Sarah", "Emily", "Tom")
|
| Named Arguments | def young\_child(child3, child2, child1):
print("The youngest child is " + child3)
\\
my\_function(child1 = "Sarah", child2 = "Emily", child3 = "Tom")
|
| Default Values | def my\_country(country = "Wakanda"):
print("I am from " + country)
\\
my\_country()
|
| Return Values | def five\_times(x):
return 5 \* x
|
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Functions | Code Examples |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Definition | function hello\_function()
{
Write-Host "Hello from my function!"
}
hello\_function
|
| Arguments | function my\_name($fname, $lname)
{
Write-Host "My name is $fname $lname"
}
my-function -fname "Wolf" -lname "Zweiler"
|
| Variable Arguments | function second\_arg()
{
Write-Host "The youngest child is $($args\[1])"
}
my-function "Sarah" "Emily" "Tom"
|
| Named Arguments | function young\_child($child3, $child2, $child1)
{
Write-Host "The youngest child is $child3"
}
my-function -child1 "Sarah" -child2 "Emily" -child3 "Tom"
|
| Default Values | function my\_country
{
param(
$country = "Wakanda"
)
\\
Write-Host "I am from $country"
}
my\_country
|
| Return Values | function five\_times($x)
{
5 \* $x
}
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
| Functions | Code Examples |
| ------------------ | ----------------------------------------------------------------- |
| Definition | `myfunc() { echo "Hello"; }` |
| Arguments | `myfunc() { echo "Hello $1"; }; myfunc World` |
| Variable Arguments | `myfunc() { for arg in "$@"; do echo $arg; done; }; myfunc a b c` |
| Named Arguments | `# Not natively supported in Bash` |
| Default Values | `myfunc() { local var=${1:-default}; echo $var; }; myfunc` |
| Return Values | `myfunc() { return 42; }; myfunc; echo $?` |
**Arguments**
Referencing arguments in a bash script:
| `$#` | Number of arguments |
| ---- | ------------------------------------- |
| `$*` | All arguments |
| `$@` | All arguments, starting from first |
| `$1` | First argument, `$2` second, etc. |
| `$_` | Last argument of the previous command |
**Returning values**
```bash
myfunc() {
local myresult='some value'
echo $myresult
}
```
```bash
result="$(myfunc)"
```
Defining Functions
```bash
myfunc() {
echo "hello $1"
}
```
```bash
# Same as above (alternate syntax)
function myfunc() {
echo "hello $1"
}
```
```bash
myfunc "John"
```
{% endtab %}
{% tab title="CMD. bat" %}
Basic functions can be defined in batch scripts, hoever they do not accept arguments nor do they have the ability to return values in the programming sense.
| Functions | Code Examples |
| ------------------ | ----------------------------------- |
| Definition | `:myfunc echo Hello & goto :eof` |
| Arguments | `REM Not natively supported in CMD` |
| Variable Arguments | `REM Not natively supported in CMD` |
| Named Arguments | `REM Not natively supported in CMD` |
| Default Values | `REM Not natively supported in CMD` |
| Return Values | `REM Not natively supported in CMD` |
| {% endtab %} | |
| {% endtabs %} | |
### Classes
{% tabs %}
{% tab title="Python" %}
| Activity | Code Examples |
| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Class Definition | class MyClass:
x = 5
|
| Object Creation | `MyClass()` |
| Using Class Constructors | class Person:
def init(self, name, age):
self.name = name
self.age = age
\\
p1 = Person("Bob", 42)
|
| Defining and using Methods | class Person:
def init(self, name, age):
self.name = name
self.age = age
\\
def myfunc(self):
print("Hello my name is " + self.name)
\\
p1 = Person("Bob", 42)
p1.myfunc()
|
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Activity | Code Examples |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Class Definition | class MyClass {
$x = 5
}
|
| Object Creation | `[MyClass]::new()` |
| Using Class Constructors | class Person {
Person($Name, $Age) {
$this.Name = $Name
$this.Age = $Age
}
\\
$Name = ''
$Age = 0
}
\[Person]::new('Bob', 42)
|
| Defining and using Methods | class Person {
Person($Name, $Age) {
$this.Name = $Name
$this.Age = $Age
}
\\
\[string]myfunc() {
return "Hello my name is $($this.Name)"
}
\\
$Name = ''
$Age = 0
}
\\
\[Person]::new('Bob', 42)
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
TODO:
| Activity | Code Examples |
| -------------------------- | ------------- |
| Class Definition | |
| Object Creation | |
| Using Class Constructors | |
| Defining and using Methods | |
| | |
| {% endtab %} | |
{% tab title="CMD. bat" %}
TODO:
| Activity | Code Examples |
| -------------------------- | ------------- |
| Class Definition | |
| Object Creation | |
| Using Class Constructors | |
| Defining and using Methods | |
| | |
| | |
| {% endtab %} | |
| {% endtabs %} | |
### Comments
{% tabs %}
{% tab title="Python" %}
| Comment Type | Code Examples |
| ------------ | ------------------------------------------------------------------------------- |
| Single line | `# Hello, world!` |
| Multiline | """
Hello, world!
"""
|
| {% endtab %} | |
{% tab title="Powershell" %}
| Comment Type | Code Examples |
| ------------ | ----------------------------------------------------------------------------- |
| Single line | `# Hello, world!` |
| Multiline | <#
Hello, world!
#>
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
| Comment Type | Code Examples |
| ------------ | ----------------------- |
| Single line | `# Single line comment` |
| Multiline | See example below |
**Comments**
```bash
# Single line comment
```
```bash
: '
This is a
multi line
comment
'
```
{% endtab %}
{% tab title="CMD. bat" %}
| Comment Type | Code Examples |
| ------------ | ---------------------------------- |
| Single line | `Rem This is a comment` |
| Multiline | Not implemented in batch scripts\` |
#### Comments Using the Rem Statement
There are two ways to create comments in Batch Script; one is via the Rem command. Any text which follows the Rem statement will be treated as comments and will not be executed. Following is the general syntax of this statement.
**Syntax**
```bat
Rem This is a comment
```
**Example**
The following example shows a simple way the **Rem** command can be used to explain the function of the code below it.
```bat
@echo off
Rem This program just displays Hello World
set message=Hello World
echo %message%
```
**Output**
The above command produces the following output. You will notice that the line with the Rem statement will not be executed.
```
Hello World
```
**Notes:**
1. `REM` command must be followed by a space or tab character.
2. You may include any symbol in the comments without any restriction.
3. If `ECHO` is in ON state, the comment is displayed on the command prompt. Otherwise, it is ignored.
4. If you want `ECHO` to be ON and you don't want to display the comment line, use an at sign `@` before `REM` command.
5. If you have too many lines of Rem, it could slow down the code, because in the end each line of code in the batch file still needs to be executed.
#### Comments Using the :: Statement
The other way to create comments in Batch Script is via the :: command. Any text which follows the :: statement will be treated as comments and will not be executed. Following is the general syntax of this statement.
**Syntax**
```bat
:: This is a comment
```
**Example**
The comment marker `::` is used exactly the same as `Rem`.
```bat
@echo off
:: This program just displays Hello World
set message = Hello World
echo %message%
```
### Trick for Multiple Line Comments
Use a `GOTO` statement to simulate a multiline comment by bypassing the lines within the block.
```bat
GOTO MultiLineComment
This line is comment.
And so is this line.
And this one...
:MultiLineComment
```
{% endtab %}
{% endtabs %}
### Data Type
{% tabs %}
{% tab title="Python" %}
| Action | Code Examples |
| ----------------- | -------------------------------------------------------- |
| Get Object's Type | var = 1
type(var)
|
| {% endtab %} | |
{% tab title="Powershell" %}
| Action | Code Examples |
| ----------------- | ---------------------------------------------------- |
| Get Object's Type | $var = 1
$var
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
Bash does not have the concept of typed variables, though attributes can be defined using the `declare` command. See the link below for more information:
{% endtab %}
{% tab title="CMD. bat" %}
TODO: this
| Action | Code Examples |
| ----------------- | ------------- |
| Get Object's Type | |
| {% endtab %} | |
| {% endtabs %} | |
### Dictionaries
{% tabs %}
{% tab title="Python" %}
| **Activity** | Code Examples |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Defining | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)
|
| Accessing Elements | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict\['brand']
|
| Updating Elements | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict\['brand'] = 'Chevy'
|
| Enumerating Keys | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
for x in thisdict:
print(x)
|
| Enumerating Values | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
for x in thisdict.values():
print(x)
|
| Check if key exists | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
if "model" in thisdict:
print("Yes, 'model' is one of the keys in the thisdict dictionary")
|
| Adding items | thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict\["color"] = "red"
|
| | |
| {% endtab %} | |
{% tab title="PowerShell" %}
| **Activity** | Code Examples |
| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Defining | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
|
| Accessing Elements | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
$thisdict.brand
\\
or
\\
$thisdict\['brand']
|
| Updating Elements | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
$thisdict.brand = 'Chevy'
|
| Enumerating Keys | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
$thisdict.Keys
|
| Enumerating Values | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
$thisdict.Values
|
| Check if key exists | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
if ($thisdict.ContainsKey("model"))
{
Write-Host "Yes, 'model' is one of the keys in the thisdict dictionary"
}
|
| Adding items | $thisdict = @{
brand = "Ford"
model = "Mustang"
year = 1964
}
$thisdict.color = 'red'
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
TODO: this
| **Activity** | Code Examples |
| ------------------- | ------------- |
| Defining | |
| Accessing Elements | |
| Updating Elements | |
| Enumerating Keys | |
| Enumerating Values | |
| Check if key exists | |
| Adding items | |
**Defining a dictionary**
```bash
declare -A sounds
```
```bash
sounds[dog]="bark"
sounds[cow]="moo"
sounds[bird]="tweet"
sounds[wolf]="howl"
```
Declares `sound` as a Dictionary object (aka associative array).
**Working with dictionaries**
```bash
echo ${sounds[dog]} # Dog's sound
echo ${sounds[@]} # All values
echo ${!sounds[@]} # All keys
echo ${#sounds[@]} # Number of elements
unset sounds[dog] # Delete dog
```
**Iteration**
**Iterate over values**
```bash
for val in "${sounds[@]}"; do
echo $val
done
```
**Iterate over keys**
```bash
for key in "${!sounds[@]}"; do
echo $key
done
```
{% endtab %}
{% tab title="CMD. bat" %}
TODO: this
| **Activity** | Code Examples |
| ------------------- | ------------- |
| Defining | |
| Accessing Elements | |
| Updating Elements | |
| Enumerating Keys | |
| Enumerating Values | |
| Check if key exists | |
| Adding items | |
#### Creating Structures in Arrays
Structures can also be implemented in batch files using a little bit of an extra coding for implementation. The following example shows how this can be achieved.
**Example**
```bat
@echo off
set len = 3
set obj[0].Name = Joe
set obj[0].ID = 1
set obj[1].Name = Mark
set obj[1].ID = 2
set obj[2].Name = Mohan
set obj[2].ID = 3
set i = 0
:loop
if %i% equ %len% goto :eof
set cur.Name=
set cur.ID=
for /f "usebackq delims==.tokens=1-3" %%j in (`set obj[%i%]`) do (
set cur.%%k=%%l
)
echo Name = %cur.Name%
echo Value = %cur.ID%
set /a i = %i%+1
goto loop
```
The following key things need to be noted about the above code:
* Each variable defined using the `set` command has 2 values associated with each index of the array.
* The variable **i** is set to 0 so that we can loop through the structure will the length of the array which is 3.
* We always check for the condition on whether the value of i is equal to the value of **len** and if not, we loop through the code.
* We are able to access each element of the structure using the `obj\[%i%]` notation.
**Output**
The above command produces the following output.
```bat
Name = Joe
Value = 1
Name = Mark
Value = 2
Name = Mohan
Value = 3
```
{% endtab %}
{% endtabs %}
### Lambdas
{% tabs %}
{% tab title="Python" %}
| Lambda | Code Examples |
| ------------ | ------------------------------------------------------------------------ |
| Lambda | x = lambda a : a + 10
print(x(5))
|
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Lambda | Code Examples |
| ------------ | ------------------------------------------------------------------------ |
| Lambda | $x = { param($a) $a + 10 }
& $x 5
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
This is implemented by creating a basic inline function in bash.
| Lambda | Code Examples |
| ------------ | ------------------------------------------- |
| Lambda | `lambda() { echo $(($1 + 10)); }; lambda 5` |
| {% endtab %} | |
{% tab title="CMD. bat" %}
Batch scripting does not natively support lambda functions.
| Lambda | Code Examples |
| ------------- | ----------------------------------- |
| Lambda | `REM Not natively supported in CMD` |
| {% endtab %} | |
| {% endtabs %} | |
### Math Operators
{% tabs %}
{% tab title="Python" %}
TODO: Add other operator types
| Operator | Code Examples |
| -------------- | --------------- |
| Addition | `var = 1 + 1` |
| Subtraction | `var = 1 - 1` |
| Multiplication | `var = 1 * 1` |
| Division | `var = 1 / 1` |
| Modulus | `var = 1 % 1` |
| Floor | `var = 10 // 3` |
| Exponent | `var = 10 ** 3` |
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Operator | Code Examples |
| -------------- | ------------------------------ |
| Addition | `$var = 1 + 1` |
| Subtraction | `$var = 1 - 1` |
| Multiplication | `$var = 1 * 1` |
| Division | `$var = 1 / 1` |
| Modulus | `$var = 1 % 1` |
| Floor | `$var = [Math]::Floor(10 / 3)` |
| Exponent | `$var = [Math]::Pow(10, 3)` |
| | |
| {% endtab %} | |
{% tab title="Bash" %}
| Operator | Code Examples |
| -------------- | ------------------- |
| Addition | `echo $((1 + 1))` |
| Subtraction | `echo $((1 - 1))` |
| Multiplication | `echo $((1 * 1))` |
| Division | `echo $((1 / 1))` |
| Modulus | `echo $((1 % 1))` |
| Floor | `echo $((10 / 3))` |
| Exponent | `echo $((10 ** 3))` |
| | |
| {% endtab %} | |
{% tab title="CMD. bat" %}
{% endtab %}
{% endtabs %}
### Error Handling
{% tabs %}
{% tab title="Python" %}
| Error Handling | Code Examples |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Try/Except | try:
print(x)
except:
print("An exception occurred")
|
| Else | try:
print("Hello")
except:
print("Something went wrong")
else:
print("Nothing went wrong")
|
| Finally | try:
f = open("file.txt") f.write("Lorum Ipsum")
except:
print("Something went wrong when writing to the file")
finally:
f.close()
|
| Raise | x = -1
if x < 0:
raise Exception("Sorry, no numbers below zero")
|
| | |
| {% endtab %} | |
{% tab title="Powershell" %}
| Error Handling | Code Examples |
| -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Try/Catch | try {
Write-Host $x
} catch {
Write-Host "An exception ocurred"
}
|
| | |
| {% endtab %} | |
{% tab title="Bash" %}
TODO: this
| Error Handling | Code Examples |
| -------------- | ------------- |
| Try/Catch | |
**Trap errors**
```
trap 'echo Error at about $LINENO' ERR
```
or
```
traperr() {
echo "ERROR: ${BASH_SOURCE[1]} at about ${BASH_LINENO[0]}"
}
set -o errtrace
trap traperr ERR
```
**Raising errors**
```
myfunc() {
return 1
}
```
```
if myfunc; then
echo "success"
else
echo "failure"
fi
```
{% endtab %}
{% tab title="CMDbat" %}
TODO: this
| Error Handling | Code Examples |
| -------------- | ------------- |
| Try/Catch | |
| {% endtab %} | |
| {% endtabs %} | |
### Shell Command Execution
{% tabs %}
{% tab title="Python" %}
{% endtab %}
{% tab title="Powershell" %}
To execute regular Windows shell commands (from cmd.exe) in PowerShell, simply type the command the same way you would in the Windows command shell. Some commands may not work in the same way, and some may need the full filename (example: to se a directory listing in cmd.exe \`dir\` is the command. To use this in PowerShell you would need to specify \`dir.exe\`.
IEX (Invoke-Expression)
{% endtab %}
{% tab title="Bash" %}
**Shell execution**
```
pwd
echo "I'm in $(pwd)"
echo "I'm in `pwd`"
```
{% endtab %}
{% tab title="CMD. bat" %}
To execute regular Windows shell commands (from cmd.exe) in PowerShell, simply type the command the same way you would in the Windows command shell. Some commands may not work in the same way, and some may need the full filename (example: to se a directory listing in cmd.exe dir is the command. To use this in PowerShell you would need to specify dir.exe.
IEX (Invoke-Expression)
{% endtab %}
{% endtabs %}
### Output Redirection
{% tabs %}
{% tab title="Python" %}
#### Redirect Standard Error to the nether
```
2>null
```
Many cmdlets also have an `ErrorAction` property
```
-ErrorAction Silent
```
{% endtab %}
{% tab title="Powershell" %}
#### Redirect Standard Error to the nether
```
2>null
```
Many cmdlets also have an `ErrorAction` property
```
-ErrorAction Silent
```
{% endtab %}
{% tab title="Bash" %}
Redirect Standard Error to the nether
```
2>/dev/null
```
{% endtab %}
{% tab title="CMD. bat" %}
There are three universal “files” for keyboard input, printing text on the screen and printing errors on the screen. The “Standard In” file, known as **stdin**, contains the input to the program/script. The “Standard Out” file, known as **stdout**, is used to write output for display on the screen. Finally, the “Standard Err” file, known as **stderr**, contains any error messages for display on the screen.
Each of these three standard files, otherwise known as the standard streams, are referenced using the numbers 0, 1, and 2. Stdin is file 0, stdout is file 1, and stderr is file 2.
#### Redirecting Output (Stdout and Stderr)
One common practice in batch files is sending the output of a program to a log file. The > operator sends, or redirects, stdout or stderr to another file. The following example shows how this can be done.
```
Dir C:\ > list.txt
```
In the above example, the **stdout** of the command Dir C: is redirected to the file list.txt.
If you append the number 2 to the redirection filter, then it would redirect the **stderr** to the file lists.txt.
```
Dir C:\ 2> list.txt
```
One can even combine the **stdout** and **stderr** streams using the file number and the '&' prefix. Following is an example.
```
DIR C:\ > lists.txt 2>&1
```
#### Suppressing Program Output
The pseudo file NUL is used to discard any output from a program. The following example shows that the output of the command DIR is discarded by sending the output to NUL.
```
Dir C:\ > NUL
```
**Stdin**
To work with the Stdin, you have to use a workaround to achieve this. This can be done by redirecting the command prompt's own stdin, called CON.
The following example shows how you can redirect the output to a file called lists.txt. After you execute the below command, the command prompt will take all the input entered by user till it gets an EOF character. Later, it sends all the input to the file lists.txt.
```
TYPE CON > lists.txt
```
{% endtab %}
{% endtabs %}
### HERE docs
In scripting, a heredoc (here document) is a way to feed a block of text into a command or script. It's often used to generate multi-line output or pass structured text to commands like cat, echo, or tee. Some benefits of using HERE docs:
* Simplifies Multi-Line Input – Instead of writing multiple commands, you can provide large text blocks neatly to a single input.
* Improves Readability – Using heredocs makes scripts easier to read and maintain, especially when handling structured data.
* Supports Variable Expansion – In most languages, heredocs allow variables to be expanded dynamically.
{% tabs %}
{% tab title="Python" %}
Python doesn't have a direct heredoc equivalent, but triple-quoted strings (`"""` or `'''`) serve a similar purpose.
```python
text = """This is a multi-line string.
It works like a heredoc."""
print(text)
```
{% endtab %}
{% tab title="Powershell" %}
PowerShell uses here-strings, which are enclosed in `@"` and `"@`, which support expansion and variables (or `@'` and `'@` for literal strings).
```powershell
$text = @"
This is a PowerShell here-string.
It spans multiple lines.
"@
Write-Output $text
```
**Note**
Here-strings in PowerShell are useful for handling multi-line text, but they come with some limitations:
* Must Start on a New Line – The opening `@"` or `@'` must be on its own line, or PowerShell will throw an error.
* No Indentation for Closing Marker – The closing `"@` or `'@` must start at the very beginning of a line, which can make formatting tricky.
* Limited Formatting Control – Unlike heredocs in Bash, PowerShell here-strings don’t support indentation or trimming whitespace easily.
{% endtab %}
{% tab title="Bash" %}
**Heredoc**
Heredocs in Bash scripting offer several additional benefits, making them a powerful tool for handling multi-line text inputs efficiently:
* Avoids Escape Characters – Unlike inline strings, heredocs allow you to include quotes and special characters without excessive escaping.
* Supports Variable Expansion – Unless explicitly prevented with `<<'EOF'`, heredocs expand variables, making dynamic content generation easier.
```
cat < output.txt
```
{% endtab %}
{% endtabs %}
### Package Management
{% tabs %}
{% tab title="Python" %}
{% endtab %}
{% tab title="Powershell" %}
| Activity | Code Examples |
| ------------ | --------------------------------------------- |
| Install | `Install-Package ` - PowerShell |
| Import | `Import-Module ` |
| List | `Get-Package` - PowerShell |
| Update | `Update-Package ` |
| Uninstall | `Uninstall-Package ` |
| Search | `Find-Package ` |
| Show Details | `Get-Package -Name ` |
PowerShell uses **PackageManagement** to handle software packages, and it supports multiple providers like NuGet and Chocolatey.
{% endtab %}
{% tab title="Winget" %}
**Winget package management**
Winget is used for managing applications on Windows, similar to package managers on Linux and macOS.
| Activity | Code Examples |
| ------------ | --------------------------------- |
| Install | `winget install ` |
| List | `winget list` |
| Update | `winget upgrade ` |
| Update All | `winget upgrade --all` |
| Uninstall | `winget uninstall ` |
| Search | `winget search ` |
| Show Details | `winget show ` |
You can find more details on Winget commands [here](https://learn.microsoft.com/en-us/windows/package-manager/winget/).
{% endtab %}
{% tab title="chocolatey" %}
**Chocolatey package management**
Chocolatey is a powerful package manager for Windows, making software installation and updates much more efficient.
| Activity | Code Examples |
| --------------------------- | -------------------------------- |
| Install | `choco install ` |
| List | `choco list --local-only` |
| Update | `choco upgrade ` |
| Update All | `choco upgrade all` |
| Uninstall | `choco uninstall ` |
| Search | `choco search ` |
| Show Details | `choco info ` |
| Check for Outdated Packages | `choco outdated` |
You can find more details on Chocolatey commands [here](https://docs.chocolatey.org/en-us/choco/commands/).
{% endtab %}
{% tab title="Bash" %}
| Activity | Code Examples |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------- |
| Install | sudo apt install \ (Debian/Ubuntu)
sudo dnf install \ (Fedora/RHEL)
|
| Import | Not applicable in Bash package management (Packages are installed, not imported) |
| List | apt list --installed (Debian/Ubuntu)
dnf list installed (Fedora/RHEL)
|
| Update | sudo apt update (Debian/Ubuntu)
sudo dnf update (Fedora/RHEL)
|
| Upgrade | sudo apt upgrade (Debian/Ubuntu)
sudo dnf upgrade (Fedora/RHEL)
|
| Remove | sudo apt remove \ (Debian/Ubuntu)
sudo dnf remove \ (Fedora/RHEL)
|
| Search | apt search \ (Debian/Ubuntu)
dnf search \ (Fedora/RHEL)
|
| Clean Cache | sudo apt clean (Debian/Ubuntu)
sudo dnf clean all (Fedora/RHEL)
|
| | |
| {% endtab %} | |
{% tab title="CMD. bat" %}
Windows lacks built-in package management, but has a somewhat similar feature using DISM (Deployment Image Servicing and Management) for managing additional features. These features can also be installed/removed using PowerShell commands as well.
| Activity | Code Examples |
| ------------------------------ | -------------------------------------------------------------------- |
| Install Feature | `DISM /Online /Enable-Feature /FeatureName:` |
| Remove Feature | `DISM /Online /Disable-Feature /FeatureName:` |
| List Installed Features | `DISM /Online /Get-Features` |
| Check Feature Status | `DISM /Online /Get-FeatureInfo /FeatureName:` |
| Install Feature via PowerShell | `Enable-WindowsOptionalFeature -Online -FeatureName ` |
| Remove Feature via PowerShell | `Disable-WindowsOptionalFeature -Online -FeatureName ` |
You can find more details on managing Windows features [here](https://learn.microsoft.com/en-us/windows/client-management/client-tools/add-remove-hide-features).
{% endtab %}
{% endtabs %}
References
*
*
*