Ugrás a fő tartalomra

PowerShell alapok 2

A PowerShell a  linux és unix rendszerek szcriptnyelveinek hatékonyságát kívánja megvalósítani windows környezetben.


PowerShell (PS) = héj – Windows-os héjprogramozás eszköze

NEM case-sensitive

Biztonsági szempontból nem lehet a ps1 kiterjesztéshez hozzárendelni a PowerShell-beli végrehajtást, el kell indítani!

Be kell állítani a futtatáshoz  Set-ExecutionPolicy –ExecutionPolicy RemoteSigned

 Futtatás módja: Lépjünk be az aktuális könyvtárba majd futtassuk a szkripteket a . .\szkriptnév.ps1 –gyel.

  Help használata   helye:./help/help.ps1  indítása: 
 . .\help.ps1 Get-Help // help használata (get-h + TAB) kiegészíti...
Get-Help about*    //összefoglalók listája Help about_escape_character
Get-Command      //parancsok és más elemek (providerek, függvények)
Get-Command -?  //Get-Command-ról help
Get-Help Get-Command –full (/Detailed/Examples) – paraméterek Hívjuk fel a figyelmet a PS utasítások szerkezetére
Pl.
Get-Command –commandtype function //függvények listája
Get-Command –Commandtype Cmdlet //a cmdlet-ek listája
gcm // Get-Command aliasa
Get-Alias //alias nevek
Set-Alias „ujnev” parancs //új aliast adhatunk


 Néhány egyszerűbb parancs helye: /parancsok/parancsok1.ps1  indítása:     . .\parancsok.ps1

Write-Host „Üdvözlés” –ForeGroundColor Blue
Clear-Host vagy Clear // képernyőtörlés
Get-Date //dátum-idő kiírása
Get-Content „fájlnév” // fájl tartalmának kilistázása
Get-Childitem //aktuális könyvtár tartalma
Get-Childitem „c:\konyvtar” // adott konyvtár tartalma
Get-ChildItem –recurse // alkönyvtár tartalmakkal együtt
Get-ChildItem –Filter *.txt // csak a txt fájlokat listázza
Copy-Item „fájlt” „fájlba” //másolás
Copy-Item „fájlt” ”fájlba” –Confirm //csak akkor hajtsa végre, ha  Copy-Item „fájlt” „fájlba” –Whatif  //nem hajtja végre, csak megadja mit tenne...

Hasonlóan: Rename-Item, Remove-Item,

Common parameter: - minden cmdlet mellett ugyanúgy viselkednek

Confirm, whatif, debug erroraction, errorvariable, warn,verbose

New-Item –Path utvonal –ItemType
Directory //új konyvtar létrehozása
New-Item –Path utvonal –ItemType File //új fájl létrehozása
Get-Location //path kiolvasása
Set-Location –path „útvonal” //könyvtárra váltás - cd
Push-Location útvonal //verembe teszi az aktuális könyvtárat és rááll az „útvonal”-ra
Pop-Location //a veremből kiolvassa az útvonalat és visszaállítja...
Get-Process //gps
Invoke-Item c:\Windows\Notepad.exe // elindítja az alkalmazást -ii
Stop-Process ID // process lelövése .- kill

Get-ChildItem | Out-File fájlnév //csővezeték
Get-Date | Get-Member //objektumok feltérképezése, pl. Dátum objektumra – NEM SZTRING-et ad át!! pl. (Get-Date).

year // objektum tagadatának elérése

Get-ChildItem „fájlnév” | Get-Member // egy fájl adatait tartalmazó objektum tagjai (Get-ChildItem „fájlnév”). FullName //fájl neve útvonallal

Get-ChildItem | Where {$_.Length –gt 100} //100-nál hosszabb fájlokat listázza ki $_ a csővezetékből érkező objektum

Get-ChildItem | Where {$_.Extension –eq „.txt”} //txt fájlokat listázza

Get-Childitem| Sort-Object –Property LastTimeWrite –Descending //a könyvtárat csökkenő sorrendben utolsó írás ideje szerint

 Get-Process // futó processzeket listázza

