ScriptoM@nia

fonction qui affiche et sélectionne les fichiers à la volée

2012-01-02T08:54:00.000-08:00

salut,

il y a des fois, la recherche de fichiers dans un répertoire contenant des centaines voire des milliers d'autres fichiers, soit une tâche fastidieuse...ça sera sympa d'avoir une petite fonction qui fait ceci à notre place et en plus sélectionne notre fichier à la voilée, non :)


Function Select-File {
 
  [CmdletBinding()]
  Param(
    [Parameter(Mandatory=$True)]
    [ValidateScript({ 
             if(Test-Path $_) {$true}
             else {
               throw $("fichier ""$_"" introuvable")
             } 
    })]
    [System.String]$FilePath
  )
  Begin{
      $item=get-item $FilePath
      Start-Process -f explorer.exe -a "/select,""$($item.FullName)"""
  }
}

on peux utiliser cette petite fonction ainsi:


PS> Select-File c:\fichier.txt

EDIT: la fonction ne peux pas être utiliser comme un filtre

get-content peux désormais traiter les fichiers XML

2011-11-27T11:45:00.001-08:00

salut,pour eviter de caster tout le temps les fichiers xml en [Xml] à fin de les traiter j'ai ajouté deux nouveaux paramètres à 'get-content' AsXml et XPath pour que le traitement soit direct.

Function Get-Content {
<#
***************************************************************************
 
 --------------------8<-----------------------------------------
    Ajout de deux nouveaux paramètres pour simplifier
    le traitement des fichiers XML: [-AsXml] [-XPath ]
    
    Attention: l'expression Xpath est sEnSiBlE à La cAsSe
    
                                  Walid toumi             
 --------------------8<-----------------------------------------
 
 PS> # Exemples d'utilisation:
 
 PS> $file = "$PSHOME\types.ps1xml"
 
 PS> $u = cat $file -As | Select-Xml -XP "//ScriptProperty" | Select -Expand Node
 PS> $u

 PS> $Xml = Get-Content $file -AsXml
 PS> $Xml.Types.Type[1..10]
 
 PS> Get-Content $file -AsXml -XPath "//Type[contains(Name,'Xml')]/Name"
 
 **************************************************************************
 
.ForwardHelpTargetName Get-Content
.ForwardHelpCategory Cmdlet

#>

[CmdletBinding(DefaultParameterSetName='Path', SupportsTransactions=$true)]
param(
    [Parameter(ValueFromPipelineByPropertyName=$true)]
    [System.Int64]
    ${ReadCount},

    [Parameter(ValueFromPipelineByPropertyName=$true)]
    [System.Int64]
    ${TotalCount},

    [Parameter(ParameterSetName='Path', Mandatory=$true, Position=0, ValueFromPipelineByPropertyName=$true)]
    [System.String[]]
    ${Path},

    [Parameter(ParameterSetName='LiteralPath', Mandatory=$true, Position=0, ValueFromPipelineByPropertyName=$true)]
    [Alias('PSPath')]
    [System.String[]]
    ${LiteralPath},

    [System.String]
    ${Filter},

    [System.String[]]
    ${Include},

    [System.String[]]
    ${Exclude},
    
    [System.String]
    ${XPath},

    [Switch]
    ${Force},
    
    [Switch]
    ${AsXml},

    [Parameter(ValueFromPipelineByPropertyName=$true)]
    [System.Management.Automation.PSCredential]
    ${Credential})

begin
{
    try {
        $outBuffer = $null
        if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
        {
            $PSBoundParameters['OutBuffer'] = 1
        }
        $wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Microsoft.PowerShell.Management\Get-Content', [System.Management.Automation.CommandTypes]::Cmdlet)
        $cmd = ''
         if($AsXml) {
          [void]$PSBoundParameters.Remove('AsXml')
          $cmd += ' | ForEach-Object {$fx=@()} {$fx+=$_} {$fx -as [Xml]}'
            if($XPath) {
               [void]$PSBoundParameters.Remove('XPath')
               $cmd += ' | Select-Xml -XPath $XPath | Select -expand Node'
            }
        } 
        $ScriptCmd = [ScriptBlock]::Create(
           { & $wrappedCmd @PSBoundParameters }.ToString() + $Cmd
          )
        $steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
        $steppablePipeline.Begin($PSCmdlet)
    } catch {
        throw
    }
}

process
{
    try {
        $steppablePipeline.Process($_)
    } catch {
        throw
    }
}

end
{
    try {
        $steppablePipeline.End()
    } catch {
        throw
    }
}

}

Get-ChildItem un peu plus conviviale :)

2011-11-20T04:50:00.000-08:00

