Come ottenere Select-Object per restituire un tipo non elaborato (ad esempio String) anziché PSCustomObject?
https://stackoverflow.com/questions/618749
-
03-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Il codice seguente mi fornisce un array di PSCustomObjects, come posso ottenerlo per restituire un array di stringhe?
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Il codice seguente mi fornisce un array di PSCustomObjects, come posso ottenerlo per restituire un array di stringhe?
<*>
(Come domanda secondaria, a che cosa serve la parte psiscontainer? L'ho copiato da un esempio online)
Modifica post-accettazione: Due grandi risposte, vorrei poterle segnare entrambe. Hanno assegnato la risposta originale.
.psiscontainer)}
(Come domanda secondaria, a che cosa serve la parte psiscontainer? L'ho copiato da un esempio online)
Modifica post-accettazione: Due grandi risposte, vorrei poterle segnare entrambe. Hanno assegnato la risposta originale.
Soluzione
Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach {'hello'; Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach {'hello'; Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach {'hello'; Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
$files = Get-ChildItem $directory -Recurse | Select-Object FullName | Where-Object {!( Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
Get-ChildItem $directory -Recurse
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
Select-Object FullName
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName; 1; 2; 3}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)} | foreach { Devi solo selezionare la proprietà che desideri dagli oggetti. FullName in questo caso.
<*>
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.FullName}
Modifica: Spiegazione per Mark, che chiede, " Che cosa fa la foreach? Che cos'è l'enumerazione? & Quot;
La spiegazione di Sung Meister è molto buona, ma aggiungerò una guida qui perché potrebbe essere utile.
Il concetto chiave è la pipeline. Immagina una serie di palle da ping-pong che rotolano giù da uno stretto tubo uno dopo l'altro. Questi sono gli oggetti nella pipeline. Ogni fase della pipeline - i segmenti di codice separati da caratteri pipe (|) - ha una pipe che vi entra e la pipe che ne esce. L'uscita di uno stadio è collegata all'ingresso dello stadio successivo. Ogni fase prende gli oggetti quando arrivano, fa loro le cose e li rimanda nella pipeline di output o invia nuovi oggetti di sostituzione.
<*>
Get-ChildItem attraversa il filesystem creando oggetti FileSystemInfo che rappresentano ogni file e directory che incontra e li inserisce nella pipeline.
<*>
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
<*>
Questo è un filtro. Prende ogni oggetto, lo esamina e lo rimanda indietro o lo scarta a seconda di una condizione. Il tuo codice qui ha un bug, comunque. Gli oggetti personalizzati che arrivano qui non hanno una proprietà psiscontainer. Questa fase in realtà non fa nulla. Il codice di Sung Meister è migliore.
<*>
Foreach, il cui nome lungo è ForEach-Object, afferra ogni oggetto quando arriva, e qui prende la proprietà FullName, una stringa, da esso. Ora, ecco la parte sottile: qualsiasi valore che non viene consumato, ovvero non viene acquisito da una variabile o soppresso in qualche modo, viene inserito nella pipeline di output. Come esperimento, prova a sostituire quella fase con questa:
<*>
Provalo ed esamina l'output. Esistono quattro valori in quel blocco di codice. Nessuno di loro viene consumato. Si noti che appaiono tutti nell'output. Ora prova questo:
<*>
Si noti che uno dei valori viene acquisito da una variabile. Non viene visualizzato nella pipeline di output.
.psiscontainer)}
Select-Object prende ogni oggetto FileSystemInfo man mano che arriva, prende la proprietà FullName da esso (che in questo caso è un percorso), inserisce quella proprietà in un oggetto personalizzato nuovo di zecca che ha creato e inserisce l'oggetto personalizzato in la pipeline.
Altri suggerimenti
Per ottenere la stringa per il nome del file puoi usare
$files = Get-ChildItem $directory -Recurse | Where-Object {!( Per ottenere la stringa per il nome del file puoi usare
<*>
Il parametro -ExpandProperty consente di recuperare un oggetto in base al tipo di proprietà specificata.
Ulteriori test mostrano che questo non ha funzionato con V1, ma che la funzionalità è stata risolta a partire dal CTP3 V2.
.psiscontainer)} | Select-Object -ExpandProperty FullName
Il parametro -ExpandProperty consente di recuperare un oggetto in base al tipo di proprietà specificata.
Ulteriori test mostrano che questo non ha funzionato con V1, ma che la funzionalità è stata risolta a partire dal CTP3 V2.
Per la domanda n. 1
Ho rimosso " select-object " porzione - è ridondante e spostato "dove" filtra prima di " foreach " a differenza di dangph's answer - Filtra il più presto possibile in modo che tu abbia a che fare solo con un sottoinsieme di ciò che dovrai affrontare nella prossima pipeline.
$files = Get-ChildItem $directory -Recurse | Where-Object {! Per la domanda n. 1
Ho rimosso " select-object " porzione - è ridondante e spostato "dove" filtra prima di " foreach " a differenza di dangph's answer - Filtra il più presto possibile in modo che tu abbia a che fare solo con un sottoinsieme di ciò che dovrai affrontare nella prossima pipeline.
>pushd HKLM:\SOFTWARE
>ls | gm
Lo snippet di codice essenzialmente legge
- Ottieni ricorsivamente tutti i file percorso completo di tutti i file (directory Get-ChildItem $ -Recurse)
- Filtra le directory (Where-Object {! $ _. PsIsContainer})
- Restituisce solo il nome file completo (foreach {$ _. FullName})
- Salva tutti i nomi dei file in $ file
Nota che per foreach {$ _. FullName} , in powershell, viene restituita l'ultima istruzione in un blocco di script ({...}), in questo caso $ _. FullName di tipo stringa
Se hai davvero bisogno di ottenere un oggetto grezzo, non devi fare nulla dopo esserti sbarazzato di " select-object " ;. Se dovessi utilizzare Select-Object ma desideri accedere all'oggetto non elaborato, usa " PsBase " ;, che è una domanda completamente diversa (argomento) - Consulta " Che succede con PSBASE, PSEXTENDED, PSADAPTED e PSOBJECT? " per ulteriori informazioni sull'argomento
Per la domanda n. 2
E anche filtrare per ! $ _. PsIsContainer significa che stai escludendo oggetti a livello di contenitore - Nel tuo caso, stai facendo Get-ChildItem su un FileSystem (puoi vedere i provider PowerShell tramite Get-PsProvider), quindi il contenitore è un DirectoryInfo (cartella)
PsIsContainer indica cose diverse in diversi provider PowerShell;
es.) Per il provider Registro , PsIsContainer è di tipo Microsoft.Win32.RegistryKey
Prova questo:
get-help foreach
[AGGIORNAMENTO] alla seguente domanda: Che cosa fa la ricerca? Cos'è l'enumerazione?
Per chiarire, "quotare foreach" è un alias per " Foreach-Object "
Puoi scoprirlo attraverso,
get-alias foreach
- oppure -
<*>
Ora nella mia risposta, " foreach " sta enumerando ogni istanza di oggetto di tipo FileInfo restituito da pipe precedente (che ha filtrato le directory). FileInfo ha una proprietà chiamata Nome completo e questo è ciò che " foreach " sta enumerando.
E fai riferimento all'oggetto passato attraverso la pipeline attraverso una speciale variabile della pipeline chiamata " $ _ " che è di tipo FileInfo nel contesto del blocco di script di " foreach " ;.
.PsIsContainer} | foreach { Per la domanda n. 1
Ho rimosso " select-object " porzione - è ridondante e spostato "dove" filtra prima di " foreach " a differenza di dangph's answer - Filtra il più presto possibile in modo che tu abbia a che fare solo con un sottoinsieme di ciò che dovrai affrontare nella prossima pipeline.
<*>
Lo snippet di codice essenzialmente legge
- Ottieni ricorsivamente tutti i file percorso completo di tutti i file (directory Get-ChildItem $ -Recurse)
- Filtra le directory (Where-Object {! $ _. PsIsContainer})
- Restituisce solo il nome file completo (foreach {$ _. FullName})
- Salva tutti i nomi dei file in $ file
Nota che per foreach {$ _. FullName} , in powershell, viene restituita l'ultima istruzione in un blocco di script ({...}), in questo caso $ _. FullName di tipo stringa
Se hai davvero bisogno di ottenere un oggetto grezzo, non devi fare nulla dopo esserti sbarazzato di " select-object " ;. Se dovessi utilizzare Select-Object ma desideri accedere all'oggetto non elaborato, usa " PsBase " ;, che è una domanda completamente diversa (argomento) - Consulta " Che succede con PSBASE, PSEXTENDED, PSADAPTED e PSOBJECT? " per ulteriori informazioni sull'argomento
Per la domanda n. 2
E anche filtrare per ! $ _. PsIsContainer significa che stai escludendo oggetti a livello di contenitore - Nel tuo caso, stai facendo Get-ChildItem su un FileSystem (puoi vedere i provider PowerShell tramite Get-PsProvider), quindi il contenitore è un DirectoryInfo (cartella)
PsIsContainer indica cose diverse in diversi provider PowerShell;
es.) Per il provider Registro , PsIsContainer è di tipo Microsoft.Win32.RegistryKey
Prova questo:
<*>
[AGGIORNAMENTO] alla seguente domanda: Che cosa fa la ricerca? Cos'è l'enumerazione?
Per chiarire, "quotare foreach" è un alias per " Foreach-Object "
Puoi scoprirlo attraverso,
<*>
- oppure -
<*>
Ora nella mia risposta, " foreach " sta enumerando ogni istanza di oggetto di tipo FileInfo restituito da pipe precedente (che ha filtrato le directory). FileInfo ha una proprietà chiamata Nome completo e questo è ciò che " foreach " sta enumerando.
E fai riferimento all'oggetto passato attraverso la pipeline attraverso una speciale variabile della pipeline chiamata " $ _ " che è di tipo FileInfo nel contesto del blocco di script di " foreach " ;.
.FullName}
Lo snippet di codice essenzialmente legge
- Ottieni ricorsivamente tutti i file percorso completo di tutti i file (directory Get-ChildItem $ -Recurse)
- Filtra le directory (Where-Object {! $ _. PsIsContainer})
- Restituisce solo il nome file completo (foreach {$ _. FullName})
- Salva tutti i nomi dei file in $ file
Nota che per foreach {$ _. FullName} , in powershell, viene restituita l'ultima istruzione in un blocco di script ({...}), in questo caso $ _. FullName di tipo stringa
Se hai davvero bisogno di ottenere un oggetto grezzo, non devi fare nulla dopo esserti sbarazzato di " select-object " ;. Se dovessi utilizzare Select-Object ma desideri accedere all'oggetto non elaborato, usa " PsBase " ;, che è una domanda completamente diversa (argomento) - Consulta " Che succede con PSBASE, PSEXTENDED, PSADAPTED e PSOBJECT? " per ulteriori informazioni sull'argomento
Per la domanda n. 2
E anche filtrare per ! $ _. PsIsContainer significa che stai escludendo oggetti a livello di contenitore - Nel tuo caso, stai facendo Get-ChildItem su un FileSystem (puoi vedere i provider PowerShell tramite Get-PsProvider), quindi il contenitore è un DirectoryInfo (cartella)
PsIsContainer indica cose diverse in diversi provider PowerShell; es.) Per il provider Registro , PsIsContainer è di tipo Microsoft.Win32.RegistryKey Prova questo:
<*>[AGGIORNAMENTO] alla seguente domanda: Che cosa fa la ricerca? Cos'è l'enumerazione? Per chiarire, "quotare foreach" è un alias per " Foreach-Object " Puoi scoprirlo attraverso,
<*>- oppure -
<*> Ora nella mia risposta, " foreach " sta enumerando ogni istanza di oggetto di tipo FileInfo restituito da pipe precedente (che ha filtrato le directory). FileInfo ha una proprietà chiamata Nome completo e questo è ciò che " foreach " sta enumerando.
E fai riferimento all'oggetto passato attraverso la pipeline attraverso una speciale variabile della pipeline chiamata " $ _ " che è di tipo FileInfo nel contesto del blocco di script di " foreach " ;.
Per V1, aggiungi il seguente filtro al tuo profilo:
filter Get-PropertyValue([string]$name) { Per V1, aggiungi il seguente filtro al tuo profilo:
gci . -r | ?{! Per V1, aggiungi il seguente filtro al tuo profilo:
filter Get-PropertyValue([string]$name) { Per V1, aggiungi il seguente filtro al tuo profilo:
<*>
Quindi puoi farlo:
<*>
A proposito, se stai utilizzando le Estensioni della community di PowerShell hai già questo.
Per quanto riguarda la capacità di usare Select-Object -Expand in V2, è un trucco carino ma non ovvio e non è proprio quello per cui Select-Object né -Expand erano pensati. -Expand si basa sull'appiattimento come SelectMany di LINQ e Select-Object riguarda la proiezione di più proprietà su un oggetto personalizzato.
.$name }
Quindi puoi farlo:
<*>
A proposito, se stai utilizzando le Estensioni della community di PowerShell hai già questo.
Per quanto riguarda la capacità di usare Select-Object -Expand in V2, è un trucco carino ma non ovvio e non è proprio quello per cui Select-Object né -Expand erano pensati. -Expand si basa sull'appiattimento come SelectMany di LINQ e Select-Object riguarda la proiezione di più proprietà su un oggetto personalizzato.
.psiscontainer} | Get-PropertyName fullname
Quindi puoi farlo:
<*>
A proposito, se stai utilizzando le Estensioni della community di PowerShell hai già questo.
Per quanto riguarda la capacità di usare Select-Object -Expand in V2, è un trucco carino ma non ovvio e non è proprio quello per cui Select-Object né -Expand erano pensati. -Expand si basa sull'appiattimento come SelectMany di LINQ e Select-Object riguarda la proiezione di più proprietà su un oggetto personalizzato.
.$name }
Quindi puoi farlo:
<*>A proposito, se stai utilizzando le Estensioni della community di PowerShell hai già questo.
Per quanto riguarda la capacità di usare Select-Object -Expand in V2, è un trucco carino ma non ovvio e non è proprio quello per cui Select-Object né -Expand erano pensati. -Expand si basa sull'appiattimento come SelectMany di LINQ e Select-Object riguarda la proiezione di più proprietà su un oggetto personalizzato.
