Commande équivalente à la queue Unix dans Windows Powershell

Je dois regarder les dernières lignes d'un grand fichier (la taille typique est de 500 Mo à 2 Go). Je recherche un équivalent de la commande Unix tailpour Windows Powershell. Quelques alternatives disponibles sur,

http://tailforwin32.sourceforge.net/

et

Get-Content [nom de fichier] | Select-Object -Last 10

Pour moi, il n'est pas autorisé d'utiliser la première alternative, et la deuxième alternative est lente. Quelqu'un connaît-il une implémentation efficace de tail pour PowerShell?

Utilisez le -waitparamètre avec Get-Content, qui affiche les lignes à mesure qu'elles sont ajoutées au fichier. Cette fonctionnalité était présente dans PowerShell v1, mais pour une raison quelconque, elle n'était pas bien documentée dans la v2.

Voici un exemple

Get-Content -Path "C:\scripts\test.txt" -Wait

Une fois que vous avez exécuté cela, mettez à jour et enregistrez le fichier et vous verrez les modifications sur la console.

Pour être complet, je mentionnerai que Powershell 3.0 a maintenant un indicateur -Tail sur Get-Content

Get-Content ./log.log -Tail 10

obtient les 10 dernières lignes du fichier

Get-Content ./log.log -Wait -Tail 10

obtient les 10 dernières lignes du fichier et attend plus

En outre, pour les utilisateurs * nix, notez que la plupart des systèmes alias chat à Get-Content, donc ce généralement des œuvres

cat ./log.log -Tail 10

À partir de PowerShell version 3.0, l'applet de commande Get-Content a un paramètre -Tail qui devrait vous aider. Consultez l'aide en ligne de la bibliothèque technet pour Get-Content.

J'ai utilisé certaines des réponses données ici, mais juste un avertissement

Get-Content -Path Yourfile.log -Tail 30 -Wait 

