What started as a passion for sharing my knowledge of Java and Python has now grown into a platform that reaches thousands of readers every month. From in-depth programming tutorials to simple "how-to" guides, Java2Blog is here to help you learn step by step—whether you’re a beginner or an experienced developer looking to sharpen your skills.

But Java2Blog isn’t just about programming. Over time, the blog has expanded into guides, tips, and tutorials across a wide range of topics that make life easier for learners, tech enthusiasts, and problem-solvers alike.

At its core, Java2Blog is built on three principles:

• Clarity : breaking down complex topics into easy-to-understand language.
• Practicality : focusing on real-world use cases and solutions.
• Community : helping people from all backgrounds gain the confidence to learn and grow.

If you’re ready to start learning, improving, or just exploring something new—you’re in the right place.

If you have multiple consecutive spaces in the string, use the last solution, the for loop. You can use any of the following solutions if you have a multiline string.

Using tr Command

Use the tr command to replace space with newline in bash.

text="This is a sample string."
new_text=$(echo "$text" | tr ' ' '\n')
echo "$new_text"

This
is
a
sample
string.

We initialized the text variable with a sample string. Next, we piped the output of the echo command to the tr command, which translated (replaced) space (' ') with newline (\n).

We captured the output of the echo "$text" | tr ' ' '\n' command using substitution syntax ($(...)) and assigned to the new_text variable. Finally, we used the echo command to print the new_text variable’s value on the bash console.

Using awk Command

Use the awk command to replace space with newline in bash.

text="This is a sample string."
new_text=$(echo "$text" | awk -v RS=" " '{print}')
echo "$new_text"

This
is
a
sample
string.

This code snippet is similar to the previous example; however, we piped the echo command output to the awk command this time. The awk is used for text processing. It operates per line by default, but we can customize it to work with fields and records (lines) using special actions and patterns.

In the above example, we used the awk command to replace space with a newline. How? For that, we used the -v option to set the record separator variable (RS) to a space character (" "). By default, the awk takes the newline character as the value of the RS variable.

So, modifying the RS to a space character meant that each space-separated word would become a separate record for processing. For each record, the print command was executed to print the current record, followed by a new line. This effectively replaced spaces with newlines in the output.

Alternatively, we can use the following solution:

text="This is a sample string."
new_text=$(echo "$text" | awk '{gsub(/ /, "\n"); print}')
echo "$new_text"

This
is
a
sample
string.

Here, we used the gsub, an AWK function to globally substitute all occurrences of a space character (/ /) in the text with a newline character ("\n").

Using sed Command

Use the sed command to replace space with newline in bash.

text="This is a sample string."
new_text=$(echo "$text" | sed 's/ /\n/g')
echo "$new_text"

This
is
a
sample
string.

We used the sed command, which is used to process and transform text, typically used for performing text substitution, deletion, insertion and more.

In the above example, we used the sed command to substitute text. For that, we wrote the sed command sequence enclosed in single quotes; for instance, 's/ /\n/g'. This sed sequence instructed to perform a substitution operation on the input text.

The sequence of the sed command was comprised of various components; let’s learn them below:

• s (stands for substitute) – It told the sed to find and replace.

• / (delimiter character) – It separated the different parts of the sed command: pattern to search for, replacement, and any flags.

• space (between first and second /): This was the pattern to search for. In our case, it was a single-space character.

• \n (newline) – It was the replacement part; when the pattern (space) was found in the input, it would be replaced with a newline.

• g (stands for global) – This flag told sed to perform the replacement globally, meaning all occurrences of the pattern in a line would be replaced with the newline character, not just the first occurrence.

This effectively split the input text into separate lines wherever there was a space character.

Using Parameter Expansion

Use parameter expansion to replace space with newline in bash.

text="This is a sample string."
new_text="{text// /$'\n'}"
echo "$new_text"

This
is
a
sample
string.

