Discussion :

[I'm_HERE]

salut,


En powershell on peux remplacer des chaines de caractères par plusieurs manières, nous allons examiner seulement les manières "officielles" qui sont au nombre de trois:


* la methode replace() de la classe 'System.string'
* l'operateur -replace et ses variantes -[ci]?replace
* la methode statique replace() de la classe 'Text.RegularExpressions.Regex'


1) methode replace() de la classe System.string

on peux voir la signature de cette methode en utilisant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
''.replace.overloaddefinition

string Replace(char oldChar, char newChar)
string Replace(string oldValue, string newValue)

cette methode n'utilise pas de Regex et est case-sensitive

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'developpEz'.replace('e','.')
d.v.loppEz

on peux chainer nos traitments pour avoir une unité plus complexe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'developpEz'.replace('e','.').replace('E','#')
d.v.lopp#z

cette methode nous permet d'utiliser les caracteres speciaux, pour plus de détails sur les caractères spéciaux vous pouvez voir l'aide "man about_Special_Characters":

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'developpEz'.replace('d',"`td")
        developpEz

la chaine à remplacer est litterale, donc on ne soucis plus d'échapper les caractères reservés des Regex:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > '$developpez'.replace("$","^")
^developpez

A/ Avantage:
------------

cette méthode est simple, nous permet de manipuler les caractères reservé sans se soucier de les échapper et en plus elle est rapide:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
PS > $s = 'a*' * 100000
PS > (measure-command { $s.replace("*","#") }).TotalMilliseconds
4,745

PS > (measure-command { $s -replace "\*","#" }).TotalMilliseconds
108,828

PS > (measure-command { [regex]::replace($s ,"\*","#") }).TotalMilliseconds
95,09

B/ limites


si on veux faire un remplcement plus complexe, cette méthode ne suffira plus


2) operateur -replace et ses variantes:

Si nous voulons un traitement plus sophistiqué (mais pas trop) on peux utiliser l'operateur -replace, qui permet d'utiliser des Regex

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'developpEz' -replace 'e','.'
d.v.lopp.z

comme vous pouvez le voir, cet operateur n'est pas case sensitive, pour qu'on change se comportement on peux soit utiliser sa variante '-creplace'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'developpEz' -creplace 'e','.'
d.v.loppEz

ou bien utiliser le modificateur de case directement dans notre pattern:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'developpEz' -replace '(?-i)e','.'
d.v.loppEz

l'avantage du modificateur sera clarifier plus tard.

l'operateur -replace peux traiter une chaine comme il peux traiter une liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
PS > 'ABC','BBA','DFF' -replace 'A','.'
.BC
BB.
DFF

on peux utiliser des references pour nos captures:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'Ppooooowwweeershhhhhheell' -replace '(.)\1*(?!$)','$1'
Powershell

dans notre exemple on a utiliser des references numeriques '\1' et '$1' (remarque: la syntaxe '\1' est utiliser dans la parti du pattern, la syntaxe '$1' est utilisé dans la partie de remplacement) qui sont des copies de la capture '()', sachant que les Regex du moteur .NET nous offre aussi la possibilité d'utiliser des reference nommé \k<hello>:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'Ppooooowwweeershhhhhheell' -replace '(?<hello>.)\k<hello>*(?!$)','$1'
Powershell

puisque l'operateur -replace utilise les regexp, quelques caractères deviennent spéciales, pour les échapper et les utiliser littéralement on peux: soit les échapper manuellement soit utiliser la fonction statique Escape():

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
PS > '\\\\\' -replace '\','.'
Mode d'expression régulière non valide*: \.

PS > '\\\\\' -replace [regex]::Escape('\'),'.'
.....

A/ Avantage:
------------
cet opérateur supporte les Regex, peux être chainer et est facile d'utilisation

B/ limites
---------------

il ne supporte pas "les expressions lambda" et n'a pas d'options avancées comme est le cas pour la méthode statique de la classe 'Text.RegularExpressions.Regex'

3)a) methode statique replace()

la methode statique replace() de la classe 'Text.RegularExpressions.Regex' est sensible à la case:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > [Regex]::replace('DEVeloppez','[a-z]','.')
DEV.......

si on regarde sa signature:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
[regex]::Replace.OverloadDefinitions

static string Replace(string input, string pattern, string replacement)
static string Replace(string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options)
static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator)
static string Replace(string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator,
System.Text.RegularExpressions.RegexOptions options)

