1/60
PowerShell dla początkujących
Slajd wprowadza słuchaczy w koncepcję nowoczesnego środowiska powłoki PowerShell oraz przedstawia plan dydaktyczny kursu.

Wprowadzenie do kursu PowerShell

  • Rola w automatyzacji: zaawansowane narzędzie stworzone przez firmę Microsoft do zarządzania systemami operacyjnymi i chmurą.
  • Podejście obiektowe: przetwarzanie całych struktur obiektowych platformy .NET zamiast surowych strumieni tekstowych.
  • Adresaci technologii: narzędzie dedykowane dla administratorów systemów, inżynierów DevOps oraz programistów.
  • Zakres tematyczny kursu: od podstawowych poleceń i potoku, przez struktury danych i pętle, aż po funkcje i obsługę błędów.
PowerShell: nowoczesna, wieloplatformowa powłoka wiersza poleceń oraz obiektowy język skryptowy opracowany przez firmę Microsoft. Integruje się bezpośrednio ze środowiskiem uruchomieniowym .NET CLR, umożliwiając bezpośrednie zarządzanie procesami, rejestrem, usługami oraz zasobami chmurowymi.
  +-------------------------------------------------------+
  |              ŚRODOWISKO POWŁOKI POWERSHELL           |
  +-------------------------------------------------------+
         |                        |                     |
         v                        v                     v
  +--------------+         +--------------+      +--------------+
  | Konsola CLI  |         | Skrypty .ps1 |      | Moduły .psm1 |
  +--------------+         +--------------+      +--------------+
         \                       |                     /
          \                      v                    /
           +-----------------------------------------+
           |     Środowisko uruchomieniowe .NET      |
           +-----------------------------------------+
        
2/60
Co to jest PowerShell?
Slajd definiuje architekturę powłoki PowerShell oraz wyjaśnia fundamentalne różnice między podejściem tekstowym a obiektowym.

Definicja i architektura

  • Hybrydowy charakter: jednoczesne pełnienie roli interaktywnego wiersza poleceń terminala oraz zaawansowanego języka skryptowego.
  • Fundament platformy .NET: każde polecenie operuje na rzeczywistych obiektach reprezentujących zasoby systemowe.
  • Eliminacja parsowania tekstu: brak konieczności stosowania wyrażeń regularnych i filtrów tekstowych do wyciągania pojedynczych pól.
  • Zarządzanie konfiguracją: wbudowane mechanizmy automatyzacji konfiguracji maszyn fizycznych i wirtualnych.
Potok obiektowy (object pipeline): mechanizm komunikacji w PowerShellu przekazujący pomiędzy poleceniami całe obiekty z kompletem pól i metod w pamięci operacyjnej, w odróżnieniu od klasycznego potoku uniksowego przesyłającego wyłącznie płaski strumień znaków ASCII/UTF-8.
  +------------------+          +-------------------------+
  |  Cmdlet / Skrypt | -------> | Obiekty .NET CLR        |
  +------------------+          +-------------------------+
                                             |
                                    Potok obiektowy (|)
                                             v
  +------------------+          +-------------------------+
  | Następny Cmdlet  | <------- | Dostęp do metod i pól   |
  +------------------+          +-------------------------+
        
3/60
Dlaczego warto uczyć się PowerShell?
Slajd przedstawia kluczowe korzyści wynikające ze stosowania PowerShella w środowiskach IT.

Zalety PowerShell w inżynierii systemowej

  • Standaryzacja składni: intuicyjny system nazewnictwa Czasownik-Rzeczownik ułatwiający przewidywanie nazw poleceń.
  • Potężny ekosystem modułów: dostęp do setek tysięcy gotowych bibliotek w repozytorium PowerShell Gallery.
  • Automatyzacja chmury: oficjalne wsparcie dla platform Azure, AWS, Google Cloud oraz środowisk Microsoft 365.
  • Zwiększenie produktywności: skracanie wielogodzinnych procedur manualnych do kilkusekundowych, powtarzalnych skryptów.
Automatyzacja systemowa (system automation): wykorzystanie języka skryptowego do programowego konfigurowania, wdrażania, monitorowania i audytowania zasobów teleinformatycznych bez udziału manualnych czynności operatora, co minimalizuje ryzyko błędu ludzkiego.
  +-------------------------------------------------------+
  |                  GŁÓWNE ZALETY POWERSHELL             |
  +-------------------------------------------------------+
  | 1. Potok obiektowy: brak konieczności parsowania tekstu|
  | 2. Spójność: jednolita konwencja Czasownik-Rzeczownik |
  | 3. Pełny dostęp do klas i bibliotek platformy .NET    |
  | 4. Zdalne zarządzanie maszynami przez protokół WinRM  |
  +-------------------------------------------------------+
        
4/60
PowerShell a inne powłoki
Slajd zestawia kluczowe cechy architektoniczne powłok CMD, Bash oraz PowerShell, wskazując na różnice w modelach danych.

Porównanie technologii powłok

  • Wiersz poleceń CMD: historyczna powłoka tekstowa z ograniczoną składnią i brakiem natywnego wsparcia dla typów danych.
  • Powłoka GNU Bash: niezwykle wydajny uniksowy interpreter strumieni tekstowych, wymagający zewnętrznych filtrów formatujących.
  • Model PowerShell: pełne środowisko obiektowe przesyłające silnie typowane instancje klas środowiska .NET CLR.
  • Kryterium wyboru: CMD do zadań wstecznych, Bash do lekkich kontenerów Linux, PowerShell do zarządzania systemami i usługami.
Silne typowanie powłoki (strongly-typed shell): cecha architektury środowiska wykonawczego, w której każda zmienna, parametr i wynik polecenia posiada precyzyjnie określony typ danych w pamięci (np. liczba całkowita, data, obiekt procesu), co zapobiega błędom interpretacji reprezentacji znakowej.
  POWŁOKI TRADYCYJNE (Bash, CMD):
  [ Polecenie 1 ] ---> "Tekst wyjściowy (znaki)" ---> [ grep / awk ]
  
  POWŁOKA POWERSHELL:
  [ Cmdlet 1 ] ----> [ Obiekt .NET z polami ] -----> [ Where-Object ]
                         (Process, Service itp.)
        
5/60
Wersje PowerShell
Slajd omawia historię rozwoju PowerShella, rozróżnienie pomiędzy edycją Windows PowerShell 5.1 a wieloplatformowym PowerShell 7 Core.

Ewolucja środowiska: od 1.0 do PowerShell 7

  • Narodziny (2006 r.): PowerShell 1.0 wprowadzony dla systemów Windows Server jako opcjonalny składnik zarządzania.
  • Windows PowerShell 5.1: ostatnia wersja oparta na pełnym .NET Framework, wbudowana domyślnie w systemy Windows 10 i 11.
  • PowerShell Core 6.0: przełomowe przepisanie silnika na wieloplatformowy .NET Core i otwarcie kodu źródłowego na GitHubie.
  • PowerShell 7.x: nowoczesna edycja łącząca wieloplatformowość z maksymalną kompatybilnością wsteczną z modułami Windows.
Windows PowerShell vs PowerShell 7: rozróżnienie technologiczne pomiędzy edycją klasyczną (wersje 1.0-5.1 oparte na .NET Framework, dedykowane wyłącznie dla Windows) a edycją nowoczesną (wersje 6.x i 7.x oparte na .NET Core/.NET 8+, wieloplatformowe i stale rozwijane).
# Sprawdzenie wersji PowerShell
# Zmienna $PSVersionTable zawiera informacje o wersji
$PSVersionTable

# Lub krócej - wyświetla tylko numer wersji
$PSVersionTable.PSVersion
6/60
Instalacja PowerShell
Slajd przedstawia metody instalacji nowoczesnego PowerShella 7 w systemach Windows, Linux oraz macOS.

Dostępność na różnych platformach

  • Wbudowane środowisko Windows: wersja 5.1 jest natywnym składnikiem systemu Windows i nie wymaga instalacji wstępnej.
  • Menedżer pakietów winget: najprostsza instalacja PowerShell 7 w Windows: polecenie winget install --id Microsoft.Powershell.
  • Środowiska uniksowe (Linux): dostępność w repozytoriach dystrybucji APT, YUM, DNF oraz jako pakiet Snap (komenda pwsh).
  • System macOS: instalacja za pomocą popularnego menedżera Homebrew (polecenie brew install powershell).
Menedżer pakietów (package manager): oprogramowanie systemowe automatyzujące proces instalacji, aktualizacji, konfiguracji oraz usuwania pakietów aplikacji z centralnych repozytoriów oprogramowania.
  +-------------------------------------------------------+
  |           INSTALACJA I DOSTĘPNOŚĆ POWERSHELL          |
  +-------------------------------------------------------+
  | Windows:     Wbudowany Windows PowerShell 5.1         |
  |              PowerShell 7.x przez: winget install ... |
  | Linux:       Pakiety deb / rpm / snap (pwsh)          |
  | macOS:       Menedżer pakietów Homebrew: brew ...     |
  +-------------------------------------------------------+
        
7/60
Interfejs PowerShell
Slajd omawia aplikacje konsolowe oraz zintegrowane środowiska programistyczne wykorzystywane do pracy z PowerShellem.

Środowisko pracy i narzędzia edycyjne

  • Aplikacja Windows Terminal: nowoczesna, wielokartowa konsola z obsługą profili, akceleracji GPU i pełnego kodowania UTF-8.
  • Edytor Visual Studio Code: rekomendowane branżowe środowisko z oficjalnym rozszerzeniem PowerShell Extension.
  • Wbudowany edytor ISE: historyczne środowisko Windows PowerShell ISE, obecnie wycofane z rozwoju na rzecz VS Code.
  • Podpowiedzi IntelliSense: mechanizm automatycznego dopełniania poleceń, parametrów i ścieżek klawiszem Tab.
IntelliSense: inteligentny system analizy kodu w czasie rzeczywistym, podpowiadający dostępne cmdlety, nazwy parametrów, właściwości obiektów oraz wartości wyliczeniowe podczas wpisywania tekstu w konsoli lub edytorze kodu.
PS C:\Users\Student>
8/60
Twoje pierwsze polecenia
Slajd prezentuje pierwsze praktyczne polecenia w PowerShellu, zapoznając słuchacza z formatem wyników i inspekcją środowiska.

Podstawowe cmdlety diagnostyczne

  • Pobieranie czasu (Get-Date): zwraca bieżącą datę i godzinę jako precyzyjny obiekt typu System.DateTime.
  • Wersja środowiska ($PSVersionTable): wbudowana zmienna tabelaryczna wyświetlająca dokładny numer wersji powłoki i silnika .NET.
  • Czyszczenie ekranu (Clear-Host): czyści bufor widoku konsoli (funkcjonalny odpowiednik polecenia cls).
  • Zatrzymanie procesu (Exit): zamyka bieżącą sesję terminala i zwalnia przydzielone zasoby pamięci.
Zmienna automatyczna $PSVersionTable: wbudowana, tylko do odczytu zmienna tabelaryczna (Hashtable) w środowisku PowerShell, przechowująca szczegółowe informacje o wersji silnika powłoki (PSVersion), edycji (PSEdition) oraz powiązanych bibliotekach .NET CLR.
# Wyświetlenie tekstu
# Write-Host wyświetla tekst na ekranie
Write-Host "Witaj w PowerShell!"

# Wyświetlenie aktualnej daty
# Get-Date zwraca bieżącą datę i godzinę
Get-Date

# Wyświetlenie nazwy komputera
# Zmienna $env:COMPUTERNAME pobiera nazwę komputera z systemu
$env:COMPUTERNAME

# Lista uruchomionych procesów (pierwsze 5)
# Get-Process pobiera listę procesów, Select-Object wybiera 5 pierwszych
Get-Process | Select-Object -First 5

# Sprawdzenie wersji PowerShell
# Wyświetla wersję PowerShell, np. 5.1.22621.1
$PSVersionTable.PSVersion
9/60
Cmdlet: serce PowerShell
Slajd wyjaśnia budowę i zasadę działania cmdletów oraz standaryzację nazewnictwa Verb-Noun ustaloną przez firmę Microsoft.

Konwencja nazewnicza Czasownik-Rzeczownik

  • Pojęcie cmdletu: niewielkie, wyspecjalizowane polecenie wbudowane w powłokę, zwracające obiekty platformy .NET.
  • Struktura Verb-Noun: dwuczłonowa nazwa rozdzielona myślnikiem precyzyjnie opisuje wykonywaną akcję i zasób docelowy.
  • Zatwierdzone czasowniki: Microsoft ściśle standaryzuje listę dozwolonych czasowników (Get, Set, New, Remove, Start, Stop).
  • Liczba pojedyncza rzeczownika: rzeczownik w nazwie cmdletu zawsze występuje w liczbie pojedynczej (np. Get-Service, a nie Get-Services).
Cmdlet (command-let): podstawowa jednostka wykonawcza w środowisku PowerShell zaimplementowana jako skompilowana klasa platformy .NET dziedzicząca po klasie Cmdlet lub PSCmdlet. Charakteryzuje się ustandaryzowaną obsługą parametrów i przetwarzaniem danych w potoku.
  +-------------------------------------------------------+
  |            BUDOWA NAZWY CMDLETU: VERB-NOUN            |
  +-------------------------------------------------------+
  |       CZASOWNIK (Verb)       -    RZECZOWNIK (Noun)   |
  |       Akcja wykonywana            Obiekt docelowy     |
  |       (Get, Set, New, ...)        (Process, Service)  |
  +-------------------------------------------------------+
  | Przykłady: Get-Process, Start-Service, New-Item       |
  +-------------------------------------------------------+
        
10/60
System pomocy: Get-Help
Slajd omawia wbudowany system dokumentacji Get-Help, poziomy szczegółowości pomocy oraz aktualizację bazy wiedzy poleceniem Update-Help.