Get-Process | Format-List –Property Name, Id // a processzeket listázza, csak az ID-t és nevet

Get-Process |Format-table –AutoSize //táblázatos formában írja ki,

Get-Process| Where-Object {$_.ProcessName –lt „Nev”} //szűrés, $_ csővezetéken érkező objektum, operátorok!!

Get-Process| Sort-Object –Property CPU| select-Object –Property Name, Cpu –Last 5 | Format-Table –AutoSize //a processzeket állítsuk sorba a CPU szerint, szűrjük le a name és cpu tulajdonságra és tábla formába írjuk ki.

$HOME // user home könyvtára c:\document and setting\ user,
$PSHOME //Powershell home könyvtára c:\Windows\system32\WindowsPowerShell\v1.0
Set-Location $HOME // Saját változók:
Get-Variable // változók listája
Set-Variable –Name x –Value 2 // x változó, 2-s értékkel
$x=3 // x változó 3-s értékkel
$x //kiírja az értéket
$sz=”hello”+”vilag” //” a string, + konkatenáció „hello$x” // „ „között a változó tartalma kerül be a szövegbe – hello3
’hello$x’ // ’’-között a szöveg, a változó azonosítóját tárolja --- hello$x $ma=Get-Date // objektumokat is tárolhat!
$ma.Year // az objektum Year adattagja
Remove-Variable –Name azonosító // azonosító eltávolítása
$tombbe=Get-Content „szoveg.txt”
$tombe // a teljes fájl tartalmát beolvassa
$tombbe |get-member // a tömbbel kapcsolatos elérhető adatok, metódusok
Get-psprovider // beépített szolgáltatók listája – drive, alias, registry....

#Get-ChildItem | Out-File konyvtar.txt                                #csővezeték
#Get-Date | Get-Member                                  #objektumok feltérképezése
#(Get-Date).year                                                # objektum tagadatának elérése
#Get-ChildItem konyvtar.txt | Get-Member                        # egy fájl adatait tartalmazó objektum tagjai
#(Get-ChildItem konyvtar.txt).FullName                          #fájl neve útvonallal
#Get-ChildItem | Where {$_.Length -gt 1250}                      #100-nál hosszabb fájlokat listázza ki #Get-ChildItem | Where {$_.Extension –eq „.txt”}                         #txt fájlokat listázza
#Get-Childitem| Sort-Object -Property LastTimeWrite -Descending         #a könyvtárat csökkenő sorrendben utolsó írás
#Get-Process                                            # futó processzeket listázza
#Get-Process | Format-List -Property Name, Id                   # a processzeket listázza, csak az ID-t és nevet
#Get-Process |Format-table -AutoSize                            #táblázatos formában írja ki,
#Get-Process| Where-Object {$_.ProcessName -lt "kozepe"}        #szűrés
#Get-Process| Sort-Object -Property CPU| select-Object -Property Name, Cpu -Last 5 | Format-Table -AutoSize
#a processzeket állítsuk sorba a CPU szerint, szűrjük le a name és cpu tulajdonságra és tábla formába írjuk ki.


$szavak="alma", "korte", "banan", "szilva", "szolo","barack"
$i=0;
while ($i -lt $szavak.length) {
 if ($szavak[$i] -match "^B"){
        write-host ($szavak[$i], " B-vel kezdodik")
 }
 $i++
 }