on constate qu'elle nous offre plusieurs autre possibilitées, on peux utiliser des options plus avancées pour notre regex:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
PS > [enum]::getnames([Text.RegularExpressions.RegexOptions])

None
IgnoreCase
Multiline 
ExplicitCapture
Compiled
Singleline
IgnorePatternWhitespace
RightToLeft	
ECMAScript

quelques options ont leurs propres modificateurs comme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
  (?x) IgnorePatternWhitespace
  (?i) IgnoreCase
  (?s) Singleline
  (?m) Multiline

on peux aussi combiner entre les options en les séparant par une virgule:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PS > $pat = @'
>>  ^       # le debut de la ligne
>>  .{3}    # n'importe quel caractère (trois fois)
>>  (?-i)   # respecter la casse pour ce bloc
>>  (?!     # tester la partie suivante pour voir s'il n' y a pas
>>     E    # caractère litteral 'e'
>>  )       # fermeture du groupe de negation non-capturant
>>'@
>>
PS > [Regex]::replace(
>>   'DEVeloppez',
>>    $pat,
>>    '###',
>>    'ignorecase,IgnorePatternWhitespace'
>> )
>>
###eloppez

dans ce regex on peux voir que le modificateur '(?-i)' prend le dessus sur l'option 'ignorecase', on pourra uiliser plusieurs modificateurs dans une même expression.

on peux aussi créer une "expression lambda" qu'on passe comme un scriptblock

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
PS > $s = 'ceci est un simple exemple'
PS > [regex]::replace(
>>     $s,
>>     '\b\w+\b',
>>     {
>>         param($word)
>>         $len = $word.length
>>        '{1}({0})' -f $len,$word
>>     }
>> )
>>
ceci(4) est(3) un(2) simple(6) exemple(7)

cette technique est comparable a celle-ci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > {param($s) $s * $s}.invoke(9)
81

3)b) caster une chaine de caractères/et ou variable en [regex]:

une autre methode est de caster une chaine de caractere

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$re = [regex]'kb\d+'

ou bien caster une variable:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
[regex]$re = 'kb\d+'

la difference entre les deux cast est que la premiere affecte uniquement la valeur de la variable tandis que la derniere affecte la variable elle même:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
PS > $re = [regex]'kb\d+'
PS > $re.GetType().fullname
System.Text.RegularExpressions.Regex

PS > $re = 1
PS > $re.GetType().fullname
System.Int32

PS > [regex]$re = 'kb\d+'
PS > $re.GetType().fullname
System.Text.RegularExpressions.Regex

PS > $re =ls
Impossible de convertir la valeur «*System.Object[]*» du type «*System.Object[]*» en type «*System.Text.RegularExpressions.Regex*»

si on observe la signature de cette variante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
$regex = [regex]'h'
$regex.Replace.OverloadDefinitions

string Replace(string input, string replacement)
string Replace(string input, string replacement, int count)
string Replace(string input, string replacement, int count, int startat)
string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator)
string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count)
string Replace(string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat)

nous pouvons voir qu'il y a deux nouvelles options 'count' et 'startat' qui sont de type 'int', l'argument 'count' est le nombre de match que le regex doit matcher, l'argument 'startat' est la position du match reussi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
PS > $regex = [regex]'\d'
PS > $text = '0123456789'
PS > $regex.Replace($text,'#')
##########

PS > $regex.Replace($text,'#',1)
#123456789

PS > $regex.Replace($text,'#',3,4)
0123###789

PS > $regex.Replace($text,
>>                '#',
>>                -1,
>>                <#
>>                  '-1' toute la chaine
>>                   ou bien: $text.length
>>                #>
>>                4)
>>
0123######

A/ Avantage:

elle permet d'utiliser toute la puissance des Regex .NET avec ses options avancées et les expressions-lambda

B/ limites



les expressions lambda peuvent aider enormement mais peuvent aussi rendre nos codes cryptic.
cette méthode n'est pas aussi flexible que l'opérateur -replace


dans cette brief explication j'ai essayé de m'eloigner le plus possible des Regex pour que l'explication ne devienne un tutoriel sur les Regex plutot qu'un tutoriel sur les méthodes 'officiels' de remplacement et la difference entre chaqu'une d'elle, mais après avoir relu ce petit how-to , je me suis apercu que separer entre les Regex et le but de ce petit tutoriel est plus difficile pour moi que je ne l'imagineais

