﻿1
00:00:00,960 --> 00:00:02,940
‫-: Die Filterfunktion, die

2
00:00:02,940 --> 00:00:06,250
‫wir gerade implementiert haben, funktioniert also bereits großartig, aber

3
00:00:06,250 --> 00:00:09,860
‫in diesem Video möchten wir es auf die nächste Stufe

4
00:00:09,860 --> 00:00:12,733
‫bringen, indem wir noch komplexere Abfragen zulassen.

5
00:00:14,210 --> 00:00:17,680
‫Im Moment kann ein Benutzer die Dokumente also

6
00:00:17,680 --> 00:00:22,430
‫nur filtern, indem er einen Schlüssel gleich einem Wert setzt, oder?

7
00:00:22,430 --> 00:00:24,760
‫Aber jetzt wollen wir

8
00:00:24,760 --> 00:00:27,680
‫eigentlich auch die Operatoren größer als, größer

9
00:00:27,680 --> 00:00:31,733
‫oder gleich, kleiner als und kleiner gleich als Operatoren implementieren.

10
00:00:32,780 --> 00:00:34,510
‫Anstatt also nur gleich

11
00:00:34,510 --> 00:00:37,500
‫zu sein, möchten wir zum Beispiel tatsächlich in der

12
00:00:37,500 --> 00:00:40,130
‫Lage sein, Dauer größer oder gleich fünf und

13
00:00:40,130 --> 00:00:42,290
‫nicht nur gleich zu sagen, in Ordnung?

14
00:00:42,290 --> 00:00:45,310
‫Und das macht alles etwas komplexer.

15
00:00:45,310 --> 00:00:48,140
‫Bevor ich Code schreibe, werde ich die

16
00:00:48,140 --> 00:00:50,810
‫Abfrage tatsächlich so schreiben, wie sie

17
00:00:50,810 --> 00:00:53,043
‫in MongoDB aussehen soll.

18
00:00:55,150 --> 00:00:58,200
‫Wie würde das Filterobjekt eigentlich aussehen?

19
00:00:58,200 --> 00:01:00,360
‫Und lass es uns hier als Kommentar

20
00:01:00,360 --> 00:01:02,273
‫schreiben und wieder nur als Übung.

21
00:01:03,270 --> 00:01:06,090
‫Das Objekt würde also ungefähr so aussehen,

22
00:01:06,090 --> 00:01:09,723
‫also Schwierigkeit, beginnen Sie damit, stellen Sie einfach und dann Dauer

23
00:01:14,040 --> 00:01:17,030
‫ein; Und jetzt denken Sie daran, dass wir,

24
00:01:17,030 --> 00:01:21,000
‫wenn wir einen Operator verwenden möchten, ein anderes Objekt starten müssen.

25
00:01:21,000 --> 00:01:24,530
‫Und dann verwenden wir es für

26
00:01:24,530 --> 00:01:29,530
‫den Größer-oder-Gleich-als-Operator so, bis fünf, richtig, erinnern Sie sich daran?

27
00:01:30,640 --> 00:01:33,050
‫So würden wir das Filterobjekt

28
00:01:33,050 --> 00:01:36,383
‫für die gerade angegebene Abfrage manuell schreiben.

29
00:01:37,340 --> 00:01:40,240
‫Kehren wir nun tatsächlich zu Postman

30
00:01:40,240 --> 00:01:43,860
‫zurück, damit ich Ihnen eine Art Standardmethode zum

31
00:01:43,860 --> 00:01:47,440
‫Schreiben einer Abfragezeichenfolge einschließlich dieser Operatoren zeigen kann.

32
00:01:47,440 --> 00:01:50,670
‫Und wir machen das so, also öffnen wir vor

33
00:01:50,670 --> 00:01:53,150
‫dem Gleichheitszeichen die Klammern und dann

34
00:01:53,150 --> 00:01:55,880
‫schreiben wir hier den Operator, also in

35
00:01:55,880 --> 00:01:58,650
‫diesem Fall größer oder gleich, und das war's.

36
00:01:58,650 --> 00:02:01,880
‫Und im Grunde fügen wir dem Schlüssel-Wert-Paar einen dritten