#-------------------------------------------------------------------------------------------------------
#   a vonalak közötti parancsok egyszerre futtatandóak
#-----------------------------------------------------------------------------------------------------
#$HOME                           # user home könyvtára c:\document and setting\ user,
#$PSHOME                         #Powershell home könyvtára c:\Windows\system32\WindowsPowerShell\v1.0
#Set-Location $HOME              #
#-----------------------Saját változók:
#Get-Variable                    #változók listája
#----------------------------------------------------------------------------------------------------
#Set-Variable -Name x -Value 2  #x változó, 2-s értékkel
#Get-Variable
#-------------------------------------------------------------------------------------------------------
#$x=3                           #x változó 3-s értékkel
#$x                             #kiírja az értéket
#----------------------------------------------------------------------------------------------
#$sz="hello"+" vilag"                    # a string, + konkatenáció
#$sz                   
#-------------------------------------------------------------------------------------------
# "hello$x"                      #„között a változó tartalma kerül be a szövegbe – hello3
# 'hello$x'                              # ’’-között a szöveg, a változó azonosítóját tárolja --- hello$x
#---------------------------------------------------------------------------------------------
#$ma=Get-Date                   #objektumokat is tárolhat!
#$ma.Year                       #az objektum Year adattagja
#----------------------------------------------------------------------
#$t=1,2,3,4,5                   #tomb hasznalata
#write $t
#-------------------------------------------------------------------------------------
#Remove-Variable –Name x                # azonosító eltávolítása
#Get-Variable
#----------------------------------------------------------------------------------------
#$tombbe=Get-Content tartalom.txt
#$tombbe                                 # a teljes fájl tartalmát beolvassa
#$tombbe |get-member             # a tömbbel kapcsolatos elérhető adatok, metódusok
#----------------------------------------------------------------------------------------------------




$szam=2
switch ($szam){
1 {write "megerett a meggy"; break}
2 {write "csipkebokor vesszo";break }
3 {write "Te legy az en parom";break }
default {write "Sok";}
}



#---------------------------------------------------
#
#  ne legyen tartalom.txt fajl a futasa elott
#---------------------------------------------------
if (Test-Path tartalom.txt) {"Van tartalom.txt fajl"}
else
{"Nincs tartalom.txt fajl"}

New-Item -path tartalom.txt  -Type File
Write-Host "Most hoztam letre"

if (Test-Path tartalom.txt) {"Van tartalom.txt fájl"}
else
{"Nincs tartalom.txt fajl"}


write-host "Szotar kezelese"
$szotar=@{kutya="dog";macska="cat";eger="mouse"}
write-host "Szavak:"
foreach ($magyar in $szotar.Keys){
        write-host ($magyar," ",$szotar[$magyar])
}





# Replace string in word file

function Replace-Word(
[string]$Document,
[string]$FindText,
[string]$ReplaceText
)
{
    $ReplaceAll = 2
    $FindContinue = 1

    $MatchCase = $False
    $MatchWholeWord = $True 
    $MatchWildcards = $False 
    $MatchSoundsLike = $False 
    $MatchAllWordForms = $False
    $Forward = $True
    $Wrap = $FindContinue
    $Format = $False

    $Word = New-Object -comobject Word.Application
    $Word.Visible = $False
    
    $OpenDoc = $Word.Documents.Open($Document)
    $Selection = $Word.Selection
    
    $Selection.Find.Execute(
    $FindText,
    $MatchCase,
    $MatchWholeWord,
    $MatchWildcards,
    $MatchSoundsLike,
    $MatchAllWordForms,
    $Forward,
    $Wrap,
    $Format,
    $ReplaceText,
    $ReplaceAll
    ) | Out-Null
    $OpenDoc.SaveAs([ref]"c:\tmp\osreport2.docx") 
    
    $OpenDoc.Close()
    $Word.quit()
}
# sample of calling this function
Replace-Word -Document c:/tmp/kl_teszt.docx -FindText ga -ReplaceText gaaaaaa


# AD (Active Directory) / LDAP userek lekérdezése ps (Powershell script) segítségével
# Meghívása : powershell.exe .\ldap.ps1 
#-------------------------------------------------------------------------------------
#Alap könyvtár beállítás
CD d:\prg\kl_ps\jelenleti

# Futtatási dátum kikérése (filenév vége ezt tartalmazza) ha esetleg létezik már a file felülírja
$date = ( get-date ).ToString('yyyyMMdd')
$file = New-Item -type file "d:\prg\kl_ps\jelenleti\kl_munkaido_$date.log" -Force