toute autre contribution/critique est la bien venu.

[sachadee]

Un grand merci pour ces explications.

[Laurent Dardenne]

Bonjour Walid,
très bon post intéressant.

Voici qq remarques.

mais après avoir relu ce petit how-to, je me suis apercu que séparer entre les Regex et le but de ce petit tutoriel est plus difficile pour moi
que je ne l'imaginais

Pour en comprendre le fond, effectivement un des prérequis est de connaître les regex, sujet délicat à aborder pour les lecteurs débutant.

les manières "officielles"

Il serait intéressant de connaître celles qui ne le sont pas :-)

1) methode replace() de la classe System.string
...
B/ Inconvénient
---------------
si on veux faire un remplacement plus complexe, cette méthode ne suffira plus

Pour moi, c'est plus une limite qu'un inconvénient.

Autre point à détailler, coupler la substitution powershell et l'opérateur -replace. Exemple remplacer '$Variable_Total' par '$Compteur_Total' via une variable powershell :

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$NewName='Compteur'
'$Variable_Total' -replace '\$variable_(.*)',"${NewName}_`$1"

Plus 'tordu', remplacer 'Variable_Total' par '$Variable_Compteur_Total' :

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

'Variable_Total' -replace '(variable)_(.*)',"`$$`$1_${NewName}_`$2"

Tu parles d'expressions lambda, pour PS V2 c'est plutôt la notion de délégué dotnet que j'utiliserais qui n'est autre qu'un scriptblock :

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 #Variable globale nécessaire
$global:PatternCount=0
 
 #crée un délégué, c'est à dire sous PS un scriptblock  
$delegate=  {
    # Renvoi le paramètre en minuscule < paramètre >
    #Exemple, pour la lettre E , on renvoi <e>
  "<$($args[0].ToString().ToLower())>"
    # et le nombre de remplacement
  $global:PatternCount++
}
 # on recherche toutes les occurences d'une lettre en majuscule
$re = [regex] "[A-Z]"
# On transforme le texte
 
 #Renvoi la chaîne transformée dans le pipeline
"Ceci est du TEXTE" |
 ForEach-object { $re.Replace($_, $delegate) }
 
 # Affichage du résultat
"`nNombre de remplacement: $PatternCount"
 
#renvoi
#
#<c>eci est du <t><e><x><t><e>
#Nombre de remplacement: 6

Pour

une autre méthode est de caster une chaîne de caractère:

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

$re = [regex]'kb\d+'

Ici, je reste dubitatif sur l'usage du terme cast, c'est plus un raccourci d'écriture équivalent à un appel de constructeur

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
$re = new-object regex 'kb\d+'
#regex(string)

Pourtant avec ceci on est tenté de penser qu'il s'agit bien d'un cast :

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

Trace-Command typeconversion -ex {$re = [regex]'kb\d+'} -pshost

En passant, si la variable est déjà typée le 'cast' ne fonctionne pas:

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
[int]$re = 10
$re = [regex]'kb\d+'

Pour :

cette méthode n'est pas aussi flexible que l'opérateur -replace

Pour moi c'est plus une différence, celle-ci n'étant pas un inconvénient. On doit juste connaitre les 3 approches et leurs limites respectives.

Les expressions lambda peuvent aider énormément mais peuvent aussi rendre nos codes cryptiques.

Personnellement je ne vois pas en quoi. Certes, c'est du code avancé, mais pas incompréhensible ni illisible.
Le code suivant incrémente le nom d'une VM :

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Function New-VMName {
   Param(
     [string] $InputObject, 
      #(?is) pour IgnoreCase,SingleLine
     [string] $Pattern='(?is)(?<Prefix>VM)(?<Numero>\d+)', 
     [System.Text.RegularExpressions.MatchEvaluator] $Evaluator={"$($Args[0].Groups['Prefix'].Value)$(1+$Args[0].Groups['Numero'].Value)"}
   )
 Write-debug "Input: $InputObject" 
 $Result=[regex]::Replace($InputObject,$Pattern,$Evaluator)
 
 Write-debug "result : $result"    
 if ($InputObject -eq $Result)
 { 
   Write-Error "New-VMName pas de correspondance pour $Input"
   #renvoi $null dans le pipeline
 }
 else                                                        
 {Return $Result}
}#New-VMName
 
