בתקופה הקרובה אני אנסה לכתוב הסברים על הכלי הנ"ל מבית היוצר מיקרוסופט.
אתם מוזמנים להגיב בשאלות/הבהרות והסברים משלכם, כמה שתתעניינו יותר - ככה אני ארצה להשקיע באשכול הזה יותר, ככה שכדאי לכם
אין צורך בידע מוקדם מלבד הכרת פקודות בסיסיות של דוס (או CMD) וראש פתוח.
אז שנתחיל?

POWERSHELL, או בשמו הקודם MSH (קיצור לmicrosoft shell) או בשם הקוד הקודם שלו monad, הוא שם לכלי שצפוי בעתיד להחליף את הprompt הישן והמוגבל של חלונות (הידוע יותר כ - cmd או command)
הכלי נועד לביצוע פעולות והרצת סקריפטים אשר יקלו את העבודה על מנהלי הרשתות/מפעילי המחשב למיניהם.
במובן מסויים הוא מאוד דומה לshell-ים השונים מעולם הלינוקס הן במבנה הפקודות והן בצורת העבודה, אך קיים הבדל מהותי עליו נרחיב בהמשך (ואני מקווה שאנשי הלינוקס לא ישתלו אותי כאן בגלל זה).

עכשיו שהבנו (בערך) בשביל מה נוצר הpowershell, בואו נתקין ונראה על מה מדובר.
כדי להפעיל את הpowershell צריך קודם כל להתקין על המחשב את ה .Net Framework 2 , שהוא בגדול סביבת ההרצה הווירטואליות למערכות .net (המקבילה של מיקרוסופט לjava)
אחרי התקנה של הframework אפשר סופסוף להתפנות ולהתקין את הpowershell .

בואו נפעיל את הpowershell:
start --> run --> powershell
אתם אמורים לקבל מסך שחור, מאוד דומה לcmd הישן ושם שאלה - האם אתם רוצים לאפשר הרצת powershell, מכיוון שזו המטרה שלנו, נענה לו "a", בשביל "always", כדי שלא יישאל אותנו בכול פעם מחדש.
לאחר שנענה לו, ולאחר המתנה ארוכה משהו, נקבל סופסוף את המסך הראשי:


בגלל שזהו פוסט ראשון בעניין, אני לא רוצה לצלול עמוק לתוך הפרטים העסיסיים, אז נתחיל עם קצת משחקים.
למי שבוער בעצמותיו ללמוד פקודות חדשות (למרות שאת הפוסט הבא אני כבר מפרסם) מוזמן לכתוב את הפקודה help (או את הפקודה man) ולראות אילו פונקציות בסיסיות(נקראות cmdlets) הpowershell נותן.

מה ההבדל בין CMD ?

חתימתכם הוסרה כיוון שלא עמדה בחוקי האתר. לפרטים נוספים לחצו כאן. תוכלו לקבל עזרה להתאמת החתימה לחוקים בפורום חתימות וצלמיות.

אוביקטים

כל דבר שם הוא בעצם אוביקט ולא RAW DATA כמו ש-CMD פולט לך
הדבר הכי פשוט שאני יכול להשוות אליו את המערכת הזאת היא,
תחשוב על מערכת שמריצה VBS או C++ בלי צורך בקומפיילר
אז תיקח את כל היכולת של VBS ותיישם אותה בשורת פקודה (לא נשמע חזק מספיק )
קח לדוגמא את האשכול ששאלתי לגבי שינוי שמות בצורה אוטומטית ע"פ רשימת שמות מקובץ
שים לב כמה יכולת תיכנות המערכת נותנת לך ...

http://www.fresh.co.il/vBulletin/sh...ad.php?t=235026

שזה לא VBS, זה .Net
תן לי כמה "פרקים", ותתחיל להבין מה ההבדל

ההבדל בין cmd לבין powershell הוא מאוד גדול, אבל את רובו אתה לא רואה (לא עד שלא תצלול פנימה באמת בכול-אופן)
הדוגמה שתמחיש לך הכי מהר את ההבדלים בין ה-2 תהייה להפעיל את הפקודה help ב-2 התוכנות, פשוט תסתכל ותראה כמה אפשרויות נוספו לpowershell יחסית לcmd.

בנוסף לזה, בדיוק כפי שiceman אמר מלמעלה, צורת העבודה בpowershell שונה, במקום ליצור פונקציות סגורות ולא ניתנות לשינוי, כל הגישה עכשיו מבוססת על אובייקטים, תסתכל על הפוסט השני ותראה את המניפולציות שעשיתי על פקודת הdir.
בcmd לא היית יכול לעשות את זה, היו לך מניפולציות מאוד בסיסות שיכלת לעשות על הפקודה הזו, אבל כולן היו מוגדרות מראש והיית מוגבל רק אליהן (תכתוב בCMD את הפקודה dir /? כדי לראות אותן)
בהמשך אתה תראה מה עוד אפשר לעשות "סתם כי אתה יכול"

לא... מטרת ההודעה הזו היא לא ללמד אתכם אינסטלצייה, אלא להסביר 2 מהרעיונות היותר בסיסיים בpowershell.
אני מזהיר מראש, ההסברים לא הכי מובנים, לא להיבהל - אתם מוזמנים לשאול כמה שאלות שאתם רוצים.

צינורות (Pipelines) (מקור - help about_pipelines תחת powershell)
מטרת הצינור הינה לאחד פקודות בpowershell (ייקרא בקיצור PS החל מעכשיו).

הPS מאפשר לאחד 2 או יותר פקודות לתוך פקודה אחת שלמה. כאשר 2 פקודות משורשרות אחת לשנייה באמצעות צינור, הפקודה הראשונה מעבירה לבאה אחריה אובייקט (יוסבר בהמשך) אחד או יותר, הפקודה השנייה, לאחר ביצוע פעולתה על האובייקט תעביר את האובייקט החדש לפקודה השלישית, וכך-הלאה, עד שכול הפקודות מסיימות את פעולתן.

כדי לאחד 2 פקודות (או יותר) יש לכתוב אותן לפי סדר הריצה הרצוי, ולכתוב ביניהן את התו "|" (קו אנכי)

אובייקטים (objects) (מקור - help about_objects תחת powershell)
כל פעולה שמבצעים בPS מתבצעת כחלק מאובייקט.
כאשר מידע עובר מפקודה אחת לשנייה, הוא עובר כאובייקט אחד או יותר.
אובייקט הוא אוסף של נתונים שמציינים פריט.
כלומר, נניח ואנחנו מסתכלים על רשימת הקבצים במחשב (מפעילים את הפקודה dir)
אנחנו מקבלים את הרשימה הבאה:

כל אחד מהשורות שאתם רואים (1.txt או chapter 01 - the aat.avi) הוא למעשה פריט, אנחנו רואים רשימה של פריטים שכול אחד מהם הוא אובייקט מסוג "קובץ" (fileinfo, ליתר דיוק).
לכול פריט כזה יש את סט הנתונים שיש לאובייקט מסוג "קובץ" כמו "שם קובץ", "תאריך יצירה", "סוג" (ועוד רבים שנכיר בהמשך)
בנוסף למאפיינים קיימים גם פונקציות (פעולות) שניתן לעשות על כל אובייקט, אך אנחנו לא נדבר עליהם בינתיים.