#Feldolgozás indítás leállítás adatok kivétele a logból az eredmény filebe írányításával
Get-WinEvent -FilterHashtable @{logname='system';id=89,109;StartTime="2012/09/01";EndTime="2015/01/01"} | Format-Table   -Autosize | out-file $file


Get-Content Excelsupport.csv | Select -First 1 | Set-Content "Export.csv"
Import-Csv -Delimiter ";" -Path .\Excelsupport.csv | % { `
  $Row = $_; `
  $_."Gyártási számok".Split(";") | % { `
    "{0};{1};{2};{3};{4};{5}" -f `
    $Row."Cikkszám", `
    $Row."Megnevezés", `
    $Row."Gyártó", `
    $Row."Mennyiség", `
    $Row."Leltári szám", `
    $_ `
  } `
} | Add-Content Export.csv




function funGetProcess()
{
 if ($args)
  {
   Get-Process |
   Format-Wide -autosize
  }
 else
  {
   Get-Process |
   Format-Wide -column $i
  }
}

cls
$i = 1
for
   ($i ; $i -le 10 ; $i++)
{
  Write-Host -ForegroundColor red "`$i is equal to $i"
  funGetProcess
}
  Write-Host -ForeGroundColor red "Now use format-wide -autosize"
  funGetProcess("auto")


Clear-Host

# AD (Active Directory) / LDAP userek lekérdezése ps (Powershell script) segítségével
# Meghívása : powershell.exe .\ldap.ps1
#-------------------------------------------------------------------------------------
#Alap könyvtár beállítás
CD d:\prg\kl_ps\jelenleti

# Futtatási dátum kikérése (filenév vége ezt tartalmazza) ha esetleg létezik már a file felülírja
$date = ( get-date ).ToString('yyyyMMdd')
$file = New-Item -type file "d:\prg\kl_ps\jelenleti\kl_munkaido_$date.log" -Force

#Feldolgozás indítás leállítás adatok kivétele a logból az eredmény filebe írányításával
Get-WinEvent -FilterHashtable @{logname='system';id=89,109;StartTime="2012/09/01";EndTime="2015/01/01"} | Format-Table   -Autosize | out-file $file


Get-WinEvent -FilterHashtable @{logname='system';id=6005,6006;StartTime="2017/09/01";EndTime="2018/01/01"} | Format-Table   -Autosize ## | out-file $file

----
# Cmdlet to find latest 2000 errors in the System eventlog
Clear-Host
$SysEvent = Get-Eventlog -Logname system -Newest 2000
$SysError = $SysEvent | Where {$_.entryType -Match "Error"}
$SysError | Sort-Object EventID |
Format-Table EventID, Source, TimeWritten, Message -auto

# Cmdlet to find 600x errors in the System eventlog
Clear-Host
Get-EventLog system -Newest 20000 | Where-Object { $_.EventID -Like "600?"} |
Format-Table TimeWritten, EventID, Message -auto

-------------------

#
# Counting words in a text file
# Uses the text from Alice in Wonderland
#
Clear-Host
$FileName = "file.txt"
Write-Host "Reading file $FileName…"
$File = Get-Content $FileName
$TotalLines = $File.Count
Write-Host "$TotalLines lines read from the file."

$SearchWord = "WONDERLAND"
$Found = 0
$WordCount = 0
$Longest = ""
$Dictionary = @{}
$LineCount = 0

$File | foreach {
    $Line = $_
    $LineCount++
    Write-Progress -Activity "Processing words…" -PercentComplete ($LineCount*100/$TotalLines)
    $Line.Split(" .,:;?!/()[]{}-") | foreach {
        $Word = $_.ToUpper()
        If ($Word[0] -ge 'A' -and $Word[0] -le "Z") {
            $WordCount++
            If ($Word.Contains($SearchWord)) { $Found++ }
            If ($Word.Length -gt $Longest.Length) { $Longest = $Word }
            If ($Dictionary.ContainsKey($Word)) {
                $Dictionary.$Word++
            } else {
                $Dictionary.Add($Word, 1)
            }
        }
    }
}