$s="VM19"
 
New-VMName $s
#renvoi 'VM20'

En quoi l'appel suivant pose problème ?

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

 $Result=[regex]::Replace($InputObject,$Pattern,$Evaluator)

En revanche, si tu ne sais pas lire ce code, effectivement il apparaît 'crypté', mais il ne l'est pas.

Pour finir, un mot sur les captures nommés compléterais, à mon avis, ce How-to.

Un lien à connaitre sur les regex : http://msdn.microsoft.com/fr-fr/libr...8VS.80%29.aspx

Et deux tutoriaux :
http://lgmorand.developpez.com/dotnet/regex/
http://stormimon.developpez.com/dotn...ns-regulieres/

Enfin une fonction dédiée au replace.

[I'm_HERE]

salut sachadee, Laurent,

merci Laurent pour tes remarques,

il serait intéressant de connaitre celles qui ne le sont pas

on peux utiliser, par exemple, des methodes de la classe system.string, prenant comme exemple: remplacer les trois premiers caractéres de la chaine $s par '123'

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
PS > $s = 'abc456789'
PS > $s.Remove(0,3).insert(0,'123')
123456789

PS > # $s -replace '^.{3}','123'

ou, remplacer tous les caractères majuscules par 'rien':

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
PS > $s = 'abcABCdef'
PS > -join ($s -split {[char]::IsUpper($_)})
abcdef

PS > # $s -creplace '[A-Z]'

pour moi c'est plus une limite qu'un inconvenient

je vais changer inconvenient par limite car il me semble le mot le plus approprié.

PS > $NewName='Compteur'
PS > '$variable_Total' -replace '\$variable_(.*)',"${newname}_`$1"

ici on n'a pas besoin de capturer le groupe '$1', le moteur regex fait le boulot tout seul.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
PS > '$variable_Total' -replace '\$variable',"${newname}"
PS > # ou bien:
PS >'$variable_Total' -replace [regex]::escape('$variable'),"${newname}"

PS > 'Variable_Total' -replace '(variable)_(.*)',"`$$`$1_${NewName}_`$2"

on peux simplifier:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
PS > 'Variable_Total' -replace 'variable_',"`$$`$&${NewName}_"
$Variable_Compteur_Total

pour comprendre le mechanisme de fonctionnement il faut comprendre les règles d'utilisation des guillemets simples et doubles dans PS, c'est important, pour ceci on peux jetter un coup d'oeil a:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
PS > man about_Quoting_Rules

aussi il faut differencier entre les groupes nommés et les variables securisées qui sont deux choses complétement differentes:

cette syntaxe ${variable} a plusieurs roles:

- elle permet d'utiliser des caractères spéciales dans une variable:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
PS > ${ma variable} = 1
PS >  ${ma variable}
1

- mais aussi elle permet de securiser la variable:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
PS > $variable = 'dev'
PS > "$variableeloppez.com"
.com
PS > "${variable}eloppez.com"
developpez.com

cette syntaxe peux, par contre, confondre avec les groupes nommés:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
PS > $S = '####'

PS > ":aaaa :123 :bbb" -replace ':(?<S>\d+)','(${S})'
:aaaa (123) :bbb

PS > ":aaaa :123 :bbb" -replace ':(?<S>\d+)',"${S}"
:aaaa #### :bbb

PS > ":aaaa :123 :bbb" -replace ':(?<S>\d+)',"${S} (`${S})"
:aaaa #### (123) :bbb

donc il faut faire attention avec l'utilisation des guillemets.

tu parles d'expression lambda en PS2 c'est plutot un délégué

une expression lambda et les délégués sont au fond une même chose, quoique les expressions lambda en PS (ou délégué) sont plus puissants que ceux d'autres langages comme en python par exemple qui ne permet pas de structures complexes comme les if/elif/else et les exceptions dans ses expressions lambda..en PS on peux faire une chose du genre sans probleme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
PS > $s = "265596236"
PS >
PS > [regex]::replace($s,'\d',{
>>    $m = $args[0].value
>>    if($m -gt 5) {"+$m"} else {"-$m"}
>> })
>>
-2+6-5-5+9+6-2-3+6

personnelement je ne vois pas en quoi, Certes, c'est du code avancée, mais pas incompréhensible ni illisible

le lecteur n'est pas forcement un codeur PS avancée ou confirmé, je voulais par ce post non pas seulement expliquer des techniques pour le remplacement mais aussi simplifier au maximum pour que tous les lecteurs essayent de pratiquer une chose qu'ils comprennent.

enfin une fonction dédié au replace

merci pour ta contribution.

[Laurent Dardenne]

on peux utiliser, par exemple, des methodes de la classe system.string

Ok, je comprends mieux.

je vais changer inconvenient par limite car il me semble le mot le plus approprié.

Toutes ont été codées via des spécifications, elles ne font donc que ce qu'on leur a demandé.

ici on n'a pas besoin de capturer le groupe '$1', le moteur regex fait le boulot tout seul.

Tu as raison. J'avais un tête une réorganisation de la chaîne.

pour ceci on peux jetter un coup d'oeil a:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
PS > man about_Quoting_Rules

Comme quoi la doc de PS contient de nombreuses informations ;-)