37
00:02:01,880 --> 00:02:04,680
‫Teil hinzu, also haben wir den

38
00:02:04,680 --> 00:02:07,610
‫Schlüssel, den Wert und jetzt auch den Operator.

39
00:02:07,610 --> 00:02:09,930
‫Und wir verwenden diese Klammern wieder,

40
00:02:09,930 --> 00:02:11,923
‫um den Operator anzugeben.

41
00:02:13,060 --> 00:02:15,320
‫Das ist also wieder eine

42
00:02:15,320 --> 00:02:17,170
‫Standardmethode und lassen

43
00:02:17,170 --> 00:02:21,150
‫Sie uns jetzt einen Blick auf die Abfragezeichenfolge werfen,

44
00:02:21,150 --> 00:02:23,360
‫die Express uns gibt,

45
00:02:23,360 --> 00:02:25,823
‫und wie zuvor, protokollieren wir tatsächlich

46
00:02:27,310 --> 00:02:32,310
‫eine Reg Dot-Abfrage in der Konsole, log Reg Dot-Abfrage, alle rechts.

47
00:02:32,600 --> 00:02:35,530
‫Schauen wir uns also an, wie unser

48
00:02:35,530 --> 00:02:37,640
‫Abfrageobjekt aussehen wird, wenn

49
00:02:37,640 --> 00:02:39,940
‫wir die Abfragezeichenfolge wie folgt angeben.

50
00:02:39,940 --> 00:02:42,040
‫In Ordnung, jetzt fällt Ihnen als erstes auf, dass

51
00:02:42,040 --> 00:02:43,640
‫wir hier einen Fehler erhalten, aber

52
00:02:43,640 --> 00:02:45,573
‫machen Sie sich darüber erst einmal keine Sorgen.

53
00:02:46,570 --> 00:02:50,470
‫Was mich hier interessiert, ist dieses Objekt, und lassen

54
00:02:50,470 --> 00:02:52,920
‫Sie mich es hierher kopieren.

55
00:02:55,570 --> 00:02:58,820
‫Alles klar, was fällt dir hier auf?

56
00:02:58,820 --> 00:03:01,420
‫Nun, was wir hier sehen, ist, dass

57
00:03:01,420 --> 00:03:03,870
‫das Abfrageobjekt fast identisch mit

58
00:03:03,870 --> 00:03:06,350
‫dem von uns manuell geschriebenen Filterobjekt aussieht,

59
00:03:06,350 --> 00:03:10,513
‫der einzige Unterschied besteht darin, dass wir hier das MongoDB-Operatorzeichen haben.

60
00:03:11,360 --> 00:03:13,420
‫Das ist also wirklich das

61
00:03:13,420 --> 00:03:16,210
‫Einzige, was hier vor diesem Betreibernamen fehlt.

62
00:03:16,210 --> 00:03:18,620
‫Okay, und die Lösung

63
00:03:18,620 --> 00:03:21,780
‫dafür besteht darin, im Grunde alle Operatoren

64
00:03:21,780 --> 00:03:24,300
‫wie diese durch ihre entsprechenden MongoDB-Operatoren

65
00:03:24,300 --> 00:03:29,030
‫zu ersetzen, also im Grunde dieses Dollarzeichen hier hinzuzufügen, okay.

66
00:03:29,030 --> 00:03:31,270
‫Also lasst uns das jetzt implementieren, und tatsächlich

67
00:03:31,270 --> 00:03:33,433
‫machen wir es irgendwo hier oben, lasst uns

68
00:03:34,810 --> 00:03:36,960
‫hier noch ein paar Kommentare hinzufügen.

69
00:03:38,700 --> 00:03:42,090
‫Also Filterung, die wir in der letzten Vorlesung gemacht haben,

70
00:03:42,090 --> 00:03:45,313
‫jetzt fügen wir etwas erweiterte Filterung hinzu, und das

71
00:03:47,920 --> 00:03:50,903
‫ist der Code, den wir jetzt schreiben werden.

72
00:03:52,720 --> 00:03:56,393
‫Nun lasst uns diesen Code hier ganz oben einfügen, in Ordnung.

73
00:03:57,290 --> 00:03:59,860
‫Dann brauchen wir diesen Code hier nicht wirklich, aber ich möchte