Wyszukiwanie dokumentacji i przykładów

  • Rola polecenia Get-Help: wbudowana wyszukiwarka dokumentacji dostarczająca opisy, składnię i przykłady użycia poleceń.
  • Przełącznik -Examples: wyświetla praktyczne przykłady wywołań cmdletu z objaśnieniem parametrów (najbardziej pomocny tryb).
  • Przełączniki -Detailed i -Full: prezentują pełną specyfikację techniczną, w tym opis każdego parametru i akceptowane typy potoku.
  • Aktualizacja pomocy (Update-Help): pobiera najświeższe wersje dokumentacji bezpośrednio z serwerów firmy Microsoft przez Internet.
System pomocy PowerShell (Get-Help): zintegrowany podsystem dokumentacji technicznej powłoki interpretujący pliki pomocy MAML oraz komentarze strukturalne w skryptach, zapewniający ujednolicony format prezentacji składni, parametrów i przykładów użycia narzędzi.
# Podstawowa pomoc dla polecenia
# Wyświetla krótkie podsumowanie polecenia
Get-Help Get-Process

# Pokaż tylko przykłady użycia
# Bardzo przydatne, gdy chcesz szybko zobaczyć jak używać polecenia
Get-Help Get-Process -Examples

# Pokaż szczegółową pomoc ze wszystkimi parametrami
# Zawiera opis każdego parametru i jego zastosowanie
Get-Help Get-Process -Full

# Otwórz pomoc w osobnym oknie
# Wygodniejsze do czytania, bo nie znika przy przewijaniu
Get-Help Get-Process -ShowWindow
11/60
Wyszukiwanie poleceń: Get-Command
Slajd przedstawia cmdlet Get-Command jako narzędzie do przeszukiwania bazy poleceń, modułów i funkcji w bieżącym środowisku.

Odkrywanie dostępnych narzędzi

  • Wyszukiwanie według wzorców: możliwość stosowania symboli wieloznacznych (wildcards) w nazwach czasowników i rzeczowników.
  • Filtrowanie według modułów: przełącznik -Module pozwala wyświetlić wyłącznie polecenia dostarczane przez określony pakiet.
  • Kategoryzacja poleceń: odróżnianie skompilowanych cmdletów od funkcji skryptowych, aliasów i programów binarnych.
  • Wyszukiwanie parametrów: przełącznik -ParameterName umożliwia znalezienie wszystkich poleceń przyjmujących zadany parametr.
Polecenie Get-Command: podstawowy cmdlet introspekcyjny środowiska PowerShell wyszukujący i katalogujący wszystkie zarejestrowane w bieżącej sesji cmdlety, funkcje, aliasy, filtry, skrypty oraz pliki wykonywalne dostępne w ścieżce systemowej PATH.
# Znajdź wszystkie polecenia związane z "process"
# Gwiazdka * oznacza "dowolny tekst"
# Wynik: Get-Process, Stop-Process, Wait-Process itp.
Get-Command *Process*

# Znajdź polecenia z czasownikiem "Get" i rzeczownikiem "Service"
# Czyli wyszukuje polecenia typu Get-Service
Get-Command -Verb Get -Noun *Service*

# Znajdź polecenia związane z plikami
# Wynik: Get-FileHash, Test-Path, Join-Path itp.
Get-Command *File*

# Policz, ile masz dostępnych poleceń
# Nawiasy () oznaczają, że najpierw wykonaj polecenie w środku,
# a potem pobierz właściwość Count
(Get-Command).Count
12/60
Potok obiektowy: podstawy
Slajd wyjaśnia zasady przesyłania całych struktur obiektowych platformy .NET pomiędzy cmdletami za pomocą operatora potoku |.

Łączenie poleceń symbolem potoku

  • Operator potoku (|): łączy strumień wyjściowy jednego cmdletu ze strumieniem wejściowym kolejnego narzędzia.
  • Transmisja obiektów: dane wędrujące przez potok zachowują wszystkie metody, właściwości i typy platformy .NET.
  • Brak utraty struktury: eliminacja ryzyka błędów parsowania wynikających ze zmiany formatowania tekstu lub języka systemu.
  • Przetwarzanie strumieniowe: obiekty są przesyłane i przetwarzane sekwencyjnie w miarę ich generowania, bez konieczności buforowania całości.
Potok obiektowy (object pipeline): mechanizm wymiany danych w PowerShellu przesyłający w czasie rzeczywistym instancje klas środowiska .NET pomiędzy poleceniami, umożliwiający bezpośrednie odwoływanie się do właściwości bez konieczności przetwarzania tekstu.
# Bez potoku - tylko wyświetlamy procesy
# Get-Process zwraca listę wszystkich procesów
Get-Process

# Z potokiem - bierzemy procesy i wybieramy tylko 5 pierwszych
# Najpierw Get-Process pobiera wszystkie procesy,
# potem Select-Object zostawia tylko 5 pierwszych
Get-Process | Select-Object -First 5

# Z potokiem - wyświetlamy tylko nazwy procesów
# Select-Object wybiera tylko właściwość Name z każdego procesu
Get-Process | Select-Object -Property Name
13/60
Inspekcja obiektów: Get-Member
Slajd omawia cmdlet Get-Member jako narzędzie do odkrywania właściwości (Properties) oraz metod (Methods) badanych obiektów .NET.

Poznawanie struktury i metod obiektów

  • Rola polecenia Get-Member: wyświetla pełną definicję typu .NET, listę pól danych oraz dostępnych operacji programistycznych.
  • Właściwości (Properties): przechowują informacje o stanie obiektu (np. nazwa procesu, zużycie procesora, identyfikator PID).
  • Metody (Methods): akcje wykonywalne, które można wywołać bezpośrednio na obiekcie (np. Kill(), Refresh(), Start()).
  • Filtrowanie członków: parametr -MemberType pozwala zawęzić wyniki wyłącznie do właściwości lub wyłącznie do metod.
Inspekcja typu (reflection / Get-Member): mechanizm refleksji środowiska .NET wykorzystywany przez Get-Member do dynamicznego odczytu metadanych obiektu w czasie wykonania, ujawniający jego strukturę, dostępne pola oraz sygnatury metod.
# Zobacz wszystkie właściwości i metody obiektu "tekst"
# "tekst" to obiekt typu string, zobaczysz co potrafi
"jakiś tekst" | Get-Member

# Zobacz właściwości procesu
# Zobaczysz Name, Id, CPU, WorkingSet itp.
Get-Process | Get-Member

# Zobacz właściwości daty
# Zobaczysz Year, Month, Day, DayOfWeek itp.
Get-Date | Get-Member

# Zobacz tylko właściwości (Property)
# Pomija metody, pokazuje tylko dane
Get-Process | Get-Member -MemberType Property
14/60
Zmienne w PowerShell
Slajd przedstawia zasady tworzenia zmiennych, prefiks dolara ($) oraz mechanizm dynamicznego dopasowywania typów w pamięci.

Deklaracja, przypisanie i elastyczność typów

  • Prefiks dolara ($): każda nazwa zmiennej w PowerShellu musi bezwzględnie rozpoczynać się od symbolu $.
  • Dynamiczne typowanie: powłoka automatycznie dopasowuje typ zmiennej na podstawie przypisywanej wartości.
  • Niewrażliwość na wielkość liter: nazwy zmiennych $Zmienna i $zmienna wskazują dokładnie ten sam obszar pamięci.
  • Dozwolone znaki: nazwy mogą zawierać litery, cyfry i podkreślenia; znaki specjalne wymagają ujęcia w nawiasy klamrowe (${nazwa}).
Zmienna w PowerShell: nazwany obiekt w pamięci operacyjnej reprezentowany przez prefiks $, przechowujący referencję do dowolnego typu danych platformy .NET (w tym liczb, łańcuchów, kolekcji lub instancji klas systemowych).
# Tworzenie zmiennej i przypisanie wartości
# Znak = przypisuje wartość do zmiennej
$imie = "Anna"        # zmienna tekstowa
$wiek = 21           # zmienna liczbowa
$pi = 3.14           # zmienna dziesiętna

# Wyświetlenie wartości zmiennej
# PowerShell automatycznie podstawia wartość zmiennej
Write-Host "Cześć, $imie!"       # Wyświetli: Cześć, Anna!
Write-Host "Masz $wiek lat."       # Wyświetli: Masz 21 lat.

# Zmiana wartości zmiennej
# Możesz zmienić wartość w dowolnym momencie
$wiek = 22
Write-Host "Teraz masz $wiek lat."  # Wyświetli: Teraz masz 22 lat.
15/60
Typy danych: podstawy
Slajd omawia fundamentalne typy danych stosowane w skryptach PowerShell: łańcuchy, liczby całkowite, zmiennoprzecinkowe i wartości logiczne.

Katalog elementarnych typów platformy .NET

  • Ciągi tekstowe ([string]): łańcuchy znaków ujęte w apostrofy (dosłowne) lub podwójne cudzysłowy (z interpolacją zmiennych).
  • Liczby całkowite ([int], [long]): 32-bitowe i 64-bitowe wartości numeryczne ze znakiem przeznaczone do obliczeń arytmetycznych.
  • Liczby dziesiętne ([double], [decimal]): liczby zmiennoprzecinkowe o wysokiej precyzji zapisu części ułamkowej.
  • Typ logiczny ([bool]): dwustanowa wartość logiczna reprezentowana przez stałe automatyczne $true oraz $false.
Typ danych .NET: formalna definicja rozmiaru pamięci, dozwolonych wartości oraz zestawu operacji matematyczno-logicznych powiązana z obiektem w środowisku uruchomieniowym platformy .NET.
# PowerShell automatycznie rozpoznaje typ
# Nie musisz go podawać - PowerShell "domyśli się"
$tekst = "Hello"    # Automatycznie string
$liczba = 42         # Automatycznie int
$prawda = $true     # Automatycznie bool

# Sprawdzenie typu zmiennej
# Metoda GetType() zwraca obiekt z informacją o typie
$tekst.GetType()    # Pokaże: IsPublic=True, IsSerial=True, Name=String
$liczba.GetType()    # Pokaże: Name=Int32

# Możesz też sprawdzić krócej - pobierz tylko pełną nazwę typu
$tekst.GetType().FullName  # Pokaże: System.String
16/60
Jawne określanie typu zmiennej
Slajd wyjaśnia technikę wymuszania typów za pomocą nawiasów kwadratowych [Typ]$zmienna oraz automatyczną konwersję wartości.

Statyczne typowanie i bezpieczeństwo kodu

  • Składnia rzutowania typu: umieszczenie nazwy typu w nawiasach kwadratowych przed nazwą zmiennej: [int]$liczba = 10.
  • Ochrona przed błędami: próba przypisania niekompatybilnego typu danych (np. tekstu do liczby) wywoła błąd zamiast uszkodzić stan.
  • Konwersja danych: jawne rzutowanie wymusza automatyczną transformację, np. tekstu '123' na liczbę całkowitą 123.
  • Większa czytelność: deklarowanie typów parametrów ułatwia analizę i utrzymanie złożonych skryptów w zespołach programistycznych.
Rzutowanie typu (type casting): jawne wymuszenie interpretacji wartości zmiennej jako instancji określonej klasy platformy .NET, zapewniające statyczną kontrolę poprawności danych wewnątrz dynamicznie typowanej powłoki.
# Jawna deklaracja różnych typów
# Nawias kwadratowy przed nazwą oznacza typ
[string]$imie = "Jan"           # Tylko tekst
[int]$wiek = 25                # Tylko liczba całkowita
[bool]$jestStudentem = $true  # Tylko prawda/fałsz
[double]$pensja = 4500.50      # Liczba z przecinkiem
[datetime]$dzis = Get-Date     # Data i godzina

# Wyświetlenie
Write-Host "Imię: $imie"
Write-Host "Wiek: $wiek"
Write-Host "Czy student: $jestStudentem"
# Po uruchomieniu zobaczysz:
# Imię: Jan
# Wiek: 25
# Czy student: True
17/60
Specjalne wartości zmiennych
Slajd omawia wbudowane literały wartości specjalnych oraz ich znaczenie w testach logicznych i diagnostyce powłoki.

Wartości $null, $true, $false i $PID

  • Pusta wartość ($null): oznacza brak przypisanej wartości lub nieistniejący obiekt; kluczowa w walidacji wejścia.
  • Prawda i fałsz ($true, $false): wbudowane stałe logiczne typu [bool] wykorzystywane w instrukcjach warunkowych.
  • Identyfikator procesu ($PID): zmienna tylko do odczytu zawierająca numer identyfikacyjny bieżącej instancji powershell/pwsh.
  • Bezpieczne porównanie z null: zalecana reguła umieszczania $null po lewej stronie operatora: if ($null -eq $zmienna).
Literał $null: specjalna stała środowiska PowerShell oznaczająca brak referencji do obiektu w pamięci, odpowiadająca wartości null w języku C# i standardzie Common Language Infrastructure.
# $null - brak wartości
# Użyj, gdy zmienna nie ma jeszcze żadnej wartości
$brakWartosci = $null

# Sprawdzenie, czy zmienna jest pusta
if ($brakWartosci -eq $null) {
    Write-Host "Zmienna jest pusta"
}

# $true i $false - wartości logiczne
# Używane w warunkach (if, while)
$czyJestWeekend = $false
$czyPadaDeszcz = $true

# $_ - bieżący element w potoku
# Bardzo ważne! Oznacza "aktualnie przetwarzany element"
# Ten przykład znajdzie procesy, które używają więcej niż 10 CPU
Get-Process | Where-Object { $_.CPU -gt 10 }
# $_ reprezentuje każdy proces z osobna w pętli Where-Object
18/60
Zmienne środowiskowe
Slajd przedstawia sposób odczytu i modyfikacji zmiennych środowiskowych systemu operacyjnego za pomocą dysku wirtualnego Env:.

Dostawca Env: i integracja z systemem operacyjnym

  • Dysk Env: (PSProvider): PowerShell udostępnia zmienne środowiskowe w postaci wirtualnego systemu plików pod adresem Env:.
  • Składnia $env:NAZWA: szybki dostęp do zmiennych systemowych za pomocą prefiksu $env: (np. $env:COMPUTERNAME, $env:USERNAME).
  • Ścieżka systemowa ($env:PATH): odczyt i tymczasowa modyfikacja listy katalogów przeszukiwanych w poszukiwaniu programów.
  • Zasięg modyfikacji: zmiana dokonana przez $env:zmienna dotyczy wyłącznie bieżącego procesu PowerShell i jego potomków.