Write-Progress -Activity "Processing words…" -Completed
$DictWords = $Dictionary.Count
Write-Host "There were $WordCount total words in the text"
Write-Host "There were $DictWords distinct words in the text"
Write-Host "The word $SearchWord was found $Found times."
Write-Host "The longest word was $Longest"
Write-Host
Write-Host "Most used words with more than 4 letters:"

$Dictionary.GetEnumerator() | ? { $_.Name.Length -gt 4 } |
Sort Value -Descending | Select -First 20 2

## (Get-ChildItem -Filter "file.txt" -Recurse | Select-String -pattern "lajoska" -AllMatches).matches.count

##-----------
cls
# --- You may like to check or amend the $URL variables  ---
#
$web = New-Object net.webclient
$doc = $web.DownloadString($URL)
"Page analysed `t `t= " +$URL
"Total characters `t= " +$doc.length
##-------------------
cls
# --- Three $variables you may like to check ---
$WordBreakers = " `",.-=:;"
$Keyword = "PowerShell"
#
$web = New-Object net.webclient
$doc = $web.DownloadString($URL)
"Page analysed `t `t= " +$URL
"Total characters `t= " +$doc.length
#
# ---- 'Cleaning the document'
$doc = $doc -replace "\<[^<]*\>", " "
"Removed HTML <tags> `t= " +$doc.length
$doc = $doc.replace("&nbsp", "")
"Removed &nbsp `t `t= " +$doc.length
$words = $doc.split($WordBreakers)
"Words after split `t= " +$words.length
$words = $words | ?{$_ -match '[a-z]'}
"Removed blank spaces `t= " +$words.length
#
# ----- Indexing the unique words ------------
$words | foreach {$hash=@{}} {$hash[$_] +=1}
$freq =$hash.psbase.keys | sort {$hash[$_]}
"`n12 Most popular words: `n"
$num =-1; While ($num -gt -14) {$freq[$num]; $num +=-1}
"`nFrequency keyword " +$Keyword +" `t= " +$hash["$Keyword"]
##---------------------------

PS> $wordList = 'three','three','one','three','two','two'
PS> $wordStatistic = $wordList | ForEach-Object -Begin { $wordCounts=@{} } -Process { $wordCounts.$_++ } -End { $wordCounts }
PS> $wordStatistic
---
$wordStatistic.GetEnumerator() |
Sort-Object -Property Value -Descending |
Select-Object -First 1
##---------------
# ----- Indexing the unique words ------------
$FrequencyDistribution =  $words.split(" ") |?{-not [String]::IsNullOrEmpty($_)} |`
%{[Regex]::Replace($_,'[^a-zA-Z0-9]','')} |group |sort count -Descending

$ImportantWords = $FrequencyDistribution |?{$_.name.length -gt 3} |`
select @{n='ImportanceWeight';e={$_.Count * 0.01}}, @{n='ImportantWord';e={$_.Name}} -First 10
## -----------------

Function Count-Words ($paths) {
    $output = @()
    foreach ($path in $paths) {
        $file = Get-ChildItem $path
        ((Get-Content $file) -join " ").Split(" ", [System.StringSplitOptions]::RemoveEmptyEntries) | Group-Object | Select-Object -Property @{n="FileName";e={$file.BaseName}}, Name, Count | % {
            $output += "$($_.FileName);$($_.Name);$($_.Count)"
        }
    }
    $output | Out-File test-out2.txt -Append
}

$filepaths = "file.txt"

Count-Words -paths $filepaths

## -------------

