Transkripte
1. Einführung: Willkommen zu meinem Kurs, JavaScript-Interviewfragen
mit praktischen Aufgaben. In diesem Kurs
werden wir gemeinsam
59 beliebtesten
Interviewfragen lösen , die sie
in den letzten zehn Jahren bekommen haben oder gestellt wurden, und sie werden das gesamte
Wissen über JavaScript abdecken. Dieser Kurs konzentriert sich voll und ganz
auf die Koordinatenaufgaben. diesem Grund
empfehle ich Ihnen dringend, jede
einzelne Aufgabe selbst zu implementieren. Zunächst werden wir es danach gemeinsam auf
verschiedene Arten
implementieren, um ein unterschiedliches
Wissensniveau zu erzielen. Am Ende dieses Kurses sind
Sie viel
besser darauf vorbereitet, dass Ihr
JavaScript-Interview einen Job bekommt. Wer bin ich? Mein Name ist
Alexander kohärierter Hinweis, und ich bin Webentwickler, war mehr als zehn
Jahre Erfahrung. Es sowie ein professioneller
Instruktor mit verschiedenen Kursen über
Web-Technologien. Ich habe mein Bestes getan, um mein
ganzes Wissen in
diesen Kurs einzubringen , und ich
wollte es mit Ihnen teilen. Also willkommen an Bord
und lass uns loslegen.
2. Arten von Interviews: Es gibt drei
verschiedene Arten von Interviews, die Sie erhalten könnten. Zuallererst ist es
theoretisches Elternteil. Ihnen wurden gerade ein paar
Fragen zu Ihrer Arbeit und
Erfahrung und so weiter gestellt. Dies ist eine normale Art
von Interview für fortgeschrittene
Entwickler, bei denen sie fortgeschrittene
Entwickler, bei denen sie
bereits viele Jahre
Erfahrung haben , weil der
Interviewer versteht, okay, dieser Typ arbeitete
in der Webentwicklung, zum Beispiel mit
JavaScript in den letzten fünf Jahren, was bedeutet, dass er über
genügend Kenntnisse verfügt und es keinen Sinn macht, seine Programmierfähigkeiten zu
überprüfen. Die zweite beliebte Art von Interview ist das
Koordinateninterview. Und eigentlich würde ich sagen, dass dies die beliebteste
Art von Interview ist. Die Leute mischten oft
theoretisches Interview
mit Programmierherausforderungen zusammen , was bedeutet, dass
Sie
einige theoretische Fragen bekommen und dann etwas codieren müssen. Meistens verwenden Sie nur Stift und Papier und Nicht-Computer. In diesem Kurs lösen
wir gemeinsam 59 verschiedene
JavaScript-Herausforderungen, die Sie bekommen können. Diese Herausforderungen werden in
fast allen JavaScript behandelt , dem
er in den Interviews begegnen wird. Und die letzte Art von Interview ist das Vorstellungsgespräch für das Projekt. Normalerweise
wollte der Interviewer Ihren Code sehen. Wenn Sie also
etwas zu zeigen haben, ist
es viel einfacher
für Sie, da Sie nicht
nur zufällige Fragen beantworten sollten, sondern
über Ihr Projekt,
über Ihren Code und so weiter sprechen können . Was eigentlich bedeutet, dass ich Ihnen für
das Interview
wärmstens empfehlen kann , um
ein Projekt umzusetzen , da
Sie dem Interviewer
zunächst etwas
zeigen können. Und zweitens
haben Sie etwas zu besprechen, das
Sie zumindest wissen.
3. Interview und Arbeit sind völlig anders: Um einen Job zu bekommen, müssen
Sie normalerweise ein Interview bestehen. Und so funktioniert es
in fast allen Unternehmen. Aber das Hauptproblem dabei ist, dass
Ihr Interview nicht immer mit Ihrer Arbeit
zusammenhängt, was tatsächlich bedeutet, dass einige
der Interviews schwierig werden , keine
realen Fragen, aber Sie müssen
sie beantworten um einen Job zu bekommen, aber Sie werden dieses Wissen
später in Ihrem Arbeitsalltag nie
nutzen . Hier ist das Problem. Es gibt einige Ähnlichkeiten
zwischen Einführung und Arbeit, aber tatsächlich sind sie unterschiedlich. Und in der perfekten Welt muss
Ihr Interview ein Spiegel Ihrer wirklichen Arbeit
im Unternehmen sein. Aber leider ist es
nicht immer so. Deshalb musst du beides wissen. Sie müssen wissen, wie Sie
das Interview bestehen , und Sie
müssen wissen, wie man arbeitet. In diesem Kurs sind die meisten
Herausforderungen völlig echtes
Wissen, das Sie
kennen müssen und das Sie sowohl in
Ihrem Interview als auch
im Alltag benötigen . Aber er hat auch
einige Fragen
in diesen Kurs aufgenommen , die sich nicht auf Ihre
alltägliche Programmierung beziehen, aber Sie müssen sie
nur für Ihre Einführung kennen.
4. Mapping Benutzer zum Abrufen von Benutzernamen: Die erste Aufgabe, die wir uns
ansehen möchten , klingt so. Sie müssen
einen Code schreiben, um Namen
von einem Array von Benutzern zu entfernen . Und wie Sie hier sehen können, haben
wir eine Reihe von Benutzern. Und eigentlich ist es nur
ein Array von Objekten. Wir sehen diesen Namen und
dieses aktive Eigentum. Und eigentlich ist das eine
relativ einfache Aufgabe, aber es ist wirklich schön, das Interview
zu beginnen. Und erfahrene
Interviewer werden wissen, dass Sie unter Stress stehen, was bedeutet, dass
Sie
mehrere einfache Übungen erhalten müssen , nur damit Sie sich
ein wenig entspannen und mehr sein können fokussiert
und produktiver. Und tatsächlich kann sogar eine
einfache Übung
dem Interview ziemlich viel sagen , welchen
Codestil Sie verwenden, wie benennen Sie Ihre Variablen und wie Sie Ihren Code
schreiben, damit er verstehen kann, auf
welcher Ebene Sie und welche Fragen muss
er dir stellen? Jetzt
empfehle ich Ihnen dringend,
dieses Video zu posten und es selbst zu
implementieren. Wenn du einfach nur
mitmachen willst, dann kodieren wir das. Und tatsächlich gibt es
mehrere Möglichkeiten, es zu implementieren. Normalerweise beginnen Anfänger
mit for-Schleife, weil es der einfachste
Ansatz ist, den sie wissen. Zum Beispiel können
wir hier
nach unserem Benutzer drei hier für Schleife schreiben. Also haben wir hier, um Index von Null
zu Benutzer schräg zu
lassen. Also hier haben wir eine kleinere Länge als Benutzerlänge und hier
haben wir acht plus plus. Jetzt in unserer for-Schleife möchten
wir auf
jeden einzelnen Namen zugreifen und ihn in etwas Ruhm drängen. Bevor wir ein Array erstellen
möchten, nennen
wir es deshalb Namen und es
wird ein leeres Array sein. Jetzt können wir innerhalb einer
for-Schleife
Namen schreiben , um auszugeben,
und hier innerhalb des Zugriffs in unseren Benutzern habe ich gesehen, dass dies unser
aktueller Benutzerpunktname ist. In diesem Fall werden wir in dieses Recht
einen Online-Namen dieses
Benutzers gesetzt. Und nach unserer
for-Schleife können wir einfach console.log in Ihren Namen
und überprüfen und durchsuchen. Ich bin auf der Seite verwandt
und wie Sie sehen können, ist
unser Ergebnis Chegg. John Mike Dies ist genau das, was wir umsetzen müssen, und ja, wir haben unsere Aufgabe gelöst. Und wenn Sie ein Anfänger sind, ist
diese Lösung völlig in Ordnung. Aber Sie können es besser machen,
denn jedes Mal, wenn Sie versuchen, ein Interview
besser zu codieren, zeigen
Sie, dass Sie ein besserer
Entwickler sind. Deswegen. Lass uns kommen und erzähle diesen
Code und versuche es noch einmal. Was wir
hier anstelle von
for-Schleife verwenden können , ist die
Rich-Funktion für unser Array. Hier können wir
einfach den Benutzerpunkt für
Rich schreiben und innen müssen wir eine Callback-Funktion
bereitstellen. Was noch wichtiger ist, dass wir hier Zugang
zu jeder einzelnen Nutzung
erhalten und jetzt innerhalb einer
Dose tun können, was wir wollen. Und wie Sie hier sehen können, haben
wir keine Indizes und unser Code sieht viel besser aus. Was wir hier machen wollen, ist genau das gleiche Zeug
wie zuvor. Wir haben hier in den
echten Namen erstellt und jetzt in unserer für jede Schleife
möchten wir in unsere Namen,
unseren Benutzerpunktnamen, schieben . Und wie Sie im
Vergleich zu unserem alten Code sehen können, ist
dieser Code viel
einfacher zu lesen. Lassen Sie uns hier unsere
console.log etwas gemeinsam machen und prüfen Sie,
ob es funktioniert. Wie Sie sehen können, erzielen wir
genau das gleiche Ergebnis. Dies ist also Ihre
zweite Ebene von Write-in-Code, aber tatsächlich ist der
beste Weg,
diese Aufgabe zu lösen , die Verwendung
zusätzlicher Map-Funktion. Und tatsächlich wird es
Ihren Code am einfachsten machen nur weil Sie
das richtige Tool für
die richtige Aufgabe verwenden . In diesem Fall können wir hier schreiben, dass wir unser
Names-Array
zurückbekommen wollen , und hier möchten wir unsere Benutzer mit
der Map-Funktion
durchlaufen . Und wenn Sie nicht wissen, was
die Map gut macht, durchlaufen Sie
jedes einzelne Element in unserem Array und
geben einige Ihrer Daten für
jedes einzelne Element in unseren Schlüsseln anstelle
unseres Objekts zurück, wir möchten einen einzigen Namen zurückgeben. Das ist wo? Hier können wir
schreiben, dass wir einen Benutzer haben und
seinen Benutzerpunktnamen zurückgeben möchten. Lasst uns prüfen, ob es funktioniert. Wie Sie im Browser sehen können, erhalten
wir genau
die gleiche Ausgabe. Aber dies ist die beste Variante für diese Aufgabe und es
zeigt, dass Sie wissen, was Sie für die
Lösung tun , ist fast
immer auf niedrigem Niveau, was bedeutet, dass Sie genau implementieren
müssen,
was Sie tun es. In diesem Fall
müssen wir hier sagen, dass wir Elemente auf unsere neuen Array-Namen übertragen. Und was Sie hier sehen können, haben wir names-Array erstellt,
bevor wir for-Schleife verwenden, was
bedeutet, dass
unsere Logik und unsere zusätzliche Variable nichts zusammen
haben. In unserem Fall
schreiben wir das Ergebnis direkt in unsere neuen
Variablennamen. Also hast du
diese Aufgabe erfolgreich gelöst und jetzt
bekommst du die nächste. Wir müssen wieder
auf aktive Benutzer zurückgreifen, was bedeutet, dass unser erster
Punkt hier gültig ist, aber dies müssen
alle aktiven Benutzer sein. Und tatsächlich könnten wir
jede Methode verwenden , die wir
hier wollen, um dies zu lösen. Zum Beispiel
könnten wir hier
for-Schleife verwenden und einfacher
im Inneren schreiben als wenn Bedingung. Und wir können
hier überprüfen, ob unser Benutzer
aktiv ist und ob diese
Eigenschaft wahr ist, dann möchten wir
unser Element im Inneren zu unserem drängen .
Und du hast Recht. Und wie Sie im Browser sehen können, erhalten
wir
nur zwei Benutzer weil unser letzter
Benutzer inaktiv ist. Das ist völlig in Ordnung, aber wir haben hier zwei Probleme. Zuallererst ist unser
Code auf niedrigem Niveau. Und zweitens mischen wir
hier Logik mit Filtern und Elementen
und kartieren sie. Und das ist schlecht, denn wenn
Ihr Code komplexer ist
, ist es
schwieriger, ihn zu teilen. Und tatsächlich wird die
Lösung mit für jeden genau dieselbe sein. Aber schauen wir uns die
Lösung dieser Karte an. Eigentlich, was wir hier machen
wollen. Wir möchten zunächst unser Array filtern und auf
die aktiven Benutzer zugreifen. Und danach möchten wir
unsere Map anwenden , damit wir
genau hier Punktfiltern können. Und wir haben genau die gleiche
Logik, die wir hier auf
unseren Benutzer zugreifen können, und wir müssen
hier ein Prädikat
mit true oder false zurückgeben . In unserem Fall wird es sein,
dass der
Benutzerpunkt aktiv ist . Wenn unser Benutzer aktiv
ist lassen wir
ihn in unserem Array. In jedem Fall
werden wir es wegwerfen und nach dieser Arbeit in
unserer Karte aufrufen, um Namen zuzuordnen. Was in
diesem Code hier wichtig ist, wenn Merkin
nicht gemischt und
gefiltert werden,
was bedeutet, dass es einfacher ist, solchen Code
zu unterstützen. Jetzt haben wir eine andere Aufgabe. Sie bekommen
bestimmte Benutzer nach
absteigendem Alter und natürlich auch
zu den ersten Regeln. Was bedeutet, dass wir zuerst Ray aussortieren
müssen
und dann unsere Rate
filtern
und unsere Namen abbilden müssen . Und wie Sie hier sehen können, erhalten wir
zusätzlich Alterseigentum. Dies ist unsere Immobilie
, nach der wir unseren Tarif sortieren werden. Und tatsächlich,
wenn Sie in JavaScript etwas suchen möchten, müssen
Sie nur eine einzige
JavaScript-Funktion
verwenden nicht sortiert ist. Sie können
es nicht wirklich anders machen, wenn Sie nicht wissen, wie eine
Resortfunktion funktioniert. Sie können zu Entwicklern springen
Mozilla orig zu dieser URL und hier ist eine
echte Prototyp-Site. Die Hauptidee ist, dass es
sich um eine
Colin-Suchfunktion in unserem
Array handelt, und im Inneren
übergeben wir einen Funktionskomparator
mit A und B und in unserem Fall wird es erster Benutzer und
zweiter
Benutzer
sein und dritter Benutzer, was bedeutet, dass er
Elemente einzeln vergleicht. Und hier müssen wir etwas
zurückgeben. Wie Sie drinnen sehen können,
können wir minus eins zurückkehren. Wenn A weniger als B A ist
, werden wir prüfen. Jetzt müssen wir
eins zurückgeben, wenn A größer
als B ist und
Null zurückgeben, wenn sie gleich sind. Und
genau das müssen wir hier tun. In allen drei Fällen müssen
wir also denselben Code schreiben, aber in den ersten beiden Varianten wird
es irgendwie verschwommen sein weil wir tatsächlich die
Sortierung vor unserem Code hier durchführen müssen . Lassen Sie uns also
unseren Code kommentieren und wir möchten
bestimmte anwenden und hier möchten
wir die gespeicherte
Sortierung des Benutzers schreiben und wir bekommen
hier unseren Komparator. Also haben wir hier
Benutzer eins und Benutzer zwei und wir möchten sie nach Alter
vergleichen. Deshalb können wir hier schreiben. Der Ein-Punkt-Alter des Benutzers ist bis zu diesem Alter geringer
als der Benutzer. Und wenn es stimmt
, haben wir hier einen zwei ternären Operator, den wir minus eins zurückgeben
wollen. In einem anderen Fall
wollen wir einen zurückgeben. Lasst uns das speichern und
prüfen, ob es funktioniert. Ich springe zum Browser, um
die Seite zu laden , und wir
holen John und checken. Schauen wir uns das Salz oben an. John ist 18 und Jack ist 20, was bedeutet, dass
unsere Daten korrekt sortiert werden, aber in absteigender Reihenfolge, wie Sie
hier sehen können , muss
in absteigender Reihenfolge sortiert werden, was bedeutet, dass wir hier nicht minus eins
tauschen wollen, aber eins, und hier
wird minus eins sein. Prüfen wir
zuerst das
Ergebnis, das wir bekommen , Jack
und dann John. Und das ist eine korrekte
Sortierung, auch Sie müssen sich an diese Sortieroperation in
JavaScript-Mutaten und Array erinnern . Dies ist hier mit
der regulären Codesortierung und wir
haben unser Ergebnis keiner Eigenschaft zugewiesen , da
es nur
unser Benutzerarray mutiert und dann andere
Dinge damit machen. Aber wie Sie
hier sehen können,
ist dieser Code wirklich von
unserer vollständigen Schleife getrennt , da wir
dies vor unseren Operationen tun müssen . Kommentieren wir nun
diesen Code und
versuchen ihn mit unserer
Karte und unserem Filter zu verwenden. Und hier ist es viel einfacher zu tun weil wir einfach
wollen unsere Benutzer dot sort aufrufen und danach Filter und Map
aufrufen. Wie Sie hier sehen können, sieht
es wirklich hübsch aus,
wenn ich kommentiert werde. Wir haben hier unsere Benutzer
unsere Sortierung gemacht. Danach machen wir unser
Filtern und dann Mapping. Und zuallererst
ist dieser Code viel einfacher zu lesen. Sie haben hier Verkettung
und Sie erhalten Ihr Ergebnis in dieser
einzigen Eigenschaft. Außerdem ist es wichtig
, dass wir verschiedene Operationen
nicht mischen. Erstes einzufügendes Wort, dann filtern und dann zuordnen. Und wenn wir einen von ihnen
anpassen müssen, müssen
wir
die Logik eines anderen nicht ändern. Lassen Sie uns prüfen, ob es
funktioniert und
die Seite überflutet und wir erhalten
genau das gleiche Ergebnis. Wie Sie sehen können, können Sie
sogar die einfache Aufgabe
auf verschiedene Arten lösen . Wenn Sie
im Interview zeigen möchten , dass Sie ein
fortgeschrittener Entwickler sind, müssen
Sie ein bestimmtes Tool
für Ihre spezifische Aufgabe verwenden. Hier ist die
Kette von Denken, Mapping und Filtern hier
viel besser als die for-Schleife zu verwenden.
5. Unterschied zwischen Null und undefiniert: Vielleicht bekommst du eine
Frage wie diese. Was wird im ersten Beispiel und
im zweiten Beispiel eingeloggt ? Um die Scherung richtig beantworten zu
können, müssen Sie
den Unterschied zwischen
null und undefined
in JavaScript verstehen . Wie Sie hier sehen können, haben
wir zwei Beispiele. Erstes Beispiel: Wir haben unserer Variablen
nichts zugewiesen,
was bedeutet, dass diese Variable noch nicht definiert
ist. Deshalb, wenn wir diese Variable hier
konsolenprotokollieren, sie gleich, undefiniert ist sie hier
danach sind wir konsolenloggen den Typ
dieser Variablen an, der Name des Titels ist auch undefiniert es hier
haben wir unser zweites Beispiel. Wir befinden uns in unserer Variablen zwei
wurde ein Nullwert zugewiesen. Hier sind wir Konsolen-Login var2. Und das kannst du
hier verstehen, dass wir unseren Wert haben. Nun, das
werden wir auf dem Bildschirm sehen. Typ der Variablen zwei
ist jedoch ein Objekt, da es keinen solchen Typ gibt, weshalb der Typ der Variablen ein Objekt
ist.
Schauen wir uns das an. Ich lade die Seite neu und wir bekommen sie hier undefiniert. Dies ist unsere Variable hier. Der Wert davon ist also undefiniert. Es ist der Typ von undefined
es ist nicht definiert als String. Jetzt, nachdem diese Arbeitskonsole protokolliert und
hier durchgearbeitet hat, bekommen wir jetzt das ist unser Wert und
der Typ der Variablen ist ein Objekt. Sie müssen in
JavaScript wirklich zwischen
null und undefined unterscheiden . Es ist undefiniert. Dies bedeutet, dass die
Variable deklariert ist, der Wert
jedoch
noch nicht innerhalb dieser Variablen zugewiesen ist. Genau das
haben wir hier in Zeile drei. Und jetzt
ist in JavaScript ein Zuweisungswert, was bedeutet, dass es ein Wert ist, den wir innerhalb der Variablen zuweisen
können. In unserem Fall hier signieren wir
jetzt innerhalb der Variablen zu. Und selbst wenn Sie hier
richtig geantwortet haben, fragt der
Interviewer Sie vielleicht, aber was ist
der Unterschied zwischen heute und damals wann wir
es verwenden müssen und wann wir es
verwenden müssen undefiniert es. Und eigentlich ist es schwierig ,
weil
wir normalerweise in
normalen Sprachen nur eine einzige Eigenschaft haben, was bedeutet, dass das
Ehrwürdige nicht existiert. Zum Beispiel
„Neue Schaltfläche JavaScript“. Wir haben zwei verschiedene Dinge. Wir haben
es nicht definiert und das haben wir jetzt. Und tatsächlich
hängt es wirklich von Ihrem Codestil und Ihrem Team ab, da Sie beide im Projekt
verwenden können . Aber zum Beispiel
ziehe ich es vor, immer
online zu verwenden und versuche so wenig undefiniert
und so wie möglich zu sein. Aber wenn
Sie versuchen, einen Wert innerhalb des Arrays zu
finden, erhalten
Sie natürlich einen Wert innerhalb des Arrays zu
finden, das
undefinierte und nicht jetzt, weil wir
nichts gefunden haben. Also die Antwort hier, dass es in Ordnung
ist, beide zu benutzen. Es gibt nicht wirklich etwas
Besseres in der einen oder anderen.
6. Hissen: Möglicherweise wird Ihnen im Interview
die
Frage wie diese gestellt, was wird hier auf der Konsole
protokolliert? Und wie Sie hier sehen können, haben
wir das Konsolenprotokoll voll und dann ist foo gleich eins. Und eigentlich ist dies
eine typische
Frage zum Hissen. Hebefehler
bedeutet, dass die Deklaration Ihrer Variablen an den
Anfang der Datei blasen
wird. Und so funktioniert es
in JavaScript, wenn Sie Schlüsselwort var oder das
Funktionsschlüsselwort
verwenden. Die Frage ist also,
was wir hier sehen werden, wir haben hier Konsolenprotokoll
f2 und f2 ist eine Variable, aber wie Sie sehen können, ist
es nicht deklariert. Und in der zweiten Zeile haben
wir foo gleich eins. Eigentlich werden wir hierher
kommen und verengen. Schauen wir uns das
an. Ich lade die Seite neu und wir bekommen foo ist nicht definiert, weil ja,
die erste Zeile, die ausgeführt
wird,
Konsolenprotokoll ist und foo nicht innerhalb einer Datei
definiert ist. diesem Grund haben wir diesen Fehler. Also die richtige Antwort hier, wir werden einen Fehler bekommen, da
foo es nicht definiert hat. Das Hauptproblem besteht darin, dass Sie
in der Regel einige Chancen nur auf dem Papier zu antworten ohne dass der Computer verwendet wird. Weil
Programmierer offensichtlich nicht jeden Tag Computer benutzen. diesem Grund können Sie es im Browser nicht
wirklich testen. Und du musst vorher verstehen, wie all dieses Zeug
funktioniert. Nach einer korrekten Übertragung werden
Sie wahrscheinlich in
etwa so etwas gefragt. Die nächste Frage
dann wird es uns gut gehen, wir sind hier für die Konsole einloggen, aber danach haben wir
var foo gleich zwei. Und eigentlich hier ist
der große Unterschied,
weil dann die erste
Frage, die wir hier hatten ,
f2 gleich eins, aber wir
hatten keine Erstellung der Variablen. Aber hier haben wir var2, was eigentlich eine
Erzeugung der Variablen ist. Aber Sie könnten denken, okay, wir sollten
nach dem Konsolenprotokoll passieren, was bedeutet, dass wir immer noch einen Fehler
bekommen, dass foo
nicht definiert ist , weil
Y2 später passiert. Aber eigentlich ist das eine falsche
Antwort, denn die Hauptidee ist, dass die Deklaration
zwar an den
Anfang der Datei sprudelt, was bedeutet, dass es genau
derselbe Code ist wie hier drin, var foo, und hier weisen wir
nur f2 zu tunen zu. Dies ist genau derselbe Code. So
interpretiert JavaScript diesen Code. Deshalb, wenn
wir einen Browser öffnen, können
Sie sehen,
dass wir es undefiniert werden, warum es passiert, denn tatsächlich haben wir hier var foo und in diesem Fall sind wir f2 nicht definiert weil wir danach
keinen
Wert zugewiesen haben, haben
wir ein Konsolenprotokoll für, wir werden es undefiniert. Und erst danach
weisen wir die Anstiftung zu Formular zu, was bedeutet, dass es
kein Fehler sein wird, es wird nicht wahr sein, es wird undefiniert sein. Es. Dieser Vorgang wird als Hissen bezeichnet. Wenn Sie richtig geantwortet
haben, erhalten Sie möglicherweise eine weitere
Frage zum Hissen. Wie Sie hier sehen können,
ist Frage drei. Wir haben hier voll gleich drei, dann konsolenlog foo und dann var foo. Und ich denke, jetzt wirst du die Antwort
wissen. Ja, wir haben hier Warum, und es sprudelt an
den Anfang der Datei,
was bedeutet, dass so weit Fu genau so
ist, wie
es hier geschrieben wurde, was bedeutet, dass wir in der ersten
Zeile
voll definieren Eigenschaft auf der nächsten Folie wo Anmeldefuß oder drei. Und nach diesem Anmeldeformular für die
Arbeitskonsole, was bedeutet, dass es gleich drei
sein wird. Und es
spielt keine Rolle, dass die Kriegsführung am Ende läuft. Es wird nach
oben sprudelt. Schauen wir uns das an. Ich lade die Seite neu
und wir bekommen drei und
genau das haben wir gewartet. Sie können genau
die gleiche Frage bekommen, aber nicht mit Wörtern, sondern mit dem Schlüsselwort function, wenn Sie irgendwo in
Ihrer Codefunktion und dann
den Namen Ihrer Funktion haben , und dann sind Sie drinnen
richtig, in irgendeiner Logik wird
diese spezifische Definition nach oben sprudeln, was bedeutet, dass
es keine
Rolle spielt , in welcher Zeile
Ihres Codes Sie sind, oder? Und Funktion foo, es wird
die erste Zeile sein , die in JavaScript ausgeführt wird
, was eigentlich bedeutet, dass
es völlig in Ordnung ist, wenn ich hier
vorher foo aufrufe . Wie Sie im Browser sehen können, erhalten
wir keine Fehler,
da diese foo Funktion nach oben
sprudelt ist und genauso
funktioniert wie var. Und hier ist eine weitere
wichtige Sache , die Sie
auf Ihre Antwort gemeistert haben. Sie müssen erwähnen, dass wir const und lead verwenden
können, und wir haben keine
Probleme damit, weil sowohl CONST als auch Blei und überhaupt
nicht sprudelt. Was bedeutet, wenn
hier const a gleich eins bereitzustellen, wird
es nirgends sprudeln. Wenn es
auf der 17. Linie definiert ist, wird es beim 17. Fliegen existieren
,
was bedeutet, dass wir keine
Probleme mit der konstanten LED haben. Und die Art und Weise, wie JavaScript unseren Code
interpretiert, ist genau die gleiche Art wie Code , den wir auf dem Bildschirm sehen. Sie können also einfach sagen
, dass Sie
CONST verwenden und in
jedem einzelnen Projekt führen und kein Problem mit dem
Blubbern der Variablen
oder mit dem Hissen haben .
7. Verschlüsse: Dies ist sicherlich eine
Frage, die sie
bei jedem einzelnen
JavaScript-Interview hören . diesem Grund müssen Sie Wasserverschlüsse
verstehen. Wie Sie hier sehen können, haben
wir eine Aufgabe, erstellen eine Zählerfunktion, die inkrementiert
ist und
gültige Funktionen erhalten. Und tatsächlich
bekommen Sie es vielleicht nicht von dieser Aufgabe, aber dies ist eine Aufgabe in Bezug auf Klauseln, da wir
eine Funktion erstellen müssen , bei der im Inneren
einen Wert wiederherstellen und wir
zwei öffentliche Methoden haben. Auf diese Weise
müssen Sie es normalerweise implementieren. Wir möchten
beispielsweise unsere private
Zählerfunktion erstellen . Und das ist privat, weil wir die Buchhaltungsseite starten, die außerhalb nicht verfügbar ist. Und eigentlich
ist das nur eine Funktion. Wenn Sie jedoch in
Interviews hören, dass Sie oder etwas
Insider-Funktion
benötigen, Sie
nach dem Aufrufen dieser Funktion haben
Sie
nach dem Aufrufen dieser Funktion eine Frage
zur Schließung. Was wir hier tun wollen, wollen
wir, dass wir unseren Counter
erstellen. Nennen wir es zählen, und standardmäßig ist es 0. Jetzt müssen wir
unsere öffentliche API zurückgeben, diese beiden Methoden erhöhen
und eine faire Funktionalität erhalten. Deshalb kehren wir hier
zurück und drinnen wollen wir zwei Dinge
zurückgeben. Zuallererst handelt es sich um eine
Inkrementfunktion. Dies ist nur eine Immobilie, in wir unseren Wert überschreiten. Und was wir
tun wollen, wir wollen
diese Zählung ändern , die wir hier an der Spitze
haben. Wir sind genau hier drin,
zählen plus gleich, und hier ist unser Wert
, den wir erhöhen wollen. Und tatsächlich könnte es
sein, dass wir es
standardmäßig
erhöhen wollen, nur um eins. Deshalb ist es sinnvoll, hier einen zu übergeben, in diesem Fall können
wir einfach inkrement aufrufen und es wird sofort funktionieren. Und die nächste Methode
wird hier sein, getValue, weil wir unsere Zählung zurückbekommen wollen
. Und tatsächlich ist dies hier nur eine Funktion,
die unsere Zählung zurückgibt. Und die Grundidee ist, dass
dies unsere öffentliche API ist. Dies ist es, was
in dieser Funktion verfügbar ist ,
nachdem wir sie aufgerufen haben, schauen wir uns das an. Lassen Sie uns hier unseren Zähler erstellen
und wir sind Doppelpunkt hier, unsere private Zählerfunktion. Und was
ich hier machen möchte, möchte
ich zuerst das
Protokoll konsolen, unseren Zählerpunkt GetValue. Dies ist eine Methode, um unseren Zähler zu
bekommen. Und zweitens
möchten wir den Zählerpunkt aufrufen, und hier ist ein Inkrement, um den R-Wert zu
erhöhen und dann erneut
zu
zählern, um den Wert zu überprüfen. Lassen Sie uns noch einmal
prüfen, ob es funktioniert. Ich lade die Seite neu,
wir kriegen 01. Aber am meisten
interessiert an der Idee, was wir in diesem
privaten Schalter
haben, wenn wir hier sind, privater Zähler, können Sie
sehen, dass dies eine Funktion ist und wir tatsächlich
keine haben Zugriff auf diese
Eigenschaft zählen. Diese Eigenschaftsanzahl ist in
diesem Fall privat. Und wenn ich direkt hier
drin bin, können
Sie sehen, dass wir
ein Objekt mit zwei Werten
erhalten, Wert und Inkrement erhalten, und wir haben keinen Zugriff auf unsere Counter-Eigenschaft darin. Dieser Code funktioniert, aber er ist wirklich schwierig und komplex, weil
dies eine Schließung ist. Was bedeutet Schließung jemals? Schließung bedeutet, dass wir innerhalb
einer Funktion auf den äußeren Bereich zugegriffen
haben , was tatsächlich bedeutet, dass
hier beispielsweise
innerhalb des Inkrements
, das wir zählen verwenden ,
und wir haben keinen Rabatt
innerhalb dieses -Funktion. Wir haben es draußen hier oben und genau
das
Gleiche in Bezug auf den Wert bekommen. Wir haben diesen Zähler
hier oben, nicht innerhalb dieser Funktion,
was bedeutet, dass Collage oder Funktion Zugriff auf
alle Eigenschaften
in sich selbst und auf alle Eigenschaften hat in sich selbst und auf alle Eigenschaften , die es definiert wurden vorher. Warum es wichtig ist, weil sie tatsächlich mit diesem einzelnen Liner, Cons Counter gleich
privatem Zähler sind, schaffen
wir eine Schließung, weil
wir jetzt Counter existieren. Wir haben eine Schließung und wir haben diesen Hinweis auf diesen Zähler. diesem Grund funktioniert
es
jedes Mal, wenn wir GetValue und Increment
aufrufen, GetValue und Increment
aufrufen, und es referenziert diese
Zählung oben. Und man könnte sagen, okay, aber es klingt wie Magie. Ich verstehe nicht, wie es in JavaScript
aussieht. Und hier kann
uns das
Konsolenverzeichnis helfen , wenn wir
in die Konsole schreiben,
nicht das Konsolenprotokoll, sondern das
Konsolenverzeichnis. Und drinnen
möchte ich eine Funktion übergeben. In unserem Fall wird
getValue gekontert und dann hier
versteckt, geben Sie ein. Hier sehen wir keinen Körper, sondern stattdessen ist unsere
Funktion ein Objekt. Und wir sind hier
teilweise interessiert, was Scopes genannt wird. Und genau das ist es,
woran wir
danach interessiert sind , hier
geöffnet Bereiche, wir haben hier eine Immobilienschließung, und das ist genau unsere Schließung, wie Sie hier sehen können, haben wir
Schließung Private Counter. Hier ist die Zählung gleich eins, was bedeutet,
dass genau diese Lead-Anzahl gleich 0 ist, und jetzt ist sie innerhalb der Schließung. diesem Grund ist es
für uns in JavaScript verfügbar. Und die ältesten Fragen zu Klauseln habe ich genau das Gleiche. Zum Beispiel könnte Ihnen die Frage gestellt
werden, Sie müssen
eine Funktion erstellen, die in einer geheimen Zeichenfolge gespeichert
wird, und wir geben sie einfach zurück ,
wenn wir diese
Funktion erneut aufrufen Sie müssen
eine Funktion erstellen, die in einer geheimen Zeichenfolge gespeichert
wird,
und wir geben sie einfach zurück,
wenn wir diese
Funktion erneut aufrufen. siehst
ungefähr so aus. Erstellen wir zum Beispiel
eine Funktion privat geheimnisvoll. Hier geben wir
nichts hinein, aber wir wollen drinnen unsere geheime Zeichenfolge
erstellen. Also lasst uns einfach ein
Geheimnis schaffen und es ist gleich vier. Dieses Geheimnis ist also
genau unsere Schließung. Damit es draußen verfügbar ist, müssen
wir hier eine Funktion zurückgeben. Wir geben einfach eine Funktion
zurück, und diese Funktion
gibt ein Geheimnis zurück. Das bedeutet, dass
wenn wir
außerhalb einer Funktion erstellen ,
die wir
beispielsweise geheim nennen können , hier unsere
private geheime Funktion aufrufen muss. Die Hauptidee ist, dass die private geheime Funktion eine Funktion
zurückgibt. In diesem Fall wird r
Secret eine Funktion ist. Und jetzt können wir konsolen log hour wird geheim und wir nennen es einfach. Und tatsächlich, wie Sie ihn konsolen sehen
können, bekommen
wir diesen
Vollbildmodus zurück. diesem Grund ist unsere geheime Zeichenfolge tatsächlich eine Schließung
und ist
draußen verfügbar , nachdem
dieses private Geheimnis
innerhalb der zusätzlichen Eigenschaft wiederhergestellt wurde. In diesem Fall beginnen wir mit Offenlegung, nachdem unsere
Funktion ausgeführt wurde. Und der Verschluss ist ein sehr beliebtes
Muster in JavaScript. diesem Grund müssen Sie wissen,
wie man Schließungen benutzt.
8. Weinen: Vielleicht bekommst du eine
Frage wie diese. Schreiben Sie eine Funktion, die
hilft, Multiplikation
a und b zu erreichen und das
Produkt von a und B zurückzugeben Und wie Sie hier sehen können, haben
wir diese seltsame Notation. Multipliziere sie a und B, nicht wie zwei Argumente, aber dies ist der erste
Aufruf der Funktion, und dies ist eine zweite
Farbe der Funktion. Und wenn Sie eine solche Frage
bekommen, bedeutet das, dass Sie
in Richtung Strom gehen. Und aktuell ist eine
besondere Möglichkeit in JavaScript, eine Funktion zu
tragen. Und dann können wir es so
nennen. Und tatsächlich können
wir hier
dieses Zeug mit
Super-Basisstrom umsetzen . Probieren wir das jetzt aus. Was ich tun möchte, möchte ich Multiply Funktion
erstellen. Und hier bekommen wir unser A, also wird es zum Beispiel die Nummer
eins sein. Hier möchten wir
eine Funktion zurückgeben , da
wir, wie Sie hier oben sehen
können, das Ergebnis der Multiplikation von a,
b aufrufen, was bedeutet, dass wir Master
zurückgeben eine Funktion
multiplizieren. Hier können wir also schreiben, dass wir eine Funktion
bekommen
, die B erhält Dies ist zum Beispiel Nummer zwei. Und hier drinnen wollen wir unsere Num1 und Num2
multiplizieren. In diesem Fall wird unsere zweite
Funktion für
uns eine Multiplikation von
Nummer eins und Nummer zwei liefern . Und so können wir es benutzen. Wir können hier Konsolenprotokoll schreiben. Wir wollen hier anrufen, ich multipliziere die Funktion und wir übergeben zum Beispiel zwei. Und danach rufen wir b. Dies ist unsere zweite Funktion
und wir geben S3 weiter. Schauen wir uns im Browser an. Ich lade die Seite neu
und wir bekommen sechs, was bedeutet, dass dieser
Code funktioniert. Und tatsächlich kann man
diese Multiplikationsfunktion
besser schreiben . Sie können hier einfach Retouren weglassen und dann wird es ein
einfacher einzelner Liner sein. Wir haben hier Multiply Funktion und wir werden hier taub. Dann wollen wir
hierher eine Funktion zurückgeben, und wir bekommen hier num2. Und wir wollen unsere
Nummer eins multiplizieren und num2 multiplizieren. Dies ist genau die gleiche Logik, aber es argumentiert
die einzelne Zeile. Ich komme jetzt und
erzähle den vorherigen Code. Und lasst uns prüfen, wie Sie sehen können, dass
wir genau
das gleiche Ergebnis erzielen, aber das ist nicht wirklich aktuell. Wenn Sie eine solche Aufgabe lösen, werden Sie
normalerweise gefragt, okay, aber was haben
Sie hier geschrieben? Was heißt das? Warum brauchen wir eine so
seltsame Notation? Und tatsächlich
müssen Sie sagen, dass wir hier über Strom
sprechen, es gibt eine nächste
Frage, die Sie
erhalten könnten , ist eine
Art Funktion zu erstellen. Und das ist eigentlich
eine schwierige Frage. Und wenn Sie
keine Erfahrung mit aktuellen Funktionen hatten, werden
Sie wahrscheinlich nicht unsicher sein. Deshalb
werden wir uns hier ansehen, wie wir eine Art
Funktion erstellen
können und warum brauchen wir sie und tatsächlich
Funktionen tragen , die genau
so funktionieren, wie ich mich hier multipliziere. So können wir zum Beispiel im
Browser schreiben, Kyrie, und das ist unsere Funktion. Wir müssen immer innerhalb
der Funktion übergeben , die wir abdecken
möchten. In diesem Fall
haben wir zum Beispiel
eine Funktion mit a, B und C. Also haben wir
drei Argumente und wir wollen nur
ein Plus B plus C summieren. Der Hauptpunkt ist, dass
das Ergebnis von Cardi ein Funktion und
nennen wir, dass es etwas getragen hat. So verwenden wir Strom, was wir später mit
dem Auto machen können, wir können hier unsere Argumente schreiben. Wir haben drei Argumente, wie wir zum Beispiel hier 123 schreiben können, genau wie drei
normale Argumente. Wir können es auch mit 123 nennen, was bedeutet, dass wir
kein Ergebnis erzielen bis wir
drei Argumente erhalten haben. Zum Beispiel haben wir hier nur
ein Argument, eins, dann wird es die
teilweise angewandte Funktion zurückgeben, was bedeutet, dass wir eine Funktion
zurückbekommen. Und wenn wir
diese Funktion aufrufen und zwei Argumente
übergeben
, erhalten wir
genug Argumente und wir werden ein Ergebnis zurückgeben. Und natürlich sollte es auch
möglich sein , die
Funktion so aufzurufen. Zunächst
nennen wir es mit einem und dann
nennen wir es mit 23. So
funktioniert die normalerweise
getragene Funktion und wir werden sie gerade
erstellen. Was wir hier machen wollen, wollen
wir eine
Curry-Funktion erstellen. Und wie gesagt, das ist
fortgeschrittenere Sachen und tatsächlich ist es eine gute Idee, diese Funktion zu schreiben,
war ECMO-Skriptdatei. Also diese Funktionsschlüsselwörter, nur weil wir
etwas schreiben , das als Bibliothek verwendet
wird. Hier
möchte ich hier eine Funktion schreiben, und hier
bekommen wir eine Funktion. Und eigentlich hier
oben, versuchen wir es, unsere Verwendung, damit wir verstehen,
wovon wir sprechen. Wir sagten hier, dass wir
wollen, dass wir etwas tragen wollen. Wir rufen hier
unsere aktuelle Funktion auf. Und im Inneren übergeben wir eine
Funktion mit a, B und C. Und hier wollen wir a, B und C
summieren und tatsächlich
kann ich sie
nach unserer Anfrage nicht einmal
hier unten schreiben . So können wir testen, ob es
tatsächlich funktioniert, wie Sie hier sehen können, als unsere aktuelle Funktion. Und wir kommen
in die Funktion ein. Das ist unser Fn, dieses abc und a plus b plus
c ist unsere Funktion hier. Aber wir wollen jetzt
wissen , wie viele Argumente
wir hier haben. Hier möchte
ich hier
eine Eigenschaft erstellen , die Arity genannt
wird. Hier können wir einfach
Funktionslänge schreiben und wir erhalten hier die Anzahl
der Argumente. Schauen wir uns das an. Konsolenprotokollarität Und hier ist unsere Arität. Ich schaue im Browser
und wir bekommen drei, denn hier haben wir drei
Argumente, a, B und C. Jetzt möchten wir hier
eine Funktion zurückgeben, weil wir wissen, dass die aktuelle Funktion immer eine Funktion
ist. Das ist y hier Lass uns Funktion
schreiben, Nennen
wir es zum Beispiel f1. Und hier möchte ich
unsere Argumente verbreiten und lasst uns überprüfen,
was wir hier drin haben, Konsolenprotokoll F1 hier
unsere Argumente. Und wenn ich
die Seite neu lade, bekommen
wir, wie Sie sehen können , nichts, weil wir dieses Auto nicht angerufen haben. Was wir danach tun müssen, müssen
wir entmutigte Summe
als Funktion bezeichnen und wir können in etwas
hineingehen. In unserem Fall können wir 123 bestehen. Dies sind unsere drei Parameter. Ich lade die Seite neu und
wir kommen hier f1, 123. Also bekommen wir alle
Argumente als Array. Das ist unsere Idee. Und offensichtlich können wir diese Funktion auch nur mit einer
aufrufen. Dann werden wir ein Array
mit nur einem Argument bekommen. Was ich drinnen machen möchte, möchte
ich überprüfen, wie
viele Argumente wir haben oder ob wir genug
Argumente haben oder nicht. Hier
können wir hier
innerhalb der Rückkehr die Länge der Argumente vergleichen, dies ist die Länge unseres Arrays
ist größer oder gleich. Dies bedeutet, dass wir
genug Argumente bekommen , um
aus der Funktion herauszukommen. Also hier möchte ich genug Argumente
konsolen. In diesem Fall
möchte ich nur
unsere Funktion hierher zurückgeben und
sie mit unseren Argumenten aufrufen. Ich bin wieder in unseren
Argumenten verbreitet, und es wird einfach
alle Argumente so vorbringen , wie
sie es zuvor waren. Schauen wir uns das
an. Ich lade die Seite neu und wir haben eine
Nachricht genug Argumente. Und tatsächlich können wir hier konsolenprotokollieren, was
wir zurückbekommen. In diesem Fall
müssen wir unser Ergebnis erhalten. Ich lade die Seite neu,
wir kriegen sechs. Es funktioniert korrekt, was bedeutet, dass unser
Code bereits funktioniert , wenn wir
drei Argumente gleichzeitig übergeben. Aber es wird nicht funktionieren, wenn wir weniger
passieren. Hier müssen wir hier schreiben L Bedingung und
innen können wir
zum Beispiel schreiben, dass die Konsolenanmeldung
mehr Argumente benötigt. Und jetzt, nachdem dieses Buch eine Funktion zurückgeben
wollte, wie ich bereits sagte,
wenn wir
zum Beispiel vorbei sind, ermutigen Sie
nur ein Argument. Es muss eine Funktion zurückgeben , bei der wir
zusätzliche Argumente übergeben können. Deshalb müssen wir hier
eine Funktion zurückgeben und können sie beispielsweise F2
nennen. Und im Inneren werden wir mehr Argumente
vorbringen, was tatsächlich bedeutet, dass
dies unsere erste Kohle ist, dies ist unsere zweite Genossenschaft. Wenn
wir beispielsweise die aktuelle Summe übergeben, ist
dies auch eine aktuelle Funktion. Nennen wir, dass es teilweise etwas
getragen hat. Hier nennen wir etwas getragen. Jetzt möchte ich hier
teilweise korrekte Summe konstruieren , damit
wir überprüfen können, was es tut. Wie Sie hier sehen können, brauchen
wir keine Argumente, und hier ist unsere Funktion
mehr Argumente. Und eigentlich wollen
wir hier einige Argumente vorbringen. Zum Beispiel
können wir hier 23 passieren, und es werden genau
diese weiteren Argumente sein , die wir hier geschrieben haben. Was wir jetzt tun wollen, möchten
wir
unsere Argumente mit
mehr Argumenten verketten , um
alle unsere Argumente in
den Aufruf der Funktion zu bringen . diesem Grund
können wir hier eine Variable,
neue Argumente erstellen , und wir möchten
hier unsere Argumente verketten. Und ich rufe hier concat an und ich gebe Einblicke
mehr Argumente. Jetzt müssen wir
unsere fn-Funktion nicht
wie hier aufrufen ,
aber wir müssen unsere F1-Funktion aufrufen weil wir diese Überprüfung
immer wieder auf
genügend Argumente achten wollen ,
was bedeutet, dass wir
nennen es rekursiv. Deshalb möchte
ich hier die
F1-Funktion zurückgeben und sie möchten alle unsere neuen Argumente
verbreiten. Hier sind hier drei
Punkte und neue Argumente. Schauen wir uns das an. Ich lade die Seite hier neu. Wir werden meinen
Argumenten und genug Argumenten begegnen. Was hat es einen Mittelwert? Hier ist es unsere aktuelle Summe. Wir haben hier ein Argument übergeben, wir kommen in Zellen. Dies ist unser Konsolenprotokoll braucht mehr Argumente und hier ist
unsere zusätzliche Funktion. Hier
rufen wir diese Funktion und wir übergeben
hier weitere Argumente. Dies ist diese Variable. Jetzt verketten wir
es, unser. Das ist es, was wir hier und 23
passiert haben, und wir nannten unsere F1. Wir kommen wieder hierher, wir haben genug Argumente, und hier rufen wir unsere Funktion auf und
wir bekommen sechs. Jetzt entfernen wir alle
unsere Konsolenprotokolle und überprüfen, wie es funktioniert. Was ich hier versuchen möchte, ist unser richtiges, wie wir es nennen können, wir können es mit 123 nennen
und wir bekommen sechs. Es funktioniert. Jetzt können wir es mit einem nennen. Wie Sie sehen können, erhalten
wir
eine Funktion zurück und wir können sie jetzt mit 23
aufrufen, wenn Sie
sehen können, dass wir auch sechs bekommen, was bedeutet, dass es funktioniert. Und jetzt können wir es
hier mit Hocker nennen und danach mit drei
und wir bekommen sechs, was tatsächlich
bedeutet, dass es mit jeder
Menge an Argumenten
richtig funktioniert . Und hier haben wir
eine Funktion getragen , bei der wir zehn Argumente
haben. Dann führen wir hier eine
Operation mit Stan-Argumenten durch. Dann
rufen wir diese Funktion rekursiv auf, bis wir
alle benötigten Argumente erhalten. Wie Sie sehen können, ist das Schreiben einer
Karrierefunktion nicht die TGA. Und wenn Sie es noch nie zuvor gemacht haben, ist
es schwierig, dies
direkt im Interview zu schreiben, besonders nur auf
das Blatt Papier. Die letzte Frage, die
du hier bekommen könntest, okay, aber warum
brauchen wir Curry-Funktion? Und was kann Ihre aktuelle
Funktion leisten? Deshalb wollen
wir hier
unsere Karrierefunktion
jetzt für unser reales Projekt nutzen . Und was wir hier tun können, können
wir es zwei
Funktionen nennen: get und map. Probieren wir das mal aus. Ich möchte eine Get-Funktion erstellen
und sie wollen sie tragen. Deshalb rufe ich
diese Art von Funktion auf. Und im Inneren übergebe ich eine
Funktion mit zwei Eigenschaften. Zuallererst
wird es Eigentum sein, und zweitens
wird es ein Objekt sein. Und was wir hierher zurückgeben wollen, wir wollen nur ein Objekt
für Schlüssel nehmen und es wird Eigentum sein. Schauen wir uns an, wie es funktioniert. Wie Sie hier sehen können, haben wir unser Get und hier
geben wir zwei Argumente weiter. Zuallererst Eigenschaft
zum Beispiel AD, und zweitens unser Objekt, zum Beispiel ein D1. In diesem Fall
bekommen wir einen zurück. Was wir hier tun können, können
wir jetzt, weil es getragen wird, nennen Sie es
einfach mit einem
Argument, nur mit AD. Sie können sehen, dass
wir
eine aktuelle Funktion zurückbekommen , jetzt können wir sie irgendwo
speichern und wiederverwenden. Zum Beispiel können wir
hier eine zusätzliche Funktion erstellen, ID
abrufen, und wir
rufen hier mit nur Property ID auf. Wie Sie
im Browser sehen können, können
wir die GetID-Funktion
überall in
ihrer Anwendung für jedes Objekt verwenden ihrer Anwendung für jedes Objekt um eine entsprechende ID daraus zu erhalten. Jetzt können wir genau
das Gleiche mit Map machen. Zum Beispiel möchte
ich hier eine
Map erstellen und sie möchten eine Map-Funktion
tragen. Hier erhalten wir eine
Funktion, die ein Argument der Map und Werte ist
, die ein Array sind. Hier möchte ich einfach einfache JavaScript-Werte aufrufen , die zuordnen und dann
unsere Funktion darin übergeben. Aber jetzt wird unsere Karte getragen, was bedeutet, dass wir sie
überall wie Karotten-Map verwenden können, zum Beispiel können wir
innerhalb einer Karte passieren, ID erhalten. Und jetzt hier als
zweites Argument können
wir ein Array übergeben und
haben einfach hier ID gleich eins. Wie Sie hier sehen können, erhalten
wir direkt ein Array von IDs mit Hilfe
der Map. Und eigentlich
übergibt Boop zwei Argumente, aber wir können es auch abdecken. Zum Beispiel können wir hier
eine Funktion benennen, const, IDs
erhalten, und hier sind wir geboren,
um unsere Map auf GetID aufzurufen. In diesem Fall haben wir eine
teilweise angewandte Funktion, erhalten Ds und wir können damit Ideen aus vielen Arrays abrufen. Zum Beispiel haben wir hier
Recht und holen uns Ideen. Und wir rufen
diese Funktion für
das Array mit Objekten auf . Und wir haben hier einen D1. Und wie Sie sehen können, funktioniert
es. Dies ist genau die Notwendigkeit des aktuellen, um JavaScript
und funktionale Weise zu schreiben. Und hier ist, das ist ein
ziemlich fortgeschrittenes Thema. Deshalb ist es
völlig in Ordnung, wenn Sie dieses
Thema nicht als Anfänger kennen,
aber zumindest müssen Sie ein grundlegendes Verständnis haben was aktuell ist und warum
brauchen Sie es überhaupt?
9. Hinzufügen von Elementen zum Array: Möglicherweise erhalten Sie eine
Frage wie diese und führen Sie zum Hinzufügen von
Elementen zum Array ein. Wie Sie hier sehen können, müssen wir
versuchen zu funktionieren, die
ein Array und ein Element erhält und ein Array
mit der Abrechnung zurückgibt. Das
klingt dann wirklich einfach, aber man kann es
auf verschiedene Arten lösen. diesem Grund müssen Sie es richtig
lösen und dem
Interviewer zumindest den richtigen Weg mitteilen. Normalerweise verwenden Anfänger
hier Array Push, und dann bauen wir so
etwas. Wir haben also eine Funktion,
zum Beispiel append, und wir
gehen auf Argumente, Array und unser neues Element ein. Und was wir hier machen, verwenden
wir Array Push und
wir geben in R, L. Und danach
geben wir dieses neue Array zurück. Dann schreiben wir einfach hier
Konsolenprotokoll append, und hier überprüfen wir, okay, zum Beispiel
haben wir unser Array 12 und hier unser drittes
Element drei. Lassen Sie uns nun prüfen, ob
es funktioniert, wo die Seite
neu geladen wird, und
wir bekommen 123, und Sie denken, dass Sie
diese Funktion richtig erstellen. Aber hier ist das Problem. Eigentlich möchte ich hier unser Array
schreiben. Nennen wir es zum Beispiel
Zahlen, und wir
haben 12 nicht gespeichert. Jetzt hier drinnen abhängen, ich möchte einfach unsere Zahlen weitergeben. Aber danach
möchte ich Protokollnummern
konsolen, die Seite neu laden
und wir bekommen 123123. Was heißt das? Wir haben diese Append-Funktion und wir geben das Array
hierher zurück. Und die meisten Leute werden denken , dass wir, wenn wir diese Funktion
verwenden, ein neues Array erstellen. Dies ist, wo sie
normalerweise neue Zahlen schreiben. Hier rufen wir
unsere Append-Funktion und denken, okay,
wir haben unseren älteren Strahl nicht modifiziert, aber wir bekommen nur neue
Zahlen, weil append-Funktion
für uns ein Array zurückgibt. Aber wie Sie sehen können,
sind
diese beiden Arrays völlig gleich, da tatsächliche Array-Push
den älteren Strahl ändert und kein neues Array erstellt wird. Und dies ist normalerweise
ein gutes Beispiel für schlechten Code in der Anwendung. Warum ist das so? Stellen Sie sich vor, Sie
haben einen Teil Ihrer Anwendung und Sie
haben das Array dieser Nummer, dann haben Sie irgendwann Ihre
spaltendisziplinierte Funktion,
um neue Zahlen zu erhalten. Aber dann haben
Sie aus heiterem Himmel Ihr
altes Zahlen-Array geändert, was Sie nicht beabsichtigten. diesem Grund denken Sie
, dass in Ihrer Anwendung etwas Magie
passieren kann, nur weil der Doppelpunkt dieser Funktion einige Daten
außerhalb dieser Funktion
ändert Dies ist ein schlechter Ansatz. Wie können wir es reparieren
und besser machen. Wir sollten
hier keinen Array-Push verwenden. Es ist nicht sicher. Was wir stattdessen hier
verwenden möchten, zum Beispiel Spread-Operator, können
wir hier schreiben,
dass wir ein neues Array
zurückgeben möchten und alle Elemente
unseres Arrays
verbreiten möchten, die wir
erhalten als Argument. Und wenn Sie nicht wissen,
was der Spread ist, ist
dies ein ECMO
Script Sechs-Operator, sind drei Punkte. Und was wir hier tun, sind
wir in allen Elementen
dieses Arrays innerhalb unseres neuen Arrays verbreitet , was im Wesentlichen
bedeutet, dass wir eine Kopie dieses Arrays
erstellen. Bewegen Sie nun eins, um dieses
Element bei der folgenden QRA hinzuzufügen. Deshalb haben wir gerade das Koma-Element
ausprobiert. Schauen wir uns das jetzt an. Ich lade die Seite neu und hier bekommen
wir eine weitere Antwort. Wir kommen hier
123 und hier 12, was eigentlich bedeutet, dass
diese einzelne Zeile die für uns
neue Array-Funktion zurückgibt ,
absolut sicher ist, da wir keine Daten
außerhalb dieser Funktion ändern. Aus diesem Grund ist diese
Implementierung viel besser, wenn Sie gefragt werden, dass selbst
etwas Triviales, wie das Verschieben von Elementen
in das Array ,
auch
dasselbe Verhalten mit Objekten hat. Wenn wir
innerhalb einer Funktion,
eines Objekts, übergeben und wenn wir dort
mutiert sind
, mutieren wir Objekte
außerhalb unserer Funktion, und das ist schlecht. Und Sie können auch Spread mit
einem Objekt verwenden , um
ein neues Objekt zu erstellen. In diesem Fall sind wir
auf der sicheren Seite. Wenn Sie nicht wussten, dass diese
Funktion wie hier rein genannt
wird,
weil
diese Funktion zunächst jedes Mal
dasselbe Ergebnis zurückgibt , wenn wir
sie mit denselben Argumenten aufrufen . Und zweitens ändert es
keine Variablen außerhalb
der Funktion. Das ist y, das ist
sichere reine Funktion.
10. Concatenating: Wir haben bereits
über versteckte Elemente
des Arrays gesprochen und warum Bush nicht
immer der beste Ansatz ist. Möglicherweise haben Sie aber auch
eine ähnliche Frage. Zum Beispiel haben
wir hier eine Aufgabe, eine Funktion
zu schreiben, die zwei Arrays
verkettet. Und tatsächlich könntest du hier
Push benutzen und es wird eine falsche Antwort
sein. diesem Grund
können Sie hier tatsächlich
die Funktion Merge-Arrays schreiben . Hier erhalten wir zwei Arrays, zum Beispiel Array
eins und Array zu. Und hier
schreiben Sie vielleicht Array eins,
Bush, und hier
verbreiten Sie sich von Array zwei. Und danach kannst du
einfach Array eins zurückgeben. Und eigentlich werden nicht viele Leute Code wie diesen schreiben weil Sie hier Push verwenden und dann in Array
verteilt sind, aber Sie könnten
über einen solchen Ansatz nachdenken. Um das Problem zu sehen, müssen
wir
zunächst unser Ergebnis erzeugen . Hier innerhalb des Ergebnisses
müssen wir zwei Arrays verwenden. Array eins zum Beispiel wird
es nur
eins sein und unser Array zwei hier wird
zum Beispiel 23 sein. Jetzt wollen wir unser
Fusion-Rennen und Pass nennen und sagten zuerst Array eins
und zweitens Array zwei. Und lasst uns prüfen und
konsolensperren, was wir bekommen. Also zuerst Ergebnis, dann Array eins und Array zwei. Ich lade die Seite neu und
wir bekommen 12312323. Das ist genau das Problem, als wäre es kein vorheriges Video. Bush-mutiertes Array. Auf diese Weise ändern
wir das Array
eins, auch wenn wir es nicht ändern
wollen. diesem Grund ist Push in diesem Fall
nicht der beste Ansatz. Was wir hier stattdessen verwenden können,
ist ich, das Array concat, das den gesamten Ansatz von
JavaScript oder nur
einem Spread-Operator hat , genau wie wir es zuvor getan haben. Statt dieser Rückkehr
und des echten Pushs können
wir zuerst hier schreiben, Array one dot concat, und wir haben eine
Verkettungsfunktion für das Array. Und hier sind wir
in unserem Array zwei verbreitet.
Schauen wir uns den Süden
an, wo das erneute Laden der Seite hier unser Ergebnis
123 ist und hier Array eins
und Array zwei bis drei. Dies ist genau der
richtige Ansatz, da Verkettung ein Array nicht
mutiert. In diesem Fall wird es für uns in einem neuen Array
zurückkehren. Deshalb ist alles in Ordnung. Wenn Sie re concat nicht verwenden
möchten, können
Sie immer einfach einen Spread-Operator
verwenden. Hier werden wir Array
eins als Spread verwenden. Hier verbreiten wir
unsere Strahlröhre. Und tatsächlich wird das Ergebnis
genau das gleiche sein , wo man 123 bekommt. Und eigentlich mag ich diesen Ansatz sehr, weil er
flexibler ist und man
nicht nur Rennen, sondern auch Objekte zusammenführen kann . Sie können hier neue Elemente hinzufügen, und es ist moderner. Wenn Sie zum Beispiel eine Frage
haben, um
drei Arrays oder mehr zu verketten, ist
es auch möglich, dass sogar Array concat mit mehreren Arrays arbeiten
kann, wie Sie hier in
der Dokumentation sehen können hier
haben wir drei verschiedene Arrays. Sie können den ersten
Array-Dot-Concat schreiben, und dann haben Sie ein
sekundäres und drittes Array. Und tatsächlich wird es richtig
funktionieren, aber tatsächlich können Sie genau dasselbe
mit Spread
tun , hier sind Sie in Array eins,
Array zwei, Array drei
verteilt . Wenn du musst. Beide Varianten sind möglich.
11. Überprüfen Sie, ob Benutzer mit solchem Namen existiert: Vielleicht bekommst du eine Frage. Prüfen Sie, ob Benutzer mit einem solchen Namen im Array des Objekts
vorhanden sind. Offensichtlich kann es
kein Name oder kein Benutzer sein. Die Idee ist jedoch, dass
Sie
eine Eigenschaft des
Objekts in einem Array überprüfen müssen. Eigentlich gibt es verschiedene
Möglichkeiten, dies zu implementieren. Und der schlechteste Weg
ist die Verwendung von for-loop. Denn wie ich bereits sagte, ist
for-loop sehr
niedrig und es ist kein richtiges Werkzeug für
diese spezifische Aufgabe. Schauen wir uns an, wie es mit for-Schleife aussieht
. Also hier wollen wir eine Funktion
erstellen, zum Beispiel ist Name existiert. Und hier müssen wir zwei
Argumente vorlegen. Zuallererst ist es ein Name, und zweitens ist es eine
Reihe unserer Benutzer. Jetzt innerhalb der
kreativen Eigenschaft Mask, die Boolean sein wird, und es wird uns zeigen, dass wir diesen Benutzer in einem Array
haben. Hier können wir dafür sorgen, dass ein Lead existiert und standardmäßig falsch
ist. Jetzt müssen wir eine for-Schleife schreiben. Also hier haben wir
unseren Lead I von 0, ich weniger als Benutzerlänge. Und hier
machen wir I plus plus. Was wir jetzt
für jedes einzelne Element im Inneren tun wollen, müssen
wir seinen Namen überprüfen. Hier
überprüfen wir hier die Benutzer. Ich Punktname entspricht unserem Namen. Und wenn es gleich ist,
dann wollen wir innerhalb existiert durch
zuweisen. Nach unserer for-Schleife möchten
wir
unsere existierende Eigenschaft zurückgeben. Ja, dieser Code wird funktionieren. Schauen wir uns das an, aber
es ist ein super niedriges Niveau, wie Sie sehen können, haben wir
zum Beispiel John genannt. Versuchen wir es hier, Jon und hören Sie Koma unserer Benutzer. Wie Sie sehen können, kommen wir
durch, weil wir einen
solchen Benutzer mit einem solchen
Namen innerhalb des Arrays hören . Wenn ich hier gerade
voll schreibe, werden wir falsch. Aber das Problem mit diesem Code
wird nicht zeigen, dass Sie
ein fortgeschrittener Entwickler sind. Deshalb wollte ich Ihnen
drei weitere Möglichkeiten zeigen , diesen Code
zu schreiben. Und eigentlich
sind all diese drei Möglichkeiten Gelegenheiten. Mein Favorit wird hier
eine einzige Zeile sein, also können wir eine
Funktion erstellen, die Name existiert, und hier erhalten wir
Namen und Array. Und wie Sie hier sehen können, habe ich nicht versucht, den
Benutzer Butter Ray zu verwenden, denn jetzt können wir
diese Funktion für alle Daten verwenden. Was ich
hier nennen möchte, ist Array-Punktsumme. Und wenn Sie nicht wissen,
was Sam tut, können
Sie einige auf dem Strahl nennen, wenn
Sie einige Prädikate setzen. Also willst du
etwas drinnen überprüfen. In unserem Fall geben einige einen Strohhalm
zurück, wenn wir
mindestens ein einzelnes Element haben , das unsere Bedingung erfüllt. In einigen können wir Element
fahren. Und wir wollen hier überprüfen, Elementname unseren Namen entspricht
, die darin übergeben wurden. Und das ist buchstäblich
derselbe Code wie wir hier geschrieben haben,
aber viel kleiner. Schauen wir uns den Ton an. Ich
lade die Seite neu und gebe nur ein , dass sein Name existiert, da Sie sehen
können, wo wahr wird. Einige sind also die beste
Lösung für diese Frage, aber es ist auch möglich, andere Lösungen
zu verwenden. Lassen Sie uns das also
auskommentieren und es erneut versuchen. Wir haben hier wieder zwei
Argumente, Name, Array. Jetzt können wir versuchen das Element mit einem solchen Namen zu
finden. Hier lassen Sie uns hier
ein Element erstellen und wir verwenden hier Array-Punkt, um zu finden, wo unser Element abgerufen
wird. Und hier wollen wir überprüfen, ob Elementpunktname
unserem Namen von oben entspricht. Aber in diesem Fall
ist unser Element tatsächlich ein Objekt. Es ist kein boolescher Wert. Hier wird er
Wrapper-Element
in Boolean brewmaster , um
Boolean und kein Objekt zurückzugeben. In diesem Fall
funktioniert es richtig. Ich lade die
Seite neu, da Sie
sehen können , dass sie
genau so funktioniert. Also die
Hauptunterschiede, die es
beherrschen , ein bisschen mehr Code weil wir es
in Boolean konvertieren müssen. Und das Letzte, was
wir hier verwenden können, ist eigentlich nicht in Ordnung,
aber Index finden. Und wenn Sie nicht wissen,
was der Index macht, ist genau dieselbe Logik, aber wir finden den
Index dieses Elements. Wenn wir
das Objekt mit einem solchen
Namen in unserem Array finden können . Hier erhalten wir
unseren Element-Button-Index nicht. Und danach werden wir wissen, dass dieses Element
nicht gefunden wurde
,
wenn dieser Index kleiner als 0 ist . Hier. Wir können versuchen, den
Index größer als 0 zurückzugeben. In diesem Fall wissen wir oder
K Es ist größer als 0. Wir haben dieses Element
innerhalb des Arrays. Und wie Sie sehen können,
funktioniert dieser Code genau gleich. Mein Ansatz wäre Summe, der nächste Ansatz wird es uns gut gehen. Der Indexfund ist ebenfalls in Ordnung, aber Sie sollten
for-loop nicht verwenden, da es für eine solche Aufgabe sehr ineffizient
ist.
12. Alle Duplikate im Array entfernen: Vielleicht bekommst du auch
eine solche Aufgabe. Entferne alle Duplikate
im Array. Das heißt im Grunde, wenn Sie ein Array von Zahlen haben
und zum Beispiel 112 haben,
müssen Sie von der 12 leben. Ich sehe hier drei verschiedene
Möglichkeiten, unser Problem zu lösen. Versuchen wir es mit der
besten Lösung. Zum Beispiel können wir
hier ein funktions-eindeutiges Array erstellen. Wir bekommen hier unser Array,
um Duplikate zu entfernen. Hier möchten
wir Coupon machen, um ein Array
zurückzugeben, und wir möchten uns innerhalb eines neuen Sets
verbreiten und
wo Bison innerhalb des Arrays, wenn Sie nicht wissen, was in JavaScript
gesetzt ist, ist es ein Objekt,
das es Ihnen ermöglicht speichert eindeutige Werte eines beliebigen Typs. Das heißt, wenn wir
hier drin sind und Sie
sagten, dass wir innerhalb
des Arrays übergeben, zum Beispiel 112, wo versteckte Enter,
wie Sie sehen können, haben
wir das Set nur von 12 da innerhalb unserer
Set-Elemente dupliziert werden. diesem Grund werden wir, wie Sie sehen können, auf
Ihrem Set verbreiten und es
in das neue Array einfügen. Um Rückschlag in Array umzuwandeln, erhalten
wir unsere einzigartigen Elemente. Und eigentlich wissen nicht viele Leute über diese Lösung Bescheid, aber dies ist die beste
Lösung,
weil es sich allem um einen einzigen Liner handelt. Zweitens ist es selten
Leistung, wenn Sie nicht fertig sind, diese Lösung, es ist nicht schlecht. Sie können
diese Logik immer selbst erstellen. Der wichtigste Teil
, der auch für die Schleife hier ist, wenn Sie forEach
foray verwenden, ist nicht so schlimm. Schauen wir uns das mal
an. Zum Beispiel haben
wir hier die gleiche Funktion, eindeutiges Array, und wir
möchten hier eine Schleife schreiben. Und natürlich müssen wir
unser Ergebnis in
zusätzlichem Eigentum lagern . Lassen Sie uns also hier ein Ergebnis machen, das unser einzigartiges Array sein
wird. Jetzt möchte ich hier
jedes einzelne Element unseres
Arrays mit der forEach-Funktion durchlaufen . Hier erhalten wir unseren Artikel als jedes Element unseres Arrays. Was wir nun hier überprüfen möchten, wenn wir diesen
Artikel bereits in unserem Ergebnis haben, können
wir hier überprüfen
Ergebnispunkt enthält. Und wenn Sie es nicht wissen, schließen Sie ein,
prüfen Sie, ob wir die
Abrechnung in
einem Array haben und wir möchten in unseren Artikel
weitergeben. Dies wird also
wahr zurückgeben, wenn es einschließt. Aber eigentlich müssen wir hier eine
Bank setzen, um eine Negation zu haben. Wenn es dieses
Element nicht in das Array einschließt, möchten wir
es auf unser Ergebnis schieben. Also Ergebnis Bush und
hier mit dem Artikel. Wie Sie sehen können, ist
selbst für jede Schleife
hier nicht so schlimm, weil sie innerhalb einer Funktion
isoliert ist,
bei der es innerhalb einer Funktion
isoliert ist,
bei der einfacher ist,
jedes einzelne Element zu durchlaufen und wir
unser Ergebnis vorantreiben direkt
im neuen Array. Und natürlich
müssen wir am Ende unsere Ergebnisse zurückgeben. Also hier lassen Sie uns
das Ergebnis zurückgeben und prüfen,
ob es funktioniert. Hier ist unsere Funktion
einzigartiges Array 112. Und wie du siehst, kriegen
wir 12 zurück. Aber offensichtlich funktioniert unsere Funktion nicht mit Objekten
oder Arrays im Inneren, und das ist völlig normal. Wenn Sie also hier ein
Objekt mit einem Gleichen haben, und hier haben Sie ein weiteres
Objekt mit einem Gleichen. Wie Sie sehen können, erhalten wir zwei Elemente und
das ist völlig in Ordnung da dies zwei
verschiedene Objekte und wir sie nicht vergleichen können. Und tatsächlich können wir
dies für Rich ableiten, indem wir Reduce verwenden. Auf diese Weise schreiben wir genau den gleichen Code-Button
auf funktionalere Weise. Also lassen Sie uns hier unser
funktionelles einzigartiges Array erstellen. Wir bekommen hier
unser Array und wir wollen direkt ein Re, Reduce zurückgeben. Und hier drinnen müssen wir
unsere Funktion mit Akkumulator
und jedem einzelnen Element übergeben . Hier haben wir eine Funktion
und als Standardargument haben
wir hier ein leeres Array, genau wie wir es hier
hatten, wo wir Resultat gleich leeres Array
geschrieben haben . Was wir jetzt drinnen tun wollen, wollen
wir unsere
Akkumulator-Includes überprüfen, also überprüfen wir unser Ergebnis. Wenn wir in diesem resultierten
Array unser Element haben. Wenn wir es also haben,
geben wir einfach den
Akkumulator zurück , damit wir
nichts ändern. In anderen Fällen möchten wir dieses Element
auf den
Akkumulator schieben und wir verwenden
keinen Array Push, aber wir verwenden Spread. Hier. Ich bin im Akkumulator verbreitet und füge dann unser Element
hinzu. Auf diese Weise ist dieser Code
vollständig funktionsfähig. Es ist leicht zu verstehen und hätte diesen
fiesen Schub hier nicht. Füllen wir die Seite aus
und prüfen, ob sie funktioniert. Wie Sie sehen können,
funktioniert es immer noch nicht mit Themen, was völlig in Ordnung ist. Und es funktioniert mit
Primitiven Weil hier einer
aus unserem Array entfernt wurde. Wie Sie sehen können, haben Sie
drei verschiedene Varianten um
Eindeutigkeit im Array zu implementieren. Und tatsächlich sind all
diese Umkehrungen völlig in Ordnung, um im Interview zu
zeigen.
13. Sortieren des Arrays: Wir hatten bereits eine
bestimmte Übung, als wir unsere Benutzer in einem
der vorherigen Videos
abgebildet haben. Aber hier möchte ich
über Chirurgen sprechen , ein
bisschen anders. Wie Sie sehen können,
können Sie die Frage bekommen, das Zahlenarray
sortieren. Was eigentlich bedeutet, dass wir ein Array
haben, zum Beispiel 351, und wir müssen sortiert werden. Dafür verwenden wir eine bestimmte
Funktion in JavaScript. Wir schreiben einfach „sortieren“. Hier müssen wir eine Funktion bestehen
und wir haben solche Bedingungen. Wenn weniger als b, kehren
wir hierher zurück minus
eins, wenn größer als, größer als 10, wenn sie gleich sind. Und zuvor haben wir hier a und B
geschrieben, und hier können wir
einen kleineren als b schreiben, dann geben wir minus eins zurück. In einem anderen Fall
geben wir einen zurück. Es ist auch wichtig,
sich daran zu erinnern, dass bestimmte Renditen, das Ergebnis des bestimmten, was bedeutet, dass wir es zum Beispiel in eine
Variable einfügen können , aber es wird auch unser
Array mutieren, das wir erstellt haben. Und eigentlich macht es hier keinen
Sinn weil dies ein
Array im laufenden Betrieb generiert hat. Aber wenn die Leute
es in die Variable setzen, dann ist es sinnvoll. Hier haben wir unser Array
und hier sind wir sicherlich, schauen wir uns das Beispiel an. Ich bin hier Konsolen-Login,
Array und Ergebnis. Und wie Sie hier
im Browser sehen können, erhalten
wir genau
das gleiche sortierte Array. Dies geschieht
, weil Sortiermutaten in einem Array
vorhanden sind und wir uns daran erinnern
müssen. Außerdem gibt es noch einen weiteren
wichtigen Punkt, an den man sich erinnern sollte. In der Vergleichsfunktion können
wir
eine Zahl zurückgeben , die größer
als 0 und kleiner als 0 ist, und sie wird genau dieselbe sein. Es wird vor a sein
und vor B sortieren, was eigentlich bedeutet, dass wir unseren Code ein
bisschen anders
schreiben können und
nicht mit minus 11, wir können einfach
hier ein Minus b zurückgeben. Warum ist das so? Weil wir
hier zwei Zahlen haben, zum Beispiel drei minus fünf. In diesem Fall wird es weniger als 0
sein. Und dann haben wir diese
Bedingung vor B. Schauen wir uns das an. Ich lade die Seite neu. Wir kriegen eins bis
fünf wie zuvor, wenn Leute hier, b minus a, dann wird es in eine andere Richtung
sortiert. Wie Sie sehen können,
bekommen wir fünf durch eins, was zum Sortieren
bedeutet, dass
wir es sortieren können, indem wir minus
11 oder etwas weniger als
0 und größer als 0
zurückgeben . Es ist auch wichtig sich daran
zu erinnern, dass wir die Sortierung von
Louis-Primitiven verwenden
können. Wenn Sie versuchen, hier ein Objekt zu
sortieren, wird
es nichts tun, weil Sie Objekte nicht wirklich vergleichen
können, aber Sie können Eigenschaften
und Site-Objekte sortieren. Und wir haben die Aufgabe
, eine Reihe
unserer Bücher nach dem Nachnamen des Autors zu sortieren . Hier können wir genau die
gleiche Such- UND Funktion verwenden. Wir schreiben hier,
Bücher punktsortieren, und hier kommen wir
als Argument, Buch eins und Buch zwei. Und jetzt müssen wir sie richtig
vergleichen. Zunächst
müssen wir also einen Nachnamen
des ersten Autors und
des zweiten Autors finden . Hier schreiben wir einen
tollen Nachnamen, eins. Und hier haben wir
unser Buch one.org genommen. Und hier
wollen wir unseren Namen
mit Leerzeichen teilen und das erste Argument
hierher bringen. In diesem Fall werden wir den
Nachnamen unseres Ehrfürchtigen bekommen. Jetzt werde ich diese Zeile kopieren und hier haben wir
auch LastName, und hier ist Buch zwei. Und jetzt, nach diesem Wochenende, vergleiche diese beiden Saiten. diesem Grund können wir hier oder
LastName einen kleineren als ASO,
LastName-Tool schreiben LastName einen kleineren als ASO, , dann
wollen wir minus eins zurückgeben. Im anderen Fall werden
wir einen zurückgeben. Und tatsächlich müssen
wir, wie
Sie hier sehen können, minus
11 verwenden, da es keine Zahlen sind, in denen Country
Strings subtrahiert. Und wie Sie
hier im Browser sehen können, haben wir nichts konsolenprotokolliert. Lassen Sie uns nun unsere Bücher konsolenprotokollieren denn wenn wir unser Array
mutiert haben, laden
wir die Seite neu. Und wie Sie sehen können,
sind dies unsere Bücher. Aber jetzt haben
wir zuerst Susan Collins. Wie Sie sehen können, ist es sortiert weil
wir vorher hier rollen mussten, dann Mary Lou und
dann John jawline, was tatsächlich bedeutet, dass
dieser Code funktioniert. Und so sortieren
Sie ein Array von Objekten nach einer Eigenschaft.
14. Interview Ist Nicht Das, Was Sie Denken: Viele Leute,
insbesondere Anfänger, verstehen den Zweck
des Interviews nicht richtig. Sie denken, dass sie zum Interview
kommen, eine Reihe von
Fragen
beantworten und einen Job finden müssen . Und es ist nicht so groß, denn Integer ist eigentlich eine Kommunikation zwischen
mehreren Personen, wo Seite
einige
Fragen zu einer anderen Person klären wollte . Wenn wir zum Beispiel über Interviewer
sprechen, interessiert
er sich für
Ihr Wissen und natürlich, wie
Sie in sein Team passen. Es geht nicht nur darum, Fragen zu
beantworten. Es ist eher wie Ping-Pong. Sie stellen eine Frage und der Interviewer
stellt die Fragen. Es sollte nicht so sein, als würde
nur Interviewer
die Fragen stellen und einfach
antworten, denn in diesem Fall können Sie
zunächst
Antworten auf Ihre Fragen erhalten. Und zweitens
zeigen Sie nicht, dass Sie sich für dieses Unternehmen oder
an
dieser spezifischen Position interessieren . Wenn Sie
mit dem Techniker
und dem Special mit jedem sprechen , müssen
Sie zeigen, dass
Sie interessiert sind. Sie müssen einige
Fragen zum Unternehmen und zum Team stellen. Wie viele Arbeitstage hast du? Haben Sie hier Überstunden, wie oft die Menschen das Unternehmen
leben, wie lange Menschen normalerweise
im Unternehmen arbeiten und so weiter. Denn
zuallererst möchten Sie
wissen, welche
Arbeitsbedingungen in
diesem Unternehmen sind und
nicht nur
ein Unternehmen mit schlechten
Arbeitsbedingungen bekommen . Und offensichtlich kann ich verstehen, dass
Sie, wenn es Ihr erstes Geschäft
ist, irgendwohin gehen
möchten, einfach anfangen zu arbeiten und das
verstehen sie vollkommen. Aber wenn Sie später nicht leiden
möchten, ist es sehr sinnvoll, diese Fragen
zu stellen. Außerdem müssen Sie
Teamleiter oder Interviewer mögen, und normalerweise wird es
Ihr zukünftiger Chef sein ,
weil Sie
viel mit dieser Person zusammenarbeiten werden viel mit dieser Person und es mit dem Team
genauso funktioniert. Es ist wirklich eine gute Idee
, das ganze Team kennenzulernen, zumindest um zu überprüfen, wie
die Stimmung im Dampf ist? Sind die Menschen freundlich
zueinander? Sind sie mit den
Arbeitsbedingungen zufrieden und so weiter? Und das gleiche kann ich
über das Überprüfen des Büros sagen. Manchmal ist es wirklich seltsam, wenn Sie nicht das ganze Büro
sehen dürfen da dies ein Ort ist, an
dem Sie arbeiten und Sie
mit den Arbeitsbedingungen zufrieden sein müssen. Ich empfehle Ihnen dringend, kurzfristig
im Büro zu
fragen , damit Sie
zumindest die
Arbeitsbedingungen sehen können . Hast du genug Licht da, welche Monitore du
hast und so weiter?
15. Schreibbereich Funktion: Möglicherweise erhalten Sie eine Codierungsübung
, um den Bereich zu implementieren. Was hat es einen Mittelwert? Es ist eine Hilfsfunktion
, die so aussieht. Wenn wir beispielsweise Bereich von eins bis 50
aufrufen, wird für uns ein Array
123456 usw. generiert , bis es verschoben wird. Und das ist
wirklich ein netter Helfer , wenn Sie einige Daten
generieren müssen. Zum Beispiel möchten Sie fünfte zufällige Benutzer
generieren. In diesem Fall
generiert Ihr Assembler ein solches Array
und dann für jedes
einzelne Element, das Sie zuordnen, und einen neuen zufälligen Benutzer. diesem Grund existiert dieser
Helfer in fast allen Helfer-Bibliotheken
wie zum Beispiel einem Strich oder Lambda. Und Vielfalt ist eine Lösung des Ergebnisdenkens hier
durch die Verwendung von for-loop. Hier können Sie
diese Funktion so schreiben. Sie haben hier einen Funktionsbereich, und Sie haben hier
beispielsweise Start und Ende von 150. Und dann müssen wir im Inneren
eine For-Schleife vom
Startpunkt zum Endpunkt schreiben . Das ist y hier, lass
ich gleich Sterne sein. Wir fangen also nicht bei 0 an, aber vom Stil hier sind wir bei mir weniger oder gleich
richtig, und hier
machen wir I plus plus. Jetzt müssen
wir in dieser for-Schleife jeden einzelnen
Index auf unser Ergebnis drücken. Das ist y. Lassen Sie uns
hier unser Lead-Ergebnis erstellen. Das ist unser Array. Jetzt können wir Resultat
Push schreiben und wir
drängen hier unser I. Und jetzt geben wir einfach unser Ergebnis
zurück. So können Sie
eine Bereichsfunktion mithilfe
von for-loop erstellen . Lassen Sie uns den Browser einchecken, ich schreibe hier
Bereichsfunktion ein Komma 15, und wir bekommen unser
Array von eins bis 50, was bedeutet, dass unser Code
völlig in Ordnung ist, aber es ist super niedrig
und wir können es schaffen besser. Fortgeschritteneres Niveau ist
es, unser Array zu nutzen. Wir können im Browser-Array schreiben und dann unser Ende,
zum Beispiel 15. Und wie Sie sehen können, gibt dies das
erste leere Array zurück , in dem wir 50 Elemente
reserviert haben und was wir direkt nach
diesen Punktschlüsseln können. Und jetzt
rufen wir nur diese Schlüssel und wir bekommen
Array-Iterator. Wenn wir nun versuchen,
diesen Array-Iterator
innerhalb des Arrays zu verbreiten ,
diesen Array-Iterator
innerhalb des Arrays , erhalten wir unsere 50 Schlüssel
von 0 bis 49. Und danach müssen wir
einfach
jedes einzelne Element abbilden und unseren Startpunkt
hinzufügen. Hier können wir also Punktmap schreiben, und hier haben wir jedes
einzelne Element und wir schreiben
zum Beispiel Element plus
Statistik in unserem Fall plus eins, und wir erhalten genau
das gleiche Ergebnis. Dies ist ein Array von eins bis 50. Aus diesem Grund ist diese Variante
etwas weiter fortgeschritten. Hier können wir
unsere Bereichsfunktion erstellen und wir bekommen
hier Stat. Und dann
wollen wir jetzt drinnen diese Logik zurückgeben. Und wie Sie sehen können,
ist dies ein Array, das wir bereitstellen und
Schlüssel erstellen , und wir sind in
diesem Array-Rater
in unserem neuen Array verteilt . Und wir kartieren
jedes einzelne Element. Und wo ich unseren Startpunkt nicht
gehört habe, laden
wir die Seite neu und
prüfen, ob sie funktioniert. Also gehe ich innerhalb der
orangefarbenen Funktion
150 durch und wir bekommen ein
nettes Array von eins bis 15. Und so schreiben Leute
diese Funktion
normalerweise in
Helfer-Bibliotheken. Zum Beispiel Lambda,
obwohl Strich.
16. Writing: Vielleicht bekommst du eine
Frage zum Interview. Schreiben Sie eine Funktion, die Shuffle
implementiert. Was bedeutet Shuffle? Sie ändern einfach die Positionen von Elementen in einem Array. Und eigentlich ist es nicht so einfach , es mit beispielsweise
für jeden
zu implementieren . Aber hier können wir Methode
random nutzen , um
Elemente nach dem Zufallsprinzip zu sortieren. Das ist eigentlich das, was
wir hören wollen. Lassen Sie uns unsere Funktion „
Shuffle Items“ erstellen. Die Grundidee ist
, dass wir hier unsere Auswahl an Artikeln
erhalten. Und das kann was auch immer sein. Es kann nur eine Zahl sein, es kann ein Objekt oder
vielleicht sogar ein Array von Arrays sein. Es muss auf jeden Fall funktionieren, deshalb möchten
wir jedes einzelne Element durchlaufen und für jedes Element und
ein Objekt mit Schlüssel und Wert erstellen . Und tatsächlich sind sie drin. Wir werden einen
Zufallsschlüssel durch Zufallsprinzip erzeugen lassen. Wir werden auch ihren Wert haben. Dies ist genau der
Wert unseres Elements. In diesem Fall können wir nach diesem Feld,
unserem Array,
sortieren und dann einfach diesen zufälligen Schlüssel
entfernen. Lass uns das jetzt machen. Ich bin direkt hier
, um unsere Artikel zurückzugeben. Und zuallererst rufe
ich Map an. Und hier haben wir Zugriff
auf jedes einzelne Element. Nennen wir es „hoch“. Und was wir tun
möchten, möchten wir, jedes einzelne Element
ein Objekt mit zwei Eigenschaften zurückgibt . Nennen wir diese Eigenschaftssortierung , da dies
tatsächlich zum Sortieren geeignet ist. Hier. Wir haben gerade Mathe-Zufall ausprobiert. Hier haben wir
unsere Zufallseigenschaft und die nächste wird Wert sein. Innerhalb des Wertes
lagern wir unseren Artikel. Wenn wir
unseren Code jetzt im Browser überprüfen, nennen
wir nur
unsere Shuffle-Elemente, zum Beispiel 12. Wie Sie zurücksehen können,
gehen wir auf die Sortierung von Objekten ein und hier ist Zufallszahl und
Wert Wert unseres Artikels. Und das ist eigentlich extrem gut, denn hier
innerhalb des Wertes können
wir Zahlen,
Objekte oder Arrays speichern. Für uns spielt es eigentlich keine
Rolle. Nach unserer Zuordnung möchten
wir
unsere Elemente in diesem Array
nach dieser bestimmten Eigenschaft sortieren . Deshalb
können wir hier sortieren schreiben und wir bekommen hier
Punkt eins und Punkt zwei. Hier. Was wir tun wollen, wir möchten Element
1 Punkt sortieren minus Punkt
zwei Punktsortierung schreiben und werden
diese Sortierung
tatsächlich mit
numerischer Eigenschaft kennen , was tatsächlich bedeutet, dass wir
hier einfach
Substract verwenden können und nicht
schreibe minus 11. Es wird es richtig sortieren. Aber für uns spielt Wasser keine
Rolle, weil wir es
nur sortieren müssen, um die Position
zu wechseln. Und nachdem wir die Position gewechselt
haben, wollen wir unsere Wertspezifikation erhalten. Dafür müssen wir es noch eine Karte
ausprobieren. Und hier haben wir, nennen
wir einen, denn dies ist unser Objekt und wir wollen hier einen Punktwert
lesen. Und tatsächlich ist dies unser
Artikel, der
hier in jedem einzelnen
Objekt gespeichert wurde . Schauen wir uns das an. Ich lade die Seite
hier neu, mischte Artikel 12. Wir kriegen einen. Ich nenne es hier wieder
zu einem hier 12, was bedeutet, dass es mit
irgendwelchen Elementen arbeitet und es
einfach mischt. Und tatsächlich ist dies eine
erstaunliche Möglichkeit,
dies zu lösen , weil wir hier Mathe-Zufall
nutzen. Und für jedes einzelne
Element
erstellen wir diese Sortierung in n-Wert. Wir sortieren einfach diese
Zufallszahlen und jetzt wird sie gemischt. Danach holen wir
gerade unsere Artikel zurück. Dies ist der einfachste und korrekteste Weg, Elemente
innerhalb des Arrays zu mischen.
17. Finden Sie die Anzahl der Vorgänge des Mindestwertes in der Liste: Vielleicht bekommst du eine solche Aufgabe. Finden Sie die Zahl für Währungen minimalem Wert in der Liste. Was eigentlich bedeutet, dass
wir ein Array von
Zahlen haben und zuerst
den Mindestwert
darin finden und dann
berechnen müssen den Mindestwert
darin finden und dann , wie oft
wir diesen Wert haben. Und wenn Sie
versuchen, hier FOR-Schleife zu verwenden, wird es wirklich
mühsam sein , weil Sie sie zweimal verwenden
müssen. Zunächst einmal, um den
Mindestwert innerhalb des Arrays zu finden. Und zweitens, um zu
berechnen, wie
oft wir diesen Wert im Inneren haben. Hier müssen wir
tatsächlich
die richtige Funktion in
JavaScript finden die richtige Funktion in , um es einfacher zu lösen. Und tatsächlich haben wir eine
solche Funktion in JavaScript und es
heißt Mathe Minimum. Wie Sie hier sehen können, geben
wir Insights mehrere Argumente weiter und es wird für uns das kleinste
zurückgeben. diesem Grund können wir diese Funktion
verwenden, aber sie funktioniert nicht mit Arrays. Was wir stattdessen tun können, können
wir mathematische Minimum schreiben und wir können nicht
innerhalb des Arrays übergeben, aber wir können hier einen
Spread-Operator verwenden, unser
Array zwei Argumente umwandelt. Hier können wir ein Array 123 haben
und wir kriegen eins zurück. Und
genau das wollten wir. diesem Grund können
wir, wie Sie in einer einzigen Zeile
sehen können, unsere for-Schleife ersetzen, die viel
schwieriger zu schreiben ist. Zuerst
nennen wir es hier den Mittelwert. Hier wollen wir
es in unserem Array nennen. Und lassen Sie uns hier unser Array erstellen, das 123 sein wird. Und hier wollen wir unser Array
verbreiten. Wir haben unseren
Mindestwert im Array gefunden. Wie können wir nun herausfinden, wie
oft wir diesen
Wert innerhalb des Arrays haben. Und eigentlich ist die einfachste Variante
hier die Verwendung von Filter. Wenn wir unser Array
nach diesem Mindestelement filtern, erhalten
wir eine Reihe
unserer Mindestelemente. Und dann können wir einfach
eine Länge dieses Arrays bekommen. Es wird
ungefähr so aussehen. Wir können hier
unser minimales Array bekommen. Und was wir
tun wollen, ist Array-Filter. Und hier haben wir Zugriff auf jedes einzelne Element und
vergleichen einfach , ob unser Element unserem Mindestwert
entspricht. In diesem Fall in
mir ein Array, nein, wir haben nur unsere Mindestwerte. Jetzt können wir
hier nur die minimale Array-Punktlänge des
Konsolenprotokolls schreiben , und es wird für uns
genau zurückgeben , wie viele Vorkommen
dieses Mindestwerts wir innerhalb des Arrays
haben. Schauen wir uns dieses Mal die Seite
neu laden,
je eine erhalten. Wenn wir hier zweimal 11 hinzufügen, dann haben wir hier drei davon. Und wie Sie sehen können, funktioniert
unser Code und hat keine aufregenden Zeilen
unser Problem gelöst. Deshalb
empfehle ich Ihnen dringend, immer das richtige Werkzeug
für den richtigen Sprung zu finden.
18. Das ist es: In diesem Video werden wir uns alle Fragen ansehen, die sich
auf diesen und den
Kontext in JavaScript
beziehen. Du könntest eine
Frage wie diese erraten. Was wird hier verschlossen sein? Die erste Aufgabe, die
Sie erhalten, haben
Sie eine Funktion
mit dem Schlüsselwort function. Das ist wichtig. Jetzt
schreiben wir nur Konsolenprotokollieren Sie das, und jetzt sind wir Doppelpunkt bekommen. Die Frage ist also, was wir in unserem Konsolenprotokoll
sehen werden ? Und tatsächlich können
Sie im Browser sehen, dass wir Fenster
sehen und Sie denken
vielleicht, okay, innerhalb von Funktionen wird dies
immer im Fenster referenziert, aber das ist nicht korrekt. Stattdessen Funktionen
referenziert dies das globale Objekt. Es kann Fenster sein, es kann nicht verteidigt sein, es könnte etwas anderes sein. Es hängt alles vom Kontext ab. Wenn Sie jedoch
ein Funktionsschlüsselwort
direkt in
JavaScript-Code ohne Verschachtelung definieren , wird
es Fenster sein. Jetzt bekommst du
Frage Nummer zwei. Was wird
in diesem Fall gesperrt? Wie Sie hier sehen können,
haben wir ein Objektelement mit Titel und GetItems-Methode
in der Methode get item Arbeitskonsole melden Sie sich hier an wir rufen
item dot get item item. bei Objekten Wenn wir bei Objekten Methoden
in Objekten haben, referenzieren
wir immer auf
dieses Objekt. Das heißt, wenn wir die Seite
neu laden, erhalten
wir dies und dies ist ein Objekt mit
Titel und Objekt abrufen. In diesem Fall können wir
alle Eigenschaften in
unserem Objekt verwenden, da sie für uns in diesem Fall
verfügbar sind Wenn wir
über Objekte sprechen, verweist
dies immer auf
unser Objekt. Hier ist unsere Aufgabe Nummer drei, was wird
in diesem Fall protokolliert? Wie Sie hier sehen können, haben wir
kein Objekt, sondern eine Klasse. Und wir haben auch innerhalb des
Titels und der GetItems-Methode, und das werden wir auch darin haben. Jetzt erstellen wir die
Instanz unserer Klasse und rufen eine
GetItems-Methode von unserer Instanz aus auf. Dies ist wichtig,
um daran zu denken, dass Insider-Methoden in unserer Klasse, wenn
wir eine Instanz haben, einen Verweis
auf unsere Instanz haben, wie Sie im
Browser hier sehen können, haben wir dies und wir können siehe
dieses Wort-Item. Dies bedeutet tatsächlich
, dass dieses Objekt eine Instanz
unserer Item-Klasse ist. Und drinnen haben wir
unseren Titelball. Wir können alle Eigenschaften
dieser Instanz darin verwenden. Aber jetzt bekommen wir eine
Frage, was passieren wird, wenn wir eine Funktion
innerhalb unserer Methode auswählen? Was wir hier
schreiben, ist also Funktion, zum Beispiel eine Funktion. Und drinnen sind wir direkt
in diesem Konsolenprotokoll. Und danach
rufen wir nur unsere sum-Funktion auf, was bedeutet, dass wir das Schlüsselwort
function with function
in unserer Methode
definieren Schlüsselwort
function with function
in unserer Methode und
sie hier direkt aufrufen. Die Frage ist, was
wird das Konsolenprotokoll darin sein? Wie Sie im Browser sehen können, ist
dies nicht definiert,
da wir, wie gesagt ,
stattdessen Funktionen,
nicht auf das Fenster verweisen, sondern auf
globales Objekt verweisen. Und eigentlich referenziert das Window-Schlüsselwort immer auf
globales Objekt. In diesem Fall wird es niemals
auf unsere Instanz verweisen. Und das ist wichtig, sich daran
zu erinnern, was bedeutet, wenn Sie eine
Funktion in Ihrer Klasse haben, diese Innenseite nicht korrekt sein. Es wird nicht auf
unsere Instanz
der Klasse verweisen und wir können keine Eigenschaften davon
verwenden. Und genau das gleiche
Problem, das Sie
nicht nur mit
der Definition der Funktion wie diese haben werden , sondern wenn Sie zum Beispiel
eine Map für Array
in Ihrem Get Item
schreiben , und hier haben Sie eine Funktion
für jeden einzelnen Artikel. Wenn wir nun eine
Konsolenprotokollierung schreiben, wird
es auch nicht korrekt sein. Wie Sie im Browser sehen können, lade
ich die Seite neu. Wir werden
dreimal undefiniert , weil wir
hier das
Funktionsschlüsselwort verwenden und dann die
Funktion festlegen , auf die es undefiniert
verweist. Beide Varianten
sind problematisch. Und jetzt stellt
sich die Frage, wie wir
es beheben und den Verweis
auf unsere Theorien erhalten können . Und dafür haben wir zwei
Lösungen. Vor allem Lösung,
die älter ist, und es wird auch verwendet, wenn wir JavaScript in der
gesamten Version
integriert sind . Dafür können wir
vorher einfach
mit einem Unterstrich definieren und weisen
Hörverweise auf unsere Liste zu. Das wird korrekt sein, weil
wir uns in unserer Methode befinden. Jetzt können wir
das hier nicht berücksichtigen , weil hier die
Referenzen stark sind, aber das war ein Unterstrich. Hier haben wir eine andere Referenz. Jetzt laden wir die Seite neu. Wie Sie sehen können, haben wir einen Charakterverweis auf
unsere Instanz wie item. Dies ist normalerweise ein
älterer Ansatz und es wird im
Build-Schritt von JavaScript verwendet , dass der bessere
Ansatz darin besteht, hier
eine Pfeilfunktion
anstelle des Funktionsschlüsselworts zu verwenden . So können wir hier einfach die
Pfeilfunktion von
Magma Script sechs verwenden . Und jetzt, wenn wir uns darin
einloggen, wird
es die
richtige Referenz haben. Wie Sie sehen können,
ist das Ergebnis genau das gleiche, weil Pfeilfunktion
den Kontext unseres Elternteils erhält. Was eigentlich bedeutet, dass wir
von hier aus
Kontext bekommen , den wir
im Gitarrenartikel haben. Hier haben wir einen Verweis
auf unsere Instanz. diesem Grund
empfehle ich Ihnen dringend , immer
Pfeilfunktionen und
keine Funktionsschlüsselwörter zu verwenden ,
und dann haben Sie keine
Probleme mit dem Kontext. Um das Inside
function Schlüsselwort zusammenzufassen, haben
Sie immer einen Verweis
auf ein globales Objekt. Innerhalb von Objekten haben Sie einen
Verweis auf das Objekt selbst. Innerhalb von Klassen
haben Sie einen Verweis auf eine Instanz der Klasse
und
Insider-Funktion, z. B. in der Methode
oder direkt innerhalb der Klasse, auf undefined verwiesen wird. Es.
19. Kurse: Eine der
beliebtesten Fragen
zum Interview ist
natürlich der Unterricht. Vielleicht bekommst du eine
Frage wie diese. Entwerfen Sie eine Klasse für
Mitarbeiter, die eine DNA namens
Urinkonstruktion von Objekten
aufnimmt. Und hier ist eine zellulare Eigenschaft. Wie Sie sehen können,
erhalten wir
hier keine strengen Anforderungen und wir haben eine gewisse
Flexibilität, sie umzusetzen. Deshalb
empfehle ich Ihnen dringend,
darüber nachzudenken und bestmöglich umzusetzen. Zuallererst hier, wollte
aber
eine Klasse erstellen und
nennen wir sie Mitarbeiter. Und jetzt als Leiter müssen
wir einen
Konstruktor mit dem DNS-Namen haben. Das ist y. Lassen Sie uns einen
Konstruktor erstellen und wir erhalten unsere AD und unseren Namen. Und danach
weisen wir sie der Sadie zu. Hier ist unser AD und
dieser Name entspricht dem Namen. Also besorgen wir uns
diese beiden Immobilien. Aber du kannst es
besser machen, weil du zeigen
musst, dass du ein guter Entwickler
bist. diesem Grund ist es
wirklich schön zu prüfen, ob wir in
diesen beiden Immobilien gegangen sind. Also können wir einfach hinzufügen, okay, wenn wir AD nicht bestanden
haben oder den Namen nicht übergeben haben, dann möchten wir einen Fehler auslösen. Deshalb wollte ich hier in New Era
werfen. Und hier drinnen können wir beispielsweise
schreiben, unsere Mitarbeiter-ID und der
Name obligatorisch sind. Denn tatsächlich
ist es das, was es in
der Aufgabe sagt und es ist schön
, diese Funktion zu behandeln. Wie Sie
sehen können, haben wir auch eine Linie und es hat eine Gehaltseigentum, was tatsächlich bedeutet, dass
wir das Gehalt festlegen können. Es ist nicht so, als
würden wir es im Konstruktor bekommen. Wir brauchen einen Setter- und
Getter-Funktionen für unser Gehalt. Zuallererst können wir
dieses festgelegte Gehalt definieren und es
wird eine Funktion sein, unsere Einstellung für das Gehalt, und wir geben
unser Gehalt und wir speichern
es einfach darin. Dieses Punktgehalt
entspricht also unserem Gehalt. Dies ist nicht alles, weil
wir
Ihre Show auch erhalten möchten , wenn das Gehalt in unserer Klasse
verfügbar ist. Aber wir möchten
diese Klasse wirklich auf fortgeschrittene Weise konstruieren , was tatsächlich bedeutet, dass
Coupon eine öffentliche API und einige
Methoden hat , um unsere Eigenschaften zu erhalten. diese Weise
empfehle ich Ihnen dringend, ein Gehalt zu erstellen, zu
erhalten und wir
brauchen hier nichts, und wir möchten dieses Punktgehalt
hierher zurückgeben. Und es ist auch
sinnvoll,
zwei Getter für unsere ID und unseren Namen zu erstellen . Hier können wir die
getID-Methode erstellen und im Inneren geben wir
unsere Thes-Punkt-ID zurück. Und wir können
hier auch erstellen getName Methode, und es wird
unseren Punktnamen zurückgeben. Wie Sie also mit viel Nachdenken
über unsere Klasse sehen können , wird sie
so gut wie möglich umgesetzt. Jetzt können wir versuchen, es zu benutzen. Hier erstellen wir
unseren Mitarbeiter mit einem
neuen Mitarbeiter und
geben ID und den Namen der
Website weiter, weil
sie obligatorisch sind. Und tatsächlich können wir es überprüfen, wir können die Seite neu laden
und wir erhalten Mitarbeiter-ID und
Name sind obligatorisch. Und das ist schön zu überprüfen. Hier ist unser 81-Name,
zum Beispiel check. Und jetzt wird unser Mitarbeiter
keinen Fehler auslösen. Was wir jetzt tun können, können wir
Mitarbeiterfestes Gehalt schreiben und wir geben zum Beispiel 1000 nach innen. Und jetzt können wir es überprüfen. Also werde ich die
Seite neu laden und hier ist unser Mitarbeiter mit einem
DNS-Namen und Gehalt, aber wir werden auch einen
Getter haben, zum Beispiel erhält Gehalt wird zu
unserem Gehalt zurückkehren und GetName
wird den Namen zurückgeben. Was eigentlich bedeutet, dass
wir
unsere Klasse so gut wie möglich implementiert haben . Aber jetzt
bekommst du eine zweite Aufgabe. Entwerfen Sie eine Klasse für Manager, die Mitarbeiter ist und Abteilungseigentum
haben kann, was bedeutet, Ihr Interviewer den Umfang unserer Klasse
sehen möchte weil wir
eine neue Klasse erstellen können basierend auf
unserer Mitarbeiterklasse. Das ist y hier unten, wir können einen neuen Klassenmanager erstellen. Hier möchten wir Extensions verwenden
, um die Funktionalität
unserer Mitarbeiterklasse zu nutzen. Und eigentlich
ist das fast t dt. Dies wird alles
aus unserer Mitarbeiterklasse nehmen, aber wir müssen auch eine Abteilung
erstellen. Deshalb brauchen wir nur
einen Setter und Getter, genau wie zuvor. Lassen Sie uns hier eine
festgelegte Abteilung erstellen und hier drinnen übergeben wir die
Abteilung oder nennen einfach nur einen Namen. Und hier speichern wir
unseren Namen
auch drinnen müssen ,
also holen Sie sich das Department. Und wir brauchen hier keine
Argumente und wir
möchten unsere
List-Punkt-Abteilung zurückgeben. Und eigentlich ist es auch sehr wichtig, überall
nette Namen zu haben. Wie Sie sehen können, nenne ich
keine Dinge wie Set oder einfach nur bei vollem Terror. Normalerweise versuche ich,
diese Namen so
produktionsbereit wie möglich zu machen . Wir verwenden hier zum
Beispiel Abteilungen und
Abteilungen, damit alles
klar ist, worum es geht. Und es zeigt wirklich im
Interview, dass Sie
ein guter Entwickler sind und qualitativ hochwertigen Code
schreiben können. Hier haben wir unsere
Setabteilung und holen uns Department. Lassen Sie uns jetzt
unseren verwalteten Chip erstellen. Also erstellen wir einfach einen neuen Manager und wir müssen wie immer
ID und Name, zum Beispiel John,
hineingehen . Und jetzt können wir unseren Manager
überprüfen. Wir können eine
Setabteilung erstellen und wir bestehen die besagte Abteilung
zum Beispiel Entwicklung. Jetzt können wir unseren Manager überprüfen. Also haben wir die
Abteilung nicht gesagt und es gibt eine GET-Abteilungsfunktion , die für
uns die Abteilung zurückgeben wird. Auf diese Weise beantworten
Sie normalerweise
Fragen zum Unterricht oder zur
Verlängerung der Klassen.
20. Prototypen: Im vorherigen Video haben wir
über Kurse gesprochen und
wie man sie erweitert. Die nächste Frage des
Change Reviewer kann jedoch gelegentliche Kurse sein. Aber haben wir
eigentlich Klassen in JavaScript? Wir haben etwas anderes, weil
wir keine Klassen
in JavaScript haben und sie als Auslöser
für Prototypen
entwickelt wurden. diesem Grund müssen wir jetzt
genau dieselben Klassen entwerfen genau dieselben Klassen indem wir JavaScript-Prototypen
ohne Verwendung von Klassen verwenden. Und eigentlich
musst du es mindestens einmal machen. Und was
sind dann die Probleme hier? Zuallererst haben wir unseren
Klassenmitarbeiter und zweitens verwalten den Chip, und jetzt
wollen wir ihn auf Prototypen reflektieren. Zuallererst müssen wir all diese Methoden nach
draußen
verschieben, da wir sie tatsächlich innerhalb
der Funktion ausprobieren
können. Und was ist eigentlich ein
Prototyp? Dies ist eine Funktion. Wir verwenden kein
Klassenschlüsselwort und ich werde
y hier verwenden , weil wir über Prototypen
sprechen. Dies ist also die ältere
Version von JavaScript. Also hier habe ich var mitarbeiter, und das ist nur eine typische
normale
Funktion mit Funktionsschlüsselwort hier drin bekommen
wir einen DNS-Namen. Und tatsächlich ist das
auch unser Konstruktor. Wir brauchen hier keinen Konstruktor. Wir überprüfen direkt, okay, ob wir ID und Namen haben, dann werfen wir einen Fehler aus. Aber wenn nicht, sitzen wir
hier diese AD und diesen Namen, was tatsächlich bedeutet, dass dies
unsere typische Klasse ist , wenn wir es mit Prototyp
machen. Jetzt müssen wir
alle unsere Funktionen anpassen. Wie Sie hier sehen können,
habe ich diese Funktionen und anstatt nur das
Gehalt wie eine Methode festzulegen, müssen
wir es
in einem Prototyp ausprobieren. Wir sagen
Mitarbeiter-Punkt-Prototyp, Punktgehalt. Und das wird eine Funktion sein. Hier sagen wir einfach
gleichwertiges Funktionswort, und hier ist unsere Funktion. Und wir müssen bei jeder Methode genau
das Gleiche tun. So ist der Mitarbeiter
dot Prototyp dot getID gleich, und hier ist unsere
Funktion und das Gleiche mit GetName und auch
mit gutem Gehalt. Hier ist der Prototyp,
getName equals Funktion. Schlüsselwort hier drin erhält Gehalt auch den gleichen Mitarbeiter-Prototyp, erhalten Gehalt gleich Funktion. Und jetzt haben wir unsere
Klasse erfolgreich auf Prototyp
umgestellt. Es war nicht so schwierig,
weil wir uns nicht ausgedehnt haben. Im Moment möchte ich den Manager
kommentieren, damit wir keine Fehler bekommen. Jetzt lasst uns nachsehen und durchstöbern. Ich lade die Seite neu und jetzt haben
wir hier unseren Mitarbeiter, wie Sie sehen können, sieht der Code genau gleich aus. Dies ist die Instanz
des Mitarbeiters. Hier haben wir zum
Beispiel die getID-Methode. Wir kriegen einen. Hier haben wir Gehälter, damit wir Gehalt
verdienen und bekommen können. Und es funktioniert alles, was bedeutet, dass
Sie Ihre Klasse so beeinflussen. Zwei Prototypen. Und jetzt haben wir einen
Manager und erweitern, und es wird schwieriger. Also hier haben wir einen Manager, wir sagten Abteilung
und holen Abteilung. Und ja, es
muss auch eine Funktion sein. Also hier können wir einfach var schreiben. Hier haben wir unseren Manager und wir wissen, dass
dies eine Funktion ist. Wir haben auch nicht die
Abteilung gesagt und das
Department reingebracht. Wir werden sie danach schreiben. Aber auch hier, das Problem, unser Manager erweitert
unseren Mitarbeiter, aber wir setzen uns in die gleichen Parameter ein und eigentlich
wollen wir hier nicht ID und Namen schreiben, aber wir können
es einfach hier ausprobieren, params. Und wir wollten nur
alle Felder werfen, die wir bekommen und nutzen,
hier unseren Mitarbeiter. Und dafür können wir Code wie diesen
schreiben. Wir können sie spielen schreiben. Hier drinnen geben wir
diese Koma-Argumente weiter. Und was das im Wesentlichen tut, verwendet
es hier Argumente aus
dieser Funktion. Und wie Sie
hier sehen können, habe ich auch geschrieben dass
Programme sie vorerst nicht
benutzt haben. Wenn Sie jedoch eine Aufgabe haben,
Manager um ein Feld zu erweitern, können
Sie hier
schreiben, zum Beispiel Bild ist gleich params Punktbild. Und in diesem Fall müssen Sie auch Ihren
Manager und ein Bild weitergeben. Dies ist durchaus möglich, aber wir brauchen
es nicht für unsere Aufgabe. Deshalb
verwenden wir hier einfach Mitarbeiter diese Argumente
anwenden
und was es tut, macht
es buchstäblich einen
Teil unseres Arbeitgebers aus. Wie Sie hier sehen können,
haben wir diese ID und diesen Namen, und tatsächlich
rufen wir diese Funktion auf, aber wir geben ihr einen anderen
Kontext,
der im Kontext unseres Managers
und Argumente
daraus gegeben der im Kontext unseres Managers wird -Funktion. Aber hier ist ein großer
Unterschied, den ich Ihnen
zeigen möchte , wenn wir zum Browser
springen. Und hier drin können
Sie den
Manager-Prototyp hier auf einer
Konstruktorfunktion sehen. Aber wenn ich hier einen
Mitarbeiter-Prototyp schreibe, können
Sie hier
alle Funktionen sehen, die wir zuvor
hatten, ganz oben, denn eigentlich nennt
diese einzelne Zeile nur den
Konstruktor des Mitarbeiters . Es hat nichts mit diesem Prototyp
zu tun,
was bedeutet, dass
diese Funktion IN besagt Prototyp von Mitarbeiter und
Manager sie nicht bekommt. Und das ist sehr wichtig , weil wir diese Klasse
verlängern. Dies bedeutet, dass wir sie direkt in
unserem Prototyp
haben wollen und sie kopieren möchten.
Wie können wir das machen. Wir können hier
Manager-Punkt-Prototyp gleich schreiben, und hier möchten wir object create
verwenden weil wir
unseren Mitarbeiter-Prototyp klonen möchten. Und im Inneren übergeben wir
unseren Mitarbeiter-Punkt-Prototyp. In diesem Fall klonen wir
all diese Funktionen von unserem Mitarbeiter bis zu unserem
Prototyp des Managers. Also lasst uns nachsehen, was
wir hier kriegen. Ich lade die Seite neu und genau hier
drin, Manager Dot Prototyp. Und wie Sie sehen können, ist dies
jetzt eine Kopie unseres Mitarbeiters. Und wir können hier
Manager Dot Prototyp schreiben, zum Beispiel
dot getID. Und wir bekommen diese Methode. Offensichtlich ist es
undefiniert, weil dies keine Instanz,
sondern die Klasse ist, aber wir haben Zugriff auf
diese Methode im Inneren. Aber hier ist auch ein großes
Problem, wenn wir hier Manager Dot
Prototype Dot Constructor
schreiben. Wir kriegen den Konstrukteur
unseres Mitarbeiters und verwalten
es nicht, und das ist falsch. Deshalb
müssen wir hier auch schreiben, Manager Dot Prototype
Dot Constructor. Und wir möchten hier
unsere Manager-Funktion zuweisen. In diesem Fall wird es zu 100% korrekt
sein. Und wie Sie sehen können,
wo ich in
Bezug auf unseren Manager komme , sind dies zwei Zeilen, die
sehr wichtig sind,
wenn Sie mit
Prototypen viel tun. Denn
zuallererst möchten Sie
alle Methoden von unserem Mitarbeiter erhalten . Und zweitens
müssen Sie überschreiben, einen Rücken zu unserem Manager
konstruieren. Und jetzt können wir die
SAT-Abteilung benutzen und die Abteilung holen. Das ist genau das
Gleiche wie zuvor. Es ist Manager-Punkt-Prototyp. Und hier weisen wir
unsere Setabteilung und hier Manager dot
prototype.js Abteilung zu. Hier müssen wir natürlich
das Funktionsschlüsselwort in
genau dem gleichen schreiben das Funktionsschlüsselwort in ,
sollte hier oben sein. In diesem Fall haben wir den Manager erfolgreich
implementiert, genau wie es in
früheren Lucas-Klassen gemacht wurde. Lasst uns unsere Seite neu laden und nachsehen. Wie Sie sehen können, erhalten wir unseren Manager mit ID und Namen, aber wir haben auch eine
Funktionssatzabteilung. Wir können zum Beispiel
hier Entwicklung schreiben. Und jetzt haben wir nicht
Manager gesagt, auch Entwicklung. Und wir haben eine nette
GET-Abteilungsfunktion. Und offensichtlich können wir dieselbe Funktion
verwenden. Holen Sie sich zum Beispiel die ID von unserem Elternteil und
es funktioniert auch. Dies ist, wen
Sie normalerweise Prototypen verwenden und Klassen mit
nativen Prototypen
in JavaScript
implementieren .
21. Ich Habe Das Interview Nicht Versäumt. Was ist als Nächstes: Es kann sein, dass er gerade Ihrem Interview
nicht bestanden hat
und vielleicht war es Ihr erstes Interview
und Sie wollten
diesen Job wirklich und jetzt sind Sie wirklich depressiv.
Was solltest du tun? Zuallererst
müssen Sie verstehen, dass dies völlig normal ist und Sie während Ihres Lebens viele
Interviews scheitern werden, und ich habe viele davon versagt, besonders am Anfang. Deshalb möchten Sie
zuerst das, was Sie tun
müssen, um fortzufahren. Sie sollten nicht kurz nach
Ihrem ersten Interview aufhören und auch
nach Ihrem fünften Interview sollten
Sie nicht aufhören, denn
früher oder später werden Sie Ihre erste Firma
finden und
Ihren ersten Job bekommen. Zuallererst solltest du
nicht deprimiert sein. Und zweitens müssen Sie
Interviews als zusätzliche
Wissensquelle verwenden Interviews als zusätzliche
Wissensquelle da dies tatsächlich ein
guter Ort ist, um zu verstehen welche Fragen Ihnen im Interview
gestellt wurden. Und Sie können auch verstehen , welches Wissen Sie mögen. Hier gibt es zwei
Hauptpunkte, die Sie tun müssen. Nach jedem einzelnen Interview. Kurz nach dem Interview müssen
Sie sich hinsetzen und alle Fragen
schreiben , die Ihnen gestellt wurden, und Sie
haben nicht richtig geantwortet, es hat nicht geantwortet. Danach müssen Sie
all diese Fragen googeln und lernen. Offensichtlich kannst du nicht
alles an einem Tag lernen, aber du kannst dieses Wissen teilen und etwas Neues für dich lernen. Dies ist wirklich wichtig, um es direkt danach zu
tun, denn im anderen
Fall werden Sie es vergessen. Der nächste wichtige Punkt besteht darin, das Unternehmen um die Antwort
zu bitten. Und tatsächlich könnte es sein, dass
Sie nach
Ihrem Interview von
der Firma überhaupt keinen Brief oder
einen Anruf erhalten nach
Ihrem Interview von
der Firma überhaupt keinen Brief oder
einen Anruf haben. Und das kann in
vielen Unternehmen passieren. Hier müssen Sie Ihr Diagramm
schreiben, mit dem Sie
mindestens zweimal gesprochen haben, möglicherweise ein oder zwei Tage
nach dem Interview
und dann vielleicht in drei Tagen
danach, und dann vielleicht in drei Tagen weil Sie eine Antwort erhalten
müssen. Und wenn sie sagten, dass Sie das Interview
nicht bestanden
haben, müssen Sie um die technische
Überprüfung Ihres Interviews bitten. Du kannst einfach fragen, okay, das ist PT, aber sie wollen
wirklich Feedback. Welches Wissen gefällt mir? Das ist völlig normal
und tatsächlich werden sie nicht oft technisches
Feedback
geben, aber manchmal können sie es tun. Und das ist auch
äußerst nützlich für Sie da Sie Ihr Wissen
aus der
Perspektive einer anderen Person
sehen werden . Ihr Interviewer
kann etwas schreiben , was für Sie extrem
wichtig ist, um zu lernen. Deshalb lassen Sie
sich nicht entmutigen wenn Sie
das Interview nicht bestanden haben,
das ist völlig normal und
Sie sollten einfach weitermachen.
22. Modulen: Möglicherweise erhalten Sie auch eine Frage
zum modularen System. Sie meinen mit diesem EPMA Script sechs Module oder
gemeinsame JS-Module. Zum Beispiel kann Ihre
Frage
ein Atmosphärenkrypt-Sechs-Modul
mit den Funktionen GetName,
Nachname und
Standard-Experte erhalten vollständigen Namen erstellt ein Atmosphärenkrypt-Sechs-Modul
mit den Funktionen GetName, werden. Dafür müssen Sie wissen, dass Harmodius
in JavaScript arbeitet, nur weil es die
Kernkomponente von
JavaScript ist und wir überall Module
verwenden. Um die Eingaben verwenden zu können, müssen wir eine weitere Datei
erstellen. Wie Sie hier sehen können,
habe ich Haupt-JS. Dies ist unsere
Hauptdatei und Index-HTML. Nehmen wir an, dass
wir
ein neues Modul erstellen und es benennen
möchten. Zum Beispiel müssen z.B.
Skripte js doten. Im Inneren werden wir ein
Atmos Script-Sechs-Modul schreiben. Zunächst möchten
wir hier eine Methode getName erstellen, und wir schreiben sie
mit export const. Hier ist GetName, und
hier bekommen wir einen Argumentnamen und geben unseren Namen
zurück. Wie Sie hier sehen können, verwenden wir den Konstruktionsexperten const, und dies ist genau eine
der Funktionen, die
wir erstellen müssen. Und wie du siehst, hol dir
den Namen und erhalte ihren Namen. Ich habe einfach keine Funktionen genannt. Deshalb schreiben wir
sie und wir sind Experten in ihnen aus diesem Modul
war export const. Ich kopiere diese Zeile und füge
sie hier ein und wir müssen sie benennen. Hol dir einen bestimmten Namen. Hier bekommen
wir einen bestimmten Namen und wir
geben nur unseren Nachnamen zurück. Das letzte, was
wir Maskennote haben, ist Standardexperte, vergesslicher Name. Und wenn Sie nicht wissen, wie
Sie einen Standardexperten erstellen, ist
dies der Exportstandard. Und hier
müssen wir keinen Namen angeben,
was bedeutet, dass
wir hier direkt
eine Funktion haben , in unserem Fall können
wir sie wie diesen erstellen, Vor- und Nachname und wir verketten ihn
einfach. Und hier drinnen haben wir eine kryptische Atmos-Zeichenfolge und rufen hier
einfach unsere Funktionen auf. Zunächst einmal GetName und
wir geben Insidername weiter. Danach haben wir hier
ein Leerzeichen, wir haben eine zweite Funktion,
bekommt ihren Namen überall dort, wo
Bison Nachname drin ist. Jetzt
ist unsere Script-Six-Stuhl-Datei ein Modul und es ist
vollständig isoliert. Und was wir Experten sind, ist es
hier draußen verfügbar, also verwenden wir es jetzt. Wir haben hier drei Funktionen Biomasse springt unsere
Hauptstühle hier rein, wir müssen sie importieren und wir geben sie
so ein, wichtig. Dann haben wir Klammern und
in dem, was wir eingeben, ist
es GetName, Coleman
bekommt ihren Namen. Und wie Sie sehen können, ist
mein Y's Redakteur älter von hier aus
bei meinem Skript sechs. Und wie Sie sehen können, ist es
natürlich schwarz , weil wir diese Funktionen nicht
verwenden. Hier möchte
ich
GetName schreiben und wir gehen weiter. Also zum Beispiel, JAK, dann haben wir hier Nachnamen bekommen, und hier wird Spatz sein. So geben wir Namensexperten ein
und verwenden sie. Wir verwenden hier Wort-Import, dann Klammern und
innerhalb benannter Funktionen. In unserem Fall
erhält GetName ihren Namen, erhält GetName ihren Namen, und dies ist der Pfad zu unserer
Datei ECMO-Skripte dot js. Jetzt
ist die Frage, wie wir
unseren Standardexperten bekommen können und
für dieses Wochenende direkt nach der Eingabe vollständigen Namen und dann Komma
erhalten. In diesem Fall erhalten wir zuerst
unseren Standardexperten und benennen danach Experten nur
mit Klammern. Jetzt können wir hier in unserem
Konsolenprotokoll get
fullName verwenden und wir geben
Site zwei Strings weiter. Zuallererst Jack und
zweitens weniger parallel. Und jetzt können wir diese
Funktionen genauso verwenden, wie sie sie
in dieser Positionsdatei definiert wurden. Jetzt
ist die Frage, wie wir das
EKG verwenden können , das sechs
Modul in unserem HTML vorschreibt. Dafür müssen wir in unseren HTML
springen. Hier haben wir ein Skript
mit Quelle Manchester. Das ist völlig in Ordnung, aber wir müssen
hier schreiben Typ-Modul und dann wird es wie das
Atmos Script Six-Modul importiert. Versuchen wir nun, unsere Seite
neu zu laden. Wie Sie sehen können, hat es
tatsächlich funktioniert aber wir bekommen
einen engen Kursfehler, weil
dieses Index-HTML-Land wirklich laut Hauptschach ist,
weil Sie keine ursprungsübergreifenden
Anfragen
stellen können aus der Datei. Und das ist eigentlich ein Problem,
denn hier verwende ich diese Quelldatei genau wie die
normale Index-HTML-Datei. Wenn Sie ein
Front-End-Framework
wie Reactor Angular verwenden , haben
Sie kein solches Problem da Sie
Modulsysteme haben, die sofort einsatzbereit sind. Aber genau für diesen
speziellen Fall in dem ich
einen Index-HTML gespielt habe, muss
ich diesen
Index-HTML wie einen Webserver bereitstellen. Und dafür gibt es ein
Paket, das Serve genannt wird. Sie können es installieren
war bekannt Schach, und wie Sie jetzt sehen können, ist
es für mich
nur diesen Index-HTML auf
localhost 3 tausend verfügbar . Wie Sie sehen können,
haben wir keinen Fehler in Bezug auf den Kurs, aber wir haben ein Problem, unsere Atmosphere
Crypt Six-Datei zu laden, weil wir
hier
dot js setzen müssen , um diese Datei zu laden. Jetzt kriegen wir die Sarah nicht. Und wie Sie sehen können, dass er Konsole
ist, sind diese alten Funktionen schnell verfügbar. Hier können wir Jack
Sparrow und Jack Sparrow sehen. Und das bedeutet, dass
wir diese drei
Funktionen erfolgreich eingegeben haben, wurden unter Verwendung von Modulen der
Atmos-Gruppe sechs als
Expert- und Standardexport aus
unserem Modul bezeichnet Expert- und Standardexport aus . Jetzt haben wir eine nächste Frage. Wir müssen genau
das gleiche Zeug
mit dem gemeinsamen JS-Modul erstellen . Und wenn Sie es nicht wissen, wird
üblicherweise ein
gängiges GIS-Modell in bekannten Stühlen verwendet. diesem Grund
wollte ich jetzt unsere
atmos Script Six JS-Datei
mit gemeinsamen Stühlen schreiben . diesem Grund kopiere ich Einfügetabulation und
erstelle hier eine neue Datei, nenne sie
einfach common dot js. Und wir werden hier
alles neu schreiben. Im gemeinsamen js-Modul können
Sie dasselbe tun. Sie können nicht gleichzeitig
Standard-Export- und Namensexperten haben . Und das liegt daran, dass statt const zu
exportieren, wo immer
ich hier reinlege, module.exports dot getName, und wir weisen hier
eine Funktion zu. Der Hauptpunkt ist,
wenn Book einen
Standardexperten
schreiben möchte , bei dem IKT und anstelle des Exports von
Standardmodul.exports gleich sind. Und hier ist unsere Funktion, was bedeutet, dass wir hier
eine Standardvorlage
für unsere Funktion haben . Was wir in
diesem Fall tun können, ist einfach diesen GetName zu
verlassen
und Nachnamen als
private Funktionen zu erhalten ,
weil wir
den Experten gleichzeitig
ohne Standardexperten kontrollieren . Und wie Sie hier sehen können, haben
wir Modulexperten, nur
um unseren Standardexperten zu haben. Jetzt können wir direkt in
Manchester springen und hier
unsere Standardfunktion importieren. Um dies zu tun, müssen wir das Suchbegriff require
verwenden. Deshalb möchte ich hier
const schreiben und wir bekommen
großen vollständigen Namen. Und hier ist gleich erforderlich, und hier ist unser Weg
gemeinsamer JS oder einfach nur üblich. Ich kann in die Konsole
und das Hauptschach des rechten Knotens springen. Und offensichtlich erhalten wir eine Nachricht GetName
ist nicht definiert,
weil wir hier versuchen, das Protokoll getName zu konsolen
und Nachnamen zu erhalten. Jetzt habe ich
gerade FullName bekommen. Versuchen wir es noch einmal. Wie Sie sehen können, haben wir
keine Fehler und wir
bekommen Schecks Eltern. Wenn wir wirklich
alle drei Funktionen bekommen wollen, müssen
wir hierher springen und
einfach überall verwenden module.exports dot und
hier wird unser GetName sein. Jetzt wird hier mehr bei Ihren Punktexperten Punkt Nachname bekommen. Und hier wollen wir mehr Teal Dot-Experten und
hier wird ein guter vollständiger Name sein. In diesem Fall wird es funktionieren und wir werden unsere
drei Funktionen erhalten. Jetzt haben wir drei Experten. Wir können zurück in Manchester springen. Und hier,
anstatt den vollständigen Namen zu bekommen, können
wir einfach destrukturieren
und drei Funktionen erhalten. Getname, bekommt ihren Namen und hier hol FullName. Und jetzt können wir
diese beiden Konsolenprotokolle auskommentieren. Schauen wir uns das an. Ich springe in die Konsole
und führe Node Manager und wir bekommen immer noch einen agilen
GetName ist nicht definiert. Aber eigentlich
ist das Problem hier, dass
wir innerhalb von gewöhnlichen JS keine Funktion
getName haben und Nachnamen bekommen weil wir
sie tatsächlich in Modulexperten haben. Aus diesem Grund funktioniert dieser
Code nicht. Berlin muss
zuerst Namen
bilden und dann nach diesem Modul punkten Experten getName
und hier gleich getName. In diesem Fall kann diese
Funktion auch funktionieren. Wir müssen genau das
Gleiche tun für unseren Nachnamen bekommen. Hier wird const Nachnamen holen und lassen Sie es uns nach oben verschieben. Und jetzt sind unsere
Experten GetName, und jetzt haben
wir hier Nachnamen und wir weisen hier unsere
Funktion Ernie zu. In diesem Fall
stehen uns alle Funktionen innerhalb dieser Datei und auch außerhalb über Modulexperten zur Verfügung.
Schauen wir uns das an. Ich betreibe Node Main Chess und wir haben keine Fehler. Wie Sie sehen können, haben wir zwei verschiedene Varianten
an meinem Drehbuch, sechs und gemeinsame Truhe. Und wenn Sie
all diese Fragen erwischt haben, dann könnte die nächste Frage lauten Was ist der Unterschied
zwischen Atmos Script sechs Modulen und
gängigen JS-Modulen. Und eigentlich macht SAL dieses Set. Gemeinsame Schachmodule werden typischerweise
in der bekannten Truhe verwendet. Dies ist das
Standardmodulsystem für bekannte Truhe ECMO Script sechs
Module, die wir im Browser haben. Das ist ECM Script
Six JavaScript. Und tatsächlich können Sie ECMO Script sechs
Module in Node-Stühlen
verwenden . Und das ist nur ein
Zucker in der Nähe. diesem Grund wissen Sie, dass Sie, wenn Sie von
einem Postscript sechs Module
in Nicht-Schach ausgehen , dass
Sie im Inneren noch benötigt werden, da es für NodeJS
obligatorisch ist. Demo-Skripte Sechs
Module sind allem neuer als
herkömmliche JS-Module und zweitens sind sie statisch,
was tatsächlich bedeutet, dass Sie diese Anforderung
innerhalb der Bedingung packen
können , wenn z.
B. in for-Schleife . Aber Sie können es nicht wirklich mit Input
machen , da die Eingabe
immer oben sein muss. Und wenn die Eingabe nicht oben ist
, blasen sie
automatisch nach oben, wenn
JavaScript sie analysiert. Und das ist eigentlich
viel besser, vor allem aus Sicherheitsgründen. Und zweitens, um
verschiedene integrierte Tools auf
der Spitze von Atmos
Script sechs Modulen zu implementieren verschiedene integrierte Tools auf .
23. Implementieren Sie Debounce: Eine der Fragen, die von Zeit zu
Zeit hier
sind , ist das Schreiben
der Bones-Funktion. Und wenn Sie nicht wissen,
was die Bones sind, bedeutet
dies, dass die
Funktion erst nach einer
bestimmten Zeit
aufgerufen wird , was bedeutet, dass
jeder einzelne Aufruf dieser Funktion verzögert
wird. Wie können wir
diese Funktion implementieren? Zuallererst müssen wir
eine Funktion erstellen , die wir zu den Bones
wollen. Hier möchte ich eine Funktion
erstellen, zum Beispiel Input speichern. Und hier werden wir
in unserem Namen angegeben. Die Idee ist also, dass
wir im Inneren einfach etwas
konsolen werden. Und wir können sehen, dass diese
Funktion funktioniert. Hier ist die Eingabe und den Namen speichern. Und wir verwenden die
Anleihefunktion. Wenn wir beispielsweise Informationen
an das Back-End
senden möchten , tippt der Benutzer etwas
in das Eingabefeld ein. Und wir möchten zum Beispiel
200 Millisekunden oder zwei Sekunden
warten, 200 Millisekunden oder zwei Sekunden nachdem die Person nicht mehr
etwas in die Eingabe eintippt. In diesem Fall schickten die Schüler nur eine
einzige Anfrage an das Back-End, um
die Validierung zu überprüfen , und nicht viele Anfragen nach
jedem einzelnen Brief. Genau deshalb brauchten
wir die Knochen. Also haben wir unsere
Save-Input-Funktion und jetzt wollen wir sie die Bones
nennen. Nennen wir
es zum Beispiel Prozessänderung. Hier möchten wir eine
DBMS-Funktion verwenden, die wir in einer Sekunde
erstellen werden , in der wir vor allem
unsere Funktion bereitstellen
müssen , dies
spart Eingabe und zweitens
Verzögerung, zum Beispiel zwei Sekunden. Danach können wir die
Prozessänderung einfach mit einer Zeichenfolge aufrufen . Und eigentlich spielt es keine
Rolle, wie
oft wir diese
Funktion als Hauptidee bezeichnen werden, sie wird auf die aufgerufen. Nach zwei Sekunden. Hier möchte ich eine
neue Funktion registrieren, die Bones. Und hier kommen wir
als Argument. Zunächst einmal eine Funktion, nennen
wir es Funk. Und zweitens unser Timeout. Und es ist ein netter Ansatz
,
das Timeout standardmäßig auf
300 Millisekunden festzulegen . Dies bedeutet, dass eine Bereitstellung nicht
zwingend erforderlich ist. Und jetzt
muss innerhalb unserer
Debonding-Funktion eine Funktion zurückgegeben werden. Denn wie Sie hier sehen können, rufen
wir die Bones-Funktion auf
und die Prozessänderung ist auch eine Funktion, bei der wir
im Inneren
einige Daten für unsere
herzhafte Eingabefunktion bereitstellen können , die tatsächlich
bedeutet, dass wir zurückkehren müssen und du funktionierst. Hier wollen wir unsere Argumente verbreiten. Und lasst uns prüfen, was
wir Gegensätze bekommen. Also hier möchte ich die
Login-Funktions-Komma-Bögen konsolen, und wir können sehen, in welchem
Format wir sie bekommen. Ich lade die Seite neu. Wie Sie sehen können, bekommen wir
viermal, weil wir diese Funktion
viermal in einer Funktion
aufrufen. Und hier haben wir nur
ein einziges Argument foo. Aber diese Verbreitung mit
Argumenten hat
unsere Argumente in
ein Array umgewandelt , da es für uns einfacher ist, mit dem Array zu
arbeiten. Das zweite, was wir tun
wollen, ist einen Timer zu erstellen und tatsächlich eine Zeit der Gruppe, die
hier oben in der Schließung
speichern möchte . Hier können wir einfach Timer
ohne Standardwert lassen. Und jetzt in unserer
inneren Funktion nach unserem Konsolenlot mit
wollte einfach setTimeout schreiben. Hier haben wir eine
Funktion und tatsächlich wird der zweite Parameter hier
unser Timeout sein. Nach welcher Zeit werden wir diesen Code im Inneren
aufrufen. Was wir hier tun wollen,
ist func dot apply. Hier wird dieser Koma Aurochs sein. Was hat es einen Mittelwert? Wir verwenden hier
die Anleihefunktion und hier stellen wir
unseren Retter Input zur Verfügung. Es ist unser Func. Hier ist unser Timeout. In diesem Moment ist
diese Prozessänderung
diese innere Funktion. Und nachdem wir diese Funktion
aufgerufen
haben, rufen wir diesen Teil auf. Hier kriegen wir
unsere Argumente. In unserem Fall
ist dies ein Array mit foo. Hier haben wir unser Konsolenprotokoll und dies wird setTimeout
generieren, was eigentlich bedeutet, dass
jede einzelne Zeile hier, wenn wir diese Funktion aufrufen, ein setTimeout generiert. Mit diesem Timeout, was
wir im Inneren machen,
wo wir func anrufen. Also rufen wir diese
Speichereingabe mit apply this args auf, was tatsächlich bedeutet, dass wir diese Funktion
nach einem Timeout mit
dem richtigen Kontext,
mit dem Kontext dieser
Funktion, mit diesen Argumenten aufrufen
möchten nach einem Timeout mit
dem richtigen Kontext, . Aber hier haben wir ein Problem
, wenn wir die Seite neu laden. Wie Sie sehen können, erhalten
wir
viermal eine Funktion und nach zwei Sekunden, indem wir viermal
gespeicherte Eingabe voll erhalten. Und das ist falsch, denn
hier müssen wir es
auf die bekommen , denn das
ist tatsächlich an den Knochen. Wir müssen unseren Timer
jedes Mal löschen , wenn wir die
Funktion aufrufen, da in diesem Fall
unser zuvor eingestelltes
Timeout
genau dafür ignoriert werden muss, unser zuvor eingestelltes
Timeout
genau dafür ignoriert werden muss was wir hier
erstellt haben Vorbereitungs- und Anlaufzeit. Was wir hier tun können, können
wir dem Timer setTimeout
zuweisen. Und wenn Sie setTimeout
nicht kennen, geben Sie uns eine
Nummer zurück und dies ist unsere spezifische ID
, die wir bereinigen können. diesem Grund können
wir vor unserem Timer jetzt ein klares Timeout schreiben und im Inneren können wir unseren Timer
bereitstellen. Wenn es undefiniert ist, spielt
es keine Rolle, es wird nichts tun. Wenn wir jedoch eine AD haben, wird das vorherige setTimeout zerstört. In diesem Fall werden jedes Mal, wenn wir diese
Funktion erneut aufrufen, wenn wir diese
Funktion erneut aufrufen,
alle vorherigen Timeouts bewässert und jetzt
erstellen wir ein neues eingestelltes Timeout. Und nach dieser Zeit
werden wir unsere Funktion aufrufen. Das ist genau die
Idee der Knochen. Jetzt laden wir die Seite neu. Wir bekommen unsere innere
Funktion viermal und jetzt erhalten wir nach zwei Sekunden
nur einmal
gespeicherte Eingabe . Und genau das
wollten wir , als wir unsere Belastungen
umgesetzt haben. Die
Bones-Funktion ermöglicht es uns erneut, nach bestimmten Zeit etwas nur einmal
aufzurufen. Dies ist sehr
wichtig, wenn wir über
etwas
sprechen, das der Benutzer der Eingabe in
das Formular oft aufrufen
kann beispielsweise
während der Eingabe in
das Formular oft aufrufen
kann.
24. Drosselfunktion implementieren: Wir haben erfolgreich implementiert
sind die Bones-Funktion. Möglicherweise
erhalten Sie aber auch eine Frage wie Sie die
Drosselklappenfunktion implementieren können. Und tatsächlich
sind sie sich super ähnlich. Und deshalb habe ich
den Code aus unserer
Bones-Funktion , weil
wir uns wirklich wie 1% des Codes
ändern müssen . Die Idee der Drosselklappenfunktion
ist also , dass sie sofort
ausgeführt wird. Und nur um Sie daran zu erinnern, wird
die Bones-Funktion am oder
nach unserem Timeout
ausgeführt. Hier führt die Gasfunktion sie sofort aus, aber danach wird
die Spalte der Funktion wird
die Spalte der Funktion
für unser Team
vollständig ignoriert,
was bedeutet, dass wir, wenn der
Benutzer etwas tippt, können
wir rufen Sie unsere Funktion nur am Anfang und
dann jedes Mal auf, also
zum Beispiel alle zwei Sekunden. Und genau das ist der
Kernzweck der Drosselklappe. Um es zu simulieren, müssen wir unseren Code ein wenig
ändern. Hier haben wir unseren Erlöser Input. Das ist in Ordnung. Hier ist eine Prozessänderung, aber wir wollen hier nicht verwenden dass
die Knochen es mit Gashebel
schreiben wollen. Die Argumente sind
genau die gleichen. Und jetzt nennen wir hier den
Prozesswechsel am Anfang. Das ist total in Ordnung, aber jetzt möchte ich simulieren , dass wir
es mit setTimeout nennen. Hier haben wir Recht
und setTimeout, und wir möchten
diese Funktionsprozessänderung
nach einiger
Zeit aufrufen diese Funktionsprozessänderung , zum Beispiel nach 1 Sekunde, dann
kopiere ich dieses setTimeout
und führe es nach 1
Sekunde, 200 Millisekunden. Jetzt kopiere ich es erneut, und ich rufe diese
Funktion nach
zwei Sekunden und
400 Millisekunden erneut auf, und dann werde ich zwei
letzte Plots entfernen, die sich geändert haben. Wie Sie hier sehen können, setzen
wir Timeout 200 Millisekunden ein, was tatsächlich
bedeutet, dass diese Funktion sofort ausgeführt werden
muss. Dieses setTimeout wird ignoriert. Dies wird ebenfalls ignoriert und das letzte eingestellte
Timeout wird
diese Funktion aufgerufen , da
dies
nach dieser Zeit
von 200 Millisekunden passieren wird . Lassen Sie uns zunächst
den Namen unserer
Knochen in Gashebel ändern . Wir bekommen hier
die gleichen Argumente, eine Funktion und unser Timeout. Aber jetzt brauchen wir hier keine
Timer-ID, sondern einen booleschen Wert. Und dieser boolesche Wert zeigt uns, ob wir diese
Funktion erneut ausführen können. diesem Grund wartet nicht die Vorlaufzeit, sondern zum Beispiel Lead und ist
standardmäßig falsch. Jetzt geben wir auch
eine Funktion zurück , die wir
hier nicht brauchen, Clear Timeout. Und eigentlich bleibt setTimeout
hier, aber wir brauchen keine Zeit,
weil wir dieses setTimeout tatsächlich
mit einer if-Bedingung hier
verbieten werden . Wir können schreiben, wenn nicht wartet, dann wollen wir
dieses setTimeout aufrufen. In anderen Fällen rufen wir
nichts auf und dieser Code
wird einfach ignoriert. Außerdem ist es wichtig, dass wir diese Funktion direkt
aufrufen. Deshalb möchte ich es in unsere
If-Bedingung und
Insights setTimeout
verschieben , wir ändern einfach unser Gewicht
in der Eigenschaft auf false zurück. Wie Sie sehen können,
bedeutet diese Zeile , dass
wir diese Funktion
zu Beginn des ersten Aufrufs aufrufen werden. Aber danach wollen wir unsere Flagge
auf „wahr“ setzen. Das ist y hier wo ich nicht gewartet habe,
ist gleich wahr. Dann haben wir ein eingestelltes Timeout, zum Beispiel zwei Sekunden. Und nach zwei Sekunden warten wir
auf false,
was bedeutet, dass wir diese Funktion
nach zwei
Sekunden und nicht vorher aufrufen
können . Wie Sie sehen können, ist der
Code 99% gleich. Die Grundidee ist, dass wir hier
Gewicht und Flagge
aufbauen, und wir erlauben nur, einmal
in unserem Timeout auf
diese Funktion zuzugreifen . Jetzt lasst uns prüfen, ob es funktioniert. Ich lade die Seite neu, wir
speichern direkt Put foo zum ersten Mal. Und dann sehen wir auf Louvain
CV Eingang f2 zweites Mal. Und das ist genau diese Änderung des
Codeprozesses und dieser letzte eingestellte Zeitmodus mit zwei Sekunden und
400 Millisekunden. Denn eigentlich werden
wir hier bei unserem ersten Versuch drosseln, warten, ist falsch. Wir gehen hier hin, wir
überprüfen einen Schlüssel, das stimmt nicht. Dann rufen wir
diese Funktion direkt auf und
setzen unser Flag auf „true“. Und dann nach unserem
festgelegten Timeout ändern wir sein
Gewicht und zurück zu falsch. Und wir brauchen
hier keine Zeit RED weil wir nie
an Bord unseres setTimeout sind. Die nächste Frage
, die du vielleicht bekommst. Okay, aber was ist der Unterschied zwischen Knochen und Drosselklappe? Und wie ich bereits sagte, rufen
wir die Knochen an,
nachdem die Benutzer angehalten haben
, um etwas zu tun. Wir nennen zuerst
Gashebel am Anfang
und dann nach einem bestimmten
Zeitintervall.
25. Markieren Sie Alle Wörter Über 8 Chars Mit Gelb: Möglicherweise erhalten Sie auch
einige
Fragen dazu, wie JavaScript
Weisheit funktioniert. Zum Beispiel müssen wir hier alle
Wörter mit mehr als acht
Zeichen lang in
den Absatztexten
mit gelbem Hintergrund
hervorheben Zeichen lang in . Und wie Sie hier sehen können, habe ich index.HTML und wir
haben unseren Absatz, und wir haben unseren
Überschriftenabsatz, und wir haben hier ziemlich
viel Text. Wenn Sie es selbst ausprobieren möchten, verknüpfe
ich den Quellcode
im Beschreibungsfeld unten. Sie sollten
diesen ganzen Text nicht erneut eingeben. So sieht es jetzt aus, wie können wir
diese spezifische Aufgabe umsetzen? Zuallererst müssen wir unseren Absatz
finden. Das ist wirklich einfach, dass wir nur einen einzigen Absatz
haben. Hier. Wir können sagen, dass
wir den Absatz finden und hier ist ein
Dokumentpunktabfrageselektor. Und hier dieses P und das
kannst du sehen, dass ich hier
QuerySelector benutzt habe. Und das ist sehr wichtig,
wenn Sie versuchen, getElementById zu verwenden oder Element für Klasse zu
erhalten Dies ist nicht der
beste Ansatz und Details, die Sie nicht mit Tom
zusammengearbeitet haben. diesem Grund müssen Sie immer querySelector
oder QuerySelector
verwenden. Oh, wenn du eine
Liste deiner Elemente bekommen willst, bekommen wir
in unserem Fall
nur ein einziges Element. Deshalb schreiben wir einfach hier p und wir bekommen
unseren Absatz. Wir könnten hier auch am Anfang ein
Dollarzeichen schreiben, genau wie im jQuery-Stil. Zum Beispiel
bevorzuge ich es, es zu leicht
durch den Namen zu unterscheiden, Der Unterschied zwischen
nur zwei Elementen und DOM-Elementen. Aber im Moment werden wir
es wie einen Absatz behalten. Aber wir wollen jetzt Poupon tun, um unseren Inhalt
so zu ändern,
dass unser inneres HTML unser inneres HTML entspricht. Und wir wollen zuerst den Absatzpunkt InnerHTML
lesen. Und wie Sie sehen können,
sehen Inhalte in InnerHTML
so aus. Das ist also nur eine einfache
Zeichenfolge und jetzt können wir wie mit
normalem JavaScript-Stream damit
arbeiten. Was wir jetzt
hier machen wollen, wollen wir es zunächst mit Raum aufteilen. In diesem Fall
erhalten wir eine Reihe von Wörtern und jetzt können wir map verwenden, um mit jedem einzelnen Wort zu
arbeiten. Eigentlich werden wir hier informiert und drinnen wollen wir
prüfen, ob unsere Welt
länger als acht Symbole ist. So können wir einfach hierher eine
Wortpunktlänge
zurückkehren , die größer
als acht Symbole ist. Dann wollen wir hier einen ternären Operator
schreiben. Und wenn wir größer
als acht Symbole sind, dann Coupon, um es in gelb zu
verpacken, was bedeutet, dass wir einen weiteren DOM-Knoten darin
schreiben möchten . Hier werde ich hier
ein String-Div mit Stil
innerhalb und innen erstellen , wir haben Recht und
Hintergrundfarbe, zum Beispiel gelb. Hier müssen wir unser div schließen
und eigentlich ist dv schlecht. Wir müssen hier Span verwenden,
denn dies wird ein Binnenelement
innerhalb dieser Spanne , wo genau in unserer Welt
das zuvor dort war. In diesem Fall
kehren wir zurück und du weißt es nicht. Und wenn wir die Welt nicht
verändert haben, geben wir
dieses Wort einfach zurück. Wie Sie in diesem
Fall sehen können, nehmen
wir zunächst unsere Saite
in die InnerHTML. Wir teilen es nach Wörtern
mit Leerzeichen, in
denen jedes einzelne Wort abgebildet wird, und
wir überprüfen die Länge. In diesem Fall gebe ich Ihren DOM-Knoten
zurück oder gebe das Wort selbst zurück. Und nachdem wir mit unserer Map
fertig sind, müssen
wir uns alles wieder anschließen. Hier
schließen wir uns hier mit dem Weltraum zusammen, genau wie zuvor. Lasst uns nachsehen, was wir kriegen. Ich lade die Seite neu. Und wie Sie
sehen können,
werden alle unsere Wörter die länger als acht Symbole sind, ,
die länger als acht Symbole sind, gelb hervorgehoben, was tatsächlich
Anfangslinien bedeutet. Wir können diese Aufgabe lösen. Sie können verschiedene
Aufgaben in Bezug auf DOM erhalten. Was Sie wissen müssen, ist, wie
man Elemente von Dom erhält, wie man sie von ihnen entfernt, wie man sie aktualisiert und wie man
DOM-Elemente direkt in
JavaScript-Zeichenfolgen umwandelt . Du kannst mit ihnen arbeiten.
26. Link hinzufügen: Eine weitere dumme Aufgabe, die
Sie erhalten können, ist das Hinzufügen eines Links zur
Textquelle nach dem Absatz-Tag. Und eigentlich habe ich genau den gleichen HTML-Code wie pervers. Aber am Ende müssen
wir einen
Link zu unserer Quelle bereitstellen. Wie können wir das lösen? Zuallererst müssen wir ein neues DOM-Element
erstellen. Falls es sich um einen Link handelt,
werden wir einen
Einblickdiagramm zur Verfügung stellen, und dann werden wir
es einfach am Ende unseres DOM anhängen. Lassen Sie uns zunächst einen Link
erstellen. Dafür können wir
Document dot create element verwenden und innerhalb der Gebärmutter muss
das DOM-Element bereitstellen , das
wir erstellen möchten. In unserem Fall ist es ein nach diesem Boop möchte innen
verknüpft sein, um unseren Graphen zuzuweisen. Also schreiben wir einfach Link href gleich im Verweigerungsfall Ich
werde ihn von hier kopieren. Es wird HTTPS für ipsum.com sein. Und wir müssen auch Einblicke
geben, ein innerer Text, der ein Inhalt unseres Links
sein wird. diesem Grund punkten Lync inneren Text. Und hier weisen wir Text zu, der aus Lorem Ipsum
generiert wurde. Unser DOM-Element ist fertig. Jetzt müssen wir
es einfach am Ende unseres DOM setzen. Wir können hier einen
Dokumentpunktkörper schreiben, Dot Append Child. Und hier stellen wir nur
unser neues DOM-Element zur Verfügung. In diesem Fall wird es
am Ende unseres Körpers erscheinen. Schauen wir uns das an. Ich lade die Seite neu
und jetzt
haben wir am Ende Texte
von Lorem Ipsum generiert, und das ist ein Link und es
geht auf die richtige Seite.
27. Jede Sätze auf eine separate Linie aufteilen: Eine andere Aufgabe mit dem
DOM-Ereignis kann so sein. Teilen Sie jeden neuen Satz in eine separate Zeile
im Absatztext auf. Es kann davon ausgegangen werden, dass es sich um eine Reihe von Texten handelt, die mit einem Zeitraum
beendet wurden. Und tatsächlich haben wir genau den gleichen Text innerhalb des Absatzes, genau wie zuvor. Nun stellt sich die Frage, wie wir diese Aufgabe umsetzen
können? Und tatsächlich denken wir
vielleicht, okay, wir haben Periode, wir können sie
einfach nach Periode teilen. Probieren wir das mal aus. Zuallererst
möchte ich hier
unseren Absatz mit
Dokumentenabfrageselektor p finden , genau wie zuvor. Und jetzt können wir hier
Absatzpunkt schreiben innerHTML entspricht dem
Absatzpunkt InnerHTML. Wir wollen es mit Punkt teilen. Und lasst uns prüfen, was wir in diesem Fall haben
werden, nachdem wir es geteilt haben und wir
eine Reihe unserer Stärken haben, müssen
wir uns wieder daran anschließen. Aber in diesem Fall
wollen wir
zuerst Punkt hier setzen , weil wir uns von DOD
anschließen. Aber dann brauchen wir ein schließendes Tag für unser p und open Tag
für unser neues p. In diesem Fall
schreiben wir Absätze für jede einzelne Zeile und Join wird nicht
auf das letzte Element angewendet. Deshalb wollen
wir am Ende plus schreiben, und hier müssen wir
unseren zusätzlichen p schließen . Ich lade die
Seite neu und tatsächlich funktioniert sie aber
nur teilweise. Ja, es funktioniert für
die einfachen Sätze, aber es funktioniert nicht für die Sätze, in denen wir zwei oder drei Punkte
haben. Wie
Sie hier sehen können, haben
wir beispielsweise Linien mit
einem Punkt darauf. Und das ist genau das Problem,
denn hier teilen wir es nur um einen Punkt und das
ist falsch Button Summe, unsere Logik ist richtig. Wir können unsere
HTML-Elemente überprüfen, wie Sie sehen können, sie sind
korrekt eingewickelt, und dann schließen wir
unsere Liste p Hier. Es funktioniert, aber
durch einen Punkt aufgeteilt ist nicht unser Fall. Eigentlich kommen wir hier
zu regulären Ausdrücken. Und das ist ein Wissen,
das Sie
zumindest auf der grundlegenden Ebene lernen müssen , da Sie es in
vielen Fällen verwenden werden , wenn
Sie
zum Beispiel mit Strings arbeiten und versuchen, zu überprüfen
regulärer Ausdruck, ich empfehle Ihnen dringend, eine Website zu
verwenden, reg X.com. Es ist völlig kostenlos. Sie können andere Websites finden, aber hier ist es wirklich schön
zu sehen, was wir finden werden. Wie Sie hier sehen können, können Sie einen regulären Ausdruck
schreiben und hier können Sie den Text angeben
und überprüfen, wie er funktioniert. Auch hier auf der rechten Seite können
Sie einige Flags setzen, zum Beispiel multiline
global und so weiter. Wie Sie sehen können, ist dies
der reguläre Ausdruck , den wir schreiben möchten. Und wenn ich
auf den Symbolen schwebe, wird
es dir zeigen, was
genau wir hier machen. Dies ist der Anfang
des regulären Ausdrucks, und wir schließen den
regulären Ausdruck immer mit zwei Schrägstrichen ein. Dieser Schrägstrich am
Anfang und am Ende ist nur Anfang und Ende
des regulären Ausdrucks. Jetzt hier drinnen haben wir Punkt, aber dot ist ein spezielles Symbol
innerhalb des regulären Ausdrucks. Deshalb müssen wir
ihm mit dem Backslash entkommen. Wie Sie hier sehen können, entspricht dies nur einem Punktzeichen. Jetzt haben wir
eckige Klammern. Und wie Sie sehen können,
ist
alles in eckigen Klammern ein negierter Satz, was tatsächlich bedeutet, dass
dies nicht da sein darf. Dieses aktuelle Symbol ist
der Anfang unseres Sets. Und hier haben wir uns
Gedanken gemacht und Tag geöffnet. In diesem Fall suchen wir
nur nach einem einzigen Punkt, aber nicht nach mehreren Punkten. Das ist alles, was
wir hier sagen wollten. Und wie Sie hier in unserem
Code sehen können, funktioniert es richtig. Und jetzt haben wir diese Übereinstimmungen
nur mit einem einzigen Punkt, wie Sie hier sehen können, haben wir
drei Punkte, Button-Move. Der letzte Punkt wird überprüft, da wir nur an Punkt
interessiert
sind , wenn wir danach nicht
den zweiten Punkt haben. diesem Grund können wir
diesen regulären Ausdruck kopieren und einfügen und ihn
einfach in unseren Split einfügen. Hier muss ich am Anfang und am
Ende einen Schrägstrich schreiben. Und das ist unser
regulärer Ausdruck. Und ich
verstehe vollkommen, wenn Sie kein 100%
bekommen, was ich hier mache, denn Sie müssen zuerst
einige Grundlagen regulärer
Ausdrücke lernen . Aber sie sind extrem wichtig wenn Sie
mit Strings arbeiten. Lassen Sie uns nun prüfen, ob
dieser Code funktioniert. Hier. Ich springe
auf die Seite, die ich neu lade, und jetzt funktioniert es richtig. Wir haben unsere Trennung gemacht. Und hier sind zum Beispiel noch
drei Punkte vorhanden und dies ist der einzige Satz. Und wenn wir einen One-Shot haben, betrachten wir einfach die Trennung und dann verschieben wir diesen
Text in die nächste Zeile. Und tatsächlich
liegt das Wissen über
reguläre Ausdrücke ein wenig
außerhalb von JavaScript, aber Sie werden es immer noch oft verwenden. Aber auch wenn Sie
diese regulären Ausdrücke lernen, können
Sie sie in
jeder einzelnen Sprache verwenden. Weil
es in allen Sprachen genau das Gleiche ist.
28. Delegation der Veranstaltung: Möglicherweise erhalten Sie auch eine Frage
wie diese implementierte Klicken Sie
so schnell wie möglich auf das Element. Und wie Sie hier
in index.HTML sehen können, haben
wir ein solches Markup. Wir haben eine UL-Liste und drinnen haben
wir nur li-Elemente. In der Regel können Sie es anders
lösen. Hier haben wir zwei
typische Lösungen, aber eine ist viel
besser als eine andere. Was wir hier tun können, können
wir Dollarelemente mit
Dokument finden und hier
verwenden wir den Abfrageselektor all. Und hier, wie Sie in unserer index.HTML
sehen können, Lee mit Klassenelement. Hier finde ich unseren Artikel nach
Klasse und hier erhalten wir
eine Liste unserer Artikel. Danach können wir
diese Liste von DOM-Knoten durchlaufen. Und für jedes einzelne Element können
wir es einem Listener anhängen. Hier können wir
Items dot for rich schreiben. Hier haben wir unseren Artikel
, der ein DOM-Knoten ist. Und im Inneren können wir
item dot addEventListener schreiben. Hier haben wir unseren Clicker
und hier ist unser Handler. Was wir tun möchten, wenn
wir auf den Artikel klicken, zumindest einige Texte
zu unserem Artikel ausprobiert. Eigentlich
haben wir drinnen nur einen Wert. Deswegen können wir hier schreiben. Sie haben auf den Artikel geklickt und hier
können wir einfach einen inneren Text mit
Pluspunkt schreiben. Also haben wir zuerst
die Liste unserer
Artikel gefunden und dann für jedes einzelne Element in der Schleife
wurde ein Ereignis-Listener hinzugefügt. Schauen wir uns das mal an. Ich lade die Seite neu. Wir sehen unsere Artikelliste. Jetzt klicken wir auf ein
Element und wir erhalten ein nettes Konsolenprotokoll mit
dem Inhalt dieses Elements. Wir klicken auf ein anderes Ende, wir bekommen ein Konsolenprotokoll und tatsächlich funktioniert es
und es ist alles in Ordnung, aber wir haben die Aufgabe,
es so schnell wie möglich zu erstellen. Und eigentlich
ist das Problem hier , wenn wir eine super riesige Liste haben, dann ist es nicht performant genug. Denn eigentlich haben
wir hier für jeden, für alle unsere Artikel, was bedeutet, dass wir
hier eine Liste von einhundert,
zehnhundert Gegenständen haben , in denen hier
einhundertzehnhundert Zuhörer
hinzugefügt werden. Und das ist super schlecht
für unsere Leistung. diesem Grund ist dies nicht die
beste Lösung für unsere Aufgabe. Was wir tun können, können wir
den Elternteil oder für unsere Liste finden. Und wie Sie hier sehen können,
haben wir UL mit der Klasse Todo App. Hier finden
wir das App-Element und wir können hier
das Dokument QuerySelector verwenden, und wir werden wissen, dass die
Klasse aus der App ist. Jetzt können wir im Inneren
nur einen einzigen Listener
für unser App-Element anhängen . Also AB addEventListener. Hier haben wir unseren Klick und
hier ist unser Hören. Und dann genau hier Veranstaltung, also haben wir Zugang zu unserer Veranstaltung. Und was wir im Inneren machen
wollen, wollen
wir überprüfen, auf welches
Element wir abzielen. Weil wir hier auf
unseren Container klicken können oder auf einen
beliebigen Artikel im Inneren klicken und tatsächlich sehr daran interessiert sind, auf den Artikel zu
klicken. Deshalb können
wir hier ein K schreiben
Wenn wir hier ein Ereignisziel haben,
was bedeutet, dass wir geklickt haben und
wir hier überprüfen möchten, ob unsere Event-Ladung
eine Klasse des Artikels hat, dann bedeutet dies, dass
wir unsere LEA erhitzt haben. Deshalb können
wir es hier versuchen, sogar Punktklassenliste zu
berühren. Hier enthält die eigentliche
Klassenlisteneigenschaft innerhalb des Knotens hat eine Funktion enthält, um zu überprüfen, ob
wir eine solche Klasse haben. Falls wir prüfen, ob
wir auf unseren Artikel geklickt haben. Wenn dies geschehen ist,
können wir
unsere
Konsolensperre hier kopieren unsere
Konsolensperre hier und
einfach ein wenig ändern. Wir verlassen hier unsere Saite. Sie haben hier
anstelle von item.name in einem Text auf das Element geklickt, wir können den
Zielpunkttext des Ereignispunkts schreiben, und es funktioniert
genauso. Schauen wir uns das mal an. Ich lade die Seite neu. Ich bin hier bei
einigen Gegenständen versteckt und wir
werden nett. Du hast geklickt. Und wenn wir irgendwo draußen
klicken, tut
es nichts. Der Hauptunterschied in
diesem Code ist jedoch viel schneller da wir hier
nur einen einzigen Listener
für unsere Eltern haben . Und wir generieren nicht Hunderttausende von
Zuhörern für jedes einzelne Element.
29. Xml HTTP-Anfrage: Vielleicht bekommst du ein Interview
die Frage, oder? Ein Beispiel für das Abrufen von Daten von API mit XML-HTTP-Anfrage. Und eigentlich ist das
eine super alte Frage. Und normalerweise
sollten die Leute
diese Frage heutzutage nicht stellen und Interviews, aber immer noch oft hier in dieser Frage sind,
weil manche Leute immer noch wissen
wollen, wie wir unseren Fetch
gelöst haben und Probleme vor zehn oder 15 Jahren. Die modernen Projekte,
Sie werden niemals die XML-HTTP-Anfrage nativ
verwenden. Deshalb macht es
keinen Sinn , diese Frage zu stellen, aber wir müssen
lernen, sie zu beantworten. Lassen Sie uns deshalb ein
Beispiel schreiben, wie es funktioniert. Zuallererst müssen wir unsere XHR-Anfrage
erstellen. Deshalb nennen wir
Sie also XML-HTTP-Anfrage. Jetzt haben wir eine Instanz
unserer XML-HTTP-Anfrage und wir können sagen, welche Methode wir senden
möchten und auf welche URL. Deshalb haben wir Recht
und XC Chair dot open. Und wie Sie hier sehen können, haben
wir zwei Parameter. Zuallererst ist es die Methode. Hier möchten wir GED schreiben , weil wir
eine GET-Anfrage stellen. Und hier ist unsere API-URL und
ich werde hier und die
API-URL von Github comm einfügen , um
alle Repositorys
dieses spezifischen Benutzers abzurufen . Danach sind wir mit
XHR-Punkt-CN und runden Klammern richtig. Aber es ist noch nicht alles. Wir müssen auch angeben, was bei Erfolg und Irrtum
passieren wird . Und dafür
schreiben wir XHR-Punkt auf Lord. Und hier müssen wir eine Funktion
zuweisen. Und in dieser
Funktion möchten
Sie zunächst überprüfen, welchen
Status wir zurückerhalten. Also können wir hier schreiben,
wenn das xy-Diagramm dieser Status nicht gleich 200 ist, was bedeutet, dass er
nicht erfolgreich ist, dann möchten wir einen Fehler
trösten. Ich möchte
hier zum Beispiel Pfeil zuletzt und vielleicht
XHR-Statusglas und hier XHR-Statustext schreiben. In diesem Fall
können wir direkt sehen, welches Problem wir
im anderen Fall haben ,
wo wir Erfolg haben. Also hier werden wir den Erfolg des
Konsolenprotokolls schreiben. Und danach
lesen wir unsere XHR-Punkt-Antwort, in der wir
unsere Antwort haben und wir werden
auch nach
dem Fehler in
XY-Chart-Anfragen suchen wollen . Hier können wir also
xy-Chart-Punkt auf Fehler schreiben. Und nur um Sie daran zu erinnern, alles Kleinbuchstaben ist und wir erhalten hier eine Funktion. Und im Inneren können wir zum Beispiel
schreiben, dass die Anfrage zur zusätzlichen
Gebühr des
Konsolenprotokolls fehlgeschlagen ist. Auf diese Weise
definieren Sie normalerweise die XHR-Funktion. Zunächst erstellen wir eine
Instanz der XML-HTTP-Anfrage. Dann machen wir ein Open
mit unserer Methode und URL. Dann bekommen wir Sand, und dann haben wir Onload-Funktion
und Fehlerfunktion, um sowohl falsche Status
als auch einen Pfeil mit einer Anfrage zu behandeln . Jetzt lasst uns prüfen, ob es funktioniert. Ich springe in den Browser
und lade die Seite neu. Und wie Sie hier sehen können, erhalten
wir unsere Antwort
und wir erzielen unseren Konsolenprotokoll-Erfolg
auch in unserem Netzwerk.
Sie können sehen, dass wir
eine Anfrage Wrapper haben und
dies ist eine XHR-Anfrage. Und wie Sie sehen können, ist
dies unsere Vorschau. Dies ist unsere Antwort
aus dem Backend. Und das bedeutet, dass wir
unsere Abrufanfrage
mithilfe der XML-HTTP-Anfrage
erfolgreich implementiert haben.
30. Fetch API: Ein weiterer Abruf und
das Abrufen von Daten von API ist etwas
aktueller. Das
benutzen wir jeden Tag. Hier hast du eine Frage, oder? Ein Beispiel für das Abrufen von
Daten mit Fetch-API. He Pi ist eine moderne Möglichkeit, einige Daten von der API zu
laden. Und eigentlich habe ich hier keine XML-HTTP-Anfrage
entfernt. Sie können Code vergleichen, den wir vor zehn Jahren
geschrieben haben. Und jetzt können wir hier die
fetch-Funktion verwenden und wir
stellen nur eine Eingabe zur Verfügung und get ist standardmäßig die Methode in
fetch, was bedeutet, dass wir hier nur eine URL
angeben müssen. Der wichtigste Teil ist, dass Fetch uns ein Versprechen zurückgibt. Und das bedeutet, dass
wir dann hier verwenden
und fangen können , um einige Ergebnisse zu erzielen. Hier haben wir unsere Antwort, aber normalerweise möchten wir unsere Antwort auf JSON
umwandeln. In diesem Fall können wir diese Daten einfach im Kunden
verwenden. Hier wird er
auf cold res.json buchen, was eine asynchrone
Funktion ist und unsere
Reaktion auf JSON verändern
wird. Und danach
können wir sie noch einmal anrufen. Und hier erhalten wir unsere Daten. Jetzt können wir mit
diesen Daten arbeiten, zum Beispiel Erfolg des
Konsolenprotokolls,
und hier sind unsere Daten. Und wie Sie sehen können,
ist dieser Code viel kleiner und einfacher zu lesen als dieser alte Code
mit XML-HTTP-Anfrage. Und offensichtlich
haben wir hier auch
einen Fehler geschrieben und wir
wollen ihn auch hier behandeln. Deshalb
können wir hier einen Punktkäfig schreiben. Hier werden wir unsere Ära bekommen. Und jetzt können wir hier Konsolenprotokoll-Ära
schreiben. Und dies wird ausgelöst,
wenn wir einen Fehler haben. Lassen Sie uns jetzt prüfen, ob
dieser Code funktioniert, ich lade die Seite neu im
Browser und wie Sie sehen können, werden
wir erfolgreich. Hier ist unsere Antwort. Und wie Sie
innerhalb des Netzwerks sehen können, haben
wir unsere Stromschnellen
und der Typ wird abgerufen. Und hier ist unsere Antwort, was tatsächlich bedeutet, dass dieser Code genau gleich funktioniert, aber er basiert auf Versprechungen, was bedeutet, dass wir diesen Code
leicht mischen können, war jeder andere asynchron
operationen , die auf Räumlichkeiten basieren. Wenn Sie beispielsweise
zwei oder drei Quellen haben ,
wenn Sie
beispielsweise mehrere
Datenquellen haben, können
Sie diese einfach miteinander
kombinieren da sie alle auf Räumlichkeiten
basieren.
31. Grundlegende Rückrufnummer: Möglicherweise erhalten Sie eine andere
Frage zu einem synchronen
JavaScript. Schreiben Sie beispielsweise eine
asynchrone Funktion, die Kohlberg ausführt, nachdem asynchrone Aufgabe
beendet wurde. Und wenn Sie es in JavaScript nicht
wissen, verwenden
wir Callbacks
ziemlich oft. Und zuvor
vor Versprechen und dem einzigen Gewicht, das wir
Callback zum Abrufen von
Daten verwendet haben , auch jetzt ist Kohlberg eine sehr beliebte Art,
innerhalb der Anwendung zu arbeiten. Also wollten
wir zunächst eine Funktion schreiben, wollten
wir zunächst eine Funktion schreiben die einen
asynchronen Code ergibt. Und der einfachste
Weg, asynchronen
Code in
Javascript zu simulieren , ist die
Verwendung von setTimeout,
da zum Beispiel h und einige Daten aus
dem
Backend und es Zeit braucht. Deshalb
möchte ich hier
eine Sinc-Funktion erstellen und sie nennen sie
einfach eine Spüle, einen Ventilator. Und hier wollen wir unseren
Callback als Parameter erhalten. Und eigentlich
ist Callback nur eine Funktion. Der wichtigste
Teil ist jedoch, dass die asynchrone Funktion
nicht weiß, was Kohlberg ist. Es kann was auch immer sein, weil
wir es von außen nennen. Jetzt machen wir drinnen
einen asynchronen Code. Zum Beispiel
holen wir Daten von der API ab, oder in unserem Fall verwenden wir setTimeout, um dies zu simulieren. Und wir haben zum Beispiel das Timeout für zwei Sekunden festgelegt . Und dann buchen Sie am Ende
einen, um unseren Rückruf anzurufen. Hier
rufen wir diese Funktion einfach oder manchmal mit den Daten
als Ergebnis unserer API auf. Vielleicht können wir hier Kohlberg fertig
schreiben, und das ist unsere asynchrone
Funktion bereit. Wie wir
diese Funktion verwenden, haben wir gerade eine sinc-Funktion ausprobiert und wir stellen
unseren Rückruf im Inneren bereit. Dies ist eine Funktion, die am Ende innen
ausgeführt wird . diesem Grund können wir hier
sagen, dass wir
eine Funktion mit
Argumentnachricht erhalten . Das ist es, was wir von
unserer asynchronischen Funktion
zurückbekommen , hier können wir Konsolenprotokoll Kohlberg
und hier eine Komma-Nachricht
schreiben. Lasst uns prüfen, ob es funktioniert. Ich lade die Seite neu
und wie Sie sehen können, haben wir
jetzt nach
zwei Sekunden nichts mehr . Genau so funktionieren
Callbacks. Genau das
haben wir umgesetzt. Wir haben eine asynchrone
Funktion, die
Kohlberg ausführt , nachdem die asynchrone Aufgabe beendet
wurde. Und die zweite Frage
, die Sie hier bekommen könnten, welche Problemrückruflösung? Und eigentlich gibt es
zwei wichtige Punkte. Zunächst einmal
erlaubt Kohlberg,
einige synchrone Mitarbeiter zu bauen und auf das Ergebnis zu warten. Denn eigentlich stellen wir hier nur eine Funktion von außen zur Verfügung und sie wird
später und nicht sofort aufgerufen. Dies ist der Hauptzweck
des Kohlbergs. Und zweitens ist es
wichtig sich daran zu erinnern ,
dass
wir innerhalb unserer
asynchronen Funktion nicht wissen, was Kohlberg ist, deshalb können wir gemeinsam nutzbare Dinge
bauen. Dieser Colbert kann
in verschiedenen Fällen alles tun. beispielsweise auf einer Seite, Buchen Sie beispielsweise auf einer Seite, um Daten abzurufen und diese Daten
möglicherweise zu rendern. Und auf einer anderen Seite wollten
wir diese
Daten abrufen und
die Gesamtzahl der Beiträge
oder ähnliches berechnen . Was eigentlich bedeutet, dass Kohlberg eine generische Funktion
ist. diesem Grund können wir
unsere asynchrone
Funktion ohne
spezifische Implementierung
unseres Rückrufs einfach teilen unsere asynchrone
Funktion ohne .
32. Parallel Async Array: Hier ist ein weiteres Beispiel für
eine synchrone Frage, aber ein bisschen fortgeschrittener, wie Sie hier sehen können, haben
wir eine Frage. Führen Sie die angegebene Liste der
asynchronen Funktionen
parallel aus und geben Sie die Ergebnisse als Array an den Callback zurück. Wie Sie hier sehen können, haben wir
bereits drei Funktionen, und dies wird mit der Aufgabe gegeben. Jede Funktion hat also
hier im Callback
, der hier den 123
wichtigsten Teil zurückgibt, diese erste Funktion
ist drei Sekunden, dann zwei Sekunden, dann 1 Sekunde. Dann müssen wir die
Funktion als Sink Parallel schreiben. Wir sind drinnen, wo wir
ein Array
asynchroner Funktionen werfen ,
was bedeutet, dass jede einzelne
Funktion einen Callback hat. Und dann haben wir den zweiten
Parameter, den wir hier haben, EINEN Kohlberg für
eine Senke Parallele. Hier bekommen wir unser Ergebnis und wir melden uns hier an der Konsole an. Und wir müssen
in diesem Fall 123 bekommen, weil es
Ergebnisse oder Risse drucken muss, synchrone Funktion in der Reihenfolge, was bedeutet, dass wir drei Funktionen
parallel
ausführen und warten
damit alle von ihnen fertiggestellt werden können. Und danach haben wir die
richtige Reihenfolge der Ergebnisse, was bedeutet, dass
wir
Ergebnisse jeder
einzelnen Funktion erhalten . Und tatsächlich verwenden wir zum Beispiel
ziemlich viel
Parallelmode, weil
wir zum Beispiel drei verschiedene
Anfragen gleichzeitig abrufen und
dann alle Daten
an einem Ort abrufen und irgendwie zusammenführen möchten drei verschiedene
Anfragen gleichzeitig abrufen und . Das ist y. Lassen Sie uns diese Funktion jetzt erstellen, aber es ist nicht einfach und wir müssen uns wirklich überlegen,
was wir hier machen. Wir wollen eine
Sink-Parallelfunktion implementieren. Und eigentlich
bekommen wir hier zunächst ein Array unserer
asynchronen Funktionen. Also können wir
hier schreiben Ich sinc ufuncs. Und der zweite Parameter
ist unser Callback. Und was wichtig ist, dass dies ein
Kohlberg für eine Senkparallele ist, nicht für die spezifische
async-Funkfunktion. Zuallererst möchte
ich hier
ein Array erstellen, in
das wir unsere Ergebnisse bringen werden. Hier. Ich kann versuchen, Array zu resultieren. Hier möchten wir ein neues Array und
innerhalb einer
Sinc-Funktionen Punktlänge
schreiben . In diesem Fall sind wir
im leeren Array mit
drei Elementen vorbereitet . Und offensichtlich sind es
drei nur für unseren Fall. Und es kann eine beliebige Länge
unserer asynchronen Funktionen haben. Danach wollte ich einen Ergebniszähler
erstellen, und standardmäßig ist er 0 bis zur Länge unseres Arrays. Warum brauchen wir das? Weil tatsächlich jede einzelne asynchrone Funktion
in zufälliger Zeit beendet werden
kann und wir warten
müssen, bis all diese
Funktionen abgeschlossen sind. Dies bedeutet, dass wir
zählen müssen, wie viele Funktionen
bereits abgeschlossen sind , bis
wir reich an Länge sind. Das ist y hier lassen Sie uns unsere Ergebnisinhalte
erstellen. Und standardmäßig wird es 0 sein. Und jetzt wollen wir unsere
asynchronen Funktionen
durchlaufen . Also hier synchronisiere ich
Fonts dot für jeden, und sie
benutzen hier wirklich for-loop. Und wir erhalten Zugriff für jede einzelne
asynchrone Funktion. Und wir brauchen hier auch
einen Index, da wir die Ergebnisse auch
in der richtigen Reihenfolge speichern müssen . Jetzt müssen
wir für jeden unsere
asynchrone Funktion aufrufen. Am wichtigsten ist, dass wir
überhaupt nicht wissen , was diese
Funktion macht. Aber wir wissen, dass diese
Funktion einen Kohlberg bekommt. Deshalb können wir hier unseren Rückruf
schreiben. Wir rufen eine sinc-Funktion
ohne Argumente auf. Und im Inneren
wird uns unser Doppelpunkt zur Verfügung gestellt. Wenn dieses Codebook ausgelöst wird, bedeutet
dies, dass wir mit unserer
asynchronen Funktion
bereit sind . Und jetzt wollen wir das
Ergebnis in unser Array schreiben. Dies ist der Punkt, an dem
wir unseren Rückrufwert erreichen. Und wie Sie hier bei jedem
einzelnen Rückruf sehen können, erhalten
wir einen Wert. Und genau das ist
der Wert, den wir hier in unserem Rückruf
erhalten. Jetzt möchten wir
diesen Wert in
unserem Ergebnis-Array speichern . Hier können wir
Ergebnis-Array schreiben und hier wird unser Index gleich Wert sein. Nur um Sie daran zu erinnern, wir
haben unseren Index hier. diesem Grund werden wir wissen
, dass wir es richtig gespeichert haben. Zum Beispiel ist dies
die dritte Funktion und sie wird zuerst ausgelöst, dann schreiben wir sie
auf das Indexgrab. Danach müssen wir unseren
Ergebniszähler
erhöhen , um zu wissen, dass eine
der Funktionen ausgeführt wird. Und zu guter Letzt wollen
wir hier prüfen, ob diese
Funktion die letzte war. Hier können wir prüfen, ob unser
Ergebniszähler größer oder
gleich ein Sink-Ufuncs ist, dann wollen wir unseren
Kohlberg für eine Senke Parallele nennen. Hier können wir also einfach Callback
schreiben und im Inneren stellen wir
unser Ergebnis-Array zur Verfügung. Wieder einmal, was wir hier
machen,
haben wir zunächst ein leeres
Array und unseren Zähler vorbereitet. Wir durchlaufen unsere asynchronen Funktionen
und rufen jede einzelne Funktion auf, die hier in jeder
Funktion bereitgestellt
wurde, einen Callback. Wenn wir Erfolg haben, speichern
wir zunächst unser Ergebnis
im Ergebnisindex und erhöhen dann
unseren Zähler. In diesem Fall wissen wir, dass diese Logik
uns Kohlberg für eine
Senkenparallele zurückgeben wird , wenn wir bereit sind und wenn alle unsere Funktionen abgeschlossen
sind. Hier rufen wir unser Ergebnis-Array mit
Codebook-Breite auf. Jetzt müssen wir
diese Funktion tatsächlich vor unserem
Aufruf einer Senke parallel verschieben , weil wir sie mit const
schreiben müssen. Und lasst uns prüfen, ob es funktioniert. Ich lade die Seite neu
und wir erhalten eine Zuweisung zu einer
konstanten Variablen. Schauen wir uns das an.
Ja, wie Sie sehen können, kann
ein Ergebniszähler
erhöht werden ,
da er const ist. Hier. Wir können LED schreiben und
dann sollte es funktionieren. Schauen wir uns das an. Ich lade die Seite neu. Wir haben keine Fehler. Jetzt vergehen drei Sekunden und wir bekommen unser
Array mit 123, was eigentlich bedeutet, dass
hier eine Senke Parallele ist, die darauf
wartet, dass jede einzelne asynchrone Funktion
abgeschlossen wird und dann regenerieren als Kohlberg unser Ergebnis
hier und jetzt können wir hier unser Array in
der richtigen Reihenfolge
verwenden. Und das ist völlig
in Ordnung, wenn
Sie diese Funktion nicht schnell erstellen können. Am wichtigsten ist, dass Sie, wenn Sie es in einem Interview
tun, immer unsere Cloud sagen müssen, was Sie tun und
wie Sie denken. Weil normalerweise ein Interview
es nicht so wichtig ist. Wenn Sie diese
Aufgabe vollständig lösen oder nicht, müssen
Sie Ihre
Denkweise zeigen und wie Sie
diese spezifische Aufgabe lösen möchten.
33. Konvertieren von Callback nach Promise: Möglicherweise erhalten Sie auch eine andere Frage zu
einem synchronen JavaScript. Hier müssen wir die
Prämise-Funktion erstellen, um die Callback-Funktion
über den Promise-Ansatz verwenden
zu können . Und eigentlich nur für Sie
, um vorher zu wissen, hatten
wir viele Callback-Funktionen weil wir keine Räumlichkeiten hatten. Nach einiger
Zeit in JavaScript haben wir zwei Räumlichkeiten migriert, und jetzt werden sie standardmäßig
in JavaScript unterstützt, was bedeutet,
dass wir keine Rückrufe mehr so oft
verwenden. Und wie Sie hier sehen können, haben
wir eine
Standard-Callback-Funktion bei der wir
davon ausgehen, dass es kalt ist, und wir gemeistert, diese Funktion
zu schreiben, um einen Ansatz zu versprechen
, der tatsächlich
bedeutet zum Beispiel, wir eine ältere Bibliothek verwenden die auf den Rückrufen basiert, aber der gesamte Code unseres
Projekts verwendet Räumlichkeiten. diesem Grund ist es
sehr sinnvoll,
einen Rapper zu machen und
diese Callback-Funktion
durch die Prämisse zu nutzen . Um dies zu tun,
müssen wir einen Thin erstellen der Promises phi Funktion genannt wird,
was tatsächlich
dieselbe Funktion bedeutet,
aber gewickelt und
verspricht was tatsächlich
dieselbe Funktion bedeutet . Wir können es von mir nennen, Sci-Fi, und das ist der typische Name
und hat eine Sinc-Funktion
freigesetzt, genau wie oben. Hier haben wir keine Argumente die wir unsere asynchrone Funktion
aufrufen möchten. Und wenn wir ein Codebook haben, möchten wir unseren
Rückruf von der Prämisse aus anrufen. Hier sind wir
Master Return und du versprechst es. Hier im Inneren
haben wir das Versprechen gelöst und abgelehnt, aber wir werden hier auf Lou
Resolve verwenden , weil wir hier keinen Fehler
haben. Jetzt können
wir innerhalb unserer Prämisse einfach
die reguläre asynchrone Funktion aufrufen und einen Rückruf hineinlegen. Und tatsächlich
wird uns dieser Rückruf einige Daten zurückgeben. Deshalb
schreibe ich Daten und wir wissen nicht einmal, über welche
Daten wir sprechen. Jetzt wollen wir einfach
die Resolve aufrufen und Insight-Daten von unserer
asynchronen Funktion
übergeben. In diesem Fall, wenn die
synchrone Funktion erledigt ist, wird unser Kohlberg stattfinden. Hier. Innerhalb von Kohlberg erhalten
wir Daten von einer synchronen
Funktion und arbeiten Doppelpunkt in Kohlberg für diese
von uns erstellte Prämisse
. Und am wichtigsten ist, dass diese Funktion ein Versprechen
zurückgibt. diesem Grund können wir es jetzt verwenden, wie diese Prämisse einer
hohen asynchronischen Funktion, wir nennen es einfach
End-Returns als Prämisse. Deswegen können wir hier schreiben. Dann erhalten wir
einige Ergebnisse und wir können zum Beispiel das Ergebnis des
Konsolenprotokolls machen. Wir verwenden diese Funktion
als Versprechen und wir haben
unsere sinc-Funktion in
Prämisse eingeschlossen unsere sinc-Funktion in , wenn phi,
Schauen wir uns das an. Ich lade die Seite neu
und wie Sie sehen können, bekommen
wir nach einiger Zeit
eine zurück. Denn hier haben wir ein Codebook mit 3 Tausend Millisekunden, was bedeutet, dass
wir unsere Daten
nach drei Sekunden erhalten und
dieser Code funktioniert. Und jetzt können
wir überall
in unserer Anwendung diese
Callback-Funktion als Versprechen verwenden Ansatz.
34. Kartendaten in Versprechen: Möglicherweise erhalten Sie
eine andere typische Aufgabe Daten mit Prämissen zuzuordnen. Wie Sie hier sehen können, haben
wir eine solche Funktion. Sie haben zwei Funktionen,
die Prämissen zurückgeben, Metadaten von Benutzern
und Benutzerstatus, um ein Array von Benutzern mit
AED-Namen zu erhalten und aktiv zu sein. Wie Sie hier sehen können, haben wir einen Array-Benutzer
mit einem D und einem Namen, und wir haben eine
sekundäre Benutzerstufen mit dem dN dt ist
aktive Eigenschaften. Und tatsächlich ist diese AD genau
das Gleiche wie ein D hier. Und genau das sind die
Daten, die wir abbilden müssen. Also müssen wir ein Array
mit einem DNS-Namen bekommen und ist aktiv. Der Hauptpunkt ist jedoch, dass diese Daten nicht schnell
verfügbar sind. Sie sind nur hier verfügbar um Benutzer zu
erhalten und Benutzerstatus zu erhalten. Wir haben zwei Funktionen,
die Versprechen sind, und normalerweise holen Sie
diese Daten von der API ab. diese Weise
werden Benutzer hier falsche Versprechen zurückgeben. diesem Grund
lösen wir eine Reihe von Benutzern hier und hier sind die
gleichen mit den Benutzerstatus,
was bedeutet, dass
wir zwei Prämissen haben. Wir müssen
sie lösen und kombinieren. Es gibt verschiedene
Möglichkeiten, diese Aufgabe zu lösen. Der
anfängerste Ansatz besteht darin, die erste Prämisse
und dann die nächste zu
holen. Probieren wir das mal aus. Jetzt. Wir können hier schreiben, um Benutzer zu bekommen, und das gibt uns eine Prämisse
zurück. Hier können
wir dann schreiben und wir holen
unsere Nutzer zurück. Danach möchten wir unsere GetUser-Status
abrufen. Hier rufen wir
GetUser-Status auf, und wir verwenden sie auch hier, und wir erhalten
unseren Benutzerstatus zurück. Und jetzt haben wir innerhalb dieser
Funktion Zugriff auf
Benutzerstatus und Benutzer. Denn hier werden wir
erst kommen , nachdem wir
beide gelöst haben, aber nicht parallel,
sondern eins nach dem anderen. Was wir hier tun können, können
wir Benutzer zuordnen, damit wir
beispielsweise zugeordnete Benutzer erstellen können. Und wir müssen
unsere Benutzer mit Map durchlaufen, wir haben Zugriff auf
jeden einzelnen Benutzer. Und jetzt müssen wir feststellen, dass dies eine aktive Eigenschaft ist, denn genau das
wollen wir in unser Array einfügen. Deshalb können wir hier
schreiben, dass const aktiv ist, und hier möchten wir
innerhalb der Benutzerstatus
unseren Status finden ,
hier sind wir richtig und finden den Benutzerstatus. Und hier müssen wir den Benutzerstatus
überprüfen. Punkt-ID entspricht unserer Benutzerpunkt-ID. Aber das wird
schneller zum Status zurückkehren und wir müssen versuchen, dass es
am Ende aktiv ist. In diesem Fall werden wir
auf das jeweilige Objekt einsteigen. Jetzt, nachdem wir unsere Führungskraft bekommen
haben, wollen wir es in
jedes einzelne Objekt stecken, aber wir werden hier keinen Push verwenden weil Sie sich daran erinnern, dass Sie sich schlecht schieben. Deshalb kehrt Google
einfacher hierher zurück und Sie widersprechen und wir sind hier
verbreitet. Alle Bereiche unseres Nutzers. Glas ist aktives Eigentum. In diesem Fall ist wir Putin aktives Eigentum in
jedem einzelnen Benutzer. Und danach können wir unsere zugeordneten Benutzer einfach
hier
konsolenprotokollieren und sie sind
für uns in unserer Anwendung verfügbar . Schauen wir uns das an. Ich lade die Seite neu und
wir werden getroffen User. Und wie Sie sehen können, ist
dies ein Array mit drei Objekten, ID, Name drei Objekten, ID, Name
und aktiv, was
tatsächlich bedeutet, dass wir diese Aufgabe erfolgreich lösen. Aber es gibt ziemlich
viele Probleme in diesem Code. Zuallererst haben wir zwei verschiedene Prämissen und sie sind nicht voneinander abhängig,
was bedeutet, dass es keinen Sinn
macht, auf die
erste Prämisse zu warten , und Don wird
dann eine zweite Prämisse machen. Wir müssen
sie tatsächlich parallel machen. In anderen Fällen ist es zu langsam. Also möchte ich hier schreiben
, dass dies
eine Lösung ist und sie unsere erste Lösung
kommentieren möchten. Versuchen wir es nun mit der
zweiten Lösung. Für die zweite Lösung können
wir Prämisse verwenden, wenn Sie nicht
wissen, was seine Prämisse ist. Genau
das hilft uns mehrere
Räumlichkeiten parallel
zu erledigen. Wir können hier schreiben versprechen Punkt o, und wir müssen eine Reihe
von Räumlichkeiten im Inneren passieren. Hier haben wir ein Array
und wir können hier schreiben, Benutzer
abrufen und dann Komma, Benutzerstatus
abrufen. In diesem Fall werfen wir in die Prämisse alle Array
mit unseren beiden Räumlichkeiten. Und nach Prämisse
am Ende können
wir es einfach ausprobieren, dann erhalten
wir hier unser
Ergebnis als Array, aber es ist nicht sehr angenehm, hier mit Array
zu arbeiten. diesem Grund können wir
hier unser Array
direkt auf
unsere beiden Eigenschaften destrukturieren . Hier bekommen wir unsere Benutzer und hier erhalten wir
unseren Benutzerstatus. Und danach
können wir unsere Logik machen, die wir hier
mit einem zugeordneten Benutzer gemacht haben. diesem Grund werde ich diesen
Code schneiden, der Benutzer zugeordnet wurde, und lege ihn
einfach hier rein weil er
genau gleich bleibt. Hier haben wir Zugriff auf unsere Benutzer und unseren Benutzerstatus SES, und wir ordnen sie zu und
protokollieren sie hier. Schauen wir uns das an. Ich lade die Seite neu und wir erhalten genau die
gleiche Antwort zurück. Der Hauptpunkt ist hier,
dass wir alle versprochen haben. Das ist viel besser
, weil
wir in diesem Fall diese beiden
Anfragen parallel stellen. Auch, wie Sie sehen können,
die Lösung für, aber haben Sie nicht diese schlechte
Böse mit dann und dann, und hier haben wir nur eine
einzige, dann ist dies offensichtlich besser, weil wir diesen tief verschachtelten Code
vermeiden wollen, aber wir können diesen
Code noch besser machen. Wie Sie sehen können,
haben wir diese Karte Benutzer und wir können
diesen Code tatsächlich außerhalb unseres
Then verschieben diesen Code tatsächlich außerhalb unseres , nur um
ihn lesbarer zu machen. Hier können wir
zusätzliche Funktionen erstellen, bevor zum Beispiel Benutzer zuordnen. Und wir wissen, dass
wir
unsere Benutzer- und Benutzerstatus hierher bekommen . Und tatsächlich ist das eine
völlig reine Funktion , die unsere Benutzer einfach abbilden wird. Also kann ich diesen Code schneiden
und ihn hier hineinlegen. Hier
brauchen wir unsere Konstante nicht. Wir können unsere Karte direkt zurückgeben. Und tatsächlich wird dieser Code
genau derselbe sein , wie
wir ihn zuvor benutzt haben. Und was wir hier tun können, können
wir einfach zugeordnete Benutzer erstellen. Und hier signieren wir
Kartenbenutzer und geben den Status unserer Benutzer
und Benutzer weiter. Wie Sie jetzt sehen können, ist dieser
Code noch besser zu
lesen, denn hier
haben wir einfach alle Prämisse. Dann ordnen wir
unseren Benutzern zusätzliche Funktionen zu und
arbeiten daran, logan sie. Schauen wir uns das an, wie
Sie hier sehen können, genau die gleiche Antwort. Und tatsächlich können wir
diese Funktion noch
ein bisschen mehr verbessern , wie Sie sehen können,
wo ich
Benutzer in- und auswendig mit ihnen zuordne . Aber tatsächlich können wir unseren Tanz
verketten, was
eigentlich bedeutet, dass wir
unsere Karte vielleicht
direkt an die Nutzer zurückgeben möchten . Also unser erstes, dann
treffen wir uns einfach mit den Benutzern
und geben sie hierher zurück. Und nach diesem Wochenende richtig One more als, und hier werden wir
unsere zugeordneten Benutzer haben, und hier
wollen wir mit ihnen arbeiten. Also hier werde ich unsere zugeordneten Benutzer
konsolenprotokollieren. In diesem Fall teilen wir zwei verschiedene Dance Mapping
der Benutzer auf und
arbeiten erfolgreich. Und tatsächlich hier mit einfacherem
Konsolenprotokoll unsere Benutzer, was bedeutet, dass dies unser Erfolg ist. Und wir können sogar die Rückkehr von
hier
entfernen und dies
als eine einzige Zeile schreiben, in diesem Fall wird es noch lesbarer
sein. Ich würde sagen, dass dieser Code so trocken wie möglich
ist. Wenn Sie also zeigen möchten , dass Sie ein
fortgeschrittener Entwickler sind, müssen
Sie Ihren
Code schreiben und versuchen, ihn so
oft wie möglich zu verbessern.
35. Mapping-Daten in Async Await neu schreiben: Die nächste asynchrone Frage in JavaScript wird sicher sein, dass ein Hilfssinken hier tatsächlich die
vorherige Übung meistern
wird,
wie das Mappen von die
vorherige Übung meistern
wird,
wie das Benutzern mit zwei Räumlichkeiten in einer Spüle,
einer Gewichtsfunktion, wie Sie hier sehen können, haben wir Benutzerstatus
und zwei Funktionen
unserer Benutzer, holen Benutzer und erhalten Benutzerräume. Und tatsächlich
bezweifle ich an unserem vorherigen Code, damit wir Teile davon kopieren können. Das erste, was
wir hier tun müssen ist eine zusätzliche Funktion zu erstellen. Warum ist das so? Weil Sie
es nicht erlauben, einen einfacheren Weg
direkt in den Stammteil der JavaScript-Datei
**** zu schreiben direkt in den Stammteil der .
Das ist y hier. Zuallererst müssen wir
etwas wie Benutzer
erstellen, vielleicht weil wir es zu
einer asynchronen Funktion machen wollen. Hier
verwenden wir unser async-Keyword. Hier drin erstellen wir
unsere Funktion. Und dieses angenommene Keyword ermöglicht es uns,
ein Gewicht im Inneren zu verwenden. Aber wir wollen
jetzt tun, dass wir den Status der Endbenutzer
unserer Benutzer erhalten möchten. Hier kann ich einfach Benutzer schreiben. Vergiss dieses Gewicht hier nicht. Wir versuchen nur, Nutzer zu gewinnen. Und wenn Sie hier ein Gewicht vergessen, werden wir hier unsere Benutzer nicht
bekommen, aber Sie werden hier eine Prämisse bekommen. Und das ist nicht das, was wir wollen. Wir wollen unsere Prämisse lösen. Die nächste Zeile hier
wird der Benutzerstatus sein, und hier möchten
wir den Status nutzen. Und wie Sie sehen können, ist
dieser Code offensichtlich viel, viel einfacher zu lesen,
weil wir keine haben, dann
haben wir nicht alle Prämisse. Es sieht so aus, als wäre es
einfacher
synchroner Code , da die Zeilen nacheinander
ausgeführt werden. Und danach möchten
wir unser Mapping tatsächlich kopieren, einfügen und hier ablegen, weil wir
es nicht ändern und es
keinen Sinn macht ,
zusätzliche Funktionen zu erstellen. Weil
wir innerhalb dieser Funktion nur zwei Zeilen haben. diesem Grund können wir hier const Mapping-Benutzer
schreiben. Hier weisen wir den
Benutzern eine Punktkarte zu und
machen genau das gleiche wie im vorherigen Video. Nach der dritten Zeile haben
wir bereits unsere Kartendaten. Hier können wir die
Konsolenprotokollzuordnung an Benutzer schreiben. Und hier können wir
unsere zugeordneten Benutzer überprüfen, müssen
aber auch irgendwo
unsere Funktion „Get-Mapped Users“ aufrufen . Wir müssen
hier kein Gewicht oder so schreiben weil wir einfach eine
asynchrone Funktion aufrufen. Jetzt lade ich diese Seite neu. Wie Sie sehen können,
erhalten wir zugeordnete Benutzer. Und das ist unsere Antwort, was tatsächlich bedeutet, dass dieser
Code korrekt funktioniert. Und dieser Code sieht
super lesbar aus, weil wir hier ein einziges Gewicht
verwendet haben , das nicht ausreicht, aber
unseren Byte-Code immer als Try-Catch umwickeln möchten. Warum ist das so? Denn wenn
wir hier einen Fehler bekommen, werden wir ihn nie sehen. Wir werden einen Fehler haben
und die Prämisse bekommen. Deshalb möchten wir hier am Anfang schreiben, versuchen Sie am Ende nach unserem Konsolenprotokollgutschein, um ihn zu
schließen und ihn hier zu trocknen, Käfig und hier bekommen wir
unseren Fehler in unserem Bargeld. Wir möchten so etwas
wie Konsolenprotokoll Azure schreiben. Und hier ist ein Fehler
, den wir bekommen können. In diesem Fall sind wir auf der
sicheren Seite und wir werden wissen, ob ein asynchroner Code hier nicht
funktioniert oder wir einige Fehler
bekommen, wir werden dann einen
Fehler hier in Catch werfen. Schauen wir uns das mal an. Unser
Code funktioniert immer noch und wir verwenden
erfolgreich
das einzigartige Gewicht nach rechts sind
Versprechen damit.
36. Sie Müssen Richtige Vokabeln Verwenden: Eine weitere wichtige Sache
, an die man sich erinnern sollte, ist ziemlich schwierig und die Leute
sprechen nicht viel darüber. Und ich spreche hier von
deinem Programmiervokabular. Was ich damit meine,
gibt es tatsächlich viele Wörter, die Sie verwenden
können, wenn Sie über Programmierung
sprechen. So versteht man dich
besser oder zumindest richtig, und du solltest sie nicht mischen. Es gibt einen Anfang. Es könnte wirklich schwierig
für Sie sein , weil Sie
all diese Begriffe nicht kennen oder sich
nicht wirklich sicher sind , was
Sie sagen möchten, aber Sie müssen es im Hinterkopf behalten und versuchen, sich mit der Zeit zu verbessern. Zum Beispiel musst du wirklich verstehen,
was du sagst. Zum Beispiel habe ich eine Funktion
gezeigt oder eine Methode
in meiner Klasse erstellt. Dies ist eine Instanz
der Klasse. Sie müssen alle diese Begriffe
korrekt verwenden , wenn Sie eine Funktion sehen, diese Methode
aber aufrufen oder
sie vielleicht etwas anderes nennen. Das ist nicht richtig. Und dann bekommst du viele zusätzliche Fragen oder du wirst als schlechter Entwickler angesehen. willst du natürlich nicht. Deshalb
müssen Sie ein
wenig überlegen , welche Wörter Sie verwenden, und versuchen, sie
richtig zu verwenden, wenn Sie einige
Programmiersachen
beschreiben.
37. Projektleiter: Hier ist eine weitere
synchrone Aufgabe, die etwas komplex ist. Du brauchst also etwas
Zeit, um es zu lösen. Und du kannst
es nicht wirklich lösen wie in drei
oder fünf Minuten. Wie Sie hier sehen können,
müssen wir ein Dienstprogramm entwerfen das eine URL und
den Wert für Versuche annimmt, die versuchen, eine Abrufanforderung zu
stellen. Wenn wir einen Fehler haben, wird diese Funktion
erneut versuchen, einige Daten
mit zunehmender Verzögerung abzurufen , um die
Anzahl der
Benutzer angefordert hat. Das bedeutet eigentlich, dass wir eine Funktion
erstellen müssen , die
eine bestimmte URL abruft , die wir
bereitstellen werden , und auch
einige Versuche hat. Und wir möchten
diese Daten immer wieder aktualisieren wenn wir
keine Erfolgsmeldung erhalten haben. Und tatsächlich ist dies ein
wirklich häufiges Problem da unsere API
manchmal nicht funktioniert oder Daten nicht
vorhanden sind und wir es erneut
versuchen möchten. Versuchen wir,
diese Funktion zu erstellen und sie möchten sie benennen, zum Beispiel den Anforderungsmanager. Und tatsächlich
bekommen wir hier unsere URL, weil wir etwas von
außen holen
wollen und jedes
Mal etwas Neues. Und hier haben wir einige
Optionen für unsere URL. Und der letzte Parameter
werden Versuche sein. Und standardmäßig können es zum Beispiel drei
sein. Also versuchen wir dreimal,
ein paar Mitarbeiter aufzufrischen. So werden wir das benutzen. Also haben wir hier Anforderungsmanager und erhielten eine URL. Sie werden hier eine
URL verwenden, die nicht existiert. In diesem Fall
werden wir es aktualisieren. Wir haben foo.com und diese Funktion muss eine schnellere Prämisse
zurückgeben, hier haben
wir
hier, dann haben wir Erfolg und Irrtum. Hier warten
wir hier Antwort und wir können es
einfach ausprobieren Konsolenprotokoll, zum Beispiel eine Antwort, um zu
überprüfen, ob es funktioniert. Auf diese Weise werden wir diese Funktion
normalerweise verwenden. Wir wollen eine URL abrufen
und wir haben sie einfach. Und offensichtlich
können wir hier einige Optionen bestehen. Zum Beispiel Method
Post und jemand
oder eine Menge Versuche, wenn
wir es ändern wollten, wenn wir nichts bestanden haben, dann
haben wir hier keine Optionen und unser Versuch ist drei. Jetzt ist die Frage, was
wir hierher zurückkehren wollen? Der wichtigste Punkt, um zu verstehen, wie wir es bauen werden. Wir werden diese Funktion
rekursiv ausführen, da dies die einfachste Möglichkeit ist,
diese Funktion mehrmals aufzurufen , wir
den Cage Request
Manager hier erneut aufrufen werden . Und wir werden hier einfach
URL-Optionen
angeben und dann Versuche, wir verringern werden, was bedeutet dass
wir am Anfang drei Versuche haben. Jetzt
werden es das nächste Mal zwei sein, dann eins, und dann werden wir
einen Fehler auslösen, weil wir keine
verbleibenden Versuche haben. Zunächst müssen wir also
ein Versprechen zurückgeben , denn
genau das warten wir draußen. Und hier
kehren wir zurück, versprochen, und hier haben wir unsere
Entschlossenheit und lehnen ab. Jetzt möchten
wir innerhalb dieser Funktion versuchen, unsere Daten
abzurufen, und wir werden
hier einfach die Abholfunktion verwenden da sie
für uns nativ verfügbar ist. Im Inneren geben wir
zuerst unsere URL und zweitens die Optionen weiter. Und jetzt haben wir unsere,
dann haben wir Fang und tatsächlich weiter dann können wir einfach unsere Entschlossenheit
nennen. Dies wird die
Erfolgsdaten direkt in Resolve übergeben, da Resolve eine Funktion ist. Hier. Wir wollen auch einen Fang. Hier im Käfig. Wir wollen unsere Matrix machen. Also hier erhalten wir
unseren Fehler und möchten unseren
Anforderungsmanager erneut anrufen. Aber hier müssen wir wissen, wann
ich es versuchen werde, der letzte ist. Also hier möchte ich eine
Eigenschaft erstellen ist der letzte Versuch. Und hier können wir einfach prüfen,
ob unser Versuch einem entspricht. In diesem Fall
werden wir wissen, okay, dies ist das letzte Mal, dass wir unser Anforderungsmanagement anrufen
können. Und danach prüfen wir,
ob dies ein letzter Versuch ist, dann wollen wir den Ablehnungspfeil
zurückgeben, was tatsächlich bedeutet, dass
wir
unsere Prämisse nur ablehnen , weil wir nach diesem EQ nicht mehr
weitermachen können , weil wir nach diesem EQ nicht mehr
weitermachen aber habe keinen letzten Versuch 0s, dann wollen wir
setTimeout machen, weil
wir diese
Funktion tatsächlich nach einiger Zeit aufrufen möchten. Es macht keinen Sinn
, es direkt danach aufzurufen, da die API vielleicht noch ausgefallen ist. Hier. Ich schreibe zum Beispiel setTimeout mit drei Sekunden. Und natürlich können wir auch ein Argument
implementieren um das Intervall für den Aufruf von Daten
zu übergeben. Innerhalb von setTimeout
möchten wir unsere Daten erneut anfordern. Also hier rufen wir den
Anforderungsmanager an und geben hier
URL-Optionen weiter. Und der letzte wird Versuche minus eins
sein,
was bedeutet, dass wir nirgends Versuche
beginnen. Wir stellen einfach rekursiv im Request-Manager eine
verringerte Anzahl von Versuchen zur Verfügung. Das ist y hier beim
ersten Mal drei, dann kommen wir
hier in setTimeout. Es ist zu eins. Und dann überprüfen wir, dass dieser
Versuch gleich eins ist und wir sind hier in dieser IV
und wir lehnen ihn ab. Also lasst uns prüfen, ob es funktioniert. Ich lade den Browser neu. Und wie Sie sehen können, erhalten
wir einen Pfeil und einen Pfeil, weil diese
URL nicht existiert und wir Versuche
erhalten, die nicht in
Zeile 13 innerhalb unseres eingestellten Timeouts definiert sind. Und eigentlich stimmt der Name
des Arguments hier nicht. Es ist kein Versuch, sondern Versuche, weil wir mehrere von ihnen
haben. Und auch hier sollten
Versuche gleich eins sein und nicht versuchen. Lasst es uns nochmal neu laden. Wie du siehst,
kriegen wir Header. Nach drei
Sekunden bekommen wir diese Anfrage wieder, weil wir es immer wieder versuchen. Hier haben wir den uncaught
Fehler nicht abgerufen, was eigentlich bedeutet, dass wir hier nicht nur sie,
sondern auch Cache schreiben
müssen , da wir
hier
einen Fehler erhalten , wenn wir keine Daten abrufen können. Und hier können wir
es einfach versuchen, den Konsolenprotokollfehler. Und hier
wollen wir unseren Fehler sehen. Aber wie Sie sehen können, erhalten wir immer noch ein fehlerhaftes
Paar vom Typ, das nicht abgeschlossen wurde, was bedeutet, dass unser Code nicht 100% korrekt
ist. Und tatsächlich ist das Problem hier , dass dies unser erster Aufruf des
Anforderungsmanagers ist und wir es dann draußen
bearbeiten und fangen. Aber hier stattdessen setTimeout haben
wir einen Anforderungsmanager, aber wir haben dann nicht und fangen das ist der Grund, warum
es kaputt geht. Wir haben einen Fehler
in unserer dritten Kohle, und dies ist hier, aber wir haben nicht angegeben, was damit
passieren wird. Das ist was hier,
Boom, schreiben muss. Dann wollen wir es hier mit Daten
lösen und auch Bargeld fangen, das
wir einfach ablehnen wollen. In diesem Fall
funktioniert es richtig. Probieren wir das mal aus. Ich lade die Seite neu. Wir bekommen
Fehler und jetzt ist unser Fehler draußen
sprudelt und wir sehen, dass
TypeError nicht abgerufen werden konnte. In diesem Fall
funktioniert es richtig. Sie sollten nicht vergessen,
unseren inneren Anforderungsmanager dann
draußen zu blasen und zu fangen. Ich kann also sagen, dass diese Funktion ziemlich kompliziert
ist. Wenn Sie also
so etwas im Interview erhalten, müssen
Sie sich wirklich
Zeit nehmen, es richtig zu lösen. Sie können eine
solche Funktion nicht wirklich in
wenigen Minuten entwerfen .
38. Shallow Vergleich implementieren: Möglicherweise erhalten Sie auch eine
Frage zur Gleichheit oder zum Vergleich
in JavaScript. Und wie Sie hier sehen können, haben
wir eine Frage, Designer flache
Vergleichsfunktion. Dafür müssen Sie
den Unterschied des
JavaScript-Vergleichs kennen , der ein nativer, flacher
Vergleich und ein tiefer Vergleich ist. In JavaScript können wir
einfach eins gleich zwei schreiben. Wir werden falsch.
Eins ist gleich eins ist wahr. Das funktioniert, weil
wir Primitive vergleichen. Aber wenn wir hier ein Gleiches
vergleichen und hier
ein Objekt ist , das gleich eins ist,
werden wir falsch. Das liegt daran, dass wir solche Objekte in
JavaScript nicht
vergleichen können solche Objekte in
JavaScript nicht
vergleichen , weil
sie auf
verschiedene Objekte
im Speicher verweisen . Und Sie haben genau das
gleiche Problem mit Array. Leeres Array
entspricht nicht dem leeren Array. Ja, wir können verstehen, warum
es so funktioniert, aber es ist nicht
bequem, da Entwickler
normalerweise
Arrays und Objekte nach Werten vergleichen
möchten und keinen Bezug auf das
Objekt im Speicher mögen. diesem Grund haben wir
flache Vergleichs - und tiefe Vergleichsfunktionen. Die Idee ist also, dass ein flacher Vergleich schneller ist
als ein tiefer Vergleich, aber Probleme beim
Vergleich von Objekten oder Arrays beheben wird . Es wird nur nicht
verschachtelte Arrays beheben, sind Objekte, was bedeutet, wenn
wir mit flachem Vergleich ein
vergleichen, und hier haben wir ein Objekt mit B1 und hier B1, wir werden immer noch eine falsche Antwort bekommen auch bei flacher
Vergleichsfunktion. Dies ist völlig normal,
da
wir in diesem Fall jeden verschachtelten Wert vergleichen wollen und dann einen
tiefen Vergleich verwenden müssen. Und ein tiefer Vergleich ist extrem langsam, weil wir
jeden einzelnen Wert überprüfen, aber ich
gebe Ihnen sicher eine echte Antwort. In diesem Video müssen wir
eine flache Vergleichsfunktion schreiben ,
was bedeutet, dass wir den
Vergleich von
Arrays und Objekten beheben möchten , aber wir dürfen keine
verschachtelten Arrays und Objekte vergleichen. So funktioniert der oberflächliche
Vergleich. Und tatsächlich habe ich hier einen
zusätzlichen Funktionstyp ,
von dem wir
enorm beim Aufbau eines
flachen Vergleichs helfen wird . Und wie Sie im Browser sehen können, können
wir typeof einfach für
verschiedene Arten von Daten verwenden. Zum Beispiel erhalten
wir für number eine angespannte Zahl für Zeichenfolgenwort, anstatt eine Zeichenfolge
zu erhalten. Und hier können wir
ein Objekt schreiben und dann bekommen
wir ein Objekt, was bedeutet, dass
es wirklich schön ist, den Typ unserer
Variablen als String zu erhalten. Für uns ist der
interessanteste Teil dieser Objektprototyp
zum Streamen von Anrufeingaben. Und wie Sie in
der Eingabe sehen können, wo zum Beispiel eins und wir
bekommen die Objektnummer. Und tatsächlich wird dieser
reguläre Ausdruck hier einfach
das Objekt verschieben und wir werden
diesen Teil mit Nummer bekommen. So funktioniert diese
Funktion. Hier möchte ich unsere
flache Vergleichsfunktion erstellen. Wir müssen
hier zwei Argumente vorlegen. Wir haben also Quelle und Ziel, und das sind zwei Dinge
, die wir vergleichen wollten, zum Beispiel zwei Variablen. Zunächst möchten wir
einen Datentyp vergleichen, denn wenn wir einen anderen Datentyp
haben, sollten wir nichts tun und das bedeutet, dass
sie nicht gleich sind. Deshalb können wir hier schreiben. Wenn typeof source
nicht gleich typeof ist, können wir hier
einfach false zurückgeben. diesem Grund ist es eine
Superleistung. Wir vergleichen nichts. Wir bekommen einfach einen Typ
vergleichen sie und wir sind raus, nachdem dieser Boom
Logik für unsere Primitive schreiben muss. Und hier können wir einfach einen
einfachen nativen
JavaScript-Vergleich verwenden . Ich schreibe hier, wenn Quelle mit drei
gleichem Stylesheet
gleich ist, dann kehren wir einfach zurück, was eigentlich
diese einzelne Zeile bedeutet. Wir vergleichen oder Primitive. Und jetzt müssen wir nur noch
Fälle für unsere
Objekte und Arrays erstellen . Lassen Sie uns zunächst unsere Arrays
abdecken. Hier möchten wir den Typ von unserem Source-Equals-Array
abchecken. Dann wollen wir diese Logik
anwenden. Und du fragst vielleicht, okay, aber warum prüfen wir nur die
Quelle und kein Reinigungsmittel? Denn eigentlich
hier oben wissen
wir bereits, dass sowohl Quelle als auch Ziel
desselben Typs sind. In anderen Fällen haben wir die Funktion
bereits nicht mehr. Hier. Wir wissen, dass Source
und Target
beide Arrays sind , und jetzt
wollen wir sie vergleichen, aber tatsächlich können wir eine gewisse
Leistungsverbesserung vornehmen. Hier können wir nur
eine Länge von zwei Arrays vergleichen. Und wenn sie
anders sind, sollten wir nichts vergleichen, weil
sie nicht gleich sind. Also hier kann ich IV schreiben, Quelle, Land entspricht nicht
unserer Ziellänge. Dann sind wir hier draußen, geben
einfach falsch zurück. Jetzt möchten wir
diese beiden Arrays vergleichen,
und der einfachste Weg, dies zu tun, ist die Verwendung des Durchschnitts. Wir überprüfen jedes
einzelne Element in einem Array und vergleichen es. Hier möchte ich jeden
Return Source schreiben, also überprüfen wir jedes
einzelne Element der Quelle. Und hier haben wir Zugriff
auf Element und Index. Und was wir hier tun können, ist unser Element entspricht dem Zielindex. In diesem Fall vergleichen wir
jedes einzelne Element
unserer Quelle mit jedem einzelnen
Element des Ziels. Aber wie Sie hier sehen können, verwenden
wir einen nativen
JavaScript-Vergleich, was bedeutet, dass er für Primitive funktioniert,
aber zum Beispiel
für Objekte oder Arrays nicht funktioniert,
wie sieht es aus? Lasst uns die Seite neu laden und genau hier unsere Funktion,
flacher Vergleich. Und wir können jetzt
Array mit Primitiven bereitstellen. Also hier haben wir 11 und
wir werden wahr, was tatsächlich bedeutet, dass
unsere Funktion
korrekt funktioniert , weil das
native
JavaScript 11 nicht vergleichen kann, es falsch ist und unsere
Funktion funktioniert richtig. Jetzt müssen wir den ähnlichen
Code für unser Objekt ausprobieren. diesem Grund können wir hier schreiben, wenn typeof source gleich object ist, dann möchten wir unsere Logik anwenden. Und wieder möchte ich die
Leistung verbessern. Das ist y hier. Zunächst können wir beispielsweise
Objektschlüssel
überprüfen und die Länge der Schlüssel
vergleichen, Objektschlüssel
überprüfen und die Länge der Schlüssel
vergleichen wenn
die Länge
anders ist als diese Objekte sicher unterschiedlich
sind. Hier können wir also
Objektpunktschlüssel schreiben. Hier haben wir Quelle und
wir vergleichen die Länge. Hier
entspricht die Länge also nicht unseren Objektpunktschlüsseln, und hier haben wir unsere
Zielpunktlänge. In diesem Fall
können wir einfach
false zurückgeben und wir sollten
keinen Vergleich durchführen. Und eigentlich
müsste hier jetzt Objekte vergleichen. Dafür werde ich
auch jeden benutzen. Also hier möchte ich
unsere Objektpunktschlüssel zurückgeben und erhalte ein Array von Schlüsselzeichenfolgen unseres Objekts. Und hier
stellen wir unsere Quelle zur Verfügung. Danach können wir
jedes einzelne Element als
jedes einzelne Element verwenden . Wir kriegen unseren Schlüssel. Jetzt können wir den Quellschlüssel vergleichen. Also bekommen wir
den Wert und vergleichen hier den Zielschlüssel. In diesem Fall vergleichen wir jeden einzelnen Wert
unseres Objekts. Aber wie Sie beim
einfachen JavaScript-Vergleich sehen können, bedeutet dies, dass es für Primitive funktioniert, aber für
tief verschachtelte Elemente nicht funktioniert .
Schauen wir uns das an. Ich lade die Seite neu. Hier ist unser oberflächlicher Vergleich. In diesem Fall möchten wir
Objekt a und Objekt vergleichen , das Sie möchten. Und wie Sie
hier sehen können, habe ich einen Tippfehler. Hier ist keine Quelle. Lasst uns das ändern. Wie Sie sehen können, funktioniert
es und wir können unsere Objekte vergleichen. Und eigentlich möchte ich jetzt
noch einen Vergleich für Daten, und das ist extrem
einfach zu machen. Hier. Wir können versuchen, eine Art von
Quelle gleichem Zustand zu versuchen. Dann wollen wir
nur zwei Zahlen vergleichen , weil wir
tatsächlich
jedes Datum zwei Millisekunden vergleichen können und Zahlen
vergleichen können, ist
extrem effizient. diesem Grund können wir hier den
Rückgabe-Quellpunkt-Zeitpunkt schreiben. Dies wird Millisekunden erhalten, die
gleich dem Zielpunkt Zeit erhalten. Und in diesem Fall vergleichen
wir einfach zwei Zahlen und das
ist völlig in Ordnung. So bauen wir eine
flache Vergleichsfunktion auf. Und eigentlich möchte
ich den
Vergleich standardmäßig
in JavaScript sehen , aber leider haben
wir ihn nicht. diesem Grund müssen wir
diese Funktion selbst erstellen oder sie
aus einer Bibliothek wie Rumba
la dash oder nur einem NPM-Paket verwenden . Wenn Sie
solche
Fragen zum flachen Vergleich beantworten , müssen
Sie sagen, dass es im
Vergleich zum tiefen Vergleich eine
Superleistung ist , aber
verschachtelte Elemente nicht vergleichen können, die ist vollkommen in Ordnung. Und Sie müssen nur wissen, für
welchen Fall Sie es verwenden.
39. Implementieren Sie einen tiefen Vergleich: Im vorherigen Video haben wir
die Funktion seichter Vergleich geschrieben . Aber du kannst auch
eine Frage bekommen, Okay? Aber wie können wir die
Funktion für einen tiefen Vergleich schreiben? Das wollen
wir in diesem Video machen. Eigentlich
habe ich, wie Sie sehen können, keinen Code entfernt. Ich habe hier eine Art und flachen Vergleich und sie möchten es
vollständig kopieren und später mit einem
tiefen Vergleich
vergleichen. diesem Grund
habe ich, wie Sie sehen können, die gesamte
Funktion kopiert und sie möchten sie einfach in Deep Compare umbenennen
. Und tatsächlich wird der Code
90% ähnlich sein , weil
wir
zunächst nach
Datentyp suchen möchten und bleibt gleich und das Ende, für
das wir Datum und Quelle und
Ziel
vergleichen werden Datum und Quelle und
Ziel
vergleichen Primitive
auf die gleiche Weise. Eigentlich ändert Biomasse
den Vergleich unserer Arrays und Objekte und tatsächlich wird
sogar der Code darin fast gleich sein. Zunächst einmal überprüfen
wir für das Rennen die Länge. Hier haben wir alle, aber hier müssen wir
unseren
Elementvergleich entfernen , da es sich um einen
nativen Vergleich handelt. Aber hier wollen wir rekursiv
jedes einzelne Element überprüfen. diesem Grund
können wir hier einfach einen
tiefen Vergleich schreiben und wir werfen in unseren
Element-Koma-Zielindex. In diesem Fall, was wir tun, sind
wir wieder Doppelpunkt vergleichen. Und tatsächlich könnte es hier
sein, dass wir ein Objekt haben, dann kommen wir rekursiv
und sagen tief vergleichen. Und wir werden
das Thema vergleichen und wir
machen es immer wieder bis wir
das gesamte Objekt oder
das gesamte Array vergleichen . Und es spielt keine Rolle, wie tief das Subjekt ist oder wie
tief diese Arrays sind, was eigentlich bedeutet, dass
dies keine Leistung ist. Das ist sehr langsam, aber es gibt Ihnen die richtige Antwort, wenn
Sie mit
verschachtelten Daten arbeiten , und genau das Gleiche, was wir jetzt
mit unseren Objekten tun müssen. Hier können wir unseren
Vergleich mit Schlüsseln hinterlassen. Das ist vollkommen in Ordnung. Hier haben wir unser Every, aber wir müssen
diesen Vergleich entfernen und stattdessen
Deep Compare aufrufen. Und wir geben
innerhalb unseres
Quellschlüssels und hier Zielschlüssel weiter. In diesem Fall vergleichen wir zwei Werte unseres
Ziels und unserer Quelle. Und wir machen es auch
mit tiefem Vergleich. Und das ist tatsächlich, es
wird
unsere flache
Vergleichsfunktion im tiefen Vergleich vollständig transformieren . Schauen wir uns das jetzt an, ich werde die Seite hier neu laden, den flachen Vergleich A1, A1, es ist wahr, aber tatsächlich
hier im flachen Vergleich, wenn ich einen B1 werfen werde, also haben wir ein
verschachteltes Objekt und hier ein B1, es wird false zurückgeben, was tatsächlich bedeutet, dass der
flache Vergleich nicht mit verschachtelten Daten funktionieren
kann. Aber hier nennen wir unseren tiefen Vergleich und wir werden wahr, weil der Dip-Vergleich rekursiv
ist und er n in
estan genau so
vergleichen
wird, wie wir es für ein Rennen haben. Wenn wir zum
Beispiel ein Array von Arrays haben, sagen
wir ein Array mit Array eins. Und hier haben wir Array
und Array eins darin. Wie Sie sehen können,
kommen wir durch und wir können Arrays jeder Ebene vergleichen.
40. Erstelle Memoization: Möglicherweise erhalten Sie auch eine
Frage zum Auswendiglernen. Hier können Sie sehen,
wo Maske
eine
Speicherfunktion entwirft , die
zehn hinzufügt, um Wert bereitzustellen und sie
aus dem Cache zu nehmen , wenn
alles berechnet wurde. Wenn Sie nicht wissen, welchen Begriff Auswendiglernen in
JavaScript bedeutet, bedeutet
dies, dass wir Werte
zwischenspeichern um zu vermeiden, dass
dieselbe Operation erneut durchgeführt ,
was zum Beispiel
bedeutet, wir subtrahiere zwei Zahlen. Und wenn wir es vorher gemacht haben
und wir die Antwort bereits
kennen, müssen wir
den Sensor einfach zurückgeben und ihn nicht erneut
berechnen. Offensichtlich macht es keinen
Sinn wir subtrahieren oder so, aber es ist sehr
sinnvoll, wenn wir einige schwierige
Berechnungen
haben. diesem Grund müssen wir hier
ein Beispiel für die
Memoisierungsfunktion erstellen . Und eigentlich ist es
nicht so schwierig. Also hier möchte ich
eine Funktion merken erstellen, addieren. Stattdessen diese Funktion. Wir
brauchen keine Argumente, aber wir möchten
einen Cache im Inneren erstellen. diesem Grund werde ich hier
Bargeldeigentum erstellen. Dies ist nur ein Objekt. Jetzt möchte ich hier eine neue Funktion
zurückgeben. Und Sie können sehen, dass dies
eine Schließung ist, weil
wir tatsächlich einige Variablen speichern können , wenn
wir einen Abschluss haben. diesem Grund gebe ich
die Funktion hier mit Wert zurück. Jetzt ist, wie wir es draußen
benutzen. Hier möchten wir eine
neue Add-Funktion erstellen und nennen ihn
einfach MIs add, in diesem Fall, neue
AD-Benutzerfunktion und wir können sie verwenden. diesem Grund
können wir hier neue Anzeigen schreiben, zum Beispiel neun, und
das ist unser Wert. Und in diesem Fall
wird die Ausgabe 19 berechnet von 19, denn tatsächlich muss er, wie Sie in unserer Zukunft
sehen können, zehn zu
unserem bereitgestellten Wert addieren. Wir werfen uns in neun
und wir kriegen 19 zurück. Aber wenn wir
neue Werbung mit Snyder aufrufen , wird
die Ausgabe auch 19 sein, aber sie sollte aus dem Cache
genommen werden. Es sollte nicht berechnet werden. Auch dies ist genau das, was das
Auswendiglernen tut. Jetzt müssen wir
diese Memoisierungslogik nur noch implementieren. Hier können wir also schreiben, wenn
wir einen Wert in bar haben, also prüfen wir, ob wir in unserem Objekt
so gültig sind, dann möchten wir es einfach zurückgeben. Und hier möchte ich das Konsolenprotokoll
schreiben damit Sie sehen können, dass
es minimiert ist. Hier wird von Bargeld abholen. Und danach möchte
ich Retourengeld schreiben. Und hier ist unser Wert. Wie Sie sehen können, führen wir hier
keine Berechnungen durch. Wir geben einfach Wert zurück
und wir werden auch noch etwas haben. Und hier haben wir
Berechnungen, die
genau hier drin waren , um Ergebnisse
zu berechnen. Und danach müssen wir es
wirklich berechnen. Lassen Sie uns hier also einen
Wert erstellen, zum Beispiel Ergebnis. Und wir wollen
hier Wert plus zehn setzen. Und danach müssen wir es
in bar legen , bevor wir es zurückgeben. In diesem Fall speichern wir unser Ergebnis für den nächsten Streifen. Hier können wir den
Barwert gleich Ergebnis schreiben. In diesem Fall weisen wir
Bargeld für unsere Nummer neun zu. In diesem Fall, wenn wir das
nächste Mal hier neun sind, dann erhalten wir
den Wert aus Bargeld. Und danach können wir
einfach unser Ergebnis zurückgeben. Und das ist nur der Wert
, den wir hier berechnet haben. Schauen wir uns das an. Ich lade die Seite neu. Wie Sie sehen können, erhalten wir
kalkulierte Endergebnisse. Dies ist unser erster Versuch
hier und berechnete 19, was bedeutet, dass wir
wirklich etwas berechnet haben. Aber beim zweiten Mal haben
wir diese Kohle von Bargeld 19 geholt, was eigentlich bedeutet, dass wir dieses Mal diese Zahl
nicht berechnet haben, aber wir haben sie aus Bargeld
genommen. Und so
implementieren Sie normalerweise das Auswendiglernen. Sie können andere Aufgaben bekommen, aber die Idee ist dieselbe. Sie haben etwas Bargeld, Sie haben eine Schließung, und Sie müssen den
Wert aus dem Cache liefern und bei der ersten Berechnung in den Cache
legen.
41. Fibonacci: Willkommen bei einigen wirklich
lustigen Fragen, denn dieses Zeug werden
Sie
in Ihrem Alltag nie
wie ein Programmierer verwenden , aber Sie müssen wissen,
wie Sie es lösen können. Und das erste hier, das ist mein Lieblingsdesign, eine Funktion, die den
Fibonacci-Sequenzwert zurückgibt und sie nicht versucht haben,
in
den letzten 12 Jahren den Fibonacci-Wert zu erhalten , was eigentlich bedeutet, dass
es nicht benötigt wird. Aber ich höre
diese Frage ständig immer wieder im Interview. Und eigentlich denke ich
, dass es völlig in
Ordnung ist , den Interviewer zu fragen. Okay, ich kenne keine
Formel für Fibonacci. Kannst du bitte speichern und
dann können sie es codieren. Es ist kein Problem. Das ist völlig in Ordnung
, weil man nicht alle
mathematischen Formeln auswendig kennen
sollte . Hier können
Sie hier tatsächlich
so etwas als Ergebnis
für Ihre Frage bekommen . Hier sehen Sie also
, dass die Fibonacci-Sequenz eine ganzzahlige Sequenz
ist,
bei der die ersten beiden Begriffe 01
sind, nachdem der nächste Begriff als Summe
der beiden vorherigen Begriffe definiert wurde. Und der andere Begriff ist die Summe von n minus eins und n minus zwei,
was tatsächlich bedeutet, dass dies
ein typischer Anfang der
Sequenz ist , die wir hier 0112 haben. Und wie Sie
hier sehen können, können wir
zum Beispiel 11 summieren und wir kommen mit etwa 12
an und wir bekommen drei
und so weiter und so weiter. Wie wir das lösen können, müssen
wir eine R-Funktion bereitstellen, einen Fibonacci-Sequenzwert
, der tatsächlich den
Index in der Sequenz bedeutet. Wenn wir zum Beispiel sieben als Argument
angeben, dann müssen wir
bei Band-to-Band hierher kommen, denn tatsächlich werden wir 813
zusammenfassen und 21 bekommen. Nennen wir diese Übung jetzt. Und tatsächlich
werden wir hier Rekursion verwenden , weil wir sie rekursiv
berechnen wollen. Hier können wir eine
Fibonacci-Funktion erstellen und wir bekommen hier n, was hier unser Index ist. Zunächst müssen wir prüfen,
ob es weniger als zwei sind, denn in diesem Fall
funktionieren
unsere Logikanleihen , weil wir hier 01 haben. Hier müssen
wir nachsehen, okay? Wenn n weniger als zwei, dann wollen wir hier eins zurückgeben. In anderen Fällen
müssen wir unsere Logik anwenden. Hier geben wir einfach Fibonacci zurück, und hier
übergeben wir n minus zwei,
was bedeutet, dass wir diese Funktion
rekursiv
berechnen und jeden einzelnen
rekursiven Aufruf von Fibonacci, wir werden sie immer wieder aufrufen bis wir zu
dieser ersten Bedingung kommen werden. Hier haben wir
Fibonacci n minus zwei plus Fibonacci und minus eins. Und tatsächlich ist dies der ganze
Code, den Sie ausprobieren müssen. Schauen wir uns das mal an. Ich springe einfach in die Konsole und genau hier Fibonacci sieben. Und wie Sie sehen können, bekommen
wir 21, was tatsächlich bedeutet, dass
unser Code funktioniert. Aber hier ist ein paar wichtige
Dinge, an die Sie sich erinnern sollten. Als Programmierer
müssen Sie wissen, wie man mathematische
Formeln oder eine Logik
konvertiert. In JavaScript sind Funktionen
Funktionen in jeder anderen Sprache, aber es ist völlig in
Ordnung, nicht alle mathematischen Formeln
auswendig zu kennen . Deshalb solltest du keine
Angst davor haben, nach ihnen zu fragen. Und zweitens
denke ich, dass es völlig in
Ordnung ist , im Gegenzug zu fragen. Okay. Ich kann nicht wirklich codiert werden, aber benutzt du dieses Zeug jeden Tag
in deinem Projekt? Und wahrscheinlich
bekommst du eine Antwort nein. diesem Grund macht
es eigentlich
keinen Sinn , dieses
Zeug überhaupt zu fragen.
42. Palindrom: Eine weitere beliebte Frage
, die ich oft höre ist bitte schreiben Sie eine Funktion
, um das Palindrom zu überprüfen. Denn eigentlich machen Programmierer das
jeden Tag. Sie überprüfen Palindrome. Aber was auch immer wir lösen können. Wenn Sie nicht
wissen, was Palindrom ist, ist dies eine Zeichenfolge, die von Anfang
und vom Ende
gleich ist . Wenn Sie beispielsweise
eine vollständige Zeichenfolge haben, ist
es kein Palindrom. Aber wenn Sie zum Beispiel eine vollständige Zeichenfolge haben , ist
es ein Palindrom, weil es die gleiche Stärke von der
Statistik und vom Ende hat. Also lasst uns das jetzt versuchen. Und eigentlich ist es wirklich einfach. Was wir hier machen wollen, wir wollen eine
Funktion erstellen, ist Palindrom. Und was wir mit
einem machen wollen, mit dem wir mit Bedacht lösen können. Und eigentlich macht es
keinen Sinn, es durch
Buchstaben zu teilen und jeden
einzelnen Buchstaben zu überprüfen und so weiter. Sie können einfach
eine Zeichenfolge umkehren und vergleichen. diesem Grund können wir hier
schreiben, dass unsere Zeichenfolge gleich ist, und wir können
sie mit String Dot split vergleichen. Und hier stellen wir einfach
eine leere Zeichenfolge zur Verfügung. Also teilen wir es
jetzt nach Buchstaben auf, indem wir einfach
rückwärts machen, in unserem Array umkehren, und
dann verbinden wir es wieder, was tatsächlich bedeutet,
wo das Gegenteil in dieser Welt und wir
vergleichen zwei gleiche Wörter. In diesem Fall erhalten wir dieselbe Zeichenfolge, wenn
sie gleich sind. Schauen wir uns den Süden
hier an, wo direkt im Ostpalindrom liegt, und wir geben vollständige Einblicke
und wir werden falsch. Aber wenn wir foo schreiben, foo, dann werden wir wahr. Die Aufgabe ist gelöst.
43. Anagram: Eine weitere Frage, die ich oft
höre, ist,
die Funktion zu schreiben , die überprüft
, dass die Zeichenfolge ein Anagramm ist. Und tatsächlich ist dieses Zeug dem Palindrom sehr ähnlich,
wie Sie hier sehen können, Anagramme von Wörtern,
die dieselben Zeichen
in derselben Menge haben ,
was bedeutet, dass zwei
Strings Anagramme sind, wenn wir können Strings neu anordnen
und den anderen bekommen. Und hier sind ein paar
Beispiele für Anagramme. Hören Sie zum Beispiel zu
und schweigen und so weiter. Also schreiben wir jetzt die
Funktion ist Anagramm. Hier haben wir ein
Anagramm und wir wissen , dass wir
hier zwei Stärken bekommen , die wir vergleichen möchten. Nennen wir es ist 31
und streamen zwei. Was wir hier
überprüfen möchten, ist, dass diese beiden Strings
dieselben Buchstaben haben. Um dies zu überprüfen, müssen
wir die Sortierung unserer Strings anpassen. In diesem Fall können wir die Strings einfach nach Gleichheit
vergleichen. Aber zuerst
möchte ich hier eine Länge überprüfen, denn wenn wir in diesen beiden Saiten eine andere
Länge haben, wird es nicht funktionieren. Wenn die Länge
unserer ersten Zeichenfolge nicht der unserer ersten Zeichenfolge nicht Länge
unserer zweiten Zeichenfolge
entspricht, wir einfach false zurück
und wir überprüfen nichts. Und natürlich
sollte hier Bank und nicht
gleich sein , weil wir überprüfen wollen
, ob sie nicht gleich sind. Das zweite, was wir tun
möchten, ist es in
Kleinbuchstaben umzuwandeln , da
wir tatsächlich eine andere Großbuchstabe haben können, aber die Strings sind
immer noch gültig. Das ist y. Nennen
wir es untere Strang eins. Und hier haben wir einfach
string1 in Kleinbuchstaben angerufen, und wir haben zwei Kleinbuchstaben
direkt in JavaScript. Hier nennen wir die niedrigste Zeichenfolge, und wir konvertieren
String in Kleinbuchstaben. Was wir nun überprüfen möchten, wollen
wir prüfen, ob diese
beiden Strings gleich sind. In diesem Fall haben wir
falsch gemeistert, weil es
sich nicht um Anagramme handelt. Deshalb schreibe ich hier,
dass der Fluss von String1 gleich der
niedrigsten Zeichenfolge zwei ist, dann ist dies falsch und
dies ist kein Anagramm. Und das letzte
müssen wir unsere Logik schreiben. Und was ich tun möchte, ich möchte
unsere Strings einfacher in ein Array konvertieren als bestimmtes Array und sie
für dieses Wochenende
direkt in String zusammenführen , oder? Zum Beispiel sortierte Zeichenfolge eins, und hier schreiben wir die
niedrigste Zeichenfolge einen Punktspalt. Und hier wollen wir uns nur nach Buchstaben
teilen. Und hier rufe ich nur
sort ohne Argumente an. Es wird auf irgendeine Weise sortiert. Und nach diesem ****, um
einen String zurück zu bekommen , das ist y hier. Join bringt uns einen String zurück. Ich möchte genau das
Gleiche an der zweiten Saite machen. Und hier können wir sie jetzt
vergleichen, weil wir in diesem Fall
alle unsere Buchstaben in
die gleiche Richtung sortiert haben . Und jetzt hier kann ich
einfach zurückgeben
sortierte Zeichenfolge eins
gleich sortierte Zeichenfolge schreiben . In diesem Fall vergleichen wir
zwei Strings, die sortiert wurden, und wir wissen bereits, dass es Chrome
eingeben, wenn sie gleich sind, schauen wir uns das an. Ich springe in den Browser und
wir schreiben ist Anagramm. Hier
stellen wir nur Full und Byron zur Verfügung. Und wie Sie sehen können, ist es falsch weil es sich um zwei
verschiedene Strings handelt. Aber versuchen wir es jetzt mit angehört
und still. Zum Beispiel. Hier schreibe ich Lektion, und rechts
schreibe ich still. Und tatsächlich
werden wir hier wahr, und es funktioniert, was
wir hier machen. Zunächst prüfen wir,
ob die Länge gleich ist. Willkommen hier drin, wir
haben zwei Stärken, Kleinbuchstaben, also sind wir nicht hier. Und jetzt sind wir uns nur
sicher, dass diese beiden Strings in unsere Arrays
konvertiert wurden, und dann konvertieren wir
sie wieder in Strings. In diesem Fall bekommen wir
etwas wie E und St., aber es ist völlig Ordnung, weil wir sie einfach vergleichen
wollen. Und so schreibst du Funktion, um Anagramme zu vergleichen.
44. Vokale finden: Sie könnten auch
eine solche Aufgabe bekommen. Schreiben Sie die Funktion, die Vokale in der Zeichenfolge
zählt. Und es sind nicht immer Vokale, sondern etwas, das man in der Zeichenfolge zählen
muss. Und eigentlich ist es
nicht so schwierig, denn die Hauptidee
ist, dass wir zuerst etwas wie eine Reihe
möglicher Wackeln
oder möglicher Symbole definieren
müssen . Und dann versuche einfach
jeden einzelnen Buchstaben in
unserer Stärke zu überprüfen jeden einzelnen Buchstaben in . Lasst uns das jetzt machen. Zunächst einmal möchten
wir hier
eine Funktion Phi und Vokale erstellen , und wir bekommen hier
String als Argument. Jetzt muss die zweite Leber
definieren, was unsere Vokale sind. Hier können wir
Vokal-Array erstellen und uns hier a,
e, I, o und u definieren . Und wir können
mit zwei verschiedenen Möglichkeiten lösen , entweder mit for-loop
immer reduzieren und tatsächlich
sind beide in Ordnung. Hier. Zunächst möchte ich
einen Zähler erstellen, weil wir ihn jedes
Mal
erhöhen wollen , wenn wir unseren Vokal finden, eine for-Schleife
benötigen. Hier können wir also
Leadzeichen abschreiben, und hier wird
String in Kleinbuchstaben sein. In diesem Fall
erhalten wir Zugriff auf jedes einzelne Zeichen in unserer Zeichenfolge und wir können überprüfen,
okay, ob Vokale unseren Charakter
enthalten, dann möchten wir unseren Zähler
erhöhen. Also hier wird
Graf Plus sein, plus. Und nach dieser for-Schleife wir einfach unser
Konto zurück, das wir erstellt haben. Hier. Versuchen wir, die Eingeweide zu finden und wir
haben eine Schnur, wie Sie hier sehen können,
bekommen wir drei Vokale weil wir dreimal
hier e haben. Und eigentlich würde ich sagen
, dass dieser Code in Ordnung ist, aber wir können ihn
besser schreiben mit reduziertem. diesem Grund wollte ich diese Lead-Anzahl und
Nachverfolgung direkt
hier kommentieren und eine reduzierte zurückgeben. Zunächst möchten
wir unsere
Zeichenfolge in Kleinbuchstaben umwandeln. Also hier können wir einfach
String in Kleinbuchstaben ausprobieren. Und danach wollen wir es in Zeichen
aufteilen. Dies ist y hier wird leer String
geteilt. Jetzt wollen wir hier reduzieren anrufen
und wir erhalten Zugang, allem auf unseren Akkumulator und zweitens auf jeden
einzelnen Charakter. Nach dieser Funktion möchten wir unsere Zählung
definieren
und es wird 0 sein. Innen sind reduziert. Wir wollen genau
die gleiche Logik machen. Wir können hierher zurückgeben
, dass wir unseren Zähler
erhöhen möchten
, wenn unser
Vokal-Array ein Zeichen enthält, das wir überprüfen . Hier vergrößern wir unseren
Akkumulator um plus eins. In anderen Fällen erhöhen wir
es nicht und geben einfach den Akkumulator zurück. Lassen Sie uns das Salz überprüfen, das
ich neu lade die Seite hier ist dieselbe Zeichenfolge
und wir bekommen drei. Eigentlich ist dieser Code besser,
weil
wir ihn zunächst Zeile für Zeile lesen können. Und zweitens ist das vollkommen
rein und funktional.
45. Konvertieren Sie in Title Case: Möglicherweise erhalten Sie auch eine Aufgabe, Ihre Zeichenfolgen-Titel-Fall zu konvertieren. Und tatsächlich könnte es schwierig sein. Deshalb ist es
wirklich gut, dass wir
hier Testfälle erhalten haben. Eigentlich müssen wir
einen Funktionstitelfall erstellen. Und wenn wir
drinnen zur Verfügung gestellt werden, bin ich eine kleine Teekanne. Wir sollten eine Zeichenfolge zurückgeben und
sie sollte kapitalisiert werden. Und wie Sie sehen können, ist
jedes einzelne Wort hier kapitalisiert, nicht nur das erste Wort, und das ist wichtig. Auch. Es spielt keine Rolle,
wie wir unsere Zeichenfolge bereitstellen, sie muss
korrekt großgeschrieben werden. Bauen wir diese Funktion jetzt auf. Und tatsächlich haben wir hier
zwei Möglichkeiten, die wir for-loop over verwenden
können, native
JavaScript-Methoden verwenden
können. Lassen
Sie es uns zuerst schreiben, indem wir for-loop verwenden. Hier erstellen wir eine
berechtigte Fallmethode und wir erhalten eine
Zeichenfolge als Argument. Zuallererst möchten wir hier ein Array
erstellen. Wir haben hier jeden einzelnen
Charakter. Wir können hier schreiben
, dass unsere
Zeichenfolge zwischen String und
Kleinbuchstaben ist, und hier wird ein Leerzeichen sein. Eigentlich
schreiben wir hier Array in String. Und tatsächlich
schreibe ich Code wie diesen , weil ich dir zeigen möchte, wie du deinen Code nicht schreiben solltest. Und es geht
hier nicht nur um Logik , die wir for-Schleife verwenden, sondern auch um das, was Sie tun, wie Sie sehen können, besteht
die schlechte Praxis hier darin, dasselbe Argument zu verwenden ,
wie wir es hier haben. haben unser Argument im Inneren überschrieben, was bedeutet, dass
wir es zunächst ändern könnten. Ja, bei der Zeichenfolge ist es nicht der
Fall, aber es wird so sein. Bei Arrays sind Objekte , weil wir in einer Referenz besser
definiert sind. Zweitens
kommen wir hier wieder ins Array, aber hier schreiben wir
es in einen solchen Stream, was es verwirrend macht. Und diese beiden Dinge dürfen Sie nicht in Ihrem Code
oder im Interview tun. Denn damit zeigen
Sie , dass Sie Einbettungscode schreiben. Ein wesentlich besserer Ansatz wird
darin bestehen,
zusätzliches Eigenschaften-Array
oder was auch immer Sie wollen zu erstellen . Hier bekommen wir eine Zeichenfolge in Kleinbuchstaben und es geht
uns völlig gut. Danach müssen wir hier for-Schleife
schreiben, wir können
einfach native for-loop schreiben, was ich auch nicht rate. Also hier können wir
var i gleich 0 schreiben, ich weniger als String-Länge. Und hier plus plus. Und natürlich ist hier kein
Stream, sondern unser Array. Also hier drinnen können wir jetzt alle einzelnen Elemente
mutieren. Also können wir hier
Array schreiben, das ich gleich ist, und hier haben wir das gleiche
Elementpunktzeichen bei 0. Und was es tut, braucht
es das erste
Element unseres Streams. In unserem Fall ist jedes
einzelne Element unseres Arrays eine Zeichenfolge. Und hier bekommen wir den
ersten Buchstaben, damit wir
groß schreiben können , dass er so
in Großbuchstaben war, was auch eine native
Methode in JavaScript ist. Und hier können wir
ein i dot slice eins schreiben. Und in diesem Fall erhalten wir alle unsere Elemente
der Zeichenfolge außer
dem ersten Buchstaben. Das ist es, was wir wollen.
Wir wollen den ersten Buchstaben großschreiben und dann einfach alle anderen Buchstaben nehmen. Und danach können wir uns
einfach wieder unserem Array anschließen. Wir sind genau hier drin,
geben
Array-Join zurück, und wir sind durch Space verbunden. Jetzt können wir
hier Konsolenprotokoll schreiben, wo hier Doppelpunkt für den Fall in unserer Zeichenfolge
angegeben wurde. Ich bin eine kleine Teekanne. Lasst uns prüfen, ob es funktioniert. Ich lade die Seite neu und
bekomme ich eine kleine Teekanne, die tatsächlich gut aussieht
und wir lösen die Aufgabe. Aber zuallererst haben wir hier negative vier
benutzt. Und wie ich bereits sagte, ist
es nicht der beste
Ansatz, wenn wir jedes einzelne
Element des Arrays durchlaufen, zumindest müssen Sie für Rich,
für Array und nicht native vier verwenden , dann Ihren Code wird besser sein. zweite Sache, die ihnen hier nicht
gefällt, ist, dass wir jedes einzelne
Element unseres Arrays
überschreiben, was tatsächlich bedeutet, dass wir
kein neues Array erstellen, aber
das vorherige überschreiben. Und es ist auch nicht der
beste Ansatz. Das ist y. Lassen Sie uns diesen ganzen Code
einfach mit einfachen
JavaScript-Methoden umschreiben . Denn eigentlich brauchen wir hier
überhaupt nicht einmal FOR Loop. Was ich
hier machen wollte, möchte ich
unseren String nehmen und ich möchte sie
in Kleinbuchstaben umwandeln. Das war vollkommen in Ordnung. Danach wollen wir es mit Leerzeichen
aufteilen. Das war auch völlig in Ordnung. Aber danach
können wir map verwenden, denn im Wesentlichen
machen wir hier eine Map. Wir möchten jedes einzelne
Element innerhalb des Arrays ändern. Deshalb rufe ich Map an und wir kriegen
hier unser Board. Und wie Sie sehen können, ist
es
jetzt klarer, weil wir Immobilienwelt
verwenden und nicht KI oder
ein Array in dem wir nicht wissen, wovon
wir sprechen. Und hier wollen wir genau das gleiche
Wortpunktzeichen bei 0 machen. Also bekommen wir das erste Element. Hier verwenden wir Großbuchstaben, und hier verwenden wir Plus, und wir werden alle
anderen Buchstaben mit
Wortpunktscheibe genommen und hier ist einer. Und wie Sie sehen können,
ist dieser Code im Wesentlichen derselbe. Wir haben
es nicht geändert, aber es ist viel effizienter und einfacher zu lesen. Und es zeigt, dass Sie
fortgeschrittenere Entwickler sind, denn hier
verwenden wir nicht for-loop sondern map, was nicht so schwierig ist. Und hier kehren wir
einfach für jedes einzelne Wort in deiner Arbeit zurück. Und hier ist es wichtig zu
erwähnen, dass Charakter add und Slice nicht
in Funktionen mutieren, was bedeutet, dass wir den
Jugendstream bekommen und den Alt-Stream
nicht mutiert haben .
Schauen wir uns das an. Ich bin der Herr
auf dieser Seite und wir bekommen unsere
Array-kapitalisierte Strings,
was bedeutet, dass ich am
Ende vergessen habe, unseren Riesen hier zu machen,
wir können einfach anrufen, dass ich mich mit dem Raum im Inneren
verbinden würde. Schauen wir uns das an und wir bekommen genau die gleiche Zeichenfolge. Daher empfehle ich Ihnen
im Interviewer dringend, sich Ihre Benennung
anzusehen, zu überprüfen, ob Ihre
Datentypen mit
Ihren Namen übereinstimmen , und Ihren Code einfacher zu
lesen, wenn dies möglich ist.
46. Konvertieren Sie die Zeiteingabe in 12 Stunden Format in 24: Hier ist eine weitere Aufgabe, die ein
wenig Nachdenken
erfordert. Und wie Sie
sehen können, müssen wir
die Funktion schreiben , die die im
12-Stunden-Format angegebene Zeiteingabe in ein
24-Stunden-Format umwandeln
kann im
12-Stunden-Format angegebene Zeiteingabe in . Hier haben wir Anwendungsfälle. diesem Grund ist es
einfacher für uns zu
prüfen, ob wir
alles richtig abgedeckt haben. Versuchen wir also, diese Funktion zu
erstellen. Und wieder einmal
ist dies keine Funktion, die Sie
in dreißig Sekunden lösen können. So kannst du dir Zeit nehmen und ein bisschen darüber nachdenken. Lassen Sie uns hier in ein 24-Stunden-Format konvertieren
. Und wir bekommen
hier Zeittext. Und was ich hier zuerst machen
wollte, möchte
ich
es in Kleinbuchstaben umwandeln, denn eigentlich bekommen
wir HIER AM und PM und wir wollen sicher sein
, dass sie Kleinbuchstaben sind. Deshalb können wir hier
versuchen, die Zeit zu senken. Und hier möchten wir den
Zeittext in Kleinbuchstaben aufrufen. Das zweite
, was ich tun möchte, ist Stunden und
Minuten getrennt zu
bekommen. Was ich
hier schreiben möchte, ist Zeittechnologie langsamer geteilt und wir möchten sie nach Spalte
aufteilen,
weil
wir in
jedem einzelnen Fall einen Doppelpunkt haben. Und auf der linken Seite
haben wir unsere Stunden, und rechts haben
wir Minuten. Und eigentlich möchte ich hier direkt
eine Destruktur und
Aufgabe machen . Ich möchte
zuerst unsere Stunden und
zweitens Minuten bekommen . In diesem Fall erstellen wir
zwei lokale Variablen. Wenn Sie nicht so schreiben
möchten, können
Sie es mit einer
Temperatur-T-Variablen benennen und dann einfach diesen temporären
variablen Punkt Stunden und Minuten lesen. Aber hier kommen wir zu
schwierigen Sachen. Wie Sie sehen können, haben wir
manchmal nur eine einstellige Ziffer und
manchmal haben wir zwei Ziffern. Aber wir haben auch einen Fall, in dem wir am Anfang Nullen
haben. Hier. Wir haben auch einen weiteren Fall
, den wir behandeln müssen. Wenn wir hier 12 als unsere haben, müssen wir
sie in Nullen 0 umwandeln. Deshalb wollte ich genau diese Logik
schreiben. Also kreuzt Eve Time langsamer Punkt und Breite an und endet
tatsächlich mit Israel. Eine nette Funktion in
JavaScript, die den tostring
überprüft,
endet mit etwas. Hier können wir nach
AM suchen , weil wir tatsächlich
wissen, dass wir hier
12 Uhr morgens haben und das bedeutet, dass wir es in zwei Nullen umwandeln
müssen. Deshalb
möchte ich hier unsere Gleichen schreiben, und hier
prüfen wir, ob unsere Stunden 1212
als String entsprechen, denn hier sind wir in unserer Zeichenfolge
geteilt, dann wollen wir hier 0 bekommen. In anderen Fällen
kommen wir Stunden hierher. Und wie Sie
sehen können,
habe ich hier zunächst eine einzige
0 geschrieben und nicht zwei Nullen. Und das ist auch wichtig. Hier habe ich nur Stunden direkt
zugewiesen, was bedeutet, dass wir
diese Logik behandelt haben , um eine einzelne
0 zu erhalten und in allen anderen Fällen einfach
das bekommen, was wir bekommen. Wenn es fünf ist, kriegen
wir fünf. Wenn es 01 ist, kriegen wir 01. Wir haben unseren AMK abgedeckt, dass
ich jetzt den PM-Fall behandeln wollte. Deshalb
können wir hier anders schreiben und vielleicht
sogar else-if, weil
wir nach PM suchen wollen. Und hier können wir
Time-Tech langsamer Punkt und Breite schreiben, und hier bekommen wir unseren PM. Und in diesem Fall
wollen wir eine andere Logik anwenden. Wir möchten
hier unsere Stunden zuweisen und wir möchten prüfen, ob
unsere Stunden 12 betragen, da dies
wieder ein anderer Fall ist. In diesem Fall
möchten wir uns hier Stunden bewerben, oder wir möchten
hier String und
innerhalb plus Stunden letzte 12 schreiben . Dieser Code ist groß,
wie Sie hier sehen können, habe ich plus Stunden geschrieben, was er eigentlich tut, wir bekommen unsere
Stunden als String. Sagen wir also, wir kommen
hier 12 an. Wenn ich jetzt am Anfang hier
plus schreibe, bekommen
wir hier direkt eine
Zahl aus einer Zeichenfolge, was tatsächlich bedeutet, dass
wir diese in
Zahl konvertieren und dann plus 12 machen. Warum ist das so? Denn
sagen wir hier, wir überprüfen PM zum Beispiel diesen Fall mit 01, und hier prüfen wir, Okay, Stunden gleich 12, Nein, dann wollen wir 01 plus 12
machen. Schauen wir uns den Süden an,
wie es sein wird. Also kommen wir hier 01 und tatsächlich wird es in eins
umgewandelt. Und jetzt danach bekommen
wir plus 12 und wir kommen in Zinn, was
bedeutet, dass
wir es mit 12 in
die richtige PM-Zeit konvertieren. Und wenn wir so 12 Uhr haben, lassen wir es einfach wie 12 Uhr. Eigentlich
könnten wir hier 12 schreiben, könnten einfach unsere Stunden dauern. Was ich jetzt machen möchte, möchte
ich überprüfen, was wir innerhalb von Stunden
bekommen. Also hier möchte ich
unser Convert to 24-Stunden-Format konsolenprotokollieren , und hier sind unsere
Zeittexte und unsere Stunden. Und jetzt möchte ich all
diese Fälle kopieren und einfach ausführen. In diesem Fall können wir überprüfen
, ob sie ordnungsgemäß funktionieren. Ich lade die Seite neu
und wir erhalten Zuweisung zu
konstanter, variabler. Und wie Sie hier sehen können, versuchen
wir unsere zu überschreiben. Und natürlich ist es verboten. Deshalb müssen
wir hier LED schreiben. Schauen wir uns das
an. Ich lade neu und wir bekommen
412045512120113. Hier haben wir PM 11231022, was bedeutet, dass unsere stundenlange
Logik korrekt ist. Danach müssen wir in diesem ganzen Fall eine
führende 0 hinzufügen. Und wie Sie sehen können, brauchen wir es
manchmal nicht und manchmal
müssen
wir es haben und wir können
es leicht
mit einer weiteren einfachen
JavaScript-Funktion lösen . Wir können hier schreiben,
unser Punktpad beginnt. Hier. Wir können 0 zur Verfügung stellen. Was es tut, ist, dass Sie hier sehen
können, dass
die aktuelle Zeichenfolge bei Bedarf
mehrmals mit einer anderen Zeichenfolge aufgefüllt wird. Was eigentlich bedeutet, dass
wir hier ein Tool bereitstellen, was bedeutet, dass wir zwei
Symbole haben werden und hier haben wir 0, was bedeutet, dass wir 0 hineinsetzen
, wenn wir dort
kein Symbol haben . Und jetzt
möchte ich diesen Teil kopieren und einfach in unser
Konsolenprotokoll legen, um zu überprüfen, ob es funktioniert. Ich lade die Seite neu
und wie Sie jetzt sehen können, bekommen
wir die richtige Zeit. Also hier haben wir zwei Nullen, 05, und dann sind alle
richtige Zahlen. Jetzt müssen wir
unsere Minuten umsetzen und tatsächlich ist
es viel einfacher. Zunächst einmal, nur
um Sie daran zu erinnern, werden
innerhalb von Minuten auch PM
und TM haben und wir müssen es
loswerden. Deshalb können wir
hier direkt schreiben bedeutet Punkt-Slice und hier
verwenden wir 0 minus zwei. In diesem Fall werden wir zwei Symbole
loswerden, AM oder PM, und wir werden hier nur wenige Minuten
bekommen. Und danach möchte ich
den PET-Strang verwenden, genau wie zuvor. Und hier werden auch 20 sein. In diesem Fall
werden wir prüfen, okay, wenn wir acht hier haben, dann müssen wir
hier Pseudohilfe besorgen. Wenn wir hier zwei Ziffern haben werden, dann ist es völlig in Ordnung. Jetzt können wir
dieses Konsolenprotokoll einfach entfernen, brauchen es
aber nicht mehr. Und eigentlich möchte
ich hier in
jedem einzelnen Fall Konsolenprotokoll schreiben. Das ist y. Lasst uns das ändern. Jetzt. Ich möchte hier
Konsolenprotokoll schreiben und dann öffnen. Und hier haben wir konvertiert. Und lass uns schließen, es war Klammer. Jetzt haben wir alle unsere Fälle. Schauen wir uns sie
an. Ich lade die Seite neu und wir
bekommen unsere Zeit, und es sieht total gut aus,
zum Beispiel haben
wir Minuten-Nullen 0
bis 35508 und so weiter. Aber das Problem ist, dass wir vergessen haben, eine
Spalte dazwischen zu legen. Hier müssen
wir plus schreiben und dazwischen einfach
eine Zeichenfolge mit einem Doppelpunkt setzen. Und wie Sie
jetzt sehen können, bekommen wir eine schöne Zeit im 24-Stunden-Format. Und aus
meiner Sicht ist
dies schwierig, diese Aufgabe in fünf
oder zehn Minuten zu lösen . Sie müssen wirklich etwa
15 Minuten oder eine halbe Stunde dort
sitzen ,
um verschiedene Fälle zu überprüfen, wie Sie es
lösen möchten und so weiter. Dies ist also eine nette Aufgabe zu
überprüfen, wie Sie
verschiedene Dinge zwischen
ihnen mit unterschiedlicher Logik konvertieren können . Aber es ist nicht
etwas, das Sie in ein oder zwei Minuten
lösen können .
47. Daten zuordnen: Hier ist eine weitere Aufgabe für Sie , die
dem realen Projekt entnommen wurde. Dies sind nicht nur einige
Aufgaben für das Interview, sondern die Aufgaben, die Sie in Ihrem Alltag
sehen werden. Und wie Sie sehen können,
wo müssen
Daten nach vorne und formatiert werden, was tatsächlich bedeutet, dass wir unsere Daten beispielsweise
aus dem Backend
abrufen und sie nicht so
informieren, wie wir es wollen. Deshalb wollen wir sie
umwandeln. Das Hauptelement
ist der Standortschlüssel, und wir müssen ihm
alle Daten zuordnen, und wir werden es
dann fünf Objekte haben. Wie Sie hier sehen können. Zuallererst haben wir
ein Location-Array, und hier haben wir zwei Objekte. Zuallererst der Standortschlüssel und dies ist unsere eindeutige Kennung. Und wir haben hier
ein paar Ideen und äußere Zuweisen
im zweiten Objekt genau das Gleiche. Und jetzt haben wir hier einen
Massenpreis konfiguriert. Dies ist auch das
Array mit Objekten. Und in jedem
einzelnen Objekt haben
wir Datenwerte und Konflikte behalten. Der Hauptpunkt ist, dass wir sie eins zu eins
zuordnen, was bedeutet, dass
der 0-Index im Positionsarray gleich dem Index der
Massenkonfigurationen 0 entspricht. Und in diesem Fall müssen wir
alles der Struktur zuordnen . Am Ende müssen wir ein Array von
Objekten mit zunächst einem Konfliktschlüssel
erhalten . Dies ist dieser Teil und Ort näher an
zwei, wie Sie sehen können, Standort Kids a22 ist dieser Teil und auch
außen zugewiesen, was tatsächlich bedeutet, dass ein
zweites Element
auch Konflikt sein wird 100
Standortkit wenn T2, dies ist unsere zweite Nummer und dann äußere Zuweisung
und so weiter und so weiter. Und es wird gesagt, dass eine
eindeutige ID schnell dies ist, was bedeutet, dass wir hier 12345 Objekte
bekommen. Also Advent müssen wir ein
Array mit fünf Objekten haben. Lassen Sie uns nun versuchen, diese Logik zu
schreiben, und tatsächlich werden wir hier
nichts Kompliziertes haben. Es dreht sich alles um Datenzuordnung. Probieren wir es hier aus. Unser Ergebnis, da ich es
direkt machen möchte , führt auf effiziente Weise zu
Schleifen. Und sie werden nicht hier sein
, um mit dem Standort zu arbeiten ,
nur weil wir unsere eindeutigen IDs
haben. Und hier innerhalb des Ortes bekommen
wir eine Karte, was eigentlich bedeutet, dass wir diese Objekte
durchschleifen. Hier in der Karte. Wir bekommen Standortelement und wir
bekommen auch hier Index. Deshalb muss ich hier
zusätzliche Klammern setzen. Standort n, der Index
ist das, was wir tun müssen. Jetzt können wir unsere Magie ,
denn jetzt innerhalb des
Standortelements erhalten
sie
jedes einzelne Objekt, das wir wollen, eine Maulwurfkarte, denn in unserem
Standortelement wollen
wir eine Schleife machen durch
unseren Standortschlüssel. diesem Grund können wir hier unser Standortelement
zurückgeben, und hier haben wir
unseren Standortschlüssel. Hier habe ich auch
eine Karte und wir haben Zugriff auf unseren Standortschlüssel. Und wie Sie sehen können,
habe ich es mit
CamelCase geschrieben , weil wir mit
JavaScript-Code Recht haben und normalerweise alle unsere Variablen CamelCase sind. Jetzt hier drinnen wollen wir
zurückgeben, was wir brauchen. Zuallererst brauchen wir
hier einen Zuteilungsschlüssel. diesem Grund
schreibe ich hier den Standortschlüssel. Wir können es mit
Unterstrichen wie vom Backend lassen, überwinden, in
Großbuchstaben umwandeln, nur
abhängig davon, was Sie wollen. Und hier
weisen wir nur unseren Standortschlüssel zu. Danach müssen wir unseren Konfliktschlüssel
bekommen. Dies ist extrem einfach,
da
wir hier innerhalb eines
Massenkonflikts diesen
Konfliktschlüssel einfach nach Index erhalten können. diesem Grund können wir hier den
Bow-Config-Index schreiben , da es sich dieselben See- und
Ort-Punkt-Datenwerte handelt, Punkt-Konfigurationsschlüssel. Und der letzte Teil ist das
äußere Zuweisen Delta-Zeichen. Wir bekommen innerhalb des
Standortelements ein Zeichen heraus. Und so wurde das umgestaltet,
was wir brauchten. Zuallererst
haben wir eine Karte durch unseren Standort,
durch das Thema. Und in einer Karte haben wir
für unseren Standortschlüssel. diesem Grund können
wir für jede
einzelne eindeutige ID Daten zuordnen, die wir benötigen. Schauen wir uns das
an. Ich schreibe hier
Konsolensperre unser Ergebnis
und lasst uns prüfen, ob es funktioniert. Ich lade die Seite neu und
wir bekommen eine Reihe von Arrays. Das erste Array, das
wir hier bekommen, Standortschlüssel im Freien konfiguriert, zuweisen, und alles ist gut. Das einzige Problem, das wir haben
, ist , dass wir ein Array von Arrays erhalten, aber wir
wollen tatsächlich ein flaches Array. diesem Grund müssen wir
etwas mit diesem Code machen. Wir können hier reduzieren verwenden, um
nur ein flaches Array zu erstellen da wir die Methode nicht nativ
in JavaScript
abgeflacht haben . Hier haben wir unser Array
und den Akkumulator. Und am Anfang können wir sagen , dass wir
ein leeres Array bekommen. Was wir im Inneren tun wollen
, ist array.com catenate zu verwenden. Und hier verketten wir
und das war Akkumulator. Was hier standardmäßig gemacht wird, haben
wir hier ein leeres
Array und wir haben jedes einzelne Array
, das Sie hier sehen können. Und wir wollen
unser Array mit einem Akkumulator verketten. Im Wesentlichen verketten
wir es also für
jedes einzelne Element mit unserem Akkumulator. Schauen wir uns das an. Ich lade die Seite neu und wir bekommen unser
Fled-Array mit Themen. Und so
ordnen Sie Daten zum Beispiel vom Backend-Format in
unser Front-End-Format zu.
48. Parameter in der URL ersetzen: Sie könnten auch
eine solche Aufgabe bekommen. Erstellen Sie eine Funktion, um Parameter in URL zu
ersetzen. Und tatsächlich ist dies eine reale Aufgabe, denn
hier haben wir eine erste URL, wie sie in
alten Routern für alle
Front-End-Frameworks generiert wird . Und in diesem Fall
haben wir einen anfänglichen URL-Schrägstrich, sowohl Schrägstrich als auch hier Spaltenpost AD
Slash-Kommentar-Spalten-Kommentar-ID, was bedeutet, dass diese beiden
Parameter mit Spalten
irgendwann durch IDs
ersetzt werden später. Und
zeigen Sie tatsächlich eine Funktion ersetzen params in
der URL, wo wir die URL mit einer
solchen Struktur und einem
Array von Ersetzungen in die URL
werfen können URL mit einer
solchen Struktur und einem
Array von Ersetzungen in die URL
werfen . Und wie Sie in
jedem einzelnen Objekt sehen können, das wir beispielsweise von und
zu
liefern müssen , bedeutet Post-Covid, dass wir Doppelpunkt
Post AD durch id1 ersetzen
müssen, und hier mit 83 kommentiert. Und natürlich muss diese
Funktion genetisch sein. Es ist nicht nur für
Beiträge und Kommentare gedacht, sondern auch für alle Ersetzungen innerhalb der URL. Und bevor wir
anfangen zu lösen, möchte
ich Ihnen noch
eine Sache zeigen, wie Sie über die
Lösung von Problemen nachdenken können. Zum Beispiel können Sie
so etwas wie eine To-Do-Liste schreiben. Und in diesem Fall
versuchen wir
schrittweise darüber nachzudenken , was
wir umsetzen möchten. Was wird zum Beispiel der erste Schritt
sein? Wie Sie sehen, haben wir ein
Array unserer Ersetzungen, was tatsächlich bedeutet, dass wir
eine Funktion mit zwei Argumenten haben . Und tatsächlich
möchten wir
jeden einzelnen Ersatz durchlaufen und diesen Ersatz
auf unsere URL
anwenden. Also können wir hier tatsächlich Ersatz
durchschreiben. Die zweite wird vielleicht
Teile jedes Ersatzteils ersetzen . Das Letzte, was wir hier sein werden, kehren Sie in Ihrem Stream zurück. Diese Liste
mag in diesem Fall nach
einer offensichtlichen Sache klingen, aber sie kann helfen, wenn Sie
so etwas
schreiben , um
komplexere Logik zu implementieren. Und eigentlich möchte ich hier direkt eine
richtige Lösung
implementieren. Und wir können dafür reduziert verwenden , weil es unser Code am besten ist. Aber ich möchte dir auch
das einzige Problem zeigen , das du vielleicht machen kannst. Eigentlich
möchten wir hier unsere Funktion erstellen, Params in URL
ersetzen, und wir erhalten hier URL
und unsere Liste der Ersetzungen. Und eigentlich ist das, was wir hier drehen
wollen, für
unseren Ersatz reduziert ,
Ersatzpunktreduzierung. Und hier haben wir
unsere Funktion mit Akkumulator und jedem
Ersatz. Diesen Anfangswert
haben wir hier unsere URL, denn das möchten
wir ändern. Jetzt müssen
wir hier in der Funktion eine aktualisierte Zeichenfolge zurückgeben. Und dafür können wir
eine einfache JavaScript-Funktion verwenden , die als ersetzt bezeichnet wird. Und tatsächlich
versuchen Sie hier vielleicht, so zu zeichnen. Du kannst denken,
Okay, ich habe eine URL, wir können einfach hier schreiben, URL ist gleich URL-Punkt ersetzen. Hier ersetzen wir
zunächst Spalte plus
Ersatzpunkt von, und wir ändern ihn
in Ersatzpunkt t2. Das ist es. Und danach möchten
wir unsere URL zurückgeben. Und tatsächlich
sieht dieser Code irgendwie korrekt aus. Und jetzt möchte ich unsere
ursprüngliche URL und die Ergebnisse
hier nach unten verschieben und die Ergebnis-URL des
Konsolenprotokolls schreiben. Und lasst uns prüfen, was wir haben. Ich lade die Seite neu
und wir bekommen genau den Schrägstrich nach Schrägstrich eins, Slash Common Slips drei, was tatsächlich bedeutet, dass diese Logik mit reduziert korrekt
funktioniert. Wir durchlaufen
jeden einzelnen Ersatz. Hier haben wir unsere URL aktualisiert und hier geben wir sie zurück und sehen
nicht gut aus, aber tatsächlich haben Sie
hier ein großes Problem. Wie Sie sehen können,
ist meine
Akkumulatorvariable nicht hervorgehoben, was bedeutet, dass wir
hier nicht
korrekt reduzieren verwenden und überhaupt keinen Akkumulator verwenden. Was wir verwenden,
verwenden wir diese URL von params und mutieren
diese URL jedes Mal direkt. Und eigentlich ist das
zuallererst
völlig falsch, weil wir unsere Params nicht mutieren
sollten. Und zweitens reduziert sich der
wichtigste Teil, den wir
hier verwenden , wie eine
for-Schleife
, weil wir unsere Variable einfach von
außen in der Schleife
mutieren und unseren Akkumulator
nicht verwenden. Eigentlich ist der richtige Code
hier nicht ersetzen, sondern einfach den
akkumulierten Ersatz zurückgeben. Denn wie Sie sehen können, haben wir hier Rail hier
als Anfangswert
zur Verfügung gestellt und wir sollten hier
keine URL verwenden. Wir möchten unsere URL nicht ändern. Wir möchten jedes
Mal
unseren Akkumulator aktualisieren und einen neuen Akkumulator zurückgeben
. Wie Sie sehen können, funktioniert dieser Code genau gleich,
aber das ist
völlig anders. Wenn Sie zuvor Code wie diesen
schreiben würden, ist
dies im Interview völlig falsch , da Sie
nicht reduzierte,
reduzierte, aber genau wie for-loop verwenden , das Gleiche mit Map. Wenn Sie die Map
nur verwenden, um
Dinge zu durchlaufen , die Sie mit Map
einen Trend machen, müssen
Sie Ihr
Array transformieren und zurückgeben.
49. Validation: Möglicherweise erhalten Sie auch eine
Frage wie diese für MOD-Backend-Validierungsnachricht, die vorne und formatiert werden soll. Und tatsächlich ist dies ein
echtes Beispiel, denn manchmal erhalten wir
Backend-Validierungsmeldungen, nicht in dem Format, wie
es
im Frontend für
unsere JavaScript-Formulare schnell geeignet ist . diesem Grund erhalten wir hier unsere Backend-Fehler
in einem solchen Format. Wir haben hier ein
Objekt mit Schlüsseln und jeder einzelne Schlüssel ist eine
Eigenschaft aus dem Back-End. Unser Feld, das wir überprüfen,
zum Beispiel E-Mail. Und hier haben wir Fehler ausgefüllt, und das ist es, was
an
Dateifehlern interessiert ist ein
Array von Objekten. Und in jedem einzelnen Objekt haben
wir Nachrichteneigenschaft
mit einer Nachricht. Zum Beispiel haben wir hier
ein Passwort mit zwei Fehlern. Dies ist es, was hier ein
Array mit zwei Objekten ist. Hier ist die Nachricht muss in einem
anderen Fall Symbole
enthalten und muss
mindestens acht Symbole sein. Was wir
in dieser Übung machen wollen, wollten
wir sie
in unser Front und unser Format umwandeln. Dies ist nur ein planares Array mit Strings und jeder einzelne
Stream ist unser Schlüssel. Also unsere angeheizt wie E-Mail, und jetzt haben wir alle unsere
verketteten Fehler wie zum Beispiel, nicht leer sein
können. Und wenn wir zwei
von ihnen haben, verketten wir sie
einfach mit Komma. Sie können
es also tatsächlich auf verschiedene Arten lösen, aber ich empfehle dringend, ein Objekt hier zu
verwenden. Wir können hier einfach
Objektpunkteinträge schreiben und
innerhalb unserer Backend-Fehler angeben. Und wie Sie
sehen können, erhalten wir ein so schönes Format wie
Arrays von Arrays. Und jedes einzelne Array
hier ist zuerst, folge einem Schlüssel und der Wert
ist der, was wir hier hatten. Wir haben also einen Wert mit Fehlern und im Inneren haben
wir unsere Fehler. Und das ist ein wirklich
komfortables Format , um für uns zu funktionieren, da wir Map in
JavaScript nicht wirklich auf das Objekt aufrufen
können. diesem Grund
möchten wir, was wir hier tun wollen, zunächst, um eine normale
Eigenschaft
zu erstellen, kann menschlich lesbare Backend-Fehler sein. Und jetzt wollen wir
hier Objektpunkteinträge aufrufen. Und wir möchten
innerhalb unserer Backend-Fehler bereitstellen. Eigentlich haben wir jetzt
ein Array von Arrays und wir können hier
jeden einzelnen Wert abbilden. Und du hast schon gesehen
, was wir hier kriegen. Wir bekommen ein
Array mit E-Mail als Schlüssel und einem gewissen Wert. Und eigentlich
möchte ich hier das reguläre diese
Strukturierung verwenden , um
zuerst unsere Schlüssel- und Zweitschleife zu erhalten, wir bekommen unseren Wert. Dies ist der einfachste Weg, wie Sie Map für das Objekt verwenden
können. Und hier
bekommen wir vor allem unser Feld und zweitens
Wert mit den Fehlern. Deshalb müssen wir unsere Fehler
vorbereiten. In diesem Fall
nennen wir sie beispielsweise
Feldnachrichten, und wir
müssen sie verketten. So können wir hier
Wertepunktfehler schreiben. Also bekommen wir unsere
Reihe von Fehlern. Und jetzt müssen wir hier jeden einzelnen Fehler
abbilden. Hier rufen wir
map fehlerfrei und möchten eine
Fehlermeldung zurückgeben. Und wie Sie
hier sehen können, stimmt das. Wir haben hier Array
mit Objekten und jedes einzelne Objekt
enthält unsere Botschaft. Hier
kartieren wir nur diese Nachrichten. Und nachdem diese Gruppe den Namen bekommen wollte
. Hier werde ich Join-Komma und
Leerzeichen setzen , weil wir geboren sind, um eine schöne lesbare Zeichenfolge zu
haben. Und danach müssen wir
einfach
unsere Zeichenfolge zurückgeben, da
wir uns hier in der Map befinden. Ich möchte hier
ECMO-Skript sechste Zeichenfolge verwenden, und innen
wollten sie unseren Schlüssel bereitstellen. Aber hier ist das Problem. Wie Sie sehen können, ist es
immer groß geschrieben. Zuallererst müssen wir es
kapitalisieren und wir haben es bereits
in früheren Videos gemacht. Hier können wir es großgeschrieben
benennen,
und tatsächlich denke ich, fülle diesen besseren Namen. Benennen wir also
unseren Schlüssel zu Feld um. Und jetzt
müssen wir auf Feld aufrufen, zuerst Zeichen bei 0. In diesem Fall werden wir
unser erstes Element genommen und wir wollen verketten, dass es gefüllte Punktscheibe
war. Und hier setzen wir eins ein, wurde in ein Symbol geschnitten. In diesem Fall ist es unser
großgeschriebener Name des Feldes. Jetzt müssen wir hier
dieses großgeschriebene Feld bereitstellen, und hier ist D wichtig. In anderen Fällen können wir
denken, dass dies
eine Funktion ist und danach einfach Spaltenraum gesetzt
wurde. Und hier unsere Außenbotschaften. Was wir hier machen, erstellen
wir unsere Objekteinträge, wo wir
direkt unser Feld und unseren Wert erhalten . Zuallererst schließen wir uns
unseren Field Messages an. Und zweitens
nutzen wir unser Feld und jetzt geben wir Stream
für jeden einzelnen Fehler zurück. Schauen wir uns das an. Ich lade unsere Seite neu und
lasst uns prüfen, was wir in menschlich
lesbaren Fehlern
haben. Und wie Sie sehen können, ist dies unser nettes Array
im richtigen Format. Also haben wir hier Strings für jedes einzelne Feld und wir schreiben den Namen jedes
Feldes groß. Und hier haben wir uns unseren Fehlern
angeschlossen, was bedeutet, dass es uns gelungen ist, dieses Problem
zu lösen und Daten in
das richtige Format zu transformieren.
50. Liste mit Nestern: Vielleicht bekommst du auch eine
Frage wie diese. Transformieren Sie die flache Liste
in verschachtelte Liste. Und das ist ein
super echtes Zeug. Normalerweise erhalten
Sie aus dem Backend alle Daten
als flache Liste, und normalerweise können diese Daten
Kinder voneinander haben. Was für
uns im Frontend bedeutet, es nicht angenehm ist, diese Daten
zu rendern. Wir können einfach mit for-Schleife gehen
, weil wir Kinder haben. Wir müssen zuerst auf
kleinen Ebenen rendern und dann
für jedes einzelne Element seine untergeordneten Elemente
finden
und rendern. diesem Grund
möchten Sie Ihre Daten normalerweise nur einmal
von der flachen Liste in eine
verschachtelte Liste umwandeln . Und genau das müssen
wir in diesem Video tun. Wie Sie hier sehen können, haben wir unsere flache Liste und jedes
einzelne Element ist ein Objekt. Wir haben eine eindeutige ID, einen Namen und übergeordnete Daten. Und zuallererst ist
es wichtig, da dies unsere eindeutige Kennung
und zweitens übergeordnete ID ist und
entweder ein anderes Element hinzugefügt werden kann. Zum Beispiel hier, übergeordnetes Element, ist
dies dieser Artikel. Dieses Objekt ist also ein
übergeordnetes Element dieses Elements. Und zweitens können übergeordnete
Daten null sein, wenn dies ein Root-Element
ist und
kein übergeordnetes Element hat. Wie Sie hier sehen können, haben
wir zwei Wurzelelemente
mit ad1 und zwei. Jetzt haben wir einen D3, der
das Kind
des Elternteils Edu ist. Dies ist also die zweite Ebene. Hier heißt der Name seine
Stufe zwei, Punkt drei. Du verstehst also das Level. Und jetzt haben wir einen Standardwert, der anscheinend D drei ist, was tatsächlich bedeutet, dass
dies ein Kind
dieses Elements ist , und tatsächlich ist
dieses Elternteil drei das. Deshalb ist es Stufe
drei, Punkt vier. Und hier haben wir ad5, das eigentlich ein
Kind von übergeordnetem D zwei ist, was bedeutet, dass dieses Element und was bedeutet, dass dieses Element und
tatsächlich
erhalten wir auf diese
Weise Daten aus dem Backend. Jetzt müssen wir
es in ein solches Format umwandeln. Wir haben also ein flaches Array
mit nur zwei Elementen. Wie Sie hier sehen können, haben wir zwei Objekte mit
81 und das Objekt mit ad2, da sie sowohl durch
Elemente als auch ihre
übergeordneten Daten
sind . Jetzt haben wir ein
neues Eigentum Kinder. Und genau das sind Kinder
, die im Inneren abgebildet sind. Und hier, wie Sie
sehen können, haben wir ad3 und auch Kinder
drinnen, weil
ad4 tatsächlich in
D drei verschachtelt ist und genau
das gleiche wie wir hier haben. Wir haben in D zwei Kinder
und hier ad5 und Kinder. Und ich habe hier Namen weggelassen , weil sie für das Verständnis nicht
wichtig sind. Aber natürlich können Sie hier
alle zusätzlichen Eigenschaften haben . Und wie Sie
im letzten Level sehen können ,
haben Sie keine Kinder. Dann kommen wir hier rein,
Kinder, leeres Array. Unsere Aufgabe besteht nun darin, die
flache Liste in verschachtelte Liste umzuwandeln. Und wie der Älteste bereits
sagte, ist es
für manche Leute viel
einfacher, einfach zu zeigen wie sie es lösen und es dann einfach programmieren. Deswegen. Versuchen wir es jetzt zu tun. Zuerst schreibe ich
hier, um das zu tun, was wir tun. Der erste Punkt ist,
Elemente loszuwerden , weil
wir dies rendern möchten. Versuchen wir, genau so die Wurzelelemente
zu bekommen. Wir müssen also ein Array
unserer Wurzelelemente haben. Der zweite Punkt besteht darin
, alle Kinder zu überprüfen und zu verstehen, ob unsere beiden
Elemente Kinder haben. Wenn nein, geben wir sie heute einfach
zurück. Wenn ja, müssen wir
rekursiv Kinder finden. Und wir müssen es rekursiv tun
, weil wir jedes einzelne Element
überprüfen
und prüfen müssen , ob es Kinder hat. Also können wir hier
so etwas schreiben. Prüfen Sie Kinder, ob
sie Kinder haben. Und jetzt
wird der nächste Punkt sein, wenn nicht, dann geben wir einfach Artikel
mit leeren Kindern zurück. Und Nummer vier hier ist, wenn ja, dann wollen wir zu Nummer zwei
gehen, was eigentlich bedeutet, dass
wir
rekursiv Nummer zwei machen , bis wir
am Ende unserer Elemente sind. Versuchen wir nun, den Code zu schreiben. Zunächst möchte ich es also unserer verschachtelten Liste
zuweisen. Und was ich tun möchte, möchte
ich unsere flache Liste nehmen
und nach kleinen Elementen suchen. Und dafür können wir einfach
Filter verwenden, weil wir alle Elemente
finden möchten, in denen sich
unsere übergeordnete ID jetzt befindet. In diesem Fall können wir einfach
sagen, dass unsere Artikel - und
Artikelpunkt-Eltern-ID gleich null ist. Also sind wir bereit zu gehen. Schauen wir uns das an.
Zeit zum Laden der Seite. Und jetzt haben wir unsere verschachtelte Liste. Wie Sie sehen können, haben wir
unsere Reihe von Objekten. Und hier haben wir 81 und 82 weil ihre
Eltern. Das sind jetzt. Genau das wollten wir. Danach möchte ich diese Map und in die
Funktion als Kinder schreiben . Warum mache ich so? Denn tatsächlich wird diese
Funktion
rekursiv aufgerufen und es wäre eine völlig zustandslose Funktion, was tatsächlich
bedeutet, dass wir
diese Funktion für jedes
Element aufrufen müssen und es funktionieren muss. Das möchte
ich hier erstellen. Unsere ADD Children Funktion
und wir bekommen hier einen Artikel brauchen
aber
nichts anderes, denn hier haben wir unsere flache
Liste ganz oben. Wenn Sie es oben nicht
zur Verfügung haben, können Sie
hier vielleicht ein zweites Argument bekommen, eine flache Liste in Ihrem Code, aber es wird in
Ihrem echten Projekt enthalten sein. Hier haben wir Zugriff
auf unsere Fluchtliste. Was wir also hier tun, durchlaufen
wir
unsere Root-Elemente und bilden Kinder ab,
was bedeutet, dass
wir jedem
einzelnen Routenelement
Kinder hinzufügen möchten . Zuallererst
müssen wir unsere Kinder finden. Also lasst uns gleich hier, Kinder. Und wir wissen, dass unsere
Kinder nur eine flache Liste sind, die nach
übergeordneten Daten gefiltert wird, wobei ID der
Artikelpunkt-ID entspricht. Also lasst uns das machen. Jetzt nehmen wir einfach eine
flache Liste, einen Punktfilter, und hier haben wir unser untergeordnetes Element und
nennen es uns, zum Beispiel
untergeordnete Artikel, und wir möchten überprüfen übergeordnete ID des
untergeordneten Artikels
in unserer Fallpunkt-ID gleich ist. In diesem Fall
finden wir alle unsere Kinder. Lass uns console.log
was wir hier haben. Also schreibe ich nur Kinder, die auf der Seite
unterstrichen sind. Und wie Sie hier sehen können,
haben wir ein einziges Element, denn dies ist ein Kind von
Foto-Element mit einem D1. Und hier haben wir
auch noch ein Kind von Fruchtelement mit Elternteil 82, was bedeutet, dass
es richtig funktioniert. Der nächste Punkt ist zu prüfen
, ob wir Kinder haben. Hier können wir also schreiben. Wenn unsere Kinder
größer als Null sind, müssen wir unsere
rekursive Magie ausüben weil wir nicht nur Kinder von Kindern
bekommen müssen, sondern wir müssen es rekursiv tun. Was ich tun möchte,
bevor ich
einen Eigenschaftenlad erstellen möchte , war die eigene
Ness für Kinder und sie wollen hier ein
leeres Array zuweisen ,
denn wenn wir uns
nicht im SIF befinden , müssen wir uns
nicht ändern irgendetwas Wir müssen einfach leere Kinder
zurückgeben. Und wie Sie
sehen können, habe ich hier
standardmäßig ein leeres Array zugewiesen , damit wir hier Object
Assign zurückgeben können und hier bin ich. Richtig, ein leeres Objekt
dann Komma, item, Komma. Und hier sind unsere Kinder. Verschachtelte Kinder. Warum
habe ich so geschrieben? Denn wenn
Sie hier
Push oder einfach nur mit gespeichert verwenden , sagen
Sie, dass hier unsere verschachtelten Kinder
sind. Dann mutieren Sie das Element,
was bedeutet, dass Sie dieses Element in der
flachen Liste ändern
werden , da wir
eine Objektreferenz haben .
Wir wollen das nicht. Wir möchten einfach Ihre Daten
zurückgeben. Deshalb verwende ich hier Object Assign mit leerem Objekt. Danach verwenden wir unseren Artikel, also kopieren wir
alle Eigenschaften
unseres Artikels in dieses neue Objekt und wurden hier in
Ihren Immobilienkindern angemeldet, was uns für Kinder entspricht. Und in diesem Fall haben
wir einfach verschachtelte Kinder ein Objekt
leeren
lassen. Schauen wir uns das an.
Zeit zum Laden der Seite. Hier ist unsere verschachtelte Liste. Und wie Sie sehen können, haben wir jetzt leeres Array für
Kinder, weil wir für diesen Vorabend
eigentlich
keine Logik geschrieben haben. diesem Grund geben wir einfach Daten in einem
solchen Format
zurück ID Name übergeordnete ID tatsächlich alle Felder und
zusätzlich untergeordnete Felder. Und wie Sie sehen können, haben wir
hier nur zwei Elemente, was bedeutet, dass alles
richtig funktioniert und wir müssen hier einfach
rekursiv unseren Code aufrufen. Was wir also hier tun wollen, wollen
wir
jedes einzelne Kind durchschauen und Kinder anrufen, die an diesem Kind
funktionieren. So können wir hier
unsere verschachtelten Kinder zuweisen. Und das sind nur unsere
Kinder, diese Karte. Und wir haben Zugang zu
jedem einzelnen Kind. Und wir nennen es
Kinder mit unserem Kind. Was passiert
in diesem Fall? Zum Beispiel haben wir das Kind gefunden. Wir schauen hier nach, okay? Wir haben ein Kind
in, sagen wir, Kindern. Und hier kartieren
wir unser Array. Und für jedes einzelne Element
rief bei Kindern den wichtigsten Teil, der
Colin war, dieser funktioniert
rekursiv. Zuallererst haben wir es
hier im Wurzelelement genannt. Jetzt hier in den Kindern
waren Colin es war Landkarte. Und als wir es hier
nannten, waren Hühnchenkinder dieses Kindes, was eigentlich bedeutet, dass es
rekursiv gehen wird , bis wir
keine Kinder haben und wir einfach
nicht in diesen Zustand gehen. So war zum Beispiel in unserem Fall Colin dreimal
hier. Zuerst machen
Sie für Sie eins dann für ID3 und dann für einen Standardwert. Und genau deshalb brauchen wir hier eine Rekursion.
Schauen wir uns das an. Zeit zum Laden der Seite. Schauen wir uns unsere verschachtelte Liste an. Und wie Sie sehen können, haben
wir jetzt Kinder. Und in Punkt eins haben
wir nur ein Kind mit ad3, und wir haben auch ein
Kindereigentum drin und wir haben hier
ein weiteres Kind, Ebene drei, Punkt vier, und wir haben Kinder leer weil tatsächlich unsere Rekursion endete und wir einfach
leere Kinder bekommen haben und
wir sie hier zuweisen. Also müssen
wir zunächst einmal alle unsere Straßenelemente bekommen. Zweitens müssen wir
eine Funktion erstellen, die wir jedes Element rekursiv
aufrufen
können. Und das sind unsere Kinder. Jetzt, drinnen,
versuchten die Kinder
zunächst, alle
Kinder des Gegenstandes zu finden, und zweitens Bären Hühnchen. Wenn wir
für unsere Kinder eine Rekursion machen müssen ,
falls wir welche haben. Wenn ja, dann sind wir Colin
bei Kindern rekursiv. Wenn nein, machen wir einfach eine
Objektzuweisung und die Rückkehr
hierher unsere Kinder. So
machen Sie es normalerweise im realen Projekt.
51. Hausaufgaben: Sie haben meinen Kurs
zur Vorbereitung auf das
JavaScript-Interview erfolgreich
abgeschlossen . Und ich denke, dass du
großartig bist , wenn du es zusammen
fertig hast, wir haben 59
JavaScript-Interviewfragen implementiert. Und tatsächlich waren viele
von ihnen nicht einfach, wenn Sie es nicht selbst
ausprobiert haben, sondern einfach dem Darlehen folgen. kannst du immer noch machen. Sie können einfach
ein Video nach dem Zufallsprinzip auswählen und versuchen, es selbst zu
implementieren ,
auch wenn Sie
es einmal gesehen haben , ist es sehr sinnvoll, es
zu versuchen. Außerdem wollte ich
dich nur daran erinnern, nicht depressiv zu sein. Wenn Sie das Interview nicht bestanden haben, wird
es mit der Zeit kommen und Sie werden sicher Ihren Kotelett
finden. Sie müssen nur mehr Wissen
sammeln,
verstehen, welche Frage
Ihnen in
den Interviews gestellt wird , und sich besser
vorbereiten. Ich hoffe, dass Sie viel
gelernt haben und wir sehen uns in
meinem nächsten Kurs.