74
00:03:59,860 --> 00:04:01,160
‫ihn trotzdem hier behalten,

75
00:04:01,160 --> 00:04:03,193
‫also lass ihn uns hier am Ende platzieren.

76
00:04:04,960 --> 00:04:08,270
‫Und dann nur dieser Code hier als Referenz, um sicherzustellen,

77
00:04:08,270 --> 00:04:11,210
‫dass wir wissen, was wir hier tun.

78
00:04:11,210 --> 00:04:13,330
‫Alles klar, und jetzt, da wir wissen,

79
00:04:13,330 --> 00:04:15,230
‫was wir hier tun müssen,

80
00:04:15,230 --> 00:04:17,400
‫ist es eigentlich nur ein einfaches Javascript-Problem.

81
00:04:17,400 --> 00:04:19,420
‫Und ich löse es

82
00:04:19,420 --> 00:04:22,710
‫so, also werde ich zuerst das Objekt in

83
00:04:25,230 --> 00:04:30,230
‫eine Zeichenfolge konvertieren, damit die Abfragezeichenfolge dem JSON-Punkt-Stringify des Abfrageobjekts entspricht, und

84
00:04:35,600 --> 00:04:38,780
‫jetzt kann ich diese Abfragezeichenfolge verwenden, um die

85
00:04:38,780 --> 00:04:40,963
‫Ersetzungsfunktion darauf zu verwenden .

86
00:04:42,060 --> 00:04:44,530
‫In Ordnung, und was ich jetzt

87
00:04:44,530 --> 00:04:48,330
‫also ersetzen möchte, ist das gte durch das Dollarzeichen gte und

88
00:04:48,330 --> 00:04:50,403
‫dann noch einen anderen Operator.

89
00:04:51,360 --> 00:04:53,290
‫Diejenigen, die wir ersetzen

90
00:04:53,290 --> 00:04:56,113
‫möchten, sind also größer oder gleich, größer

91
00:04:56,970 --> 00:05:01,010
‫als, kleiner oder gleich und kleiner als, und es gibt

92
00:05:01,010 --> 00:05:03,620
‫mehrere Möglichkeiten, dies zu tun, aber

93
00:05:03,620 --> 00:05:06,193
‫ich werde einen regulären Ausdruck verwenden.

94
00:05:07,243 --> 00:05:10,340
‫Und für mich persönlich sind reguläre

95
00:05:10,340 --> 00:05:13,450
‫Ausdrücke eines der schwierigsten Konzepte in Javascript

96
00:05:13,450 --> 00:05:16,210
‫und überhaupt in der Programmierung.

97
00:05:16,210 --> 00:05:18,270
‫Wenn ich so etwas tun

98
00:05:18,270 --> 00:05:21,538
‫muss, gehe ich normalerweise einfach auf Stack Overflow oder google einfach

99
00:05:21,538 --> 00:05:24,180
‫herum, um die richtige Lösung für das Problem

100
00:05:24,180 --> 00:05:26,280
‫zu finden, das ich zu lösen versuche.

101
00:05:26,280 --> 00:05:28,070
‫Was wir jetzt also

102
00:05:28,070 --> 00:05:31,660
‫tun möchten, ist, im Wesentlichen eines dieser vier Wörter zuzuordnen und

103
00:05:31,660 --> 00:05:33,900
‫es dann durch dieselben Wörter zu

104
00:05:33,900 --> 00:05:35,933
‫ersetzen, jedoch mit dem Dollarzeichen davor.

105
00:05:36,980 --> 00:05:38,530
‫Der reguläre Ausdruck,

106
00:05:38,530 --> 00:05:42,620
‫um eines dieser vier Wörter zu finden, sieht also so

107
00:05:42,620 --> 00:05:46,820
‫aus; Also öffnen wir diese Klammern und schreiben dann die

108
00:05:46,820 --> 00:05:50,517
‫Operatoren, also gte oder gt oder lte oder lt.

109
00:05:55,500 --> 00:06:00,500
‫Und dann müssen wir dieses \b auch davor und danach hinzufügen, und das liegt daran,

110
00:06:01,140 --> 00:06:04,283
‫dass wir nur diese genauen Wörter abgleichen möchten.