This example is similar to the previous ones, but we used parameter expansion this time. The parameter expansion ({text// /$'\n'}) took the value of the text variable, found all occurrences of a space character, and replaced them with a newline character. How? Following is a brief explanation of each component:

• ${...} was the basic syntax of parameter expansion; here, ... meant anything that you want to accomplish; for instance, text// /$'\n' in our case.

• // was a pattern-matching operator used in parameter expansion. When used as ${parameter//pattern/string}, it matched all occurrences of the provided pattern in the parameter (in this case, the variable text) and replaced them with the given string.

• ' ' was the pattern we searched for in the text variable. It was a single-space character.

• $'\n' was an ANSI-C quoted string representing a newline character (\n). The $'...' syntax interpreted backslash escapes in bash, so $'\n' was replaced with an actual newline character.

This was how we replaced space with newline in the text.

Using for Loop

Use the for loop to replace space with newline in bash.

text="This is a sample string."
new_text=""
for current_word in $text; do
    new_text="$new_text$current_word\n"
done
echo -e "$new_text"

This
is
a
sample
string.

We used a for loop in the above example to iterate over the $text. In each iteration, we concatenated the $new_text, $current_word, and a newline (\n) as "$new_text$current_word\n" and assigned its value to the new_text variable.

Once the loop was over, we used the echo command with the -e option to print the value of the new_text variable on the bash console.

Note that the -e option was used to interpret backslash escapes in the given string (in this case, new_text), allowing us to include special characters with specific meanings; for example, \n means a new line.

Searching for strings in text files is a common task in bash, used in scenarios like log file analysis and configuration file searches. This article explores various methods to check if file contains String, including both case-sensitive and case-insensitive approaches.

2. Introduction to Problem Statement

Let’s consider a log file named server.log:

2023-11-24 10:00:00 INFO Starting server process
2023-11-24 10:00:05 ERROR Failed to bind to port 8080
2023-11-24 10:00:10 INFO Server listening on port 9090
2023-11-24 10:01:00 WARN Database connection timeout

Our goal is to check if file server.log contains string Error in it.

The expected output is something like this:

Error found in server.log.

3. Using grep

The grep is a command-line utility optimized for searching text data for lines matching a regular expression.

if grep -q "Error" server.log; then
  echo "Error found in server.log."
else
  echo "Error not found in server.log."
fi

Explanation:

• grep -q "Error" server.log: This command searches for string Error in server.log. Here, -q stands for "quiet". It causes grep to not output anything but to exit with status 0 if the pattern is found, and 1 otherwise.
• The if statement then checks the exit status of grep. If grep finds the string, the first block ("Error found in server.log.") is executed; if not, the else block executes.

Case-Insensitive Search:

By default, grep search is case-sensitive. To perform a case-insensitive search, use the -i flag: grep -iq "Error" server.log.

Performance:
grep is highly optimized for searching text, making it fast and efficient for this task.

4. Using awk

The awk is a versatile programming language designed for pattern scanning and processing.

Let’s use awk with if to achieve our goal:

if awk '/Error/ {found=1; exit} END {if (!found) exit 1}' server.log; then
  echo "Error found in server.log."
else
  echo "Error not found in server.log."
fi

Explanation:

• This awk command scans server.log for the pattern Error.
• When Error is found, awk sets a flag found to 1 and exits immediately.
• In the END block, awk exits with status 1 if the flag found is not set, indicating that the pattern was not found.

Case-Insensitive Search:

To make the search case-insensitive in awk, we can use the tolower function:

if awk 'tolower($0) ~ /Error/ {found=1; exit} END {if (!found) exit 1}' server.log; then
  echo "Error found in server.log."
else
  echo "Error not found in server.log."
fi

Performance:
The awk is powerful for text processing but might be slightly slower than grep for simple string searches. However, it offers more flexibility for complex data manipulations.

3. Using Bash Conditional Expressions

Bash conditional expressions are a powerful feature in shell scripting, allowing for decision-making based on the evaluation of conditions within a script.

Let’s use conditional expression to check if file contains string:

if [[ $(cat server.log) == *"Error"* ]]; then
  echo "Error found in server.log."
else
  echo "Error not found in server.log."
fi

Here, cat filename.txt outputs the content of the file server.log, and the conditional [[ ... == *"Error"* ]] checks if the content contains "Error".
Case-Insensitive Search:
Bash does not directly support case-insensitive matching in this context. However, you can convert the file content and the search string to the same case:

if [[ $(cat server.log | tr '[:upper:]' '[:lower:]') == *"error"* ]]; then
  echo "Error (case-insensitive) found in server.log."
else
  echo "Error (case-insensitive) not found in server.log."
fi

Performance:
For smaller files, this method is quick and efficient. However, for larger files, its performance can degrade due to the need to read the entire file content.

6. Using sed with grep Command

The sed (Stream Editor) is a powerful and versatile text processing tool that performs text transformations on an input stream (a file or input from a pipeline).

Here, we will use sed for preprocessing and grep for final check. Let’s see with the help of example:

if sed -n '/Error/p' server.log | grep -q .; then
  echo "Error found in server.log."
else
  echo "Error not found in server.log."
fi

Explanation:

• The sed command searches server.log for lines containing the string Error and prints them.
• The output of sed (the matched lines) is passed to grep.
• grep -q . checks if there is any output from sed. If there is at least one line (meaning at least one line in server.log contained "Error"), grep exits with a status of zero.
• If grep exits with a status of zero, indicating that sed found at least one line containing "Error", the condition in the if statement is considered true, and the commands following then are executed. If no lines are found, the condition is false, and the commands after then are not executed.

Let’s understand more about sed expression sed -n '/Error/p' server.log used in above command:

• sed: This is a stream editor for filtering and transforming text.
• -n: This option suppresses automatic printing of pattern space. It means sed will not print anything unless explicitly told to do so.
• '/Error/p': This is a sed command enclosed in single quotes. It tells sed to search for lines containing the string Error and print those lines (p stands for print). The /Error/ is a pattern that sed looks for in each line of the input.
  server.log: This is the file sed reads from. sed will process each line of this file, looking for the pattern Error.

7. Using Bash Loops

This method involves iterating over each line of a file to search for a string. This approach is very slow and should be only used while searching in smaller files.

found=0
while IFS= read -r line; do
  if [[ $line == *"Error"* ]]; then
    found=1
    break
  fi
done < server.log

if [[ $found -eq 1 ]]; then
  echo "Error found in server.log."
else
  echo "Error not found in server.log."
fi

Performance:
Bash loops are straightforward but can be slower, especially for larger files.

8. Searching for Multiple Strings in File

While working on script, there are often situations where we need to search based on multiples patterns rather than single pattern.

There are multiple ways to do it. Let’s see with the help of examples:

Using grep Command:

if grep -Eq 'Error|Warn' server.log; then
  echo "Error or warn found in server.log."
else
  echo "Error or warn not found in server.log."
fi

This command uses the pipe | as a logical OR to search for "Error" or "Warn".

Using awk Command

if awk '/Error/ || /Warning/' server.log; then
  echo "Error or Warning found in server.log."
else
  echo "Error or Warning not found in server.log."
fi

This awk command checks if either Error or Warn is present in server.log.

Using Bash Loops

found=0
while IFS= read -r line; do
  if [[ $line == *"Error"* ]] || [[ $line == *"Warning"* ]]; then
    found=1
    break
  fi
done < server.log

if [[ $found -eq 1 ]]; then
  echo "Error or Warning found in server.log."
else
  echo "Error or Warning not found in server.log."
fi

This Bash loop manually iterates through each line of server.log, checking for Error or Warn.

9. Searching for String in Multiple Files

To search across multiple files, use grep with a file pattern.

if grep -q "Error" *.log; then
  echo "Error found in log files."
else
  echo "Error not found in log files."
fi

We can also provide filenames separated by space.

if grep -q "Error" server1.log server2.log; then
  echo "Error found in log files."
else
  echo "Error not found in log files."
fi

10. Performance Comparison

It’s important to test how fast each method works so we can choose the best one.

We’ll create a big input server.log with 1 million lines, and test each solution on it to search pattern "Error" in the file.
To Benchmark their performance, here is the script:

#!/bin/bash

# Sample file and string
file="server.log"
string="Error"

# Function to measure using grep
measure_grep() {
    time if grep -q "$string" "$file"; then
        echo "grep: String found."
    else
        echo "grep: String not found."
    fi
}

# Function to measure using awk
measure_awk() {
    time if awk "/$string/ {found=1; exit} END {if (!found) exit 1}" "$file"; then
        echo "awk: String found."
    else
        echo "awk: String not found."
    fi
}

# Function to measure using sed
measure_sed() {
    time if sed -n "/$string/p" "$file" | grep -q .; then
        echo "sed: String found."
    else
        echo "sed: String not found."
    fi
}

# Function to measure using Bash loop
measure_bash_loop() {
    time {
        found=0
        while IFS= read -r line; do
            if [[ $line == *"$string"* ]]; then
                found=1
                break
            fi
        done < "$file"

        if [[ $found -eq 1 ]]; then
            echo "Bash loop: String found."
        else
            echo "Bash loop: String not found."
        fi
    }
}

# Function to measure using Bash Conditional Expressions
measure_bash_conditional() {
    time {
        if [[ $(cat "$file") == *"$string"* ]]; then
            echo "Bash conditional: String found."
        else
            echo "Bash conditional: String not found."
        fi
    }
}

# Execute the functions
echo "Measuring grep..."
measure_grep

echo "Measuring awk..."
measure_awk

echo "Measuring sed..."
measure_sed

echo "Measuring Bash loop..."
measure_bash_loop

echo "Measuring Bash Conditional Expressions..."
measure_bash_conditional

Measuring grep...
grep: String found.

real    0m0.073s
user    0m0.015s
sys     0m0.000s

Measuring awk...
awk: String found.

real    0m0.209s
user    0m0.125s
sys     0m0.015s
Measuring sed...
sed: String found.

real    0m0.252s
user    0m0.187s
sys     0m0.000s

Measuring Bash loop...

Bash loop: String found.

real    1m39.973s
user    0m50.156s
sys     0m34.875s
Measuring Bash Conditional Expressions...

Bash conditional: String found.

real    0m6.878s
user    0m0.687s
sys     0m2.796s

The grep command is fastest of all as it is meant for searching text data.

11. Conclusion

In this article, we have different ways for checking if file contains a String. Let’s highlight important points:

• For simple string searching tasks in a file, grep proves to be the most efficient tool in terms of speed and CPU usage.
• While awk and sed offer more versatility for complex text processing, they are less efficient for straightforward string searches. For example: Once it’s confirmed that the file includes the string, substitute ‘Error’ with ‘Exception’ and proceed with similar replacements.etc.
• Bash loops and conditional expressions are significantly slower and less efficient for this task, and their use should be limited to cases where command-line tools like grep, awk, or sed are not viable.

The Get-ADDefaultDomainPasswordPolicy is used to get the default password policy for the specified domain. We can use it differently in different use cases; let’s learn a few of them below.

Use the Get-ADDefaultDomainPasswordPolicy cmdlet with the -Current parameter to get the default password policy for the currently logged-on user in an active directory. Here, the user can be an Administrator or any XYZ name.

Get-ADDefualtDomainPasswordPolicy -Current LoggedOnUser

ComplexityEnabled           : True
DistuniguishedName          : DC=maslab,DC=com
LockoutDuration             : 00:30:00
LockoutObservationWindow    : 00:30:00
LockoutThreshold            : 0
MaxPasswordAge              : 42.00:00:00
MinPasswordAge              : 1.00:00:00
MinPasswordLength           : 7
objectClass                 : {domainDNS}
objectGuid                  : 574e7bd0-a042-45d2-8fdd-00ca4cb0a769
PasswordHistoryCount        : 24
ReversibleEncryptionEnabled : False

Alternatively, we can use the Get-ADDefualtDomainPasswordPolicy cmdlet alone to retrieve the default password policy from the currently logged-on user domain.

Use the Get-ADDefaultDomainPasswordPolicy cmdlet with the -Identity parameter to get the default password policy for the specified domain in an active directory; in our case, it is maslab.com.

Get-ADDefaultDomainPasswordPolicy -Identity maslab.com

ComplexityEnabled           : True
DistuniguishedName          : DC=maslab,DC=com
LockoutDuration             : 00:30:00
LockoutObservationWindow    : 00:30:00
LockoutThreshold            : 0
MaxPasswordAge              : 42.00:00:00
MinPasswordAge              : 1.00:00:00
MinPasswordLength           : 7
objectClass                 : {domainDNS}
objectGuid                  : 574e7bd0-a042-45d2-8fdd-00ca4cb0a769
PasswordHistoryCount        : 24
ReversibleEncryptionEnabled : False

Use Get-ADForest with Get-ADDefaultDomainPasswordPolicy

Use the Get-ADForest cmdlet along with the Get-ADDefaultDomainPasswordPolicy cmdlet to retrieve default password policy objects from all domains in the specified forest.

(Get-ADForest -Current LoggedOnUser).Domains |
ForEach-Object{ 
    Get-ADDefaultDomainPasswordPolicy -Identity $_
}

ComplexityEnabled           : True
DistuniguishedName          : DC=maslab,DC=com
LockoutDuration             : 00:30:00
LockoutObservationWindow    : 00:30:00
LockoutThreshold            : 0
MaxPasswordAge              : 42.00:00:00
MinPasswordAge              : 1.00:00:00
MinPasswordLength           : 7
objectClass                 : {domainDNS}
objectGuid                  : 574e7bd0-a042-45d2-8fdd-00ca4cb0a769
PasswordHistoryCount        : 24
ReversibleEncryptionEnabled : False

First, we used the Get-ADForest cmdlet to retrieve details about a current Active Directory forest using the domain of a currently logged-on user. You might be thinking that how this cmdlet would know about logged-on users. It was because we specified the -Current parameter and set its value to the LoggedOnUser. This cmdlet got the forest object containing the forest name, forest functional level, domain names, etc.

Then, we used the .Domain property to get all domains in the current Active Directory forest, which was then piped to the ForEach-Object cmdlet. The ForEach-Object cmdlet iterated over all the objects. In each iteration, we used the Get-ADDefaultDomainPasswordPolicy cmdlet with the -Identity parameter to get the password policy for the current object ($_).

We got the same output because we have one domain forest (maslab.com) in our case.

Use Get-ADUser with Get-ADDefaultDomainPasswordPolicy

Use the Get-ADUser cmdlet with the Get-ADDefaultDomainPasswordPolicy cmdlet to retrieve the detailed password policy for the specified user in the active directory.

$user_name = "Administrator"
$user = Get-ADUser -Identity $user_name -Properties *
$domain_policy = Get-ADDefaultDomainPasswordPolicy
$password_policy_for_one_user = @{
    "Password Never Expires" = $user.PasswordNeverExpires
    "Password Last Set" = $user.PasswordLastSet
    "Password Expired" = $user.PasswordExpired
    "Minimum Password Length" = $domain_policy.MinPasswordLength
    "Minimum Password Age" = $domain_policy.MinPasswordAge
    "Maximum Password Age" = $domain_policy.MaxPasswordAge
    "Password Complexity" = $domain_policy.ComplexityEnabled
    "Password HistoryCount" = $domain_policy.HistoryLength
    "Lockout Threshold" = $domain_policy.LockoutThreshold
    "Lockout Duration" = $domain_policy.LockoutDuration
}
$password_policy_for_one_user

Name                            Value
----                            -----
"Lockout Duration"              00:30:00
"Password Last Set"             7/16/2023 4:35:46 PM
"Minimum Password Length"       7
"Password Expired"              False
"Password Complexity"           True
"Lockout Threshold"             0
"Minimum Password Age"          1.00:00:00
"Maximum Password Age"          42.00:00:00
"Password History Count"        {}  
"Password Never Expires"        False

First, we initialized the $user_name variable with the Administrator; don’t forget to replace the Administrator with your username. Then, we used the Get-ADUser cmdlet with -Identity parameter to retrieve the user from the active directory and stored it in the $user variable; this $user would have all the properties because we set the -Properties parameter to the wildcard character (*) to retrieve all properties.

Next, we used the Get-ADDefaultDomainPasswordPolicy cmdlet to get the default password policy and assigned it to the $domain_policy variable. After that, we create a HashTable to set the keys with corresponding values. We stored this HashTable in the $password_policy_for_one_user variable to further display it on the PowerShell console.

Do we have any option to use calculated properties to meet the project needs; for instance, if we want to know the password age meaning the time since the last password was changed? Yes, of course! See the following example.

Use the Get-ADUser cmdlet with the Get-ADDefaultDomainPasswordPolicy cmdlet to display calculated properties for the mentioned user in the active directory.

$user_name = "Administrator"
$user = Get-ADUser -Identity $user_name -Properties *
$domain_policy = Get-ADDefaultDomainPasswordPolicy
$password_age = (Get-Date) - $user.PasswordLastSet
$password_age_days = $password_age.TotalDays
$password_policy_for_one_user = @{
    "Password Never Expires" = $user.PasswordNeverExpires
    "Password Last Set" = $user.PasswordLastSet
    "Password Age Days" = $password_age_days
    "Password Expired" = $user.PasswordExpired
    "Minimum Password Length" = $domain_policy.MinPasswordLength
    "Minimum Password Age" = $domain_policy.MinPasswordAge
    "Maximum Password Age" = $domain_policy.MaxPasswordAge
    "Password Complexity" = $domain_policy.ComplexityEnabled
    "Password HistoryCount" = $domain_policy.HistoryLength
    "Lockout Threshold" = $domain_policy.LockoutThreshold
    "Lockout Duration" = $domain_policy.LockoutDuration
}
$password_policy_for_one_user

Name                            Value
----                            -----
"Lockout Duration"              00:30:00
"Password Last Set"             7/16/2023 4:35:46 PM
"Minimum Password Length"       7
"Password Expired"              False
"Password Complexity"           True
"Lockout Threshold"             0
"Password Age Days"             0.293340765600694
"Minimum Password Age"          1.00:00:00
"Maximum Password Age"          42.00:00:00
"Password History Count"        {}  
"Password Never Expires"        False

Using net accounts Command

Use the net accounts command to get password policy details on the local computer.

net accounts

Force user logoff how long after time expires?:     Never
Minimum password age (days):                        1
Maximum password age (days):                        42
Minimum password length:                            7
Length of password history maintained:              24
Lockout threshold:                                  Never
Lockout duration (minutes):                         30
Lockout observation window (minutes):               30
Computer role:                                      PRIMARY
The command completed successfully.

Using Group Policy Management Editor

To use the group policy management editor, follow the given steps:

Step 1: Open group policy management editor.

Step 2: Navigate to the Default Domain Policy. Right-click on it and select Edit.

Step 3: Navigate to the Password Policy as shown in the following screenshot. You will find the password policy on the left hand (see box number 2). Double-click on any property in the box-2 to edit the details (if you want).

That’s all about how to get password policy for user in active directory in PowerShell.

In environments where internet access is controlled through a proxy, PowerShell scripts often need to be aware of these settings to function correctly. This article will guide you through different methods to get proxy settings using PowerShell, focusing on the proxy address, port, and its operational status.

2. Using Net.WebProxy Class

The Net.WebProxy class from the .NET Framework is a straightforward approach to obtain the system’s default proxy settings.

$proxy = [System.Net.WebProxy]::GetDefaultProxy()
"Address: " + $proxy.Address
"Bypass On Local: " + $proxy.BypassProxyOnLocal

Here,
[System.Net.WebProxy]::GetDefaultProxy(): Retrieves the default proxy settings.
$proxy.Address: Shows the proxy server’s URI.
$proxy.BypassProxyOnLocal: Indicates if local addresses bypass the proxy.

The settings and information obtained through Net.WebProxy are relevant to applications using the .NET framework. They may not reflect proxy configurations used by non-.NET applications or services.

3. Using netsh Command

The netsh (Network Shell) is the command-line tool in Windows, utilized to communicate with different network-related settings.

Let’s use netsh command to get proxy settings:

netsh winhttp show proxy

Current WinHTTP proxy settings:
    Proxy Server(s) : 10.0.0.21:8080
    Bypass List     : (none)

On Windows machines, the above command is useful for checking the current proxy settings and it is beneficial for verifying proxy settings and troubleshooting network connectivity.

The winhttp specified the context for the netsh, which indicates that we desire to work with the Windows HTTP services settings (WinHTTP settings). The show proxy is the particular command within the WinHTTP context, which displays the current proxy settings on the PowerShell console.

After executing this command, we got the current proxy server, port number, and any bypass list that had been configured (see the above output).

It’s important to note that netsh winhttp show proxy does not display the proxy settings configured for a user in their web browser (like Internet Explorer, Chrome, or Firefox). Those settings are user-specific and are stored separately from the WinHTTP settings.

4. Accessing Internet Explorer Proxy Settings

Accessing Internet Explorer Proxy Settings involves querying the Windows Registry to find out the proxy configuration specifically set for Internet Explorer (IE). This approach is based on the fact that many Windows applications, including some older or legacy systems, use the proxy settings defined in Internet Explorer.

Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Internet Settings" | 
Select ProxyEnable, ProxyServer

ProxyEnable         ProxyServer
-----------         -----------
         1          10.0.0.21:8080

The above code got the proxy settings from the Windows registry. How? In this example, we used the Get-ItemProperty cmdlet to get the properties of the specified item. In our case, it was the registry key specified using the -Path parameter.

In the registry key path, the HKCU denotes the HKEY_CURRENT_USER hive in the Windows registry. This registry key contains Internet Settings, particularly the proxy settings for the current user. We piped the output of the Get-ItemProperty cmdlet to the Select cmdlet to choose the ProxyEnable and ProxyServer properties with corresponding values.

The ProxyEnable shows the status of the proxy whether it is enabled or not. If the value of the ProxyEnable property is 1, it meant the proxy is enabled. Whereas, the value of 0 for this property represents that the proxy is not enabled. The ProxyServer property contains the proxy-server related details as Server_IP:Port.

The Select cmdlet is an alias of the Select-Object cmdlet in PowerShell.

5. Using WebRequest Class

This method involves creating a web request to extract proxy settings using WebRequest class.

$request = [System.Net.WebRequest]::Create("http://www.example.com")
$proxy = $request.Proxy
if ($null -ne $proxy) {
    "Proxy URI: " + $proxy.GetProxy($request.RequestUri).ToString()
} else {
    "No proxy"
}

WebRequest: creates an object for a specific URL.
$request.Proxy: Retrieves the proxy used by this request.
GetProxy($request.RequestUri).ToString(): Outputs the proxy’s URI.

6. Using Windows Settings

Navigate to the Windows Settings > Network & Internet > Proxy and see the details about the proxy server; check the following screenshot.

We can also use chrome://net-internals/#proxy in Google address bar and click Enter.

7. Conclusion

We explored four methods to obtain proxy settings in PowerShell, catering to various network configurations and requirements.

These methods range from using .NET Framework classes, querying the Windows Registry, to executing system commands like netsh. Each technique offers a reliable way to ensure that PowerShell scripts can correctly identify and utilize proxy settings in a networked environment.

We can have multiple use cases for getting memory usage percentages. For example:

• Getting overall memory usage percentage
• Getting overall memory usage percentage history
• Getting memory usage percentage for one/all processes

Let’s learn them one by one.

Overcall Memory Usage Percentage

We can use Get-Counter and Get-WmiObject cmdlets to retrieve the overall memory usage percentage. Let’s explore them below in detail.

Use Get-Counter Cmdlet

Use the Get-Counter cmdlet to get total memory usage in percentage.

$performance_counter = Get-Counter '\Memory\% Committed Bytes In Use'
$usedMemoryPercentage = $performance_counter.CounterSamples[0].CookedValue
Write-Host "Used Memory Percentage: $usedMemoryPercentage%"

Used Memory Percentage: 57.7237514214878%

We used the Get-Counter cmdlet to get the performance counter for the percentage of used memory bytes on the system and stored it in the $performance_counter variable. The counter path '\Memory\% Committed Bytes In Use' specified the memory counter that measured the proportion of committed memory bytes compared to the total physical memory available.

Then, we retrieved the performance counter’s value from $performance_counter and assigned it to the $usedMemoryPercentage variable. Now, how did we get the value of the performance counter? For that, we used the CounterSamples property of the $performance_counter variable, which contained an array of performance counter samples.

Since we intended to retrieve the first counter sample, we used [0] to access it. Then, we used the CookedValue property of the counter sample to get the message usage percentage. Finally, we used the Write-Host to display it on the PowerShell console.

Use Get-WmiObject Cmdlet

Use the Get-WmiObject cmdlet to get the memory usage percentage if you use PowerShell version 3.0 or earlier.

$usedMemory = Get-WmiObject -Class Win32_OperatingSystem
$totalMemory = $usedMemory.TotalVisibleMemorySize
$freeMemory = $usedMemory.FreePhysicalMemory
$usedMemoryPercentage = ($totalMemory - $freeMemory) / $totalMemory * 100
Write-Host "Used Memory Percentage: $usedMemoryPercentage%"

Used Memory Percentage: 54.8795984097428%

We used the Get-WmiObject cmdlet to get details about the OS, particularly the Win32_OperatingSystem, which we specified using -Class parameter. We stored the retrieved details in the $usedMemory variable.

Then, we used the TotalVisibleMemorySize and FreePhysicalMemory properties of the $usedMemory variable to get the visible memory size and free physical memory, respectively. We stored them in two separate variables named $totalMemory and $freeMemory.

After that, we calculated the percentage of the memory usage by subtracting the amount of $freeMemory from the $totalMemory, dividing the output by the $totalMemory, then multiplying it by 100. Finally, we stored this calculated percentage in the $usedMemoryPercentage variable, which we further used with the Write-Host cmdlet to print on the PowerShell console.

Prefer using Get-CimInstance cmdlet if you are using PowerShell version 3.0 or higher because the Get-WmiObject has been superseded by Get-CimInstance since PowerShell 3.0.

$usedMemory = Get-CimInstance -Class Win32_OperatingSystem
$totalMemory = $usedMemory.TotalVisibleMemorySize
$freeMemory = $usedMemory.FreePhysicalMemory
$usedMemoryPercentage = ($totalMemory - $freeMemory) / $totalMemory * 100
Write-Host "Used Memory Percentage: $usedMemoryPercentage%"

Used Memory Percentage: 54.8795984097428%

Until now, we have learned how to get the overall memory usage percentage; what if you only want to know how much memory percentage has been consumed by the current process on your machine? Let’s see how we can do it.

Overcall Memory Usage Percentage History

Use the Get-Counter cmdlet to get the overall memory usage percentage history.

Get-Counter '\Memory\% Committed Bytes In Use' -Continuous -SampleInterval 5

Timestamp                  CounterSamples
---------                  --------------
7/15/2023 11:38:12 AM      \\desktop-nkk10jm\memory\% committed bytes in use :
                           57.3812244593588

7/15/2023 11:38:17 AM      \\desktop-nkk10jm\memory\% committed bytes in use :
                           57.3770478035736

7/15/2023 11:38:22 AM      \\desktop-nkk10jm\memory\% committed bytes in use :
                           57.3751683014853

7/15/2023 11:38:27 AM      \\desktop-nkk10jm\memory\% committed bytes in use :
                           57.3706575337263

We already learned the Get-Counter cmdlet and counter path in the first example code. Here, we set the -SampleInterval parameter to 5 to get performance counter data for the percentage of the committed memory bytes in use, with the sample interval of 5 seconds. However, the -Continous parameter was used to continuously update the data until the user entered Ctrl+C from the keyboard to stop it.

Memory Usage Percentage for One/More Processes

We can use the Get-Process and Get-WmiObject cmdlets to find the memory usage percentage for one or all processes.

Use Get-Process Cmdlet

Use the Get-Process cmdlet to get the memory usage percentage for the current process on the local machine.

$current_process = Get-Process -Id $PID
$usedMemoryPercentage = ($current_process.WorkingSet / (Get-WmiObject -Class Win32_ComputerSystem).TotalPhysicalMemory) * 100
Write-Host "Used Memory Percentage: $usedMemoryPercentage%"

Used Memory Percentage: 0.918036721468859%

We used the Get-Process cmdlet with the -Id parameter to get the information about the current process. We specified the current process using the $PID variable, which contained the process ID (a.k.a PID) of the current PowerShell process.

By setting the -Id with $PID, we got the process details for the current PowerShell session, which we assigned to the $current_process variable.

Then, we calculated the memory usage percentage and assigned it to the $usedMemoryPercentage variable, which was used with Write-Host to display on the console. But how did we calculate the memory usage percentage?

For that, we divided the WorkingSet property of the $current_process object (which contained the amount of memory the process was using) by the TotalPhysicalMemory property of the Win32_ComputerSystem WMI class (which contained the total amount of physical memory installed on the computer), and then multiplying the result by 100.

This way, the above code retrieved the process object of the current process, calculated the memory usage percentage of that process, and then displayed the output on the PowerShell console.

Use Get-WmiObject Cmdlet

Use the Get-WmiObject cmdlet to get the memory usage percentage for all the processes on the local machine.

Get-WmiObject -Class Win32_PerfFormattedData_PerfProc_Process |
Select-Object Name, IDProcess, 
@{Name="Memory Usage %";Expression={($_.WorkingSetPrivate / (Get-WmiObject Win32_ComputerSystem).TotalPhysicalMemory) * 100}}

Name                           IDProcess       Memory Usage %
----                           ---------       --------------
ApplicationFrameHost                8556   0.0132102058275879
CalculatorApp                      15368  0.00387112258683896
CompPkgSrv                         14692  0.00532279355690357
CxMonSvc                            3224   0.0582120058995908
CxUtilSvc                           3248  0.00503245936289065
Greenshot                          10684   0.0124359813102202
HPHotkeyNotification               15640  0.00832291356170376
HotKeyServiceUWP                    3740    0.011323033566504
HxAccounts                         10436   0.0434533510372673
HxOutlook                            480 0.000435501291019383
HxTsr                               5836   0.0515343194372936
Idle                                   0 9.67780646709739E-05
IntelCpHDCPSvc                      1264                    0
IntelCpHeciSvc                      1384  0.00508084839522613
LanWlanWwanSwitchingServiceUWP      3104   0.0180007200288012
Locator                             3504                    0
Memory Compression                  1888     3.33555277694979
MicTray64                           2348  0.00479051420121321
...                                 ...   ...
...                                 ...   ...
...                                 ...   ...

The above code retrieved information about the currently running processes on the machine and calculated the memory usage percentage by each process. How?

First, we used the Get-WmiObject cmdlet with Win32_PerfFormattedData_PerfProc_Process class to get performance counter date for all the processes running on the machine. Note that we used the -Class parameter to specify the Win32_PerfFormattedData_PerfProc_Process class; however, we can also omit this parameter.

Then, we piped the output, produced by the Get-WmiObject, to the Select-Object cmdlet to select the Name, IDProcess, and corresponding memory usage percentage. We calculated the memory percentage by dividing the process’s private working set by the computer’s total physical memory and then multiplying it by 100.

Note that we used a HashTable to create a calculated property named Memory Usage %.

That’s all about how to get memory usage percentage in PowerShell.

Use an environment variable to get a fully qualified domain name.

$computer_name = $env:COMPUTERNAME
$fqdn = $env:USERDNSDOMAIN
Write-Output "Fully Qualified Domain Name: $computer_name.$fqdn"

Fully Qualified Domain Name: MAS-DC-01.MASLAB.COM

First, we assigned the value of the environment variable ($evn:COMPUTERNAME) to the $computer_name variable. The environment variable COMPUTERNAME stored the current computer’s name or you can say the current host’s name; both meaning the same.

Then, we assigned the $fqdn variable with the value of the $env:USERDNSDOMAIN environment variable. Here, the USERDNSDOMAIN stored the DNS domain name, which was associated with the current user. This meant it indicated the domain name in which the user account was registered.

Finally, we joined the value of the $computer_name and $fqdn by separating them with a dot. We used the Write-Output cmdlet to display it on the PowerShell console.

Using System.Net.Dns Class

Use the System.Net.Dns class to get a fully qualified domain name.

$host_name = [System.Net.Dns]::GetHostName()
$ip_addresses = [System.Net.Dns]::GetHostAddresses($host_name)
foreach ($current_ip in $ip_addresses) {
    if ($current_ip.AddressFamily -eq 'InterNetwork') {
        $fqdn = [System.Net.Dns]::GetHostEntry($current_ip).HostName
        break
    }
}
Write-Output "Fully Qualified Domain Name: $fqdn"

Fully Qualified Domain Name: MAS-DC-01.maslab.com

The GetHostName() method was called using the Dns class. We used it to retrieve the local machine name, which was further assigned to the $host_name variable.

We used another method called GetHostAddresses(), providing it with the $host_name as a parameter to get an array of all IP addresses associated with the $host_name. We stored this array in the $ip_addresses variable.

Then, we used the foreach loop to loop the $ip_addresses array. In each iteration, we used the if statement with the -eq (equal to) operator to determine whether the address family (AddressFamily) of a current IP address ($current_ip) was equal to the InterNetwork, which resembled the IPv4 addresses.

The GetHostEntry() method, which required the $current_ip parameter to create a System.Net.IPHostEntry object, was utilized if the requirement was met. We used the HostName property of the System.Net.IPHostEntry object to get the FQDN, which was stored in the $fqdn variable. Next, we exit the loop using the break statement.

Why did we exit the for loop? Because we only wanted to use the first IPv4 address to get the FQDN. Lastly, we used the Write-Output cmdlet to print $fqdn on the console.

The following are the one-line solution:

[System.Net.Dns]::GetHostEntry($env:COMPUTERNAME).HostName
#OR
[System.Net.Dns]::GetHostEntry([string]"localhost").HostName

MAS-DC-01.maslab.com
MAS-DC-01.maslab.com

According to the documentation, the GetHostByName() and Resolve() methods are deprecated ..

Using ping Command

Use the ping command to get a fully qualified domain name.

$fqdn= $(ping localhost -n 1)[1].split(" ")[1]
Write-Output "Fully Qualified Domain Name: $fqdn"

Fully Qualified Domain Name: MAS-DC-01.maslab.com

We used the ping command, which is a PowerShell command to get the local computer’s FQDN by pinging the hostname and parsing the result. How did the ping work in the above example? The ping localhost -n 1 was used to ping the local computer once to retrieve the hostname and IP address.

Then, we used the command substitution ($(...)) to capture the output of the ping localhost -n 1 command; however, the [1] got the captured output’s second line containing the hostname. Moreover, we chained the split(" ") method to split this second line into the array of words using a space as a delimiter and retrieved the second word (a hostname) by accessing the 1 index as [1].

We stored the final output in the $fqdn variable, which was further used with the Write-Output cmdlet to print its value on the PowerShell console.

If you do not access the index 1 twice as demonstrated in the above example, you will get more detailed output including the information about packets (sent, received, lost), round trip times (minimum, maximum, average), etc.

Using Get-WmiObject Cmdlet

Use the Get-WmiObject cmdlet to get a fully qualified domain name.

$computer_name = $env:COMPUTERNAME
$wmi_obj = Get-WmiObject -Class Win32_ComputerSystem -Namespace 'root\CIMv2'
$domain_name = $wmi_obj.Domain
Write-Output "Fully Qualified Domain Name: $computer_name.$domain_name"

Fully Qualified Domain Name: MAS-DC-01.maslab.com

We started by using the $env:COMPUTERNAME environment variable to get the computer name of a local machine and saved it in the $computer_name variable. Remember, the $env:COMPUTERNAME contained the current computer’s name.

Then, we used the Get-WmiObject cmdlet to query the Windows Management Instrumentation to get details about a computer system; particularly, we targeted the Win32_ComputerSystem class of root\CIMv2 namespace, which contained different properties about computer’s operating system and hardware. We stored the details in the $wmi_obj variable. Here, the $wmi_obj represented the WMI object.

We specified the Win32_ComputerName class and 'root\CIMv2' namespace using -Class and -NameSpace parameters, respectively.

Further, we used this variable to access the value of its Domain property representing the name of an Active Directory domain to which a computer was joined. The resulting value was stored in the $domain_name variable. Finally, we used the Write-Output cmdlet to print the fully qualified domain name on the PowerShell console.

Alternatively, we can use the alias of the Get-WmiObject cmdlet as demonstrated below:

(gwmi -Class Win32_ComputerSystem).DNSHostName+"."+(gwmi -Class Win32_ComputerSystem).Domain

MAS-DC-01.maslab.com

Here, we used the .DNSHostName and .Domain properties to get the local machine’s computer name and the domain to which the local computer was joined. We concatenated the both using concatenation operator (+) by separating them with a dot (.).

Using Get-CimInstance Cmdlet

Use the Get-CimInstance cmdlet to get a fully qualified domain name. Go ahead with the below solution if you’re using PowerShell 3.0+. Why? As of PowerShell 3.0, the Get-WmiObject has been superseded by Get-CimInstance. Remember, you can use Get-CimInstance on Windows platforms only.

(Get-CimInstance -Class Win32_ComputerSystem).Name+"."+(Get-CimInstance -ClassWin32_ComputerSystem).Domain

MAS-DC-01.maslab.com

This snippet resembles the last example learned in the previous section but we used GetCimInstance cmdlet to retrieve information about the Win32_ComputerSystem class. We used the .Name and .Domain properties to get the name of a local computer and the domain to which this computer was joined.

Using Get-ADComputer Cmdlet

Use the Get-ADComputer cmdlet to get a fully qualified domain name. You must install the Active Directory on your machine to use this cmdlet.

$fqdn = (Get-ADComputer $(hostname)).DNSHostName
Write-Output "Fully Qualified Domain Name: $fqdn"

Fully Qualified Domain Name: MAS-DC-01.maslab.com

The above command retrieved the local computer’s DNS hostname using the Active Directory module. How did it work? We used the hostname command as $(hostname) to get the hostname of a local computer, which was specified as an argument to the Get-ADComputer cmdlet.

Then, the Get-ADComputer cmdlet accessed the information regarding a computer object in the Active Directory. Finally, we used the DNSHostName property to have the DNS hostname of the computer object. We assigned the resulting value to the $fqdn variable to further display it on the console using the Write-Output cmdlet.

Using Registry

Use the registry to get a fully qualified domain name. You can use this solution if you have installed Active Directory on your computer.

$domain_name = (Get-ItemProperty -Path 'HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters').Domain
$computer_name = $env:COMPUTERNAME
$fqdn = "$computer_name.$domain_name"
Write-Output "Fully Qualified Domain Name: $fqdn"

Fully Qualified Domain Name: MAS-DC-01.maslab.com

We used the Get-ItemProperty cmdlet to access the ‘HKLM:\SYSTEM\CurrentControlSet\Services\Tcpip\Parameters’ registry key to retrieve its properties. The registry key we used for this code contained network-related configuration settings.

We used the .Domain property to retrieve the domain name of the computer. This domain name is often set in the registry when a computer connects to the Active Directory domain. We stored the value of the .Domain property in the $domain_name variable.

After that, we used the $env:COMPUTERNAME to get the local computer’s name and stored it in the $computer_name variable. Next, we joined the $computer_name and $domain_name by separating them using a dot (.), and assigned the concatenated value to the $fqdn variable, which was further used with Write-Output to display it on the PowerShell console.

That’s all about how to get fully qualified domain name in PowerShell.

We can use the ConvertFrom-Json cmdlet to traverse the JSON file with first and nested-level keys; Let’s explore them below.

Traverse JSON File Containing First-Level Keys

Use ConvertFrom-Json with the foreach loop to traverse the JSON file having first-level keys only.

{
    "name": "John Christoper",
    "age": 40,
    "city": "Washington"
}

$jsonData = Get-Content -Path "./file.json" -Raw | ConvertFrom-Json
foreach ($current_property in $jsonData.PSObject.Properties) {
    Write-Host "$($current_property.Name): $($current_property.Value)"
}

name: John Christoper
age: 40
city: Washington

We used the Get-Content cmdlet to read the contents of a JSON file located at ./file.json path, which we specified using the -Path parameter. The -Raw parameter ensured the file’s entire content was read as a single string before passing to the ConvertFrom-Json cmdlet.

We used the ConvertFrom-Json cmdlet to convert the JSON string into a PowerShell object (PSObject), which we stored in the $jsonData variable. Then, we used the for loop to iterate over all properties in the $jsonData.

How did we retrieve all properties? This expression $json.PSObject.Properties retrieved the properties of the $jsonData object as a collection.

For each property ($current_property), we used $current_property.Name and $current_property.Value to retrieve the current property name and its corresponding value, respectively.

After that, we constructed a string by combining the property name and its value as "$($current_property.Name): $($current_property.Value)" to further display on the PowerShell console using the Write-Host cmdlet.

Let’s take another example, but we will take the key from the user this time; see the following example.

{
    "name": "John Christoper",
    "age": 40,
    "city": "Washington"
}

$jsonData = Get-Content -Path "./file.json" -Raw | ConvertFrom-Json
$key = Read-Host -Prompt "Enter key"

foreach ($record in $jsonData) {
   if ($record |
       Select-Object -ExpandProperty $key -ErrorAction SilentlyContinue){
           Write-Host "$($record.$key)"
    }else{
           Write-Host "The given key was not found."
    }
}

Enter key: name
John Christopher

Enter key: random
The given key was not found.

Again, we used the Get-Content and ConvertFrom-Json to read the JSON file’s content and assign it to the $jsonData variable. After that, we used the Read-Host cmdlet with the -Prompt parameter to prompt the user and enter the desired key. We stored this key in the $key variable.

Next, we used the foreach loop (a.k.a. foreach statement) to iterate over the $jsonData. In each iteration, we piped the $record to the Select-Object cmdlet with the -ExpandProperty parameter to select and expand the property given by the $key.

We set the -ErrorAction to the SilentlyContinue to suppress the error message because we wanted to show our custom message rather than the error generated by the PowerShell.

So, if the $key was present in the JSON file, the Write-Host cmdlet from the if block would be executed to print the corresponding value; otherwise, the else block would be executed to display a message on the console saying the given know not found.

Let’s dive deeper and work with the JSON file with nested keys.

Traverse JSON File Containing First-Level Keys

Use ConvertFrom-Json with the foreach loop to traverse the JSON file having nested keys.

{
    "student1": {
        "name": {
            "firstName": "John",
            "lastName": "Doe"
        },
        "age": 30,
        "Courses": {
            "CS123": "Introduction to Computer Science",
            "DS234": "Introduction to DataScience"
        }
    },
    "student2": {
        "name": {
            "firstName": "Thomas",
            "lastName": "Nelsan"
        },
        "age": 28,
        "Courses": {
            "CS123": "Java Programming",
            "Ph234": "Introduction to Psychology"
        }
    }
}

#Define a function named TraverseJson that takes a JSON object ($json)
#and an optional prefix ($prefix)
function TraverseJson($json, $prefix = '') {

    # Iterate over each property in the JSON object
    foreach ($property in $json.PSObject.Properties) {

        # Get the name and value of the property
        $propertyName = $property.Name
        $propertyValue = $property.Value

        # Check if the property value is a nested object
        if ($propertyValue -is [System.Management.Automation.PSCustomObject]) {

            # Check if it's the first level of keys
            if ($prefix -eq '') {
                # Display the available first-level keys
                Write-Host "First level keys:"
                foreach ($firstLevelKey in $json.PSObject.Properties.Name) {
                    Write-Host "- $firstLevelKey"
                }

                # Prompt the user to choose a first-level key
                $firstLevelKey = Read-Host "Choose a first level key (enter 'exit' to exit)"

                # If 'exit' is entered, return and exit the recursion
                if ($firstLevelKey -eq "exit") {
                    return
                }

                # If the chosen first-level key is valid
                elseif ($json.PSObject.Properties.Name -contains $firstLevelKey) {
                    # Get the available second-level keys for the chosen first-level key
                    $secondLevelKeys = $json.$firstLevelKey.PSObject.Properties.Name
                    Write-Host "Second level keys under '$firstLevelKey':"
                    foreach ($secondLevelKey in $secondLevelKeys) {
                        Write-Host "- $secondLevelKey"
                    }

                    # Prompt the user to choose a second-level key
                    $secondLevelKey = Read-Host "Choose a second level key (enter 'exit' to exit)"

                    # If 'exit' is entered, return and exit the recursion
                    if ($secondLevelKey -eq "exit") {
                        return
                    }

                    # If the chosen second-level key is valid
                    elseif ($secondLevelKeys -contains $secondLevelKey) {
                        # Get the nested value corresponding to the chosen keys
                        $nestedValue = $json.$firstLevelKey.$secondLevelKey
                        Write-Host "Value of '$firstLevelKey.$secondLevelKey': $nestedValue"
                    }

                    else {
                        Write-Host "Invalid second level key. Please try again."
                    }

                    # Recursively call the TraverseJson function with the
                    #nested value and an updated prefix
                    TraverseJson $json.$firstLevelKey.$secondLevelKey ($firstLevelKey + '.' + $secondLevelKey + '.')
                }
                else {
                    Write-Host "Invalid first level key. Please try again."
                }

                # Return to exit the recursion
                return
            }

            # If it's not the first level of keys
            else {
                # Recursively call the TraverseJson function with the
                #nested object and an updated prefix
                TraverseJson $propertyValue ($prefix + $propertyName + '.')
            }
        }

        # If the property value is an ArrayList
        elseif ($propertyValue -is [System.Collections.ArrayList]) {
            # Iterate over each item in the ArrayList
            $index = 0
            foreach ($item in $propertyValue) {
                #Recursively call the TraverseJson function with the item
                #and an updated prefix, including the array index
                TraverseJson $item ($prefix + $propertyName + "[$index].")
                $index++
            }
        }

        # If it's a regular property (not a nested object or ArrayList)
        else {
            # Display the key and value
            Write-Host "${prefix}${propertyName}: ${propertyValue}"
        }
    }
}

#Read the content of the JSON file and convert it to a JSON object
$json = Get-Content -Path "./file.json" -Raw | ConvertFrom-Json

#Call the TraverseJson function with the JSON object
TraverseJson $json

First level keys:
- student1
- student2
Choose a first level key from the options above (or enter 'exit' to exit): student1
Second level keys under 'student1':
- name
- age
- Courses
Choose a second level key from the options above (or enter 'exit' to exit): age
Value of 'student1.age': 30

First level keys:
- student1
- student2
Choose a first level key from the options above (or enter 'exit' to exit): student2
Second level keys under 'student2':
- name
- age
- Courses
Choose a second level key from the options above (or enter 'exit' to exit): Courses
Value of 'student2.Courses': @{CS123=Java Programming; Ph234=Introduction to Psychology}
student2.Courses.CS123: Java Programming
student2.Courses.Ph234: Introduction to Psychology

Don’t be afraid to look at the code; it is very simple and straightforward; Let’s learn it step by step below:

• First, we defined the TraverseJson function, which took two parameters: $json represented the JSON object, and $prefiex stored the prefix for nested keys. This function recursively traversed the JSON object and displayed the key-value pairs.
• The TraverseJson function began with the foreach loop, which iterated over the properties of the $json object using $json.PSObject.Properties.
• Inside the foreach loop, the name and value for every property are assigned to the $propertyName and $propertyValue variables, respectively.
• Then, the above code checked if the $propertyValue was a nested object using the -is operator and the type [System.Management.Automation.PSCustomObject]. If it was, the code entered the if block.
• There was an additional check for the $prefix variable within the if block. We were at the first level of keys if it was an empty string. In this case, the code displayed the available first-level keys by iterating over $json.PSObject.Properties.Name and prompted the user to choose a first-level key.
• If the user entered exit, the function returned and exited the recursion. Otherwise, if the chosen first-level key was valid ($json.PSObject.Properties.Name -contains $firstLevelKey), the code displayed the available second-level keys for the chosen first-level key.
• The second-level keys were obtained from $json.$firstLevelKey.PSObject.Properties.Name and displayed to the user.
• The user was prompted to choose a second-level key. If exit was entered, the function returned and exited the recursion. If the chosen second-level key was valid ($secondLevelKeys -contains $secondLevelKey), the code retrieved the corresponding nested value using $json.$firstLevelKey.$secondLevelKey and displayed it.
• If the chosen second-level key was invalid, an error message was displayed, and the user was prompted to try again.
• Finally, the TraverseJson function called itself recursively with the selected nested value ($json.$firstLevelKey.$secondLevelKey) and an updated prefix ($firstLevelKey + '.' + $secondLevelKey + '.').
• If the $prefix was not empty (indicating nested keys), the function recursively called TraverseJson on the nested object ($propertyValue) with an updated prefix ($prefix + $propertyName + '.').
• If the $propertyValue was an ArrayList, the code entered an elseif block and iterated over each item in the ArrayList using a foreach loop. It recursively called TraverseJson on every item with an updated prefix that included the array index.
• If the $propertyValue was neither a nested object nor an ArrayList, it entered the else block and displayed the full key path along with the corresponding value using the Write-Host cmdlet.
• Finally, outside the function, the code read the JSON file content using the Get-Content cmdlet, converted it to a JSON object using ConvertFrom-Json, and called the TraverseJson function with the JSON object.

So, the above code allowed the user to interactively traverse a JSON object, select keys at different levels, and view their corresponding values. This code is limited to second-level keys; you can add value to it to fit your requirements.

What is the importance of using ConvertFrom-Json, which compels us to use it in every above solution? Because PowerShell can’t iterate over the JSON objects directly, we used the ConvertFrom-Json to convert the JSON string to a PSCustomObject, where each property represents a JSON field.

The above solutions will work if you use PowerShell version 3.0+; run the $PSVersionTable.PSVersion to check your PowerShell version. If you are using PowerShell version 2.0 or looking for an alternative, the following solution is for you.

Using JavaScriptSerializer Class

Use the JavaScriptSerializer class to loop through the JSON if you are using PowerShell version 2.0.

Add-Type -AssemblyName System.Web.Extensions
$JS = New-Object System.Web.Script.Serialization.JavaScriptSerializer
$json = @'
[{"id":1,"firstName":"John","lastName":"Doe","age":32},
{"id":2,"firstName":"Thomas","lastName":"Christoper","age":30},{"id":3,"firstName":"Johny","lastName":"Daniel","age":29}]
'@
$data = $JS.DeserializeObject($json)
$data.GetEnumerator() | foreach-Object {
    foreach ($key in $_.Keys){
        Write-Host "$key : $($_[$key])"
    }
}

id : 1
firstName : John
lastName : Doe
age : 32
id : 2
firstName : Thomas
lastName : Christoper
age : 30
id : 3
firstName : Johny
lastName : Daniel
age : 29

First, we used the Add-Type command to load the System.Web.Extensions assembly into the current session. This assembly provides classes for working with JSON data in .NET applications.

Then, we used the New-Object cmdlet to create an object of the JavaScriptSerializer class from the System.Web.Script.Serialization namespace, which we stored in the $JS variable.

After that, we used the DeserializeObject() method of the $JS object. This method took JSON string ($json) as a parameter to deserialize it into the PowerShell object. We stored the resulting object in the $data variable.

Next, we loop through each item in the $data using the GetEnumerator() method and foreach-Object cmdlet. Inside the foreach-Object, we used the foreach loop with the Keys property of the current item to iterate over each key in the current item. We displayed the corresponding key-value pair using the Write-Host cmdlet.

That’s all about how to Loop through JSON File in PowerShell.

Using Get-History to get the complete history of the executed commands in PowerShell.

Get-History

Id CommandLine
  -- -----------
   1 Get-History
   2 ls
   3 ping example.com
   4 Get-History
   5 Get-History
   6 Get-Process
   7 Get-Service

In this example, the history of the commands is obtained using the Get-History cmdlet. On execution of the above code, we can see the list of executed commands is returned and displayed on the screen with their respective Id (showing the sequence of the execution of the commands) and the CommandLine (showing the text or command we entered). From the above output, we can see 7 commands were executed in PowerShell.

By default, Get-History does not display all the object properties on execution. To display all the object properties on the console consider the below example:

Get-History | Select-Object -Property *

Id                 : 1
CommandLine        : Get-History
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:37:00 PM
EndExecutionTime   : 7/19/2023 3:37:00 PM

Id                 : 2
CommandLine        : ls
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:37:04 PM
EndExecutionTime   : 7/19/2023 3:37:05 PM

Id                 : 3
CommandLine        : ping example.com
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:37:58 PM
EndExecutionTime   : 7/19/2023 3:38:02 PM

Id                 : 4
CommandLine        : Get-History
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:38:13 PM
EndExecutionTime   : 7/19/2023 3:38:13 PM

Id                 : 5
CommandLine        : Get-History
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:52:33 PM
EndExecutionTime   : 7/19/2023 3:52:33 PM

Id                 : 6
CommandLine        : Get-Process
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:53:13 PM
EndExecutionTime   : 7/19/2023 3:53:14 PM

Id                 : 7
CommandLine        : Get-Service
ExecutionStatus    : Completed
StartExecutionTime : 7/19/2023 3:53:25 PM
StartExecutionTime : 7/19/2023 3:53:25 PM

In this code, the output of Get-History is passed to the Select-Object cmdlet using the pipe operator (|) with the -property * option to get all the object properties on the console. We can observe, the given command returned Id, CommandLine, ExecutionStatus and the duration of the command.

Get Specific Commands from the History

If you want to get the last three executed commands from the history check the below example

Get-History -Count 3

Id CommandLine
  -- -----------
   5 Get-History
   6 Get-Process
   7 Get-Service

In the above example, the -Count option is used with the Get-History cmdlet to get the last 3 executed commands from the history. Consider the below example if you want to get the range of commands.

Note: You can change the value of -Count according to your requirement. For example, if you want to get the list of the last 20 executed commands run set count as -Count 20.

Re-execute Commands from History

If you want to run a specific command again from the history that you have executed. Consider the below example.

Invoke-History -Id 6

Get-Process

Handles  NPM(K)    PM(K)      WS(K)     CPU(s)     Id  SI ProcessName
-------  ------    -----      -----     ------     --  -- -----------
    336      19     9204      24588       0.14  11012   5 ApplicationFrameHost
    624      44    29696       1492       1.11  16968   5 CalculatorApp
    285      19    21348      43392       0.50   2152   5 chrome
    387      24   227000     202836      65.38   2772   5 chrome
    445      23    92284     130664      10.91   3184   5 chrome
    283      19    21556      38792       0.28   3564   5 chrome
    325      22    64852     108200      15.77   6476   5 chrome
    370      24   110008     134700       7.47   7424   5 chrome
    246      16    15172      19488       0.56   7628   5 chrome
   1001      44   152880     139736     172.61   7644   5 chrome
    293      20   101448      71412      10.50   7800   5 chrome
    292      20    39724      62776       1.64   8096   5 chrome
    438      23   139896     165516      48.23   8832   5 chrome
    279      19    21992      41580       0.38   9356   5 chrome

In this code snippet, the Invoke-History cmdlet is used to invoke the History command and execute the command with the given id. In the above case, the command id 6 is executed which is the Get-Process cmdlet. Another way to write the same command is as follows:

!6

In this way, you can re-execute the command from the history using the exclamation mark (!) followed by the command id. On execution of this command, you will get the same output as above.

Save the Command History to a File

If you want to save the history of executed commands for the current session in the form of a CSV file for future use check the following example.

Get-History | Export-CSV -Path 'C:\History\CommandHistory.Csv'

In this PowerShell script, the output of Get-History is passed to the Export-CSV cmdlet as input using the | pipe operator. Here, the -Path option is used to specify the path where we want to save the history commands in the form of CSV.

On execution of the above command, no output is displayed on the screen. However, the list of executed commands is stored at path C:\History\CommandHistory.Csv with all the object properties.

Note: The history of executed commands in the current session is stored in memory by default. Once the PowerShell window is closed the history will be lost. To store the history between sessions by default configure the PowerShell to save the history to a file.

Clear History

Use Clear-History to clear the command history in PowerShell.

Clear-History

By executing the above command the history of the current PowerShell session is removed.

That’s all about how to get history of Commands in PowerShell.