Dostawca środowiska (Env: Provider): wyspecjalizowany mechanizm PSProvider integrujący tablicę zmiennych środowiskowych procesu systemu operacyjnego z mechanizmami nawigacji i manipulacji danymi w powłoce PowerShell.
# Nazwa komputera - pobiera nazwę z ustawień Windows
$env:COMPUTERNAME

# Nazwa zalogowanego użytkownika
$env:USERNAME

# Ścieżka do folderu użytkownika (np. C:\Users\Jan)
$env:USERPROFILE

# Ścieżka tymczasowa (gdzie system trzyma pliki tymczasowe)
$env:TEMP

# Zmienna PATH - ścieżki wyszukiwania programów
# Gdy wpisujesz "notepad", system szuka go w tych folderach
$env:Path

# Podziel zmienną PATH na części (każda ścieżka osobno)
# -split ';' dzieli tekst na tablicę przy znaku średnika
$env:Path -split ';' | ForEach-Object { $_ }
19/60
Tablice: wprowadzenie
Slajd omawia deklarowanie tablic obiektowych, operator @() oraz indeksowanie elementów od zera.

Kolekcje obiektów i podstawowe indeksowanie

  • Tworzenie tablicy (@()): deklaracja tablicy za pomocą jawnego konstruktora @(1, 2, 3) lub prostej listy rozdzielanej przecinkami.
  • Kolekcje heterogeniczne: domyślna tablica w PowerShellu może przechowywać obiekty różnych typów (np. tekst, liczbę i datę w jednej tablicy).
  • Indeksowanie od zera: dostęp do pierwszego elementu przez $tablica[0]; indeks ujemny $tablica[-1] zwraca ostatni element.
  • Liczba elementów (.Count): właściwość .Count lub .Length zwraca aktualną liczbę elementów przechowywanych w kolekcji.
Tablica obiektowa (object array): uporządkowana kolekcja referencji do obiektów platformy .NET typu System.Object[], indeksowana liczbami całkowitymi począwszy od zera, o stałym rozmiarze alokacji pamięci.
# Tworzenie tablicy za pomocą @
# Elementy oddzielamy przecinkami
$kolory = @("czerwony", "zielony", "niebieski")
$liczby = @(1, 2, 3, 4, 5)

# Dostęp do elementów (indeksowanie od 0!)
# Uwaga! Pierwszy element ma indeks [0], nie [1]!
Write-Host "Pierwszy kolor: $($kolory[0])"   # czerwony
Write-Host "Drugi kolor: $($kolory[1])"      # zielony
Write-Host "Trzeci kolor: $($kolory[2])"     # niebieski

# Pobranie ostatniego elementu
# Indeks [-1] zawsze oznacza ostatni element
$ostatni = $kolory[-1]
Write-Host "Ostatni kolor: $ostatni"

# Liczba elementów w tablicy
# Właściwość Count zwraca liczbę elementów
Write-Host "Liczba kolorów: $($kolory.Count)"
20/60
Operacje na tablicach
Slajd przedstawia manipulację tablicami: operator dodawania +=, operator zakresu (..) oraz alternatywne listy dynamiczne ArrayList.

Dodawanie elementów, wycinanie zakresów i łączenie

  • Operator zakresu (..): konstrukcja 1..10 generuje natychmiast ciąg liczb całkowitych od 1 do 10.
  • Koszt operatora +=: ponieważ tablice .NET mają stały rozmiar, operacja += w tle tworzy nową tablicę i kopiuje wszystkie elementy.
  • Wycinanie podzbiorów: pobieranie wielu elementów jednocześnie przez podanie indeksów lub zakresu: $tablica[0..2].
  • Listy dynamiczne (Generic List): dla dużych zbiorów danych zaleca się stosowanie kolekcji [System.Collections.Generic.List[object]].
Operator zakresu (range operator ..): wbudowany operator PowerShell generujący sekwencyjny ciąg liczb całkowitych w zadanym przedziale obustronnie domkniętym, często wykorzystywany w pętlach i indeksowaniu tablic.
# Tworzenie tablicy
$owoce = @("jabłko", "banan", "pomarańcza")

# Dodawanie elementu
# Operator += dodaje nowy element na końcu tablicy
$owoce += "winogrono"
Write-Host "Po dodaniu: $($owoce -join ', ')"
# Wynik: jabłko, banan, pomarańcza, winogrono

# Usuwanie elementu
# Tworzymy nową tablicę bez "banan"
$owoce = $owoce | Where-Object { $_ -ne "banan" }
Write-Host "Po usunięciu banana: $($owoce -join ', ')"
# Wynik: jabłko, pomarańcza, winogrono

# Sprawdzenie, czy element istnieje
# Operator -in sprawdza, czy element jest w tablicy
if ("jabłko" -in $owoce) {
    Write-Host "Jabłko jest w tablicy!"
}

# Iteracja po tablicy - przejdź przez każdy element
foreach ($owoc in $owoce) {
    Write-Host "Lubię: $owoc"
}
21/60
Tablice mieszające (Hashtable)
Slajd omawia strukturę tablic asocjacyjnych Hashtable, konstruktor @{} oraz szybki dostęp do danych według unikalnych kluczy.

Przechowywanie par klucz-wartość

  • Konstruktor @{}: deklaracja tablicy mieszającej za pomocą składni @{ Klucz = 'Wartość'; Klucz2 = 123 }.
  • Błyskawiczny dostęp O(1): wyszukiwanie wartości na podstawie klucza odbywa się w czasie stałym dzięki funkcjom skrótu.
  • Dostęp kropkowy i indeksowy: odczyt wartości możliwy przez właściwość ($h.Klucz) lub indeks nawiasowy ($h['Klucz']).
  • Różnorodne typy danych: wartościami mogą być dowolne obiekty .NET, w tym zagnieżdżone tablice lub inne tablice mieszające.
Tablica mieszająca (Hashtable): struktura danych typu System.Collections.Hashtable przechowująca pary klucz-wartość, w której każdy klucz jest przekształcany przez funkcję skrótu na indeks pamięci, co zapewnia natychmiastowy dostęp do skojarzonej wartości.
# Tworzenie tablicy mieszającej za pomocą @
# Struktura: Klucz = Wartość
$osoba = @{
    Imie = "Anna"
    Nazwisko = "Kowalska"
    Wiek = 25
    Miasto = "Warszawa"
}

# Dostęp do wartości przez klucz - sposób 1 (kropka)
Write-Host "Imię: $($osoba.Imie)"              # Anna
Write-Host "Nazwisko: $($osoba.Nazwisko)"     # Kowalska

# Dostęp do wartości przez klucz - sposób 2 (nawiasy)
Write-Host "Wiek: $($osoba['Wiek'])"           # 25

# Dodawanie nowej pary klucz-wartość
$osoba.Telefon = "123-456-789"                # sposób kropka
$osoba["Email"] = "anna@example.com"           # sposób nawiasy

# Wyświetlenie wszystkich kluczy
$osoba.Keys
# Wynik: Imie, Nazwisko, Wiek, Miasto, Telefon, Email
22/60
Operacje na tablicach mieszających
Slajd przedstawia metody .Add(), .Remove(), iterację po kluczach oraz konwersję Hashtable na pełnoprawny [PSCustomObject].

Modyfikacja, usuwanie i tworzenie PSCustomObject

  • Dodawanie i usuwanie par: metoda .Add('Klucz', 'Wartość') dodaje wpis; metoda .Remove('Klucz') usuwa wybrany element.
  • Iteracja po kluczach (.Keys): przechodzenie przez wszystkie elementy pętlą foreach ($k in $h.Keys).
  • Rzutowanie na [PSCustomObject]: zamiana tablicy mieszającej na niestandardowy obiekt .NET ułatwiający eksport do tabeli i formatu CSV.
  • Zachowanie kolejności ([ordered]): dodanie atrybutu [ordered]@{} zapobiega losowemu tasowaniu kolejności kluczy przez silnik skrótu.
Obiekt PSCustomObject: uniwersalna klasa w PowerShellu pozwalająca programiście na dynamiczne tworzenie własnych obiektów o zdefiniowanych właściwościach, w pełni integrujących się z potokiem obiektowym i poleceniami eksportu danych.
# Tworzenie tablicy mieszającej
$uzytkownik = @{
    Login = "student01"
    Haslo = "tajne123"
    Uprawnienia = "admin"
}

# Modyfikacja wartości - po prostu przypisz nową wartość
$uzytkownik.Haslo = "noweHaslo456"

# Usuwanie klucza wraz z wartością
$uzytkownik.Remove("Haslo")

# Iteracja po parach klucz-wartość
# Przejdź przez każdy klucz i pobierz jego wartość
foreach ($klucz in $uzytkownik.Keys) {
    $wartosc = $uzytkownik[$klucz]
    Write-Host "$klucz = $wartosc"
}
# Wynik:
# Login = student01
# Uprawnienia = admin