va mâcher la mémoire après un certain temps. Un collègue a laissé une telle "queue" au cours de la dernière journée et elle est passée à 800 Mo. Je ne sais pas si la queue Unix se comporte de la même manière (mais j'en doute). Il est donc très bien d'utiliser pour des applications à court terme, mais soyez prudent avec elle.

Les extensions de communauté PowerShell (PSCX) fournissent l' Get-FileTailapplet de commande . Cela ressemble à une solution adaptée à la tâche. Remarque: je ne l'ai pas essayé avec des fichiers extrêmement volumineux, mais la description indique qu'il contient efficacement le contenu et qu'il est conçu pour les fichiers journaux volumineux.

NAME
    Get-FileTail

SYNOPSIS
    PSCX Cmdlet: Tails the contents of a file - optionally waiting on new content.

SYNTAX
    Get-FileTail [-Path] <String[]> [-Count <Int32>] [-Encoding <EncodingParameter>] [-LineTerminator <String>] [-Wait] [<CommonParameters>]

    Get-FileTail [-LiteralPath] <String[]> [-Count <Int32>] [-Encoding <EncodingParameter>] [-LineTerminator <String>] [-Wait] [<CommonParameters>]

DESCRIPTION
    This implentation efficiently tails the cotents of a file by reading lines from the end rather then processing the entire file. This behavior is crucial for ef
    ficiently tailing large log files and large log files over a network.  You can also specify the Wait parameter to have the cmdlet wait and display new content
    as it is written to the file.  Use Ctrl+C to break out of the wait loop.  Note that if an encoding is not specified, the cmdlet will attempt to auto-detect the
     encoding by reading the first character from the file. If no character haven't been written to the file yet, the cmdlet will default to using Unicode encoding
    . You can override this behavior by explicitly specifying the encoding via the Encoding parameter.

Juste quelques ajouts aux réponses précédentes. Il existe des alias définis pour Get-Content, par exemple si vous êtes habitué à UNIX, vous pourriez aimer cat, et il y a aussi typeet gc. Donc au lieu de

Get-Content -Path <Path> -Wait -Tail 10

tu peux écrire

# Print whole file and wait for appended lines and print them
cat <Path> -Wait
# Print last 10 lines and wait for appended lines and print them
cat <Path> -Tail 10 -Wait

À l'aide de Powershell V2 et des versions antérieures, get-content lit l'intégralité du fichier, il ne m'a donc pas été utile. Le code suivant fonctionne pour ce dont j'avais besoin, bien qu'il y ait probablement des problèmes avec les encodages de caractères. Il s'agit en fait de tail -f, mais il peut être facilement modifié pour obtenir les derniers x octets ou les dernières x lignes si vous souhaitez rechercher des sauts de ligne en arrière.

$filename = "\wherever\your\file\is.txt"
$reader = new-object System.IO.StreamReader(New-Object IO.FileStream($filename, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [IO.FileShare]::ReadWrite))
#start at the end of the file
$lastMaxOffset = $reader.BaseStream.Length

while ($true)
{
    Start-Sleep -m 100

    #if the file size has not changed, idle
    if ($reader.BaseStream.Length -eq $lastMaxOffset) {
        continue;
    }

    #seek to the last max offset
    $reader.BaseStream.Seek($lastMaxOffset, [System.IO.SeekOrigin]::Begin) | out-null

    #read out of the file until the EOF
    $line = ""
    while (($line = $reader.ReadLine()) -ne $null) {
        write-output $line
    }

    #update the last max offset
    $lastMaxOffset = $reader.BaseStream.Position
}

J'ai trouvé la plupart du code pour le faire ici .

J'ai pris la solution de @ hajamie et l'ai enveloppée dans un wrapper de script légèrement plus pratique.

J'ai ajouté une option pour commencer à partir d'un décalage avant la fin du fichier, afin que vous puissiez utiliser la fonctionnalité de type queue de lecture d'une certaine quantité à partir de la fin du fichier. Notez que le décalage est en octets, pas en lignes.

Il existe également une option pour continuer à attendre plus de contenu.

Exemples (en supposant que vous l'enregistrez sous TailFile.ps1):

.\TailFile.ps1 -File .\path\to\myfile.log -InitialOffset 1000000
.\TailFile.ps1 -File .\path\to\myfile.log -InitialOffset 1000000 -Follow:$true
.\TailFile.ps1 -File .\path\to\myfile.log -Follow:$true

Et voici le script lui-même ...

param (
    [Parameter(Mandatory=$true,HelpMessage="Enter the path to a file to tail")][string]$File = "",
    [Parameter(Mandatory=$true,HelpMessage="Enter the number of bytes from the end of the file")][int]$InitialOffset = 10248,
    [Parameter(Mandatory=$false,HelpMessage="Continuing monitoring the file for new additions?")][boolean]$Follow = $false
)

$ci = get-childitem $File
$fullName = $ci.FullName

$reader = new-object System.IO.StreamReader(New-Object IO.FileStream($fullName, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [IO.FileShare]::ReadWrite))
#start at the end of the file
$lastMaxOffset = $reader.BaseStream.Length - $InitialOffset

while ($true)
{
    #if the file size has not changed, idle
    if ($reader.BaseStream.Length -ge $lastMaxOffset) {
        #seek to the last max offset
        $reader.BaseStream.Seek($lastMaxOffset, [System.IO.SeekOrigin]::Begin) | out-null

        #read out of the file until the EOF
        $line = ""
        while (($line = $reader.ReadLine()) -ne $null) {
            write-output $line
        }

        #update the last max offset
        $lastMaxOffset = $reader.BaseStream.Position
    }

    if($Follow){
        Start-Sleep -m 100
    } else {
        break;
    }
}

essayer Windows Server 2003 Resource Kit Tools

il contient un tail.exequi peut être exécuté sur le système Windows.

https://www.microsoft.com/en-us/download/details.aspx?id=17657

Très basique, mais fait ce dont vous avez besoin sans modules supplémentaires ou exigences de version PS:

while ($true) {Clear-Host; gc E:\test.txt | select -last 3; sleep 2 }

Probablement trop tard pour une réponse mais essayez celle-ci

Get-Content <filename> -tail <number of items wanted>

Il y a eu de nombreuses réponses valides, cependant, aucune d'entre elles n'a la même syntaxe que tail dans linux . La fonction suivante peut être stockée dans votre $Home\Documents\PowerShell\Microsoft.PowerShell_profile.ps1pour la persistance (voir la documentation des profils PowerShell pour plus de détails).

Cela vous permet d'appeler ...

tail server.log
tail -n 5 server.log
tail -f server.log
tail -Follow -Lines 5 -Path server.log

ce qui est assez proche de la syntaxe linux.

function tail {
<#
    .SYNOPSIS
        Get the last n lines of a text file.
    .PARAMETER Follow
        output appended data as the file grows
    .PARAMETER Lines
        output the last N lines (default: 10)
    .PARAMETER Path
        path to the text file
    .INPUTS
        System.Int
        IO.FileInfo
    .OUTPUTS
        System.String
    .EXAMPLE
        PS> tail c:\server.log
    .EXAMPLE
        PS> tail -f -n 20 c:\server.log
#>
    [CmdletBinding()]
    [OutputType('System.String')]
    Param(
        [Alias("f")]
        [parameter(Mandatory=$false)]
        [switch]$Follow,

        [Alias("n")]
        [parameter(Mandatory=$false)]
        [Int]$Lines = 10,

        [parameter(Mandatory=$true, Position=5)]
        [ValidateNotNullOrEmpty()]
        [IO.FileInfo]$Path
    )
    if ($Follow)
    {
        Get-Content -Path $Path -Tail $Lines -Wait
    }
    else
    {
        Get-Content -Path $Path -Tail $Lines
    }
}