Salut,je ne sais pas si quelqu'un d'autre a eu l'idée d'ajouter ces deux fonctionnalités à la cmdlet 'Get-ChildItem' et je n'ai pas aussi tester Powershell vNext pour voir s'il implémente l'une de ces deux fonctionnalités...alors, je me suis dit pourquoi attendre ?! j'ai tout ce qu'il me faut pour configurer mes 'cmdlets' .... alors la première chose qui m'ai venu à l'esprit c'est d'ajouter deux nouveaux paramètres: 'FileSizeInHumanReadableFormat' et 'Pattern' le premier est une implémentation du switch '-lh' de la commande lunix 'ls' qui signifie "Display File Size in Human Readable Format" et l'autre paramètre pour allez un cran au-dessus des simples wildcards utiliser par les "filter" et "include" ... 'pattern' va nous permette d'utiliser les RegExp dans nos recheches :)vous pouvez voir les nouveaux paramètres de la fonction 'Get-ChildItem' en écrivant ceci:

 
Get-Command Get-ChildItem -TotalCount 1 -Syntax

en fait le méchanisme d'execution des commandes dans "Windows Powershell"

help Precedence

va nous permettre d'executer notre fonction avant le cmdlet 'Get-Childtem'

Function Get-ChildItem {
<#

.ForwardHelpTargetName Get-ChildItem
.ForwardHelpCategory Cmdlet

#>

[CmdletBinding(DefaultParameterSetName='Items', SupportsTransactions=$true)]
param(
    [Parameter(ParameterSetName='Items', Position=0, ValueFromPipeline=$true, ValueFromPipelineByPropertyName=$true)]
    [System.String[]]
    ${Path},

    [Parameter(ParameterSetName='LiteralItems', Mandatory=$true, Position=0, ValueFromPipelineByPropertyName=$true)]
    [Alias('PSPath')]
    [System.String[]]
    ${LiteralPath},

    [Parameter(Position=1)]
    [System.String]
    ${Filter},

    [System.String[]]
    ${Include},

    [System.String[]]
    ${Exclude},
    
    [System.String]
    ${Pattern},

    [Switch]
    ${Recurse},

    [Switch]
    ${FileSizeInHumanReadableFormat},

    [Switch]
    ${Force},

    [Switch]
    ${Name})

begin
{
    try {
        $outBuffer = $null
        if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
        {
            $PSBoundParameters['OutBuffer'] = 1
        }
        $wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Microsoft.PowerShell.Management\Get-ChildItem', [System.Management.Automation.CommandTypes]::Cmdlet)
        $cmd = ""
        if($FileSizeInHumanReadableFormat) {
          $PSBoundParameters.Remove('FileSizeInHumanReadableFormat') | Out-Null
          $cmd = @"
            | ForEach-Object {
                `$_length=Switch(`$_.length) {
                  { `$_ -lt 1kb } 
                           {  '{0}B' -f (`$_) ;break }
                  { `$_ -lt 1MB }
                           {  '{0}KB' -f ([math]::round(`$(`$_/ 1kb)), 2) ;break }
                  { `$_ -lt 1gb }
                            { '{0}MB' -f ([math]::round(`$(`$_/ 1mb), 2)) ;break }
                  defaut { 
                            {  '{0}GB' -f ([math]::round(`$(`$_/ 1gb), 2)) ;break }
                   }
                }
                if(`$_.PSISContainer) { `$_length=`$null }
                New-Object PSObject -Property @{
                  Mode = `$_.Mode
                  LastWriteTime = `$_.LastWriteTime
                  Length = `$_length
                  Name = `$_.Name
                }
            }         
"@
        }
        if($PSBoundParameters['Pattern']) {
          if($Filter -or $Include) {
           throw "les paramètres Pattern et Filter/Include sont mutuellemnt exculsive"
          } else {
          $PSBoundParameters.Remove('Pattern') | Out-Null
          $scriptCmd = {& $wrappedCmd @PSBoundParameters | Where { $_.Name -imatch "$Pattern"  } }
          }
        } else {
          $scriptCmd = {& $wrappedCmd @PSBoundParameters } 
        }
        $scriptCmd = $ExecutionContext.InvokeCommand.NewScriptBlock(
                $scriptCmd.ToString() + $cmd
            )
        $steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
        $steppablePipeline.Begin($PSCmdlet)
    } catch {
        throw
    }
}

process
{
    try {
        $steppablePipeline.Process($_)
    } catch {
        throw
    }
}

end
{
    try {
        $steppablePipeline.End()
    } catch {
        throw
    }
}

}

voici quelques utilisation de cette fonction:

Get-ChildItem  -Path $env:windir -Pattern "^\d{2}" -FileSizeInHumanReadableFormat

Get-ChildItem -path $env:windir -filter *.txt -FileSizeInHumanReadableFormat

la sortie de la commande est un objet:

System.Management.Automation.PSCustomObject

ou

System.IO.FileSystemInfo

Get-Help: comment afficher l'aide graphique sans être connecté à internet

2011-11-10T22:25:00.000-08:00

salut,

voici une petite fonction proxy du cmdlet Get-Help qui vous permettera d'avoir une aide graphique sans utilisation du paramètre "Online" (qui requiert une connexion internet)...la démarche est toute simple: On décompile à la volée le fichier d'aide local de PS puis on sélectionne la rubrique choisi par une simple recherche...

Function Get-Man {
<#

.ForwardHelpTargetName Get-Help
.ForwardHelpCategory Cmdlet

#>

[CmdletBinding(DefaultParameterSetName='AllUsersView')]
param(
    [Parameter(Position=0, ValueFromPipelineByPropertyName=$true)]
    [System.String]
    ${Name},

    [System.String]
    ${Path},

    [System.String[]]
    ${Category},

    [System.String[]]
    ${Component},

    [System.String[]]
    ${Functionality},

    [System.String[]]
    ${Role},

    [Parameter(ParameterSetName='DetailedView')]
    [Switch]
    ${Detailed},

    [Parameter(ParameterSetName='AllUsersView')]
    [Switch]
    ${Full},

    [Parameter(ParameterSetName='Examples')]
    [Switch]
    ${Examples},

    [Parameter(ParameterSetName='Parameters')]
    [System.String]
    ${Parameter},
    
    # affiche l'aide dans le navigateur par defaut
    [Switch]
    ${ShowUI},

    [Switch]
    ${Online})

begin
{
    try {
        $outBuffer = $null
        if ($PSBoundParameters.TryGetValue('OutBuffer', [ref]$outBuffer))
        {
            $PSBoundParameters['OutBuffer'] = 1
        }
        $wrappedCmd = $ExecutionContext.InvokeCommand.GetCommand('Get-Help', [System.Management.Automation.CommandTypes]::Cmdlet)
        if($PSBoundParameters['ShowUI']) {
          $null=$PSBoundParameters.Remove('ShowUI')
                
    function invokeUI {
         param(
           [Parameter(ValueFromPipeLineByPropertyName=$True)]
           $Name
         )
        Begin{
             $HelpChm = "$env:Windir\Help\WindowsPowerShellHelp.chm"
             $HelpTmp = "$env:Temp\PSCmd"
             if (! (Test-Path $HelpChm) ) { 
                  throw "le fichier source $HelpChm est introuvable"
             }
            if(! (Test-Path $HelpTmp)) {
                 Start-Process -File "hh.exe" -Arg "-decompile $HelpTmp $HelpChm" -Wait
            }
            $HtmlFiles = Get-childItem "$HelpTmp\html" *.htm
        }
        Process{
            forEach($file in @($HtmlFiles)) {
                 [Xml]$Xml = get-content $file.Fullname
                 if($Xml.html.head.title -ieq "$Name") {
                    invoke-item $file.Fullname 
                 }
            }
       }
       End{
           Remove-Item $HelpTmp -Recurse
       }
   }

        $scriptCmd = {& $wrappedCmd @PSBoundParameters | invokeUI}
        } else {
        $scriptCmd = {& $wrappedCmd @PSBoundParameters }
        }
        $steppablePipeline = $scriptCmd.GetSteppablePipeline($myInvocation.CommandOrigin)
        $steppablePipeline.Begin($PSCmdlet)
    } catch {
        throw
    }
}

process
{
    try {
        $steppablePipeline.Process($_)
    } catch {
        throw
    }
}

end
{
    try {
        $steppablePipeline.End()
    } catch {
        throw
    }
}
}

l'utilisation de Get-Man est simple voici quelques exemples:

PS>  Get-Man -Name Select-Xml -ShowUI

PS> Get-commend Get-Man -syntax

plage d'adresses

2011-08-24T09:32:00.000-07:00

salut,

voici un petit script simple pour trouver une plage d'adresses entre deux IP:

    @echo off

    

    call :go 192.168.0.3 192.168.0.65

    echo %ips%

    goto :eof

     

    :go

    setlocal enabledelayedexpansion&set a=0

    for /f "tokens=1-8 delims=." %%a in ("%1.%2") do (

       set /A a=%%h-%%d,b=%%g-%%c,c=%%f-%%b,d=%%e-%%a  

       for %%e in (b c d) do (

          if !%%e! gtr 0 (set e=!e!*255) else (set e=)

       set /A a+=%%e!e!

    ))

    endlocal & set ips=%a%

comment convertir un decimal en binaire

2011-08-24T09:26:00.000-07:00

salut,

@echo off



set num=

set bin=

set k=



set /A num=%1,1/num 2>Nul || (

  findstr /bl "::|" %0

  exit /b 1)

::|

::| usage:  prog 

::|

::| exemple: prog 2335

::|

:lp

set /A k=num %% 2

set bin=%k%%bin%

set /A num/=2

if %num% gtr 0 goto :lp



echo  %bin%

Comment numéroter les lignes d'un fichier:

2011-07-27T01:19:00.000-07:00

salut,

L'une des solutions possibles:

   @Echo >$ oFF
   Set file=c:\temp\a.txt
   for /f "delims=" %%a in ('
      "fc /l /n %file% $|findstr -vbi [\*A-Z]"
    ') do echo %%a
   del $ 
   goto:eof

utilisation de %variable% en PS

2011-05-14T10:21:00.000-07:00

Salut,

voici une petite fonction pouvant afficher/créer des variables d'environements aussi simple que les batchs NT

del alias:set -ea 0
function set
{
  $_nam,$_rest = "$args".Split('=')
  if(!$_rest -and $_nam) { gci "env:$($_nam)" }
  elseif(!$_nam) { gci env: }
  else {
    $_val = [environment]::ExpandEnvironmentVariables("$_rest")
    ni -pa env:$_nam -va $_val -fo
  }
}

et voici quelques exemples d'utilisation:

[1] # affichage de toutes les variables d'environments
[1] set
Name                           Value                                           
----                           -----                                           
ALLUSERSPROFILE                D:\Documents and Settings\All Users             
APPDATA                        D:\Documents and Settings\walid2mi\Applicatio...
CLIENTNAME                     Console                                         
CommonProgramFiles             D:\Program Files\Fichiers communs   
...
...

[2] # affichage des variables commencant par "P"
[2] set p*
Name                           Value                                           
----                           -----                                           
Path                           D:\WINDOWS\system32;D:\WINDOWS;D:\WINDOWS\Sys...
PATHEXT                        .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;....
PROCESSOR_ARCHITECTURE         x86                                             
ProgramFiles                   D:\Program Files                                

[3] # création d'une variable "user"
[3] set user = %username%

[4] # création d'une variable "Home"
[4] set home=$home

Ajouter un add-On à son éditeur ISE

2011-05-04T05:03:00.000-07:00

Salut,

me revoilà, ce petit code permet d'ajouter à la barre de menu un nouveau menu personnalisé destiné à l'ajout des add-ons, vous pouvez inclure cette fonction dans votre profil ISE pour qu'elle se charge à chaque session démarrée.

Function Add-AddOns
{
<# 
.synopsis
 affiche et/ou créer des add-ons
.parameter List
  affiche tous les noms des add-ons disponibles
.parameter Name
  nom du add-on
.parameter ShortCut
  un raccourcis pour le add-on
.parameter Action
  un bloc de script qui va s'executer à l'appel du add-on
.example
  Add-AddOns -List
.example
 PS> Add-AddOns -n "Effacer le volet de Script" -s "ctrl+shift+b" -a {   
 >>   $psISE.CurrentFile.Editor.Clear()
 >>  }

  Créer un add-on pour effacer le volet script
.example
  PS> Add-AddOns -RemoveAll
  
  Supprime tous les add-Ons 
.example
  PS> Add-AddOns -RemoveItem 1
  
  Supprime l'add-on ayant l'index 1
.example
  PS> $sb = { Invoke-Expression 'c:\script.ps1'  }
  PS> Add-AddOns "script.ps1" "Ctrl+shift+q" $sb
  
  Execute le script 'c:\script.ps1'
#> 
  [CmdletBinding(DefaultParameterSetName='List')]
  Param(
   [Parameter(Mandatory=$False,Position=0,ParameterSetName='List')]
   [Switch]$List,
   [Parameter(Mandatory=$True,Position=0,ParameterSetName='RemoveAll')]
   [Switch]$RemoveAll,
   [Parameter(Mandatory=$True,Position=0,ParameterSetName='RemoveItem')]
   [int]$RemoveItem,
   [Parameter(Mandatory=$True,Position=0,ParameterSetName='Name')]
   [String]$Name,
   [Parameter(Mandatory=$false,Position=1,ParameterSetName='Name')]
   $ShortCut=$null,
   [Parameter(Mandatory=$True,Position=2,ParameterSetName='Name')]
   [ScriptBlock]$Action
  )
  if($Host.Name -ne 'Windows PowerShell ISE Host') 
  { throw "fonctionne uniquement dans l'environment ISE" }
  Switch ($PSCmdlet.ParameterSetName)
  {
     "List"
     {
        $Items = $psISE.CurrentPowerShellTab.AddOnsMenu.Submenus
        for($i=0;$i -le $items.count-1;$i++) 
         { Select -inp $Items @{n="Index";e={$i}},
            @{n="Name";e={$_.Item($i).DisplayName}}   
         }
     }
     "RemoveAll"
     { 
       $psISE.CurrentPowerShellTab.AddOnsMenu.Submenus.Clear() 
     }
     "RemoveItem"
     { 
       $psISE.CurrentPowerShellTab.AddOnsMenu.Submenus.RemoveAt($RemoveItem)
     }
     "Name"
     {
       $psISE.CurrentPowerShellTab.AddOnsMenu.Submenus.Add($Name,$Action,$ShortCut)
     }
  }
}

Bon Scripting ;)

Inclure du code PS dans un fichier Batch

2011-04-22T21:50:00.001-07:00

salut,

;@echo off & Setlocal EnableExtensions
;echo CMD %ERRORLEVEL%
;:<>
;Findstr -rbv ; %0 | powershell -c - 
;goto:sCode ######################################
 
"PSH " | Write-Host -for yellow -no
$_=$OFS;$OFS=''
$char=87,65,76,73,68,50,77,73,64,71,77,65,73,76,46,67,79,77
([string][char[]]($char));$OFS=$_
exit 5
 
;:sCode ######################################
;:<>
;echo CMD %ERRORLEVEL%
;pause & goto :eof

voici une autre approche plus robuste:

@echo off
::::::::::::::::::::::::::::::::::::
For /f "delims=:" %%a In ('
     findstr /Bn "@PS" %0
 ') do Set /ALine=%%a
 more +%Line% %0  | powershell -c -
::::::::::::::::::::::::::::::::::::
:: ici suite du code Batch

dir
pause & exit /b 

@PS ::::::::::::::::::::::::::::::
Function Get-Test {
  param()
  Begin{
    Write-Warning "Debut du traitement" 
  }
  Process{
    write-verbose "ici n'importe quel traitement"
    gps power*,cmd*  
    <# 
      un Bloc de commentaires 
    #>
  }
  End{
   Write-warning "Fin du traitement"
  }
}
Get-Test
exit

Trier selon les Types d'objets

2011-04-22T05:08:00.000-07:00

cette petite fonction, à pour rôle de trier selon 3 types d'objets: [String] [Version] et [int]

Function Sort-ObjectType {
<#
 .Synopsis
   Sort Object by Types
 .Description
   Sort Object by Types
 .Parameter Type
   Specifies the type of object
     - ToString:   [System.String]
     - ToInteger:  [System.Int32]
     - ToVersion:  [System.Version]
     - ToIPAddress [System.Net.IPAddress]
 .Parameter CaseSensistive
 .Parameter Descending
 .Parameter Unique    
 .Example
  [1]PS> $str += "10","2","5"
  [2]PS> $str | Sort-Object # 10 2 5
  [3]PS> $str | Sort-ObjectType -Type ToInteger # 2 5 10
 .Example
  [1]PS> '1.0.1.10','1.0.1.100','1.0.1.9' | Sort-Object -unique
  [2]PS> # 1.0.1.10 > 1.0.1.100 > 1.0.1.9
  [3]PS> '1.0.1.10','1.0.1.100','1.0.1.9' | Sort-ObjectType -Type ToVersion
  [4]PS> # 1.0.1.9 > 1.0.1.10 > 1.0.1.100
 .Example
  [1]PS> $ips="3.25.20.100","198.10.3.1","1.2.0.3","10.2.0.6"
  [2]PS> $ips | Sort-ObjectType -Type ToIPAddress 
 .Outputs
  System.String
#>
#Requires -version 2.0
 Param(
  [ValidateSet('ToString','ToInteger','ToVersion','ToIPAddress')]
  $Type,
  [Switch]$CaseSensitive,
  [SWitch]$Descending,
  [Switch]$Unique
  )
 $input | Sort-Object -Property {
    $ty=$_
    Switch($Type) {
     'ToString'  {[String]$ty}
     'ToInteger' {[Int]$ty}
     'ToVersion' {[Version]$ty}
     'ToIPAddress' { 
         [byte[]]$ty.split('.')|ForEach{[string]::Format("{0:000}",$_)}
         }
     default {$ty}
    }
  } -case:$CaseSensitive -desc:$Descending -uni:$Unique
}

colorer vos invites de commandes

2011-04-14T23:59:00.000-07:00

salut,

malheureusement, dans le shell windows, on n'a pas de commandes native qui permet de colorer nos chaines de caractères, pour pallier à cette lacune on peux télécharger des commandes externes, ou bien pour les puristes on peux bricoler un tuc comme ceci:

@echo off
if "%~2"=="" (
   cls
   echo.
   echo   .SYNTAXE:
   echo. 
   echo        %~n0 BackgroundColor+ForegroundColor chaine
   echo.
   echo  ------------ EXEMPLE 1 --------------
   echo.  
   echo        CMD E:\^> %~n0 0c "hello world"
   echo.
   echo  ------------ EXEMPLE 2 --------------
   echo.
   echo        CMD E:\^> type script.cmd
   echo        @echo off
   echo        call cecho ce "Debut"
   echo        echo processus
   echo        call cecho ec "Fin"
   exit /b 3
)
mkdir $temp || (exit /b 2)
pushd $temp || (rmdir $temp & exit /b 1)
for /f "delims=" %%. in ('
    "%ComsPec% /k prompt $h$h <&1"
 ') do >rtn echo %%.
Call:bfc %1 %2
popd
rmdir /s /q $temp
exit /b 0

:bfc
>%2 (set/P=+) <&1
findstr /a:%1 + %2 con
type rtn
goto :eof

supprimer les dossiers vides

2011-04-14T23:52:00.000-07:00

salut,

voici un petit filtre en PS pour supprimer les dossiers vides

Filter Remove-EmptyFolder
{
  try{
   [IO.DirectoryInfo]$Folder=$_
   if($Folder.GetFiles().count -eq 0) {$Folder.Delete()}
  }
  catch{}
}

PS> gci -Recurse | Remove-EmptyFolder

Call+chemin avec le caractère %

2011-03-04T11:20:00.000-08:00

appeler un bat se trouvant dans un dossier %dossier% est embêtant, et peux facilement être tragique si notre %dossier% était une variable valuée...pour contournée ce problème on peux faire ceci:

echo=|call %%dossier%%\srep\fichier.bat
:: ou bien
Cmd /c %%dossier%%\srep\fichier.bat
:: ou bien
cd /d "%%dossier%%\srep"
fichier.bat

Fibonacci en batch

2011-03-04T11:12:00.000-08:00

ce beau vieux Fibonacci est desormais devenu une star...

@Echo oFF
Setlocal EnableDelayedExpansion

Set cnt=20
Set /A a=1,b=a
Echo !a!&for /l %%# in (1=1=!cnt!) do (
  set /A c=a+b,a=b,b=c
  Echo=!c!
)
Pause

émulation de la commande externe attrib.exe

2011-03-04T10:32:00.000-08:00

Set-Attrib est une fonction qui associe à la fois la simplicité du codage en PS et la puissance de celui-ci:

Function Set-Attrib
{
  param(
   [string]$Path=".",
   [string]$Filter="*",
   [switch]$ReadOnly,
   [switch]$System,
   [switch]$Normal,
   [switch]$Hidden,
   [switch]$Archive,
   [switch]$Recurse
  )
  $attr=@()
  Switch($true)
   {
     $ReadOnly { $attr+='ReadOnly'}
     $Archive  { $attr+='Archive' }
     $Hidden   { $attr+='Hidden'  }
     $System   { $attr+='System'  }
     $Normal   { $attr+='Normal'  }
   }      
 gci -Path $Path -Fi $Filter -Recurse:$Recurse -Fo | `
   Where { -not $_.PSIsContainer } | `
     ForEach {
       $_.PsBase.Attributes=[System.IO.FileAttributes]$attr
     }
 <#
   .SYNOPSIS
       Modifie les attributs des fichiers
   .DESCRIPTION
     Modifie les attributs des fichiers, les attributs supportés sont:
       -ReadOnly: fichier en Lecture seul
       -System  : fichier système
       -Hidden  : fichier caché
       -Archive : fichier archivé
   .PARAMETER Path
     Chemin du répertoire source
   .PARAMETER Filter
     Filtre sur les fichiers à traiter ou bien un nom d'un fichier  
   .PARAMETER Recurse
     recherche recursive  
   .EXAMPLE 
     PS C:\> Set-Attrib -Path c: -Filter boot.ini -Normal
     hôtter du fichier c:\boot.ini les attributs "Sytème" et "Caché"
   .EXAMPLE
     PS C:\> Set-Attrib -Filter *.inf -Recurse -ReadOnly -System
     Modifie tous les attributs des fichiers *.iNF du répértoire courant et tous ses sous répértoie en fichiers "En lecture seul" et "Système"
   .EXAMPLE
     PS C:\> Set-Attrib -Hidden
     Caché tous les fichiers du répertoire en cours    
 #>    
}

[POWERSHELL] provider en alias

2010-08-28T07:58:00.000-07:00

pour mettre le provider variable: comme alias on passera par une fonction comme ceci

  PS> function global:variable: {"test"}
  PS> set-alias variable: global:variable:
  PS> variable:
test

Tri numérique

2010-08-28T02:21:00.000-07:00

Pour trier des données on a la commande SORT.EXE mais malheureusement elle n'effectue que le trie alphabétique:
Salut,

Pour trier des données on a la commande SORT.EXE mais malheureusement elle n'effectue que le trie alphabétique:

c:\> type fichier1.txt

1 marcoc
2 libye
3 palestine
4 france

c:\> sort /r /+2 fichier1.txt /o trier.txt
c:\> type trier.txt

3 palestine
1 maroc
2 libye
4 france

un autre exemple:

c:\> type fichier2.txt

5
3
6
1

c:\> sort fichier2.txt

1
3
5
6

jusqu'ici tout marche à la perfection, voyons maintenant cette exemple:

c:\> type fichier3.txt

65
1
26894
1125
369

c:\> sort fichier3.txt

1
1125
26894
369
65

comme vous voyez la commande SORT.EXE ne connait pas le trie numérique.

pour contourner ce problème, on peux utiliser la commande externe "gnu sort" avec l'option "-n"

c:\> gnusort -n fichier3.txt

1
65
369
1125
26894

une autre solution est de faire un script émulant la commande "gnusort -n".

Donc l'une des solution possible est de fixer la longueur des chaine de caractères pour qu'il aillent la même longueur, pour se faire on va ajouter des zero "0" à gauche de chaque chaine:

ensuite on va les passer à la commande SORT.EXE

c:\> Sort fichier4.txt

le trie est effectuer avec succès il nous ne reste plus qu'a enlever les zeros "0" de plus.

et voilà voyons notre script de quoi aura l'air:

@Echo oFF
Setlocal EnableExtensions

Set liste=1 1125 26894 369 65 396

For %%i in (%liste%) Do >>~@ Call :S %%i
For /F "Tokens=*" %%c in ('Sort ~@') do Call:P set "c=%%c"
del ~@
pause
Endlocal & goto :EOF

:S
Set "tz=00000000%1"
Echo:%tz:~-8%
goto :EOF

:P
%*
:z
if (%c:~0,1%)==(0) set "c=%c:~1%" & goto:z
echo=%c% 
goto:EOF

comme vous voyez c'est le bordel !! On essayera alors une autre solution,...que dites-vous de
comparer les nombres, nombre par nombre en décalant chaque chiffre de gauche à droite, le plus grand nombre sera décalé à droite et le plus petit à gauche ? un SORT à bulle...quoi..

@Echo oFF

Call :Sort 1256 280 3 10 2 98 259 563 8
pause
goto :EOF


:Sort
Setlocal EnableDelayedExpansion
Set/A n=1,s=0,c=s,r=s
for %%: In (%*) do (
    Set /a c+=1
    Set "nm.!c!=%%:")
:LP.1
if %s% EQU %c% Set/A n+=1,s=0
    Set/A s+=1
    Call :SPL %n% %s%
If %n% LEQ %c% goto :LP.1
:LP.2
    Echo:!nm.%c%!
    Set/A c-=1
If %c% GTR 0 goto :LP.2 
Endlocal & goto :EOF
:SPL
 If !nm.%1! GTR !nm.%2! (
   Set "t=!nm.%2!"&Set "nm.%2=!nm.%1!"
   Set "nm.%1=!t!"
 ) 
goto :EOF

c'est plus simple..non.. :)

fonctions utiles

2010-07-18T19:20:00.000-07:00

voici quelques fonctions utiles

1/ extraire d'une chaîne de caractères uniquement les lettres /ou les nombres:

@Echo oFF
Setlocal EnableExtensions

Call :Xtract 65446gjkngd5343dflgd
set substr 
Endlocal & goto :eof
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:Xtract  %1=chaîne de caractères  %2=paramètre optionnel [$str]
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
Setlocal enableExtensions
If [%2]==[$str] Set "v1=-v" & set "v2=^"
Set is=%~1
For /F "Tokens=2 Delims=:" %%# In ('
  "%Comspec% /u /cEcho:%is%|More|FindStr -o .|FindStr %v1% ".*:[%v2%0-9]"
 ') do Call Set substr=%%substr%%%%#
Endlocal & Set "substr=%substr%" & goto :eof

voici quelques exemples:

Call :xtract "45ds8f9558fr5r585f854447r"  
echo %substr%

c:\> tst.bat

45895585585854447


Call :xtract "45ds8f9558fr5r585f854447r"  $str
echo %substr%

c:\> tst.bat

dsffrrfr

2/ afficher les propriétés avancées d'un fichier:

:AdvancedProp
Setlocal EnableExtensions
If Not Exist "%~f1" Exit /B 2
For %%x In (
    "0:$Nom","1:$Taille","2:$Type","3:$Date.Modif"
    "4:$Date.Create","5:$Date.Access","6:$Attribut"
    "7:$Etat","8:$Proprietaire","9:$Auteur"
    "10:$Titre","11:$objet","12:$Categorie"
    "14:$Commentaire","15:$Copyright","16:$Artist"
    "17:$Titre.Album","18:$Annee","19:$Numero.Piste"
    "20:$Genre","21:$Duree","23:$Protege"
    "26:$Dimension","34:$Chaines","35:$Entreprise"
    "36:$Description","37:$Version.Fichier"
    "38:$Nom.Produit","39:$Version.Produit"
    "40:$Mots.Clefs" 
) Do For /F "Tokens=1* Delims=:" %%s In (%%x) Do (
   >$ Call :$Prop "%~1" %%s %%t 
     set "%%t="
     for /f "tokens=* delims=" %%a in ('
           "cscript -nologo -e:vbs $ & del $"
    ') Do %%a
     if defined %%t Set %%t
)
Endlocal & goto :EOF
:$Prop
echo Set o=createObject("shell.application").^
     namespace("%~dp1")
echo wsh.echo "set %3="^&o.^
     getdetailsof(o.parsename("%~nx1"),%2)
Exit /B 0


Call :AdvancedProp "%windir%\explorer.exe"

3/ Lire un fichier à l'envers:

:fileRev
for /f "tokens=1* delims=][" %%s in ('

find /n /v "" ^< %1') do (
    Set "tab[%%s]=%%t"
    if not defined tab[%%s] set tab[%%s]=µµµ
    Set nline=%%s
)
for /l %%i in (%nline% -1 1) Do (
  for /f "tokens=1* delims=µ=" %%_ in ('

set tab[%%i]

') do echo=%%_
)
goto:eof


Call :fileRev "mon fichier de test.txt"

4/ Convertir une chaîne de caractères en majuscule:

:ucase
for /f "tokens=1* delims=µ" %%a in ('
  "tree \µµµ%1|find ":\""
  ') do set "ucase=%%b"
goto:eof

 

Call :ucase "tunisia"

5/ Inverse une chaîne de caractère:

:reverse
for /f "tokens=1* delims=:" %%a in ('
    "%comspec% /u /c echo:%~1|more|findstr /o ."
 ') do set "reverse=%%b!reverse!"
goto:eof

 

 Call :reverse "vive palestine"

6/ a* Convertir un nombre décimal en hexa

:tohexa
Setlocal enableextensions
set hx=0x0
Set exp=%comspec% /cexit/b %1^&set;^|find "^=ExitCode^="
for /f "tokens=1* delims=0=" %%a in ('
      "%exp%" % expression evalue %
') do Set hx=0x%%b
Endlocal & Set "hex=%hx%" & goto :eof


 set hex=98
 set hex
 Call :tohexa %hex% && Set hex

6/ b* Convertir un nombre décimal en hexa:

:tohexa
for /f "tokens=1,3" %%i in ('^(
 reg add hkcu\console /v hexa /t reg_dword /d %1 /f ^&
 reg query hkcu\console /v hexa  ^&
 reg delete hkcu\console /v hexa /f
 ^)^|find "REG_DWORD"') do Set %%i=%%j
goto:eof

 

set hexa=685

set hexa & Call :tohexa %hexa% & set hexa

7/ Compter le nombre de répétition d'une lettre:

:CountChar
for /f %%: in ('
  "%comspec% /u /c echo:%~1|more|sort"
 ') do Set /A "$[%%:]+=1"
goto:eof


Call :CountChar "tunisia and africa"
Set $[

8/ Supprimer les espaces de plus en debut/fin d'un string:

@echo off 
(set Ch=    ceci    est un simple test   )
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
set path=%path%;D:\Program Files\GnuWin32\bin
set e="s_^\s*__;s_\s*$__;s_^_del %%0\&set %%1=&_w ~.Cmd"
echo [%Ch%]
echo\%Ch%|1>&0 sed %e%
2>Nul=(call ~.Cmd ch)
echo [%Ch%]&goto:EOF :::::GnuSED Version 4.2::::::::::::::::

Compter le nombre de caractères

2010-06-19T08:01:00.000-07:00

VBS-LIKE

@echo off
call:LCount %*
echo %length%
goto:EOF
:LCount
echo/wsh.echo "set length="^&Len("%*")>..vbs
cscript/nologo ..vbs>..bat
for %%. in (call del) do %%. ..bat ..vbs
goto:EOF

VBS-LIKE

@echo off
echo\Input=Inputbox("String:","Input")>..vbs
echo\wsh.echo "set length="^&Len(Input)>>..vbs
cscript/nologo ..vbs>..bat
for %%. in (call del) do %%. ..bat ..vbs
echo\%length%
pause

VBS-LIKE

@echo off
set str=%*
echo>len.vbs c=len(wsh.arguments.item(0)):wsh.echo c
for /f  %%i in ('cscript/nologo len.vbs "%str%"') do set len=%%i
echo LENGTH=%len%
del len.vbs
goto:EOF

NATIVE

Set Str=hello
for /f "tokens=1* delims=[]" %%a in ('
  "%comspec% /u /c echo:%Str%|more|find /n /v """
 ') do set /a "length=%%a-4"
goto:eof

Remplacement de chaine de caractères

2010-06-19T03:07:00.000-07:00

voici quelques méthodes, parmis d'autres, pour remplacer une chaîne de caractères par une autre, avec un fichier batch

1-Utilisation de l'utilitaire Edlin

@echo off
REM batfile infile "search" "rep"
REM EXEMPLE: batfile test.txt a A
REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
set/p="1r%~2"-
copy /a -+nul>nul
set/p="%~3"--
copy /b -+-- --->nul
echo.>>---
echo>>--- w
echo>>--- 900a
echo>>--- e
type --- |>nul edlin /b %1
del - -- ---
goto:EOF

2- VBS-LIKE

@echo off
set file=a.txt
set oldstr=u
set newstr=#MAJ#

For %%A in (
  "do until Wsh.stdin.atendofstream    " 
  "  o="%oldstr%" :  n="%newstr%"      "
  "  ch=replace(wsh.stdin.readline,o,n)"
  "  Wsh.echo ch                       "
  "loop"
) do >>__.vbs echo\%%~A 
type %file% |>' cscript /nologo __.vbs && move ' %file%
del __.vbs
exit /b

naviguer dans la base de registre

2010-06-16T05:15:00.000-07:00

salut,

voici une astuce pour naviguer dans la base de registre assez facilement:
l'astuce consiste à copier la clef du registre dans la mémoire pour ensuite l'exploiter grâce à un utilitaire NIRCMD.EXE

raccourcis pour naviguer dans la base de registre from WALID on Vimeo.

.Bat VS .Cmd

2010-06-13T04:53:00.000-07:00

Les Fichiers de commandes MS-DOS connus sous le nom .BAT diffèrent des Scripts de commandes Windows NT connus sous le nom .CMD
Cette différence, n'est si grande, elle se situe fondamentalement sur la portabilité des .Bat au contraires des fichiers .CMD et l'intérprétation des erreurs retournées par quelques commandes internes à l'intérpréteur.

  @echo off 
  set test=CMD
  Call :sub 6
  set test=BAT
  If errorlevel 6 (echo BAT) else (echo CMD)
  goto:eof

  :sub
  exit /b %1
  goto :eof