# Sprawdzenie, czy klucz istnieje
if ($uzytkownik.ContainsKey("Login")) {
    Write-Host "Klucz Login istnieje"
}
23/60
Komentarze: dokumentowanie kodu
Slajd omawia techniki dokumentowania kodu skryptu: komentarze jednoliniowe (#), blokowe (<# #>) oraz nagłówki pomocy CBH.

Komentarze jednoliniowe, blokowe i pomoc oparta na komentarzach

  • Komentarz jednoliniowy (#): symbol krzyżyka ignoruje resztę bieżącego wiersza; idealny do zwięzłych notatek technicznych.
  • Komentarz blokowy (<# ... #>): pozwala na wyłączenie z kompilacji wieloliniowego fragmentu kodu lub dodanie długiego opisu.
  • Comment-Based Help (CBH): specjalne słowa kluczowe (.SYNOPSIS, .DESCRIPTION, .PARAMETER) integrujące się z poleceniem Get-Help.
  • Higiena programistyczna: regularne komentowanie założeń algorytmicznych jest fundamentem utrzymania kodu w środowiskach produkcyjnych.
Pomoc oparta na komentarzach (Comment-Based Help): mechanizm powłoki PowerShell automatycznie przekształcający ustrukturyzowany blok komentarza umieszczony w funkcji lub skrypcie na oficjalną dokumentację systemową dostępną przez cmdlet Get-Help.
# To jest komentarz jednoliniowy
# Komputer go ignoruje, pomaga ludziom rozumieć kod

# Poniżej tworzę zmienną z imieniem
$imie = "Jan"

<#
    To jest komentarz
    wieloliniowy.
    Może zawierać wiele
    linii tekstu.
#>

# Przykład użycia komentarzy w kodzie
$wiek = 20  # To jest komentarz "końcowy" - w linii
24/60
Wprowadzanie danych: Read-Host
Slajd omawia cmdlet Read-Host, komunikaty zachęty (prompt) oraz bezpieczne wprowadzanie poświadczeń z przełącznikiem -AsSecureString.

Interaktywne pobieranie danych i bezpieczne hasła

  • Rola polecenia Read-Host: wstrzymuje bieg programu i pobiera pojedynczą linię tekstu wprowadzoną przez użytkownika z klawiatury.
  • Monit zachęty (-Prompt): parametr -Prompt wyświetla czytelną instrukcję informującą użytkownika, jakich danych oczekuje program.
  • Pobieranie haseł (-AsSecureString): maskuje wpisywane znaki gwiazdkami i szyfruje dane w pamięci RAM w obiekcie System.Security.SecureString.
  • Ograniczenie w automatyzacji: polecenia interaktywne nie powinny być stosowane w skryptach uruchamianych w tle przez harmonogram zadań.
Ciąg zabezpieczony (SecureString): klasa platformy .NET przechowująca poufne dane tekstowe (np. hasła, klucze API) w postaci zaszyfrowanej w pamięci RAM przy użyciu kluczy kryptograficznych powiązanych z bieżącym kontem użytkownika.
# Proste wprowadzenie danych
# Najpierw wyświetl pytanie
Write-Host "Jak masz na imię?"
# Następnie pobierz odpowiedź od użytkownika
$imie = Read-Host
Write-Host "Cześć, $imie!"

# Wprowadzenie z podpowiedzią
# Read-Host może wyświetlić podpowiedź w jednej linii
$nazwisko = Read-Host "Podaj swoje nazwisko"
Write-Host "Twoje nazwisko to: $nazwisko"

# Wprowadzenie liczby
# Read-Host ZAWSZE zwraca tekst, więc trzeba konwertować
# Nawias [int] konwertuje tekst na liczbę
$wiek = [int](Read-Host "Ile masz lat?")
Write-Host "Za rok będziesz mieć $($wiek + 1) lat"
25/60
Wyświetlanie danych: Write-Host vs Write-Output
Slajd wyjaśnia kluczową różnicę semantyczną pomiędzy wypisaniem na ekran (Write-Host) a zwróceniem obiektu do potoku (Write-Output).

Strumień konsoli a strumień potoku obiektowego

  • Polecenie Write-Host: kieruje tekst bezpośrednio do bufora ekranu terminala; dane NIE trafiają do potoku i nie mogą być przechwycone.
  • Polecenie Write-Output: umieszcza obiekt w standardowym strumieniu wyjściowym potoku, skąd może trafić do zmiennej lub kolejnego cmdletu.
  • Formatowanie kolorystyczne: Write-Host wspiera parametry -ForegroundColor i -BackgroundColor ułatwiające budowanie interfejsu.
  • Złota zasada: używaj Write-Host wyłącznie do komunikatów wizualnych dla człowieka, nigdy do zwracania wyników z funkcji.
Strumień sukcesu potoku (pipeline output stream): główny strumień danych w PowerShellu (strumień numer 1), przez który obiekty zwracane przez Write-Output są przekazywane do kolejnych etapów potoku lub przypisywane do zmiennych.
# Podstawowe użycie
Write-Host "Witaj w PowerShell!"

# Wyświetlanie zmiennej
# PowerShell automatycznie podstawi wartość zmiennej
$imie = "Anna"
Write-Host "Cześć, $imie!"   # Wynik: Cześć, Anna!

# Kolorowanie tekstu - zmiana koloru liter
Write-Host "To jest ważny komunikat!" -ForegroundColor Red
Write-Host "To jest sukces!" -ForegroundColor Green
Write-Host "To jest ostrzeżenie!" -ForegroundColor Yellow
Write-Host "To jest informacja." -ForegroundColor Cyan

# Kolorowanie tła tekstu
Write-Host "Tekst na żółtym tle" -BackgroundColor Yellow
26/60
Argumenty wiersza poleceń: param()
Slajd omawia blok param() umieszczany na początku skryptu, definiowanie typowanych parametrów oraz wartości domyślnych.

Deklaracja sformalizowanych parametrów skryptu

  • Blok param(): formalna deklaracja argumentów akceptowanych przez skrypt .ps1 lub funkcję wiersza poleceń.
  • Typowanie parametrów: podanie typu przed nazwą (np. [string]$Sciezka) gwarantuje automatyczną walidację wejścia.
  • Wartości domyślne: możliwość przypisania wartości rezerwowej stosowanej wtedy, gdy użytkownik nie poda danego parametru.
  • Automatyczne przełączniki: parametry zdefiniowane w param() stają się natywnie dostępne z autouzupełnianiem klawiszem Tab.
Blok parametrów (param block): kluczowa konstrukcja składniowa języka PowerShell definiująca formalny interfejs wejściowy skryptu lub funkcji, określająca nazwy, typy, atrybuty oraz wartości domyślne argumentów wiersza poleceń.
# Plik: Witaj.ps1
# Parametry definiujemy w bloku param() na początku
param(
    [string]$Imie,     # Parametr tekstowy (bez wartości domyślnej)
    [int]$Wiek = 18     # Parametr liczbowy z wartością domyślną 18
)

Write-Host "Cześć, $Imie!"
Write-Host "Masz $Wiek lat."

# URUCHOMIENIE SKRYPTU:
# Podajemy argumenty po nazwie parametru (najbezpieczniejsze)
# .\Witaj.ps1 -Imie Anna -Wiek 25
# Wynik: Cześć, Anna! Masz 25 lat.

# Można też bez podawania nazwy (kolejność ma znaczenie)
# .\Witaj.ps1 Anna 25
# Wynik: Cześć, Anna! Masz 25 lat.

# Gdy nie podamy -Wiek, użyje wartości domyślnej 18
# .\Witaj.ps1 -Imie Jan
# Wynik: Cześć, Jan! Masz 18 lat.
27/60
Zapis do pliku tekstowego
Slajd przedstawia metody zapisu danych do plików: Out-File, Set-Content, obsługę kodowania UTF-8 oraz dopisywanie parametrem -Append.

Polecenia Out-File oraz Set-Content

  • Polecenie Set-Content: zapisuje obiekty lub łańcuchy tekstowe do pliku, nadpisując jego dotychczasową zawartość.
  • Polecenie Add-Content: dopisuje nowe linie na końcu istniejącego pliku bez naruszania wcześniejszych danych.
  • Polecenie Out-File: kieruje sformatowany widok obiektów do pliku tekstowego dokładnie tak, jak pojawiłby się na ekranie konsoli.
  • Parametr -Encoding: jawne określenie standardu kodowania znaków (np. utf8, ascii), kluczowe dla zachowania polskich znaków diakrytycznych.
Kodowanie znaków UTF-8: standard zmiennokodowy kodowania znaków Unicode w postaci sekwencji od 1 do 4 bajtów, będący uniwersalnym branżowym standardem zapisu tekstu w nowoczesnych systemach operacyjnych.
# Zapis pojedynczej linii (nadpisuje plik!)
# UWAGA: Jeśli plik istnieje, jego zawartość zostanie USUNIĘTA!
Set-Content -Path "C:\Temp\test.txt" -Value "Pierwsza linia"

# Zapis wielu linii na raz
# Tablica linii zostanie zapisana jako wiele linii w pliku
$dane = @("Linia 1", "Linia 2", "Linia 3")
Set-Content -Path "C:\Temp\test.txt" -Value $dane

# Dopisanie linii na końcu pliku
# Dodaje nową linię, nie usuwając istniejącej zawartości
Add-Content -Path "C:\Temp\test.txt" -Value "Nowa linia"

# Zapis z użyciem zmiennych
$imie = "Jan"
$data = Get-Date  # Pobiera aktualną datę i godzinę
Add-Content -Path "C:\Temp\log.txt" -Value "[$data] Użytkownik $imie się zalogował"
28/60
Odczyt z pliku tekstowego
Slajd omawia cmdlet Get-Content, przetwarzanie pliku linia po linii w potoku oraz wczytywanie całego bufora z przełącznikiem -Raw.

Wierszowe i całościowe wczytywanie danych: Get-Content

  • Domyślne działanie Get-Content: odczytuje plik tekstowy i zwraca tablicę łańcuchów znaków [string[]], gdzie każdy element to jeden wiersz.
  • Przełącznik -Raw: wczytuje całą zawartość pliku do pojedynczego, ciągłego łańcucha znaków z zachowaniem znaków nowej linii.
  • Przełącznik -TotalCount (-Head): pobiera określoną liczbę początkowych wierszy pliku (odpowiednik uniksowego head).
  • Przełącznik -Tail: pobiera zadaną liczbę ostatnich linii pliku; w połączeniu z -Wait realizuje funkcjonalność tail -f dla logów.
Polecenie Get-Content: podstawowy cmdlet wejścia/wyjścia w PowerShellu służący do odczytywania zawartości elementów systemu plików oraz innych dostawców PSProvider, zwracający dane w postaci obiektów tekstowych.
# Odczyt całego pliku
# Zmienna $zawartosc będzie zawierać tablicę linii
$zawartosc = Get-Content -Path "C:\Temp\test.txt"
Write-Host $zawartosc

# Odczyt z wyświetleniem numerów linii
# ReadCount to numer aktualnej linii
Get-Content -Path "C:\Temp\test.txt" | ForEach-Object {
    $numer = $_.ReadCount
    Write-Host "$numer : $_"
}
# Wynik:
# 1 : Pierwsza linia
# 2 : Druga linia

# Odczyt tylko pierwszych 5 linii
Get-Content -Path "C:\Temp\test.txt" -TotalCount 5

# Odczyt tylko ostatnich 3 linii (bardzo przydatne dla logów!)
Get-Content -Path "C:\Temp\log.txt" -Tail 3

# Odczyt jako tablica linii
$linie = Get-Content -Path "C:\Temp\test.txt"
Write-Host "Plik ma $($linie.Count) linii"
29/60
Sprawdzanie istnienia ścieżek: Test-Path
Slajd prezentuje cmdlet Test-Path do bezbłędnego sprawdzania obecności plików, katalogów oraz kluczy w rejestrze systemowym.

Weryfikacja obecności zasobów dyskowych i rejestru

  • Rola polecenia Test-Path: zwraca wartość logiczną $true, jeżeli wskazana ścieżka fizycznie istnieje w systemie, lub $false w przeciwnym razie.
  • Przełącznik -PathType: umożliwia sprecyzowanie, czy badany obiekt musi być plikiem zwykłym (Leaf), czy folderem (Container).
  • Wsparcie dla dostawców PSProvider: działa identycznie na dyskach fizycznych (C:), udziałach sieciowych oraz gałęziach rejestru (HKLM:).
  • Zastosowanie w warunkach if: standardowa praktyka sprawdzania obecności plików konfiguracyjnych przed rozpoczęciem operacji odczytu.
Dostawca PowerShell (PSProvider): składnik architektury powłoki, który prezentuje różnorodne magazyny danych (system plików, rejestr Windows, certyfikaty, zmienne) w postaci ujednoliconego, hierarchicznego drzewa ścieżek dyskowych (PSDrive).
# Sprawdzenie, czy plik istnieje
$sciezkaPliku = "C:\Windows\System32\notepad.exe"
if (Test-Path -Path $sciezkaPliku) {
    # Jeśli plik istnieje, wykonaj ten kod
    Write-Host "Plik istnieje!"
} else {
    # Jeśli plik nie istnieje, wykonaj ten kod
    Write-Host "Plik nie istnieje!"
}

# Sprawdzenie, czy katalog istnieje
# Parametr -PathType Container oznacza "katalog"
if (Test-Path -Path "C:\Temp" -PathType Container) {
    Write-Host "Katalog istnieje!"
}

# Sprawdzenie wielu ścieżek jednocześnie
# Pętla przejdzie przez każdy katalog z listy
$katalogi = @("C:\Windows", "C:\Program Files", "C:\NieIstnieje")
foreach ($k in $katalogi) {
    if (Test-Path $k) {
        Write-Host "$k - OK" -ForegroundColor Green
    } else {
        Write-Host "$k - NIE ZNALEZIONO" -ForegroundColor Red
    }
}
30/60
Zarządzanie plikami i katalogami
Slajd omawia tworzenie folderów i plików poleceniem New-Item oraz bezpieczne usuwanie zasobów poleceniem Remove-Item z parametrem -Recurse.

Tworzenie i usuwanie zasobów: New-Item i Remove-Item

  • Tworzenie zasobów (New-Item): parametr -ItemType Directory tworzy folder, a -ItemType File tworzy nowy pusty plik tekstowy.
  • Wymuszenie operacji (-Force): pozwala utworzyć całą ścieżkę brakujących podkatalogów lub nadpisać istniejący plik tylko do odczytu.
  • Usuwanie zasobów (Remove-Item): usuwa wskazane pliki; parametr -Recurse usuwa całe drzewo podkatalogów wraz z zawartością.
  • Bezpieczeństwo operacji (-WhatIf): parametr -WhatIf symuluje wykonanie polecenia i wyświetla raport zmian bez dokonywania modyfikacji na dysku.
Mechanizm WhatIf (risk mitigation): wbudowany w zaawansowane cmdlety mechanizm bezpieczeństwa pozwalający administratorowi sprawdzić, jakie operacje usunięcia lub modyfikacji zostałyby wykonane, przed ich faktycznym zatwierdzeniem.
# Tworzenie katalogu
$katalog = "C:\Temp\MojeDane"
New-Item -Path $katalog -ItemType Directory

# Tworzenie pustego pliku tekstowego
$plik = "C:\Temp\MojeDane\test.txt"
New-Item -Path $plik -ItemType File

# Tworzenie pliku z zawartością (w jednej linii)
New-Item -Path "C:\Temp\MojeDane\opis.txt" -ItemType File -Value "To jest zawartość pliku"

# Usuwanie pliku
# Plik zostanie TRWALE usunięty (nie ma kosza!)
Remove-Item -Path "C:\Temp\MojeDane\test.txt"

# Usuwanie katalogu z całą zawartością
# -Recurse oznacza "również wszystkie pliki i podkatalogi w środku"
# -Force oznacza "nawet jeśli są zabezpieczone"
Remove-Item -Path "C:\Temp\MojeDane" -Recurse -Force
31/60
Lista plików w katalogu: Get-ChildItem
Slajd przedstawia cmdlet Get-ChildItem, parametry przeszukiwania rekursywnego (-Recurse) oraz właściwości obiektów FileInfo.

Trawersowanie folderów i zaawansowane filtry

  • Rola polecenia Get-ChildItem: wyświetla zawartość katalogu roboczego lub wskazanej ścieżki (funkcjonalny odpowiednik dir i ls).
  • Przeszukiwanie rekursywne (-Recurse): nakazuje przeszukanie wszystkich zagnieżdżonych podkatalogów w głąb struktury dyskowej.
  • Filtrowanie atrybutów (-File, -Directory): przełącznik -File ogranicza wyniki do plików, a -Directory wyłącznie do podfolderów.
  • Obiekty FileInfo i DirectoryInfo: każdy zwrócony element posiada precyzyjne właściwości: Length (rozmiar w bajtach), Extension, LastWriteTime.
Obiekt System.IO.FileInfo: klasa platformy .NET reprezentująca plik w systemie operacyjnym, udostępniająca właściwości metadanych oraz metody instancyjne do kopiowania, przenoszenia, otwierania i usuwania zasobu dyskowego.
# Lista plików w bieżącym katalogu (tam gdzie jesteś)
Get-ChildItem

# Lista wszystkich elementów (w tym ukryte pliki systemowe)
Get-ChildItem -Force

# Lista tylko plików (bez katalogów)
Get-ChildItem -File

# Lista tylko katalogów (bez plików)
Get-ChildItem -Directory

# Lista plików z filtrem - tylko pliki .txt
Get-ChildItem -Filter "*.txt"

# Lista z podkatalogów - przeszukaj rekursywnie
Get-ChildItem -Recurse

# Szukanie największych plików
# Sort-Object według rozmiaru (malejąco), weź pierwsze 10
Get-ChildItem -File | Sort-Object Length -Descending | Select-Object -First 10
32/60
Operatory porównania w PowerShell
Slajd omawia specyfikę operatorów porównań w PowerShellu (-eq, -ne, -gt, -lt, -like, -match) oraz brak stosowania symboli < i >.

Operatory myślnikowe i dopasowanie wzorców

  • Brak symboli matematycznych: znaki <, > są zarezerwowane dla przekierowań; PowerShell stosuje operatory z myślnikiem (-eq, -gt, -lt).
  • Równość i relacja wielkości: -eq (equal), -ne (not equal), -gt (greater than), -lt (less than), -ge (greater or equal), -le (less or equal).
  • Dopasowanie z maską (-like): obsługuje symbole wieloznaczne gwiazdki (*) i znaku zapytania (?) w dopasowywaniu łańcuchów znaków.
  • Wyrażenia regularne (-match): testuje łańcuch pod kątem dopasowania do pełnego wyrażenia regularnego (Regex) i wypełnia zmienną $Matches.
Operator relacyjny PowerShell: słowo kluczowe poprzedzone myślnikiem służące do porównywania dwóch obiektów. Domyślnie ignoruje wielkość liter (np. -eq); dodanie prefiksu c (np. -ceq, -cmatch) wymusza ścisłe rozróżnianie wielkości liter.
# Przykłady porównań
$a = 10
$b = 20

# Sprawdzenie równości (czy równe?)
if ($a -eq $b) { 
    "Równe" 
} else { 
    "Różne" 
}
# Wynik: Różne (bo 10 nie jest równe 20)

# Porównania liczbowe - zwracają $true lub $false
$a -gt 5    # True (10 > 5)
$a -lt 15   # True (10 < 15)
$a -ge 10   # True (10 >= 10)
$a -le 10   # True (10 <= 10)

# Porównania tekstowe
"kot" -eq "kot"   # True (teksty są identyczne)
"kot" -like "k*"  # True (wildcard: zaczyna się od "k")
"kot" -like "*t"  # True (wildcard: kończy się na "t")
33/60
Operatory logiczne
Slajd przedstawia operatory algebry Boole'a w PowerShellu, ich priorytety oraz reguły ewaluacji zwarciowej (short-circuit).

Łączenie warunków złożonych: -and, -or, -not

  • Iloczyn logiczny (-and): wyrażenie jest prawdziwe wyłącznie wtedy, gdy oba warunki składowe mają wartość logiczną $true.
  • Suma logiczna (-or): wyrażenie jest prawdziwe, jeżeli przynajmniej jeden z warunków składowych jest spełniony.
  • Negacja logiczna (-not lub !): odwraca wartość logiczną wyrażenia ($true staje się $false i odwrotnie).
  • Ewaluacja zwarciowa: jeżeli pierwszy warunek w -and jest fałszywy, drugi nie jest w ogóle ewaluowany przez parser, co oszczędza czas procesora.
Ewaluacja zwarciowa (short-circuit evaluation): semantyczna reguła wykonywania operacji logicznych polegająca na przerwaniu sprawdzania kolejnych członów wyrażenia, gdy wynik całego złożonego warunku jest już jednoznacznie zdeterminowany.
# Operator AND (i) - oba muszą być spełnione
$wiek = 25
$maPrawoJazdy = $true
if ($wiek -ge 18 -and $maPrawoJazdy) {
    Write-Host "Możesz prowadzić samochód"
}
# Wynik: Zostanie wyświetlone (obie warunki spełnione)

# Operator OR (lub) - przynajmniej jeden musi być spełniony
$jestStudentem = $true
$jestEmerytem = $false
if ($jestStudentem -or $jestEmerytem) {
    Write-Host "Przysługuje Ci zniżka"
}
# Wynik: Zostanie wyświetlone (przynajmniej jeden warunek spełniony)

# Operator NOT (nie) - odwraca wartość warunku
$czyPadaDeszcz = $false
if (-not $czyPadaDeszcz) {
    Write-Host "Możesz iść na spacer"
}
# Wynik: Zostanie wyświetlone (bo warunek był fałszywy, NOT go odwrócił)
34/60
Instrukcja warunkowa if, elseif, else
Slajd omawia konstrukcję instrukcji warunkowej if, składnię bloków kodu w nawiasach klamrowych {} oraz sekwencję elseif.

Rozgałęzianie przepływu wykonania programu

  • Składnia bazowa if: warunek logiczny umieszcza się w nawiasach okrągłych (warunek), a kod wykonywany w nawiasach klamrowych { ... }.
  • Gałęzie alternatywne (elseif): pozwala na sprawdzenie kolejnych warunków w sytuacji, gdy poprzedni test zwrócił fałsz.
  • Klauzula domyślna else: blok kodu wykonywany wtedy, gdy żaden z wcześniejszych warunków if ani elseif nie został spełniony.
  • Czytelność formatowania: obowiązek stosowania wcięć kodu (tabulator lub 4 spacje) w celu zachowania wysokiej przejrzystości logiki.
Instrukcja warunkowa if: podstawowa struktura sterująca w językach programowania pozwalająca na warunkowe wykonanie bloku instrukcji w zależności od logicznej wartości testowanego wyrażenia Boole'a.
# Przykład z ocenami - system oceniania
$ocena = 4

if ($ocena -ge 5) {
    # Jeśli ocena >= 5, wykonaj ten blok
    Write-Host "Celujący!"
} elseif ($ocena -ge 4) {
    # Jeśli ocena >= 4 (ale < 5), wykonaj ten blok
    Write-Host "Bardzo dobry"
} elseif ($ocena -ge 3) {
    # Jeśli ocena >= 3 (ale < 4), wykonaj ten blok
    Write-Host "Dobry"
} else {
    # Jeśli żaden z powyższych warunków nie był spełniony
    Write-Host "Niedostateczny"
}
# Wynik: Bardzo dobry (bo 4 >= 4)

# Sprawdzenie parzystości liczby
$liczba = 7
if ($liczba % 2 -eq 0) {
    # Operator % to modulo (reszta z dzielenia)
    # Jeśli 7 % 2 = 1 (nie 0), to liczba jest NIEPARZYSTA
    Write-Host "$liczba jest parzysta"
} else {
    Write-Host "$liczba jest nieparzysta"
}
# Wynik: 7 jest nieparzysta
35/60
Instrukcja wyboru: switch
Slajd przedstawia instrukcję switch w PowerShellu, dopasowywanie wartości wielokrotnych, wyrażenia regularne i klauzulę default.

Wielowariantowe podejmowanie decyzji

  • Przewaga nad serią if: znacząco czytelniejsza i bardziej elegancka konstrukcja przy testowaniu jednej zmiennej pod kątem wielu wartości.
  • Klauzula domyślna (default): blok wykonywany wtedy, gdy testowana wartość nie pasuje do żadnego ze zdefiniowanych przypadków.
  • Obsługa kolekcji: instrukcja switch potrafi przyjąć całą tablicę elementów i automatycznie przeiterować przez każdy z nich.
  • Zaawansowane przełączniki: opcje -Regex (dopasowanie do wyrażeń regularnych), -Wildcard oraz -File (parsowanie zawartości pliku).
Instrukcja wyboru (switch statement): wielobiegunowa struktura sterująca w PowerShellu realizująca dopasowywanie badanej wartości do listy wzorców, charakteryzująca się wbudowaną obsługą iteracji po kolekcjach oraz dopasowań regex.
# Przykład: sprawdzenie dnia tygodnia
# Pobierz aktualny dzień tygodnia (po angielsku)
$dzien = (Get-Date).DayOfWeek

switch ($dzien) {
    # Sprawdź każdy możliwy przypadek
    "Monday"    { Write-Host "Poniedziałek - czas zacząć tydzień!" }
    "Tuesday"   { Write-Host "Wtorek - jeszcze daleko do weekendu" }
    "Wednesday" { Write-Host "Środa - połowa tygodnia" }
    "Thursday"  { Write-Host "Czwartek - już prawie weekend!" }
    "Friday"    { Write-Host "Piątek - już weekend!" }
    "Saturday"  { Write-Host "Sobota - czas odpoczywać!" }
    "Sunday"    { Write-Host "Niedziela - niedziela!" }
    # default wykonuje się, gdy żaden przypadek nie pasuje
    default     { Write-Host "Nieznany dzień" }
}

# Przykład: rozpoznawanie typu pliku po rozszerzeniu
$plik = "dokument.pdf"
switch -Wildcard ($plik) {
    # Wildcard (* = dowolny tekst)
    "*.txt"     { Write-Host "Plik tekstowy" }
    "*.pdf"     { Write-Host "Dokument PDF" }
    "*.doc*"    { Write-Host "Dokument Word (doc lub docx)" }
    "*.xls*"    { Write-Host "Arkusz Excel" }
    default     { Write-Host "Nieznany typ pliku" }
}
36/60
Pętla: foreach
Slajd omawia pętlę foreach ($element in $kolekcja), zasady tworzenia zmiennej iteracyjnej oraz natychmiastowe przetwarzanie tablic.

Iteracja po elementach kolekcji w pamięci

  • Składnia pętli foreach: konstrukcja foreach ($element in $kolekcja) { ... } sekwencyjnie pobiera każdy obiekt ze zbioru danych.
  • Zmienna iteracyjna: tymczasowa zmienna ($element) reprezentuje bieżący przetwarzany obiekt wewnątrz ciała pętli.
  • Wysoka wydajność w pamięci: klasyczna pętla foreach działa bardzo szybko, gdy cała kolekcja danych jest już załadowana do pamięci RAM.
  • Zastosowanie: masowa konfiguracja kont użytkowników, przetwarzanie list maszyn wirtualnych czy sprawdzanie stanu dysków.
Pętla foreach: instrukcja sterująca języka PowerShell służąca do sekwencyjnego trawersowania wszystkich elementów kolekcji implementującej interfejs IEnumerable, gwarantująca jednokrotne odwiedzenie każdego obiektu.
# Przechodzenie przez tablicę owoców
$owoce = @("jabłko", "banan", "pomarańcza")

# foreach przechodzi przez każdy element tablicy
foreach ($owoc in $owoce) {
    # Dla każdego owoca wykonaj ten kod
    Write-Host "Lubię jeść: $owoc"
}
# Wynik:
# Lubię jeść: jabłko
# Lubię jeść: banan
# Lubię jeść: pomarańcza

# Obliczanie sumy liczb
$liczby = @(10, 20, 30, 40, 50)
$suma = 0  # Zaczynamy od zera
foreach ($liczba in $liczby) {
    $suma += $liczba  # Dodaj każdą liczbę do sumy
}
Write-Host "Suma: $suma"  # Wynik: 150

# Przechodzenie przez wyniki polecenia
# Pobierz 3 pierwsze procesy i przejdź przez nie
foreach ($proc in Get-Process | Select-Object -First 3) {
    Write-Host "Proces: $($proc.Name)"
}
37/60
Pętla: for
Slajd przedstawia tradycyjną pętlę for (inicjalizacja; warunek; krok), dedykowaną do zadań wymagających ścisłej kontroli indeksu liczbowego.

Klasyczna pętla licznikowa ze sterowaniem krokiem

  • Trójczłonowa budowa: for ($i = 0; $i -lt 10; $i++) składa się z inicjalizacji licznika, testu warunku oraz operacji kroku.
  • Ścisła kontrola indeksu: umożliwia łatwe iterowanie z krokiem różnym od jeden (np. $i += 2) lub odliczanie w dół ($i--).
  • Dostęp do sąsiednich elementów: posiadanie numerycznego indeksu $i pozwala na łatwe porównywanie elementu bieżącego z poprzednim ($tab[$i-1]).
  • Kiedy stosować: głównie przy operacjach na macierzach, algorytmach numerycznych lub gdy konieczna jest znajomość numeru iteracji.
Pętla for (counted loop): strukturalna pętla sterująca powtarzająca wykonanie bloku instrukcji określoną liczbę razy, kontrolowana przez zmienną licznikową modyfikowaną w każdym kroku iteracji.
# Wypisz liczby od 1 do 5
# for (start; warunek; krok)
for ($i = 1; $i -le 5; $i++) {
    # $i++ oznacza: zwiększ $i o 1 po każdym obiegu
    Write-Host "Licznik: $i"
}
# Wynik: 1, 2, 3, 4, 5

# Wypisz tylko liczby parzyste od 2 do 10
for ($i = 2; $i -le 10; $i += 2) {
    # $i += 2 oznacza: zwiększ $i o 2
    Write-Host "Liczba parzysta: $i"
}
# Wynik: 2, 4, 6, 8, 10

# Odliczanie od 10 do 1 (potem START!)
for ($i = 10; $i -ge 1; $i--) {
    # $i-- oznacza: zmniejsz $i o 1
    Write-Host "Odliczanie: $i..."
}
Write-Host "START!"
# Wynik: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, START!
38/60
Pętle: while i do-while
Slajd omawia pętle warunkowe while (sprawdzanie warunku na początku) oraz do-while / do-until (sprawdzanie warunku na końcu).

Powtarzanie instrukcji w oparciu o warunek logiczny

  • Pętla while: sprawdza warunek przed wykonaniem ciała pętli; jeśli warunek jest od początku fałszywy, pętla nie wykona się ani razu.
  • Pętla do-while: sprawdza warunek na końcu; gwarantuje, że ciało pętli zostanie wykonane co najmniej jeden raz.
  • Konstrukcja do-until: odmiana pętli do wykonująca się tak długo, dopóki zadany warunek jest fałszywy (zatrzymuje się przy prawdzie).
  • Ryzyko nieskończonej pętli: ciało pętli musi bezwzględnie modyfikować stan zmiennych warunku, aby zapobiec zawieszeniu skryptu.
Pętla warunkowa (while loop): struktura sterująca wielokrotnie wykonująca zadany blok instrukcji tak długo, jak długo stowarzyszone wyrażenie logiczne zachowuje wartość logiczną prawdy ($true).
# Pętla while - odliczanie
$licznik = 5
while ($licznik -gt 0) {
    # Dopóki licznik > 0, wykonuj kod
    Write-Host "Zostało: $licznik"
    $licznik--  # Zmniejsz licznik o 1
}
Write-Host "Koniec!"
# Wynik: Zostało: 5, 4, 3, 2, 1, Koniec!

# Pętla do-while - zawsze wykonuje się przynajmniej raz
# Pytaj użytkownika, aż poda "t" (tak)
do {
    # Ten kod wykona się ZAWSZE przynajmniej raz
    $odpowiedz = Read-Host "Czy chcesz kontynuować? (t/n)"
} while ($odpowiedz -ne "t")
# Pętla trwa, dopóki odpowiedź jest różna od "t"
Write-Host "Kontynuujemy!"

# UWAGA: do-while wykonuje się zawsze przynajmniej raz,
# nawet jeśli warunek jest fałszywy od początku!
39/60
Filtrowanie potokowe: Where-Object
Slajd przedstawia cmdlet Where-Object, mechanizm filtrowania obiektów w potoku oraz zmienną bieżącego elementu $_ ($PSItem).

Selekcja obiektów spełniających zadane kryteria

  • Rola polecenia Where-Object: przepuszcza przez potok wyłącznie te obiekty, które spełniają zadany warunek logiczny.
  • Zmienna $_ ($PSItem): specjalna zmienna automatyczna reprezentująca obiekt aktualnie badany na danym etapie potoku.
  • Składnia tradycyjna i uproszczona: tradycyjna: Where-Object { $_.CPU -gt 10 }; uproszczona: Where-Object CPU -gt 10.
  • Zasada 'filtruj po lewej': dobra praktyka nakazuje filtrowanie danych jak najwcześniej w potoku w celu oszczędzania zasobów.
Filtrowanie potokowe (pipeline filtering): proces selektywnego odrzucania obiektów niespełniających reguł predykatu w potoku danych, realizowany przez cmdlet Where-Object bez konieczności pobierania i buforowania całego zbioru w pamięci.
# Znajdź procesy, które używają więcej niż 10 CPU
# $_ to aktualny proces w potoku
Get-Process | Where-Object { $_.CPU -gt 10 }

# Znajdź usługi, które są uruchomione (Status = Running)
Get-Service | Where-Object { $_.Status -eq "Running" }

# Uproszczona składnia (PowerShell 3.0+) - bez $_
# Możesz pisać krócej:
Get-Process | Where-Object CPU -gt 10
Get-Service | Where-Object Status -eq "Running"

# Wiele warunków jednocześnie (AND)
Get-Process | Where-Object { 
    ($_.CPU -gt 10) -and ($_.WorkingSet -gt 100MB) 
}
# Wynik: procesy, które spełniają OBA warunki jednocześnie
40/60
Wybieranie właściwości: Select-Object
Slajd omawia cmdlet Select-Object, wybieranie określonych właściwości (-Property), pobieranie pierwszych N elementów (-First) oraz usuwanie duplikatów (-Unique).

Rzutowanie kolumn, limitowanie wyników i właściwości wyliczane

  • Rola polecenia Select-Object: tworzy nowe obiekty zawierające wyłącznie wskazany podzbiór właściwości obiektów wejściowych.
  • Limitowanie wyników (-First, -Last): parametr -First 5 pobiera 5 pierwszych obiektów i natychmiast przerywa działanie potoku w celu optymalizacji.
  • Eliminacja duplikatów (-Unique): odrzuca powtarzające się wartości, zwracając wyłącznie unikalne rekordy danych.
  • Właściwości wyliczane (Calculated Properties): możliwość tworzenia nowych dynamicznych pól w locie: @{ Name = 'RozmiarMB'; Expression = { $_.Length / 1MB } }.
Rzutowanie właściwości (projection / Select-Object): operacja przekształcania strumienia obiektów wejściowych w nowe instancje obiektów niestandardowych (PSCustomObject) zawierających wyłącznie określone pola, realizująca zasadę projekcji danych.
# Wybór tylko określonych właściwości (kolumn)
# Zamiast wszystkich danych, weź tylko Name, Id i CPU
Get-Process | Select-Object Name, Id, CPU

# Pierwsze 5 elementów
Get-Process | Select-Object -First 5

# Ostatnie 5 elementów
Get-Process | Select-Object -Last 5

# Tworzenie nowej właściwości (obliczona)
# Konwertuj pamięć z bajtów na megabajty
Get-Process | Select-Object Name, @{Name="MemoryMB"; Expression={$_.WorkingSet / 1MB}}

# Sortowanie i wybór TOP 5 największych procesów
Get-Process | Sort-Object WorkingSet -Descending | Select-Object -First 5
41/60
Sortowanie obiektów: Sort-Object
Slajd przedstawia cmdlet Sort-Object, sortowanie rosnące i malejące (-Descending) oraz sortowanie wielopoziomowe po wielu polach.

Uporządkowanie danych według zadanych właściwości

  • Rola polecenia Sort-Object: porządkuje strumień obiektów na podstawie wartości wskazanych właściwości.
  • Sortowanie malejące (-Descending): odwraca domyślny porządek rosnący, umieszczając najwyższe wartości na początku listy.
  • Sortowanie wielopoziomowe: podanie wielu właściwości (np. -Property Status, Name) sortuje według pierwszej kolumny, a przy równości według drugiej.
  • Konieczność buforowania: Sort-Object musi wczytać wszystkie obiekty z potoku do pamięci przed rozpoczęciem sortowania (operacja blokująca potok).
Sortowanie potokowe (Sort-Object): blokująca operacja potoku polegająca na zgromadzeniu wszystkich obiektów wejściowych w buforze pamięci i ułożeniu ich w określonym porządku alfanumerycznym lub numerycznym na podstawie zadanego klucza sortowania.
# Sortowanie rosnące (domyślne) - od najmniejszego do największego
Get-Process | Sort-Object CPU

# Sortowanie malejące - od największego do najmniejszego
Get-Process | Sort-Object CPU -Descending

# Sortowanie po wielu właściwościach jednocześnie
# Najpierw sortuj po WorkingSet, potem po CPU
Get-Process | Sort-Object { $_.WorkingSet }, CPU -Descending

# Sortowanie tekstów alfabetycznie
$imiona = @("Kasia", "Ania", "Basia", "Ewa")
$imiona | Sort-Object
# Wynik: Ania, Basia, Ewa, Kasia (alfabetycznie)

# Sortowanie liczb
$liczby = @(5, 2, 8, 1, 9)
$liczby | Sort-Object
# Wynik: 1, 2, 5, 8, 9 (rosnąco)

# Sortowanie liczb malejąco
$liczby | Sort-Object -Descending
# Wynik: 9, 8, 5, 2, 1
42/60
Akcje potokowe: ForEach-Object
Slajd omawia cmdlet ForEach-Object, różnice w stosunku do pętli foreach oraz przetwarzanie obiektów w locie wewnątrz potoku.

Przetwarzanie strumieniowe obiekt po obiekcie

  • Rola polecenia ForEach-Object: wykonuje wskazany blok skryptu dla każdego pojedynczego obiektu przepływającego przez potok.
  • Strumieniowy charakter: w przeciwieństwie do pętli foreach, cmdlet ten nie wymaga wcześniejszego załadowania całej kolekcji do pamięci RAM.
  • Wieloblokowa konstrukcja: wspiera bloki -Begin (inicjalizacja), -Process (wykonywany dla każdego obiektu) oraz -End (podsumowanie).
  • Równoległość w PowerShell 7: parametr -Parallel umożliwia wielowątkowe, równoczesne wykonywanie akcji na wielu obiektach.
Przetwarzanie strumieniowe potoku (ForEach-Object): wbudowany cmdlet realizujący funkcję mapowania (map), który pobiera obiekty z wejścia potoku i wykonuje na nich operacje sekwencyjnie w miarę ich napływania, minimalizując zużycie pamięci operacyjnej.
# ForEach-Object w potoku - skrót %
# Wyświetl nazwy wszystkich procesów
Get-Process | ForEach-Object { Write-Host $_.Name }

# Skrócony zapis (symbol %)
Get-Process | % { Write-Host $_.Name }

# Złożona akcja - dla każdego procesu wykonaj wiele operacji
Get-Process | ForEach-Object {
    # Pobierz dane procesu
    $name = $_.Name
    $cpu = [math]::Round($_.CPU, 2)  # Zaokrąglij do 2 miejsc
    
    # Wyświetl sformatowany tekst
    Write-Host "Proces '$name' używa $cpu sekund CPU"
}
43/60
Tworzenie funkcji
Slajd przedstawia tworzenie wielokrotnego użytku podprogramów za pomocą słowa kluczowego function oraz reguły przekazywania wyników.

Podstawowa deklaracja, zasięg i zwracanie wartości

  • Słowo kluczowe function: deklaracja funkcji o określonej nazwie zgodnej z konwencją Verb-Noun (np. Get-Raport).
  • Automatyczne zwracanie wartości: każde wyrażenie lub komenda wewnątrz funkcji generująca obiekt na wyjściu niejawnie zwraca go do potoku.
  • Słowo kluczowe return: kończy natychmiast wykonywanie funkcji i opcjonalnie przekazuje wartość wynikową.
  • Zasięg zmiennych (scope): zmienne tworzone wewnątrz funkcji są domyślnie lokalne i znikają po zakończeniu jej działania.
Funkcja w PowerShellu: nazwany blok skryptu zdefiniowany w pamięci powłoki za pomocą słowa kluczowego function, przyjmujący parametry wejściowe i zwracający obiekty do potoku, stanowiący podstawową jednostkę modularyzacji kodu proceduralnego.
# Prosta funkcja - bez parametrów
function SayHello {
    # Cały kod funkcji w nawiasach klamrowych
    Write-Host "Cześć! Witaj w PowerShell!"
}

# Wywołanie funkcji - po prostu wpisz jej nazwę
SayHello  # Wyświetli: Cześć! Witaj w PowerShell!
SayHello  # Możesz wywołać wielokrotnie

# Funkcja z parametrem
function Przywitania {
    param($imie)  # Parametr o nazwie $imie
    Write-Host "Cześć, $imie!"
}

# Wywołanie z parametrem
Przywitania -imie "Anna"   # Wynik: Cześć, Anna!
Przywitania -imie "Jan"     # Wynik: Cześć, Jan!

# Funkcja zwracająca wartość
function Dodaj {
    param($a, $b)
    # return zwraca wartość
    return $a + $b
}

# Pobierz wynik funkcji
$wynik = Dodaj -a 5 -b 3
Write-Host "5 + 3 = $wynik"  # Wynik: 5 + 3 = 8
44/60
Zaawansowane parametry funkcji
Slajd omawia przekształcanie prostych funkcji w zaawansowane cmdlety skryptowe za pomocą atrybutów CmdletBinding i Parameter.

Atrybuty [CmdletBinding()] i [Parameter()]

  • Atrybut [CmdletBinding()]: wyposaża funkcję w standardowe mechanizmy zaawansowanych cmdletów, m.in. parametry -Verbose i -Debug.
  • Atrybut [Parameter(Mandatory=$true)]: wymusza podanie parametru przez użytkownika; w przypadku braku powłoka sama wyświetli monit.
  • Wsparcie dla potoku (ValueFromPipeline): umożliwia bezpośrednie przyjmowanie danych wejściowych wędrujących potokiem z innych poleceń.
  • Zestawy parametrów (ParameterSetName): pozwala na definiowanie wzajemnie wykluczających się grup opcji wewnątrz jednego polecenia.
Zaawansowana funkcja (advanced function / script cmdlet): funkcja skryptowa wyposażona w atrybut [CmdletBinding()], dzięki któremu zachowuje się identycznie jak skompilowany cmdlet platformy .NET, obsługując wspólne parametry systemowe oraz zaawansowaną walidację argumentów.
# Funkcja z wieloma parametrami i wartościami domyślnymi
function Powitanie {
    param(
        [string]$Imie = "Gościu",      # Parametr tekstowy z domyślną wartością
        [int]$Wiek = 18,                # Parametr liczbowy z domyślną wartością
        [switch]$JestEmerytem            # Przełącznik (switch) - albo jest, albo nie
    )
    
    Write-Host "Cześć, $Imie!"
    Write-Host "Masz $Wiek lat."
    
    # Jeśli przełącznik -JestEmerytem został podany, wykonaj kod
    if ($JestEmerytem) {
        Write-Host "Jesteś emerytem!"
    }
}

# Różne sposoby wywołania:

# Wszystkie parametry
Powitanie -Imie "Anna" -Wiek 65 -JestEmerytem
# Wynik: Cześć, Anna! Masz 65 lat. Jesteś emerytem!

# Tylko niektóre parametry
Powitanie -Imie "Kasia" -Wiek 25
# Wynik: Cześć, Kasia! Masz 25 lat.

# Tylko z domyślnymi wartościami
Powitanie
# Wynik: Cześć, Gościu! Masz 18 lat.
45/60
Obsługa błędów: try, catch, finally
Slajd wyjaśnia architekturę obsługi wyjątków w PowerShellu, różnicę między błędami przerywającymi a nieprzerywającymi oraz blok finally.

Pułapka błędów nieprzerywających i -ErrorAction Stop

  • Blok try / catch: kod chroniony umieszcza się w sekcji try; w przypadku wystąpienia błędu sterowanie przechodzi do bloku catch.
  • Błędy nieprzerywające (non-terminating): większość cmdletów generuje błędy nieprzerywające, których blok catch domyślnie NIE przechwytuje.
  • Konieczność -ErrorAction Stop: wymuszenie zamiany błędu zwykłego na wyjątek przerywający parametrem -ErrorAction Stop.
  • Sekcja czyszcząca finally: kod w bloku finally wykonuje się ZAWSZE, niezależnie od tego, czy wystąpił błąd (zamykanie plików, połączeń).
Wyjątek przerywający (terminating error): krytyczny stan błędu w środowisku PowerShell, który natychmiast przerywa wykonywanie bieżącego potoku i przekazuje sterowanie do najbliższego bloku obsługi wyjątków catch.
# Próba odczytu nieistniejącego pliku
try {
    # Ten kod może spowodować błąd
    # -ErrorAction Stop wymusza zgłoszenie błędu
    $zawartosc = Get-Content -Path "C:\NieIstnieje\plik.txt" -ErrorAction Stop
    Write-Host "Plik istnieje: $zawartosc"
}
catch {
    # Ten kod wykona się TYLKO gdy wystąpi błąd
    Write-Host "BŁĄD: Nie można odczytać pliku!" -ForegroundColor Red
    # $_ to obiekt błędu z szczegółami
    Write-Host "Szczegóły: $($_.Exception.Message)"
}
finally {
    # Ten kod wykona się ZAWSZE - niezależnie od błędu
    Write-Host "Koniec operacji."
}
46/60
Operatory łańcuchowe i specjalne
Slajd omawia zaawansowane operatory manipulacji łańcuchami znaków: łączenie (-join), dzielenie (-split), podmianę (-replace) oraz formatowanie ciągów (-f).

Formatowanie tekstu: -join, -split, -replace i operator -f

  • Operator łączenia (-join): scala tablicę elementów w jeden ciąg tekstowy z opcjonalnym separatorem: $tablica -join ', '.
  • Operator podziału (-split): rozbija ciąg znaków na tablicę podciągów według zadanego znaku lub wyrażenia regularnego.
  • Operator zamiany (-replace): wyszukuje wzorzec tekstowy lub regex i zastępuje go nowym łańcuchem znaków.
  • Operator formatowania (-f): zaawansowane formatowanie oparte na standardzie string.Format z platformy .NET: '{0}: {1:C2}' -f $nazwa, $cena.
Operator formatowania ciągów (-f): wbudowany operator PowerShell integrujący mechanizm formatowania kompozytowego platformy .NET (System.String.Format), umożliwiający precyzyjne wstawianie i zaokrąglanie wartości liczbowych, walutowych oraz dat w szablonie tekstu.
# Operator -match - wyszukiwanie wzorca w tekście (wyrażenie regularne)
$tekst = "Mój email to jan@example.com"
if ($tekst -match '\S+@\S+\.\S+') {
    Write-Host "Znaleziono adres email!"
}
# Wzorzec \S+@\S+\.\S+ oznacza: tekst@tekst.tekst

# Operator -replace - zamiana tekstu
$tekst = "Cześć Jan!"
$nowy = $tekst -replace "Jan", "Anna"
Write-Host $nowy  # Wynik: Cześć Anna!

# Zamień wszystkie cyfry na X
$tekst = "Mam 5 jabłek i 3 gruszki"
$tekst -replace '\d', 'X'
# Wynik: Mam X jabłek i X gruszek

# Operator -in - sprawdza, czy element jest w tablicy
$kolory = @("czerwony", "zielony", "niebieski")
if ("czerwony" -in $kolory) {
    Write-Host "Czerwony jest na liście!"
}

# Operator zakresu - generuje ciąg liczb
1..10  # Wynik: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
47/60
Formatowanie wyjścia
Slajd przedstawia cmdlety formatujące widok danych w konsoli oraz wyjaśnia regułę umieszczania ich wyłącznie na samym końcu potoku.

Format-Table, Format-List i kardynalna reguła potoku

  • Polecenie Format-Table (ft): prezentuje dane w postaci zwartej tabeli; przełącznik -AutoSize dopasowuje szerokość kolumn.
  • Polecenie Format-List (fl): wyświetla każdą właściwość w osobnym wierszu; fl * ujawnia wszystkie ukryte pola obiektu.
  • Polecenie Out-GridView (ogv): otwiera interaktywne graficzne okno z możliwością szybkiego sortowania i filtrowania wyników.
  • Kardynalna zasada formatowania: cmdlety Format-* zamieniają obiekty na instrukcje renderowania tekstu; używaj ich ZAWSZE na samym końcu potoku!
Polecenia formatujące (formatting cmdlets): grupa cmdletów powłoki (Format-Table, Format-List, Format-Wide) przekształcających surowe obiekty w specjalne struktury formatujące przeznaczone wyłącznie do prezentacji na ekranie, niszczących oryginalną strukturę danych obiektu .NET.
# Format-Table - wyświetl jako tabela
# Domyślny format dla list
Get-Process | Select-Object Name, Id, CPU | Format-Table

# Format-Table z dopasowaniem szerokości kolumn
# -AutoSize dopasowuje szerokość do danych
Get-Service | Where-Object Status -eq "Running" | Format-Table -AutoSize

# Format-List - wyświetl jako listę właściwości
# Przydatne, gdy obiekt ma wiele właściwości
Get-Process | Select-Object -First 1 | Format-List *

# Eksport do pliku CSV
Get-Process | Export-Csv -Path "C:\Temp\procesy.csv" -NoTypeInformation

# Eksport do pliku HTML (tabela HTML)
Get-Process | ConvertTo-Html | Out-File "C:\Temp\procesy.html"
48/60
Projekt 1: raport plików z filtrowaniem
Slajd demonstruje implementację skryptu inwentaryzującego pliki o dużym rozmiarze, sortującego wyniki i eksportującego dane do formatu CSV.

Praktyczny skrypt inwentaryzacji zasobów dyskowych

  • Cel skryptu: przeszukanie wskazanego katalogu i odnalezienie plików przekraczających zadany próg wielkości (np. 100 MB).
  • Pobranie i filtracja: użycie Get-ChildItem -Recurse oraz Where-Object Length -gt 100MB.
  • Właściwości wyliczane: przeliczenie rozmiaru z surowych bajtów na czytelne megabajty w Select-Object.
  • Eksport do CSV: użycie Export-Csv -Path 'raport.csv' -NoTypeInformation do trwałego zapisu wyników audytu.
Eksport do CSV (Export-Csv): cmdlet przekształcający kolekcję obiektów w potoku na ustandaryzowany plik tekstowy wartości rozdzielanych przecinkami, automatycznie tworzący wiersz nagłówka na podstawie nazw właściwości obiektów.
# =============================================
# Skrypt: Generowanie raportu z plików
# =============================================

param(
    [string]$Sciezka = "C:\Windows\System32",    # Katalog do przeszukania
    [string]$Filtr = "*.dll",                     # Szukaj tylko plików .dll
    [int]$MinRozmiarKB = 100                     # Minimalny rozmiar w KB
)

Write-Host "Szukam plików: $Filtr"
Write-Host "W katalogu: $Sciezka"
Write-Host "Minimalny rozmiar: $MinRozmiarKB KB"

# Znajdź pliki spełniające kryteria
$pliki = Get-ChildItem -Path $Sciezka -Filter $Filtr -File -ErrorAction SilentlyContinue |
         Where-Object { $_.Length -gt ($MinRozmiarKB * 1024) } |  # Konwertuj KB na bajty
         Sort-Object Length -Descending

Write-Host "Znaleziono $($pliki.Count) plików"

# Wyświetl listę z rozmiarami
foreach ($plik in $pliki) {
    $rozmiarMB = [math]::Round($plik.Length / 1MB, 2)  # Zaokrąglij do 2 miejsc
    Write-Host "$($plik.Name) - $rozmiarMB MB"
}
49/60
Projekt 2: monitorowanie usług systemowych
Slajd przedstawia konstrukcję skryptu nadzorującego stan kluczowych usług systemowych z automatyczną próbą restartu w razie awarii.

Praktyczny skrypt audytu i restartu usług Windows

  • Cel skryptu: weryfikacja czy wskazane usługi krytyczne (np. Spooler, W32Time) znajdują się w stanie Running.
  • Inspekcja stanu (Get-Service): pobranie obiektów usług i zbadanie właściwości Status w pętli warunkowej.
  • Automatyczna naprawa: wywołanie Start-Service w przypadku wykrycia zatrzymania usługi.
  • Raportowanie zdarzeń: generowanie czytelnych komunikatów o podjętych akcjach naprawczych za pomocą Write-Host lub wpisu do logu.
Usługa systemowa Windows (Windows Service): długodziałający proces wykonywany w tle bez interfejsu graficznego użytkownika, zarządzany przez systemowy Menedżer Kontroli Usług (Service Control Manager - SCM).
# =============================================
# Skrypt: Monitorowanie usług Windows
# =============================================

param(
    [string[]]$Uslugi = @("Spooler", "W32Time", "EventLog", "BITS")
)

Write-Host "Data sprawdzenia: $(Get-Date)"
Write-Host ""

$wszystkieOK = $true

# Sprawdź każdą usługę z listy
foreach ($nazwa in $Uslugi) {
    # Spróbuj pobrać usługę (jeśli nie istnieje, zignoruj błąd)
    $usluga = Get-Service -Name $nazwa -ErrorAction SilentlyContinue
    
    if ($usluga) {
        # Sprawdź status usługi
        if ($usluga.Status -eq "Running") {
            Write-Host "[OK] $($usluga.DisplayName)" -ForegroundColor Green
        } else {
            # Usługa nie działa!
            Write-Host "[PROBLEM] $($usluga.DisplayName) ($($usluga.Status))" -ForegroundColor Red
            $wszystkieOK = $false
        }
    } else {
        # Usługa nie istnieje w systemie
        Write-Host "[BRAK] Usługa '$nazwa' nie znaleziona" -ForegroundColor Yellow
    }
}

# Podsumowanie
if ($wszystkieOK) {
    Write-Host "Wszystkie usługi działają poprawnie!" -ForegroundColor Green
} else {
    Write-Host "UWAGA: Niektóre usługi wymagają uwagi!" -ForegroundColor Red
}
50/60
Projekt 3: prosta kopia zapasowa
Slajd prezentuje implementację skryptu tworzącego archiwum kopii zapasowej ze stemplem czasu oraz kompresją do formatu ZIP.

Automatyzacja backupu plików z unikalnym znacznikiem czasu

  • Cel skryptu: zabezpieczenie wskazanego folderu projektowego przed utratą danych w postaci skompresowanego archiwum.
  • Generowanie znacznika czasu: użycie Get-Date -Format 'yyyyMMdd_HHmmss' gwarantuje unikalność nazwy pliku kopii.
  • Kompresja danych (Compress-Archive): wbudowany cmdlet pakujący katalog źródłowy do archiwum w standardzie .zip.
  • Weryfikacja sukcesu: sprawdzenie obecności nowo utworzonego archiwum poleceniem Test-Path.
Archiwizacja danych (Compress-Archive): wbudowany cmdlet środowiska PowerShell tworzący skompresowane pakiety plików w formacie ZIP, wykorzystujący natywne algorytmy kompresji platformy .NET.
# =============================================
# Skrypt: Prosta kopia zapasowa
# =============================================

param(
    [Parameter(Mandatory=$true)]       # Parametr OBOWIĄZKOWY
    [string]$Zrodlo,
    [string]$Cel = "C:\Backup"       # Domyślna lokalizacja backupu
)

# Sprawdź, czy katalog źródłowy istnieje
if (-not (Test-Path $Zrodlo)) {
    Write-Host "BŁĄD: Katalog źródłowy nie istnieje!" -ForegroundColor Red
    exit 1  # Zakończ skrypt z kodem błędu 1
}

# Utwórz katalog docelowy, jeśli nie istnieje
if (-not (Test-Path $Cel)) {
    New-Item -Path $Cel -ItemType Directory | Out-Null
}

# Generuj unikalną nazwę folderu z datą i godziną
$data = Get-Date -Format "yyyy-MM-dd_HH-mm"
$celBackup = Join-Path $Cel "Backup_$data"
New-Item -Path $celBackup -ItemType Directory | Out-Null

# Kopiuj wszystkie pliki z źródła do backupu
Copy-Item -Path "$Zrodlo\*" -Destination $celBackup -Recurse

Write-Host "Kopia zapasowa utworzona!" -ForegroundColor Green
Write-Host "Lokalizacja: $celBackup"
51/60
Projekt 4: czyszczenie plików tymczasowych
Slajd omawia implementację skryptu bezpiecznego usuwania przestarzałych plików logów i folderów tymczasowych starszych niż N dni.

Skrypt konserwacyjny z weryfikacją wieku plików

  • Cel skryptu: zwolnienie przestrzeni dyskowej poprzez usunięcie plików tymczasowych nieużywanych od ponad 30 dni.
  • Wyliczenie daty granicznej: zastosowanie metody (Get-Date).AddDays(-30) do ustalenia progu czasowego retencji.
  • Filtrowanie po LastWriteTime: Where-Object LastWriteTime -lt $dataGraniczna precyzyjnie wskazuje stare pliki.
  • Bezpieczne usuwanie: wywołanie Remove-Item -Force z opcjonalnym raportowaniem liczby usuniętych megabajtów.
Retencja danych (data retention policy): zestaw sformalizowanych reguł określających maksymalny czas przechowywania danych i plików tymczasowych w systemie komputerowym przed ich trwałym usunięciem w celu optymalizacji zasobów.
# =============================================
# Skrypt: Czyszczenie plików tymczasowych
# =============================================

param(
    [int]$DniDoUsuniecia = 7,       # Usuwaj pliki starsze niż 7 dni
    [switch]$Symulacja                # Tryb symulacji - tylko pokazuj, nie usuwaj
)

Write-Host "Usuwam pliki starsze niż: $DniDoUsuniecia dni"
if ($Symulacja) {
    Write-Host "TRYB: SYMULACJA (nic nie będzie usunięte)" -ForegroundColor Yellow
}

# Lista lokalizacji do sprawdzenia
$lokalizacje = @($env:TEMP, "C:\Windows\Temp")
$calyLicznik = 0

# Przejdź przez każdą lokalizację
foreach ($lokalizacja in $lokalizacje) {
    if (Test-Path $lokalizacja) {
        # Znajdź stare pliki (LastWriteTime < dzisiaj - X dni)
        $starePliki = Get-ChildItem -Path $lokalizacja -Recurse -File -ErrorAction SilentlyContinue |
                      Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-$DniDoUsuniecia) }
        
        foreach ($plik in $starePliki) {
            Write-Host "  - $($plik.Name)"
            if (-not $Symulacja) {
                # Faktycznie usuń plik (tylko jeśli NIE jest tryb symulacji)
                Remove-Item -Path $plik.FullName -Force -ErrorAction SilentlyContinue
            }
            $calyLicznik++
        }
    }
}

Write-Host "Znaleziono plików do usunięcia: $calyLicznik"
52/60
Aliasy: skróty poleceń
Slajd przedstawia mechanizm aliasów, polecenie Get-Alias oraz regułę wykluczającą aliasy ze skryptów produkcyjnych.

Przyspieszanie pracy w konsoli i zakaz stosowania w skryptach

  • Koncepcja aliasu: krótka alternatywna nazwa przypisana do pełnego cmdletu (np. dir -> Get-ChildItem, ? -> Where-Object).
  • Wyszukiwanie aliasów (Get-Alias): pozwala sprawdzić, do jakiego oficjalnego cmdletu odwołuje się dany skrót lub jakie aliasy posiada cmdlet.
  • Kompatybilność z uniksami: wbudowane aliasy ls, cp, rm, cat ułatwiają początkową adaptację użytkownikom systemów Linux.
  • Zakaz w skryptach produkcyjnych: w plikach .ps1 należy ZAWSZE stosować pełne nazwy cmdletów, aby zachować czytelność i wsparcie analizatorów kodu.
Alias w PowerShellu: proste mapowanie nazwy tekstowej na docelowy cmdlet, funkcję lub plik wykonywalny, przyspieszające interaktywne wpisywanie instrukcji w konsoli terminala.
# Sprawdzenie, jakiemu poleceniu odpowiada alias
Get-Alias ls      # Pokaże: ls -> Get-ChildItem
Get-Alias cd      # Pokaże: cd -> Set-Location

# Tworzenie własnego aliasu
Set-Alias -Name gp -Value Get-Process
gp  # To samo, co Get-Process - ale krócej!

# Używanie w potoku
ls | ? { $_.Length -gt 1MB }   # ? = Where-Object
ls | % { $_.Name }              # % = ForEach-Object
53/60
Zmienne automatyczne: podsumowanie
Slajd podsumowuje najważniejsze zmienne automatyczne utrzymywane przez silnik PowerShella: $_, $?, $LASTEXITCODE oraz $PSScriptRoot.

Wbudowane zmienne stanu powłoki

  • Bieżący obiekt potoku ($_ / $PSItem): reprezentuje element aktualnie przetwarzany wewnątrz bloków Where-Object i ForEach-Object.
  • Status powodzenia ($?): wartość logiczna [bool] informująca, czy ostatnie wykonane polecenie zakończyło się sukcesem ($true) czy błędem ($false).
  • Kod wyjścia procesów zewnętrznych ($LASTEXITCODE): przechowuje numeryczny kod powrotu ostatniego programu natywnego (np. robocopy, git, ping).
  • Katalog bieżącego skryptu ($PSScriptRoot): bezwzględna ścieżka do folderu zawierającego aktualnie wykonywany plik skryptu .ps1.
Zmienna automatyczna (automatic variable): predefiniowana, zarządzana przez silnik PowerShell zmienna przechowująca stan środowiska, wyniki wykonania ostatnich operacji lub kontekst potoku, w większości dostępna wyłącznie w trybie tylko do odczytu.
# Wersja PowerShell
$PSVersionTable.PSVersion
# Wynik: np. 5.1.22621.1

# Aktualny katalog
$PWD
# Wynik: np. C:\Users\Student

# Katalog domowy użytkownika
$HOME
# Wynik: np. C:\Users\Student

# Ostatni błąd w sesji
$Error[0]
# Wynik: szczegóły ostatniego błędu
54/60
Zasady wykonywania skryptów: ExecutionPolicy
Slajd omawia poziomy polityki wykonywania skryptów (Restricted, RemoteSigned, Bypass) oraz wyjaśnia jej rzeczywistą rolę w systemie Windows.

Zabezpieczenie przed pomyłkami a granica bezpieczeństwa

  • Rola ExecutionPolicy: mechanizm ochrony przed przypadkowym uruchomieniem nieznanych skryptów przez niedoświadczonych użytkowników.
  • Nie jest to bariera bezpieczeństwa: polityka nie jest kryptograficznym zabezpieczeniem, gdyż każdy użytkownik może uruchomić: pwsh -ExecutionPolicy Bypass.
  • Poziom Restricted: domyślny tryb w starszych systemach klienckich Windows blokujący uruchamianie jakichkolwiek skryptów .ps1.
  • Poziom RemoteSigned: rekomendowany standard korporacyjny: skrypty lokalne działają swobodnie, skrypty z Internetu wymagają cyfrowego podpisu.
Polityka wykonywania skryptów (Execution Policy): konfigurowalna flaga bezpieczeństwa w środowisku Windows określająca reguły wczytywania plików konfiguracyjnych i uruchamiania skryptów PowerShell, mająca na celu zapobieganie nieświadomemu wykonaniu złośliwego kodu.
# Sprawdź aktualne zasady
Get-ExecutionPolicy
# Wynik: najprawdopodobniej Restricted

# Zmień zasady (wymaga uruchomienia jako Administrator!)
Set-ExecutionPolicy RemoteSigned

# Tymczasowo zmień zasady tylko dla bieżącej sesji:
# (działa tylko, dopóki nie zamkniesz PowerShell)
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass

# Uruchomienie konkretnego skryptu bez zmiany zasad:
powershell.exe -ExecutionPolicy Bypass -File .\skrypt.ps1
55/60
Moduły PowerShell
Slajd omawia architekturę modułów (.psm1), zarządzanie pakietami (Get-Module, Import-Module, Install-Module) oraz repozytorium PowerShell Gallery.

Rozszerzanie możliwości powłoki i PowerShell Gallery

  • Pojęcie modułu: pakiet zawierający powiązane tematycznie cmdlety, funkcje, dostawców i pliki pomocy spakowane w jedną całość.
  • Autouzupełnianie modułów: PowerShell od wersji 3.0 automatycznie ładuje moduł w momencie pierwszego wywołania któregokolwiek z jego cmdletów.
  • Repozytorium PowerShell Gallery: centralny, publiczny katalog rozszerzeń udostępniany przez firmę Microsoft (ponad 10 000 gotowych modułów).
  • Instalacja modułów (Install-Module): pobiera i instaluje moduł bezpośrednio z Internetu jednym poleceniem (np. Install-Module -Name Az).
Moduł PowerShell (PSModule): podstawowa jednostka dystrybucji i współdzielenia kodu w ekosystemie PowerShell, grupująca skrypty, zestawy binarne oraz zasoby dokumentacji w spójną całość zarządzaną przez instalator pakietów PowerShellGet.
# Sprawdź zainstalowane moduły
Get-Module -ListAvailable

# Załaduj moduł (aby używać jego poleceń)
Import-Module -Name NazwaModulu

# Zobacz, jakie polecenia udostępnia moduł
Get-Command -Module NazwaModulu

# Lista załadowanych modułów (aktualnie używanych)
Get-Module

# Odładuj moduł (gdy już nie potrzebujesz)
Remove-Module -Name NazwaModulu
56/60
Słownik podstawowych pojęć
Slajd rekapituluje fundamentalną terminologię języka PowerShell: Cmdlet, Pipeline, Object, Property, Method, Provider oraz ScriptBlock.

Zestawienie terminologii

  • Cmdlet i Pipeline: obiektowa komenda powłoki oraz potok przesyłający silnie typowane instancje klas środowiska wykonawczego .NET.
  • Obiekt, właściwość i metoda: obiekt jako byt programistyczny, właściwość jako jego cecha danych, metoda jako akcja wykonywalna.
  • Dostawca (PSProvider): mechanizm prezentacji dowolnych zasobów systemowych jako wirtualnych dysków w strukturze ścieżek.
  • Blok skryptu (ScriptBlock): niewykonany fragment kodu ujęty w nawiasy klamrowe { ... }, przekazywany jako parametr do potoku.
Blok skryptu (ScriptBlock): obiekt platformy .NET reprezentujący skompilowany fragment kodu źródłowego języka PowerShell, który może być przechowywany w zmiennej, przekazywany jako parametr lub wykonywany dynamicznie operatorem &.
  +-------------------------------------------------------+
  |                 SŁOWNIK POJĘĆ POWERSHELL              |
  +-------------------------------------------------------+
  | Cmdlet:      lekka komenda powłoki wbudowana w .NET   |
  | Pipeline:    potok przesyłający silnie typowane dane  |
  | Property:    właściwość obiektu (np. Id, Name, Status)|
  | Method:      akcja obiektu (np. Kill(), Start(), Stop)|
  +-------------------------------------------------------+
        
57/60
Ściągawka: najważniejsze polecenia
Slajd prezentuje podręczną ściągawkę najważniejszych cmdletów administracyjnych uporządkowanych według kategorii funkcjonalnych.

Kompilacja kluczowych narzędzi systemowych

  • Odkrywanie środowiska: Get-Command (wyszukiwanie), Get-Help (dokumentacja), Get-Member (badanie metod i właściwości).
  • Przetwarzanie w potoku: Where-Object (filtrowanie), Select-Object (wybieranie pól), Sort-Object (sortowanie), ForEach-Object (akcja).
  • System plików: Get-ChildItem (listowanie), Test-Path (istnienie), New-Item (tworzenie), Remove-Item (usuwanie).
  • Wejście / wyjście danych: Get-Content (czytanie), Set-Content / Out-File (zapis), Export-Csv (eksport), Read-Host (monit).
Zestawienie poleceń podstawowych (core cmdlets): kanoniczna grupa wbudowanych poleceń modułu Microsoft.PowerShell.Core oraz Microsoft.PowerShell.Management stanowiąca fundament codziennej pracy w wierszu poleceń.
  +-------------------------------------------------------+
  |             ŚCIĄGAWKA NAJWAŻNIEJSZYCH CMDLETÓW         |
  +-------------------------------------------------------+
  | Get-Command  | Wyszukiwanie dostępnych poleceń        |
  | Get-Help     | Pobieranie dokumentacji i przykładów   |
  | Get-Member   | Inspekcja właściwości i metod obiektów |
  | Where-Object | Filtrowanie obiektów w potoku          |
  | Select-Object| Wybieranie kolumn i limitowanie danych |
  +-------------------------------------------------------+
        
58/60
Podsumowanie i dalsza nauka
Slajd podsumowuje wiedzę zdobytą podczas kursu, podkreślając wagę myślenia obiektowego i zasady bezpiecznego pisania skryptów.

Rekapitulacja zdobytych umiejętności

  • Od tekstu do obiektów: opanowanie paradygmatu przetwarzania obiektów .NET eliminuje konieczność żmudnego parsowania tekstu.
  • Struktury danych: umiejętność sprawnego posługiwania się tablicami, tablicami mieszającymi i obiektami PSCustomObject.
  • Automatyzacja procesowa: tworzenie modularnych funkcji z blokiem param(), obsługą błędów try/catch oraz eksportem raportów.
  • Dobre praktyki: unikanie aliasów w skryptach, stosowanie pełnych nazw parametrów oraz rzetelne testowanie z przełącznikiem -WhatIf.
Dobre praktyki skryptowe (scripting best practices): zbiór standardów branżowych obejmujących pełne nazewnictwo poleceń, statyczną analizę kodu narzędziem PSScriptAnalyzer oraz hermetyzację logiki w funkcjach zaawansowanych.
  +-------------------------------------------------------+
  |               ŚCIEŻKA OPANOWANIA POWERSHELL           |
  +-------------------------------------------------------+
  | 1. Składnia bazowa: Cmdlety, potok obiektowy, pomoc   |
  | 2. Programowanie: Zmienne, tablice, hashtable, pętle   |
  | 3. Automatyzacja: Funkcje, param(), try/catch, pliki  |
  | 4. Wdrożenia: Skrypty produkcyjne, moduły, DevOps     |
  +-------------------------------------------------------+
        
59/60
Co dalej z PowerShell?
Slajd wskazuje kierunki dalszego rozwoju kompetencji: zarządzanie chmurą hybrydową, metodykę DevOps, konfigurację DSC oraz konteneryzację.

Zaawansowane perspektywy rozwoju

  • Chmura hybrydowa (Azure / AWS): opanowanie dedykowanych modułów Az i AWS Tools do automatyzacji maszyn i usług chmurowych.
  • Infrastruktura jako kod (DSC): technologia Desired State Configuration do deklaratywnego wymuszania konfiguracji serwerów.
  • Potoki CI/CD i kontenery: wykorzystanie skryptów pwsh w GitHub Actions, GitLab CI oraz środowiskach Docker.
  • Bezpieczeństwo JEA: wdrażanie technologii Just Enough Administration ograniczającej uprawnienia administratorów do wybranych cmdletów.
Desired State Configuration (DSC): deklaratywna platforma zarządzania konfiguracją w PowerShellu oparta na standardach branżowych, umożliwiająca definiowanie docelowego stanu serwera za pomocą kodu i automatyczne korygowanie odchyleń.
  +-------------------------------------------------------+
  |                 PERSPEKTYWY ROZWOJU                   |
  +-------------------------------------------------------+
  | Chmura:      Moduły Azure PowerShell (Az), AWS Tools  |
  | DevOps:      Automatyzacja w GitHub Actions / GitLab  |
  | Bezpieczeństwo: JEA (Just Enough Administration)      |
  | Infrastruktura: DSC (Desired State Configuration)     |
  +-------------------------------------------------------+
        
60/60
Dziękuję za uwagę!
Slajd podsumowuje ukończenie wykładu z języka PowerShell oraz zachęca do samodzielnych eksperymentów w konsoli terminala.

Zakończenie kursu PowerShell

  • Podsumowanie kursu: opanowanie fundamentów potoku obiektowego, cmdletów, struktur danych i automatyzacji zadań.
  • Samodzielna praktyka: najlepszą metodą utrwalenia wiedzy jest codzienne zastępowanie czynności manualnych skryptami.
  • Źródła wiedzy: oficjalna dokumentacja Microsoft Learn, fora społecznościowe PowerShell.org oraz repozytoria GitHub.
  • Kolejny etap edukacji: przejście do części 4 kursu poświęconej automatyzacji i skryptowaniu urządzeń sieciowych MikroTik.
Inżynier automatyzacji (automation engineer): rola specjalisty IT odpowiedzialnego za projektowanie, wdrażanie i utrzymanie powtarzalnych, bezpiecznych skryptów i procesów automatyzujących infrastrukturę teleinformatyczną.
  +-------------------------------------------------------+
  |              ZAKOŃCZENIE KURSU POWERSHELL             |
  +-------------------------------------------------------+
  | Gratulacje! Opanowałeś fundamentalne reguły           |
  | obiektowego języka skryptowego PowerShell.            |
  | Koduj bezpiecznie, unikaj aliasów w skryptach         |
  | i wykorzystuj pełen potencjał platformy .NET!         |
  +-------------------------------------------------------+