function Count-Words($docs) {
  foreach ($doc in $docs) {
    Get-Content $doc `
      | % { $_.split(" `t",[stringsplitoptions]::RemoveEmptyEntries) } `
      | Group-Object `
      | select @{n="Document";e={$doc}}, Name, Count
  }
}

$files = @("document1", "document2", ...)

Count-Words $files | Export-CSV output.csv -Delimiter ";" -NoTypeInfo

## -----------

function Get-WordCounts ($doc)
{
      $text_ = [IO.File]::ReadAllText($doc.fullname)

      $WordHash = @{}

      $text_ -split '\b' -match '\w+'|
        foreach {$WordHash[$_]++}

      $WordHash.GetEnumerator() |
       foreach {
         New-Object PSObject -Property @{
                                          Word     = $_.Key
                                          Count    = $_.Value
                                         }
               }
  }


$docs = gci *.txt |
sort name

&{
foreach ($doc in dir $docs)
        {
           Get-WordCounts $doc |
           sort Count -Descending |
            foreach {
              (&{$doc.Name;$_.Word;$_.Count}) -join ';' 
             }
        }
} | out-file wordcounts.txt

## ----------------------
$words = "'Twas the night before Santa's party, when the elves' tools ' malfunctioned in the shop."
$words = $words.ToLower() -replace "[.,!?)(]",""
$words = $words -replace "([^a-z])'([^a-z])","`${1}`${2}"
$words = $words -replace "'","''"
## --------------------


##################################### -------------------------------------------------
-------c#

using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.IO;
using System.Threading;

namespace WordCount
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Counting words...");
            DateTime start_at = DateTime.Now;
            TrieNode root = new TrieNode(null, '?');
            Dictionary<DataReader, Thread> readers = new Dictionary<DataReader, Thread>();

            if (args.Length == 0)
            {
                args = new string[] { "war-and-peace.txt", "ulysees.txt", "les-miserables.txt", "the-republic.txt",
                                      "war-and-peace.txt", "ulysees.txt", "les-miserables.txt", "the-republic.txt" };
            }

            if (args.Length > 0)
            {
                foreach (string path in args)
                {
                    DataReader new_reader = new DataReader(path, ref root);
                    Thread new_thread = new Thread(new_reader.ThreadRun);
                    readers.Add(new_reader, new_thread);
                    new_thread.Start();
                }
            }

            foreach (Thread t in readers.Values) t.Join();

            DateTime stop_at = DateTime.Now;
            Console.WriteLine("Input data processed in {0} secs", new TimeSpan(stop_at.Ticks - start_at.Ticks).TotalSeconds);
            Console.WriteLine();
            Console.WriteLine("Most commonly found words:");

            List<TrieNode> top10_nodes = new List<TrieNode> { root, root, root, root, root, root, root, root, root, root };
            int distinct_word_count = 0;
            int total_word_count = 0;
            root.GetTopCounts(ref top10_nodes, ref distinct_word_count, ref total_word_count);
            top10_nodes.Reverse();
            foreach (TrieNode node in top10_nodes)
            {
                Console.WriteLine("{0} - {1} times", node.ToString(), node.m_word_count);
            }

            Console.WriteLine();
            Console.WriteLine("{0} words counted", total_word_count);
            Console.WriteLine("{0} distinct words found", distinct_word_count);
            Console.WriteLine();
            Console.WriteLine("done.");
        }
    }

    #region Input data reader

    public class DataReader
    {
        static int LOOP_COUNT = 1;
        private TrieNode m_root;
        private string m_path;       

        public DataReader(string path, ref TrieNode root)
        {
            m_root = root;
            m_path = path;
        }

        public void ThreadRun()
        {
            for (int i = 0; i < LOOP_COUNT; i++) // fake large data set buy parsing smaller file multiple times
            {
                using (FileStream fstream = new FileStream(m_path, FileMode.Open, FileAccess.Read))
                {
                    using (StreamReader sreader = new StreamReader(fstream))
                    {
                        string line;
                        while ((line = sreader.ReadLine()) != null)
                        {
                            string[] chunks = line.Split(null);
                            foreach (string chunk in chunks)
                            {
                                m_root.AddWord(chunk.Trim());
                            }
                        }
                    }
                }
            }
        }
    }

    #endregion

    #region TRIE implementation

    public class TrieNode : IComparable<TrieNode>
    {
        private char m_char;
        public int m_word_count;
       private TrieNode m_parent = null;
        private ConcurrentDictionary<char, TrieNode> m_children = null;

        public TrieNode(TrieNode parent, char c)
        {
            m_char = c;
            m_word_count = 0;
            m_parent = parent;
            m_children = new ConcurrentDictionary<char, TrieNode>();           
        }

        public void AddWord(string word, int index = 0)
        {
            if (index < word.Length)
            {
                char key = word[index];
                if (char.IsLetter(key)) // should do that during parsing but we're just playing here! right?
                {
                    if (!m_children.ContainsKey(key))
                    {
                        m_children.TryAdd(key, new TrieNode(this, key));
                    }
                    m_children[key].AddWord(word, index + 1);
                }
                else
                {
                    // not a letter! retry with next char
                    AddWord(word, index + 1);
                }
            }
            else
            {
                if (m_parent != null) // empty words should never be counted
                {
                    lock (this)
                    {
                        m_word_count++;                       
                    }
                }
            }
        }

        public int GetCount(string word, int index = 0)
        {
            if (index < word.Length)
            {
                char key = word[index];
                if (!m_children.ContainsKey(key))
                {
                    return -1;
                }
                return m_children[key].GetCount(word, index + 1);
            }
            else
            {
                return m_word_count;
            }
        }

        public void GetTopCounts(ref List<TrieNode> most_counted, ref int distinct_word_count, ref int total_word_count)
        {
            if (m_word_count > 0)
            {
                distinct_word_count++;
                total_word_count += m_word_count;
            }
            if (m_word_count > most_counted[0].m_word_count)
            {
                most_counted[0] = this;
                most_counted.Sort();
            }
            foreach (char key in m_children.Keys)
            {
                m_children[key].GetTopCounts(ref most_counted, ref distinct_word_count, ref total_word_count);
            }
        }

        public override string ToString()
        {
            if (m_parent == null) return "";
            else return m_parent.ToString() + m_char;
        }

        public int CompareTo(TrieNode other)
        {
            return this.m_word_count.CompareTo(other.m_word_count);
        }
    }

    #endregion
}
----------------------------------------------------------------------------------




###---------------------------------------

## 10000 sor kiírás

$ext = "xml"

$inputFile = "C:\Users\kecskemetil\Documents\munka\doksi\kimeneti_xml\utf_file_0531\ELECTRA_20210531_GOEMMO_1_EBE_F.xml"

$rootName = "c:\Users\kecskemetil\Documents\munka\doksi\kimeneti_xml\tmp\xml_kim_"

$sorszam = 1

 

$reader = new-object System.IO.StreamReader($inputFile)

$count = 1

$fileName = "{0}{1}.{2}" -f ($rootName, $count, $ext)

while(($line = $reader.ReadLine()) -ne $null)  ### minden sornál állomány méteret hasonlít össze ezért lassú!!! Helyesebb

{

    Add-Content -path $fileName -value $line

#    if((Get-ChildItem -path $fileName).Length -ge $upperBound)

    if ($sorszam -ge 10000)

    {

        ++$count

        $fileName = "{0}{1}.{2}" -f ($rootName, $count, $ext)

    }

               ++$sorszam

}

 

$reader.Close()

##------------

# gyorsabb

$from = "C:\Users\kecskemetil\Documents\munka\doksi\kimeneti_xml\utf_file_0531\ELECTRA_20210531_GOEMMO_1_EBE_F.xml"

$rootName = "c:\Users\kecskemetil\Documents\munka\doksi\kimeneti_xml\tmp\xml_kim_"

$ext = "xml"

$upperBound = 50MB

 

 

$fromFile = [io.file]::OpenRead($from)

$buff = new-object byte[] $upperBound

$count = $idx = 0

try {

    do {

        "Reading $upperBound"

        $count = $fromFile.Read($buff, 0, $buff.Length)

        if ($count -gt 0) {

            $to = "{0}.{1}.{2}" -f ($rootName, $idx, $ext)

            $toFile = [io.file]::OpenWrite($to)

            try {

                "Writing $count to $to"

                $tofile.Write($buff, 0, $count)

            } finally {

                $tofile.Close()

            }

        }

        $idx ++

    } while ($count -gt 0)

}

finally {

    $fromFile.Close()

}




Megjegyzések