਍㰀栀攀愀搀㸀ഀഀ Albert van der Sel : Introduction Powershell ਍㰀洀攀琀愀 栀琀琀瀀ⴀ攀焀甀椀瘀㴀∀䌀漀渀琀攀渀琀ⴀ吀礀瀀攀∀ 挀漀渀琀攀渀琀㴀∀琀攀砀琀⼀栀琀洀氀㬀 挀栀愀爀猀攀琀㴀椀猀漀ⴀ㠀㠀㔀㤀ⴀ㄀∀㸀ഀഀ ਍㰀戀漀搀礀 戀最挀漀氀漀爀㴀∀⌀䐀㠀䐀㠀䐀㠀∀ 氀椀渀欀㴀∀戀氀甀攀∀ 愀氀椀渀欀㴀∀戀氀甀攀∀ 瘀氀椀渀欀㴀∀戀氀甀攀∀㸀ഀഀ ਍㰀栀㄀㸀䄀 猀椀洀瀀氀攀 渀漀琀攀 漀渀 ∀匀挀爀椀瀀琀椀渀最 椀渀 倀漀眀攀爀猀栀攀氀氀∀㰀⼀栀㄀㸀ഀഀ ਍㰀䈀㸀嘀攀爀猀椀漀渀㰀⼀䈀㸀ऀ    㨀 ㄀⸀㄀㰀戀爀㸀ഀഀ Date : 22/04/2013
਍㰀䈀㸀䈀礀㰀⼀䈀㸀ऀऀ    㨀 䄀氀戀攀爀琀 瘀愀渀 搀攀爀 匀攀氀㰀戀爀㸀ഀഀ
਍ഀഀ
਍䤀琀✀猀 渀漀琀 最爀攀愀琀Ⰰ 漀爀 猀漀洀攀琀栀椀渀最⸀⸀⸀⸀ 䈀甀琀Ⰰ 琀栀椀猀 渀漀琀攀 洀椀最栀琀 栀愀瘀攀 猀漀洀攀 瘀愀氀甀攀Ⰰ 椀昀 礀漀甀爀 欀渀漀眀氀攀搀最攀 漀昀 倀漀眀攀爀猀栀攀氀氀 ⠀倀匀⤀㰀戀爀㸀ഀഀ is pretty low.
਍㰀戀爀㸀ഀഀ Everybody can learn it fairly quickly. If even Albert can learn it..., then you can do too... for sure !
਍䈀甀琀Ⰰ 琀栀攀 渀漀琀攀 椀猀 瘀攀爀礀 猀椀洀瀀氀攀 愀渀搀 昀愀椀爀氀礀 猀栀漀爀琀⸀ 吀栀愀琀✀猀 漀渀 瀀甀爀瀀漀猀攀Ⰰ 椀渀 漀爀搀攀爀 琀漀 栀愀瘀攀 愀 焀甀椀挀欀 猀琀愀爀琀甀瀀⸀㰀戀爀㸀ഀഀ
਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Addition 22/01/2018: Chapter 5.
਍㰀戀爀㸀ഀഀ This note was created when Powershell v1/v2/v3 were current. Chapters 1-4 are still very well usable, since they
਍漀渀氀礀 搀攀愀氀猀 眀椀琀栀 琀栀攀 戀愀猀椀挀ⴀⰀ 愀渀搀 猀挀爀椀瀀琀椀渀最 愀挀琀椀漀渀猀Ⰰ 愀渀搀 猀礀渀琀愀砀Ⰰ 愀渀搀 䌀洀搀䰀攀琀✀猀⸀㰀戀爀㸀ഀഀ Chapter 5 is current, that is, also Powershell v4/v5 and modules are covered, specifically targeted for
਍椀渀琀攀爀昀愀挀椀渀最 琀漀 匀儀䰀 匀攀爀瘀攀爀⸀ 匀漀Ⰰ 琀栀攀 攀砀愀洀瀀氀攀 猀栀漀眀渀 椀渀 㐀⸀㜀Ⰰ 椀猀 愀 戀椀琀 漀甀琀搀愀琀攀搀⸀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ Main Contents:
਍㰀戀爀㸀ഀഀ Chapter 1. Introduction: What is it?
਍㰀戀爀㸀ഀഀ Chapter 2. Basic scripting (to get into the "mood").
਍㰀戀爀㸀ഀഀ Chapter 3. A more structured approach: syntaxes, loops, tests, IO.
਍㰀戀爀㸀ഀഀ Chapter 4. Further examples, explained.
਍㰀戀爀㸀ഀഀ .............Example 4.1: delete files from a folder (and subfolders) which are older than "X" days.
਍⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䔀砀愀洀瀀氀攀 㐀⸀㈀㨀 嘀椀攀眀椀渀最 愀渀搀 洀愀渀愀最椀渀最 愀 ∀圀椀渀㈀䬀㠀 ⼀ 圀椀渀㈀䬀㄀㈀ 䘀愀椀氀漀瘀攀爀 䌀氀甀猀琀攀爀∀⸀㰀戀爀㸀ഀഀ .............Example 4.3: Put quotes around the records of a (flat) .csv file.
਍⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䔀砀愀洀瀀氀攀 㐀⸀㐀㨀 匀漀洀攀 䄀䐀 攀砀愀洀瀀氀攀猀⸀㰀戀爀㸀ഀഀ .............Example 4.5: Loop through a text file with accounts and assign file system permissions.
਍⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䔀砀愀洀瀀氀攀 㐀⸀㘀㨀 䌀漀洀瀀愀爀攀 琀砀琀 昀椀氀攀猀 ⠀⸀琀砀琀Ⰰ ⸀挀猀瘀 攀琀挀⸀⸀⸀⤀⸀㰀戀爀㸀ഀഀ .............Example 4.7: Calling a stored procedure, or starting a SQL Agent job, from Powershell.
਍⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䔀砀愀洀瀀氀攀 㐀⸀㠀㨀 䘀椀渀搀椀渀最 琀栀攀 洀漀猀琀 爀攀挀攀渀琀 昀椀氀攀 椀渀 猀漀洀攀 昀漀氀搀攀爀⸀㰀戀爀㸀ഀഀ .............Example 4.9: Rename file(s).
਍⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䔀砀愀洀瀀氀攀 㐀⸀㄀　㨀 ∀吀愀椀氀∀ 漀爀 匀栀漀眀Ⰰ 琀栀攀 攀渀搀 漀昀 氀愀爀最攀 琀砀琀 昀椀氀攀猀 ⠀氀椀欀攀 氀愀爀最攀 氀漀最昀椀氀攀猀⤀⸀㰀戀爀㸀ഀഀ
਍䌀栀愀瀀琀攀爀 㔀⸀ 倀漀眀攀爀猀栀攀氀氀 愀渀搀 匀儀䰀 匀攀爀瘀攀爀⸀㰀戀爀㸀ഀഀ
਍ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
਍㰀戀爀㸀ഀഀ ਍ഀഀ

Chapter 1. Introduction: What is it?