Une expression lambda et les délégués sont au fond une même chose,

Oui, je sais. C'était plus pour éviter une possible confusion avec LINQ. Mais il s'agit là de considérations avancées.

le lecteur n'est pas forcement un codeur PS avancée ou confirmé, je voulais par ce post non pas seulement expliquer des techniques pour le remplacement, mais aussi simplifier au maximum pour que tous les lecteurs essayent de pratiquer une chose qu'ils comprennent.

Dit ainsi je comprend mieux.
L'usage de 'cryptique' laisse supposer que la notion de délégué est qq chose de 'compliqué', alors que c'est juste une question de niveau de connaissances.
Je me disais qu'à la lecture de ce paragraphe, un débutant pouvait considérer cet aspect comme inaccessible.

J'ai pu lire du code 'cryptique' sans pour autant que l'auteur utilise des délégués...

[animetheque]

bonjour , je dispose d'une importante liste de fichiers a traiter , j'ai besoin de corriger leurs noms mais il me semble qu'ils sont nommé en cp1252 ce qui donne " é " a la place de " é " etc etc etc , je n'ai que des connaissances de base au niveau des batch et pas en vb

j'aimerai connaitre la meilleur solution pour corriger ces fichiers , qu'on m'aiguille au moins apres j'essayerai de bidouiller de mon coter ^^ ( ou si quelqu'un connais un renommeur de masse ou un programme du genre qui permet de corriger de type d'erreur je suis preneur )

thx

[hackoofr]

bonjour , je dispose d'une importante liste de fichiers a traiter , j'ai besoin de corriger leurs noms mais il me semble qu'ils sont nommé en cp1252 ce qui donne " é " a la place de " é " etc etc etc , je n'ai que des connaissances de base au niveau des batch et pas en vb
j'aimerai connaitre la meilleur solution pour corriger ces fichiers , qu'on m'aiguille au moins apres j'essayerai de bidouiller de mon coter ^^ ( ou si quelqu'un connais un renommeur de masse ou un programme du genre qui permet de corriger de type d'erreur je suis preneur )

Je crois que Sachadee a posté quelque chose de similaire : [BAT/PowerShell] Remplacer un string dans un fichier

[animetheque]

merci je vais voir de ce coté la

[correcteur]

"On peux..." sera plutôt "On peuT..."

Je peuX
Tu peuX
Il (On) peuT
Nous pouvons
Vous pouvez
Ils peuvent

[I'm_HERE]

@correcteur

d'accord merci mais ça aurait été plus amiable si ton ton était plus sympa...en plus je ne suis pas francophone donc j'essaye d'aider les membres et de me faire comprendre du mieux que je peux

[Laurent Dardenne]

Le comble pour un correcteur :
Manquer de correction.

[Docserta]

Bonjour,

Je souhaite remplacer une chaine comprise dans une liste (Jan., Fev. ,Mar., avr., etc..)
par une autre valeur comprise dans une autre liste (01, 02 ,03, etc..)

Merci de votre attention

[Docserta]

J'ai utilisé Switch et ça marche.

Code PowerShell :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
$Mois = switch ($args[0]) `
{
"Jan." {01};
"Fev." {02};
"Mar." {03};
"Avr." {04};
"Mai." {05};
"Jun." {06};
"Jul." {07};
"Aou." {08};
"Sep." {09};
"Oct." {10};
"Nov." {11};
"Dec." {12};
default {01}
}

Peut être y a il mieux ?