111
00:06:05,220 --> 00:06:08,183
‫Stellen Sie sich also vor, es gibt ein Wort, das

112
00:06:08,183 --> 00:06:10,700
‫lt enthält, dann wollen wir natürlich nicht

113
00:06:10,700 --> 00:06:14,070
‫abgleichen, dass wir nur dann abgleichen möchten, wenn es genau dieses Wort

114
00:06:14,070 --> 00:06:16,840
‫ist, ohne dass es eine andere Zeichenfolge darum gibt.

115
00:06:16,840 --> 00:06:19,170
‫Und dieser reguläre Ausdruck, den ich hier

116
00:06:19,170 --> 00:06:21,310
‫habe, wird sich darum kümmern,

117
00:06:21,310 --> 00:06:24,670
‫und tatsächlich fehlt ein Stück und das ist dieses g-Flag hier,

118
00:06:24,670 --> 00:06:27,130
‫was bedeutet, dass es tatsächlich mehrmals vorkommen wird.

119
00:06:27,130 --> 00:06:30,270
‫Wenn wir also zwei oder drei

120
00:06:30,270 --> 00:06:33,880
‫Operatoren oder sogar alle haben, werden sie alle ersetzt.

121
00:06:33,880 --> 00:06:36,240
‫Und ohne dieses g hier würde

122
00:06:36,240 --> 00:06:40,300
‫es nur das erste Vorkommen ersetzen, daher ist dieses sehr wichtig.

123
00:06:40,300 --> 00:06:43,460
‫Wodurch wollen wir es nun eigentlich ersetzen?

124
00:06:43,460 --> 00:06:45,450
‫Nun, die Methode replace

125
00:06:45,450 --> 00:06:48,880
‫akzeptiert tatsächlich einen Callback, der sehr mächtig ist, und

126
00:06:48,880 --> 00:06:51,100
‫dieser Callback hat als erstes Argument

127
00:06:51,100 --> 00:06:53,523
‫das übereinstimmende Wort oder die übereinstimmende Zeichenfolge.

128
00:06:55,060 --> 00:06:58,690
‫Wir können also match an diese Callback-Funktion übergeben und

129
00:06:58,690 --> 00:07:01,840
‫von diesem Callback geben wir die neue Zeichenfolge

130
00:07:01,840 --> 00:07:04,690
‫zurück, die die alte ersetzt, okay?

131
00:07:04,690 --> 00:07:07,200
‫Lassen Sie uns hier also eine

132
00:07:07,200 --> 00:07:08,820
‫Vorlagenzeichenfolge erstellen, und

133
00:07:08,820 --> 00:07:13,820
‫wir möchten die Übereinstimmung durch eine Übereinstimmung mit dem Dollarzeichen ersetzen. Okay,

134
00:07:14,190 --> 00:07:17,060
‫das ist also der Teil der Vorlagenzeichenfolgensyntax.

135
00:07:17,060 --> 00:07:19,860
‫Das hier ist also diese Übereinstimmung, und dann

136
00:07:19,860 --> 00:07:22,613
‫wollen wir das Dollarzeichen davor setzen.

137
00:07:25,690 --> 00:07:28,570
‫Und jetzt, um sicherzugehen, protokollieren

138
00:07:29,970 --> 00:07:34,250
‫wir es tatsächlich in der Konsole und möchten das

139
00:07:34,250 --> 00:07:38,303
‫Objekt tatsächlich zurück, also analysiert JSON die Abfragezeichenfolge.

140
00:07:40,210 --> 00:07:43,200
‫In Ordnung, lassen Sie mich das hier klären, damit

141
00:07:43,200 --> 00:07:45,603
‫Sie die Ergebnisse etwas besser sehen können.

142
00:07:48,541 --> 00:07:50,050
‫Auch hier erhalten wir

143
00:07:50,050 --> 00:07:52,240
‫diesen Fehler und das liegt natürlich daran,

144
00:07:52,240 --> 00:07:54,330
‫dass MongoDB den Abfragestring oder das Abfrageobjekt,

145
00:07:54,330 --> 00:07:56,933
‫wie wir es gerade haben, nicht wirklich verwenden kann.