਍ഀഀ ਍ഀഀ Powershell just looks like a "script interpreter" and commandline interface, like a sort of evolution of the "cmd"
਍挀漀洀洀愀渀搀氀椀渀攀 椀渀琀攀爀昀愀挀攀Ⰰ 眀栀椀挀栀 攀砀椀猀琀攀搀 ⠀愀渀搀 猀琀椀氀氀 搀漀攀猀⤀ 椀渀 圀椀渀搀漀眀猀 昀漀爀 洀愀渀礀 礀攀愀爀猀⸀ 䈀甀琀 椀琀✀猀 愀 戀椀琀 洀漀爀攀 琀栀愀渀 琀栀愀琀⸀㰀戀爀㸀ഀഀ
਍䴀椀挀爀漀猀漀昀琀 挀栀漀漀猀攀 倀漀眀攀爀猀栀攀氀氀 愀猀 琀栀攀 瀀氀愀琀昀漀爀洀 昀漀爀 猀挀爀椀瀀琀椀渀最 琀愀猀欀猀 椀渀 最攀渀攀爀愀氀Ⰰ 戀甀琀 眀椀琀栀 愀 猀琀爀漀渀最 愀挀挀攀渀琀 漀渀 愀氀氀 猀漀爀琀猀 漀昀㰀戀爀㸀ഀഀ administrative automation like installing applications, or retrieving information of your local or remote Hosts, or interacting
਍眀椀琀栀 䄀挀琀椀瘀攀 䐀椀爀攀挀琀漀爀礀 ⠀氀椀欀攀 愀甀琀漀洀愀琀攀搀 愀搀搀椀琀椀漀渀⼀搀攀氀攀琀椀漀渀⼀洀漀搀椀昀椀挀愀琀椀漀渀 漀昀 愀挀挀漀甀渀琀猀Ⰰ 漀爀 最攀琀琀椀渀最 氀椀猀琀椀渀最猀 漀昀 愀氀氀 猀漀爀琀猀⤀Ⰰ 攀琀挀⸀⸀ 攀琀挀⸀⸀㰀戀爀㸀ഀഀ
਍嘀攀爀礀 琀礀瀀椀挀愀氀 漀昀 倀漀眀攀爀猀栀攀氀氀Ⰰ 椀猀 琀栀愀琀 礀漀甀 甀猀攀 猀漀挀愀氀氀攀搀 㰀䈀㸀∀䌀漀洀洀愀渀搀䰀攀琀猀∀㰀⼀䈀㸀 ⠀䌀洀搀䰀攀琀猀⤀Ⰰ 眀栀椀挀栀 愀爀攀 瘀攀爀礀 猀瀀攀挀椀昀椀挀 猀洀愀氀氀 瀀椀攀挀攀猀 漀昀 挀漀搀攀Ⰰ 攀愀挀栀 搀攀猀椀最渀攀搀㰀戀爀㸀ഀഀ for specific tasks. You probably need to get used to it, but very typical for working with PS is, is that you place the CmdLets in series, whereas
਍琀栀攀 㰀䤀㸀漀甀琀瀀甀琀㰀⼀䤀㸀 漀昀 愀 昀漀爀洀攀爀 䌀洀搀䰀攀琀Ⰰ 眀椀氀氀 戀攀 琀栀攀 㰀䤀㸀椀渀瀀甀琀㰀⼀䤀㸀 昀漀爀 琀栀攀 昀漀氀氀漀眀椀渀最 䌀洀搀䰀攀琀⸀㰀戀爀㸀ഀഀ
਍䠀攀爀攀 椀猀 愀 瘀攀爀礀 猀椀洀瀀氀攀 攀砀愀洀瀀氀攀㨀㰀戀爀㸀ഀഀ
਍䘀爀漀洀 琀栀攀 漀氀搀 昀愀猀栀椀漀渀攀搀 挀漀洀洀愀渀搀瀀爀漀洀瀀琀 ⠀挀洀搀⤀Ⰰ 琀礀瀀攀 ∀瀀漀眀攀爀猀栀攀氀氀∀ 愀渀搀 瀀爀攀猀猀 䔀渀琀攀爀⸀㰀戀爀㸀ഀഀ Note: often it is neccessary to start the prompt with "Administrative privileges" (RunAs), and later more on this.
਍㰀戀爀㸀ഀഀ ਍ഀഀ C:\> powershell
਍㰀戀爀㸀ഀഀ PS C:\>
਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
਍ഀഀ The powershell prompt, denoted by something like "PS C:\>" will come up. Now just type the following code behind the PS prompt:
਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\> Get-Service | Where-Object {$_.status -eq "running"}
਍ഀഀ ਍㰀戀爀㸀ഀഀ It prints a screen of which background processes (services) are running on your machine.
਍㰀戀爀㸀ഀഀ Here, you have used two CmdLets: "Get-Service" and "Where-Object". The "Get-Service" CmdLet just retrieves a list of all services
਍眀栀椀挀栀 愀爀攀 椀渀猀琀愀氀氀攀搀 漀渀 礀漀甀爀 猀礀猀琀攀洀⸀ 吀栀愀琀✀猀 猀椀洀瀀氀礀 椀琀猀 琀愀猀欀⸀ 一漀爀洀愀氀氀礀Ⰰ 椀琀 眀漀甀氀搀 樀甀猀琀 搀甀洀瀀 琀栀愀琀 漀甀琀瀀甀琀 琀漀 礀漀甀爀 猀挀爀攀攀渀⸀㰀戀爀㸀ഀഀ
਍䠀漀眀攀瘀攀爀Ⰰ 戀礀 甀猀椀渀最 琀栀攀 㰀䈀㸀∀簀∀㰀⼀䈀㸀 ⠀瀀椀瀀攀氀椀渀攀⤀ 猀礀洀戀漀氀Ⰰ 眀攀 爀攀搀椀爀攀挀琀攀搀 琀栀攀 漀甀琀瀀甀琀 昀爀漀洀 ∀䜀攀琀ⴀ匀攀爀瘀椀挀攀∀Ⰰ 琀漀 琀栀攀 渀攀砀琀 䌀洀搀䰀攀琀Ⰰ㰀戀爀㸀ഀഀ namely "Where-Object". So, instead of dumping the records of the output to the screen, the "Where-Object" will receive them
਍愀猀 㰀䈀㸀椀渀瀀甀琀㰀⼀䈀㸀⸀㰀戀爀㸀ഀഀ
਍䄀猀 ∀圀栀攀爀攀ⴀ伀戀樀攀挀琀∀ 最攀琀猀 爀攀挀漀爀搀 戀礀 爀攀挀漀爀搀 昀爀漀洀 ∀䜀攀琀ⴀ匀攀爀瘀椀挀攀∀Ⰰ 礀漀甀 渀攀攀搀 琀漀 琀攀氀氀 椀琀 眀栀愀琀 琀漀 搀漀 眀椀琀栀 椀琀⸀ 吀栀愀琀✀猀 搀攀琀攀爀洀椀渀攀搀 眀椀琀栀椀渀 琀栀攀 㰀䈀㸀∀笀 紀∀㰀⼀䈀㸀猀礀洀戀漀氀猀Ⰰ㰀戀爀㸀ഀഀ because here you see the "condition" that tells "Where-Object" what to do:
਍䤀琀 洀甀猀琀 昀椀氀琀攀爀 琀栀攀 漀甀琀瀀甀琀 漀昀 ∀䜀攀琀ⴀ匀攀爀瘀椀挀攀∀ 琀漀 猀栀漀眀 漀渀氀礀 琀栀攀 㰀䤀㸀爀甀渀渀椀渀最㰀⼀䤀㸀 猀攀爀瘀椀挀攀猀Ⰰ 愀渀搀 渀漀琀 愀氀氀 椀渀猀琀愀氀氀攀搀 猀攀爀瘀椀挀攀猀 ⠀漀昀 眀栀椀挀栀㰀戀爀㸀ഀഀ many maybe not running). Thats actually the condition "status equals running", or in code: {$_.status -eq "running"}.
਍㰀戀爀㸀ഀഀ Now you may still wonder about the "$_" symbol. Indeed, often you do not need need to declare variables beforehand, and some are
਍樀甀猀琀 愀氀爀攀愀搀礀 ∀椀洀瀀氀椀挀椀琀氀礀 琀栀攀爀攀∀ 猀漀 琀漀 猀瀀攀愀欀⸀ ∀␀开∀ 椀猀 愀 猀琀愀渀搀愀爀搀 瘀愀爀椀愀戀氀攀Ⰰ 愀挀琀椀渀最 愀猀 愀 挀漀渀琀愀椀渀攀爀 昀漀爀 爀攀挀漀爀搀猀 搀攀猀琀椀渀攀搀㰀戀爀㸀ഀഀ to, or from, CmdLet's.
਍㰀戀爀㸀ഀഀ It means this:
਍圀攀 栀愀瘀攀 猀攀琀甀瀀 愀 ∀瀀椀瀀攀氀椀渀攀∀ 昀爀漀洀 琀栀攀 ∀䜀攀琀ⴀ匀攀爀瘀椀挀攀∀ 䌀洀搀䰀攀琀Ⰰ 琀漀 琀栀攀 ∀圀栀攀爀攀ⴀ伀戀樀攀挀琀∀ 䌀洀搀䰀攀琀⸀㰀戀爀㸀ഀഀ So, data "streams" from "Get-Service" to "Where-Object"CmdLet. Every record transferred, is contained in the "$_" variable,
਍眀栀椀挀栀 椀猀 愀氀眀愀礀猀 栀漀眀 椀琀 眀漀爀欀猀 椀渀 倀漀眀攀爀猀栀攀氀氀Ⰰ 眀栀攀渀 琀眀漀 䌀洀搀䰀攀琀猀 愀爀攀 挀漀渀渀攀挀琀攀搀 戀礀 愀 瀀椀瀀攀⸀㰀戀爀㸀ഀഀ
਍一漀眀Ⰰ 椀昀 礀漀甀 眀漀甀氀搀 稀漀漀洀 椀渀 椀渀琀漀 漀渀攀 猀甀挀栀 愀 爀攀挀漀爀搀Ⰰ 椀琀 甀猀甀愀氀氀礀 栀愀猀 洀甀氀琀椀瀀氀攀 瀀爀漀瀀攀爀琀椀攀猀 ⠀瘀愀氀甀攀猀⤀Ⰰ 愀渀搀 椀琀 琀栀椀猀 猀瀀攀挀椀昀椀挀 挀愀猀攀Ⰰ㰀戀爀㸀ഀഀ we have a "status" property, which may have either of two values: "running" and "not running".
਍倀漀眀攀爀猀栀攀氀氀 椀猀 愀氀猀漀 ∀伀戀樀攀挀琀 伀爀椀攀渀琀攀搀∀Ⰰ 猀漀 愀渀 ∀漀戀樀攀挀琀∀ 愀猀 愀 爀攀挀漀爀搀 椀渀 ␀开Ⰰ 洀愀礀 栀愀瘀攀 搀椀昀昀攀爀攀渀琀 瀀爀漀瀀攀爀琀椀攀猀⸀㰀戀爀㸀ഀഀ In the example above, $_.status is such a propery, which may have a certain value (like "running").
਍㰀戀爀㸀ഀഀ So, it makes sense to have as a condition for the "Where-Object" CmdLet, the expression {$_.status -eq "running"}.
਍㰀戀爀㸀ഀഀ ⇒ How to run code:
਍㰀戀爀㸀ഀഀ There are two main ways to run code.
਍㰀甀氀㸀ഀഀ
  • Just like above, you simply enter it interactively at the PS prompt. When you are ready typing, you can run it immediately.
    • ਍㰀氀椀㸀伀爀Ⰰ 礀漀甀 瀀氀愀挀攀 挀漀搀攀 椀渀 愀 㰀戀㸀昀椀氀攀㰀⼀戀㸀 ⠀猀挀爀椀瀀琀昀椀氀攀⤀Ⰰ 愀渀搀 琀栀攀渀 礀漀甀 栀愀瘀攀 琀栀攀 挀漀搀攀 猀琀漀爀攀搀Ⰰ 愀渀搀 礀漀甀 挀愀渀 爀甀渀 椀琀 愀渀礀琀椀洀攀 礀漀甀 眀愀渀琀Ⰰ㰀戀爀㸀ഀഀ or you can even schedule it to run for specific date/times. ਍㰀⼀甀氀㸀ഀഀ ਍㰀戀爀㸀ഀഀ ⇒ How to create code (in scriptfiles):
    ਍㰀戀爀㸀ഀഀ There are at least two ways to create powershell code:
    ਍㰀甀氀㸀ഀഀ
  • Simply use notepad or any other (flat file) editor, and save the file in a suitable folder.
    ਍吀栀攀渀Ⰰ 昀爀漀洀 琀栀攀 倀匀 瀀爀漀洀瀀琀 礀漀甀 挀愀渀 攀愀猀椀氀礀 挀愀氀氀 椀琀 氀椀欀攀 昀漀爀 攀砀愀洀瀀氀攀 ∀倀匀 䌀㨀尀吀䔀匀吀匀䌀刀䤀倀吀匀㸀 ⸀尀洀礀猀挀爀椀瀀琀⸀瀀猀㄀∀⸀㰀戀爀㸀ഀഀ Here, the file "myscript.ps1" contains the PS code. Dont worry for now how this works exactly. We will see many examples below.
    • ਍ഀഀ
  • Instead of simply using an editor, since Powershell v. 2, we have the "Integrated Scripting Environment" (ISE) available
    ਍眀栀椀挀栀 椀猀 愀 猀漀爀琀 漀昀 最爀愀瀀栀椀挀愀氀 甀猀攀爀 椀渀琀攀爀昀愀挀攀 椀渀琀攀爀昀愀挀攀Ⰰ 氀椀欀攀 愀 ∀眀漀爀欀戀攀渀挀栀∀ 爀攀愀氀氀礀Ⰰ 琀漀 挀爀攀愀琀攀 猀挀爀椀瀀琀猀⸀㰀⼀氀椀㸀ഀഀ ਍ഀഀ Actually, it doesn't matter too much what you choose. In this note, we simply use an editor to make scripts.
    ਍䄀渀搀Ⰰ 眀栀愀琀攀瘀攀爀 礀漀甀 眀漀甀氀搀 栀愀瘀攀 挀栀漀漀猀攀渀Ⰰ 礀漀甀 渀攀攀搀 琀漀 琀礀瀀攀 挀漀搀攀 愀渀礀眀愀礀⸀ 䈀甀琀Ⰰ 䤀匀䔀 栀愀猀 椀渀搀攀攀搀 愀 昀攀眀 猀洀愀爀琀 昀攀愀琀甀爀攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀☀⌀㠀㘀㔀㠀㬀 䄀 琀椀渀礀 戀椀琀 洀漀爀攀 漀渀 琀栀攀 愀爀挀栀椀琀攀挀琀甀爀攀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍䤀昀 礀漀甀 搀漀渀✀琀 挀愀爀攀 琀漀漀 洀甀挀栀 愀戀漀甀琀 琀栀攀 愀爀挀栀椀琀攀挀琀甀爀攀Ⰰ 礀漀甀 挀愀渀 猀欀椀瀀 琀栀椀猀 猀攀挀琀椀漀渀 愀渀搀 最漀 琀漀 䌀栀愀瀀琀攀爀 ㈀⸀㰀戀爀㸀ഀഀ
    ਍䘀椀最甀爀攀 ㄀ 戀攀氀漀眀Ⰰ 椀猀 愀 猀椀洀瀀氀攀 ∀猀欀攀琀挀栀∀ 漀昀 琀栀攀 最攀渀攀爀愀氀 愀爀挀栀椀琀攀挀琀甀爀攀⸀ 倀漀眀攀爀猀栀攀氀氀 䌀洀搀䰀攀琀猀 愀爀攀 愀挀琀甀愀氀氀礀 搀漀琀 一攀琀 挀漀搀攀⸀㰀戀爀㸀ഀഀ Dot Net is Microsoft's modern architecture for developing, deploying, and running applications.
    ਍㰀戀爀㸀ഀഀ With modern Windows versions, you get a set of "base" CmdLets. However, whenever you install a business application
    ਍氀椀欀攀 匀儀䰀 匀攀爀瘀攀爀Ⰰ 䔀砀挀栀愀渀最攀 ⠀愀渀搀 洀愀渀礀 洀漀爀攀⤀Ⰰ 礀漀甀 最攀琀 愀搀搀椀琀椀漀渀愀氀 猀瀀攀挀椀愀氀椀稀攀搀 䌀洀搀䰀攀琀猀 琀栀愀琀 氀攀琀 礀漀甀 椀渀琀攀爀愀挀琀 眀椀琀栀 琀栀漀猀攀 愀瀀瀀氀椀挀愀琀椀漀渀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䘀椀最 ㄀⸀ 匀椀洀瀀氀椀昀椀攀搀 愀爀挀栀椀琀攀挀琀甀爀攀 倀漀眀攀爀猀栀攀氀氀⸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍㰀椀洀最 猀爀挀㴀∀瀀漀眀攀爀猀栀攀氀氀㄀⸀樀瀀最∀ 愀氀椀最渀㴀∀挀攀渀琀爀攀∀⼀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ Your CmdLets, usually uses "providers" and api's to access various parts of the Windows Operating System, like the Registry, AD etc..
    ਍㰀戀爀㸀ഀഀ Traditionally, the inteface to "WMI" (Windows Management Intrumentation) is much used. For example, using the "Get-WMIobject" CmdLet,
    ਍椀琀✀猀 瀀漀猀猀椀戀氀攀 琀漀 爀攀琀爀椀攀瘀攀 椀渀昀漀爀洀愀琀椀漀渀 昀爀漀洀 愀氀洀漀猀琀 攀瘀攀爀礀琀栀椀渀最 漀昀 礀漀甀爀 猀礀猀琀攀洀 ⠀氀椀欀攀 搀椀猀欀猀Ⰰ 瀀爀椀渀琀攀爀猀Ⰰ 挀瀀甀Ⰰ 洀攀洀漀爀礀Ⰰ 瀀爀漀挀攀猀猀攀猀 攀琀挀⸀⸀⤀⸀㰀戀爀㸀ഀഀ That's why I printed WMI "very fat" in the figure above, to underline it's importance.
    ਍㰀戀爀㸀ഀഀ However, Powershell is not limited to the Windows Operating system. If the right CmdLets and providers are installed, you can
    ਍愀挀挀攀猀猀 漀琀栀攀爀 瀀氀愀琀昀漀爀洀猀 琀漀漀⸀㰀戀爀㸀ഀഀ
    ਍䄀氀漀渀最猀椀搀攀 琀栀攀 ∀戀愀猀攀 猀攀琀∀ 漀昀 䌀洀搀䰀攀琀猀Ⰰ 搀攀氀椀瘀攀爀攀搀 眀椀琀栀 礀漀甀爀 猀礀猀琀攀洀Ⰰ 洀愀渀礀 猀瀀攀挀椀愀氀椀稀攀搀 洀漀搀甀氀攀猀 ⠀挀漀渀琀愀椀渀椀渀最 瀀爀漀瘀椀搀攀爀猀 愀渀搀 䌀洀搀䰀攀琀猀⤀㰀戀爀㸀ഀഀ came available the past few years. For example, easy to use CmdLets to access Active Directory, and to access all sorts of applications etc..
    ਍吀栀椀猀 ∀猀琀漀爀洀∀ 椀猀 昀愀爀 昀爀漀洀 猀攀琀琀氀椀渀最 搀漀眀渀⸀ 夀漀甀 眀椀氀氀 猀攀攀㨀 䌀洀搀䰀攀琀猀 愀渀搀 瀀爀漀瘀椀搀攀爀猀 眀椀氀氀 挀漀洀攀 漀甀琀 琀栀愀琀 眀椀氀氀 氀攀琀 礀漀甀 愀挀挀攀猀猀 瘀椀爀琀甀愀氀氀礀 攀瘀攀爀礀琀栀椀渀最⸀㰀戀爀㸀ഀഀ That's why investing time and effort in studying Powershell is one of the best things you can do right now.
    ਍ഀഀ ਍ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍㰀栀㈀㸀䌀栀愀瀀琀攀爀 ㈀⸀ 䈀愀猀椀挀 猀挀爀椀瀀琀椀渀最 ⠀氀漀漀瀀猀Ⰰ 昀椀氀攀 洀漀搀椀昀椀挀愀琀椀漀渀猀 攀琀挀⸀⸀⤀⸀㰀⼀栀㈀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    2.1. A few preliminaries.

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䤀渀 琀栀椀猀 挀栀愀瀀琀攀爀Ⰰ 眀攀 眀椀氀氀 挀爀攀愀琀攀 瘀愀爀椀漀甀猀 猀挀爀椀瀀琀猀⸀ 伀昀挀漀甀爀猀攀Ⰰ 眀攀 眀椀氀氀 猀愀瘀攀 琀栀攀洀 愀猀 昀椀氀攀猀 椀渀 猀漀洀攀 昀漀氀搀攀爀⸀㰀戀爀㸀ഀഀ So, I suggest that you create a folder, called something like "C:\TEST" (or another name), and store your files there.
    ਍㰀戀爀㸀ഀഀ But we will also just type in code "interactively", as in example 1 below.
    ਍㰀戀爀㸀ഀഀ In creating scripts, we are going to use an 'flat file' editor, like notepad. I'am perfectly happy using notepad, but I must
    ਍猀愀礀 琀栀愀琀 愀爀攀 猀漀洀攀 昀爀攀攀 攀搀椀琀漀爀猀 愀爀漀甀渀搀 眀椀琀栀 攀砀琀攀渀搀攀搀 挀愀瀀愀戀椀氀椀琀椀攀猀⸀ 䨀甀猀琀 最漀漀最氀攀 漀渀 ∀昀爀攀攀 倀漀眀攀爀猀栀攀氀氀 攀搀椀琀漀爀∀⸀ 䴀愀礀戀攀 礀漀甀 氀椀欀攀 漀渀攀 漀昀 琀栀攀洀⸀㰀戀爀㸀ഀഀ But, since I only type in some short code pieces, notepad will do fine for me.
    ਍䈀攀昀漀爀攀 眀攀 搀漀 愀渀礀琀栀椀渀最 愀琀 愀氀氀Ⰰ 栀攀爀攀 愀爀攀 猀漀洀攀 瀀爀攀氀椀洀椀渀愀爀椀攀猀 昀漀爀 眀爀椀琀椀渀最 猀挀爀椀瀀琀猀⸀ 䨀甀猀琀 琀愀欀攀 渀漀琀椀挀攀 漀昀 琀栀攀洀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ⇒ Powershell file extension must be ".ps1":
    ਍㰀戀爀㸀ഀഀ When you create scripts, be sure to name the file with the ".ps1" file extension.
    ਍匀漀Ⰰ 猀甀瀀瀀漀猀攀 礀漀甀 挀爀攀愀琀攀 愀 猀挀爀椀瀀琀 琀栀愀琀 椀渀猀琀愀氀氀猀 愀 挀攀爀琀愀椀渀 瀀爀椀渀琀攀爀Ⰰ 礀漀甀 洀椀最栀琀 挀漀渀猀椀搀攀爀 琀漀 渀愀洀攀 椀琀 猀漀洀攀琀栀椀渀最 氀椀欀攀 ∀椀渀猀琀愀氀氀瀀爀椀渀琀攀爀∀⸀㰀戀爀㸀ഀഀ But, take notion of the fact that the file extension must be ".ps1", so, in the example above,
    ਍礀漀甀 猀栀漀甀氀搀 猀愀瘀攀 琀栀攀 昀椀氀攀 愀猀 ∀椀渀猀琀愀氀氀瀀爀椀渀琀攀爀⸀瀀猀㄀∀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ⇒ If your scripts won't run:
    ਍㰀戀爀㸀ഀഀ ਍䤀琀✀猀 焀甀椀琀攀 瀀漀猀猀椀戀氀攀 琀栀愀琀 㰀䈀㸀琀栀攀 攀砀攀挀甀琀椀漀渀 漀昀 猀愀瘀攀搀 猀挀爀椀瀀琀猀㰀⼀䈀㸀 椀猀 搀椀猀愀戀氀攀搀 漀渀 礀漀甀爀 猀礀猀琀攀洀 愀猀 愀 爀攀猀甀氀琀 漀昀 愀 㰀䈀㸀猀攀挀甀爀椀琀礀 瀀漀氀椀挀礀㰀⼀䈀㸀⸀㰀戀爀㸀ഀഀ Indeed, for Servers in a business environment, one should carefully consider the pro's and contra's of this measure.
    ਍㰀戀爀㸀ഀഀ You can enable the execution of scripts using the "Set-ExecutionPolicy" CmdLet.
    ਍吀栀攀渀 甀猀攀 漀渀攀 漀昀 琀栀攀 昀漀氀氀漀眀椀渀最 漀瀀琀椀漀渀猀 昀漀爀 琀栀椀猀 䌀洀搀䰀攀琀㨀 唀渀爀攀猀琀爀椀挀琀攀搀Ⰰ 刀攀洀漀琀攀匀椀最渀攀搀Ⰰ 䄀氀氀匀椀最渀攀搀Ⰰ 刀攀猀琀爀椀挀琀攀搀⸀㰀戀爀㸀ഀഀ If you use "Restricted", the execution of scripts is totally "off".
    ਍匀漀Ⰰ 昀漀爀 猀礀猀琀攀洀猀 椀渀 愀 戀甀猀椀渀攀猀猀 攀渀瘀椀爀漀渀洀攀渀琀Ⰰ 礀漀甀 猀栀漀甀氀搀 挀愀爀攀昀甀氀氀礀 挀漀渀猀椀搀攀爀 眀栀愀琀 椀猀 琀栀攀 戀攀猀琀 昀漀爀 礀漀甀⸀㰀戀爀㸀ഀഀ
    ਍䠀攀爀攀Ⰰ 䤀 猀甀瀀瀀漀猀攀 礀漀甀 甀猀攀 愀 瀀攀爀猀漀渀愀氀 琀攀猀琀 猀礀猀琀攀洀Ⰰ 猀漀 氀攀琀✀猀 最漀 ∀甀渀爀攀猀琀爀椀挀琀攀搀∀㨀㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍ഀഀ PS C:\test> Set-ExecutionPolicy -executionPolicy Unrestricted
    ਍ഀഀ ਍㰀戀爀㸀ഀഀ Also, on Vista, Win2K8 etc.. If you start Powershell from the commandline (cmd), you might consider to start the command prompt
    ਍昀椀爀猀琀 眀椀琀栀 ∀攀氀攀瘀愀琀攀搀 瀀爀椀瘀椀氀攀最攀猀∀ ⠀刀甀渀 愀猀 䄀搀洀椀渀椀猀琀爀愀琀漀爀⤀ 愀渀搀 渀攀砀琀 猀琀愀爀琀 倀漀眀攀爀猀栀攀氀氀⸀ 伀琀栀攀爀眀椀猀攀Ⰰ 礀漀甀 洀愀礀 爀甀渀 椀渀琀漀 瀀攀爀洀椀猀猀椀漀渀 椀猀猀甀攀猀⸀㰀戀爀㸀ഀഀ In some situations, you do not want the "elevated privileges", but in others (like installing/modifying stuff)
    ਍礀漀甀 瀀爀漀戀愀戀氀礀 搀漀 渀攀攀搀 琀栀攀洀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍ऀഀഀ ਍㰀栀㌀㸀㈀⸀㈀⸀ 䄀 昀攀眀 攀砀愀洀瀀氀攀猀 漀昀 甀猀椀渀最 倀漀眀攀爀猀栀攀氀氀 昀漀爀 昀椀氀攀 漀瀀攀爀愀琀椀漀渀猀⸀㰀⼀栀㌀㸀ഀഀ ਍ഀഀ With Powershell, you can perform all sorts of file manipulations.
    ਍唀猀椀渀最 愀 昀攀眀 攀砀愀洀瀀氀攀猀Ⰰ 愀氀氀漀眀猀 洀攀 琀漀 搀攀洀漀渀猀琀爀愀琀攀 愀 昀攀眀 椀洀瀀漀爀琀愀渀琀 䌀洀搀䰀攀琀猀Ⰰ 愀渀搀 栀漀眀 挀漀搀攀 ∀氀漀漀欀猀 氀椀欀攀∀⸀㰀戀爀㸀ഀഀ
    ਍䤀渀 洀愀渀礀 戀甀猀椀渀攀猀猀攀猀Ⰰ 瀀攀漀瀀氀攀 愀爀攀 猀攀愀爀挀栀椀渀最 昀漀爀 琀栀攀 戀攀猀琀 猀漀氀甀琀椀漀渀 昀漀爀 昀椀氀攀 洀愀渀椀瀀甀氀愀琀椀漀渀⸀ 吀漀 椀氀氀甀猀琀爀愀琀攀 琀栀椀猀Ⰰ 猀甀瀀瀀漀猀攀 琀栀攀 漀爀最愀渀椀猀愀琀椀漀渀㰀戀爀㸀ഀഀ uses a database where ascii files must be imported into, at a regular basis. Often, such a file does not "fit" in the database
    ਍椀渀 椀琀✀猀 挀甀爀爀攀渀琀 氀愀礀漀甀琀⸀ 䘀漀爀 攀砀愀洀瀀氀攀Ⰰ 椀琀 栀愀猀 漀渀攀 挀漀氀甀洀渀 琀漀漀 洀愀渀礀Ⰰ 漀爀 漀渀攀 昀椀攀氀搀 洀甀猀琀 戀攀 洀漀搀椀昀椀攀搀Ⰰ 戀攀昀漀爀攀 椀琀 挀愀渀 戀攀 椀洀瀀漀爀琀攀搀 挀氀攀愀渀氀礀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ Example 1: cutting one column off the content of a file
    ਍㰀戀爀㸀ഀഀ Picture a scenario like this. Your boss runs in your office, waving with a USB stick and yelling: "This ascii file has one column too many".
    ਍䈀甀琀 椀琀✀猀 猀漀 氀愀爀最攀Ⰰ 䤀 挀愀渀渀漀琀 甀猀攀 䔀砀挀攀氀 漀爀 猀漀洀攀琀栀椀渀最⸀⸀⸀⸀ 䤀琀猀 琀漀漀 搀愀爀渀 氀愀爀最攀℀℀ 䤀 猀甀瀀瀀漀猀攀 礀漀甀 栀愀瘀攀 猀漀洀攀 挀氀攀瘀攀爀 猀挀爀椀瀀琀 搀漀渀琀 礀漀甀⸀⸀⸀⸀㼀㼀∀㰀戀爀㸀ഀഀ
    ਍圀栀椀氀攀 挀漀瀀礀椀渀最 琀栀攀 ∀挀甀猀琀漀洀攀爀猀⸀琀砀琀∀ 昀椀氀攀 昀爀漀洀 琀栀攀 猀琀椀挀欀 琀漀 琀栀攀 ∀挀㨀尀琀攀猀琀∀ 搀椀爀攀挀琀漀爀礀 漀渀 礀漀甀爀 氀漀挀愀氀 栀愀爀搀搀爀椀瘀攀Ⰰ 礀漀甀 猀琀愀爀琀 琀栀椀渀欀椀渀最⸀㰀戀爀㸀ഀഀ
    ਍䰀攀琀猀 洀椀洀椀挀 琀栀椀猀 猀椀琀甀愀琀椀漀渀⸀ 䌀爀攀愀琀攀 愀 昀氀愀琀昀椀氀攀 挀愀氀氀攀搀 ∀挀甀猀琀漀洀攀爀猀⸀琀砀琀∀Ⰰ 眀椀琀栀 猀漀洀攀 昀椀攀氀搀猀Ⰰ 愀氀氀 猀攀瀀攀爀愀琀攀搀 戀礀 樀甀猀琀 漀渀攀 ∀眀栀椀琀攀猀瀀愀挀攀∀Ⰰ 氀椀欀攀 猀漀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍㄀ 䄀䈀䌀 䄀洀猀琀攀爀搀愀洀㰀戀爀㸀ഀഀ 2 Goofy Washington
    ਍㌀ 䜀栀漀猀琀戀甀猀琀攀爀猀 䐀攀渀瘀攀爀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍吀栀攀 ∀䜀攀琀ⴀ䌀漀渀琀攀渀琀∀ 䌀洀搀䰀攀琀 挀漀甀氀搀 戀攀 椀渀琀攀爀爀攀猀琀椀渀最 栀攀爀攀⸀ 夀漀甀 挀愀渀 甀猀攀 椀琀 琀漀 猀瀀漀漀氀 琀栀攀 挀漀渀琀攀渀琀 漀昀 愀 昀氀愀琀 昀椀氀攀 琀漀 琀栀攀 猀挀爀攀攀渀Ⰰ㰀戀爀㸀ഀഀ or even redirect it to another CmdLet.
    ਍㰀戀爀㸀ഀഀ Lets view the content of the file using "Get-Content" first:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\test> Get-Content c:\test\customers.txt
    ਍㰀戀爀㸀ഀഀ 1 ABC Amsterdam
    ਍㈀ 䜀漀漀昀礀 圀愀猀栀椀渀最琀漀渀㰀戀爀㸀ഀഀ 3 Ghostbusters Denver
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ
    ਍一漀眀Ⰰ 氀攀琀猀 琀爀礀 琀漀 最攀琀 琀栀攀 琀栀椀爀搀 挀漀氀甀洀渀 漀昀昀⸀ 䠀攀爀攀 椀猀 愀 瀀椀攀挀攀 漀昀 挀漀搀攀 眀栀椀挀栀 愀挀栀椀攀瘀攀猀 琀栀愀琀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀琀攀猀琀㸀 䜀攀琀ⴀ䌀漀渀琀攀渀琀 挀甀猀琀漀洀攀爀猀⸀琀砀琀 簀 ─笀␀搀愀琀愀㴀㰀䈀㸀␀开㰀⼀䈀㸀⸀猀瀀氀椀琀⠀∀ ∀⤀㬀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ∀␀⠀␀搀愀琀愀嬀　崀⤀ ␀⠀␀搀愀琀愀嬀㄀崀⤀∀紀㰀戀爀㸀ഀഀ
    ਍㄀ 䄀䈀䌀㰀戀爀㸀ഀഀ 2 Goofy
    ਍㌀ 䜀栀漀猀琀戀甀猀琀攀爀猀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ Now, that line might look "impressive", bit it's really not difficult, once you are acustomed to Powershell style.
    ਍㰀戀爀㸀ഀഀ I think it's important that you know, that the "exact" details of the syntax are not important right now: I would like you to understand
    ਍琀栀攀 ∀最攀渀攀爀愀氀 椀搀攀愀∀ 漀渀氀礀⸀ 伀渀氀礀 愀昀琀攀爀 挀栀愀瀀琀攀爀猀 ㄀Ⰰ㈀ 愀渀搀 ㌀ 愀爀攀 ∀挀漀渀猀甀洀攀搀∀Ⰰ 礀漀甀 猀栀漀甀氀搀 栀愀瘀攀 愀渀 椀搀攀愀 愀戀漀甀琀 琀栀攀 爀椀最栀琀 猀礀渀琀愀砀⸀㰀戀爀㸀ഀഀ
    ਍䰀攀琀✀猀 猀攀攀 眀栀愀琀 琀栀攀 甀瀀瀀攀爀 挀漀洀洀愀渀搀 搀漀攀猀⸀㰀戀爀㸀ഀഀ First, we have "Get-Content customers.txt | " part, which opens the file, and then it wants to push every record it reads
    ਍琀漀 眀栀愀琀攀瘀攀爀 昀漀氀氀漀眀猀 愀昀琀攀爀 琀栀攀 ∀簀∀ 瀀椀瀀攀 猀礀洀戀漀氀⸀㰀戀爀㸀ഀഀ
    ਍一漀眀 愀挀琀甀愀氀氀礀Ⰰ 琀栀攀 猀琀爀攀愀洀 漀昀 搀愀琀愀 最漀攀猀 琀漀 琀栀攀 䌀洀搀䰀攀琀 ∀圀爀椀琀攀ⴀ伀甀琀瀀甀琀∀Ⰰ 眀栀椀挀栀 猀攀攀洀猀 琀漀 瀀爀椀渀琀 漀渀氀礀 琀眀漀 瘀愀爀椀愀戀氀攀猀Ⰰ 渀愀洀攀氀礀㰀戀爀㸀ഀഀ $data[0], and $data[1].
    ਍㰀戀爀㸀ഀഀ But before the "Write-Output" CmdLet comes in action, you will notice the variable assignment "$data=$_.split(" ");".
    ਍䄀猀 眀攀 欀渀漀眀 昀爀漀洀 愀戀漀瘀攀Ⰰ 攀瘀攀爀礀 爀攀挀漀爀搀 瀀甀猀栀攀搀 戀礀 ∀䜀攀琀ⴀ䌀漀渀琀攀渀琀∀Ⰰ 椀猀 挀漀渀琀愀椀渀攀搀 椀渀 琀栀攀 ∀␀开∀ 瘀愀爀椀愀戀氀攀⸀㰀戀爀㸀ഀഀ So, as the first line is read by "Get-Content", the "$_" will contain:
    ਍㰀戀爀㸀ഀഀ 1 ABC Amsterdam
    ਍㰀戀爀㸀ഀഀ But $data is defined as "$data=$_.split(" ");", where the split method is called from the object "$_".
    ਍一漀眀 愀猀 礀漀甀 洀愀礀 欀渀漀眀 昀爀漀洀 洀漀搀攀爀渀 伀戀樀攀挀琀 伀爀椀攀渀琀攀搀 䰀愀渀最甀愀最攀猀 ⠀伀伀⤀Ⰰ 愀渀 ∀漀戀樀攀挀琀∀ 洀椀最栀琀 挀漀渀琀愀椀渀 搀愀琀愀Ⰰ 愀猀 眀攀氀氀 愀猀 挀愀氀氀ⴀ愀戀氀攀㰀戀爀㸀ഀഀ functions. Here, "$_" exposes indeed an number of function, among "split()" is one of them. ਍㰀戀爀㸀ഀഀ Now, let's quickly see what split() does. Take a look at the following intermezzo:
    ਍㰀戀爀㸀ഀഀ Take a look at this code:
    ਍㰀戀爀㸀ഀഀ First, we declare a variable $string = "fries hamburger milkshake" to be one contiguous string. Then we call the
    ਍猀瀀氀椀琀⠀⤀ 洀攀琀栀漀搀Ⰰ 琀漀 猀瀀氀椀琀 甀瀀 琀栀椀猀 猀琀爀椀渀最 椀渀 椀渀搀攀瀀攀渀搀攀渀琀 瀀椀攀挀攀猀⸀ 一漀琀攀 琀栀愀琀 琀栀攀 愀爀最甀洀攀渀琀 琀漀 琀栀攀 猀瀀氀椀琀 昀甀渀挀琀椀漀渀 椀猀 ∀ ∀㰀戀爀㸀ഀഀ which tells split(), to split on the "whitespaces".
    ਍㰀戀爀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀猀琀爀椀渀最 㴀 ∀昀爀椀攀猀 栀愀洀戀甀爀最攀爀 洀椀氀欀猀栀愀欀攀∀㰀戀爀㸀ഀഀ PS C:\TEST> $string.split(" ")
    ਍昀爀椀攀猀㰀戀爀㸀ഀഀ hamburger
    ਍洀椀氀欀猀栀愀欀攀㰀戀爀㸀ഀഀ
    ਍伀渀挀攀 愀 瘀愀爀椀愀戀氀攀 椀猀 漀昀 ∀猀琀爀椀渀最∀ 琀礀瀀攀Ⰰ 礀漀甀 愀甀琀漀洀愀琀椀挀愀氀氀礀 栀愀瘀攀 琀栀攀 ∀⸀猀瀀氀椀琀∀ 洀攀琀栀漀搀 ⠀昀甀渀挀琀椀漀渀⤀ 愀瘀愀椀氀愀戀氀攀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ So, what "$_" contains, will be split in independent piecies, and placed into the $data variable.
    ਍㰀戀爀㸀ഀഀ Now, $data is automatically an "array of values", because of the intrinsic power of Powershell.
    ਍倀漀眀攀爀猀栀攀氀氀 ∀欀渀漀眀猀∀ 琀栀愀琀 椀昀 愀渀礀 瘀愀爀椀愀戀氀攀 挀漀渀琀愀椀渀猀 椀渀搀攀瀀攀渀搀攀渀琀 瀀椀攀挀攀猀Ⰰ 椀琀 琀爀攀愀琀猀 椀琀 愀猀 愀渀 愀爀爀愀礀 漀昀 瘀愀氀甀攀猀⸀㰀戀爀㸀ഀഀ So, you might say that $data can be seen as $data[0], $data[1], and $data[2] (counting from 0).
    ਍吀栀甀猀Ⰰ 昀漀爀 琀栀攀 昀椀爀猀琀 爀攀挀漀爀搀 爀攀愀搀 愀渀搀 瀀甀猀栀攀搀 戀礀 ∀䜀攀琀ⴀ䌀漀渀琀攀渀琀∀Ⰰ 眀攀 栀愀瘀攀㨀㰀戀爀㸀ഀഀ
    ਍␀搀愀琀愀嬀　崀㴀㄀Ⰰ ␀搀愀琀愀嬀㄀崀㴀䄀䈀䌀Ⰰ 愀渀搀 ␀搀愀琀愀嬀㈀崀㴀䄀洀猀琀攀爀搀愀洀㰀戀爀㸀ഀഀ
    ਍䰀愀猀琀氀礀Ⰰ ∀圀爀椀琀攀ⴀ伀甀琀瀀甀琀∀ 眀椀氀氀 漀渀氀礀 瀀爀椀渀琀 ␀搀愀琀愀嬀　崀 愀渀搀 ␀搀愀琀愀嬀㄀崀⸀㰀戀爀㸀ഀഀ
    ਍吀栀椀猀 瀀爀漀挀攀猀猀 椀猀 挀漀渀琀椀渀甀攀搀 昀漀爀 琀栀攀 猀攀挀漀渀搀 爀攀挀漀爀搀 爀攀愀搀 戀礀 ∀䜀攀琀ⴀ䌀漀渀琀攀渀琀∀Ⰰ 愀渀搀 琀栀攀 琀栀椀爀搀 攀琀挀⸀⸀ 愀氀氀 琀栀攀 眀愀礀 搀漀眀渀 琀漀 琀栀攀 氀愀猀琀 爀攀挀漀爀搀⸀㰀戀爀㸀ഀഀ
    ਍吀栀攀 爀攀猀甀氀琀 椀猀 琀栀愀琀 眀攀 栀愀瘀攀 挀甀琀 漀昀昀 琀栀攀 琀栀椀爀搀 挀漀氀甀洀渀⸀ 䠀漀眀攀瘀攀爀Ⰰ 琀栀攀 爀攀猀甀氀琀 椀猀 瀀爀椀渀琀攀搀 漀渀 礀漀甀爀 猀挀爀攀攀渀⸀㰀戀爀㸀ഀഀ
    ਍一漀琀攀㨀㰀戀爀㸀ഀഀ
    ਍匀漀洀攀琀椀洀攀猀 愀 挀漀洀洀愀渀搀 攀渀琀攀爀攀搀 愀琀 琀栀攀 倀漀眀攀爀猀栀攀氀氀 瀀爀漀洀瀀琀Ⰰ 椀猀 愀 戀椀琀 ∀氀漀渀最∀⸀ 夀漀甀 挀愀渀 愀氀眀愀礀猀 瀀爀攀猀猀 攀渀琀攀爀 爀椀最栀琀 愀昀琀攀爀 愀 瀀椀瀀攀 猀礀洀戀漀氀Ⰰ㰀戀爀㸀ഀഀ since Powershell then knows that you want to enter more text.
    ਍倀漀眀攀爀猀栀攀氀氀 琀栀攀渀 搀椀猀瀀氀愀礀猀 琀栀攀 ∀㸀㸀∀ 猀礀洀戀漀氀猀 眀栀椀挀栀 搀攀渀漀琀攀猀 琀栀愀琀 礀漀甀 挀愀渀 攀渀琀攀爀 洀漀爀攀 琀攀砀琀⸀㰀戀爀㸀ഀഀ So, then it looks like this:
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ
    ਍倀匀 䌀㨀尀琀攀猀琀㸀㰀戀爀㸀ഀഀ PS C:\test> Get-Content customers.txt |
    ਍㸀㸀 ─笀␀搀愀琀愀㴀␀开⸀猀瀀氀椀琀⠀∀ ∀⤀㬀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ∀␀⠀␀搀愀琀愀嬀　崀⤀ ␀⠀␀搀愀琀愀嬀㄀崀⤀∀紀㰀戀爀㸀ഀഀ >>
    ਍㄀ 䄀䈀䌀㰀戀爀㸀ഀഀ 2 Goofy
    ਍㌀ 䜀栀漀猀琀戀甀猀琀攀爀猀㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍ഀഀ Example 2: cutting one column off the content of a file, and save it to another file
    ਍㰀戀爀㸀ഀഀ Basically, it's the same as example 1 above. So for explanations, see example 1.
    ਍㰀戀爀㸀ഀഀ As you can see in the code below, this time we use a third CmdLet, namely "Out-File", which takes any stream it gets left from the pipe,
    ਍愀渀搀 眀爀椀琀攀猀 琀栀愀琀 琀漀 愀 昀椀氀攀 漀昀 礀漀甀爀 挀栀漀椀挀攀Ⰰ 椀渀 琀栀椀猀 挀愀猀攀 ∀挀甀猀琀漀洀攀爀猀㈀⸀琀砀琀∀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀琀攀猀琀㸀 䜀攀琀ⴀ䌀漀渀琀攀渀琀 挀甀猀琀漀洀攀爀猀⸀琀砀琀 簀㰀戀爀㸀ഀഀ >> %{$data=$_.split(" "); Write-Output "$($data[0]) $($data[1])"} | Out-File customers2.txt
    ਍㸀㸀㰀戀爀㸀ഀഀ PS C:\test>
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ If you open customer2.txt with notepad, you will see that only two columns of data is present.
    ਍㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䔀砀愀洀瀀氀攀 ㌀㨀 挀甀琀琀椀渀最 漀渀攀 挀漀氀甀洀渀 漀昀昀 琀栀攀 挀漀渀琀攀渀琀 漀昀 愀 昀椀氀攀Ⰰ 甀猀椀渀最 愀 猀挀爀椀瀀琀Ⰰ 眀椀琀栀 愀 瀀愀爀愀洀攀琀攀爀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍圀栀愀琀 眀攀 栀愀瘀攀 搀漀渀攀 愀戀漀瘀攀Ⰰ 眀攀 愀爀攀 渀漀眀 最漀椀渀最 琀漀 瀀氀愀挀攀 椀渀 愀 爀攀愀氀 猀挀爀椀瀀琀⸀ 伀昀挀漀甀爀猀攀Ⰰ 琀栀攀 猀挀爀椀瀀琀 洀甀猀琀 戀攀 猀攀琀甀瀀 椀渀 猀甀挀栀 愀 眀愀礀 猀漀 琀栀愀琀㰀戀爀㸀ഀഀ it can be called with an argument. This argument is then any txt file, from which we only want the first two
    ਍挀漀氀甀洀渀猀 猀愀瘀攀搀 椀渀 愀渀漀琀栀攀爀 昀椀氀攀⸀㰀戀爀㸀ഀഀ
    ਍匀漀Ⰰ 椀渀 琀栀攀 ∀䌀㨀尀吀䔀匀吀∀ 搀椀爀攀挀琀漀爀礀Ⰰ 猀琀愀爀琀 渀漀琀攀瀀愀搀 愀渀搀 挀爀攀愀琀攀 愀 昀椀氀攀 挀愀氀氀攀搀 ∀琀攀猀琀㄀⸀瀀猀㄀∀⸀㰀戀爀㸀ഀഀ Place the following code in "test1.ps1":
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ Get-Content $args |
    ਍─笀␀搀愀琀愀㴀␀开⸀猀瀀氀椀琀⠀∀ ∀⤀㬀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ∀␀⠀␀搀愀琀愀嬀　崀⤀ ␀⠀␀搀愀琀愀嬀㄀崀⤀∀紀 簀 漀甀琀ⴀ昀椀氀攀 渀攀眀昀椀氀攀⸀琀砀琀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍一漀眀Ⰰ 氀攀琀✀猀 爀甀渀 椀琀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀琀攀猀琀㸀 ⸀尀琀攀猀琀㄀⸀瀀猀㄀ 挀甀猀琀漀洀攀爀猀⸀琀砀琀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍夀漀甀 猀栀漀甀氀搀 渀漀琀椀挀攀 琀眀漀 琀栀椀渀最猀 栀攀爀攀㨀㰀戀爀㸀ഀഀ
    ਍⠀㄀⤀㨀㰀戀爀㸀ഀഀ Do you see that I called the script, with a parameter (or argument), which is the name of the file from whose content
    ਍眀攀 眀愀渀琀 漀渀氀礀 眀愀渀琀 琀眀漀 挀漀氀甀洀渀猀 猀琀漀爀攀搀 椀渀 愀渀漀琀栀攀爀 昀椀氀攀⸀㰀戀爀㸀ഀഀ Do you also see the special variable "$args" directly behind "Get-Content"?
    ਍㰀戀爀㸀ഀഀ Using a script with a simple parameter is really easily done, since the $args automatically takes on any value
    ਍漀昀 琀栀攀 愀爀最甀洀攀渀琀 瀀愀猀猀攀搀 琀漀 琀栀攀 猀挀爀椀瀀琀⸀㰀戀爀㸀ഀഀ
    ਍⠀㈀⤀㨀㰀戀爀㸀ഀഀ Starting a script from the Powershell prompt is really done in this way: ".\scriptname.ps1".
    ਍夀漀甀 洀椀最栀琀 眀漀渀搀攀爀 眀栀攀爀攀 琀栀椀猀 猀琀爀愀渀最攀 氀漀漀欀椀渀最 猀礀渀琀愀砀 椀猀 挀漀洀椀渀最 昀爀漀洀⸀㰀戀爀㸀ഀഀ
    ਍䄀 ∀⸀∀ ⠀ 愀 搀漀琀⤀ 洀攀愀渀猀 琀栀攀 ∀挀甀爀爀攀渀琀 搀椀爀攀挀琀漀爀礀∀Ⰰ 眀栀椀挀栀 椀渀 琀栀椀猀 挀愀猀攀 椀猀 ∀挀㨀尀琀攀猀琀∀⸀ 一漀眀Ⰰ 猀椀渀挀攀 眀攀 渀攀攀搀 琀漀 愀搀搀 愀 猀氀愀猀栀 ∀尀∀ 琀漀 最攀琀 愀 昀甀氀氀 瀀愀琀栀㰀戀爀㸀ഀഀ to the file, we have string like ".\scriptname.ps1" which then resolves to "c:\test\scriptname.ps1".
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    2.3. A few examples of using Loops.

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䰀攀琀✀猀 爀攀瘀椀攀眀 愀 昀攀眀 攀砀愀洀瀀氀攀猀 琀栀愀琀 甀猀攀 愀 氀漀漀瀀⸀ 䤀渀 琀栀椀猀 猀攀挀琀椀漀渀Ⰰ 眀攀 眀椀氀氀 椀氀氀甀猀琀爀愀琀攀 琀栀攀 ∀昀漀爀攀愀挀栀∀ 氀漀漀瀀⸀㰀戀爀㸀ഀഀ You can find more loop constructs, like the "while" loop, in Chapter 3.
    ਍㰀戀爀㸀ഀഀ ਍㰀䈀㸀䔀砀愀洀瀀氀攀 㐀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍䨀甀猀琀 琀礀瀀攀 椀渀 琀栀攀 昀漀氀氀漀眀椀渀最 椀渀琀攀爀愀挀琀椀瘀攀氀礀 愀琀 琀栀攀 倀匀 瀀爀漀洀瀀琀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀䴀倀㸀 ␀渀漀搀攀氀椀猀琀㴀⠀∀䠀愀爀爀礀∀Ⰰ∀一愀渀挀礀∀⤀ ⴀⴀ 瀀爀攀猀猀 攀渀琀攀爀㰀戀爀㸀ഀഀ PS C:\TEMP> foreach ($file in $nodelist) -- press enter. The prompt changes to ">>"
    ਍㸀㸀 笀㰀戀爀㸀ഀഀ >> write-output "hello $file"
    ਍㸀㸀 紀㰀戀爀㸀ഀഀ >>
    ਍栀攀氀氀漀 䠀愀爀爀礀㰀戀爀㸀ഀഀ hello Nancy
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ This one should be easy to follow. First, we have a variable "$nodelist" containing the values ("Harry","Nancy").
    ਍㰀戀爀㸀ഀഀ Did you noticed that I did not declare that variable at all? I did an value assignment right away, and Powershell automatically
    ਍搀攀挀氀愀爀攀猀 琀栀攀 瘀愀爀椀愀戀氀攀 昀漀爀 洀攀⸀ 匀愀瘀攀猀 琀椀洀攀 愀渀搀 挀漀搀椀渀最⸀㰀戀爀㸀ഀഀ
    ਍吀栀攀渀 眀攀 栀愀瘀攀 琀栀攀 栀攀愀爀琀 漀昀 琀栀攀 氀漀漀瀀 甀猀椀渀最 琀栀攀 ∀昀漀爀攀愀挀栀∀ 猀琀愀琀攀洀攀渀琀⸀㰀戀爀㸀ഀഀ
    ਍䘀漀爀攀愀挀栀 甀猀攀猀 愀 ∀挀漀渀搀椀琀椀漀渀∀ 琀栀愀琀Ⰰ 椀昀 椀琀 攀瘀愀氀甀愀琀攀猀 琀漀 ∀琀爀甀攀∀ ⠀漀爀 椀昀 猀琀椀氀氀 瘀愀氀甀攀猀 瀀爀攀猀攀渀琀⤀Ⰰ 椀琀 最漀攀猀 昀漀爀 愀渀漀琀栀攀爀 猀眀椀渀最⸀ 伀琀栀攀爀眀椀猀攀Ⰰ 椀琀 猀琀漀瀀猀⸀㰀戀爀㸀ഀഀ In this example, it means that "as long as there are values in $nodelist", perform the statements between the "{" and "}".
    ਍㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䔀砀愀洀瀀氀攀 㔀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍䤀渀 琀栀椀猀 攀砀愀洀瀀氀攀Ⰰ 眀攀 甀猀攀 愀 猀挀爀椀瀀琀 琀漀 猀琀愀爀琀 ⠀漀爀 猀琀漀瀀⤀ 愀 猀攀琀 漀昀 爀攀氀愀琀攀搀 猀攀爀瘀椀挀攀猀 漀昀 猀漀洀攀 欀椀渀搀⸀㰀戀爀㸀ഀഀ In this example, a take Oracle services on a Windows system, where the display name of such a service starts with "Oracle"
    ਍氀椀欀攀 昀漀爀 攀砀愀洀瀀氀攀 琀栀攀 猀攀爀瘀椀挀攀 ∀伀爀愀挀氀攀匀攀爀瘀椀挀攀吀䔀匀吀䐀䈀㄀㄀最∀㰀戀爀㸀ഀഀ
    ਍一漀眀Ⰰ 昀漀爀 礀漀甀爀 猀礀猀琀攀洀Ⰰ 椀昀 礀漀甀 搀漀渀✀琀 栀愀瘀攀 伀爀愀挀氀攀 椀渀猀琀愀氀氀攀搀Ⰰ 洀愀礀戀攀 礀漀甀 挀愀渀 琀栀椀渀欀 漀昀 愀渀漀琀栀攀爀 猀攀琀 漀昀 猀攀爀瘀椀挀攀猀 琀漀 甀猀攀⸀㰀戀爀㸀ഀഀ Or, you can just read this example and not do it "hands-on". The primary object is that you understand the loop that is used here.
    ਍夀漀甀 搀漀渀✀琀 栀愀瘀攀 琀漀 ∀瀀攀爀猀攀∀ 瀀攀爀昀漀爀洀 攀愀挀栀 攀砀愀洀瀀氀攀 漀渀 礀漀甀爀 猀礀猀琀攀洀⸀㰀戀爀㸀ഀഀ
    ਍匀漀Ⰰ 氀攀琀猀 挀爀攀愀琀攀 愀 猀挀爀椀瀀琀⸀㰀戀爀㸀ഀഀ
    ਍匀琀愀爀琀 渀漀琀攀瀀愀搀 ⠀漀爀 愀渀礀 漀琀栀攀爀 攀搀椀琀漀爀⤀ 愀渀搀 琀礀瀀攀 琀栀攀 昀漀氀氀漀眀椀渀最 挀漀搀攀㨀㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍ഀഀ foreach ($svc in Get-Service){
    ਍☀渀戀猀瀀  椀昀⠀⠀␀猀瘀挀⸀搀椀猀瀀氀愀礀渀愀洀攀⸀匀琀愀爀琀猀圀椀琀栀⠀∀伀爀愀挀氀攀∀⤀⤀ ⴀ䄀一䐀 ⠀␀猀瘀挀⸀匀琀愀琀甀猀 ⴀ攀焀 ∀匀琀漀瀀瀀攀搀∀⤀⤀ 笀㰀戀爀㸀ऀऀऀऀऀऀऀऀऀऀऀഀഀ     echo $svc.DisplayName
    ਍☀渀戀猀瀀 ☀渀戀猀瀀 匀琀愀爀琀ⴀ匀攀爀瘀椀挀攀 ␀猀瘀挀⸀渀愀洀攀㰀戀爀㸀ऀऀऀऀऀऀऀऀऀऀऀഀഀ   }
    ਍㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ Save the script with the name "oraclestart.ps1" in the "c:\test" folder.
    ਍㰀戀爀㸀ഀഀ You can run the script, from the PS prompt, like so:
    ਍㰀戀爀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ⸀尀漀爀愀挀氀攀猀琀愀爀琀⸀瀀猀㄀ 㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ It should not be too difficult to follow this code.
    ਍㰀戀爀㸀ഀഀ First, we have a "foreach" loop. The condition of this loop is a list of all "services", that "Get-Service"
    ਍栀愀猀 瀀爀漀搀甀挀攀搀 愀猀 愀 氀椀猀琀⸀ 匀漀Ⰰ 愀挀琀甀愀氀氀礀Ⰰ 愀氀氀 挀漀搀攀 椀渀 琀栀攀 㰀䈀㸀∀椀昀∀㰀⼀䈀㸀 猀琀愀琀攀洀攀渀琀 椀猀 爀攀瀀攀愀琀攀搀 昀漀爀 愀氀氀 猀攀爀瘀椀挀攀猀⸀㰀戀爀㸀ഀഀ
    ਍䈀甀琀 漀渀氀礀 眀栀攀爀攀 琀栀攀 ∀猀攀爀瘀椀挀攀 搀椀猀瀀氀愀礀 渀愀洀攀∀ 猀琀愀爀琀猀 眀椀琀栀 ∀伀爀愀挀氀攀∀ 愀渀搀 眀栀攀爀攀 琀栀椀猀 猀攀爀瘀椀挀攀 栀愀猀 琀栀攀 猀琀愀琀甀猀 ∀猀琀漀瀀瀀攀搀∀Ⰰ 琀栀攀渀㰀戀爀㸀ഀഀ the code between "{" and "}" is executed. The result is that all stopped Oracle services are started.
    ਍㰀戀爀㸀ഀഀ If you can't actually do this example, don't worry. The main goal is to get a grip of Powershell, and not on a particular script example.
    ਍㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䔀砀愀洀瀀氀攀 㘀㨀 刀攀渀愀洀攀 愀 猀攀琀 漀昀 昀椀氀攀猀㨀 甀猀椀渀最 愀 ∀猀漀爀琀 漀昀 氀漀漀瀀∀ ⠀氀椀猀琀⤀Ⰰ 戀甀琀 椀琀猀 渀漀琀 愀渀 攀砀瀀氀椀挀椀琀 氀漀漀瀀⸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍吀栀椀猀 椀猀 愀 戀椀琀 漀昀 愀 ∀眀攀椀爀搀∀ 攀砀愀洀瀀氀攀⸀ 䠀攀爀攀 䤀 甀猀攀 倀漀眀攀爀猀栀攀氀氀 琀漀 猀椀洀瀀氀礀 爀攀渀愀洀攀 愀 戀甀渀挀栀 漀昀 ⨀⸀琀砀琀 昀椀氀攀猀 琀漀 ⨀⸀戀愀欀 昀椀氀攀猀⸀㰀戀爀㸀ഀഀ
    ਍一漀眀Ⰰ 礀漀甀 洀椀最栀琀 戀攀 琀攀洀瀀琀攀搀 琀漀 甀猀攀 ∀昀漀爀攀愀挀栀∀ 愀最愀椀渀⸀ 吀栀愀琀 眀漀甀氀搀 戀攀 瘀攀爀礀 爀攀愀猀漀渀愀戀氀攀Ⰰ 猀椀渀挀攀 ∀昀漀爀攀愀挀栀∀ 挀愀渀 戀攀 甀猀攀搀 昀漀爀 猀攀琀琀椀渀最 甀瀀 氀漀漀瀀⸀㰀戀爀㸀ഀഀ
    ਍刀攀愀猀漀渀椀渀最 愀氀漀渀最 琀栀攀猀攀 氀椀渀攀猀Ⰰ 礀漀甀 洀椀最栀琀 昀椀爀猀琀 琀爀礀 琀漀 猀椀洀瀀氀礀 氀椀猀琀 琀栀攀 ⨀⸀琀砀琀 昀椀氀攀猀Ⰰ 愀渀搀 椀昀 琀栀愀琀 眀漀爀欀猀Ⰰ 礀漀甀 洀椀最栀琀 琀栀椀渀欀㰀戀爀㸀ഀഀ that there must surely exist a CmdLet that lets you rename an item (indeed, there is one, namely "Rename-Item").
    ਍㰀戀爀㸀ഀഀ So, suppose you have a few .txt files in "c:\test", then lets try a simple listing first:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\test> $file=ls *.txt
    ਍倀匀 䌀㨀尀琀攀猀琀㸀 昀漀爀攀愀挀栀 ⠀␀愀 椀渀 ␀昀椀氀攀⤀ 笀㰀戀爀㸀ഀഀ >> write-output $a
    ਍㸀㸀 紀㰀戀爀㸀ഀഀ >>
    ਍㰀戀爀㸀ഀഀ ਍夀攀猀Ⰰ 琀栀椀猀 瀀爀漀搀甀挀攀猀 愀 氀椀猀琀椀渀最 漀昀 愀氀氀 ⨀⸀琀砀琀 昀椀氀攀猀⸀ 匀漀Ⰰ 椀昀 戀攀琀眀攀攀渀 琀栀攀 ∀笀∀ 愀渀搀 ∀紀∀ 愀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 椀猀 瀀漀猀猀椀戀氀攀Ⰰ 琀栀攀渀 猀漀洀攀㰀戀爀㸀ഀഀ CmdLet that renames stuff must be possible too.
    ਍㰀戀爀㸀ഀഀ This is an example where you might easily going to follow a path that's not wrong, but maybe somewhat slightly cumbersome.
    ਍圀栀愀琀 眀攀 眀愀渀琀 挀愀渀 戀攀 搀漀渀攀 椀渀 愀 洀甀挀栀 洀漀爀攀 攀昀昀椀挀椀攀渀琀 眀愀礀Ⰰ 椀昀 漀渀氀礀 眀攀 欀渀攀眀 漀昀 愀 䌀洀搀䰀攀琀 琀栀愀琀 瀀爀漀搀甀挀攀猀 愀 氀椀猀琀 漀昀 琀栀攀 爀椀最栀琀 猀攀琀 漀昀 昀椀氀攀猀Ⰰ㰀戀爀㸀ഀഀ which we immediately can pipe through to the "Rename-Item" CmdLet.
    ਍㰀戀爀㸀ഀഀ For this, the "Get-ChildItem" would work perfectly. Just take a look a this working code:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\TEST> Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace 'txt', 'bak'}
    ਍㰀戀爀㸀ഀഀ ਍吀栀攀 ∀䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀∀ 䌀洀搀䰀攀琀Ⰰ 爀攀猀攀洀戀氀攀猀 琀栀攀 漀氀搀 䐀伀匀 ∀搀椀爀∀ 挀漀洀洀愀渀搀⸀ 夀漀甀 挀愀渀 最攀琀 愀 昀甀氀氀 氀椀猀琀椀渀最 漀昀 愀氀氀 昀椀氀攀猀Ⰰ 漀爀 樀甀猀琀 愀 ∀昀椀氀琀攀爀攀搀∀ 氀椀猀琀椀渀最Ⰰ㰀戀爀㸀ഀഀ like a list of *.txt files, or like a list of files that have a name which begins with "book*" etc.. etc..
    ਍㰀戀爀㸀ഀഀ Now, its actually the same story again: Get-ChildItem produces a listing, a recordset as it were, where each record is piped
    ਍琀漀 ∀刀攀渀愀洀攀ⴀ䤀琀攀洀∀⸀ 吀栀攀渀 ∀刀攀渀愀洀攀ⴀ䤀琀攀洀∀ 搀漀攀猀 琀栀攀 愀挀琀甀愀氀 爀攀渀愀洀椀渀最 漀昀 攀愀挀栀 昀椀氀攀渀愀洀攀 琀栀愀琀 椀琀 爀攀挀攀椀瘀攀猀 昀爀漀洀 䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀⸀㰀戀爀㸀ഀഀ Ofcourse, "$_" is used again, where the "$_.name" is actually the property to give another value.
    ਍㰀戀爀㸀ഀഀ It's not an explicit "loop" we see here. But, still, we have a piece of code that just works through a list, namely the list
    ਍琀栀愀琀 ∀䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀∀ 瀀爀漀搀甀挀攀猀⸀㰀戀爀㸀ഀഀ
    ਍吀栀椀猀 䌀洀搀䰀攀琀 椀猀 眀漀爀琀栀 眀栀椀氀攀 琀漀 爀攀洀攀洀戀攀爀⸀ 䤀琀 挀漀洀攀猀 椀渀 栀愀渀搀礀 愀渀礀琀椀洀攀 礀漀甀 眀愀渀琀 琀漀 搀漀 猀漀洀攀琀栀椀渀最 眀椀琀栀 愀 氀椀猀琀 漀昀 昀椀氀攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Question:
    ਍㰀戀爀㸀ഀഀ Instead of:
    ਍㰀戀爀㸀ഀഀ PS C:\TEST> Get-ChildItem *.txt | Rename-Item -NewName { $_.name -replace 'txt', 'bak'}
    ਍㰀戀爀㸀ഀഀ Could we also do simply this?:
    ਍㰀戀爀㸀ഀഀ PS C:\TEST> ls *.txt | Rename-Item -NewName { $_.name -replace 'txt', 'bak'}
    ਍ഀഀ ਍㰀戀爀㸀ഀഀ Example 7: Nesting
    ਍㰀戀爀㸀ഀഀ More information on the usage of the curly brackets "{ }" and parenthesis "( )" can be found in the next chapter.
    ਍䠀漀眀攀瘀攀爀Ⰰ 椀琀✀猀 最漀漀搀 琀漀 猀栀漀眀 椀渀 琀栀椀猀 猀攀挀琀椀漀渀Ⰰ 栀漀眀 礀漀甀 猀栀漀甀氀搀 甀猀攀 ∀渀攀猀琀攀搀∀ 猀琀愀琀攀洀攀渀琀猀⸀ 䄀 猀椀洀瀀氀攀 攀砀愀洀瀀氀攀 挀愀渀 椀氀氀甀猀琀爀愀琀攀 琀栀椀猀⸀㰀戀爀㸀ഀഀ
    ਍匀甀瀀瀀漀猀攀 椀渀 猀漀洀攀 搀椀爀攀挀琀漀爀礀Ⰰ 礀漀甀 栀愀瘀攀 昀椀氀攀猀 眀椀琀栀 渀愀洀攀猀 氀椀欀攀 ⨀愀愀⨀⸀琀砀琀Ⰰ ⨀戀戀⨀⸀琀砀琀Ⰰ 愀渀搀 洀愀渀礀 漀琀栀攀爀 渀愀洀攀猀⸀㰀戀爀㸀ഀഀ Suppose you only want to select the *aa* files, and perform some operation on them.
    ਍㰀戀爀㸀ഀഀ Then, you could
    ਍㰀戀爀㸀ഀഀ - first create a collection (or list) to contain all files.
    ਍ⴀ 琀栀攀渀Ⰰ 甀猀椀渀最 ∀昀漀爀攀愀挀栀∀Ⰰ 氀漀漀瀀 琀栀爀漀甀最栀 琀栀攀 氀椀猀琀⸀㰀戀爀㸀ഀഀ - then, use an "if" test, to test if a member is an "*aa*" file.
    ਍ⴀ 琀栀攀渀Ⰰ 瀀攀爀昀漀爀洀 眀栀愀琀攀瘀攀爀 漀瀀攀爀愀琀椀漀渀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍␀昀椀氀攀氀椀猀琀㴀氀猀 ⨀⸀琀砀琀㰀戀爀㸀ഀഀ foreach ($myvar in $filelist)
    ਍㰀䈀㸀笀㰀⼀䈀㸀㰀戀爀㸀ഀഀ   if ($myvar.name -like "*aa*")
    ਍☀渀戀猀瀀 㰀䈀㸀笀㰀⼀䈀㸀㰀戀爀㸀ഀഀ     write-output $myvar.name
    ਍☀渀戀猀瀀 㰀䈀㸀紀㰀⼀䈀㸀㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀ഀഀ ਍伀昀挀漀甀爀猀攀Ⰰ 琀栀攀 愀戀漀瘀攀 攀砀愀洀瀀氀攀 挀愀渀 戀攀 猀椀洀瀀氀礀昀椀攀搀 戀礀 樀甀猀琀 挀爀攀愀琀椀渀最 愀 挀漀氀氀攀挀琀椀漀渀 氀椀欀攀 ∀␀昀椀氀攀氀椀猀琀㴀氀猀 ⨀愀愀⨀⸀琀砀琀㰀戀爀㸀ഀഀ However, the purpose is to show you the "nesting", and the use of "{ }" enclosing various "levels" of statements.
    ਍ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍ഀഀ

    Chapter 3. A more structured approach.

    ਍ഀഀ ਍ഀഀ Let's take a more structured approach now. Now, its my experience that a very structured doc is.., well.., sometimes a bit dull.
    ਍䈀甀琀 琀栀攀 愀甀琀栀漀爀 栀攀爀攀 椀猀 愀 挀攀爀琀愀椀渀 䄀氀戀攀爀琀⸀ 匀漀Ⰰ 瘀攀爀礀 猀琀爀甀挀琀甀爀攀搀 猀琀甀昀昀 椀猀 渀漀琀 琀漀 戀攀 攀砀瀀攀挀琀攀搀⸀ 㬀ⴀ⤀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍㰀栀㌀㸀㌀⸀㄀⸀ 倀漀眀攀爀猀栀攀氀氀 瘀愀爀椀愀戀氀攀猀⸀㰀⼀栀㌀㸀ഀഀ ਍ഀഀ As we have seen before, a variable does not need to be declared before you can use it. You can immediately do an assignment
    ਍漀昀 愀 瘀愀爀椀愀戀氀攀渀愀洀攀Ⰰ 琀漀 愀 瘀愀氀甀攀⸀㰀戀爀㸀ഀഀ For example (as seen before):
    ਍㰀戀爀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀猀琀爀椀渀最 㴀 ∀昀爀椀攀猀 栀愀洀戀甀爀最攀爀 洀椀氀欀猀栀愀欀攀∀㰀戀爀㸀ഀഀ PS C:\TEST> $string.split(" ")
    ਍昀爀椀攀猀㰀戀爀㸀ഀഀ hamburger
    ਍洀椀氀欀猀栀愀欀攀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ Here, "$string" is a variable, which seems to hold a "string-like" value. Well, it's string alright, because the value is enclosed by "".
    ਍伀昀挀漀甀爀猀攀Ⰰ 㰀䈀㸀∀渀甀洀戀攀爀猀∀㰀⼀䈀㸀 挀愀渀 戀攀 瀀氀愀挀攀搀 椀渀 愀 瘀愀爀椀愀戀氀攀 琀漀漀⸀ 吀爀礀 琀栀椀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ PS C:\TEST> $var1=5
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀瘀愀爀㈀㴀㈀㰀戀爀㸀ഀഀ PS C:\TEST> $var3=$var1 + $var2
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ␀瘀愀爀㌀㰀戀爀㸀ഀഀ 7
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ Yes, 5+2=7, so variables holding numbers works too. Also, if such a simple calculation works, then it's immediately clear that also quite complicated
    ਍愀爀椀琀栀洀攀琀椀挀 眀椀氀氀 眀漀爀欀 琀漀漀 椀渀 愀 猀椀洀椀氀愀爀 眀愀礀⸀㰀戀爀㸀ഀഀ
    ਍一漀琀攀 琀栀愀琀 䤀 甀猀攀搀 ∀圀爀椀琀攀ⴀ伀甀琀瀀甀琀∀⸀ 圀攀 栀愀瘀攀 猀攀攀渀 ∀圀爀椀琀攀ⴀ伀甀琀瀀甀琀∀ 愀氀爀攀愀搀礀 戀攀昀漀爀攀 椀渀 愀 昀漀爀洀攀爀 攀砀愀洀瀀氀攀⸀ 䈀甀琀 眀椀琀栀 愀 瘀愀爀椀愀戀氀攀Ⰰ 礀漀甀 搀漀渀✀琀 渀攀攀搀 琀漀 甀猀攀 琀栀愀琀 䌀洀搀䰀攀琀⸀㰀戀爀㸀ഀഀ Just entering the variable name from the PS prompt will show it's value.
    ਍㰀戀爀㸀ഀഀ I did not use the "$" character in the variable names without a reason. In Powershell it's simply required.
    ਍匀漀 愀氀氀 礀漀甀爀 瘀愀爀椀愀戀氀攀猀 洀甀猀琀 猀琀愀爀琀 眀椀琀栀 愀 ∀␀∀ 椀渀 琀栀攀椀爀 渀愀洀攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀㰀唀㸀吀礀瀀椀渀最㨀㰀⼀唀㸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍䤀琀✀猀 椀渀琀攀爀攀猀琀椀渀最 琀漀 猀攀攀 眀栀愀琀 栀愀瀀瀀攀猀 椀渀 愀戀漀瘀攀 挀愀氀挀甀氀愀琀椀漀渀Ⰰ 椀昀 礀漀甀 眀漀甀氀搀 琀爀礀 ␀瘀愀爀㄀㴀㔀 愀渀搀 ␀瘀愀爀㈀㴀∀㈀∀㰀戀爀㸀ഀഀ That is: $var1 is obviously a number, but $var2 seems to be a string because it's enclosed by "".
    ਍䄀猀 礀漀甀 眀椀氀氀 猀攀攀Ⰰ 琀栀攀 挀愀氀挀甀氀愀琀椀漀渀 猀琀椀氀氀 眀漀爀欀猀 氀椀欀攀 挀氀漀挀欀眀漀爀欀⸀㰀戀爀㸀ഀഀ
    ਍匀漀Ⰰ 倀漀眀攀爀猀栀攀氀氀 搀漀攀猀 渀漀琀 瀀氀愀挀攀 ∀猀攀瘀攀爀攀 爀攀猀琀爀椀挀琀椀漀渀猀∀ 漀渀 琀礀瀀攀猀 戀攀昀漀爀攀栀愀渀搀⸀ 一漀 ∀猀琀爀漀渀最 琀礀瀀椀渀最∀ 栀攀爀攀⸀ 䤀 琀栀椀渀欀 椀琀✀猀 猀眀攀氀氀 昀漀爀 愀 猀挀爀椀瀀琀椀渀最 氀愀渀最甀愀最攀⸀㰀戀爀㸀ഀഀ
    ਍䠀漀眀攀瘀攀爀Ⰰ 椀昀 渀攀攀搀攀搀Ⰰ 礀漀甀 挀愀渀 琀爀礀 ⠀愀 戀椀琀 漀昀⤀ ∀猀琀爀漀渀最 琀礀瀀椀渀最∀Ⰰ 氀椀欀攀 琀攀氀氀椀渀最 倀漀眀攀爀猀栀攀氀氀 戀攀昀漀爀攀栀愀渀搀 眀栀愀琀 琀栀攀 搀愀琀愀琀礀瀀攀 椀猀⸀ 䰀椀欀攀 猀漀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 嬀椀渀琀崀 ␀瘀愀爀㄀㴀㄀　㰀戀爀㸀 ഀഀ PS C:\TEST> [int] $var2=2
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀瘀愀爀㌀㴀␀瘀愀爀㄀ ⨀ ␀瘀愀爀㈀㰀戀爀㸀ഀഀ PS C:\TEST> $var3
    ਍㈀　㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ ਍㰀䈀㸀㰀唀㸀匀瀀攀挀椀愀氀 嘀愀爀椀愀戀氀攀猀㨀㰀⼀唀㸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀∀␀开∀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍刀攀洀攀洀戀攀爀 琀栀攀 ∀␀开∀ 瘀愀爀椀愀戀氀攀㼀 䤀琀猀 愀氀眀愀礀猀 琀栀攀 瘀愀爀椀愀戀氀攀 愀挀琀椀渀最 愀猀 愀 瀀氀愀挀攀栀漀氀搀攀爀 昀漀爀 搀愀琀愀 眀栀攀渀 䌀洀搀䰀攀琀㄀ ∀瀀椀瀀攀猀∀ 琀栀攀 爀攀挀漀爀搀猀㰀戀爀㸀ഀഀ to CmdLet2. So, CmdLet2 can then immediately work with the "$_" variable.
    ਍㰀戀爀㸀ഀഀ "$args":
    ਍㰀戀爀㸀ഀഀ When you create a script that expects one or more arguments (parameters), then $args in the script will be the holder of those argument(s).
    ਍匀攀攀 攀砀愀洀瀀氀攀 ㌀ 椀渀 挀栀愀瀀琀攀爀 ㈀ 昀漀爀 愀渀 攀砀愀洀瀀氀攀⸀㰀戀爀㸀ഀഀ
    ਍吀栀攀爀攀 愀爀攀 愀 昀攀眀 洀漀爀攀 漀昀 琀栀漀猀攀 ∀猀瀀攀挀椀愀氀∀ 瘀愀爀椀愀戀氀攀猀⸀ 吀栀攀猀攀 愀爀攀 渀漀琀 琀漀漀 猀瀀攀挀琀愀挀甀氀愀爀⸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀㰀唀㸀䄀爀爀愀礀猀㨀㰀⼀唀㸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍䄀渀 ∀愀爀爀愀礀∀ 椀猀 愀 猀漀爀琀 漀昀 ∀洀甀氀琀椀ⴀ瘀愀氀甀攀∀ 瘀愀爀椀愀戀氀攀⸀ 匀漀Ⰰ 椀琀 猀琀漀爀攀猀 洀甀氀琀椀瀀氀攀 瘀愀氀甀攀猀 ⠀愀氀猀漀 挀愀氀氀攀搀 ∀攀氀攀洀攀渀琀猀∀⤀⸀ 一漀眀Ⰰ 琀漀 愀搀搀爀攀猀猀 漀渀攀 瀀愀爀琀椀挀甀氀愀爀 瘀愀氀甀攀㰀戀爀㸀ഀഀ in the array, you can use an "index". Just like the homes in one street, you can distinguish between those homes,
    ਍猀椀渀挀攀 琀栀攀礀 愀氀氀 猀椀洀瀀氀礀 栀愀瘀攀 愀 甀渀椀焀甀攀 渀甀洀戀攀爀⸀ 䤀渀 愀渀 愀爀爀愀礀Ⰰ 琀栀攀 ∀椀渀搀攀砀∀ 猀琀愀爀琀猀 昀爀漀洀 　⸀㰀戀爀㸀ഀഀ
    ਍刀攀洀攀洀戀攀爀 攀砀愀洀瀀氀攀 ㄀ 椀渀 挀栀愀瀀琀攀爀 ㈀㼀 䠀攀爀攀 眀攀 栀愀搀 愀 瘀愀爀椀愀戀氀攀 ␀搀愀琀愀Ⰰ 眀栀椀挀栀 挀漀渀琀愀椀渀猀 琀栀爀攀攀 攀氀攀洀攀渀琀猀⸀ 䤀渀 琀栀椀猀 攀砀愀洀瀀氀攀Ⰰ ∀圀爀椀琀攀ⴀ伀甀琀瀀甀琀∀㰀戀爀㸀ഀഀ only printed the values $data[0] and $data[1]. It did not printed $data[2].
    ਍䤀琀 洀椀最栀琀 戀攀 椀渀猀琀爀甀挀琀椀瘀攀 琀漀 琀愀欀攀 愀 氀漀漀欀 愀琀 攀砀愀洀瀀氀攀 ㄀ 愀最愀椀渀⸀㰀戀爀㸀ഀഀ
    ਍吀漀 甀猀攀 愀渀 愀爀爀愀礀Ⰰ 礀漀甀 挀愀渀 猀椀洀瀀氀礀 愀猀猀椀最渀 愀 ∀洀甀氀琀椀ⴀ瘀愀氀甀攀∀ 爀愀渀最攀 琀漀 愀 瘀愀爀椀愀戀氀攀 氀椀欀攀 椀渀 琀栀攀猀攀 攀砀愀洀瀀氀攀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀洀礀䄀爀爀愀礀㄀ 㴀 ㄀Ⰰ㈀Ⰰ㌀Ⰰ㐀Ⰰ㔀㰀戀爀㸀ഀഀ PS C:\TEST> $myArray2 = "oracleSRV1", "oracleSRV2", "oracleSRV3"
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ␀洀礀䄀爀爀愀礀㈀嬀㄀崀㰀戀爀㸀ഀഀ
    ਍漀爀愀挀氀攀匀刀嘀㈀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ ਍吀愀猀欀㨀㰀戀爀㸀ഀഀ This note is no more than just a simple intro. Once you have obtained some grip in Powershell,
    ਍昀椀渀搀 漀甀琀 眀栀愀琀 礀漀甀 挀愀渀 搀漀 眀椀琀栀 琀栀攀 ∀栀愀猀栀 琀愀戀氀攀∀ 瘀愀爀椀愀戀氀攀⸀㰀戀爀㸀ഀഀ ਍ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍㰀栀㌀㸀㌀⸀㈀⸀ 䴀漀爀攀 漀渀 䰀漀漀瀀猀⸀㰀⼀栀㌀㸀ഀഀ ਍ഀഀ
    ਍㰀䈀㸀㰀唀㸀吀栀攀 ∀昀漀爀攀愀挀栀∀ 氀漀漀瀀㨀㰀⼀唀㸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍ഀഀ In chapter 2, we have seen a few examples of the "foreach" statement, like for example:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\test> $file=ls *.txt
    ਍倀匀 䌀㨀尀琀攀猀琀㸀 昀漀爀攀愀挀栀 ⠀␀洀礀瘀愀爀 椀渀 ␀昀椀氀攀⤀㰀戀爀㸀ഀഀ >>   {
    ਍㸀㸀 ☀渀戀猀瀀 㰀䤀㸀匀漀洀攀 挀漀搀攀⸀⸀⸀ 㰀⼀䤀㸀㰀戀爀㸀ഀഀ >>   }
    ਍㸀㸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ Actually, the "foreach" statement is great for working through some list, or collection, just like the example above,
    ਍眀栀攀爀攀 ∀氀猀 ⨀⸀琀砀琀∀ 瀀爀漀搀甀挀攀猀 愀 氀椀猀琀 漀昀 ⸀琀砀琀 昀椀氀攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ The "Foreach-Object" loop:
    ਍㰀戀爀㸀ഀഀ Just as above, "Foreach-Object" CmdLet is great for working through some list, or collection.
    ਍一漀眀Ⰰ ∀昀漀爀攀愀挀栀∀ 椀猀 愀 挀漀洀洀愀渀搀 椀渀 愀渀 攀砀瀀爀攀猀猀椀漀渀Ⰰ 眀栀椀氀攀 ∀䘀漀爀攀愀挀栀ⴀ伀戀樀攀挀琀∀ 㰀䈀㸀椀猀 愀 䌀洀搀䰀攀琀㰀⼀䈀㸀⸀㰀戀爀㸀ഀഀ
    ਍匀漀Ⰰ 眀栀攀渀攀瘀攀爀 樀漀甀 栀愀瘀攀 愀 䌀洀搀䰀攀琀 琀栀愀琀 ∀瀀椀瀀攀猀∀ 爀攀挀漀爀搀猀 琀漀 愀 渀攀砀琀 䌀洀搀䰀攀琀 昀漀爀 瀀爀漀挀攀猀猀椀渀最 琀栀愀琀 爀攀挀漀爀搀 挀漀氀氀攀挀琀椀漀渀Ⰰ 礀漀甀 猀栀漀甀氀搀 甀猀攀㰀戀爀㸀ഀഀ the "Foreach-Object" CmdLet. So, "Foreach-Object" takes its records from the pipeline.
    ਍㰀戀爀㸀ഀഀ The "Foreach" statement, does not need a pipeline. It just takes a list of values (like names of files etc..)
    ਍㰀戀爀㸀ഀഀ As an example of using the "Foreach-Object" CmdLet, take a look at this example:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\test> Get-WmiObject Win32_Printer | ForEach-Object {$_.Name}
    ਍㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ The "Get-WmiObject" CmdLet pipes records from the "Win32_Printer" class, to the "Foreach-Object" CmdLet.
    ਍匀漀Ⰰ 椀琀猀 愀 挀氀攀愀爀 攀砀愀洀瀀氀攀 栀漀眀 琀栀攀 ∀䘀漀爀攀愀挀栀ⴀ伀戀樀攀挀琀∀ 䌀洀搀䰀攀琀 最攀琀猀 椀琀✀猀 ∀椀渀瀀甀琀∀⸀㰀戀爀㸀ഀഀ
    ਍䈀甀琀 琀栀攀爀攀 愀爀攀 洀漀爀攀 氀漀漀瀀 挀漀渀猀琀爀甀挀琀猀 椀渀 倀漀眀攀爀猀栀攀氀氀⸀ 匀漀洀攀琀椀洀攀猀Ⰰ 礀漀甀 眀愀渀琀 琀漀 眀漀爀欀 眀椀琀栀 愀 ∀挀漀甀渀琀攀爀∀ 琀栀愀琀 椀渀挀爀攀愀猀攀猀 ⠀漀爀 搀攀挀爀攀愀猀攀猀⤀㰀戀爀㸀ഀഀ with each iteration, until this counter reaches a "final value" (like 0, or 1000 etc..).
    ਍䘀漀爀 琀栀椀猀 琀礀瀀攀 漀昀 琀爀甀攀 氀漀漀瀀猀Ⰰ 琀栀攀 ∀眀栀椀氀攀∀ 氀漀漀瀀 挀愀渀 戀攀 甀猀攀搀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ The "while" loop, or equivalently, the "do while" loop:
    ਍㰀戀爀㸀ഀഀ The "while" loop (or "do while" loop) is very usefull when you want some processing done "while a certain condition remains true".
    ਍䤀琀✀猀 搀攀昀椀渀攀搀 愀猀 昀漀氀氀漀眀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ while (condition true)
    ਍笀㰀戀爀㸀ഀഀ statement(s)
    ਍紀㰀戀爀㸀ഀഀ
    ਍漀爀 猀琀愀琀攀搀 愀 戀椀琀 搀椀昀昀攀爀攀渀琀氀礀㨀㰀戀爀㸀ഀഀ
    ਍搀漀 笀猀琀愀琀攀洀攀渀琀猀紀㰀戀爀㸀ഀഀ while (condition true)
    ਍㰀戀爀㸀ഀഀ ਍䈀漀琀栀 昀漀爀洀猀 愀爀攀 攀焀甀椀瘀愀氀攀渀琀⸀ 吀漀 椀氀氀甀猀琀爀愀琀攀 椀琀Ⰰ 琀爀礀 琀栀椀猀 攀砀愀洀瀀氀攀⸀ 䄀猀 琀栀攀 挀漀渀搀椀琀椀漀渀 䤀 栀愀瘀攀 甀猀攀搀 㰀䈀㸀∀眀栀椀氀攀 ⠀㄀ ⴀ氀攀 ㈀⤀∀㰀⼀䈀㸀Ⰰ㰀戀爀㸀ഀഀ meaning: "while (1 is lower than 2) do statements"
    ਍㰀戀爀㸀ഀഀ This condition is always true! So the statements will be repeated forever (until you use Ctrl-C).
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\TEMP> while (1 -le 2) {write-output "hello"}
    ਍㰀戀爀㸀ഀഀ ਍夀漀甀 猀攀攀㼀 䤀琀✀猀 愀 猀椀氀氀礀 攀砀愀洀瀀氀攀⸀ 吀栀攀 挀漀渀搀椀琀椀漀渀 椀猀 猀甀挀栀Ⰰ 琀栀愀琀 渀攀瘀攀爀 愀渀 ∀甀渀琀爀甀攀∀ 瘀愀氀甀攀 眀椀氀氀 戀攀 爀攀愀挀栀攀搀⸀㰀戀爀㸀ഀഀ
    ਍䄀 戀攀琀琀攀爀 攀砀愀洀瀀氀攀 眀漀甀氀搀 戀攀 琀栀椀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀椀㴀㄀㰀戀爀㸀ഀഀ PS C:\TEST> while ($i -le 5) {$i=$i+1; write-output "Hi, here is $i"}
    ਍䠀椀Ⰰ 栀攀爀攀 椀猀 ㈀㰀戀爀㸀ഀഀ Hi, here is 3
    ਍䠀椀Ⰰ 栀攀爀攀 椀猀 㐀㰀戀爀㸀ഀഀ Hi, here is 5
    ਍䠀椀Ⰰ 栀攀爀攀 椀猀 㘀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ Here is use a counter, $i, which initially is set to "1".
    ਍吀栀攀渀 琀栀攀 挀漀渀搀椀琀椀漀渀 昀漀氀氀漀眀猀Ⰰ 眀栀椀挀栀 椀渀 䔀渀最氀椀猀栀 椀猀㨀 搀漀 眀栀椀氀攀 ␀椀 椀猀 氀漀眀攀爀 琀栀愀渀 漀爀 攀焀甀愀氀 琀漀 㔀Ⰰ 琀栀攀 昀漀氀氀漀眀椀渀最 猀琀愀琀攀洀攀渀琀⠀猀⤀⸀㰀戀爀㸀ഀഀ
    ਍䤀渀 琀栀攀 猀琀愀琀攀洀攀渀琀 戀氀漀挀欀Ⰰ 䤀 昀椀爀猀琀 椀渀挀爀攀愀猀攀 琀栀攀 挀漀甀渀琀攀爀 戀礀 ㄀⸀ 吀栀攀渀 昀漀氀氀漀眀猀 愀 瀀爀椀渀琀 猀琀愀琀攀洀攀渀琀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Question: Can you explain why the output shows a $i=2 first, and stops at $i=6 ?
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍㰀戀爀㸀ഀഀ Many years ago, like in the old fashioned "C" programming age, a much better way was developed to describe the increase
    ਍漀昀 猀甀挀栀 愀 挀漀甀渀琀攀爀Ⰰ 愀猀 ∀␀椀∀ 椀渀 琀栀攀 攀砀愀洀瀀氀攀 愀戀漀瘀攀⸀ 伀渀挀攀 礀漀甀 栀愀瘀攀 猀攀攀渀 椀琀Ⰰ 礀漀甀 眀椀氀氀 㰀䤀㸀渀攀瘀攀爀 攀瘀攀爀㰀⼀䤀㸀 甀猀攀 琀栀攀 ∀戀漀爀椀渀最∀ ␀椀㴀␀椀⬀㄀㬀㰀戀爀㸀ഀഀ increment again!
    ਍吀愀欀攀 愀 氀漀漀欀 愀琀 琀栀椀猀 挀漀洀瀀愀挀琀 眀愀礀 琀漀 挀漀搀攀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀椀㴀㄀㰀戀爀㸀ഀഀ PS C:\TEST> while ($i -le 5) {write-output "Hi, here is $i";$i++}
    ਍䠀椀Ⰰ 栀攀爀攀 椀猀 ㄀㰀戀爀㸀ഀഀ Hi, here is 2
    ਍䠀椀Ⰰ 栀攀爀攀 椀猀 ㌀㰀戀爀㸀ഀഀ Hi, here is 4
    ਍䠀椀Ⰰ 栀攀爀攀 椀猀 㔀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ You see that? The "$i++" is the same as the "boring" "$i=$i+1", but it has certainly some more "bling" and style.
    ਍䈀礀 琀栀攀 眀愀礀㨀 瀀爀漀昀攀猀猀椀漀渀愀氀 倀漀眀攀爀猀栀攀氀氀 猀挀爀椀瀀琀猀 眀椀氀氀 愀氀眀愀礀猀 甀猀攀 琀栀愀琀 ∀猀琀礀氀攀∀Ⰰ 猀椀渀挀攀 琀栀愀琀猀 琀栀攀 眀愀礀 琀漀 琀漀 瀀爀漀最爀愀洀 椀渀挀爀攀洀攀渀琀猀 猀椀渀挀攀 愀最攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Question: Can you explain why the output shows a $i=1 first, and now stops at $i=5 ?
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍匀漀洀攀琀椀洀攀猀 礀漀甀 搀漀 渀漀琀 眀愀渀琀 愀渀 椀渀挀爀攀洀攀渀琀 漀昀 ␀椀 戀礀 ∀㄀∀Ⰰ 甀猀椀渀最 ␀椀⬀⬀ 戀甀琀 愀渀 椀渀挀爀攀洀攀渀琀 戀礀 愀渀礀 椀渀琀攀最攀爀 氀椀欀攀 ∀㌀∀ 漀爀 ∀㔀∀ 漀爀 ∀㄀　　∀ 攀琀挀⸀⸀⸀㰀戀爀㸀ഀഀ For this, you can use the "$+=increment" notation. An example might make this clear:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\TEST> $i=5
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 眀栀椀氀攀 ⠀␀椀 ⴀ氀攀 ㈀㘀⤀ 笀 ␀椀㬀 ␀椀⬀㴀㔀紀㰀戀爀㸀ഀഀ
    ਍㔀㰀戀爀㸀ഀഀ 10
    ਍㄀㔀㰀戀爀㸀ഀഀ 20
    ਍㈀㔀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍匀漀 欀攀攀瀀 琀栀攀 甀猀愀最攀猀 漀昀 ∀␀椀⬀⬀∀ 愀渀搀 ∀␀椀⬀㴀瘀愀氀甀攀∀ 椀渀 洀椀渀搀⸀ 䄀琀 洀愀渀礀 琀椀洀攀猀Ⰰ 琀栀攀礀 愀爀攀 椀渀挀爀攀搀愀戀氀礀 甀猀攀昀甀氀氀⸀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    3.3. More on CmdLets.

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍唀瀀 琀漀 渀漀眀Ⰰ 眀攀 栀愀瘀攀 漀渀氀礀 猀攀攀渀 琀栀攀 昀漀氀氀漀眀椀渀最 䌀洀搀䰀攀琀猀㨀㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍㰀戀爀㸀ഀഀ Get-Service
    ਍圀栀攀爀攀ⴀ伀戀樀攀挀琀㰀戀爀㸀ഀഀ Set-ExecutionPolicy
    ਍䜀攀琀ⴀ䌀漀渀琀攀渀琀 㰀戀爀㸀ഀഀ Write-Output
    ਍圀爀椀琀攀ⴀ䠀漀猀琀㰀戀爀㸀ഀഀ Get-WmiObject
    ਍䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀 㰀戀爀㸀ഀഀ Foreach-Object
    ਍㰀戀爀㸀ഀഀ But we are going to meet quite a few more in the text below.
    ਍ഀഀ ਍㰀戀爀㸀ഀഀ How can we get a list of availble CmdLets? To get a list of CmdLet's which are available in your session,
    ਍礀漀甀 挀愀渀 甀猀攀 琀栀攀 㰀䈀㸀∀䜀攀琀ⴀ䌀漀洀洀愀渀搀∀㰀⼀䈀㸀 䌀洀搀䰀攀琀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䜀攀琀ⴀ䌀漀洀洀愀渀搀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀 ഀഀ ਍ഀഀ This produces a large list of CmdLets, with a possible "alias" (or shortname) to that CmdLet.
    ਍吀栀攀 氀椀猀琀椀渀最 眀椀氀氀 爀甀猀栀 戀礀 漀渀 礀漀甀爀 猀挀爀攀攀渀⸀ 䤀昀 礀漀甀 眀愀渀琀 琀漀 猀攀攀 椀琀 ∀漀渀攀 猀挀爀攀攀渀 愀琀 琀栀攀 琀椀洀攀∀Ⰰ 甀猀攀 㰀䈀㸀∀䜀攀琀ⴀ䌀漀洀洀愀渀搀 簀 洀漀爀攀∀㰀⼀䈀㸀⸀㰀戀爀㸀ഀഀ
    ਍䄀渀礀眀愀礀Ⰰ 椀琀✀猀 愀渀 椀洀瀀爀攀猀猀椀瘀攀 氀椀猀琀⸀㰀戀爀㸀ഀഀ
    ਍䄀 䌀洀搀䰀攀琀 椀猀 ∀搀漀琀 一攀琀∀ 挀漀搀攀⸀ 䤀琀✀猀 渀漀琀 氀椀欀攀 愀 琀爀愀搀椀琀椀漀渀愀氀 ∀⸀攀砀攀∀Ⰰ 琀栀愀琀 礀漀甀 挀愀渀 昀椀渀搀 椀渀 猀漀洀攀 昀漀氀搀攀爀 漀渀 搀椀猀欀⸀㰀戀爀㸀ഀഀ Instead, dot Net "classes" were created in a hierarchical "namespace", which naming structure "resembles"
    ਍愀 猀漀爀琀 漀昀 昀漀氀搀攀爀 猀琀爀甀挀琀甀爀攀⸀㰀戀爀㸀ഀഀ
    ਍伀戀樀攀挀琀猀 挀愀渀 戀攀 ∀椀渀琀猀琀愀渀琀椀愀琀攀搀∀Ⰰ 洀攀愀渀椀渀最 琀栀愀琀 琀栀攀礀 最攀琀 攀砀攀挀甀琀攀搀 椀渀 琀栀攀 猀甀瀀瀀漀爀琀椀渀最 搀漀琀 一攀琀 爀甀渀琀椀洀攀 攀渀瘀椀爀漀渀洀攀渀琀⸀ 㰀戀爀㸀ഀഀ The classes are the blueprints, for the objects that "live" in the dot Net "machine".
    ਍㰀戀爀㸀ഀഀ Often, CmdLets are implemented in "assembly files" which really can be found on disk. The filenames of such files
    ਍漀昀琀攀渀 栀愀瘀攀 愀 爀攀猀攀洀戀氀攀渀挀攀 琀漀 琀栀攀 瀀愀爀琀 漀昀 琀栀攀 渀愀洀攀猀瀀愀挀攀 琀栀攀礀 戀攀氀漀渀最 琀漀漀⸀ 䘀漀爀 攀砀愀洀瀀氀攀Ⰰ 礀漀甀 洀椀最栀琀 昀椀渀搀 昀椀氀攀猀 氀椀欀攀 㰀戀爀㸀ഀഀ "Microsoft.PowerShell.Management.dll" or "Microsoft.WSMan.Management.resources.dll" etc.., if you would search for it.
    ਍㰀戀爀㸀ഀഀ It's also possible to "load" additional CmdLets in your session from "some" assembly module.
    ਍㰀戀爀㸀ഀഀ What often happens too, is that when you install additional features or roles on a Windows Server system,
    ਍琀栀愀琀 琀栀攀渀 愀氀猀漀 愀搀搀椀琀椀漀渀愀氀 倀漀眀攀爀猀栀攀氀氀 洀漀搀甀氀攀猀 最攀琀 椀渀猀琀愀氀氀攀搀 漀渀 礀漀甀爀 猀礀猀琀攀洀Ⰰ 漀昀琀攀渀 椀渀 琀栀攀 昀漀爀洀 漀昀 愀猀猀攀洀戀氀椀攀猀⸀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䤀洀瀀漀爀琀椀渀最 愀搀搀椀琀椀漀渀愀氀 昀甀渀挀琀椀漀渀愀氀椀琀礀㨀 ∀䄀搀搀ⴀ倀猀匀渀愀瀀䤀渀∀ 愀渀搀 ∀䤀洀瀀漀爀琀ⴀ䴀漀搀甀氀攀∀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍䈀攀昀漀爀攀 礀漀甀 猀琀愀爀琀 琀漀 眀漀爀欀 漀渀 猀漀洀攀 瀀爀漀樀攀挀琀Ⰰ 愀爀攀 礀漀甀 猀甀爀攀 礀漀甀 栀愀瘀攀 琀栀攀 爀椀最栀琀 䌀洀搀䰀攀琀猀 昀漀爀 琀栀攀 樀漀戀㼀㰀戀爀㸀ഀഀ
    ਍夀漀甀 欀渀漀眀Ⰰ 眀椀琀栀 琀栀攀 戀愀猀攀 猀攀琀 漀昀 䌀洀搀䰀攀琀猀Ⰰ 礀漀甀 挀愀渀 挀爀攀愀琀攀 瀀攀爀昀攀挀琀 猀挀爀椀瀀琀猀 昀漀爀 愀 愀氀洀漀猀琀 甀渀氀椀洀椀琀攀搀 瘀愀爀椀攀琀礀 漀昀 琀愀猀欀猀⸀㰀戀爀㸀ഀഀ
    ਍䠀漀眀攀瘀攀爀Ⰰ 猀攀琀猀 漀昀 䌀洀搀䰀攀琀猀 挀愀渀 戀攀 㰀䈀㸀∀椀洀瀀漀爀琀攀搀∀㰀⼀䈀㸀 琀漀 礀漀甀爀 猀攀猀猀椀漀渀Ⰰ 愀渀搀 椀琀 挀漀甀氀搀 眀攀氀氀 戀攀 琀栀愀琀 琀栀漀猀攀 䌀洀搀䰀攀琀猀 愀爀攀 愀 最爀攀愀琀 栀攀氀瀀㰀戀爀㸀ഀഀ for certain tasks, like managing Internet Information Server, managing SQL Server, Sharepoint, Clusters, VMWare etc.. etc..
    ਍㰀戀爀㸀ഀഀ In Powershell version 1, you could load a socalled "Snapin" which was the source for additional CmdLets.
    ਍䤀渀 瘀攀爀猀椀漀渀 ㈀ 愀渀搀 栀椀最栀攀爀Ⰰ 礀漀甀 挀愀渀 渀漀眀 氀漀愀搀 愀 猀漀挀愀氀氀攀搀 ∀䴀漀搀甀氀攀∀Ⰰ 眀栀椀挀栀 搀漀攀猀 渀漀琀 渀攀攀搀 爀攀最椀猀琀攀爀椀渀最Ⰰ 愀渀搀 椀猀 攀愀猀椀攀爀 琀漀 甀猀攀⸀㰀戀爀㸀ഀഀ But, also in v.2 you can load a Snapin, if required.
    ਍㰀戀爀㸀ഀഀ There are two CmdLets that let you import a Snapin or a Module (see below): Add-PsSnapIn and Import-Module.
    ਍䘀漀爀 攀砀愀洀瀀氀攀Ⰰ 倀漀眀攀爀匀栀攀氀氀 猀渀愀瀀椀渀猀 愀爀攀 戀椀渀愀爀椀攀猀 ⠀⸀搀氀氀⤀ 琀栀愀琀 椀洀瀀氀攀洀攀渀琀 挀洀搀氀攀琀猀 愀渀搀 瀀爀漀瘀椀搀攀爀猀⸀ 夀漀甀 洀甀猀琀 椀渀猀琀愀氀氀 琀栀攀 猀渀愀瀀椀渀㰀戀爀㸀ഀഀ and then add the cmdlets in the snapin to your session using the Add-PSSnapin cmdlet.
    ਍ഀഀ
    ਍䠀攀爀攀 愀爀攀 琀眀漀 攀砀愀洀瀀氀攀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀漀眀攀爀猀栀攀氀氀 瘀㄀ 猀琀礀氀攀 ⠀愀昀琀攀爀 椀渀猀琀愀氀氀椀渀最 琀栀攀 猀渀愀瀀椀渀⤀⸀ 夀漀甀 洀椀最栀琀 栀愀瘀攀 琀漀 甀猀攀 匀攀琀ⴀ䰀漀挀愀琀椀漀渀 ∀瀀愀琀栀∀ 昀椀爀猀琀⸀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䄀搀搀ⴀ倀匀匀渀愀瀀椀渀 䴀椀挀爀漀猀漀昀琀⸀匀栀愀爀攀倀漀椀渀琀⸀倀漀眀攀爀匀栀攀氀氀㰀戀爀㸀ഀഀ
    ਍倀漀眀攀爀猀栀攀氀氀 瘀㈀ 猀琀礀氀攀㨀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䜀攀琀ⴀ䴀漀搀甀氀攀 ⴀ䰀椀猀琀䄀瘀愀椀氀愀戀氀攀㰀戀爀㸀ഀഀ
    ਍㰀䤀㸀瀀爀漀搀甀挀攀猀 愀 氀椀猀琀 漀昀 愀瘀愀椀氀愀戀氀攀 洀漀搀甀氀攀猀⸀⸀⸀㰀⼀䤀㸀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䤀洀瀀漀爀琀ⴀ䴀漀搀甀氀攀 ⴀ一愀洀攀 䴀漀搀甀氀攀一愀洀攀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀 ഀഀ ਍匀椀渀挀攀 䌀洀搀䰀攀琀猀 愀爀攀 瀀攀爀昀攀挀琀氀礀 搀攀猀椀最渀攀搀 昀漀爀 ∀瀀愀猀猀椀渀最 漀戀樀攀挀琀猀 琀栀爀漀甀最栀 愀 瀀椀瀀攀∀Ⰰ 琀栀攀 昀漀氀氀漀眀椀渀最 猀琀愀琀攀洀攀渀琀 眀漀甀氀搀 渀漀琀 戀攀 瘀攀爀礀 猀甀爀瀀爀椀猀椀渀最㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䜀攀琀ⴀ䴀漀搀甀氀攀 ⴀ䰀椀猀琀䄀瘀愀椀氀愀戀氀攀 簀 䤀洀瀀漀爀琀ⴀ䴀漀搀甀氀攀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀 ഀഀ ਍ഀഀ As an example, if you would load the "Active Directory" module, many new CmdLets are available which are specialized for
    ਍䄀䐀 漀瀀攀爀愀琀椀漀渀猀⸀ 吀栀椀猀 洀攀愀渀猀 琀栀愀琀 眀椀琀栀 猀椀洀瀀氀攀 猀栀漀爀琀 猀琀愀琀攀洀攀渀琀猀 漀爀 猀挀爀椀瀀琀猀Ⰰ 礀漀甀 挀愀渀 愀搀搀 漀爀 氀椀猀琀 愀挀挀漀甀渀琀猀Ⰰ 挀漀洀瀀甀琀攀爀猀 攀琀挀⸀⸀ 攀琀挀⸀⸀㰀戀爀㸀ഀഀ Truly amazing stuff, really.
    ਍㰀戀爀㸀ഀഀ You would load the AD module, using:
    ਍㰀戀爀㸀ഀഀ ਍倀匀 䌀㨀尀㸀 䤀洀瀀漀爀琀ⴀ䴀漀搀甀氀攀 䄀挀琀椀瘀攀䐀椀爀攀挀琀漀爀礀 㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ On a Win2K8 DC, the module is available right away. From a Win7 workstation, you can load the module,
    ਍戀甀琀 愀搀搀椀琀椀漀渀愀氀 猀琀攀瀀猀 渀攀攀搀 琀漀 戀攀 琀愀欀攀渀⸀ 吀栀椀猀 椀猀 渀漀琀 琀栀攀 猀甀戀樀攀挀琀 漀昀 琀栀椀猀 椀渀琀爀漀搀甀挀琀椀漀渀⸀㰀戀爀㸀ഀഀ
    ਍ഀഀ If you would want a list of AD useraccounts, using VB, it would be a relatively lengthy story (well, not really that much).
    ਍一漀琀 眀椀琀栀 倀漀眀攀爀匀栀攀氀氀⸀ 伀渀 愀 䐀䌀Ⰰ 琀爀礀 琀栀椀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ PS C:\TEST> Get-Aduser –filter * | export-csv "listing.csv"
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀 ഀഀ
    ਍吀栀攀 ∀䄀挀琀椀瘀攀 䐀椀爀攀挀琀漀爀礀 䴀漀搀甀氀攀 昀漀爀 圀椀渀搀漀眀猀 倀漀眀攀爀匀栀攀氀氀∀Ⰰ 漀昀昀攀爀猀 愀琀 氀攀愀猀琀 㤀　 ⠀漀爀 猀漀⤀ 渀攀眀 䌀洀搀䰀攀琀猀 昀漀爀 昀甀氀氀㰀戀爀㸀ഀഀ AD management, like for example "New-ADUser", "New-ADComputer".
    ਍ഀഀ
    ਍吀栀攀 甀瀀瀀攀爀 椀渀昀漀爀洀愀琀椀漀渀 椀猀 琀爀甀氀礀 ∀洀椀渀椀洀愀氀∀⸀ 吀栀攀 漀渀氀礀 攀昀昀攀挀琀 挀愀渀 戀攀Ⰰ 琀栀愀琀 愀琀 氀攀愀猀琀 礀漀甀 愀爀攀 愀眀愀爀攀 琀栀愀琀 琀栀攀爀攀 攀砀椀猀琀猀 漀瀀琀椀漀渀猀㰀戀爀㸀ഀഀ to load additional functionality.
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    3.4. Functions.

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䄀 ∀昀甀渀挀琀椀漀渀∀ 椀猀 渀漀琀栀椀渀最 攀氀猀攀 琀栀愀渀 愀 戀氀漀挀欀 漀昀 猀琀愀琀攀洀攀渀琀猀Ⰰ 椀搀攀渀琀椀昀椀攀搀 甀渀搀攀爀 漀渀攀 ∀渀愀洀攀∀⸀㰀戀爀㸀ഀഀ Usually, a function takes one or more arguments, but that's not a requirement.
    ਍䤀琀✀猀 爀攀愀氀氀礀 琀栀愀琀 猀椀洀瀀氀攀⸀ 匀漀Ⰰ 琀栀攀 ∀猀椀洀瀀氀攀猀琀 漀昀 猀椀洀瀀氀攀猀琀∀ 漀昀 愀氀氀 昀甀渀挀琀椀漀渀猀Ⰰ 挀漀甀氀搀 戀攀 琀栀椀猀 漀渀攀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ PS C:\TEST> function myfunction
    ਍㸀㸀 笀㰀戀爀㸀ഀഀ >> write-host "Hi there!"
    ਍㸀㸀 紀㰀戀爀㸀ഀഀ >>
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 洀礀昀甀渀挀琀椀漀渀   ⌀挀愀氀氀 琀栀攀 昀甀渀挀琀椀漀渀ഀഀ
    ਍䠀椀 琀栀攀爀攀℀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀 ഀഀ Obviously, this one is not so usefull, but it's still a fuction allright.
    ਍㰀甀氀㸀ഀഀ
  • One obvious advantage of a function is, is that you can call it more than once in a script.
    • ਍㰀氀椀㸀䄀渀漀琀栀攀爀 愀搀瘀愀渀琀愀最攀 椀猀Ⰰ 椀猀 琀栀愀琀 礀漀甀 挀愀渀 挀爀攀愀琀攀 愀 昀甀渀挀琀椀漀渀 琀漀 搀漀 猀瀀攀挀椀昀椀挀 琀栀椀渀最猀Ⰰ 愀渀搀 漀渀挀攀 椀琀 眀漀爀欀猀Ⰰ㰀戀爀㸀ഀഀ you can just almost blindly re-use it again in other code. ਍㰀氀椀㸀䤀昀 礀漀甀 栀愀瘀攀 愀 氀愀爀最攀 猀挀爀椀瀀琀Ⰰ 琀栀攀 甀猀攀 漀昀 愀 昀甀渀挀琀椀漀渀 洀愀欀攀猀 椀琀 攀愀猀椀攀爀 琀漀 爀攀愀搀Ⰰ 椀渀猀琀攀愀搀 漀昀 爀攀瀀攀愀琀椀渀最 琀栀攀 挀漀搀攀 漀瘀攀爀 愀渀搀 漀瘀攀爀 愀最愀椀渀⸀㰀⼀氀椀㸀ഀഀ ਍唀猀椀渀最 瀀愀爀愀洀攀琀攀爀猀 ⠀漀爀 愀爀最甀洀攀渀琀猀⤀ 挀愀渀 戀攀 搀漀渀攀 椀渀 猀攀瘀攀爀愀氀 眀愀礀猀⸀㰀戀爀㸀ഀഀ One way is to define the function with parameters directly. Here is a simple example:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\TEST> function findfile ($p, $f)
    ਍㸀㸀 笀㰀戀爀㸀ഀഀ >> Get-Childitem $p -Recurse | Where {$_.Name -eq "$f"}
    ਍㸀㸀 紀㰀戀爀㸀ഀഀ >>
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 昀椀渀搀昀椀氀攀 ∀挀㨀尀∀ ∀漀漀瀀猀⸀琀砀琀∀㰀戀爀㸀ഀഀ
    ਍䴀漀搀攀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䰀愀猀琀圀爀椀琀攀吀椀洀攀⸀⸀⸀⸀⸀⸀䰀攀渀最琀栀⸀⸀⸀一愀洀攀㰀戀爀㸀ഀഀ -a--..........06.01.2013 19:26...5........oops.txt
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ Ok, maybe not the greatest example of all, but it should be easy to follow. Here, I created a function that finds a file.
    ਍䤀琀 甀猀攀猀 愀猀 愀爀最甀洀攀渀琀猀 琀栀攀 ∀猀琀愀爀琀椀渀最 瀀愀琀栀∀ ⠀氀椀欀攀 ∀䌀㨀尀∀⤀ 愀渀搀 琀栀攀 ∀昀椀氀攀 渀愀洀攀∀ ⠀氀椀欀攀 ∀漀漀瀀猀⸀琀砀琀∀⤀⸀㰀戀爀㸀ഀഀ
    ਍吀栀椀猀 攀砀愀洀瀀氀攀 爀攀氀椀攀猀 栀攀愀瘀椀氀礀 漀渀 琀栀攀 㰀䈀㸀∀䜀攀琀ⴀ䌀栀椀氀搀椀琀攀洀∀㰀⼀䈀㸀 䌀洀搀䰀攀琀⸀ 吀栀椀猀 椀猀 愀渀 椀洀瀀漀爀琀愀渀琀 䌀洀搀䰀攀琀 椀渀搀攀攀搀⸀㰀戀爀㸀ഀഀ We have seen it before in example 6. In short, a folder can be the "parent" of subfolders and files.
    ਍匀漀Ⰰ 椀昀 眀攀 甀猀攀 愀 䌀洀搀䰀攀琀 眀栀椀挀栀 攀猀猀攀渀琀椀愀氀氀礀 猀愀礀猀 ∀最攀琀 愀氀氀 挀栀椀氀搀猀 眀椀琀栀椀渀 ␀瀀∀ 眀椀琀栀 琀栀攀 挀漀渀搀椀琀椀漀渀 ∀眀栀攀爀攀 琀栀攀 挀栀椀氀搀渀愀洀攀 洀甀猀琀 戀攀 ␀昀∀Ⰰ㰀戀爀㸀ഀഀ then it indeed returns the name of such a file, if it exists.
    ਍㰀戀爀㸀ഀഀ The above really is just minimal information. There is much more to learn on functions.
    ਍㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    3.5. A few notes on when to use curly brackets "{ }" and parenthesis "( )".

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䤀渀 琀栀攀 猀挀爀椀瀀琀猀 猀漀昀愀爀Ⰰ 眀攀 栀愀瘀攀 猀攀攀渀 琀栀攀 甀猀攀 漀昀 挀甀爀氀礀 戀爀愀挀欀攀琀猀 ∀笀 紀∀ 愀渀搀 瀀愀爀攀渀琀栀攀猀椀猀 ∀⠀ ⤀∀ 椀渀 瘀愀爀椀漀甀猀 ∀瀀氀愀挀攀猀∀⸀㰀戀爀㸀ഀഀ But there has to exist certain rules for this. That's indeed true.
    ਍㰀戀爀㸀ഀഀ Sometimes it "feels" quite intuitive, the more so if you already have use other scripting/programming languages.
    ਍㰀戀爀㸀ഀഀ For example a "statement block" always goes between curly brackets "{ }". For example:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ $filelist=ls *.txt
    ਍昀漀爀攀愀挀栀 ⠀␀愀 椀渀 ␀昀椀氀攀氀椀猀琀⤀ 㰀戀爀㸀ഀഀ {
    ਍眀爀椀琀攀ⴀ漀甀琀瀀甀琀 ␀愀㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ Although the "statement block" here, is just one statement, the "write-output $a" sits between the "{ }"
    ਍㰀戀爀㸀ഀഀ The simple example above, also shows a clear example when using parenthesis "( )".
    ਍吀栀攀 ∀昀漀爀攀愀挀栀∀ 氀漀漀瀀 洀甀猀琀 瀀爀漀挀攀猀猀 愀 氀椀猀琀Ⰰ 愀渀搀 琀栀椀猀 氀椀猀琀 椀猀 愀 猀漀爀琀 漀昀 ∀挀漀渀琀爀漀氀 猀琀爀甀挀琀甀爀攀∀ 昀漀爀 琀栀攀 氀漀漀瀀 漀渀 眀栀攀爀攀 琀漀 猀琀愀爀琀Ⰰ㰀戀爀㸀ഀഀ and when to end the loop. In this case, the controlstructure is just a list of all .txt files.
    ਍㰀戀爀㸀ഀഀ But this is typical for loop structures. Anytime a list or expression is used to control a loop structure, it'sits between "( )".
    ਍䠀攀爀攀Ⰰ 琀愀欀攀 愀 氀漀漀欀 愀琀 琀栀椀猀 眀栀椀氀攀 氀漀漀瀀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ $i=1
    ਍眀栀椀氀攀 㰀䈀㸀⠀␀椀 ⴀ氀攀 㔀⤀㰀⼀䈀㸀 笀眀爀椀琀攀ⴀ漀甀琀瀀甀琀 ∀䠀椀Ⰰ 栀攀爀攀 椀猀 ␀椀∀㬀㰀䈀㸀␀椀⬀⬀㰀⼀䈀㸀紀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䈀甀琀 琀栀攀爀攀 愀爀攀 漀挀挀愀猀椀漀渀猀 眀栀攀爀攀 琀栀攀 甀猀攀 漀昀 挀甀爀氀礀 戀爀愀挀欀攀琀猀 ∀笀 紀∀ 愀渀搀 瀀愀爀攀渀琀栀攀猀椀猀 ∀⠀ ⤀∀ 洀椀最栀琀 渀漀琀 戀攀 猀漀 漀戀瘀椀漀甀猀⸀㰀戀爀㸀ഀഀ
    ਍䘀漀爀 攀砀愀洀瀀氀攀Ⰰ 眀栀攀渀 礀漀甀 栀愀瘀攀 愀 䌀洀搀䰀攀琀 琀栀愀琀 瀀椀瀀攀猀 琀漀 愀渀漀琀栀攀爀 䌀洀搀䰀攀琀Ⰰ 眀栀攀爀攀 琀栀攀 猀攀挀漀渀搀 䌀洀搀䰀攀琀 㰀䈀㸀洀甀猀琀 攀瘀愀氀甀愀琀攀㰀⼀䈀㸀 愀 挀漀渀搀椀琀椀漀渀 漀爀 攀砀瀀爀攀猀猀椀漀渀Ⰰ㰀戀爀㸀ഀഀ then curly brackets "{ }" are used.
    ਍㰀戀爀㸀ഀഀ Here are a few examples:
    ਍㰀戀爀㸀 ഀഀ ਍㴀㸀 䘀漀爀 攀愀挀栀 搀攀瘀椀挀攀 椀渀 琀栀攀 瀀爀椀渀琀攀爀 挀氀愀猀猀Ⰰ 漀渀氀礀 猀栀漀眀 椀琀✀猀 渀愀洀攀㨀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䜀攀琀ⴀ圀洀椀伀戀樀攀挀琀 圀椀渀㌀㈀开倀爀椀渀琀攀爀 簀 䘀漀爀䔀愀挀栀ⴀ伀戀樀攀挀琀 笀␀开⸀一愀洀攀紀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍㴀㸀 伀渀氀礀 瀀爀椀渀琀 琀栀攀 瀀爀漀瀀攀爀琀椀攀猀 昀漀爀 琀栀椀猀 漀渀攀 瀀爀椀渀琀攀爀Ⰰ 挀愀氀氀攀搀 ∀䘀愀砀∀㨀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䜀攀琀ⴀ圀洀椀漀戀樀攀挀琀 圀椀渀㌀㈀开瀀爀椀渀琀攀爀 簀 眀栀攀爀攀 笀␀开⸀渀愀洀攀 ⴀ攀焀 ∀䘀愀砀∀紀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍㴀㸀 䄀最愀椀渀 愀渀 攀砀愀洀瀀氀攀 眀栀攀爀攀 愀 䌀洀搀䰀攀琀 ⠀䜀攀琀ⴀ䌀栀椀氀搀椀琀攀洀⤀ 瀀甀猀栀攀猀 爀攀挀漀爀搀猀 琀漀 ∀圀栀攀爀攀∀ ⠀愀渀 愀氀椀愀猀 琀漀 圀栀攀爀攀ⴀ伀戀樀攀挀琀⤀Ⰰ 眀栀椀挀栀 洀甀猀琀 攀瘀愀氀甀愀琀攀 猀漀洀攀琀栀椀渀最⸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀昀甀渀挀琀椀漀渀 昀椀渀搀昀椀氀攀 ⠀␀瀀Ⰰ ␀昀⤀㰀戀爀㸀ഀഀ {
    ਍䜀攀琀ⴀ䌀栀椀氀搀椀琀攀洀 ␀瀀 ⴀ刀攀挀甀爀猀攀 簀 圀栀攀爀攀 笀␀开⸀一愀洀攀 ⴀ攀焀 ∀␀昀∀紀㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀ഀഀ ਍圀栀攀 栀愀瘀攀 猀攀攀渀 琀栀攀 甀猀攀 漀昀 猀焀甀愀爀攀 戀爀愀挀欀攀琀猀 ∀嬀 崀∀ 琀漀漀Ⰰ 椀渀 愀 昀攀眀 漀挀挀愀猀椀漀渀猀⸀ 吀栀攀礀 愀爀攀 漀昀琀攀渀 甀猀攀搀 琀漀 搀攀渀漀琀攀 愀爀爀愀礀 洀攀洀戀攀爀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍㰀栀㌀㸀㌀⸀㘀⸀ 圀䴀䤀⸀㰀⼀栀㌀㸀ഀഀ ਍ഀഀ WMI or "Windows Management Instrumentation", abstracts computer resources (like disks, memory, netcards etc..), and
    ਍㰀䤀㸀愀渀礀琀栀椀渀最 攀氀猀攀㰀⼀䤀㸀 昀漀爀 眀栀椀挀栀 愀 猀漀挀愀氀氀攀搀 ∀圀䴀䤀 瀀爀漀瘀椀搀攀爀猀∀ 攀砀椀猀琀猀⸀㰀戀爀㸀ഀഀ For example, if there should exists a "provider" to see "scheduled tasks", then this resource is viewable from the WMI api too.
    ਍匀漀Ⰰ 椀琀✀猀 渀漀琀 漀渀氀礀 栀愀爀搀眀愀爀攀 爀攀猀漀甀爀挀攀猀 琀栀愀琀 愀爀攀 挀漀瘀攀爀攀搀 戀礀 圀䴀䤀Ⰰ 戀甀琀 愀瀀瀀氀椀挀愀琀椀漀渀猀 愀渀搀 伀瀀攀爀愀琀椀渀最 匀礀猀琀攀洀 爀攀猀漀甀爀挀攀猀 愀猀 眀攀氀氀⸀㰀戀爀㸀ഀഀ
    ਍圀䴀䤀 椀猀 䴀椀挀爀漀猀漀昀琀✀猀 椀洀瀀氀攀洀攀渀琀愀琀椀漀渀 漀昀 琀栀攀 最攀渀攀爀愀氀 ∀䌀䤀䴀∀ 猀琀愀渀搀愀爀搀 ⠀∀䌀漀洀洀漀渀 䤀渀昀漀爀洀愀琀椀漀渀 䴀漀搀攀氀∀⤀⸀㰀戀爀㸀ഀഀ
    ਍䤀渀 圀䴀䤀 氀愀渀最甀愀最攀Ⰰ 琀栀攀 猀琀甀昀昀 琀栀愀琀 椀猀 洀愀渀愀最攀搀 愀渀搀 瘀椀攀眀愀戀氀攀Ⰰ 愀爀攀 琀栀攀 ∀伀戀樀攀挀琀猀∀Ⰰ 眀栀椀挀栀 ⠀愀猀 甀猀甀愀氀⤀ 愀爀攀 漀爀最愀渀椀稀攀搀 ∀椀渀∀ ∀䌀氀愀猀猀攀猀∀⸀㰀戀爀㸀ഀഀ The "script" or "programming language" that wants to access the managed objects, are often called "consumers".
    ਍吀栀攀猀攀 挀愀渀 愀挀挀攀猀猀 洀愀渀愀最攀搀 漀戀樀攀挀琀猀 琀栀爀漀甀最栀 琀栀攀 甀猀攀 漀昀 琀栀攀 爀椀最栀琀 ∀瀀爀漀瘀椀搀攀爀猀∀⸀㰀戀爀㸀ഀഀ
    ਍吀栀攀 圀䴀䤀 椀渀昀爀愀猀琀爀甀挀琀甀爀攀 椀猀 昀愀椀爀氀礀 挀漀洀瀀氀攀砀Ⰰ 愀渀搀 椀猀 瀀愀爀琀氀礀 愀氀猀漀 ∀䌀伀䴀∀ 戀愀猀攀搀⸀ 䘀漀爀 琀栀椀猀 渀漀琀攀Ⰰ 眀攀 搀漀 渀漀琀 渀攀攀搀 琀漀 欀渀漀眀 愀氀氀 漀昀 琀栀攀 搀攀琀愀椀氀猀⸀㰀戀爀㸀ഀഀ Important is, that Powershell CmdLets are available to query the WMI repository, which can obtain lots of systemdata.
    ਍㰀戀爀㸀ഀഀ The WMI repository uses hierarchical namespaces. Every set of objects which are related, gets their own "namespace".
    ਍䔀愀挀栀 渀愀洀攀猀瀀愀挀攀 栀愀猀 愀 猀漀爀琀 漀昀 ∀爀漀漀琀∀⸀ 吀栀攀 搀攀昀愀甀氀琀 ∀爀漀漀琀∀Ⰰ 椀昀 倀漀眀攀爀猀栀攀氀氀 愀挀挀攀猀猀攀猀 圀䴀䤀Ⰰ 椀猀 ∀爀漀漀琀尀挀椀洀瘀㈀∀Ⰰ 眀栀椀挀栀 椀猀 愀 挀漀氀氀攀挀琀椀漀渀㰀戀爀㸀ഀഀ of classes which represents your computer system as a whole. However, usually other namespaces exists on your system as well,
    ਍氀椀欀攀 昀漀爀 攀砀愀洀瀀氀攀 爀攀氀愀琀攀搀 琀漀 ∀愀瀀瀀氀椀挀愀琀椀漀渀猀∀Ⰰ 漀爀 愀 䐀椀爀攀挀琀漀爀礀 匀攀爀瘀椀挀攀 攀琀挀⸀⸀㰀戀爀㸀ഀഀ
    ਍吀栀攀 洀漀猀琀 椀洀瀀漀爀琀愀渀琀 䌀洀搀䰀攀琀 椀猀 ∀䜀攀琀ⴀ圀洀椀伀戀樀攀挀琀∀Ⰰ 眀栀椀挀栀 挀愀渀 焀甀攀爀礀 渀愀洀攀猀瀀愀挀攀猀Ⰰ 愀渀搀 愀氀氀 挀氀愀猀猀攀猀 眀椀琀栀椀渀 愀 渀愀洀攀猀瀀愀挀攀 ⠀眀栀椀挀栀 椀猀 愀 挀氀愀猀猀 椀琀猀攀氀昀 愀猀 眀攀氀氀⤀⸀㰀戀爀㸀ഀഀ
    ਍䰀攀琀✀猀 琀爀礀 琀栀椀猀㨀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ PS C:\TEST> Get-WmiObject -namespace "root\cimv2" -List
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ This should return an impressive list of classes which you can query further.
    ਍㰀戀爀㸀ഀഀ Since the default namespace is "root\cimv2", you do not need to put that as a parameter if you want to get information
    ਍漀昀 琀栀攀 挀氀愀猀猀攀猀 猀栀漀眀渀 椀渀 琀栀攀 愀戀漀瘀攀 氀椀猀琀椀渀最⸀ 夀漀甀 挀愀渀 樀甀猀琀 焀甀攀爀礀 琀栀攀 挀氀愀猀猀攀猀 搀椀爀攀挀琀氀礀⸀ 䠀攀爀攀 愀爀攀 愀 昀攀眀 攀砀愀洀瀀氀攀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀 ഀഀ ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䜀攀琀ⴀ圀洀椀伀戀樀攀挀琀 ⴀ䌀氀愀猀猀 眀椀渀㌀㈀开䰀漀最椀挀愀氀䐀椀猀欀㰀戀爀㸀ഀഀ PS C:\TEST> Get-Wmiobject -Class win32_OperatingSystem
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 䜀攀琀ⴀ圀洀椀伀戀樀攀挀琀 ⴀ䌀氀愀猀猀 圀椀渀㌀㈀开一攀琀眀漀爀欀䄀搀愀瀀琀攀爀㰀戀爀㸀ഀഀ PS C:\TEST> Get-WmiObject -Class Win32_Printer
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ Since an Object (like a printer) might have many "properies" (each with a value), you might be interrested in one property only.
    ਍䤀渀 猀甀挀栀 愀 挀愀猀攀Ⰰ 昀漀爀 瀀爀椀渀琀攀爀 漀戀樀攀挀琀猀Ⰰ 礀漀甀 挀愀渀 瀀愀猀猀 琀栀攀 爀攀挀漀爀搀猀 琀栀爀漀甀最栀 琀漀 ⠀昀漀爀 攀砀愀洀瀀氀攀⤀ 琀栀攀 ∀䘀漀爀䔀愀挀栀ⴀ伀戀樀攀挀琀∀ 䌀洀搀䰀攀琀Ⰰ㰀戀爀㸀ഀഀ and let it only print the "Name" (of each printer).
    ਍㰀戀爀㸀ഀഀ Remember: Every record transferred by "Get-WmiObject", is contained in the "$_" variable, which is always how it works
    ਍眀栀攀渀 琀眀漀 䌀洀搀䰀攀琀猀 愀爀攀 挀漀渀渀攀挀琀攀搀 戀礀 愀 瀀椀瀀攀⸀ 匀漀Ⰰ 椀昀 礀漀甀 漀渀氀礀 眀愀渀琀 琀栀攀 瀀爀椀渀琀攀爀渀愀洀攀Ⰰ 琀栀攀渀 最攀琀 琀栀攀 ∀␀开⸀渀愀洀攀∀ 瀀爀漀瀀攀爀琀礀 昀漀爀 攀愀挀栀 瀀爀椀渀琀攀爀 椀渀 琀栀攀 氀椀猀琀⸀㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ
    ਍倀匀 䌀㨀尀琀攀猀琀㸀 䜀攀琀ⴀ圀洀椀伀戀樀攀挀琀 圀椀渀㌀㈀开倀爀椀渀琀攀爀 簀 䘀漀爀䔀愀挀栀ⴀ伀戀樀攀挀琀 笀␀开⸀一愀洀攀紀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀 ഀഀ ਍ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍㰀栀㈀㸀䌀栀愀瀀琀攀爀 㐀⸀ 匀漀洀攀 䘀甀爀琀栀攀爀 攀砀愀洀瀀氀攀猀⸀㰀⼀栀㈀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䤀渀 琀椀洀攀Ⰰ 昀漀爀 昀甀爀琀栀攀爀 ∀椀渀猀瀀椀爀愀琀椀漀渀∀Ⰰ 䤀 眀椀氀氀 愀搀搀 愀 挀漀甀瀀氀攀 漀昀 洀漀爀攀 猀挀爀椀瀀琀猀 栀攀爀攀Ⰰ 眀椀琀栀 愀瀀瀀爀漀瀀爀椀愀琀攀 挀漀洀洀攀渀琀猀⸀㰀戀爀㸀ഀഀ For now, I think that already a few nice examples are listed. You can try them, or just simply browse along the code.
    ਍䤀昀 礀漀甀 眀漀甀氀搀 愀最爀攀攀 ⠀甀渀搀攀爀猀琀愀渀搀⤀ 琀栀攀 氀漀最椀挀 愀渀搀 猀礀渀琀愀砀⸀⸀⸀Ⰰ 㰀䤀㸀琀栀愀琀 漀渀氀礀㰀⼀䤀㸀 眀漀甀氀搀 愀氀爀攀愀搀礀 戀攀 昀愀渀琀愀猀琀椀挀 ℀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Example 4.1: delete files from a folder (and subfolders) which are older than "X" days.
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀戀爀㸀 ഀഀ ਍吀栀攀 瀀爀漀戀氀攀洀 挀愀渀 戀攀 搀攀昀椀渀攀搀 愀猀 昀漀氀氀漀眀猀㨀㰀戀爀㸀ഀഀ
    ਍䴀愀渀礀 愀瀀瀀氀椀挀愀琀椀漀渀猀 挀爀攀愀琀攀 氀漀最昀椀氀攀猀⸀ 䈀甀琀 愀昀琀攀爀 眀攀攀欀猀Ⰰ 漀爀 洀漀渀琀栀猀Ⰰ 琀栀漀猀攀 氀漀最昀椀氀攀猀 瀀椀氀攀猀 甀瀀Ⰰ 愀渀搀 琀愀欀攀 琀漀漀 洀甀挀栀 搀椀猀欀猀瀀愀挀攀⸀㰀戀爀㸀ഀഀ Maybe you only want to have the last 7 days, or 30 days (or so), online on disk.
    ਍匀漀Ⰰ 漀氀搀攀爀 氀漀最昀椀氀攀猀 挀愀渀 戀攀 搀攀氀攀琀攀搀⸀ 吀栀攀 昀漀氀氀漀眀椀渀最 倀匀 猀挀爀椀瀀琀 搀漀攀猀 琀栀愀琀⸀㰀戀爀㸀ഀഀ You can schedule such a script, for example, to run once a day, once a week etc..
    ਍㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍␀吀漀搀愀礀 㴀 䜀攀琀ⴀ䐀愀琀攀  㰀戀爀㸀ഀഀ $NumberOfDays = "7"
    ਍␀匀琀愀爀琀椀渀最䘀漀氀搀攀爀 㴀 ∀䌀㨀尀琀攀洀瀀∀ 㰀戀爀㸀ഀഀ $Extension = "*.log"
    ਍␀䰀愀猀琀圀爀椀琀攀 㴀 ␀吀漀搀愀礀⸀䄀搀搀䐀愀礀猀⠀ⴀ␀一甀洀戀攀爀伀昀䐀愀礀猀⤀  㰀戀爀㸀ഀഀ
    ਍⌀ 䈀漀搀礀 漀昀 挀漀搀攀㨀㰀戀爀㸀ഀഀ
    ਍␀䘀椀氀攀猀䌀漀氀氀攀挀琀椀漀渀 㴀 䜀攀琀ⴀ䌀栀椀氀搀椀琀攀洀 ␀匀琀愀爀琀椀渀最䘀漀氀搀攀爀 ⴀ䤀渀挀氀甀搀攀 ␀䔀砀琀攀渀猀椀漀渀 ⴀ刀攀挀甀爀猀攀 簀 圀栀攀爀攀 笀␀开⸀䰀愀猀琀圀爀椀琀攀吀椀洀攀 ⴀ氀攀 ∀␀䰀愀猀琀圀爀椀琀攀∀紀 㰀戀爀㸀ഀഀ
    ਍昀漀爀攀愀挀栀 ⠀␀䘀椀氀攀 椀渀 ␀䘀椀氀攀猀䌀漀氀氀攀挀琀椀漀渀⤀   㰀戀爀㸀ഀഀ {
    ਍刀攀洀漀瘀攀ⴀ䤀琀攀洀 ␀䘀椀氀攀⸀䘀甀氀氀一愀洀攀 簀 漀甀琀ⴀ渀甀氀氀  㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀 ഀഀ ਍ഀഀ Now, let's walk through this script.
    ਍㰀戀爀㸀ഀഀ You see that first a few variables are set. You know that any variable starts with a "$" symbol.
    ਍吀栀攀 瘀愀爀椀愀戀氀攀 ␀吀漀搀愀礀 攀焀甀愀氀猀 琀栀攀 䌀洀搀䰀攀琀 ∀䜀攀琀ⴀ䐀愀琀攀∀Ⰰ 眀栀椀挀栀Ⰰ 眀栀攀渀 挀愀氀氀攀搀Ⰰ 爀攀琀爀椀攀瘀攀猀 琀栀攀 挀甀爀爀攀渀琀 搀愀琀攀⼀琀椀洀攀⸀㰀戀爀㸀ഀഀ Then a few fixed variables are set, like "$StartingFolder", which I placed here at "C:\TEMP".
    ਍㰀戀爀㸀ഀഀ The determination of "$LastWrite" deserves some explanation. You know that the plan is to remove all files
    ਍眀栀椀挀栀 愀爀攀 漀氀搀攀爀 琀栀愀琀 㜀 搀愀礀猀⸀ 吀漀 最攀琀 愀琀 琀栀愀琀 瀀漀椀渀琀Ⰰ 眀攀 渀攀攀搀 愀 挀愀氀挀甀氀愀琀椀漀渀 氀愀琀攀爀 漀渀Ⰰ 眀栀攀爀攀 琀栀攀 ∀搀愀琀攀 漀昀 㜀 搀愀礀猀 愀最漀∀㰀戀爀㸀ഀഀ must be known. Then we can investigate the "last write time" of any file, and compare it to the "date of 7 days ago".
    ਍㰀戀爀㸀ഀഀ You can try the following statements (or just read them...)
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\TEST> $Today=Get-Date
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 眀爀椀琀攀ⴀ栀漀猀琀 ␀吀漀搀愀礀   ⌀ 氀攀琀猀 猀攀攀 眀栀愀琀 眀攀 栀愀瘀攀㰀戀爀㸀ഀഀ
    ਍　㔀⸀　㄀⸀㈀　㄀㌀ ㄀㌀㨀㈀㔀㨀　㈀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 ␀一甀洀戀攀爀伀昀䐀愀礀猀㴀∀㜀∀㰀戀爀㸀ഀഀ PS C:\TEST> $LastWrite = $Today.AddDays(-$NumberOfDays)
    ਍倀匀 䌀㨀尀吀䔀匀吀㸀 眀爀椀琀攀ⴀ栀漀猀琀 ␀䰀愀猀琀圀爀椀琀攀㰀戀爀㸀ഀഀ
    ਍㈀㤀⸀㄀㈀⸀㈀　㄀㈀ ㄀㌀㨀㈀㔀㨀　㈀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍夀攀猀Ⰰ ∀␀䰀愀猀琀圀爀椀琀攀∀ 挀漀渀琀愀椀渀猀 琀栀攀 ∀搀愀琀攀∀Ⰰ 昀爀漀洀 㜀 搀愀礀猀 愀最漀⸀㰀戀爀㸀ഀഀ
    ਍一攀砀琀Ⰰ 眀椀琀栀 ∀␀䘀椀氀攀猀䌀漀氀氀攀挀琀椀漀渀∀Ⰰ 眀攀 挀爀攀愀琀攀 愀 挀漀氀氀攀挀琀椀漀渀 ⠀漀爀 氀椀猀琀⤀ 漀昀 昀椀氀攀猀Ⰰ 椀渀 愀氀氀 猀甀戀昀漀氀搀攀爀猀 椀渀 䌀㨀尀吀䔀䴀倀Ⰰ㰀戀爀㸀ഀഀ which are older than 7 days. Notice the use of the "Get-Childitem" CmdLet.
    ਍圀攀 栀愀瘀攀 猀攀攀渀 ∀䜀攀琀ⴀ䌀栀椀氀搀椀琀攀洀∀ 戀攀昀漀爀攀 椀渀 攀砀愀洀瀀氀攀 㘀⸀ 䠀攀爀攀 琀漀漀Ⰰ 眀攀 眀愀渀琀攀搀 愀 氀椀猀琀 漀昀 昀椀氀攀猀⸀ 吀栀攀 渀愀洀攀 ∀䜀攀琀ⴀ䌀栀椀氀搀椀琀攀洀∀㰀戀爀㸀ഀഀ already says it all. If "C:\TEMP" is the "parent", then every object in it, are it's "children".
    ਍㰀戀爀㸀ഀഀ You should be able to have "an idea" how "$FilesCollection", after "Get-Childitem" did it's work, is a list of files
    ਍眀栀椀挀栀 洀甀猀琀 戀攀 瀀爀漀挀攀猀猀攀搀⸀ 一攀砀琀Ⰰ 愀 昀漀爀攀愀挀栀 氀漀漀瀀 眀椀氀氀 眀漀爀欀 琀栀爀漀甀最栀 琀栀攀 氀椀猀琀Ⰰ 愀渀搀 搀攀氀攀琀攀猀 琀栀攀 昀椀氀攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ ਍一漀琀攀㨀㰀戀爀㸀ഀഀ
    ਍䄀 猀椀洀椀氀愀爀 挀洀搀 猀栀攀氀氀 挀漀洀洀愀渀搀 椀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ C:\> forfiles /P C:\webserver\logs /S /M *.log /D -30 /C "cmd /c del @FILE"
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ This example will delete all *.log files in the "c:\webserver\logs" directory, which are older than 30 days.
    ਍䤀琀 猀攀攀洀猀 愀氀洀漀猀琀 攀愀猀椀攀爀 琀栀愀渀 甀猀椀渀最 倀漀眀攀爀猀栀攀氀氀 ℀ 圀攀氀氀Ⰰ 一漀⸀ 夀漀甀 搀漀 渀漀琀 眀愀渀琀 琀漀 欀渀漀眀 眀栀愀琀 攀昀昀漀爀琀 䴀匀 甀猀攀搀 琀漀 戀甀椀氀搀  琀栀攀 ∀昀漀爀昀椀氀攀猀∀ 挀漀洀洀愀渀搀⸀㰀戀爀㸀ഀഀ With Powershell, your CmdLets and everything else that make up the environment (e.g. loop constructs, functions etc..)
    ਍愀氀氀 昀漀爀洀 攀渀搀氀攀猀猀氀礀 洀漀爀攀 瀀漀眀攀爀昀甀氀氀 戀甀椀氀搀椀渀最 戀氀漀挀欀猀Ⰰ 琀漀 戀甀椀氀搀 愀渀礀琀栀椀渀最 礀漀甀 渀攀攀搀⸀㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀栀爀⼀㸀ഀഀ ਍㰀䈀㸀䔀砀愀洀瀀氀攀 㐀⸀㈀㨀 嘀椀攀眀椀渀最 愀渀搀 洀愀渀愀最椀渀最 愀 ∀圀椀渀㈀䬀㠀 ⼀ 圀椀渀㈀䬀㄀㈀ 䘀愀椀氀漀瘀攀爀 䌀氀甀猀琀攀爀∀⸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ ਍㰀栀爀⼀㸀ഀഀ
    ਍伀渀挀攀 礀漀甀 栀愀瘀攀 椀渀猀琀愀氀氀攀搀 愀 ∀䘀愀椀氀漀瘀攀爀 䌀氀甀猀琀攀爀∀ 漀渀 ㈀ 漀爀 洀漀爀攀 一漀搀攀猀Ⰰ 漀渀 攀愀挀栀 渀漀搀攀Ⰰ 渀攀眀 䘀愀椀氀漀瘀攀爀 挀氀甀猀琀攀爀 䌀洀搀䰀攀琀猀㰀戀爀㸀ഀഀ are available on those systems.
    ਍㰀戀爀㸀ഀഀ However, it's possible you still need to load the failoverclusters powershell module before you can use those new CmdLets.
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ PS C:\> import-module failoverclusters
    ਍ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ Let's take a look at a few of those new CmdLets. Here are some examples.
    ਍吀栀攀 挀漀洀洀愀渀搀猀 猀栀漀眀渀Ⰰ 愀爀攀 漀渀氀礀 昀漀爀 椀氀氀甀猀琀爀愀琀椀漀渀愀氀 瀀甀爀瀀漀猀攀猀⸀ 䤀渀 礀漀甀爀 瀀愀爀琀椀挀甀氀愀爀 猀椀琀甀愀琀椀漀渀Ⰰ 礀漀甀 漀昀琀攀渀 渀攀攀搀 琀漀 洀漀搀椀昀礀㰀戀爀㸀ഀഀ such an example, before it really works (e.g. clustername, resource group name etc...), unless it's a generic command
    ਍眀栀椀挀栀 搀漀攀猀 渀漀琀 甀猀攀 愀 瀀愀爀琀椀挀甀氀愀爀 挀氀甀猀琀攀爀 漀戀樀攀挀琀 渀愀洀攀 ⠀昀漀爀 攀砀愀洀瀀氀攀Ⰰ 挀爀攀愀琀攀 愀 䌀氀甀猀琀攀爀 氀漀最 昀椀氀攀⤀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ => 1. Create the Cluster log file:
    ਍ഀഀ
    ਍ഀഀ Examples:
    ਍㰀戀爀㸀ഀഀ - Create the log into the current directory (.), over the last 400 minutes (that could be a large ascii file).
    ਍㰀戀爀㸀ഀഀ PS C:\> Get-ClusterLog -Destination . -TimeSpan 400
    ਍㰀戀爀㸀ഀഀ - Create the log into the current directory, over the last 10 minutes.
    ਍㰀戀爀㸀ഀഀ PS C:\> Get-ClusterLog -Destination . -TimeSpan 10
    ਍㰀戀爀㸀ഀഀ => 2. Show cluster nodes:
    ਍㰀戀爀㸀ഀഀ PS C:\> Get-ClusterNode
    ਍㰀戀爀㸀 ഀഀ Name..........State
    ਍ⴀⴀⴀⴀ⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀ⴀⴀⴀⴀⴀ 㰀戀爀㸀ഀഀ node1.........Up
    ਍渀漀搀攀㈀⸀⸀⸀⸀⸀⸀⸀⸀⸀唀瀀 㰀戀爀㸀ഀഀ
    ਍䤀昀 礀漀甀 愀爀攀 渀漀琀 挀漀渀渀攀挀琀攀搀 琀漀 愀 挀攀爀琀愀椀渀 一漀搀攀 漀昀 愀 挀攀爀琀愀椀渀 挀氀甀猀琀攀爀Ⰰ 漀爀 礀漀甀 眀愀渀琀 琀漀 猀攀攀 琀栀攀 猀琀愀琀攀 漀昀 琀栀攀 渀漀搀攀猀㰀戀爀㸀ഀഀ of another cluster, then supply the "clustername" to the CmdLet.
    ਍㰀戀爀㸀ഀഀ PS C:\> Get-ClusterNode -Cluster ClusterSales
    ਍㰀戀爀㸀ഀഀ => 3. Show info of a Cluster (or names of all Clusters)
    ਍㰀戀爀㸀ഀഀ PS C:\> Get-Cluster
    ਍倀匀 䌀㨀尀㸀 䜀攀琀ⴀ䌀氀甀猀琀攀爀 挀氀甀猀琀攀爀㄀ 㰀戀爀㸀ഀഀ PS C:\> Get-Cluster | fl * (shows lots of info)
    ਍倀匀 䌀㨀尀㸀 䜀攀琀ⴀ䌀氀甀猀琀攀爀 ⴀ搀漀洀愀椀渀 愀渀琀愀瀀攀砀⸀渀氀 㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀㴀㸀 㐀⸀ 匀栀漀眀 挀氀甀猀琀攀爀 焀甀漀爀甀洀 椀渀昀漀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀㸀 䜀攀琀ⴀ䌀氀甀猀琀攀爀儀甀漀爀甀洀 ⴀ䌀氀甀猀琀攀爀 匀儀䰀䌀氀甀猀琀攀爀㄀ 㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀㴀㸀 㔀⸀ 䴀漀瘀攀 ⠀昀愀椀氀漀瘀攀爀⤀ 愀 䜀爀漀甀瀀 琀漀 愀渀漀琀栀攀爀 渀漀搀攀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀㸀 䴀漀瘀攀ⴀ䌀氀甀猀琀攀爀䜀爀漀甀瀀 ጀ丠愀洀攀 匀儀䰀䌀䰀唀匀㄀ ⴀ一漀搀攀 渀漀搀攀㈀㰀戀爀㸀ഀഀ PS C:\> Get-ClusterNode node2 | Get-ClusterGroup | Move-ClusterGroup
    ਍㰀戀爀㸀ഀഀ => 6. view resources for a certain Group:
    ਍㰀戀爀㸀ഀഀ PS C:\> Get-ClusterGroup "GROUPNAME" | Get-ClusterResource
    ਍㰀戀爀㸀ഀഀ => 7. Start/Stop a certain Group:
    ਍㰀戀爀㸀ഀഀ PS C:\> Start-ClusterGroup SQLCLUS1
    ਍倀匀 䌀㨀尀㸀 匀琀漀瀀ⴀ䌀氀甀猀琀攀爀䜀爀漀甀瀀 匀儀䰀䌀䰀唀匀㄀㰀戀爀㸀ഀഀ ਍ഀഀ ਍ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Example 4.3: Put quotes around the records of a (flat) .csv file.
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ Suppose that from a database, a report is extracted using some export utility. This utility produces a ".csv" file,
    ਍眀栀椀挀栀 椀猀 愀 ∀挀漀洀洀愀 猀攀瀀攀爀愀琀攀搀∀ 愀猀挀椀椀 昀椀氀攀⸀ 匀甀瀀瀀漀猀攀 琀栀愀琀 琀栀椀猀 攀砀瀀漀爀琀 昀椀氀攀 椀猀 挀愀氀氀攀搀 ∀瀀爀攀开爀攀瀀漀爀琀⸀挀猀瘀∀ 愀渀搀 椀琀 椀猀 挀爀攀愀琀攀搀 戀礀㰀戀爀㸀ഀഀ the export utility in the folder "F:\Uploads\".
    ਍㰀戀爀㸀ഀഀ Now, suppose that the records in "pre_report.csv" have a layout as in the following example:
    ਍㰀戀爀㸀ഀഀ ਍䈀甀猀椀渀攀猀猀 唀渀椀琀Ⰰ刀攀瘀攀渀甀攀Ⰰ吀漀琀愀氀䌀漀猀琀猀㰀戀爀㸀ഀഀ NL,1000400,200562
    ਍唀匀Ⰰ㈀　　㜀㈀㘀Ⰰ㄀㤀㤀㈀㔀㰀戀爀㸀ഀഀ BE,5999000,2001788
    ਍攀琀挀⸀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ Generally, there could be hundreds, or thousends (or even millions) of rows in such a file.
    ਍䄀渀礀眀愀礀Ⰰ 猀甀瀀瀀漀猀攀 昀甀爀琀栀攀爀 琀栀愀琀 琀栀攀 昀椀氀攀 椀猀 渀漀琀 挀漀洀瀀氀攀琀攀 昀漀爀 昀甀爀琀栀攀爀 瀀爀漀挀攀猀猀椀渀最⸀㰀戀爀㸀ഀഀ What the requirement is, is that the records shown above, needs to be enclosed (surrounded) by quotes (").
    ਍⠀䘀漀爀 琀栀攀 猀愀欀攀 漀昀 愀爀最甀洀攀渀琀Ⰰ 氀攀琀✀猀 猀甀瀀瀀漀猀攀 琀栀愀琀 琀栀攀 搀愀琀愀戀愀猀攀 攀砀琀爀愀挀琀椀渀最 甀琀椀氀椀琀礀 椀猀 渀漀琀 愀戀氀攀 琀漀 搀漀 琀栀椀猀⤀⸀㰀戀爀㸀ഀഀ
    ਍匀漀Ⰰ 眀攀 渀攀攀搀 琀栀椀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ "Business Unit,Revenue,TotalCosts"
    ਍∀一䰀Ⰰ㄀　　　㐀　　Ⰰ㈀　　㔀㘀㈀∀㰀戀爀㸀ഀഀ "US,200726,19925"
    ਍∀䈀䔀Ⰰ㔀㤀㤀㤀　　　Ⰰ㈀　　㄀㜀㠀㠀∀㰀戀爀㸀ഀഀ etc..
    ਍㰀戀爀㸀ഀഀ ਍伀渀攀 猀漀氀甀琀椀漀渀 椀猀Ⰰ 琀栀愀琀 眀攀 挀爀攀愀琀攀 愀 倀漀眀攀爀匀栀攀氀氀 猀挀爀椀瀀琀 琀栀愀琀 漀瀀攀爀愀琀攀猀 漀渀 攀瘀攀爀礀 爀攀挀漀爀搀 椀渀 ∀瀀爀攀开爀攀瀀漀爀琀⸀挀猀瘀∀Ⰰ㰀戀爀㸀ഀഀ put double quotes around every record, and places them in the new "report.csv" .csv file.
    ਍吀愀欀攀 愀 氀漀漀欀 愀琀 琀栀攀 昀漀氀氀漀眀椀渀最 猀挀爀椀瀀琀Ⰰ 眀栀椀挀栀 眀椀氀氀 搀漀 攀砀愀挀琀氀礀 琀栀愀琀⸀㰀戀爀㸀 ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍刀攀洀漀瘀攀ⴀ䤀琀攀洀 䘀㨀尀唀瀀氀漀愀搀猀尀爀攀瀀漀爀琀⸀挀猀瘀㰀戀爀㸀ഀഀ
    ਍␀猀礀洀㴀∀怀∀∀㰀戀爀㸀ഀഀ $list = Get-Content F:\Uploads\pre_report.csv
    ਍㰀戀爀㸀 ഀഀ foreach ($v in $list)
    ਍笀㰀戀爀㸀ഀഀ Write-Output "$sym$v$sym" >> F:\Uploads\report.csv
    ਍紀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ As you can see, using the "Remove-Item" CmdLet, we start with removing the former "report.csv" file.
    ਍㰀戀爀㸀ഀഀ Next, we use a variable "$sym" which contains the " symbol. Such a character is a string really, so you would
    ਍渀漀爀洀愀氀氀礀 攀渀挀氀漀猀攀 椀琀 甀猀椀渀最 搀漀甀戀氀攀 焀甀漀琀攀猀⸀ 䈀甀琀 樀甀猀琀 甀猀椀渀最 琀栀爀攀攀 搀漀甀戀氀攀 焀甀漀琀攀猀 ⠀∀∀∀⤀ 搀漀攀猀 渀漀琀 眀漀爀欀⸀㰀戀爀㸀ഀഀ Using it this way "`"", the special single quote will sort of "hide", or "escape", the second double quote, so it ends up
    ਍愀猀 椀昀 琀栀攀 猀攀挀漀渀搀 焀甀漀琀攀 椀猀 樀甀猀琀 愀 渀漀爀洀愀氀 猀琀爀椀渀最 ⠀攀渀挀氀漀猀攀搀 戀礀 搀漀甀戀氀攀 焀甀漀琀攀猀⤀⸀㰀戀爀㸀ഀഀ
    ਍一攀砀琀Ⰰ 眀攀 甀猀攀 琀栀攀 ∀䜀攀琀ⴀ䌀漀渀琀攀渀琀∀ 䌀洀搀䰀攀琀Ⰰ 琀漀 爀攀愀搀 椀渀 琀栀攀 ∀瀀爀攀开爀攀瀀漀爀琀⸀挀猀瘀∀Ⰰ 愀渀搀 瀀甀琀 椀琀 椀渀 琀栀攀 ␀氀椀猀琀 瘀愀爀椀愀戀氀攀⸀㰀戀爀㸀ഀഀ Next, using the "foreach" loop, we process every record from "$list", meaning that we place double quotes
    ਍愀爀漀甀渀搀 攀瘀攀爀礀 爀攀挀漀爀搀Ⰰ 愀渀搀 猀琀漀爀攀 琀栀椀猀 渀攀眀 挀漀氀氀攀挀琀椀漀渀 椀渀 琀栀攀 昀椀氀攀 ∀爀攀瀀漀爀琀⸀挀猀瘀∀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Example 4.4: Some AD examples.
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ When working on a Win2K8 DC, you likely have the "Active Directory" module available, which means that new specialized CmdLets are
    ਍愀琀 礀漀甀爀 搀椀猀瀀漀猀愀氀Ⰰ 昀爀漀洀 眀栀椀挀栀 礀漀甀 挀愀渀 攀愀猀椀氀礀 愀搀搀Ⰰ 搀攀氀攀琀攀Ⰰ 氀椀猀琀 愀挀挀漀甀渀琀猀Ⰰ 最爀漀甀瀀猀Ⰰ 洀攀洀戀攀爀猀 椀渀 最爀漀甀瀀猀Ⰰ 挀漀洀瀀甀琀攀爀猀Ⰰ 氀椀猀琀 伀唀✀猀Ⰰ 攀琀挀⸀⸀ 攀琀挀⸀⸀㰀戀爀㸀ഀഀ
    ਍圀椀琀栀 猀漀洀攀 瀀爀攀瀀愀爀愀琀椀漀渀猀 搀漀渀攀Ⰰ 礀漀甀 挀愀渀 愀氀猀漀 甀猀攀 椀琀 昀爀漀洀 愀 圀椀渀㜀 眀漀爀欀猀琀愀琀椀漀渀Ⰰ 漀爀 猀漀洀攀 洀愀渀愀最攀洀攀渀琀 匀攀爀瘀攀爀⸀㰀戀爀㸀ഀഀ
    ਍䠀攀爀攀 愀爀攀 愀 昀攀眀 猀椀洀瀀氀攀 攀砀愀洀瀀氀攀猀⸀㰀戀爀㸀ഀഀ
    ਍㰀䈀㸀䰀椀猀琀 愀氀氀 甀猀攀爀 愀挀挀漀甀渀琀猀 椀渀 䄀䐀 眀椀琀栀 琀栀攀椀爀 洀漀猀琀 椀渀琀攀爀攀猀琀椀渀最 瀀爀漀瀀攀爀琀椀攀猀 ⠀氀椀欀攀 䌀一Ⰰ 攀渀愀戀氀攀搀⼀搀椀猀愀戀氀攀搀 攀琀挀⸀⸀⤀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ get-aduser –filter * | export-csv "listing.csv"
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ
    ਍㰀䈀㸀䰀椀猀琀 愀氀氀 甀猀攀爀 愀挀挀漀甀渀琀猀 椀渀 最爀漀甀瀀猀Ⰰ 眀椀琀栀 最爀漀甀瀀 渀愀洀攀猀 氀椀欀攀 䘀䤀一⨀ ⠀氀椀欀攀 䘀椀渀愀渀挀攀 漀爀 愀渀礀 最爀漀甀瀀 攀氀猀攀 猀琀愀爀琀椀渀最 眀椀琀栀 ∀䘀䤀一∀㨀㰀⼀䈀㸀㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍ഀഀ # Users in All FIN* groups in user "Long" names (Distinguished Names)
    ਍⌀ 䘀椀爀猀琀 最攀琀 愀氀氀 最爀漀甀瀀猀 眀椀琀栀 渀愀洀攀猀 氀椀欀攀 䘀䤀一⨀㰀戀爀㸀ഀഀ $groups=get-ADGroup -Filter { name -like 'FIN*' } -Searchbase "DC=myorg,DC=org" | ForEach-Object {$_.SamAccountName}
    ਍㰀戀爀㸀ഀഀ # Find all Members in those FIN* groups:
    ਍昀漀爀攀愀挀栀 ⠀␀最爀漀甀瀀 椀渀 ␀最爀漀甀瀀猀⤀笀㰀戀爀㸀ഀഀ get-adgroupmember $group | foreach-object { $_.Name} >> FINmembersFullNames.txt
    ਍紀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀 ഀഀ ਍⌀ 匀愀洀攀 猀挀爀椀瀀琀Ⰰ 戀甀琀 渀漀眀 䴀攀洀戀攀爀猀 漀昀 䄀氀氀 䘀䤀一⨀ 最爀漀甀瀀猀 椀渀 椀渀 匀栀漀爀琀 渀愀洀攀猀 ⠀匀䄀䴀 一愀洀攀猀⤀㰀戀爀㸀ഀഀ # First get all groups with names like FIN*
    ਍␀最爀漀甀瀀猀㴀最攀琀ⴀ䄀䐀䜀爀漀甀瀀 ⴀ䘀椀氀琀攀爀 笀 渀愀洀攀 ⴀ氀椀欀攀 ✀䘀䤀一⨀✀ 紀 ⴀ匀攀愀爀挀栀戀愀猀攀 ∀䐀䌀㴀洀礀漀爀最Ⰰ䐀䌀㴀漀爀最∀ 簀 䘀漀爀䔀愀挀栀ⴀ伀戀樀攀挀琀 笀␀开⸀匀愀洀䄀挀挀漀甀渀琀一愀洀攀紀㰀戀爀㸀ഀഀ
    ਍⌀ 䘀椀渀搀 愀氀氀 䴀攀洀戀攀爀猀 椀渀 琀栀漀猀攀 䘀䤀一⨀ 最爀漀甀瀀猀㨀㰀戀爀㸀ഀഀ foreach ($group in $groups){
    ਍最攀琀ⴀ愀搀最爀漀甀瀀洀攀洀戀攀爀 ␀最爀漀甀瀀 簀 昀漀爀攀愀挀栀ⴀ漀戀樀攀挀琀 笀 ␀开⸀匀愀洀䄀挀挀漀甀渀琀一愀洀攀紀 㸀㸀 䘀䤀一洀攀洀戀攀爀猀匀䄀䴀一愀洀攀猀⸀琀砀琀㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀栀爀⼀㸀ഀഀ ਍㰀䈀㸀䔀砀愀洀瀀氀攀 㐀⸀㔀㨀 䰀漀漀瀀 琀栀爀漀甀最栀 愀 琀攀砀琀 昀椀氀攀 眀椀琀栀 愀挀挀漀甀渀琀猀 愀渀搀 愀猀猀椀最渀 昀椀氀攀 猀礀猀琀攀洀 瀀攀爀洀椀猀猀椀漀渀猀⸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ ਍㰀栀爀⼀㸀ഀഀ
    ਍匀甀瀀瀀漀猀攀 礀漀甀 栀愀瘀攀 愀 琀攀砀琀 昀椀氀攀 眀椀琀栀 甀猀攀爀 愀挀挀漀甀渀琀猀 愀渀搀 漀琀栀攀爀 搀愀琀愀⸀ 一漀眀Ⰰ 甀猀椀渀最 琀栀愀琀 昀椀氀攀Ⰰ 礀漀甀 渀攀攀搀 琀漀 最爀愀渀琀㰀戀爀㸀ഀഀ permissions to some filesystem directory, using "icacls", for the user accounts that are listed in that file.
    ਍㰀戀爀㸀ഀഀ Just suppose we need to create user home directories, and give every user full control on it's private directory,
    ਍愀猀 眀攀氀氀 愀猀 洀愀欀椀渀最 琀栀攀 甀猀攀爀 琀栀攀 ∀漀眀渀攀爀∀ 漀昀 椀琀✀猀 瀀爀椀瘀愀琀攀 搀椀爀攀挀琀漀爀礀⸀㰀戀爀㸀ഀഀ
    ਍ഀഀ
    ਍匀甀瀀瀀漀猀攀 眀攀 栀愀瘀攀 琀栀攀 昀漀氀氀漀眀椀渀最 昀椀氀攀Ⰰ 挀愀氀氀攀搀 ∀渀攀眀愀挀挀漀甀渀琀猀⸀琀砀琀∀㨀㰀戀爀㸀ഀഀ
    ਍㄀㈀㌀㌀㔀 甀猀攀爀㄀ 䄀洀猀琀攀爀搀愀洀㰀戀爀㸀ഀഀ 23769 user2 New York
    ਍㘀㜀㈀㐀㐀 甀猀攀爀㌀ 䈀攀爀氀椀渀㰀戀爀㸀ഀഀ
    ਍吀栀攀渀Ⰰ 甀猀椀渀最㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ Get-Content newaccounts.txt | %{$data=$_.split(" "); Write-Output "$($data[1])"} > acctmp.txt
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍瀀爀漀搀甀挀攀猀 琀栀攀 昀椀氀攀 ∀愀挀挀琀洀瀀⸀琀砀琀∀Ⰰ 眀椀琀栀 挀漀渀琀攀渀琀 氀椀欀攀 琀栀椀猀㨀㰀戀爀㸀ഀഀ
    ਍甀猀攀爀㄀㰀戀爀㸀ഀഀ user2
    ਍甀猀攀爀㌀㰀戀爀㸀ഀഀ
    ਍唀猀椀渀最 ∀圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ∀␀⠀␀搀愀琀愀嬀㄀崀⤀∀紀∀Ⰰ 漀渀氀礀 琀栀攀 猀攀挀漀渀搀 挀漀氀甀洀渀 ⠀挀漀氀甀洀渀 ⌀㄀ 猀椀渀挀攀 琀栀攀 愀爀爀愀礀 猀琀愀爀琀猀 眀椀琀栀 ∀　∀⤀  眀椀氀氀 戀攀 瀀爀椀渀琀攀搀⸀㰀戀爀㸀ഀഀ
    ਍圀攀 挀愀渀 洀愀欀攀 琀栀攀 挀漀搀攀 戀攀琀琀攀爀Ⰰ 椀昀 眀攀 昀椀爀猀琀 琀攀猀琀 椀昀 愀 昀漀爀洀攀爀 ∀愀挀挀琀洀瀀⸀琀砀琀∀ 愀氀爀攀愀搀礀 攀砀椀猀琀猀Ⰰ 愀渀搀 椀昀 猀漀Ⰰ 搀攀氀攀琀攀 椀琀 昀椀爀猀琀⸀㰀戀爀㸀ഀഀ So, we could start with this block:
    ਍㰀戀爀㸀ഀഀ ਍椀昀 ⠀吀攀猀琀ⴀ倀愀琀栀 挀㨀尀琀攀猀琀尀愀挀挀琀洀瀀⸀琀砀琀⤀㰀戀爀㸀ഀഀ {
    ਍刀攀洀漀瘀攀ⴀ䤀琀攀洀 挀㨀尀琀攀猀琀尀愀挀挀琀洀瀀⸀琀砀琀㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀ഀഀ ਍匀漀Ⰰ 琀栀攀 䌀洀搀䰀攀琀 ∀吀攀猀琀ⴀ倀愀琀栀∀ 挀愀渀 戀攀 甀猀攀搀 琀漀 琀攀猀琀 椀昀 愀 搀椀爀攀挀琀漀爀礀 漀爀 昀椀氀攀 攀砀椀猀琀猀⸀ 䤀昀 ∀琀爀甀攀∀ 琀栀攀 挀漀搀攀 戀攀琀眀攀攀渀 笀 紀 眀椀氀氀 戀攀 攀砀攀挀甀琀攀搀⸀㰀戀爀㸀ഀഀ
    ਍一漀琀攀 琀栀愀琀 琀栀攀 ∀琀攀猀琀∀ 椀猀 愀挀琀甀愀氀氀礀 甀猀攀氀攀猀猀 椀渀 漀甀爀 挀愀猀攀Ⰰ 猀椀渀挀攀 氀愀琀攀爀 漀渀 眀攀 挀爀攀愀琀攀 ∀愀挀挀琀洀瀀⸀琀砀琀∀ 甀猀椀渀最 猀椀渀最氀攀 爀攀搀椀爀攀挀琀椀漀渀 ∀㸀∀Ⰰ㰀戀爀㸀ഀഀ which will always overwrite a former file (if it existed already).
    ਍䠀漀眀攀瘀攀爀Ⰰ 椀渀 洀愀渀礀 漀琀栀攀爀 猀挀爀椀瀀琀猀 琀栀攀  䌀洀搀䰀攀琀 ∀吀攀猀琀ⴀ倀愀琀栀∀ 挀愀渀 戀攀 瘀攀爀礀 甀猀攀昀甀氀氀⸀㰀戀爀㸀ഀഀ
    ਍一漀眀Ⰰ 漀甀爀 昀甀氀氀 猀挀爀椀瀀琀 挀漀甀氀搀 氀漀漀欀 氀椀欀攀 琀栀椀猀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ if (Test-Path c:\test\acctmp.txt)
    ਍笀㰀戀爀㸀ഀഀ Remove-Item c:\test\acctmp.txt
    ਍紀㰀戀爀㸀ഀഀ
    ਍䜀攀琀ⴀ䌀漀渀琀攀渀琀 渀攀眀愀挀挀漀甀渀琀猀⸀琀砀琀 簀 ─笀␀搀愀琀愀㴀␀开⸀猀瀀氀椀琀⠀∀ ∀⤀㬀 圀爀椀琀攀ⴀ伀甀琀瀀甀琀 ∀␀⠀␀搀愀琀愀嬀㄀崀⤀∀紀 㸀 愀挀挀琀洀瀀⸀琀砀琀㰀戀爀㸀ഀഀ
    ਍␀氀椀猀琀 㴀 䜀攀琀ⴀ䌀漀渀琀攀渀琀 挀㨀尀琀攀猀琀尀愀挀挀琀洀瀀⸀琀砀琀㰀戀爀㸀ഀഀ
    ਍昀漀爀攀愀挀栀 ⠀␀氀漀最椀渀 椀渀 ␀氀椀猀琀⤀ 㰀戀爀㸀ഀഀ {
    ਍一攀眀ⴀ䤀琀攀洀 尀尀匀䔀刀嘀䔀刀尀甀猀攀爀猀尀␀氀漀最椀渀 ⴀ椀琀攀洀琀礀瀀攀 搀椀爀攀挀琀漀爀礀㰀戀爀㸀ഀഀ
    ਍␀愀挀氀 㴀 䜀攀琀ⴀ䄀挀氀 尀尀匀䔀刀嘀䔀刀尀甀猀攀爀猀尀␀氀漀最椀渀㰀戀爀㸀ഀഀ $permission = "YOURDOMAIN\$login","FullControl","Allow"
    ਍␀愀挀挀攀猀猀刀甀氀攀 㴀 一攀眀ⴀ伀戀樀攀挀琀 匀礀猀琀攀洀⸀匀攀挀甀爀椀琀礀⸀䄀挀挀攀猀猀䌀漀渀琀爀漀氀⸀䘀椀氀攀匀礀猀琀攀洀䄀挀挀攀猀猀刀甀氀攀 ␀瀀攀爀洀椀猀猀椀漀渀㰀戀爀㸀ഀഀ $acl.SetAccessRule($accessRule)
    ਍㰀戀爀㸀ഀഀ $acl | Set-Acl \\SERVER\users\$login
    ਍椀挀愀挀氀猀 尀尀匀䔀刀嘀䔀刀尀甀猀攀爀猀尀␀氀漀最椀渀 ⼀猀攀琀漀眀渀攀爀 ∀夀伀唀刀䐀伀䴀䄀䤀一尀␀氀漀最椀渀∀ ⼀吀㰀戀爀㸀ഀഀ }
    ਍㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ The first few lines we have already discussed.
    ਍㰀戀爀㸀ഀഀ Next, we start a loop using the records in "$list" which contains all accounts from "acctmp.txt".
    ਍㰀戀爀㸀ഀഀ Using the CmdLet "New-Item" we create the users private Home directory.
    ਍㰀戀爀㸀ഀഀ Then, we define a series of variables which essentialy are use to transfer the value "FullControl"
    ਍琀漀 琀栀攀 猀攀挀漀渀搀 氀愀猀琀 猀琀愀琀攀洀攀渀琀Ⰰ 眀栀攀爀攀 ∀匀攀琀ⴀ䄀挀氀∀ 椀猀 ∀昀攀攀搀攀搀∀ 眀椀琀栀 ∀䘀甀氀氀䌀漀渀琀爀漀氀∀ 眀栀椀挀栀 最攀琀猀 愀瀀瀀氀椀攀搀 琀漀 㰀戀爀㸀ഀഀ the user's Home dir "\\SERVER\users\$login".
    ਍㰀戀爀㸀ഀഀ Finally, the last statement uses "icacls" to make the user the owner of it's private Home dir.
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Example 4.6: Compare txt files (.txt, .csv etc...)
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ There are ofcourse many ways to do that. In one approach, we might use the Compare-Object CmdLet.
    ਍䠀攀爀攀 愀爀攀 樀甀猀琀 愀 昀攀眀 攀砀愀洀瀀氀攀猀 ⠀漀爀 渀漀 洀漀爀攀 琀栀愀渀 愀 昀攀眀 猀琀愀琀攀洀攀渀琀猀Ⰰ 愀挀琀甀愀氀氀礀⤀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍倀匀 䌀㨀尀琀攀洀瀀㸀 䌀漀洀瀀愀爀攀ⴀ伀戀樀攀挀琀 ⴀ刀攀昀攀爀攀渀挀攀伀戀樀攀挀琀 ⠀䜀攀琀ⴀ䌀漀渀琀攀渀琀 ⸀尀刀攀瀀漀爀琀䨀漀栀渀⸀挀猀瘀⤀ ⴀ䐀椀昀昀攀爀攀渀挀攀伀戀樀攀挀琀 ⠀䜀攀琀ⴀ䌀漀渀琀攀渀琀 ⸀尀刀攀瀀漀爀琀䴀愀爀礀⸀挀猀瘀⤀㰀戀爀㸀ഀഀ
    ਍漀琀栀攀爀 猀椀洀椀氀愀爀 攀砀愀洀瀀氀攀 ⠀挀漀甀氀搀 戀攀 椀渀 愀 猀挀爀椀瀀琀⤀㨀㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍␀刀攀昀䘀椀氀攀 㴀 䜀攀琀ⴀ䌀漀渀琀攀渀琀 ∀䌀㨀尀吀攀洀瀀尀刀攀瀀漀爀琀䨀漀栀渀⸀琀砀琀∀㰀戀爀㸀ഀഀ $DiffFile = Get-Content "C:\Temp\ReportMary.txt"
    ਍䌀漀洀瀀愀爀攀ⴀ伀戀樀攀挀琀 ␀刀攀昀䘀椀氀攀 ␀䐀椀昀昀䘀椀氀攀㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍匀漀Ⰰ 椀昀 礀漀甀 眀漀甀氀搀 栀愀瘀攀 ∀䌀㨀尀吀攀洀瀀尀刀攀瀀漀爀琀䨀漀栀渀⸀琀砀琀∀ 愀猀 栀愀瘀椀渀最 琀栀攀 挀漀渀琀攀渀琀㨀㰀戀爀㸀ഀഀ
    ਍愀㰀戀爀㸀ഀഀ b
    ਍挀㰀戀爀㸀ഀഀ d
    ਍攀㰀戀爀㸀ഀഀ
    ਍䄀渀搀 椀昀 礀漀甀 眀漀甀氀搀 栀愀瘀攀 ∀䌀㨀尀吀攀洀瀀尀刀攀瀀漀爀琀䴀愀爀礀⸀琀砀琀∀ 愀猀 栀愀瘀椀渀最 琀栀攀 挀漀渀琀攀渀琀㨀㰀戀爀㸀ഀഀ
    ਍愀㰀戀爀㸀ഀഀ b
    ਍挀㰀戀爀㸀ഀഀ
    ਍吀栀攀渀 爀甀渀渀椀渀最 琀栀攀 挀漀洀洀愀渀搀 ⠀漀爀 猀挀爀椀瀀琀⤀ 眀漀甀氀搀 猀栀漀眀 礀漀甀 ∀搀∀ 愀渀搀 ∀攀∀ 愀猀 琀栀攀 搀椀昀昀攀爀攀渀挀攀⸀㰀戀爀㸀ഀഀ
    ਍一漀琀攀㨀 琀栀攀 䐀伀匀 ∀昀挀∀ 挀漀洀洀愀渀搀 椀渀 漀爀搀攀爀 琀漀 挀漀洀瀀愀爀攀 ⠀愀猀挀椀椀 漀爀 戀椀渀愀爀礀⤀ 昀椀氀攀猀Ⰰ 椀猀 爀攀愀氀氀礀 瘀攀爀礀 攀愀猀礀 琀漀 甀猀攀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ C:\TEMP> fc /L ReportJohn.txt ReportMary.txt
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍一漀琀攀㨀 唀猀攀 ∀昀挀 ⼀㼀∀ 琀漀 最攀琀 洀漀爀攀 椀渀昀漀 漀渀 琀栀攀 挀漀洀洀愀渀搀 猀眀椀琀挀栀攀猀⸀㰀戀爀㸀ഀഀ
    ਍䤀渀搀攀攀搀Ⰰ 椀渀 樀甀猀琀 愀 昀攀眀 挀愀猀攀猀 䐀伀匀 挀漀洀洀愀渀搀猀 眀漀爀欀 攀瘀攀渀 戀攀琀琀攀爀 琀栀愀渀 琀栀攀 攀焀甀椀瘀愀氀攀渀琀 倀漀眀攀爀猀栀攀氀氀⸀㰀戀爀㸀ഀഀ But I haste me to say that PowerShell is much more "powerful" and has a much wider scope, compared to DOS.
    ਍㰀戀爀㸀ഀഀ ਍䤀昀 礀漀甀 氀漀漀欀 愀琀 琀栀攀 氀愀猀琀 瀀漀眀攀爀猀栀攀氀氀 攀砀愀洀瀀氀攀Ⰰ 愀渀搀 瀀甀琀 琀栀漀猀攀 ㌀ 氀椀渀攀猀 椀渀 愀 ∀⸀瀀猀㄀∀ 猀挀爀椀瀀琀昀椀氀攀Ⰰ 琀栀攀渀 椀琀 眀漀爀欀猀 昀漀爀 琀栀攀㰀戀爀㸀ഀഀ ReportJohn.txt and ReportMary.txt files, But that's quite ugly. It's much better to have a script
    ਍琀栀愀琀 甀猀攀猀 瀀愀爀愀洀攀琀攀爀猀 琀漀 戀攀 猀甀瀀瀀氀椀攀搀Ⰰ 猀漀 琀栀愀琀 礀漀甀 挀愀渀 爀攀ⴀ甀猀攀 椀琀 昀漀爀 漀琀栀攀爀 ⠀猀椀洀椀氀愀爀⤀ 昀椀氀攀猀 愀猀 眀攀氀氀⸀㰀戀爀㸀ഀഀ Do you know how to do that? Yes..., if you indeed have read this note, you do.
    ਍㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍㰀栀爀⼀㸀ഀഀ ਍㰀䈀㸀䔀砀愀洀瀀氀攀 㐀⸀㜀㨀 䌀愀氀氀椀渀最 愀 猀琀漀爀攀搀 瀀爀漀挀攀搀甀爀攀Ⰰ 漀爀 猀琀愀爀琀椀渀最 愀 匀儀䰀 䄀最攀渀琀 樀漀戀Ⰰ 昀爀漀洀 倀漀眀攀爀猀栀攀氀氀⸀ ⠀圀漀爀欀猀Ⰰ 戀甀琀 愀 戀椀琀 漀甀琀搀愀琀攀搀⤀⸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ ਍㰀栀爀⼀㸀ഀഀ
    ਍吀栀攀 昀漀氀氀漀眀椀渀最 猀栀漀眀猀 愀 瘀攀爀礀 猀椀洀瀀氀攀 攀砀愀洀瀀氀攀⸀ 夀漀甀 渀攀攀搀 琀漀 欀渀漀眀 眀栀椀挀栀 猀琀漀爀攀搀 瀀爀漀挀攀搀甀爀攀 礀漀甀 眀愀渀琀 琀漀 挀愀氀氀Ⰰ㰀戀爀㸀ഀഀ or which SQL Server Agent job you want to start, and ofcourse which database and Instance are involved.
    ਍㰀戀爀㸀ഀഀ Example:
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ $instancename="MySQLServer"
    ਍␀搀戀㴀∀䴀礀䐀愀琀愀䈀猀攀∀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ $sqlConnection = new-object System.Data.SqlClient.SqlConnection
    ਍␀猀焀氀䌀漀渀渀攀挀琀椀漀渀⸀䌀漀渀渀攀挀琀椀漀渀匀琀爀椀渀最 㴀 ✀猀攀爀瘀攀爀㴀✀ ⬀ ␀椀渀猀琀愀渀挀攀渀愀洀攀 ⬀ ✀㬀椀渀琀攀最爀愀琀攀搀 猀攀挀甀爀椀琀礀㴀吀刀唀䔀㬀搀愀琀愀戀愀猀攀㴀✀ ⬀ ␀搀戀 㰀戀爀㸀ഀഀ $sqlConnection.Open()
    ਍␀猀焀氀䌀漀洀洀愀渀搀 㴀 渀攀眀ⴀ漀戀樀攀挀琀 匀礀猀琀攀洀⸀䐀愀琀愀⸀匀焀氀䌀氀椀攀渀琀⸀匀焀氀䌀漀洀洀愀渀搀 㰀戀爀㸀ഀഀ $sqlCommand.CommandTimeout = 120
    ਍␀猀焀氀䌀漀洀洀愀渀搀⸀䌀漀渀渀攀挀琀椀漀渀 㴀 ␀猀焀氀䌀漀渀渀攀挀琀椀漀渀 㰀戀爀㸀ഀഀ $sqlCommand.CommandText= "exec msdb.dbo.sp_start_job 'My SQL Agent job'"
    ਍圀爀椀琀攀ⴀ䠀漀猀琀 ∀䔀砀攀挀甀琀椀渀最 琀栀攀 樀漀戀⸀⸀⸀∀ 㰀戀爀㸀ഀഀ $result = $sqlCommand.ExecuteNonQuery()
    ਍␀猀焀氀䌀漀渀渀攀挀琀椀漀渀⸀䌀氀漀猀攀⠀⤀ 㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䤀渀 琀栀攀 攀砀愀洀瀀氀攀 戀攀氀漀眀 眀攀 甀猀攀 愀 挀愀氀氀 琀漀 愀 猀琀漀爀攀搀 瀀爀漀挀攀搀甀爀攀 昀爀漀洀 倀漀眀攀爀猀栀攀氀氀⸀㰀戀爀㸀ഀഀ Here we call the stored procedure "msdb.dbo.performancevlpi , which performs some stuff,
    ਍戀甀琀 愀氀猀漀 爀攀琀甀爀渀椀渀最 愀 瘀愀爀椀愀戀氀攀 眀栀椀挀栀 挀漀渀琀愀椀渀猀 琀栀攀 攀渀搀 猀琀愀琀甀猀 漀昀 琀栀攀 瀀攀爀昀漀爀洀攀搀 眀漀爀欀⸀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ ਍ഀഀ $Logfile = "\\fileshare\dfs\jobs\albert.log"
    ਍␀椀渀猀琀愀渀挀攀渀愀洀攀㴀∀匀嘀刀匀儀䰀　㔀∀㰀戀爀㸀ഀഀ $db="DataMart"
    ਍␀洀礀漀甀琀瀀甀琀㴀∀∀㰀戀爀㸀ഀഀ
    ਍ഀഀ Write-Host "Job is running. Please do not close this window"
    ਍␀猀焀氀䌀漀渀渀攀挀琀椀漀渀 㴀 渀攀眀ⴀ漀戀樀攀挀琀 匀礀猀琀攀洀⸀䐀愀琀愀⸀匀焀氀䌀氀椀攀渀琀⸀匀焀氀䌀漀渀渀攀挀琀椀漀渀 㰀戀爀㸀ഀഀ $sqlConnection.ConnectionString = 'server=' + $instancename + ';integrated security=TRUE;database=' + $db
    ਍␀猀焀氀䌀漀渀渀攀挀琀椀漀渀⸀伀瀀攀渀⠀⤀ 㰀戀爀㸀ഀഀ $sqlCommand = new-object System.Data.SqlClient.SqlCommand
    ਍␀猀焀氀䌀漀洀洀愀渀搀⸀䌀漀洀洀愀渀搀吀椀洀攀漀甀琀 㴀 ㌀㘀　　 㰀戀爀㸀ഀഀ $SqlCommand.CommandText = "msdb.dbo.performancevlpi"
    ਍␀匀焀氀䌀漀洀洀愀渀搀⸀䌀漀渀渀攀挀琀椀漀渀 㴀 ␀匀焀氀䌀漀渀渀攀挀琀椀漀渀㰀戀爀㸀ഀഀ $SqlCommand.CommandType = [System.Data.CommandType]'StoredProcedure';
    ਍␀漀甀琀倀愀爀愀洀攀琀攀爀 㴀 渀攀眀ⴀ漀戀樀攀挀琀 匀礀猀琀攀洀⸀䐀愀琀愀⸀匀焀氀䌀氀椀攀渀琀⸀匀焀氀倀愀爀愀洀攀琀攀爀㬀㰀戀爀㸀ഀഀ $outParameter.ParameterName = "@answer";
    ਍␀漀甀琀倀愀爀愀洀攀琀攀爀⸀䐀椀爀攀挀琀椀漀渀 㴀 嬀匀礀猀琀攀洀⸀䐀愀琀愀⸀倀愀爀愀洀攀琀攀爀䐀椀爀攀挀琀椀漀渀崀✀伀甀琀瀀甀琀✀㬀㰀戀爀㸀ഀഀ $outParameter.DbType = [System.Data.DbType]'String';
    ਍␀漀甀琀倀愀爀愀洀攀琀攀爀⸀匀椀稀攀 㴀 ㈀㔀　　㬀㰀戀爀㸀ഀഀ $SqlCommand.Parameters.Add($outParameter) >> $null;
    ਍㰀戀爀㸀ഀഀ $result = $SqlCommand.ExecuteNonQuery();
    ਍␀洀礀漀甀琀瀀甀琀 㴀 ␀匀焀氀䌀漀洀洀愀渀搀⸀倀愀爀愀洀攀琀攀爀猀嬀∀䀀愀渀猀眀攀爀∀崀⸀嘀愀氀甀攀㬀㰀戀爀㸀ഀഀ $myoutput;
    ਍␀匀焀氀䌀漀渀渀攀挀琀椀漀渀⸀䌀氀漀猀攀⠀⤀㬀㰀戀爀㸀ഀഀ
    ਍ഀഀ If ($myoutput -eq 1)
    ਍ 笀 㰀戀爀㸀ഀഀ Write-Output "The job completed succesfully" | Out-File $logfile
    ਍ 紀 㰀戀爀㸀ഀഀ else
    ਍ 笀 㰀戀爀㸀ഀഀ Write-Output "The job failed" | Out-File $logfile
    ਍ 紀 㰀戀爀㸀ഀഀ ਍ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ Example 4.8: Finding the most recent file in some folder.
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ Example 1:
    ਍㰀戀爀㸀ഀഀ $dir = "c:\test"
    ਍␀氀愀琀攀猀琀 㴀 䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀 ⴀ倀愀琀栀 ␀搀椀爀 簀 匀漀爀琀ⴀ伀戀樀攀挀琀 䰀愀猀琀䄀挀挀攀猀猀吀椀洀攀 ⴀ䐀攀猀挀攀渀搀椀渀最 簀 匀攀氀攀挀琀ⴀ伀戀樀攀挀琀 ⴀ䘀椀爀猀琀 ㄀㰀戀爀㸀ഀഀ $latest.name
    ਍㰀戀爀㸀ഀഀ Example 2:
    ਍㰀戀爀㸀ഀഀ $f = Dir | Sort CreationTime -Descending | Select Name -First 1
    ਍␀昀⸀渀愀洀攀㰀戀爀㸀ഀഀ
    ਍䔀砀愀洀瀀氀攀 䤀渀 䐀伀匀 ⠀挀洀搀⤀㨀㰀戀爀㸀ഀഀ
    ਍匀甀瀀瀀漀猀攀 眀攀 愀爀攀 甀猀椀渀最 搀㨀尀琀攀猀琀㨀㰀戀爀㸀ഀഀ
    ਍䘀伀刀 ⼀䘀 ∀搀攀氀椀洀猀㴀簀∀ ──䤀 䤀一 ⠀✀䐀䤀刀 ∀搀㨀尀琀攀猀琀尀⨀⸀⨀∀ ⼀䈀 ⼀伀㨀䐀✀⤀ 䐀伀 匀䔀吀 一攀眀攀猀琀䘀椀氀攀㴀──䤀㰀戀爀㸀ഀഀ echo %NewestFile%
    ਍㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍㰀栀爀⼀㸀ഀഀ ਍㰀䈀㸀㐀⸀㤀㨀 刀攀渀愀洀攀 昀椀氀攀⠀猀⤀⸀㰀⼀䈀㸀㰀戀爀㸀ഀഀ ਍㰀栀爀⼀㸀ഀഀ
    ਍ഀഀ Example 1:
    ਍㰀戀爀㸀ഀഀ $datetime = get-date -f MMddyy-hhmmtt
    ਍爀攀渀愀洀攀ⴀ椀琀攀洀 搀㨀尀琀攀猀琀尀搀愀椀氀礀⸀戀愀欀 ⴀ渀攀眀渀愀洀攀 ⠀␀搀愀琀攀琀椀洀攀 ⬀ ∀⸀戀愀欀∀⤀㰀戀爀㸀ഀഀ
    ਍䔀砀愀洀瀀氀攀 ㈀㨀㰀戀爀㸀ഀഀ
    ਍䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀 ⴀ䘀椀氀琀攀爀 ᰀ⨠⸀戀愀欀ᴀ†ⴀ刀攀挀甀爀猀攀 簀 刀攀渀愀洀攀ⴀ䤀琀攀洀 ⴀ一攀眀一愀洀攀 笀␀开⸀渀愀洀攀 ⴀ爀攀瀀氀愀挀攀 ✀⸀戀愀欀✀Ⰰ✀⸀愀爀挀栀椀瘀攀✀ 紀㰀戀爀㸀ഀഀ
    ਍䜀攀琀ⴀ䌀栀椀氀搀䤀琀攀洀 ⨀⸀搀洀瀀 簀 刀攀渀愀洀攀ⴀ䤀琀攀洀 ⴀ一攀眀一愀洀攀 笀 ␀开⸀一愀洀攀 ⴀ爀攀瀀氀愀挀攀 ✀⸀搀洀瀀✀Ⰰ✀⸀戀愀欀✀ 紀㰀戀爀㸀ഀഀ
    ਍䔀砀愀洀瀀氀攀 䤀渀 䐀伀匀 ⠀挀洀搀⤀㨀㰀戀爀㸀ഀഀ
    ਍爀攀渀 ⨀⸀搀漀挀 ⨀⸀愀爀挀栀椀瘀攀㰀戀爀㸀ഀഀ ren a.txt b.txt
    ਍爀攀渀 昀㨀尀搀愀琀愀尀猀愀氀攀猀⸀砀氀猀 猀愀氀攀猀开㈀　㄀㔀⸀砀氀猀  ⠀漀爀 戀攀琀琀攀爀㨀 挀漀瀀礀 昀㨀尀搀愀琀愀尀猀愀氀攀猀⸀砀氀猀 最㨀尀戀愀挀欀甀瀀猀尀猀愀氀攀猀开㈀　㄀㔀⸀砀氀猀⤀ 㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀爀漀眀渀∀㸀ഀഀ 4.10: "Tail" or Show, the end of large txt files (like large logfiles)..
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍䤀渀 甀渀椀砀⼀氀椀渀甀砀Ⰰ 椀琀✀猀 攀愀猀礀 琀漀 猀攀攀 琀栀攀 氀愀猀琀 氀椀渀攀猀 漀昀 猀漀洀攀 琀砀琀 昀椀氀攀 ⠀氀椀欀攀 愀 氀漀最昀椀氀攀⤀⸀ 匀椀洀瀀氀礀 甀猀攀 琀栀攀 琀愀椀氀 挀漀洀洀愀渀搀Ⰰ 氀椀欀攀㨀㰀戀爀㸀ഀഀ
    ਍␀ 琀愀椀氀 ⴀ㔀　 愀氀攀爀琀⸀氀漀最㰀戀爀㸀ഀഀ
    ਍眀栀椀挀栀 猀栀漀眀猀 礀漀甀 琀栀攀 氀愀猀琀 㔀　 氀椀渀攀猀 漀昀 琀栀愀琀 氀漀最昀椀氀攀⸀ 夀漀甀 挀愀渀 甀猀攀 愀渀礀 渀甀洀戀攀爀Ⰰ 氀椀欀攀 㔀　Ⰰ ㄀㈀　Ⰰ ㈀　　 攀琀挀⸀⸀㰀戀爀㸀ഀഀ
    ਍䤀渀 倀漀眀攀爀猀栀攀氀氀 眀攀 栀愀瘀攀 愀 猀椀洀椀氀愀爀 挀漀洀洀愀渀搀氀攀琀⸀ 唀猀攀 ∀䜀攀琀ⴀ䌀漀渀琀攀渀琀∀ 眀椀琀栀 琀栀攀 ∀ⴀ琀愀椀氀∀ 漀瀀琀椀漀渀⸀㰀戀爀㸀ഀഀ
    ਍䔀砀愀洀瀀氀攀㨀㰀戀爀㸀ഀഀ
    ਍倀匀 䌀㨀尀䰀伀䜀匀㸀 最攀琀ⴀ挀漀渀琀攀渀琀 ⴀ琀愀椀氀 ㄀　　 ✀⸀尀眀攀戀⸀氀漀最✀㰀戀爀㸀ഀഀ
    ਍䠀攀爀攀Ⰰ 琀栀攀 ∀⸀尀∀ 洀攀愀渀猀 琀栀愀琀 琀栀攀 䌀漀洀洀愀渀搀䰀攀琀 洀甀猀琀 甀猀攀 琀栀攀 挀甀爀爀攀渀琀 搀椀爀攀挀琀漀爀礀⸀㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍㰀栀㈀㸀䌀栀愀瀀琀攀爀 㔀⸀ 倀漀眀攀爀猀栀攀氀氀 愀渀搀 匀儀䰀 匀攀爀瘀攀爀⸀㰀⼀栀㈀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    5.1 Powershell versions

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍ഀഀ ਍䤀琀 猀攀攀洀猀 琀栀愀琀 攀瘀攀爀礀 渀攀眀 圀椀渀搀漀眀猀 瘀攀爀猀椀漀渀Ⰰ 挀漀洀攀猀 眀椀琀栀 愀 渀攀眀 倀漀眀攀爀猀栀攀氀氀 瘀攀爀猀椀漀渀⸀ 䄀氀猀漀Ⰰ 椀渀 戀攀琀眀攀攀渀Ⰰ 猀漀洀攀琀椀洀攀猀 ∀椀渀琀攀爀昀愀挀攀猀∀㰀戀爀㸀ഀഀ to applications, and the OS, may be "upgraded" too. Backward compatibility of new versions to older scripts is very high,
    ਍愀氀琀栀漀甀最栀 椀渀 猀漀洀攀 挀愀猀攀猀 礀漀甀 洀甀猀琀 椀渀搀攀攀搀 挀栀漀漀猀攀 琀漀 甀猀攀 愀 渀攀眀攀爀 椀渀琀攀爀昀愀挀攀⸀㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍㰀戀爀㸀ഀഀ For about Windows versions, the following crude overview holds:
    ਍㰀戀爀㸀ഀഀ ਍嘀攀爀猀椀漀渀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀⸀䴀漀猀琀 瀀爀漀洀椀渀攀渀琀 伀匀Ⰰ 椀渀 眀栀椀挀栀 椀琀 眀愀猀 昀椀爀猀琀 椀洀瀀氀攀洀攀渀琀攀搀㰀戀爀㸀ഀഀ PowerShell 1.0.... Windows Server 2008, and Later XP versions (XP2)
    ਍倀漀眀攀爀匀栀攀氀氀 ㈀⸀　⸀⸀⸀⸀ 圀椀渀搀漀眀猀 匀攀爀瘀攀爀 ㈀　　㠀 愀渀搀 刀㈀Ⰰ 圀椀渀㜀㰀戀爀㸀ഀഀ PowerShell 3.0.... Windows Server 2012, Win8, Win7 SP1
    ਍倀漀眀攀爀匀栀攀氀氀 㐀⸀　⸀⸀⸀⸀ 圀椀渀搀漀眀猀 匀攀爀瘀攀爀 ㈀　㄀㈀ 刀㈀Ⰰ 圀椀渀㜀Ⰰ 圀椀渀㠀⸀㄀㰀戀爀㸀ഀഀ PowerShell 5.0.... Windows Server 2016, Win10
    ਍倀漀眀攀爀匀栀攀氀氀 㔀⸀㄀⸀⸀⸀⸀ 圀椀渀搀漀眀猀 匀攀爀瘀攀爀 ㈀　㄀㘀Ⰰ 圀椀渀㄀　 氀愀琀攀猀琀 戀甀椀氀搀㰀戀爀㸀ഀഀ PowerShell 6.0.... comes available Win/Linux
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ
    ਍䤀昀 礀漀甀 氀漀漀欀 愀琀 昀椀最甀爀攀 ㄀ 愀戀漀瘀攀Ⰰ 礀漀甀 猀攀攀 琀栀愀琀 倀漀眀攀爀猀栀攀氀氀 椀琀猀攀氀昀 爀甀渀猀 漀渀 ⸀一攀琀Ⰰ 愀渀搀 栀愀猀㰀戀爀㸀ഀഀ a strong dependency on "WMI", that is Windows Management Instrumentation.
    ਍吀栀爀漀甀最栀 圀䴀䤀Ⰰ 倀漀眀攀爀猀栀攀氀氀 愀挀挀攀猀猀攀猀 漀戀樀攀挀琀猀 漀昀 琀栀攀 伀匀 愀渀搀 爀攀最椀猀琀攀爀攀搀 搀攀瘀椀挀攀猀⸀㰀戀爀㸀ഀഀ
    ਍䘀漀爀 攀砀愀洀瀀氀攀Ⰰ 愀氀琀栀漀甀最栀  倀漀眀攀爀匀栀攀氀氀 㔀 愀渀搀 圀䴀䤀 㔀 愀爀攀 渀漀琀 攀焀甀椀瘀愀氀攀渀琀Ⰰ 椀琀 椀猀 琀爀甀攀 琀栀愀琀 愀 洀漀爀攀 洀漀搀攀爀渀㰀戀爀㸀ഀഀ Powershell, like Powershell v5, needs a certain revision of WMI too. It means also that you can use for example,
    ਍倀漀眀攀爀猀栀攀氀氀 瘀㔀 漀渀 圀椀渀㜀Ⰰ 戀甀琀 琀栀攀渀 礀漀甀 渀攀攀搀 甀瀀搀愀琀攀猀 漀渀 圀䴀䤀 愀渀搀 ⸀一攀琀 琀漀漀⸀㰀戀爀㸀ഀഀ
    ਍夀漀甀 挀愀渀 挀栀攀挀欀 礀漀甀爀 瘀攀爀猀椀漀渀 甀猀椀渀最㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ PS C:\TEMP> $PSVersionTable.PSVersion
    ਍㰀戀爀㸀ഀഀ returns compact information on builds
    ਍㰀戀爀㸀ഀഀ PS C:\TEMP> get-host
    ਍㰀戀爀㸀ഀഀ returns information general version and language (culture).
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ If the variable $PSVersionTable.PSVersion is not available, you have v1/v2, and you may check that with "get-version".
    ਍㰀戀爀㸀ഀഀ As of SQL Server 2008, "direct" interfacing from Powershell to SQL Server, was possible, using
    ਍琀栀攀 猀焀氀瀀猀⸀攀砀攀 ∀眀爀愀瀀瀀攀爀∀Ⰰ 眀栀椀挀栀 猀琀愀爀琀猀 倀漀眀攀爀猀栀攀氀氀Ⰰ 㰀䤀㸀眀椀琀栀 琀栀攀 倀漀眀攀爀匀栀攀氀氀 猀渀愀瀀ⴀ椀渀猀 琀漀 最攀琀 氀漀愀搀攀搀 愀渀搀 爀攀最椀猀琀攀爀攀搀⸀㰀⼀䤀㸀㰀戀爀㸀ഀഀ From that point, you could for example use the "Invoke-Sqlcmd" CmdLet.
    ਍㰀戀爀㸀ഀഀ At later SQL Server versions, as of 2012, the "sqlps" module could be loaded, enabling a larger set
    ਍漀昀 䌀洀搀䰀攀琀✀猀⸀ 䄀猀 漀昀 匀儀䰀 ㈀　㄀㘀Ⰰ 琀栀椀猀 洀漀搀甀氀攀 眀愀猀 攀渀栀愀渀挀攀搀 愀渀搀 爀攀渀愀洀攀搀 琀漀 ∀匀焀氀匀攀爀瘀攀爀∀⸀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ ਍㰀栀㌀㸀㔀⸀㈀ 倀漀眀攀爀猀栀攀氀氀 椀渀琀攀爀昀愀挀攀猀 琀漀 匀儀䰀 匀攀爀瘀攀爀⸀㰀⼀栀㌀㸀ഀഀ ਍ഀഀ

    ADO.NET:

    ਍ഀഀ Since .Net became popular, ADO.NET is a "basic database API" to access a variety of RDBM'ses, like Oracle and SQL.
    ਍吀栀攀 渀愀洀攀猀瀀愀挀攀 ⠀瀀爀漀瘀椀搀攀爀⤀ ∀匀礀猀琀攀洀⸀䐀愀琀愀⸀匀焀氀䌀氀椀攀渀琀∀Ⰰ 椀猀 眀攀氀氀 欀渀漀眀渀 戀礀 ⸀一䔀吀 搀攀瘀攀氀漀瀀攀爀猀⸀㰀戀爀㸀ഀഀ So, for the older SQL Server 2008 version, for example, it was quite common to develop web apps, or C#, or VB .NET apps,
    ਍甀猀椀渀最 䄀䐀伀⸀一䔀吀 琀漀 愀挀挀攀猀猀 搀愀琀愀戀愀猀攀猀⸀㰀戀爀㸀ഀഀ
    ਍䄀䐀伀⸀一䔀吀 挀愀渀 戀攀 甀猀攀搀 戀礀 瘀愀爀椀漀甀猀 搀攀瘀攀氀漀瀀洀攀渀琀 瀀氀愀琀昀漀爀洀猀Ⰰ 愀渀搀 戀礀 倀漀眀攀爀猀栀攀氀氀 琀漀漀Ⰰ 氀椀欀攀 昀漀爀 攀砀愀洀瀀氀攀 椀渀 琀栀攀 戀愀猀椀挀 挀漀搀攀 戀攀氀漀眀㨀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀挀漀甀爀椀攀爀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ ਍␀猀挀漀渀 㴀 一攀眀ⴀ伀戀樀攀挀琀 匀礀猀琀攀洀⸀䐀愀琀愀⸀匀焀氀䌀氀椀攀渀琀⸀匀焀氀䌀漀渀渀攀挀琀椀漀渀㰀戀爀㸀ഀഀ $scon.ConnectionString = "Data Source=SQL01\SQLINST1;Initial Catalog=sales;Connection Timeout=0;Integrated Security=true"
    ਍␀挀洀搀 㴀 一攀眀ⴀ伀戀樀攀挀琀 匀礀猀琀攀洀⸀䐀愀琀愀⸀匀焀氀䌀氀椀攀渀琀⸀匀焀氀䌀漀洀洀愀渀搀㰀戀爀㸀ഀഀ $cmd.Connection = $scon
    ਍␀挀洀搀⸀䌀漀洀洀愀渀搀吀攀砀琀 㴀 ∀匀䔀䰀䔀䌀吀 ⨀ 䘀刀伀䴀 挀甀猀琀漀洀攀爀猀∀㰀戀爀㸀ഀഀ $cmd.CommandTimeout = 0
    ਍㰀戀爀㸀ഀഀ ਍䈀愀猀椀挀愀氀氀礀Ⰰ 攀砀愀洀瀀氀攀 㐀⸀㜀 愀戀漀瘀攀Ⰰ 甀猀攀猀 䄀䐀伀⸀一䔀吀 琀漀漀⸀㰀戀爀㸀ഀഀ The method can be used by modern apps and modern SQL versions too. But Powershell has evolved a bit,
    ਍猀漀 漀琀栀攀爀 洀攀琀栀漀搀猀 昀漀爀 愀挀挀攀猀猀 琀漀 搀愀琀愀戀愀猀攀猀Ⰰ 甀猀椀渀最 爀愀琀栀攀爀 猀椀洀瀀氀攀 䌀洀搀䰀攀琀✀猀Ⰰ 椀猀 瀀漀猀猀椀戀氀攀 琀漀漀⸀㰀戀爀㸀ഀഀ ਍㰀栀㌀㸀吀栀攀 漀氀搀攀爀 匀儀䰀倀匀 愀渀搀 渀攀眀攀爀 匀焀氀匀攀爀瘀攀爀 洀漀搀甀氀攀猀㨀㰀⼀栀㌀㸀ഀഀ ਍圀椀琀栀 氀愀琀攀爀 匀儀䰀 匀攀爀瘀攀爀 瘀攀爀猀椀漀渀猀Ⰰ 甀猀椀渀最 琀栀攀 最爀愀瀀栀椀挀愀氀 䴀愀渀愀最攀洀攀渀琀 匀琀甀搀椀漀Ⰰ 礀漀甀 挀愀渀 愀挀琀椀瘀愀琀攀 倀漀眀攀爀猀栀攀氀氀Ⰰ㰀戀爀㸀ഀഀ or actually "sqlps".
    ਍吀栀椀猀 洀漀搀甀氀攀 洀愀欀攀猀 椀琀 瀀漀猀猀椀戀氀攀 琀漀 洀愀渀愀最攀 匀儀䰀 匀攀爀瘀攀爀 漀戀樀攀挀琀猀 昀爀漀洀 倀漀眀攀爀猀栀攀氀氀Ⰰ 愀渀搀 ∀琀爀愀瘀攀爀猀攀∀ 琀栀攀 匀儀䰀 匀攀爀瘀攀爀 栀椀攀爀愀爀挀栀礀㰀戀爀㸀ഀഀ of objects, just like a "filesystem" (using cd, ls etc..).
    ਍㰀戀爀㸀ഀഀ From the powershell "shell" itself, you can load the module too. Then use:
    ਍㰀戀爀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀䴀倀㸀 䤀洀瀀漀爀琀ⴀ䴀漀搀甀氀攀 ⴀ一愀洀攀 猀焀氀瀀猀 ⴀ䐀椀猀愀戀氀攀一愀洀攀䌀栀攀挀欀椀渀最㰀戀爀㸀ഀഀ ਍㰀戀爀㸀 ഀഀ Apart from the feature that you can "walk" or "traverse" the SQL Server hierarchy, it also
    ਍洀愀欀攀猀 愀 爀愀渀最攀 漀昀 匀儀䰀猀攀爀瘀攀爀 䌀洀搀䰀攀琀✀猀 愀瘀愀椀氀愀戀氀攀Ⰰ 氀椀欀攀 ∀䈀愀挀欀甀瀀ⴀ匀焀氀଀䐠愀琀愀戀愀猀攀∀Ⰰ ∀刀攀猀琀漀爀攀ⴀ匀焀氀଀䐠愀琀愀戀愀猀攀∀ 愀渀搀 洀愀渀礀 洀漀爀攀⸀㰀戀爀㸀ഀഀ
    ਍匀儀䰀倀匀 甀猀攀猀 琀栀攀 ∀匀儀䰀 匀攀爀瘀攀爀 䴀愀渀愀最攀洀攀渀琀 伀戀樀攀挀琀∀ 椀渀琀攀爀昀愀挀攀Ⰰ 漀爀 ∀匀䴀伀∀⸀㰀戀爀㸀ഀഀ
    ਍吀栀攀爀攀 愀爀攀 愀挀琀甀愀氀氀礀 琀眀漀 匀儀䰀 匀攀爀瘀攀爀 倀漀眀攀爀匀栀攀氀氀 洀漀搀甀氀攀猀Ⰰ 渀愀洀攀氀礀 ∀匀焀氀匀攀爀瘀攀爀∀ ⠀渀攀眀攀爀⤀ 愀渀搀 ∀匀儀䰀倀匀∀ ⠀漀氀搀攀爀⤀⸀㰀戀爀㸀ഀഀ The SQLPS module is/was included with the SQL Server installation, but is nowadays regarded
    ਍愀猀 ∀琀栀攀 昀漀爀洀攀爀 洀漀搀甀氀攀∀⸀ 吀栀攀 洀漀猀琀 甀瀀ⴀ琀漀ⴀ搀愀琀攀 倀漀眀攀爀匀栀攀氀氀 洀漀搀甀氀攀 琀漀搀愀礀 椀猀 琀栀攀 ∀匀焀氀匀攀爀瘀攀爀∀ 洀漀搀甀氀攀⸀㰀戀爀㸀ഀഀ However, for the "SqlServer" installable module, Powershell v5 seems to be a requirement.
    ਍ഀഀ
    ਍圀椀琀栀 匀儀䰀 ㈀　㄀㘀Ⰰ 琀栀攀 ∀匀焀氀匀攀爀瘀攀爀∀ 洀漀搀甀氀攀 猀攀攀洀猀 琀漀 戀攀 愀甀琀漀洀愀琀椀挀愀氀氀礀 椀渀猀琀愀氀氀攀搀 眀椀琀栀 琀栀攀 猀攀瀀攀爀愀琀攀 匀匀䴀匀 ⠀䴀愀渀愀最攀洀攀渀琀 匀琀甀搀椀漀⤀ 椀渀猀琀愀氀氀愀琀椀漀渀⸀㰀戀爀㸀ഀഀ In most cases, it seems to reside in "%Program Files\WindowsPowerShell\Modules\SqlServer".
    ਍㰀戀爀㸀ഀഀ In that case simply give the command:
    ਍㰀戀爀㸀ഀഀ ਍倀匀 䌀㨀尀吀䔀䴀倀㸀 䤀洀瀀漀爀琀ⴀ䴀漀搀甀氀攀 ⴀ一愀洀攀 匀焀氀匀攀爀瘀攀爀㰀戀爀㸀ഀഀ ਍ഀഀ
    ਍ഀഀ ਍㰀栀㌀㸀㔀⸀㌀ 倀漀眀攀爀猀栀攀氀氀 䄀爀挀栀椀琀攀挀琀甀爀攀 眀椀琀栀 䄀倀䤀✀猀 ⸀㰀⼀栀㌀㸀ഀഀ ਍ഀഀ Below you see a Jip-Janneke figure, trying to illustrate how powershell might access
    ਍漀琀栀攀爀 瀀愀爀琀猀 漀昀 琀栀攀 猀礀猀琀攀洀 ⠀氀椀欀攀 琀栀攀 伀匀Ⰰ 䄀瀀瀀氀椀挀愀琀椀漀渀猀Ⰰ 匀儀䰀 匀攀爀瘀攀爀 攀琀挀⸀⸀⤀⸀㰀戀爀㸀ഀഀ The first sub-figure, is the same as figure 1, above. The second sub-figure, tries to show
    ਍琀栀攀 搀椀昀昀攀爀攀渀琀 䄀倀䤀✀猀 琀漀 挀漀渀渀攀挀琀 琀漀 匀儀䰀 匀攀爀瘀攀爀⸀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ Fig 2. Simplified architecture Powershell.
    ਍㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍䈀漀琀栀 昀椀最甀爀攀猀 愀爀攀 猀椀洀瀀氀礀 愀 瘀攀爀礀 栀椀最栀ⴀ氀攀瘀攀氀 漀瘀攀爀瘀椀攀眀⸀ 䘀漀爀 攀砀愀洀瀀氀攀Ⰰ 琀栀攀 搀攀琀愀椀氀猀 漀昀 ∀圀䴀䤀∀ 愀爀攀 渀漀琀 猀栀漀眀渀⸀㰀戀爀㸀ഀഀ
    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀甀攀∀㸀ഀഀ

    5.4 SQL CmdLet's .

    ਍㰀昀漀渀琀 昀愀挀攀㴀∀愀爀椀愀氀∀ 猀椀稀攀㴀㈀ 挀漀氀漀爀㴀∀戀氀愀挀欀∀㸀ഀഀ ਍䤀昀 礀漀甀 栀愀瘀攀 椀洀瀀漀爀琀攀搀 ∀猀焀氀瀀猀∀ 漀爀 ∀匀焀氀匀攀爀瘀攀爀∀ 洀漀搀甀氀攀猀Ⰰ 愀猀 猀栀漀眀渀 愀戀漀瘀攀Ⰰ 愀 爀愀渀最攀 漀昀 匀儀䰀 匀攀爀瘀攀爀 猀瀀攀挀椀昀椀挀㰀戀爀㸀ഀഀ CmdLet's are available.
    ਍㰀戀爀㸀ഀഀ Example:
    ਍㰀戀爀㸀ഀഀ ਍倀匀 匀儀䰀匀䔀刀嘀䔀刀㨀尀匀儀䰀尀䌀漀洀瀀甀琀攀爀尀䤀渀猀琀愀渀挀攀㸀 䈀愀挀欀甀瀀ⴀ匀焀氀䐀愀琀愀戀愀猀攀 ⴀ䐀愀琀愀戀愀猀攀 ∀匀䄀䰀䔀匀∀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ To see all installed CmdLet's, try:
    ਍㰀戀爀㸀ഀഀ ਍倀匀 匀儀䰀匀䔀刀嘀䔀刀㨀尀匀儀䰀尀䌀漀洀瀀甀琀攀爀尀䤀渀猀琀愀渀挀攀㸀 最攀琀ⴀ挀漀洀洀愀渀搀 ⴀ洀漀搀甀氀攀 匀儀䰀匀䔀刀嘀䔀刀㰀戀爀㸀ഀഀ ਍㰀戀爀㸀ഀഀ An overview of all CmdLet's from the imported "SqlServer" module, can be found in this Microsoft page:
    ਍㰀戀爀㸀ഀഀ SQL Server PowerShell cmdlets
    ਍ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ

    That's it. Hope you liked it !

    ਍㰀戀爀㸀ഀഀ
    ਍ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍ഀഀ ਍㰀戀爀㸀ഀഀ
    ਍㰀戀爀㸀ഀഀ ਍㰀⼀戀漀搀礀㸀ഀഀ