1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [סמינר: התאמת דפוסים עם ביטויים רגולריים]

2
00:00:02,000 --> 00:00:04,000
[אוניברסיטת ג'ון מוסמן-הרווארד]

3
00:00:04,000 --> 00:00:07,220
[זה CS50.-CS50.TV]

4
00:00:07,780 --> 00:00:11,610
אוקיי. ובכן, ברוכים הבאים לכולם. זה CS50 2012.

5
00:00:11,780 --> 00:00:16,610
שמי ג'ון, ואני יהיה לדבר היום על ביטויים רגולריים.

6
00:00:16,610 --> 00:00:22,530
ביטויים רגולריים הוא בעיקר כלי, אלא גם משמשים לעתים

7
00:00:22,530 --> 00:00:28,650
בקוד באופן פעיל כדי להתאים דפוסים ומחרוזות במהות.

8
00:00:28,650 --> 00:00:33,800
אז הנה קומיקס אינטרנט מxkcd.

9
00:00:34,440 --> 00:00:42,370
בקומיקס הזה יש תעלומת רצח שבו יש לו את הרוצח

10
00:00:42,370 --> 00:00:47,860
אחרי שמישהו בחופשה, ויש לי את הגיבורים ל

11
00:00:47,860 --> 00:00:52,500
לחפש דרך 200 מגה בייט של הודעות דוא"ל המחפשים כתובת.

12
00:00:52,500 --> 00:00:56,090
והם עומדים לוותר כאשר מישהו שמכיר ביטויים רגולריים -

13
00:00:56,090 --> 00:01:00,550
ככל הנראה גיבור - נוחת למטה וכותב קצת קוד

14
00:01:00,550 --> 00:01:02,970
ופותר את תעלומת הרצח.

15
00:01:02,970 --> 00:01:07,370
אז כנראה שיהיה משהו שאתה יהיה מוסמך לעשות

16
00:01:07,370 --> 00:01:09,370
לאחר הסמינר הזה.

17
00:01:09,370 --> 00:01:12,250
אנחנו רק הולכים לספק מבוא תמציתי לשפה

18
00:01:12,250 --> 00:01:16,770
ולתת לך מספיק אמצעים כדי ללכת אחרי יותר משאבים בעצמך.

19
00:01:17,680 --> 00:01:21,700
>> ביטויים כל כך רגילים לחפש בעצם כמו זה.

20
00:01:22,930 --> 00:01:25,550
זה ביטוי רגיל ברובי.

21
00:01:25,550 --> 00:01:29,280
זה לא שונה מאוד בין שפות.

22
00:01:29,690 --> 00:01:37,630
יש לנו רק על לוכסנים להתחיל ולסמן את הביטוי הרגיל ברובי.

23
00:01:37,630 --> 00:01:42,880
ואת זה הוא ביטוי רגיל לחפש בתבנית כתובת דואר אלקטרוני.

24
00:01:42,880 --> 00:01:49,160
כך אנו רואים בתחילה קצת נראה לכל תו אלפאנומרי.

25
00:01:50,500 --> 00:01:54,880
זאת משום שכתובות דואר אלקטרוני לעתים קרובות יש להתחיל עם אופי אלפביתי.

26
00:01:55,460 --> 00:01:59,330
ואז כל תו מיוחד ואחריו הסימן @.

27
00:01:59,330 --> 00:02:03,260
ולאחר מכן את אותו דבר עבור שם הדומיין.

28
00:02:03,260 --> 00:02:10,030
ולאחר מכן תווים בין 2 ל 4 לחפש. Com,. נטו, וכן הלאה.

29
00:02:10,850 --> 00:02:13,200
אז זה הוא דוגמה נוספת לביטוי רגיל.

30
00:02:13,200 --> 00:02:17,270
ביטויים כל כך רגילים הם פרוטוקולים למציאת הדפוסים בטקסט.

31
00:02:17,270 --> 00:02:21,130
הם עושים השוואות, בחירות, והחלפות.

32
00:02:21,690 --> 00:02:27,970
אז דוגמה שלישית היא למצוא את כל מספרי הטלפון שהסתיימו ב54 בספרייה.

33
00:02:27,970 --> 00:02:34,360
אז לפני שקורע את דוד ספריית CS50 אנחנו יכולים לחפש

34
00:02:34,360 --> 00:02:40,450
דפוס שבו יש לנו סוגריים אז 3 מספרים אז בסופו הסוגריים,

35
00:02:40,450 --> 00:02:44,070
3 מספרים נוספים, מקף, 2 מספרים, ולאחר מכן 54.

36
00:02:44,070 --> 00:02:48,310
וזה יהיה בעצם איך אנחנו באים עם ביטוי רגיל כדי לחפש את זה.

37
00:02:49,150 --> 00:02:52,960
>> אז יש - שעשינו כמה דברים בCS50 שהם קצת כמו

38
00:02:52,960 --> 00:02:59,740
ביטויים רגילים, ולכן - לדוגמה - בקובץ dictionary.C

39
00:02:59,740 --> 00:03:04,720
לקבוצת הבעיה בדיקת האיות ייתכן שהשתמשת fscanf

40
00:03:04,720 --> 00:03:07,930
לקרוא במילה מהמילון.

41
00:03:07,930 --> 00:03:16,240
ואתה יכול לראות את 45s אחוז הוא מחפש מחרוזת של 45 תווים.

42
00:03:16,240 --> 00:03:20,020
אז זה קצת כמו ביטוי בסיסי קבוע.

43
00:03:21,150 --> 00:03:26,060
ואתה יכול לקבל את כל תווים 45 שמתאימים את החשבון לשם

44
00:03:26,060 --> 00:03:28,080
ולהרים אותם למעלה.

45
00:03:28,080 --> 00:03:33,480
ולאחר מכן הדוגמא השנייה בבעיה תכנות האינטרנט האחרונה

46
00:03:33,480 --> 00:03:40,760
להגדיר בקוד ההפצה עבור PHP שאנחנו עושים בעצם צריכים פשוט ביטוי קבוע.

47
00:03:40,760 --> 00:03:46,790
ואת זה הוא פשוט מחפש כדי לבדוק אם דף האינטרנט שהוא עבר ב

48
00:03:46,790 --> 00:03:51,940
מתאים גם התחברות והתנתקות הרשמה. PHP.

49
00:03:52,220 --> 00:03:57,910
ולאחר מכן חוזר אמת או שקר שמבוסס על התאמת הביטוי רגילה.

50
00:03:59,400 --> 00:04:01,740
>> לכן, כאשר אתם משתמשים בביטוי רגיל?

51
00:04:01,740 --> 00:04:04,820
למה אתה כאן היום?

52
00:04:05,330 --> 00:04:08,480
אז אתה לא רוצה להשתמש בביטוי רגיל, כאשר יש משהו ש

53
00:04:08,480 --> 00:04:11,640
עושה את העבודה בשבילך אפילו יותר בקלות.

54
00:04:11,640 --> 00:04:15,510
אז XML ו-HTML הם למעשה די מסובך

55
00:04:15,510 --> 00:04:18,480
לכתוב ביטויים רגולריים לכפי שנראה בקצת.

56
00:04:19,110 --> 00:04:23,280
אז יש מנתחים ייעודיים לשפות אלו.

57
00:04:24,170 --> 00:04:30,060
אתה גם צריך להיות בסדר עם offs הסחר והדיוק בתדירות גבוהה.

58
00:04:30,060 --> 00:04:36,220
אם אתה מנסה - כך ראינו ביטוי רגיל לכתובת דוא"ל,

59
00:04:37,370 --> 00:04:42,590
אבל אמרת שאתה רוצה את כתובת הדוא"ל של ספציפית ובהדרגה

60
00:04:42,590 --> 00:04:48,570
ביטוי רגיל עלול להפוך למורכב יותר ככל שזה הפך מדויק יותר.

61
00:04:49,580 --> 00:04:52,260
אז זה יהיה אחד מסחר.

62
00:04:52,260 --> 00:04:55,330
אתה צריך להיות בטוח שאתה בסדר עושה עם הביטוי הרגיל.

63
00:04:55,330 --> 00:04:57,920
אם אתה יודע בדיוק מה אתה מחפש זה אולי הגיוני יותר

64
00:04:57,920 --> 00:05:02,070
כדי להשקיע את הזמן ולכתוב מנתח יעיל יותר.

65
00:05:02,070 --> 00:05:06,980
וסוף סוף יש בעיה היסטורי עם הסדירות

66
00:05:06,980 --> 00:05:08,940
ביטויים ושפות.

67
00:05:08,940 --> 00:05:12,960
ביטויים רגולריים הם למעשה הרבה יותר חזק מאשר

68
00:05:12,960 --> 00:05:16,450
ביטויים רגולריים לאומרים במובן פורמלי.

69
00:05:17,130 --> 00:05:20,150
>> אז אני לא רוצה ללכת רחוק מדי לתאוריה הרשמית,

70
00:05:20,150 --> 00:05:24,000
אך רוב השפות שלמעשה קוד שבאנחנו לא רגילים.

71
00:05:24,000 --> 00:05:29,110
ובגלל זה בביטויים רגילים לפעמים לא נחשבים כל כך בטוח.

72
00:05:29,670 --> 00:05:33,150
אז בעצם יש היררכית חומסקי לשפות,

73
00:05:33,150 --> 00:05:38,400
וביטויים רגולריים הם לבנות באמצעות איחוד, שרשור,

74
00:05:38,400 --> 00:05:41,810
ופעולת כוכב Kleene כי אנו רואים בכמה דקות.

75
00:05:43,130 --> 00:05:48,860
אם אתם מעוניינים בתאוריה יש די הרבה קורה שם מתחת למכסת המנוע.

76
00:05:50,360 --> 00:05:55,880
>> אז היסטוריה קצרה - רק בשביל ההקשר כאן - סטים רגילים באו

77
00:05:55,880 --> 00:05:59,580
בשנת 1950, ולאחר מכן היו לנו עורכים פשוט כי

78
00:05:59,580 --> 00:06:03,300
התאגד בביטויים רגילים - פשוט מחפש מחרוזות.

79
00:06:03,570 --> 00:06:09,110
Grep - אשר הוא כלי שורת פקודת - היה אחד הראשונים

80
00:06:09,110 --> 00:06:14,160
כלים מאוד פופולריים ששולבו בביטויים רגילים ב -1960.

81
00:06:14,160 --> 00:06:20,560
בשנתי ה -80, פרל נבנה - היא שפת תכנות ש

82
00:06:20,560 --> 00:06:24,110
משלב ביטויים רגולריים באופן בולט מאוד.

83
00:06:24,550 --> 00:06:30,130
ואז לאחרונה היה לנו פרל ביטוי תואם רגיל

84
00:06:30,130 --> 00:06:35,870
פרוטוקולים בעצם בשפות אחרות המשתמשות בהרבה מאותו התחביר.

85
00:06:36,630 --> 00:06:39,840
כמובן שהאירוע החשוב ביותר היה בשנת 2008

86
00:06:39,840 --> 00:06:43,040
שבו היה יום הרגיל הלאומי הראשון ביטויים,

87
00:06:43,040 --> 00:06:47,350
שאני מאמין הוא 1 יוני אם אתה רוצה לחגוג את זה.

88
00:06:48,430 --> 00:06:50,840
>> שוב, רק קצת יותר תיאוריית כאן.

89
00:06:52,180 --> 00:06:55,320
אז יש כמה דרכים לבניית ביטויים רגולריים שונות.

90
00:06:55,950 --> 00:07:02,050
דרך פשוטה אחת היא לבנות את הביטוי שאתה הולך

91
00:07:02,050 --> 00:07:07,500
לרוץ על המחרוזת לפרש - בעצם לבנות מיני תכנית קטנה ש

92
00:07:07,500 --> 00:07:11,870
ינתח חתיכות של חוט ולראות, "הו, האם זה יתאים ביטוי הרגיל או לא?"

93
00:07:12,250 --> 00:07:14,250
ולאחר מכן להפעיל את זה.

94
00:07:14,250 --> 00:07:17,300
אז אם יש לך ביטוי קטן מאוד רגיל, זה כנראה

95
00:07:17,300 --> 00:07:19,380
הדרך היעילה ביותר לעשות את זה.

96
00:07:20,090 --> 00:07:25,420
ואז אם אתה - אפשרות נוספת היא לשמור על בנייה מחדש

97
00:07:25,420 --> 00:07:30,260
ביטוי כמו שאתה הולך, וכי הוא האפשרות לדמות.

98
00:07:30,440 --> 00:07:37,690
והניסיונות המוקדמים אלה באלגוריתמי ביטוי רגילים היו

99
00:07:37,690 --> 00:07:44,330
יחסית פשוט ומהיר יחסית, אבל לא היה לי הרבה גמישות.

100
00:07:44,330 --> 00:07:47,500
אז כדי לעשות אפילו חלק מהדברים שאנחנו הולכים להסתכל על

101
00:07:47,500 --> 00:07:52,860
היום יש לנו היה צריך לעשות ביטוי מורכב יותר קבוע

102
00:07:52,860 --> 00:07:56,650
יישומים שעשויים להיות איטיות הרבה יותר, כך שהוא משהו לזכור

103
00:07:57,510 --> 00:08:02,920
יש גם הכחשת ביטויים קבועה של מגוון התקפה

104
00:08:02,920 --> 00:08:08,330
כי לנצל את הפוטנציאל עבור יישומים חדשים אלה של

105
00:08:08,330 --> 00:08:10,930
ביטויים רגילים להיות מאוד מורכב.

106
00:08:11,570 --> 00:08:15,650
והרבה באותה התחושה שראינו בהתקפות הצפת מאגר,

107
00:08:15,650 --> 00:08:21,610
יש לך התקפות כי עבודה על ידי ביצוע לולאות רקורסיבית ש

108
00:08:21,610 --> 00:08:24,400
הצפת הקיבולת של זיכרון.

109
00:08:24,780 --> 00:08:29,540
ודרך אגב Regexen היא אחת מהצורות הרבות הרשמיות של ביטוי רגיל

110
00:08:29,540 --> 00:08:32,890
על ידי אנלוגיה לשוורים באנגלו סכסון.

111
00:08:33,500 --> 00:08:40,169
>> אוקיי, אז ספריית פייתון רבים מכם כאן באדם שיש לי מחשבי מקינטוש,

112
00:08:40,169 --> 00:08:43,860
כך למעשה אתה יכול למשוך את זה על המסך שלך.

113
00:08:43,860 --> 00:08:47,480
ביטויים רגולריים בנויים לתוך פייתון.

114
00:08:48,070 --> 00:08:53,020
וכך פייתון הוא מראש על מחשבי מק וגם באינטרנט בקישור הזה.

115
00:08:53,770 --> 00:08:57,350
אז אם אתם צופים בך יכול לעצור ולוודא שיש לך פייתון

116
00:08:58,080 --> 00:09:00,170
כמו שאנחנו משחקים כאן בסביבה.

117
00:09:00,780 --> 00:09:06,420
יש באינטרנט מדריך ל, כך שאם אתה פשוט להקליד לתוך המחשב פייתון

118
00:09:06,420 --> 00:09:10,500
אתה תראה שהגרסה עולה במסוף.

119
00:09:11,070 --> 00:09:17,720
אז סיפק קישור למדריך לגרסת 2 של פייתון, כמו גם גיליון לרמות.

120
00:09:17,720 --> 00:09:23,100
יש גרסה 3 של פייתון, אבל Mac שלך לא בהכרח

121
00:09:23,100 --> 00:09:25,130
באנו עם זה מראש.

122
00:09:25,130 --> 00:09:27,360
אז לא נורא שונה.

123
00:09:27,360 --> 00:09:33,270
אוקיי, אז כמה עקרונות בסיסיים של שימוש בביטויים רגילים בפייתון.

124
00:09:34,080 --> 00:09:42,650
>> אז הנה אני משמש ביטוי מאוד פשוט, אז עשיתי מחדש יבוא פייתון

125
00:09:43,750 --> 00:09:47,070
ולאחר מכן לקח את התוצאה של re.search.

126
00:09:47,070 --> 00:09:49,910
והחיפוש לוקח 2 טענות.

127
00:09:49,910 --> 00:09:56,040
הראשון הוא הביטוי הרגיל, והשני הוא הטקסט

128
00:09:56,040 --> 00:09:58,290
או מחרוזת שברצונך לנתח.

129
00:09:58,290 --> 00:10:01,210
ואז הדפסתי result.group.

130
00:10:01,580 --> 00:10:05,860
אז אלה הם 2 פונקציות בסיסיות אנחנו הולכים לראות היום

131
00:10:06,790 --> 00:10:10,170
ללמוד על ביטויים רגולריים.

132
00:10:10,170 --> 00:10:12,880
אז רק פירוק ביטוי רגיל זה כאן

133
00:10:12,880 --> 00:10:21,770
שעות ולאחר מכן \ W ולאחר מכן מ 'כך \ W פשוט מקבל כל תו בא"ב לשם.

134
00:10:21,850 --> 00:10:26,820
אז הנה אנחנו מחפשים "שעות" ולאחר מכן דמות אחרת אלפביתי

135
00:10:26,820 --> 00:10:30,060
ולאחר מכן מ ', כך שיתאים לכאן בשר חזיר

136
00:10:30,060 --> 00:10:34,480
ב", כריכי אברהם לינקולן ובשר חזיר ".

137
00:10:35,040 --> 00:10:37,150
זו היא התוצאה של אותה הקבוצה.

138
00:10:37,680 --> 00:10:43,130
דבר נוסף שאנו יכולים לעשות הוא להשתמש במחרוזות לפנינו של טקסט בפייתון.

139
00:10:43,130 --> 00:10:46,220
אז אני מניח שאני אלך קדימה ולמשוך את זה כאן.

140
00:10:46,220 --> 00:10:49,210
מחדש יבוא פייתון.

141
00:10:50,070 --> 00:10:54,000
ואם הייתי עושה את אותו הדבר - תן לנו לומר הוא טקסט,

142
00:10:55,390 --> 00:11:00,800
"אברהם," תן לנו להתקרב - שם אנחנו הולכים.

143
00:11:01,610 --> 00:11:06,430
טקסט הוא: "אברהם אוכל בשר חזיר."

144
00:11:07,460 --> 00:11:15,260
אוקיי, ולאחר מכן לגרום = re.search.

145
00:11:16,260 --> 00:11:22,020
ואז הביטוי שלנו יכול להיות שעות, ולאחר מכן אני אעשה נקודה מ '.

146
00:11:22,020 --> 00:11:26,280
אז הנקודה פשוט לוקחת כל תו שהוא לא קו חדש כולל מספרים,

147
00:11:26,280 --> 00:11:28,650
סימני אחוז, משהו כזה.

148
00:11:28,650 --> 00:11:38,030
ולאחר מכן טקסט - בום - ולאחר מכן result.group--כן.

149
00:11:38,030 --> 00:11:41,820
אז זה בדיוק כיצד ליישם את הפונקציונליות בסיסית כאן.

150
00:11:42,300 --> 00:11:55,110
אם היו לנו טבעת טקסט - טקסט מטורף ש-- כלל אומרים המון חתכים בגב

151
00:11:55,110 --> 00:12:01,180
ובתוך מחרוזות ודברים שיכולים להיראות כמו רצפים להימלט,

152
00:12:01,180 --> 00:12:08,480
אז אנחנו כנראה רוצים להשתמש בקלט הטקסט הגולמי כדי לוודא שהוא קיבל.

153
00:12:08,480 --> 00:12:14,120
וזה רק נראה ככה.

154
00:12:14,120 --> 00:12:17,810
אז אם אנחנו מחפשים בכל אחד מהם יש אנחנו לא צריכים למצוא שום דבר.

155
00:12:19,070 --> 00:12:21,680
אבל זה איך היית ליישם אותה, רק לפני המחרוזת של

156
00:12:21,680 --> 00:12:24,990
הביטוי הרגיל אתה שם את אות ר '.

157
00:12:26,150 --> 00:12:30,260
>> אוקיי, אז תן לנו להמשיך.

158
00:12:30,260 --> 00:12:33,730
בסדר - אז הבה נתבונן בכמה דפוסים חוזרים כאן.

159
00:12:34,750 --> 00:12:39,150
אז דבר אחד שאתה רוצה לעשות הוא לחזור על דברים

160
00:12:40,040 --> 00:12:42,480
כמו שאתה מחפש דרך טקסט.

161
00:12:42,480 --> 00:12:48,300
אז כדי לעשות אחריו מספר כלשהו של b - אתה עושה AB *.

162
00:12:48,630 --> 00:12:51,620
ואז יש סדרה של חוקים אחרים.

163
00:12:51,620 --> 00:12:54,380
ואתה יכול להסתכל למעלה כל אלה, אני פשוט ארוץ דרך כמה

164
00:12:54,380 --> 00:12:57,630
אלה נפוצים ביותר.

165
00:12:57,630 --> 00:13:03,920
אז AB + הוא ואחריו כל N גדול מ -0 של b.

166
00:13:04,510 --> 00:13:08,000
ab? הוא ואחריו 0 או 1 של b.

167
00:13:09,190 --> 00:13:18,580
ab {N} הוא ואחריו N של B, ולאחר מכן כן הלאה.

168
00:13:18,580 --> 00:13:22,820
אם יש לך 2 מספרים בסוגריים המסולסלים אתה ציון טווח

169
00:13:23,300 --> 00:13:25,440
יכול להיות שאולי מתאים.

170
00:13:26,390 --> 00:13:30,420
אז אנחנו ייראו יותר בכמה דפוסים חוזרים ונשנים בדקה.

171
00:13:31,960 --> 00:13:42,300
אז 2 דברים שכדאי לזכור בעת שימוש בתבנית התאמת כלים אלה כאן.

172
00:13:42,300 --> 00:13:52,120
אז אומרים שאנחנו רוצים להסתכל על HM של "אברהם לינקולן עושה כריכי בשר חזיר".

173
00:13:52,120 --> 00:13:55,230
אז שיניתי את שמו של אברהם לינקולן לאברהם.

174
00:13:55,230 --> 00:14:00,290
ועכשיו אנחנו מחפשים את מה שהוחזר על ידי פונקצית חיפוש זה,

175
00:14:00,290 --> 00:14:03,270
וזה רק מחזיר את בשר חזיר במקרה זה.

176
00:14:03,620 --> 00:14:08,080
והיא עושה את זה כי החיפוש פשוט לוקח את התור השמאלי ביותר באופן טבעי.

177
00:14:08,080 --> 00:14:12,130
וכל הביטויים הרגילים, אלא אם כן תציינו אחר יעשו את זה.

178
00:14:12,830 --> 00:14:18,880
אם אנחנו רוצים למצוא את כל מה שיש פונקציה לזה - למצוא הכל.

179
00:14:18,880 --> 00:14:35,100
כך שרק יכלו להיראות כמו כל = re.findall ('h.m', טקסט)

180
00:14:35,100 --> 00:14:44,540
ולאחר מכן all.group ().

181
00:14:44,540 --> 00:14:51,040
הכל מייצר גם בשר חזיר ובשר חזיר, ובמקרה זה גם של המיתרים באברהם כל בשר חזיר.

182
00:14:51,610 --> 00:14:55,110
אז זה עוד אפשרות.

183
00:14:56,250 --> 00:15:06,940
>> גדול. הדבר השני שיש לזכור הוא שביטויים רגולריים לקחת הגדול ביותר באופן אינטואיטיבי.

184
00:15:06,940 --> 00:15:09,520
תנו לנו להסתכל על דוגמה זו.

185
00:15:10,200 --> 00:15:16,070
אנחנו עשינו את זה ביותר החיפוש ממני כאן, ולאחר מכן ניסיתי חיפוש גדול יותר

186
00:15:16,070 --> 00:15:18,800
באמצעות מפעיל כוכב Kleene.

187
00:15:18,800 --> 00:15:24,180
אז ל, "אברהם לינקולן עושה כריכי בשר חזיר," ויש לי רק חזרה

188
00:15:24,180 --> 00:15:26,280
מ 'כתוצאה מכך.

189
00:15:26,280 --> 00:15:31,670
הסיבה לטעות שהייתה שאני היה יכול לקחת את כל מספר של

190
00:15:31,670 --> 00:15:36,140
שעות בגלל שלא ציינו דבר ללכת בשעות בין מ.

191
00:15:36,140 --> 00:15:42,010
הדוגמא היחידה שם שהייתה מ '- דוגמאות רק שם עם מ' בזה

192
00:15:42,010 --> 00:15:46,220
וכל מספר שעות של היה פשוט מ 'החוט.

193
00:15:46,490 --> 00:15:51,850
אחר כך ניסיתי את זה שוב, אני אמרתי, "בסדר, תן לנו לקבל את הקבוצה בפועל הגדולה ביותר כאן".

194
00:15:51,850 --> 00:15:59,670
ואז עשיתי שעות. * מ ', כך שרק מחזיר את כל מספרים ותווים בין שעות ודקות.

195
00:16:00,280 --> 00:16:02,950
ואם אתה רק מתחיל וחושב, "אה, בסדר, גם זה יהיה

196
00:16:02,950 --> 00:16:11,560
תבין אותי בשר חזיר, "זה לוקח כל דבר, החל בשעות למעשה אברהם לינקולן

197
00:16:11,560 --> 00:16:13,690
כל הדרך עד לסופו של חזיר.

198
00:16:14,040 --> 00:16:18,110
זה חמדן, זה רואה ש - כל הטקסט הזה אחר - מ ',

199
00:16:18,110 --> 00:16:21,280
וזה מה שזה לוקח פנימה

200
00:16:22,060 --> 00:16:27,480
זה בוטה במיוחד - זו היא תכונה שאנחנו יכולים גם

201
00:16:27,480 --> 00:16:30,670
לציין לזה לא להיות חמדנים שימוש בפונקציות אחרות.

202
00:16:31,480 --> 00:16:34,490
אבל זה משהו שאנחנו צריכים לזכור במיוחד

203
00:16:34,490 --> 00:16:38,720
כאשר מסתכלים בטקסט HTML, וזו אחת סיבות ש

204
00:16:38,720 --> 00:16:41,500
ביטויים רגולריים הם קשים עבור ה-HTML.

205
00:16:42,460 --> 00:16:46,310
כי אם יש לך תג HTML פתוח ולאחר מכן המון דברים באמצע

206
00:16:46,310 --> 00:16:49,820
ועוד קצת HTML אחר נסגר תג הרבה יותר מאוחר בתכנית,

207
00:16:49,820 --> 00:16:55,420
יש לך רק נאכל הרבה קוד ה-HTML שלך אולי בטעות.

208
00:16:56,200 --> 00:17:01,840
>> בסדר - דמויות כל כך יותר מיוחדות, כמו שפות רבות אחרות,

209
00:17:01,840 --> 00:17:04,780
אנו לברוח באמצעות הקו הנטוי.

210
00:17:04,780 --> 00:17:10,329
אז אנחנו יכולים להשתמש בנקודה כדי לציין כל תו למעט שורה חדשה.

211
00:17:10,329 --> 00:17:14,550
אנחנו יכולים להשתמש בבריחת w כדי לציין כל תו אלפביתי.

212
00:17:14,550 --> 00:17:20,329
ועל ידי ד בריחת אנלוגיה לכל מספר שלם - אופי מספרי.

213
00:17:20,630 --> 00:17:27,440
אנו יכולים לציין - אנחנו יכולים להשתמש בסוגריים כדי לציין ביטויים קשורים.

214
00:17:27,440 --> 00:17:30,970
אז זה היה מקבל A, B, או C.

215
00:17:31,320 --> 00:17:37,000
ואנחנו גם יכולים לציין או אפשרויות לאחד או ב.

216
00:17:37,000 --> 00:17:41,110
לדוגמה - אם אנחנו מחפשים אפשרויות מרובות

217
00:17:41,110 --> 00:17:44,940
בסוגריים שאנחנו יכולים להשתמש המפעיל או כב--

218
00:17:44,940 --> 00:17:52,480
אז בוא נחזור לדוגמה זו כאן.

219
00:17:53,000 --> 00:17:59,790
ועכשיו הרשה לנו לקחת - תן לנו לחזור לדוגמה זו כאן, ולאחר מכן

220
00:17:59,790 --> 00:18:12,290
לקחת AE - כך זה צריך לחזור - אני מניח שזה עדיין אברהם.

221
00:18:12,290 --> 00:18:17,410
אז זה - אם אנחנו עושים את כל - גדולים.

222
00:18:17,410 --> 00:18:22,700
אז הרשה לנו לעדכן את הטקסט כאן.

223
00:18:22,700 --> 00:18:34,690
"אברהם אוכל חזיר תוך המהומים -. תוך המינג" גדול.

224
00:18:44,090 --> 00:18:47,330
הכל. גדול. עכשיו אנחנו מקבלים בשר חזיר, בשר חזיר, ומכפלת.

225
00:18:48,510 --> 00:18:59,370
בעוד המינג - בעוד מזמזם לו - ואילו זמזם לאמרתו. גדול.

226
00:19:00,350 --> 00:19:03,250
אותו דבר.

227
00:19:03,820 --> 00:19:09,180
עכשיו כל מה שמחזיר עדיין רק בשר חזיר, בשר חזיר, ומכפלת בלי להרים על הזמזום או לו.

228
00:19:09,940 --> 00:19:22,600
גדול - אז מה אם אנחנו רוצים להסתכל או ש-- כדי שנוכל גם לעשות

229
00:19:23,510 --> 00:19:33,810
לו או - אנחנו נחזור לזה.

230
00:19:34,810 --> 00:19:45,760
אוקיי - כך - בסדר - בתפקידים שאתה יכול גם להשתמש בתו או סימן הדולר

231
00:19:45,760 --> 00:19:49,350
כדי לציין שאתם מחפשים משהו בתחילת או בסוף המחרוזת.

232
00:19:50,260 --> 00:19:52,260
או התחלה או הסוף של מילה.

233
00:19:52,400 --> 00:19:54,470
זוהי דרך אחת להשתמש בזה.

234
00:19:55,630 --> 00:20:01,160
>> אוקיי - אז תן לנו לשחק עם בלוק של טקסט מעט גדול יותר.

235
00:20:03,950 --> 00:20:08,310
תן לנו לומר את השורה הזו כאן - הצהרה זו כאן.

236
00:20:08,310 --> 00:20:11,360
כוחו של ביטוי הרגיל הוא שהם יכולים לציין דפוסים

237
00:20:11,360 --> 00:20:13,390
לא רק קבוע תווים.

238
00:20:14,900 --> 00:20:18,790
תן לנו לעשות - תנו לנו להתקשר אל בלוק זה.

239
00:20:22,400 --> 00:20:27,110
אז תוכל לקרוא את כל זה פנימה

240
00:20:28,890 --> 00:20:50,820
ואז יש לי - תן לנו לעשות את כל =; אז מה הם כמה דברים שאנחנו יכולים לחפש ברווחיים כאן?

241
00:20:50,820 --> 00:20:54,070
אנחנו יכולים להסתכל לאוזן הביטוי.

242
00:20:55,050 --> 00:21:01,520
לא מאוד מעניין. מה דעתך על זה? נצטרך לראות מה קורה.

243
00:21:03,710 --> 00:21:05,710
נתתי לו בעיה.

244
00:21:06,380 --> 00:21:10,750
אז כל מספר של דברים לפני מחדש וכל.

245
00:21:10,750 --> 00:21:15,630
כך שצריך להחזיר את הכל מההתחלה עד כל מחדש אולי כמה פעמים.

246
00:21:18,800 --> 00:21:21,970
ואז כאן יש לנו את כוח של ביטויים רגולריים הוא שהם

247
00:21:21,970 --> 00:21:24,900
ניתן לציין דפוסים לא רק דמויות כאן.

248
00:21:24,900 --> 00:21:28,510
אז כל הדרך עד לגמר מחדש, זה התחיל עם הכי שמאלי והיה חמדן.

249
00:21:30,710 --> 00:21:32,710
תן לנו לראות - מה עוד אנחנו יכולים לחפש.

250
00:21:32,710 --> 00:21:39,860
אני מניח שדבר אחד אם היית מעוניינים במחפש את כינויים שהיא והוא,

251
00:21:39,860 --> 00:21:44,600
אתה יכול לבדוק אם זה שווה ל -0 או 1

252
00:21:44,600 --> 00:21:49,710
וביטויו, ושהוא כנראה לא הולך לחזור -

253
00:21:49,710 --> 00:21:58,020
אה, אני מניח שזה בגלל שיש לו חזר אנחנו מסתכלים על כוח, באותו יום, כאן.

254
00:22:00,590 --> 00:22:06,270
הבה תנסו לציין שזה צריך לבוא בהתחלה של משהו.

255
00:22:06,640 --> 00:22:09,530
תן לנו לראות אם זה יורד לכיוון שער.

256
00:22:09,530 --> 00:22:19,630
אז אנחנו יכולים לעשות את שומן, ויש לנו לא מקבלים שום דבר, כי היא והוא

257
00:22:19,630 --> 00:22:22,870
לא מתרחש בביטוי הזה.

258
00:22:24,960 --> 00:22:30,410
גדול. אוקיי - אז בחזרה לחתול כאן.

259
00:22:30,410 --> 00:22:35,720
דפוסים מורכבים כל כך פוגע במוח.

260
00:22:35,720 --> 00:22:40,500
אז זו הסיבה שאנו משתמשים בביטויים רגילים, כדי למנוע בעיות אלה.

261
00:22:40,820 --> 00:22:43,520
>> אז הנה כמה מצבים שימושיים אחרים שאתה יכול לשחק עם סביב.

262
00:22:43,520 --> 00:22:50,290
אנחנו הבטנו בחיפוש היום, אבל אתה יכול גם להשתמש בהתאמה, פיצול, findall, וקבוצות.

263
00:22:50,290 --> 00:22:53,970
דברים מגניבים אחרים אז אתה יכול לעשות עם ביטויים רגולריים חוץ מזה רק

264
00:22:53,970 --> 00:22:58,870
מחפש דפוסים הוא לוקח תבנית ומחזיק את כל המשחקים -

265
00:22:58,870 --> 00:23:02,530
המשתנים שלה - ולאחר מכן באמצעות אלה בקוד שלך בשלב מאוחר יותר.

266
00:23:02,850 --> 00:23:05,980
זה יכול להיות מועיל למדי. דברים אחרים עשויים להיות לספור.

267
00:23:05,980 --> 00:23:11,720
אז אנחנו יכולים לספור את מספר המופעים של תבנית ביטוי רגילה,

268
00:23:11,720 --> 00:23:13,960
וזה מה שאנחנו יכולים להשתמש בקבוצות ל.

269
00:23:13,960 --> 00:23:17,550
והמצבים אחרים, כמו גם גם אפשרי.

270
00:23:18,040 --> 00:23:22,980
אז אני רק רוצה לדבר קצת יותר על דרכים אחרות אתה יכול להשתמש בביטויים רגילים.

271
00:23:22,980 --> 00:23:29,100
>> אז יישום מתקדם יותר אחד הוא בהתאמה מטושטשת.

272
00:23:29,100 --> 00:23:33,450
אז אם אתם מחפשים טקסט לביטוי, יוליוס קיסר,

273
00:23:33,450 --> 00:23:37,740
ואתה רואה גם גאיוס יוליוס קיסר או את השם יוליוס קיסר בשפות אחרות,

274
00:23:37,740 --> 00:23:44,400
אז אולי אתה גם רוצה להקצות קצת משקל לערכים אלו.

275
00:23:44,400 --> 00:23:48,930
ואם הוא קרוב מספיק - אם הוא חוצה סף מסוים - אז אתה רוצה

276
00:23:48,930 --> 00:23:50,860
כדי להיות מסוגל לקבל את יוליוס הקיסר.

277
00:23:50,860 --> 00:24:00,580
אז יש כמה מימושים שונים שלבעוד כמה שפות אחרות גם כן.

278
00:24:02,580 --> 00:24:08,420
הנה כמה כלים אחרים, Regex PAL - אפליקציה קטנה ונחמדה באינטרנט כדי

279
00:24:08,420 --> 00:24:12,190
לבדוק אם הביטויים הרגילים שלך מורכבים בצורה נכונה.

280
00:24:12,190 --> 00:24:18,500
ישנם גם כלים עצמאיים שניתן להפעיל משולחן העבודה שלך

281
00:24:18,500 --> 00:24:22,100
כמו פיקו Ultra, וכמו גם ספרי בישול בלבד.

282
00:24:22,100 --> 00:24:25,410
אז אם אתה עושה פרויקט שיש בו טונות של ביטויים רגולריים

283
00:24:25,410 --> 00:24:29,810
זה כנראה המקום ללכת אל מחוץ להיקף של היום.

284
00:24:31,520 --> 00:24:35,770
ולאחר מכן, רק כדי לתת לך תחושה של כמה נפוץ הוא

285
00:24:35,770 --> 00:24:44,090
יש grep ביוניקס, יש פרל מובנית, ו-C יש PCRE לג

286
00:24:44,090 --> 00:24:48,890
ויש לי אז כל אלה שפות אחרות גם חבילות ביטוי רגולרי

287
00:24:48,890 --> 00:24:52,020
שפועלים עם רמה דומה של תחביר שיש לנו טעם של היום.

288
00:24:52,020 --> 00:24:54,790
PHP, Java, רובי, וכן הלאה.

289
00:24:56,080 --> 00:24:58,980
>> חיפוש קוד גוגל הוא למעשה שווה אזכור, הוא אחד

290
00:24:58,980 --> 00:25:05,720
מספר קטן יחסית של יישומים שם בחוץ, כי מאפשר לציבור הגישה

291
00:25:05,720 --> 00:25:07,800
מסד הנתונים שלה תוך שימוש בביטויים רגילים.

292
00:25:07,800 --> 00:25:12,920
אז אם אתה מסתכל על קוד חיפוש של Google אתה יכול למצוא את הקוד

293
00:25:12,920 --> 00:25:16,880
אם אתם מחפשים דוגמה לאופן שעשויה לשמש פונקציה,

294
00:25:16,880 --> 00:25:21,610
אתה יכול להשתמש בביטוי רגיל למצוא שפונקציה נמצא בשימוש בכל מיני מקרים שונים.

295
00:25:21,610 --> 00:25:28,000
אתה יכול לחפש fwrite, ואז אתה יכול לחפש את הדגל של לכתוב או לקרוא

296
00:25:28,000 --> 00:25:32,000
אם אתה רוצה דוגמה לfwrite בשימוש במקרה זה.

297
00:25:33,530 --> 00:25:37,010
אז אותו הדבר שם, והנה כמה המלצות.

298
00:25:37,010 --> 00:25:40,990
זה יהיה זמין באינטרנט, כמו גם, אז הולך קדימה אם

299
00:25:40,990 --> 00:25:45,560
אתה רוצה להסתכל על פייתון, grep, פרל - אתה רק רוצה לקבל קצת השראה

300
00:25:45,560 --> 00:25:50,650
או אם אתה רוצה להסתכל יותר בתאוריה הנה כמה קפיצות טובות את המקומות.

301
00:25:50,650 --> 00:25:53,870
תודה רבה.

302
00:25:58,470 --> 00:25:59,910
[CS50.TV]