146
00:07:58,980 --> 00:08:01,300
‫Und hier haben wir die

147
00:08:01,300 --> 00:08:04,610
‫beiden Ergebnisse und Sie sehen tatsächlich, dass unser Ergebnis

148
00:08:04,610 --> 00:08:07,150
‫genau das gleiche ist wie zuvor

149
00:08:07,150 --> 00:08:09,670
‫und etwas hier eindeutig nicht funktioniert.

150
00:08:09,670 --> 00:08:12,240
‫Versuchen wir also herauszufinden, was das ist.

151
00:08:12,240 --> 00:08:15,940
‫Und hier sieht der reguläre Ausdruck ganz gut aus,

152
00:08:15,940 --> 00:08:18,707
‫hier sieht alles gut aus, ah, aber

153
00:08:18,707 --> 00:08:22,470
‫okay, das Problem ist, dass ich ihn im String ersetze,

154
00:08:22,470 --> 00:08:24,320
‫aber dann nirgendwo speichere.

155
00:08:24,320 --> 00:08:28,030
‫Und eigentlich wollen wir es zurück in die Abfragezeichenfolge speichern.

156
00:08:28,030 --> 00:08:30,580
‫Also ändern wir dies

157
00:08:30,580 --> 00:08:33,940
‫hier in ein let, damit es dann

158
00:08:33,940 --> 00:08:38,940
‫die Daten mutieren kann und sagen wir, Abfragestring, oh sorry.

159
00:08:39,640 --> 00:08:44,640
‫Abfragezeichenfolge entspricht also der ersetzten Abfragezeichenfolge, genau wie zuvor, also

160
00:08:45,530 --> 00:08:49,750
‫habe ich einfach vergessen, das Ergebnis hier tatsächlich wieder

161
00:08:49,750 --> 00:08:52,693
‫in der Variablen zu speichern.

162
00:08:54,320 --> 00:08:58,670
‫Versuchen wir es noch einmal, und jetzt funktioniert es.

163
00:08:58,670 --> 00:09:01,170
‫Jetzt haben wir also

164
00:09:01,170 --> 00:09:04,400
‫das Dollarzeichen vor dem Operator, großartig.

165
00:09:04,400 --> 00:09:07,840
‫Okay, also es funktioniert, lasst uns diese Kommentare hier und jetzt endlich

166
00:09:07,840 --> 00:09:10,430
‫loswerden, alles was wir tun müssen ist hier

167
00:09:10,430 --> 00:09:13,703
‫eigentlich nicht das Abfrageobjekt zu verwenden sondern einfach dieses zu verwenden.

168
00:09:16,730 --> 00:09:19,290
‫Also JSON. parsen Sie die

169
00:09:19,290 --> 00:09:22,020
‫Abfragezeichenfolge, und wenn Sie keinen Operator in der Abfragezeichenfolge

170
00:09:22,020 --> 00:09:23,770
‫haben, funktioniert natürlich alles gut.

171
00:09:23,770 --> 00:09:27,920
‫Es wird dort einfach keinen dieser vier Operatoren finden, aber das ist

172
00:09:27,920 --> 00:09:29,670
‫kein Problem, es ersetzt dann

173
00:09:30,539 --> 00:09:31,403
‫einfach nichts.

174
00:09:32,681 --> 00:09:36,290
‫Und probieren wir es auch aus. Es dauert ein

175
00:09:37,690 --> 00:09:39,800
‫bisschen, aber es kamen tatsächlich

176
00:09:39,800 --> 00:09:41,750
‫drei Ergebnisse zurück. Lassen

177
00:09:41,750 --> 00:09:45,020
‫Sie uns nun überprüfen, ob sie tatsächlich richtig sind.

178
00:09:45,020 --> 00:09:47,860
‫Die Dauer sollte also größer oder gleich fünf

179
00:09:47,860 --> 00:09:50,570
‫sein, und dieser hier ist eine Dauer von

180
00:09:50,570 --> 00:09:52,730
‫fünf, dies hat eine Dauer von

181
00:09:52,730 --> 00:09:54,880
‫neun, was größer oder gleich fünf

182
00:09:54,880 --> 00:09:58,730
‫ist, und so funktioniert es tatsächlich, die Schwierigkeit ist immer noch