לפני שנמשיך, אני רוצה לעשות סקירה קצרה על 4 פקודות שכדאי מאוד להכיר, מכיוון שבהמשך תגלו שהן מאוד שימושיות.
פקודה מספר 1 - dir (קיצור של Get-ChildItem).
הפקודה הזו צריכה להיות מוכרת לכם עוד מהCMD הישן, הפקודה הזו מציגה את רשימת הקבצים והתיקיות תחת התיקייה הנוכחית.

פקודה מספר 2 - gm (קיצור של Get-Member)
הפקודה הזו, בצירוף אובייקט משורשר בצינור תחזיר לכם את רשימת כל המאפיינים והפונקציות המשוייכות לאובייקט.
לדוגמה - אם אנחנו רוצים לקבל את המאפיינים של קבצים (fileinfo) ובמקרה ידוע לנו שהפקודה dir מחזירה פריטים מסוג האובייקט הזה בדיוק, נוכל להשתמש בפקודה הבאה:

קוד:

dir | gm

תוספת קטנה, מכיוון שסיכמנו שפונקציות לא מעניינות אותנו ואנחנו נצמדים אך ורק למאפיינים בינתיים, אפשר יהיה להשתמש בפקודה הבאה:

קוד:

dir | gm -type property

כך נקבל רק את המאפיינים של אובייקטים מסוג קובץ.

פקודה מספר 3 - fl (קיצור של Format-List).
הפקודה הזו, בצירוף אובייקטים משורשרים בצינור תחזיר לנו את האובייקטים מופרדים בשורת רווח.
לכול אובייקט יוצגו המאפיינים המבוקשים כאשר כל מאפיין מקבל שורה משלו.
דוגמאות:

שימו לב שבפקודה השנייה ציינתי לו בדיוק אילו מאפיינים אני רוצה לראות, ולכן הרשימה קצרה יותר.

פקודה מספר 4 - ft (קיצור של Format-Table).
הפקודה הזו פועלת כמעט בדיוק כמו fl, אבל היא מוציאה את הנתונים בצורת טבלה.
דוגמאות:


מקווה שההסבר על אובייקטים וpipes היה מספיק מובן, בפעם הבאה (כנראה בסופ"ש) נמשיך ונלמד איך לצבוע את הפלט שלנו בצבעים יפים, ונתחיל להכיר regular expressions.
בינתיים יש לכם בסיס, אתם מוזמנים להשתמש בhelp וללמוד פקודות חדשות.

תיקון ללינק שלך למעלה להורדה של Power Shell Download

אני יודע שהבטחתי משהו שונה, אבל אתם תסלחו לי, אני בטוח
אז אפשר להתחיל?

משתנים.
בpowershell קיימת אופצייה לשימוש במשתנים לשם שמירת מידע זמני.
אנחנו נזהה משתנים ע"י כך שנדע כי הם תמיד יתחילו עם הסימן "$" בהתחלה.
אני אנסה להבהיר באמצעות כמה דוגמאות:

קוד:

PS C:\> $name = "Koby"
PS C:\> $name
Koby
PS C:\> $num1 = 7
PS C:\> $num2 = 5
PS C:\> $num1+$num2
12
PS C:\> $num1,$num2
7
5
PS C:\> $list = dir *.rar
PS C:\> $list


    Directory: Microsoft.PowerShell.Core\FileSystem::C:\


Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        08/09/2006     23:46     215734 30779174.rar
-a---        08/09/2006     23:46     174640 71017424.rar
PS C:\> 

אלו היו 3 דוגמאות למה משתנים יכולים להכיל, מחרוזות (כמו השם שלי לדוגמה), מספרים (ואפשרות לבצע פעולות אריתמטיות/חשבוניות עליהם) ואפילו פקודות.

למה זה שימושי? אנחנו נראה את זה בהסבר על הפקודה הבאה:

ForEach-Object.
הפקודה הזו מקבלת באמצעות צינור אובייקט אחד או יותר (בד"כ יותר) ומבצעת פעולה מסויימת על כולם.
לפקודה זו יש 2 אפשרויות נוספות:
-begin
כל פקודה שנמצאת אחרי "-begin" תתבצע פעם אחת, לפני שהפעולה המבוקשת תתבצע על כל האובייקטים.
-end
כל פקודה שנמצאת אחרי ה"-end" תתבצע פעם אחת כאשר הForEach יסיים את הריצה שלו.
דוגמה:
אנחנו רוצים לדעת כמה קבצים יש לנו בתיקיה הנוכחית:

קוד:

 PS C:\bla> dir | ForEach-Object -begin {$num=0} {$num=$num+1} -end {"We got $num
 files in that folder"}
We got 22 files in that folder

אנחנו רוצים לדעת מה הגודל של כל הקבצים בכונן E:

קוד:

PS C:\bla> dir e:\ -Recurse | ForEach-Object -begin {$size=0} {$size=$size+$_.Le
ngth} -end {"we got $size bytes used on drive E"}
we got 37649902929 bytes used on drive E
 

לפני שאני ממשיך, הסבר קטן על החלק הזה: {$size=$size+$_.Length}
די ברור מה זה $size, זה המשתנה שאנחנו משתמשים בו כדי לספור כמה תופסים הקבצים בכונן.
המשתנה $_ הוא האובייקט שקיבלנו מהצינור, אובייקט מסוג fileinfo שאחד המאפיינים שלו הוא Length, שזה כמה שהקובץ תופס על הכונן.
ועכשיו נמשיך

אבל אנחנו לא יודעים מה המספר הזה, הוא גדול מידי...
אנחנו יודעים שבכול K יש 1024 בתים, ובכול MB יש 1024 K.
אז אם נחלק את התוצאה פעמיים ב1024... כלומר, אנחנו רוצים שבסוף הריצה לפני שהוא כותב כמה מקום תפוס בכונן הוא ייחלק את התוצאה פעמיים ב-1024.
כדי לכתוב כמה פקודות בבלוק פקודות (כל מה שכתוב בתוך סוגריים מסולסלים) אנחנו נפריד בין הפקודות עם התו ";" (נקודה-פסיק), ונקבל את התוצאה הבאה:

קוד:

PS C:\bla> dir e:\ -Recurse | ForEach-Object -begin {$size=0} {$size=$size+$_.Le
ngth} -end {$size=$size/1024; $size=$size/1024; "we got $size Mega-bytes used on driv
e E"}
we got 35905.7454385757 Mega-bytes used on drive E
 

נכון שעכשיו זה נראה יותר טוב, אבל בואו נתקן קצת את התצוגה, אף-אחד לא באמת מתעניין ביותר מ-2 ספרות אחרי הנקודה, נכון?
אז איך עושים את זה?
למזלנו, כל דבר בpowershell הוא אובייקט, זוכרים?
לכול אובייקט יש מאפיינים (properties) ופונקציות.
בואו נראה אילו נתונים יש באובייקט של מספר עם נקודה עשרונית:

קוד:

 PS C:\bla> $num = 35905.7454385757
PS C:\bla> $num | gm


   TypeName: System.Double

Name        MemberType Definition
----        ---------- ----------
CompareTo   Method     System.Int32 CompareTo(Object value), System.Int32 Co...
Equals      Method     System.Boolean Equals(Object obj), System.Boolean Equ...
GetHashCode Method     System.Int32 GetHashCode()
GetType     Method     System.Type GetType()
GetTypeCode Method     System.TypeCode GetTypeCode()
ToString    Method     System.String ToString(String format, IFormatProvider...

הפונקצייה שאנחנו מתעניינים בה היא - ToString.
לא ניכנס להסבר עליה (אם אתם מתעניינים - $num.ToString ייתן לכם פירוט ארוך ומאוד לא ברור)
כדי לראות רק 2 מספרים אחרי הנקודה העשרונית, אנחנו נכתוב את ההפקודה הבאה:

קוד:

PS C:\bla> $num.ToString(".00")
35905.75
 

"שיעורי בית"
כדי לראות אם הבנתם את מה שכתבתי למעלה אתם מוזמנים לנסות לכתוב פקודה שתספור את כמות הקבצים שמתחילים באות "a" בכונן לבחירתכם, וכן תציין את הגודל הכולל של כל הקבצים האלו ב-מידות של K (עם עימוד נורמלי, שזה אומר - לא 80 ספרות אחרי הנקודה).
בונוס למי שיגלה איך עושים את הפקודה לכמה כוננים ביחד (C, D ו - E לדוגמה)

נ.ב.
תודה לiceman על התיקון, הלינק ל-powershell עודכן.

צרות התוכנית שלך
תגיד אין לולאות פשוטות ???

נ.ב - לתת לו ENTER בשאלה של הפרמטר השני

קוד:

$Drive_To_Search = "D,E"
$Size_Counter = 0

$Drive_To_Search.Split(',') | ForEach-Object { dir "$_:\" -Include a*.* -Recurse} | ForEach-Object -begin {$Size_Counter += $_.Length} -end {$Size_Counter } 

$Size_Counter = $Size_Counter / 1048576
$Size_Counter.tostring(".00MB")

אין צורך ביותר משורה אחת, ואין צורך ביותר מ - foreach-object אחד...
תנסה שוב

לא חושב שהסתבכתי,
עזוב שאני משתמש במשתנים כדי לראות דברים בצורה ברורה עבורי ולאפשר דינמיות בשינוים
אני עדין לא מבין איך אתה מתכנן לבצע את הסריקה עבור כל כונן
כשאתה לא יודע מראש את הכוננים שאתה צריך לסרוק

פה אני נותן למשתמש להזין את הכוננים ידנית ולשלוט על מקורות החיפוש

לא אמרתי משתמש, לא אמרתי לכתוב תוכנית.
אמרתי פקודה והתכוונתי לזה, עדיין אי אפשר להפעיל תוכניות בpowershell (לא לפני שאני אגיע להסבר הזה בכ"א )
ובשביל זה זה היה בונוס, ד"א, קודם-כל תנסה על כונן אחד

שורה אחת לכונן אחד

קוד:

dir E:\ -Include a*.* -Recurse | ForEach-Object -begin {$File_Found=0 ; $Size_Counter=0} {$Size_Counter += $_.Length; $File_Found+=1} -end {($Size_Counter/1048576).tostring(".00MB") ;  $File_Found.ToString() + " files"}

טיפ קטן:
אם אתה רוצה לעשות dir לכמה כוננים - תפריד ביניהם בפסיקים.

קוד:

dir c:\,d:\

תנסה, אל תשאל סתם

ניסיתי, בגלל זה אני שואל

ציטוט:

Get-ChildItem : Cannot process argument because the value of argument "path" is invalid. Change the value of the "path" argument and run the operation aga in. At line:1 char:4 + dir <<<< c:\,d:\ -Include a*.exe

אתה לא יכול לתת לו כמה ערכים בצורה כזו...
KIS, מכיר? (Keep it Simple)

קוד:

dir c:\a*,d:\a*

ואיך אתה מבצע את החיפוש בתת סיפריות ?

קוד:

 dir c:\a*\,d:\*\a* -Recurse

צריך גם לספר לך איך עושים ספירת קבצים ולגלות גודל כולל או שאתה תוכל לגלול למעלה ולראות לבד?

עכשיו כעונש על העצלנות שלך - תחשוב על שיעורי בית לwhere, get-service ו - get-process מלמטה.

ותודה

מה השיעורי בית ?
תביא אתגר יהיה על מה לשבת

נ.ב חברה לכל אלה שרוצים להכנס לתחום של PowerShell
אז הנה כמה הקלות לדרך ...

>> באתר - http://secretgeek.net/powertools.asp
ניתן למצוא מספר כלים עבור PS

אני ממליץ קודם כל על ה-2 הראשונים שהם עוד בחינם לבנתיים
שהם מספקים סביבת עבודה מול PS והם :

• http://karlprosser.edify.us/coder/
• http://powershell.com/

השנים מספקים כמעט את אותה תכונות, אני מנצל את שניהם

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.karlprosser.com/blogpics/psachart1.PNG]



[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.scriptinternals.de/new/powershell/us/Internal/bodyHO1.JPG]

תהנו,

אתה יודע, ממשק גרפי לשפת סקריפטים שאמורה לרוץ בcommand line... נשמע קצת בעייתי

העניין הוא שסקריפטים לא מסתימים בשורה אחת או 3
לפעמים הסקריפט יגדל לממדים שתידרש יכולת DEBUG וזה מאאאאווווד עוזר שאתה יכול לעבוד בצורה ויזואלית ככה

נסה את זה, אתה גם תאהב, במיוחד ביכולת להריץ את החלקים שאתה מסמן עם העכבר
סתם ככה כדי לבדוק כל פעם מה החלק הזה עושב בקוד

ככה שאני יודע טוב מאוד מה כל חלק עושה...
וכבר עשיתי פקודות של 6 שורות ויותר, ולא הייתה לי בעייה להבין אותן

אני מניח שיש היגיון במה שאתה אומר, אבל אל תשכח שזה נועד לניהול מחשבים מרחוק בלי הצורך להשתלט עליהם בממשק הגרפי, כאן נכנס הpower ב - powershell (שייקפצו כל אוהבי הלינוקס ויגידו "נו-מה, זה קיים בלינוקס כבר שנים", הפעם אני אצדיק אותם )

הם צריכים לקנא האמת

כי משהו כאן לקח את המושג של SHELL צעד אחד קדימה
כל הרעיון של אוביקטים הוא פשוט גאוני...

כרגע לא ידוע האם מיקרוסופט הולכת לשלב את ה PowerShell כבר בגרסאות החדשות של VISTA,
אבל כן יש תיכנון שכזה.
מה שכן, וזה אחד הדברים היותר מעניינים ששמעתי מבית מיקרוסופט בכמה השנים האחרונות,
זה שכל ה Server החדשים יהיו בנויים על גבי ה PowerShell.
ולמה אני מתכוון.
בדצמבר הקרוב, מיקרוסופט הולכת לשחרר גרסאות RC של שרתי ה Exch 2007 ו MOM 2007
כל הקוד של השרתים האלה, בנוי על בסיס ה PowerShell.
ולא רק זה, אם ברצונכם לנהל את השרתים האלו, אתם תצטרכו לעשות זאת דרך ה PowerShell.
מכיוון שמיקרוסופט יודעת שחלק לא קטן מהלקוחות שלה עצלנים וכו (מבלי להעליב אף אחד),
היא כתבה לחלק מהקוד ממשק גרפי.
למה אני מתכוון חלק מהקוד?
אז לדוגמה בשרתי ה Exch, את רוב הניהול שלו תצטרכו לעשות דרך ה PowerShell,
אבל פעולות יותר פשוטות כמו יצירת תיבה וכו, תוכלו לעשות גם בממשק הגרפי.

בגדול, מה שאני מנסה להגיד לכם זה שכדאי מאוד להתחיל ללמוד את הPowerShell,
כי הוא הולך להיות חלק בלתי נפרד בגרסאות החדשות של המוצרים של Microsoft.

וכמובן, תודה רבה לקובי שמקדיש זמן ללמד את כולנו! שוב פעם מצדיע לך קובי!

בהצלחה לכולם...

בואו נרחיב את היכולות של הpowershell שלנו ונלמד קצת על חיפושים על הדרך.

regular expressions ידוע (או יותר נכון, היה ידוע) יותר בשם תבנית, דרך להציג אוסף של מחרוזות שונות בתבנית אחת.
הדוגמה אולי הכי שכיחה לregular expression היא "*", שמסמלת מספר לא מוגבל של אותיות מסוג "כל אות"
איפה נתקלנו בזה? כאשר רצינו לראות את כל הקבצים:

קוד:

dir *

כאשר רצינו לראות את כל הקבצים שמתחילים באות A:

קוד:

dir a*

וכו'.
בצדפות של יוניקס, ועכשיו גם בpowershell, הרחיבו מאוד את הנושא הזה ותומכים בהמון תבניות נוספות (זה לא אומר שregular expressions בחלונות זהה לזה של יוניקס, אבל קיים דימיון):
אנחנו נבצע את ההשוואות באמצעות המילה השמורה "-match" (ה"-" מגיע לפני המילה), הסבר על צורות השוואה נוספות - בהמשך.
מחרוזת רגילה בתוך מרכאות - השוואה למחרוזת עצמה (או חלק ממנה), 2 הדוגמאות הבאות יחזירו ערך אמת:

קוד:

PS C:\> Write-Host ("koby" -match "ob")
True

התו "." מחליף תו אחד:

קוד:

PS C:\> Write-Host ("koby" -match "k..y")
True

אם נשים תווים בתוך סוגריים מרובעות - ההשוואה תצליח אם לפחות אחד מהתווים קיים.
הדוגמה הראשונה נכונה, השנייה לא:

קוד:

PS C:\> Write-Host ("koby" -match "k[aeiou]by")
True
PS C:\> Write-Host ("koby" -match "kob[aeio]")
False

ניתן לשלב את הבדיקה מלמעלה עם טווח מספרים/אותיות:

קוד:

 PS C:\> Write-Host ("koby3" -match "ob[w-z][1-4]")
True

אם נשים "^" בתוך הסוגריים המרובעות, הבדיקה היא אם לא מופיעים האותיות בפנים:

קוד:

PS C:\> Write-Host ("koby3" -match "ob[w-z][^1-2]")
True 

חיפוש תחילת מילה או סוף מילה יצויינו בתו "^" בתחילת המילה, או בתו "$" בסוף המילה בהתאמה:

קוד:

PS C:\> Write-Host ("koby3" -match "^ko")
True
PS C:\> Write-Host ("koby3" -match "^ob")
False
PS C:\> Write-Host ("koby3" -match "ob$")
False
PS C:\> Write-Host ("koby3" -match "by3$")
True 

חיפוש תווים מיוחדים (כמו סוגריים מרובעות, "^", וכו') יתבצע ע"י השמת התו "\" לפני התו הבעייתי:

קוד:

PS C:\> Write-Host ("c:\koby\kobykoby" -match ":\\koby\\kobykoby$")
True 
PS C:\> Write-Host ("koby^be" -match "by\^b")
True

דוגמאות נוספות להשוואה ניתן למצוא בעזרה של powershell, כל שיש לרשום הוא:

קוד:

help about_regular

פקודה אחרונה להיום - פקודת where
בדומה לפקודת foreach-object אותה הכרנו ב"שיעור" הקודם, פקודת where גם היא מקבלת קבוצה של אובייקט אחד או יותר, אבל בניגוד לforeach, במקום לבצע פעולה עליהם, היא מסננת אותם לפי תנאים קבועים מראש (מתחילים לשים לב לקשר לregular expressions? )
הדרך הכי טובה להתחיל לדעתי תהייה בדוגמאות:
אם לדוגמה אנחנו נרצה לקבל את כל הקבצים שיש בשם שלהם את הספרות "01" עד "09", נכתוב את הפקודה הבאה:

קוד:

PS C:\bla> dir | where {$_.Name -match "0[1-9]"}


    Directory: Microsoft.PowerShell.Core\FileSystem::C:\bla


Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        03/10/2006     19:20         22 Chapter 01 - the aat.avi
-a---        03/10/2006     19:20         22 Chapter 02 - the bat.avi
-a---        03/10/2006     19:20         22 Chapter 03 - the cat.avi
-a---        03/10/2006     19:20         22 Chapter 04 - the dat.avi
-a---        03/10/2006     19:20         22 Chapter 05 - the eat.avi
-a---        03/10/2006     19:20         22 Chapter 06 - the fat.avi
-a---        03/10/2006     19:20         22 Chapter 07 - the gat.avi
-a---        03/10/2006     19:20         22 Chapter 08 - the hat.avi
-a---        03/10/2006     19:20         22 Chapter 09 - the iat.avi

כמובן שאפשר לעשות את הפעולה הזו גם ע"י הפקודה:

קוד:

 dir *0[1-9]*

אבל, where נותן לנו לבדוק לא רק את השדה Name שנמצא בכול קובץ, אלא כל שדה אחר.
לדוגמה - אני רוצה לראות את כל הקבצים שנמצאים תחת תקייה ששמה הוא system:

קוד:

 dir -r | where {$_.Directory -match "system$"}
    Directory: Microsoft.PowerShell.Core\FileSystem::C:\WINDOWS\R  egisteredPacka
    ges\{3FDF25EE-E592-4495-8391-6E9C504DAC2B}$BACKUP$\System


Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        22/04/2006     19:51        578 $BackupData$
-a---        04/08/2004     09:56     774144 setup_wm.exe


    Directory: Microsoft.PowerShell.Core\FileSystem::C:\WINDOWS\R  egisteredPacka
    ges\{60204BB3-7078-4F70-8F69-68297621941C}$BACKUP$\System


Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        22/04/2006     19:51        578 $BackupData$
-a---        04/08/2004     09:56      20480 wmpcore.dll
-a---        04/08/2004     09:56      20480 wmpui.dll

    Directory: Microsoft.PowerShell.Core\FileSystem::C:\WINDOWS\R  egisteredPacka
    ges\{981FB688-E76B-4246-987B-92083185B90A}$BACKUP$\System


Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        22/04/2006     19:51        578 $BackupData$
-a---        22/09/2004     18:46       3954 wpd10.inf


    Directory: Microsoft.PowerShell.Core\FileSystem::C:\WINDOWS\R  egisteredPacka
    ges\{A47B3654-48EE-48A5-B629-97D70175E58F}$BACKUP$\System


Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        22/04/2006     19:51        578 $BackupData$
-a---        04/08/2004     09:56     408064 wmadmod.dll

אפשרויות נוספות:
לא נעבור על כולן, אלא נסקור רק את החשובות (רשימת אפשרויות מלאה ניתן למצוא בעזרה)
שיוויון הוא טוב ויפה, אבל מה אם אנחנו רוצים לסנן נתונים שגדולים או שווים למספר מסויים, כמו לדוגמה למצוא את כל הקבצים שגדולים מ10K:

קוד:

 dir -r | where {$_.Length -gt 10000}

"-gt" מסמל קיצור לצמד המילים greater then.

אם אני רוצה את הקבצים שנוצרו לפני 150 יום או יותר:

קוד:

 dir -R | where {$([datetime]::today - $_.creationtime).Days -ge 150}

לפני שנמשיך, אני מודה - רימיתי קצת, זוכרים שאמרתי בכתבה הראשונה שpowershell משתמש ב .net? זה אומר שמרבית האפשרויות של ה.net קיימות אצלו, כמו המחלקה של תאריך/שעה.
אני אנסה לפרק את הבדיקה הזו לכמה חלקים, כדי שתהייה מובנת יותר:
[datetime]::today - מחזיר את התאריך של היום
[datetime]::today - $_.creationtime - מחסר בין התאריך של היום לתאריך היצירה של הקובץ (בגלל שמדובר על 2 אובייקטים הפעולה הזו אפשרית)
$([datetime]::today - $_.creationtime).Days - תו ה$ והקפת הפעולה בסוגריים מראה שאני מתייחס לתוצאה של פעולת החיסור כאובייקט, איך ידעתי לעשות זאת?
לפני שכתבתי את הפקודה הזו, כתבתי את הפקודה הבאה:

קוד:

PS C:\> dir | foreach-object -begin {$n=[datetime]::today} {$_.creationtime - $n
 }


Days              : -31
Hours             : 0
Minutes           : -13
Seconds           : -15
Milliseconds      : -906
Ticks             : -26791959062500
TotalDays         : -31.0092118778935
TotalHours        : -744.221085069444
TotalMinutes      : -44653.2651041667
TotalSeconds      : -2679195.90625
TotalMilliseconds : -2679195906.25 

וכך ידעתי איזה מאפיין להוציא.

היום כתבתי הרבה... מקווה שלא הרדמתי אף אחד.
תרגישו חופשיים לתרגל את העניין, אני אתן אח"כ כמה שאלות כדי שתוכלו לבדוק עד-כמה הנושא היה מובן.

עד עכשיו כל הנושא היה די משעמם בגלל 2 דברים:
1. למדנו רק את הבסיס
2. עבדנו רק עם פקודת dir
הפוסט הזה נועד לתת לכם עוד כמה פקודות כדי שיהיה ממש עם מה לשחק.
שנתחיל?

ניהול שירותים:
הפקודה הכי בסיסית להצגת השירותים: get-services

קוד:

PS C:\> Get-Service

Status   Name               DisplayName
------   ----               -----------
Running  Alerter            Alerter
Running  ALG                Application Layer Gateway Service
Stopped  AppMgmt            Application Management
Stopped  aspnet_state       ASP.NET State Service
Running  Ati HotKey Poller  Ati HotKey Poller
Stopped  ATI Smart          ATI Smart
Running  AudioSrv           Windows Audio
Stopped  BITS               Background Intelligent Transfer Ser...
 

נתחיל לשלב את זה עם דברים שלמדנו מלמעלה:
קבלת כל השירותים במצב מופעל (started)

קוד:

PS C:\> Get-Service | where {$_.Status -eq "Running"}

Status   Name               DisplayName
------   ----               -----------
Running  Alerter            Alerter
Running  ALG                Application Layer Gateway Service
Running  Ati HotKey Poller  Ati HotKey Poller
Running  AudioSrv           Windows Audio
Running  Browser            Computer Browser
Running  CryptSvc           Cryptographic Services
Running  DcomLaunch         DCOM Server Process Launcher
Running  Dhcp               DHCP Client
Running  dmserver           Logical Disk Manager 

קבלת כל השירותים שמותר לעצור:

קוד:

 PS C:\> Get-Service | where {$_.CanStop -eq "True"}

Status   Name               DisplayName
------   ----               -----------
Running  Alerter            Alerter
Running  ALG                Application Layer Gateway Service
Running  AudioSrv           Windows Audio
Running  Browser            Computer Browser
Running  CryptSvc           Cryptographic Services
Running  Dhcp               DHCP Client
Running  dmserver           Logical Disk Manager

(אולי אפשר ככה לעצור גם תהליכים ש"אסור", לא ניסיתי עדיין - מודה)

קבלת כל השירותים שרצים עכשיו ואי אפשר להשהות אותם:

קוד:

 PS C:\> Get-Service | where {$_.Status -eq "Running" -and $_.CanPauseAndContinue
 -eq "False"}

Status   Name               DisplayName
------   ----               -----------
Running  lanmanserver       Server
Running  lanmanworkstation  Workstation
Running  Schedule           Task Scheduler

והפקודה המסובכת להיום:
הצגת כל השירותים שיש להם תלויות (דרישה ששירותים אחרים ירוצו לפני שהם יעלו) והצגה שלהם:

קוד:

 PS C:\> Get-Service * | foreach-object {$n=$_.Name;$_.DependentServices} | forea
ch-object {$_.Name  + ", needs $n to run"}
dmadmin, needs dmserver to run
wscsvc, needs Eventlog to run
SharedAccess, needs Eventlog to run
winmgmt, needs Eventlog to run
usnsvc, needs Eventlog to run
SENS, needs EventSystem to run
Browser, needs lanmanserver to run
RpcLocator, needs lanmanworkstation to run
Netlogon, needs lanmanworkstation to run
Messenger, needs lanmanworkstation to run

וסתם בשביל הכיף, נוסיף עוד דרישה - הצגה של כל השירותים הנ"ל, אבל שלא פעילים נכון לעכשיו:

קוד:

PS C:\> Get-Service * | where {$_.Status -ne "Running"} | foreach-object {$n=$_.
Name;$_.DependentServices} | foreach-object {$_.Name  + ", needs $n to run"}
ClipSrv, needs NetDDE to run
ClipSrv, needs NetDDEdsdm to run
NetDDE, needs NetDDEdsdm to run
TlntSvr, needs NtLmSsp to run
RasAuto, needs RasMan to run
RasAuto, needs TapiSrv to run
RasMan, needs TapiSrv to run 

ניתן לכם לגלות מה עוד אפשר לעשות לבד

כמו שאפשר לראות שירותים, בטח הצלחתם לנחש לבד את הפקודה לראות תהליכים שרצים עכשיו על המחשב:

קוד:

PS C:\> Get-Process

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName
-------  ------    -----      ----- -----   ------     -- -----------
    104       6     1248       3492    33        0   2504 alg
     59       2      712       2180    20        0    848 ati2evxx
     72       2      884       2920    25        0   1428 ati2evxx
     66       4    14420      17664    52        1   1720 ClamTray
    400      50    22260       4700   215        3   1712 CLI
    279      44    16644       4928   201        1   3128 CLI
    281      42    16368       5308   194        1   3136 CLI
    557       6     1960       4680    27       32    564 csrss 

ניתן כמה דוגמאות קצרות ונלך לישון...

הצגה של כל התהליכים שרצים מקבצים שנמצאים תחת תיקיית חלונות:

קוד:

 
PS C:\> Get-Process | where {$_.Path -match "C:\\WINDOWS"} | ft Name, Path

Name                                    Path
----                                    ----
alg                                     C:\WINDOWS\System32\alg.exe
ati2evxx                                C:\WINDOWS\System32\Ati2evxx.exe
ati2evxx                                C:\WINDOWS\system32\Ati2evxx.exe
csrss                                   \??\C:\WINDOWS\system32\csrss.exe
ctfmon                                  C:\WINDOWS\system32\ctfmon.exe
explorer                                C:\WINDOWS\Explorer.EXE
lsass                                   C:\WINDOWS\system32\lsass.exe
services                                C:\WINDOWS\system32\services.exe

הצגת כמות התהליכים שתופסים יותר מ10MB בזכרון, גודל הזכרון הכולל התפוס ושמות התהליכים (פקודה מסובכת):

קוד:

PS C:\> Get-Process | where {$_.WorkingSet -gt 10000000} | ForEach-Object -begin
 {$c=0;$mem=0} {$c+=1;$mem+=$_.WorkingSet} -end {$mem/=1024;$mem/=1024;$mem=$mem
.ToString(".00");"A total of $c processes holds over 10MB of data and hold $mem
MB of total RAM"}
A total of 6 processes holds over 10MB of data and hold 208.93 MB of total RAM 

כמובן שאפשר באמת להשתולל עם העניין הזה... אבל אני אתן לכם לגלות...

אל תשכחו להשתמש ב - gm כדי לראות אילו מאפיינים ופונקציות יש לשירותים ותהליכים...
פונקצייה שצריכה לעניין חלקכם היא פונקציית kill על תהליכים...
מישהו יכול לנחש מה הפקודה הבאה תעשה?

קוד:

$(Get-Process | where {$_.Name -match "PowerShell"}).Kill()

לפני שנתחיל, הסעיף הזה (וכנראה סעיפים קודמים) כוללים פקודות שעלולות לצאת מאוד ארוכות.
בpowershell, כמו בכול prompt טקסטואלי שמכבד את עצמו, יש אפשרות להשלמת פקודות, שמות קבצים ושמות תיקיות באמצעות לחיצה על המקש <TAB>
כלומר, במקום לרשום ForEach-Object, ניתן לכתוב ForEach- ולהשלים את המילה ע"י הקשה על המקש TAB.
כנ"ל לגבי פקודות כמו cd c:\windows, ניתן לכתוב cd c:\wi ולהשלים את המילה ע"י לחיצה על <TAB>, אם קיימות כמה אפשרויות, הקשה על TAB תעבור קדימה בין האפשרויות, הקשה על <SHIFT>+<TAB> תדפדף בין האפשרויות אחורה.
ועכשיו נמשיך.

עד עכשיו השתמשנו בpowershell כדי לגשת לקבצים ותיקיות מקומיים במחשב, העקרון נראה מאוד פשוט.
יש לנו מחשב, במחשב יש כוננים, תחתיהם יש תיקיות ו/או קבצים.
העקרון (המאוד פשוט הזה) נכון, כי כברירת מחדל בכניסה לpowershell אנחנו מגיעים לתיקיית המשתמש שלנו, שנמצאת על הכונן המקומי במחשב.
מה שאנחנו לא יודעים, זה שכדי לגשת לכונן המקומי שלנו, הpowershell משתמש בשירות מיוחד לגישה לכוננים מקומיים, השרות הזה נקרא ספק (או - provider).
אני מניח שהרבה יושבים עכשיו (הרבה = מי שממש קורא את זה) ותוהים "למה לעזאזל הוא מספר לנו דברים לא מעניינים שכאלה?"
התשובה היא מאוד פשוטה, כי באמצעות הproviders האלו, אנחנו יכולים לגשת, דרך הcommand line למקומות שלא חשבנו שניתן לגשת אליהם.

לדוגמה, קיים לנו provider לגישה לשיתופי רשת.
זאת אומרת, שאם אנחנו יודעים שיש לנו מחשב ברשת בשם naomi ואנחנו יודעים שתחתיו יש לנו שיתוף בשם MP3, אנחנו יכולים לכתוב את הפקודה הבאה:

קוד:

 PS C:\> cd \\naomi\mp3
PS Microsoft.PowerShell.Core\FileSystem::\\naomi\mp3>

כמובן שמכאן ניתן לעשות את כל הפעולות שניתן לעשות על קבצים מקומיים כמו dir, copy, rename וכו'

אבל... לא באתי להרדים אתכם בסיפורים על ספקים למיניהם, אלא להראות תכל'ס לאן זה יכול להגיע.
אז בואו נכיר פקודה חדשה - Get-PSProvider

קוד:

PS C:\> Get-PSProvider

Name                 Capabilities                  Drives
----                 ------------                  ------
Alias                ShouldProcess                 {Alias}
Environment          ShouldProcess                 {Env}
FileSystem           Filter, ShouldProcess         {C, D, E, S...}
Function             ShouldProcess                 {Function}
Registry             ShouldProcess                 {HKLM, HKCU}
Variable             ShouldProcess                 {Variable}
Certificate          ShouldProcess                 {cert} 

כמו שיכלתם לנחש מהפקודה עצמה, הפקודה מציגה את כל הproviders המותקנים על המחשב, ואת ה"כוננים" המשוייכים אליה.
על כל אחד מהproviders ניתן לתת "שיעור" שלם, אבל לא כולם באמת מעניינים, בסופו של דבר אנחנו נדבר (אם יהיה טעם להמשיך בכ"א) על כולם חוץ מcert, אבל ניתן עכשיו תיאור זריז על כל אחד מהם:
Environment - הכונן שמחזיק את משתני הסביבה.
Variable - הכונן שמחזיק את כל המשתנים שייצרתם (כאשר עשינו $size = 0 למעשה "יצרנו" מאפיין/קובץ בשם size תחת תיקיית variable)
Alias - הכונן שמחזיק קיצורים לפקודות, אם תעברו לכונן ותעשו dir תוכלו לגלות קיצורים די שימושיים, לדוגמה תגלו שבמקום לכתוב ForEach-Object מספיק לכתוב "%", ושdir הוא עצמו קיצור לפקודה Get-ChildItem וכ'
Function - הכונן שמחזיק פונקציות המוגדרות למשתמשים בpowershell, כאם תגלו שפקודת more היא פונקצייה, ואפילו path הוא פונקצייה (חלק מאוד חשוב שאני כנראה אסביר עליו בהמשך)
Registry - על זה רציתי לדבר היום למעשה, אחרי הרבה מאוד זמן, יש לנו אפשרות לגשת לregistry בממשק סטנדרטי ונוח דרך הcommand line.

נניח ואנחנו נכנסנו לmsconfig, וראינו תחת startup כמה פעולות שעולות ביחד עם המחשב שאנחנו לא רוצים, במקרה שלנו זה יהיה הפריט המסומן:

אם היינו גוררים את החלו ימינה (אתם מוזמנים לעשות זאת בעצמכם) נראה שה"תיקייה" שבה מוגדר הפריט הזה היא: " HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru n"
אז אנחנו ניכנס לpowershell שלנו ונכתוב את הפקודות הבאות (השלמה אוטומטית עובדת גם כאן, כך שאין צורך להתענות ולכתוב את כל המילה, 2 אותיות ראשונות מספיקות בהחלט):

קוד:

 PS C:\> cd hklm:
PS HKLM:\> cd HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n
PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n>

ועכשיו מתחיל הנושא הבעייתי...
אם היינו במערכת קבצים, פקודת DIR הייתה מחזירה את כל הפריטים שמוגדרים תחת המפתח הזה... אבל לא כאן.
לא ניכנס להסבר של מה ולמה, פשוט תסמכו עלי בקטע הזה (או שתנסו לבד, אבל DIR יראה לכם רק מפתחות אחרים שנמצאים תחת תיקייה זו)
אז איך אנחנו רואים מאפיינים שמוגדרים במפתח מסויים בregistry?
נשתמש בפקודה Get-ItemProperty, או בקיצור gp ונבקש פרטים על התיקייה הנוכחית (מסומנת בנקודה - "."):

קוד:

PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> gp .


PSPath             : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOF
                     TWARE\Microsoft\Windows\CurrentVersion\Run
PSParentPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOF
                     TWARE\Microsoft\Windows\CurrentVersion
PSChildName        : Run
PSDrive            : HKLM
PSProvider         : Microsoft.PowerShell.Core\Registry
ATICCC             : "d:\Program Files\ATI Technologies\ATI.ACE\cli.exe" runtim
                     e -Delay
ClamWin            : "d:\Program Files\ClamWin\bin\ClamTray.exe" --logon
SunJavaUpdateSched : d:\Program Files\Java\jre1.5.0_06\bin\jusched.exe
SoundMAXPnP        : d:\Program Files\Analog Devices\SoundMAX\SMax4PNP.exe
SoundMAX           : "D:\Program Files\Analog Devices\SoundMAX\Smax4.exe" /tray
dla                : C:\WINDOWS\system32\dla\tfswctrl.exe
UpdateManager      : "C:\Program Files\Common Files\Sonic\Update Manager\sgtray
                     .exe" /r
QuickTime Task     : "D:\Program Files\QuickTime\qttask.exe" -atboottime
IMONTRAY           : C:\Program Files\Intel\Intel(R) Active Monitor\imontray.ex
                     e
FastTVSync         : "C:\Program Files\Common Files\InterVideo\FastTVSync\FastT
                     VSync.exe"
SonicFocus         : "D:\Program Files\Sonic Focus\SFIGUI\SFIGUI.EXE" BOOT
NeroFilterCheck    : C:\Program Files\Common Files\Ahead\Lib\NeroCheck.exe
Windows Defender   : "d:\Program Files\Windows Defender\MSASCui.exe" -hide
iTunesHelper       : "d:\Program Files\iTunes\iTunesHelper.exe"
deleteme           : delete me alraedy, I'm not a realt software! 

מבט מהיר יגלה שאנחנו רוצים למחוק את המאפיים האחרון, זה שנושא בגאווה את השם "deleteme".
כדי למחוק את המאפיין הזה נשתמש בפקודה Remove-ItemProperty (או בקיצור - rp) בצורה הבאה:

קוד:

rp . -Name deleteme 

עכשיו בואו נשחק קצת, כדי להכיר את ההרגשה של הגישה לregistry דרך הpowershell (מומלץ לעשות על מפתח נפרד, לא על אחד קריטי כמו זה שאני משחק איתו)
אני רוצה ליצור מאפיין חדש (Set-ItemProperty, או, sp)

קוד:

 PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> sp . -name a -value b
PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> gp . -name a


PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE\
               Microsoft\Windows\CurrentVersion\Run
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE\
               Microsoft\Windows\CurrentVersion
PSChildName  : Run
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry
a            : b

אני עכשיו רוצה לשנות את הערך של a, שיהיה משהו ארוך יותר:

קוד:

PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> sp . -name a -value "No
one knows what it's like, To be the bad man, To be the sad man, Behind blue eyes
"
PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> gp . -name a


PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE\
               Microsoft\Windows\CurrentVersion\Run
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE\
               Microsoft\Windows\CurrentVersion
PSChildName  : Run
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry
a            : No one knows what it's like, To be the bad man, To be the sad ma
               n, Behind blue eyes 

הםם... המקום הזה לא מתאים לי, אני רוצה ליצור תחת software מפתח בשם songs ולהעביר לשם את המאפיין... אז הנה מה שאני אעשה:
יצירת המפתח (זהה לתחלוטין לצורה שבה יוצרים תיקייה במערכת קבצים:

קוד:

 PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> mkdir HKLM:\SOFTWARE\Son
gs


   Hive: Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE

SKC  VC Name                           Property
---  -- ----                           --------
  0   0 Songs                          {}

העברת המאפיין (באמצעות Move-ItemProperty, או בקיצור - mp):

קוד:

 PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> mp . -Name a -Destinatio
n HKLM:\SOFTWARE\Songs
PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> gp . -name a
Get-ItemProperty : Property a does not exist at path HKEY_LOCAL_MACHINE\SOFTWAR
E\Microsoft\Windows\CurrentVersion\Run.
At line:1 char:3
+ gp  <<<< . -name a
PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> gp HKLM:\SOFTWARE\Songs
-name a


PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE\
               Songs
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MAC  HINE\SOFTWARE
PSChildName  : Songs
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry
a            : No one knows what it's like, To be the bad man, To be the sad ma
               n, Behind blue eyes

היו כאן כמה פקודות למעשה - העברת המאפיין, ניסיון להציג אותו במפתח המקורי (שהעלה שגיאה בגלל זה) והצגה שלו במפתח החדש.
ולסיום, מחיקת המפתח Songs:

קוד:

PS HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Ru  n> cd \
PS HKLM:\> cd SOFTWARE
PS HKLM:\SOFTWARE> rmdir Songs 

חשוב לשים לב - למרות שהיו מאפיינים בתיקייה הזו (כי הרי לפני שנייה ראינו שקיים שם "a" שיצרנו), עדיין לא הייתה לו בעייה למחוק את כל המפתח בלי לשאול אפילו, והוא לא יחזור יותר, כך שצריך להיזהר עם הפעולות האלו מאוד!

עד-כאן עריכת registry מpowershell, מקווה שנהניתם...
בגלל מיעוט התגובות אני מסיק מסקנות ומבין שזה לא הכי מעניין אתכם, אז אל חשש, העונש הזה ייגמר כנראה מוקדם מהצפוי

העניין הוא שאין אתגרים מהכיוון שלך
אני מסיים לקרוא וסוגר את החלון אחרי זה, כי את מה שרציתי ללמוד למדתי

אם יש לך איזה שהוא אתגר קיצ'י על החומר שלימדתה ... אז קדימה תן אותו

כמה אתגרים מהחומר שלמדנו עד עכשיו (בשביל התרגילים הקשים תצטרכו לחפש קצת מאפיינים/פונקציות עם פקודת GM).
קל:
* ספרו את כמות התהליכים שרצים עכשיו ברקע.

* עצרו את כל התהליכים עם השם iexplore

* מצאו כמה זכרון תופסים כל התהליכים שלא מורצים מתיקיית c:\windows\system32 או תיקיות מתחתיו

בינוני:
התרגילים האלו נחשבים בינוני כי צריך ללמוד בשבילם פקודה חדשה:
Sort-Object
מאפשר למיין את האובייקטים המתקבלים דרך PIPE.
דוגמה למיון כל התהליכים לפי מי תופס הכי הרבה זכרון בסדר יורד:

קוד:

 Get-Process | Sort-Object -property WS -desc

* מצא את התהליך שתופס הכי הרבה זכרון (קצת מתחכם, תחשבו על זה)

קשה: (אני לא בטוח שזה נחשב קשה, אבל שיהיה, צריך גם שאלות בקטגוריה הזו )

* בהמשך לאשכול הזה , איך משנים תאריך שינוי אחרון של קובץ מסויים.

* מצאו את כל המפתחות בregistry תחתיהם יש מפתח בשם RUN (ורק RUN, לא מפתחות כמו RunEX לדוגמה)

זהו לבינתיים, תשתוללו.

מספר התהליכים שרצים:

קוד:

 Get-Process | ForEach-Object -begin {$Counter = 0} {$Counter += 1 ; Write-Host "$Counter. " $_.Name } -end {Write-Host "There are $Counter, runing right now" } 

לעצור ישומים בעל שם מסויים:

קוד:

$(Get-Process | Where-Object { $_.Name -eq "iexplore"}).Kill()
#$(Get-Process | where {$_.Name -match "iexplore"}).Kill()

כמה זיכרון תופס כל מה שלא רץ תחת SYSTEM 32

קוד:

 
Get-Process | Where-Object { $_.Path -notlike "*c:\windows\system32*" } | ForEach-Object -Begin {$Mem=0} {$Mem += $_.WorkingSet} -end {Write-Host "All App that not runing form SYSTEM32 folder Taking " ($Mem/1048576).ToString(".00 MB")}

הכי הרבה זיכרון :

קוד:

 
#Write-Host $(Get-Process | Sort-Object -property WS -desc)[0].Name 
$p = Get-Process | Sort-Object -property WS -desc
Write-Host "Most Mem app prize gos to " $p[0].Name "with " ($p[0].ws/1048576).tostring(".00 MB")

שינוי תאריך הכתיבה לקובץ

קוד:

 $(dir "f:\temp\ps\ko.ps1").LastWriteTime = [System.DateTime]::Now
 

ה-REG נותן לי שגיאות כרגע על עניין של הרשאה,
אז אני אשאיר אותו למחר

מספר תהליכים - נכון

לעצור יישומים בעלי שם מסויים - נכון, אבל רק אם יש לך יישום אחד שכזה, תעלה 2 חלונות אקספלורר ותקבל הודעת שגיאה, יש דרך טובה יותר.

כמה זיכרון - נכון, פתרון יפה.

הכי הרבה זיכרון - זה עובד, נכון, אבל תנסה בלי לעבוד עם מערכים (כי לא לימדתי) ובלי לעבוד עם משתנה זמני, פקודה אחת (אמרתי שזה קצת מתחכם)

שינוי תאריך - יפה מאוד, אני רואה שהבנת את העניין של",כל דבר הוא אובייקט"

ציטוט:

לעצור יישומים בעלי שם מסויים - נכון, אבל רק אם יש לך יישום אחד שכזה, תעלה 2 חלונות אקספלורר ותקבל הודעת שגיאה, יש דרך טובה יותר.

רמז

ציטוט:

הכי הרבה זיכרון - זה עובד, נכון, אבל תנסה בלי לעבוד עם מערכים (כי לא לימדתי) ובלי לעבוד עם משתנה זמני, פקודה אחת (אמרתי שזה קצת מתחכם)

עשיתי אבל לא הצלחתי לבצע 2 פעולת
אני יכול להוציא רק את השם של התוכנה אבל לא את הכמות זיכרון
תראה את השורה הראשונה

ציטוט:

שינוי תאריך - יפה מאוד, אני רואה שהבנת את העניין של",כל דבר הוא אובייקט"

חחח.. זה פשוט נראה הגיוני

אני אענה על השאלות כשאני אפרסם את ההודעה הבאה..

האם אפשר לייצר מה Powershell קובץ Batch כמו ה BAT?

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://dinods.co.il/images/logo4.png]

עיצוב גרפי | מיתוג | הפקות דפוס
dinods.co.il

ובכלל איך משתמשים במשתנים איך פועל העסק??
אני לא מבין את כל הקטע של IF FOR? יש איזה משהו נורמלי להסביר את זה.....
אם תוכל לשלוח לי פרטים וחומר למייל שלי: maorosh@gmail.com , או איזה הודעה פרטית.. או משהו...
אשמח..

ברסלב כרמיאל

כללי: הפסקתי להשקיע באשכול הזה מחוסר עניין לציבור לפני הרבה זמן... ההקפצה לא היתה הכי במקום.
אם אני אראה התעניינות, אולי נתחיל אחד חדש עם חזרה על החומר הזה + נושאים מתקדמים יותר... כשיהיה לי יותר זמן (יש משהו אחר שאני חייב כאן לפני )

אדיוס:
לpowersehll יש שפת סקריפט משלה, זה דומה ל bat, אבל הם נקראים ps1.
אז לשאלתך - כן, ניתן ליצור סקריפטים בpowershell, וזה אפילו די נוח.

מאור:
קצת זמן פנוי, הרבה ניסוי ותהייה, וימים בעבודה שהתחילו ב "מעניין אם אפשר לעשות את *** עם PS", קצת חיפושים לא הזיקו לאף אחד, נכון?

בכול אופן, האשכול ננעל ע"מ למנוע הקפצות נוספות, שאלות ספציפיות אתם מוזמנים לשאול בכללי, לגבי אשכול המשך - תאלצו לחכות (אלא אם מישהו מוכן להתחיל אחד, אני אשמח להצטרף)