183
00:09:58,730 --> 00:10:02,460
‫einfach und so was es bedeutet, dass der Code, den wir

184
00:10:02,460 --> 00:10:04,603
‫gerade implementiert haben, einwandfrei funktioniert.

185
00:10:05,480 --> 00:10:08,750
‫Perfekt, jetzt fügen wir zum Spaß noch einen

186
00:10:08,750 --> 00:10:11,380
‫weiteren Parameter hinzu, also filtern wir

187
00:10:11,380 --> 00:10:13,860
‫jetzt auch nach dem Preis.

188
00:10:13,860 --> 00:10:18,860
‫Dieser hat also fast 2000, dann 1100, dieser hat 300.

189
00:10:19,350 --> 00:10:23,070
‫Lassen Sie uns nun nach Preisen unter Tausend

190
00:10:23,070 --> 00:10:25,150
‫oder unter Tausendfünfhundert filtern.

191
00:10:28,100 --> 00:10:32,920
‫Und der Preis, und jetzt wieder unsere Klammern, und

192
00:10:32,920 --> 00:10:37,920
‫wir verwenden weniger als 1500, und in Ordnung, senden Sie das.

193
00:10:41,320 --> 00:10:46,240
‫Und was bekommen wir hier, oh, jetzt haben wir nur zwei Ergebnisse.

194
00:10:46,240 --> 00:10:51,240
‫Und tatsächlich, die Preise hier, 397, und hier 1197, und

195
00:10:51,420 --> 00:10:54,930
‫so ist der vorher 2000er jetzt weg.

196
00:10:54,930 --> 00:10:57,470
‫Also haben wir auch diesen herausgefiltert, indem

197
00:10:57,470 --> 00:11:00,670
‫wir wieder den Operator verwenden, den wir gerade implementiert haben.

198
00:11:00,670 --> 00:11:03,030
‫Und wir könnten jetzt hier nach

199
00:11:03,030 --> 00:11:07,060
‫allen möglichen Dingen filtern, aber Sie verstehen, worauf es ankommt, und

200
00:11:07,060 --> 00:11:10,110
‫ja, wir haben hier an dieser Stelle unsere

201
00:11:10,110 --> 00:11:14,500
‫Art der erweiterten Filterung implementiert, die jetzt sogar diese vier Operatoren akzeptiert.

202
00:11:14,500 --> 00:11:16,600
‫In der realen Welt müssten

203
00:11:16,600 --> 00:11:19,340
‫wir dann eine Dokumentation schreiben, im Wesentlichen

204
00:11:19,340 --> 00:11:22,040
‫damit der Benutzer weiß, welche Arten von

205
00:11:22,040 --> 00:11:25,100
‫Operationen er an unserer API ausführen kann, oder?

206
00:11:25,100 --> 00:11:28,800
‫Also, idealerweise würden wir unsere API komplett dokumentieren, indem wir

207
00:11:28,800 --> 00:11:31,660
‫angeben, welche Anfragen mit welchen HTTP-Methoden gestellt werden

208
00:11:31,660 --> 00:11:34,360
‫können und dann auch, welche Art von

209
00:11:34,360 --> 00:11:36,490
‫Filterung oder Sortierung oder all diese

210
00:11:36,490 --> 00:11:39,580
‫Funktionen, welche davon verfügbar sind und wie sie sie

211
00:11:39,580 --> 00:11:41,570
‫verwenden können, richtig ?

212
00:11:41,570 --> 00:11:44,400
‫In unserem Fall werden wir das natürlich nicht

213
00:11:44,400 --> 00:11:47,000
‫tun, aber vergessen Sie nicht, dass Sie

214
00:11:47,000 --> 00:11:50,160
‫diese Art von Dokumentation wirklich machen müssen, wenn Sie

215
00:11:50,160 --> 00:11:53,600
‫wirklich eine API implementieren, die von jemand anderem verwendet wird.

216
00:11:53,600 --> 00:11:56,780
‫Aber egal, lassen Sie uns jetzt zu unserem nächsten

217
00:11:56,780 --> 00:11:59,203
‫Video übergehen und eine Sortierfunktion implementieren.

