LearnJS
1.0.0
LearnJsist ein Versuch, die besten Teile von JavaScript darzustellen, die ziemlich hart und schwer zu finden sind. Es ist zu beachten, dass dies in keiner Form ein Buch/Leitfaden ist, sondern eine Gemeinde von Best Practices, Sprachkonstrukten und anderen einfachen, aber effektiven Ausschnitten, die uns eine Essenz dafür geben, wie wir das Beste aus der Sprache heraus nutzen können.
1.1 Declarations :
// bad
var arr = new Array ( ) ;
var str = new String ( ) ;
var num = new Number ( ) ;
var boo = new Boolean ( ) ;
var obj = new Object ( ) ;
var reg = new RegExp ( ) ;
var fun = new function ( ) ;
// good
var arr = [ ] ,
str = "" ,
num = 0 ,
boo = false ,
obj = { } ,
reg = / () / ,
fun = function ( ) { } ; Wir müssen die Tatsache verstehen, dass in JavaScript alles ein Objekt ist. Wenn wir also eine Zeichenfolge unter Verwendung des String -Objekts deklarieren und es mit var a = "" vergleichen, wäre das Ergebnis des Vergleichs falsch. Dies liegt einfach daran, dass wenn wir eine Zeichenfolge mit dem bad Weg deklarieren und mit einer Zeichenfolge vergleichen, die unter dem good Weg deklariert ist, im Grunde genommen eine Zeichenfolge mit einem Objekt (String) vergleichen.
Semicolons :
// Snippet one
var foo = { }
foo . code = "this is javascript empire"
foo . engine = "node 0.12.7"
foo . author = "akhil pandey"
foo . version = 0.1
// Snippet two
var bar = { } ;
bar . name = "akhil pandey" ;
bar . url = "www.akhilhector.com" ;
bar . github = "AkhilHector" ;
bar . age = 20 ;
if ( typeof ( bar ) == typeof ( foo ) ) {
console . log ( "Semicolons donot matter at all" )
}Code -Snippet eins und zwei sind gleich. Der grundlegende Unterschied zwischen beiden Code -Stichproben besteht jedoch darin, dass einer Semikolonen in der Lang -Uage -Semantik verwendet, aber der andere nicht. Grundsätzlich wird uns beigebracht, Semikolone in Sprachen wie C, C ++, Java usw. zu verwenden, da Codezeilen mit ''; 'beendet werden;'; Aber in JavaScript ist das gesamte Szenario anders. Es gibt absolut keinen Unterschied in der Ausführung von Code mit oder ohne Semikolons.
Methoden Teil des JavaScript -Kartenobjekts :
2.1 map .set ():
let m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . set ( "name" , "akhil pandey" ) //Map { { id: 1 } => 'foo', { id: 2 } => 'bar', 'name' => 'akhil pandey' } Map .set () ist eine Methode, mit der ein Element mit einem bestimmten Schlüssel und Wert in einer Karte hinzugefügt oder aktualisiert wird. Hier ist das erste Argument der Schlüssel, während das zweite Argument der Wert ist. Die Schlüssel können von jedem Typ sein, aber es wäre vorzuziehen, objects als Schlüssel anstelle von strings zu verwenden, da, wenn wir strings als Schlüssel verwenden, keinen signifikanten Unterschied zwischen Maps und Objects geben würde.
2.2 Karte .get ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . get ( x ) ; //returns 'foo' Map .get () ist eine Methode, mit der ein Element mit einem bestimmten Schlüssel aus dem Map abgerufen wird. Der Schlüssel wird also als Argument übergeben und das mit diesem Schlüssel zugeordnete Element wird zurückgegeben. Wenn kein Schlüssel als Argument übergeben wird, kehrt die Methode mit undefined zurück.
2.3 Karte .has ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . has ( x ) // returns true
m1 . has ( "akhil" ) // retuqrns false Map .has () ist eine Methode, die angibt, ob ein Element mit dem angeforderten Schlüssel in der Karte vorhanden ist oder nicht. Die Methode nimmt nur ein Argument an, das der Schlüssel ist, und gibt ein true zurück, wenn das Element vorhanden ist oder false wenn das Element nicht vorhanden ist.
2.4 Karte .Size:
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . size ; MAP .SIZE ist eine Accessor -Eigenschaft, die die Anzahl der im Map -Objekt vorhandenen Elemente zurückgibt. Da es sich um eine Accessor -Eigenschaft handelt, sollten wir diese nicht wie eine Methode anrufen/verwenden. Wenn m1.size() aufgerufen wird, wird ein Typeerror ausgeführt, in dem m1.size keine Funktion ist. Daher ist der gültige Aufruf dieser Eigenschaft m1.size .
2.5 Karte .Clear ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . has ( x ) ; // returns true
m1 . clear ( ) ;
m1 . has ( x ) ; // returns false Map .clear () ist eine Methode, die alle Elemente löscht/entfernt, die im Map vorhanden sind. Die Methode nimmt keine Argumente auf, sondern wirft im Gegenzug undefined .
2.6 Karte .Delete ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . has ( x ) ; // returns true
m1 . delete ( x ) ; // returns true
m1 . delete ( "something" ) ; // returns false
m1 . has ( x ) ; // returns false Map .delete () ist eine Methode, die zum Löschen eines bestimmten Elements aus dem Map verwendet wird. Die Methode nimmt nur ein Argument auf, das der Schlüssel ist. Wenn der Schlüssel in der Map vorhanden ist, löscht sie das Element und gibt ein true zurück. Wenn der Schlüssel jedoch nicht in der Map vorhanden ist, wirft es ein false .
2.7 Karte .Keys ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . keys ( ) ; // MapIterator { { id: 1 }, { id: 2 } }
let iterator = m1 . keys ( ) ;
console . log ( iterator . next ( ) . value ) ; // { id: 1 }
console . log ( iterator . next ( ) . value ) ; // { id: 2 }
console . log ( iterator . next ( ) . value ) ; // undefined Map .Keys () ist eine Methode, mit der die im Map vorhandenen Schlüssel für jedes Element zurückgegeben werden. Die Methode gibt ein Karten -Iterator -Objekt zurück, mit dem die in der Map vorhandenen Schlüssel zu wissen können. Im obigen Beispiel wird beschrieben, wie über Map .KEYS () mit next() iteriert werden kann. Es ist anzumerken, dass beim next() im Iteratorobjekt entweder value oder done wird, da eine geradlinige Verwendung von next() zur Anzeige eines Object führt. iterator.next().value gibt den Wert des im Iteratorobjekts vorhandenen Schlüssels zurück, während iterator.next().done gibt ein boolescher Sprache zurück, das false sagt, wenn mehr Schlüssel im Iteratorobjekt vorhanden sind, und true wenn keine weiteren Schlüssel vorhanden sind.
2.8 Karte .Values ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . values ( ) ; // MapIterator { 'foo', 'bar' }
let iterator = m1 . values ( ) ;
console . log ( iterator . next ( ) . value ) ; // foo
console . log ( iterator . next ( ) . value ) ; // bar
console . log ( iterator . next ( ) . value ) ; // undefined Map .Values () ist eine Methode, mit der die im Map vorhandenen Werte für jedes Element zurückgegeben werden. Die Methode gibt ein Iteratorobjekt zurück, das zum Wissen der in der Map vorhandenen Werte verwendet werden kann. Im obigen Beispiel wird beschrieben, wie über Map .Values () mit next() iteriert werden kann. Es ist anzumerken, dass beim next() im Iteratorobjekt entweder value oder done wird, da eine geradlinige Verwendung von next() zur Anzeige eines Object führt. iterator.next().value gibt den Wert eines bestimmten Elements zurück, das im Iteratorobjekt vorhanden ist, während iterator.next().done gibt ein boolescher Sprache zurück, das false sagt, wenn im Iteratorobjekt mehr Werte vorhanden sind, und true wenn keine mehr Werte vorhanden sind.
2.9 Karte .ententries ():
var m1 = new Map ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // Map { { id: 1 } => 'foo' }
m1 . set ( y , "bar" ) ; // Map { { id: 1 } => 'foo', { id: 2 } => 'bar' }
m1 . entries ( ) ; // MapIterator { [ { id: 1 }, 'foo' ], [ { id: 2 }, 'bar' ] }
let iterator = m1 . values ( ) ;
console . log ( iterator . next ( ) . value ) ; // [ { id: 1 }, 'foo' ]
console . log ( iterator . next ( ) . value ) ; // [ { id: 2 }, 'bar' ]
console . log ( iterator . next ( ) . value ) ; // undefined MAP .Entries () ist eine Methode, die verklagt wird, um die im Map für jedes Element vorhandenen Schlüssel und Werte zurückzugeben. Die Methode ist der MAP .Values () ziemlich ähnlich, um ein Iteratorobjekt zurückzugeben, mit dem die in der Map vorhandenen Schlüssel und Werte bekannt werden könnten. Im obigen Beispiel wird es angezeigt, wie es mit next() über die Karte .ententries () iteriert werden kann. Die Fähigkeit der Methode und ihre Betriebsweise sind der MAP -Werte () sehr ähnlich (), mit Ausnahme der Tatsache, dass Tasten auch zusammen mit den Werten zurückgegeben werden, wenn wir über das Iteratorobjekt iterieren. Ähnlich wie bei jedem Iteratorobjekt , sobald es das Ende seines Flugzeugs erreicht, würde es sich undefined . Es ist auch zu beachten, dass jede andere Methode, die für ein Iteratorobjekt gilt, damit verwendet werden kann, da es ein und dasselbe ist.
MISC[Maps] : Schwächen können als Karten mit Unterschieden in der Methodik betrachtet werden, deren Müllsammlungen unter der Motorhaube auftreten. Um es einfacher und einfacher Terminologie zu setzen, muss eine kleine konzeptionelle Lektion erzählt werden, um Perspektive zu bringen. In JavaScript ist alles ein Objekt , sodass der Moment, in dem Sie einen erstellen und der Speicher für dasselbe zugewiesen wird, und bis der V8 automatisch GCs (kurz für den Müll sammelt) das Objekt als Knoten im Diagramm bleibt. Es ist anzumerken, dass bis es keine Verweise auf das in der Speicher erzeugte Objekt gibt, es nicht gc'd wird, sodass alle Objekte tightly oder strongly gehalten werden. Im Wesentlichen wird der Unterschied, der mit Schwächen mitgebracht wird, darin besteht, dass die Schlüssel des Objekts weakly gehalten werden. Wenn das Objekt von V8 oder von Ihnen gciert wird, würde der Eintrag aus der Schwächung entfernt, aber keine Werte sind. Es gibt keinen strengen Unterschied zwischen der Art und Weise, wie Karten und Schwächungen funktionieren, obwohl Schwächen nur Objekte (streng) als Schlüssel akzeptieren. Lassen Sie uns unten sehen, wie sie initialisiert werden:
var m1 = new WeakMap ( ) ;
let x = { id : 1 } ,
y = { id : 2 } ;
m1 . set ( x , "foo" ) ; // WeakMap {}
m1 . set ( y , "bar" ) ; // WeakMap {}
m1 . get ( x ) ; // 'foo'
m1 . get ( y ) ; // 'bar'm1. Es ist anzumerken, dass die Art und Weise, wie die API schwächst, mit uns auf die gleiche Weise wie das MAPS -Objekt interagiert, aber es gibt Einschränkungen für die von der API der Schwächen bereitgestellten Operationen. Es unterstützt get() , set() , has() und delete() bis ab sofort.
MISC[Maps] : Verwendung von ... Operator
Methoden Teil des JavaScript -Set -Objekts:
3.1 set .add ():
var s1 = new Set ( )
s1 . add ( 'akhil' )
s1 . add ( 123 )
s1 . add ( 456.789 )
s1 . add ( true )
s1 . add ( { id : 123456 } )
s1 . add ( NaN )
s1 . add ( null )
console . log ( s1 ) // Set { 'akhil', 123, 456.789, true, { id: 123456 }, NaN, null} Set .add () ist eine Mutatormethode zum Hinzufügen von Werten zu einem Satz. Das Verfahren, um dies zu erreichen, ist unkompliziert. Wir rufen die add() -Methode auf das bereits erstellte Set -Objekt auf und übergeben den Wert, den wir als Argument gewünscht haben. Wenn mehr als ein Argument an die add() -Methode übergeben wird, ignoriert es nur die verbleibenden Argumente und berücksichtigt nur das erste Argument. Es ist anzumerken, dass das Set Objekt weder Einschränkungen für die Art des übergebenen Werts hat noch Einschränkungen erzwungen, wenn wir die Set Heterogen machen. NaN , null kann auch Teil eines Set sein. Es wird zwar nie ermutigt, den Set mit den Werten dieser Art zu füllen.
3.2 einstellen .has ():
var s1 = new Set ( )
s1 . add ( 123 )
s1 . add ( 456 )
s1 . add ( 789 )
s1 . add ( "akhil" )
s1 . add ( null )
s1 . has ( 123 ) // returns true
s1 . has ( NaN ) // returns false
s1 . has ( "akhil" ) // returns true
s1 . has ( 456.12 ) // returns false
s1 . has ( 123.0000000000000009123 ) // returns true Set .has () ist eine Methode, die bei der Feststellung hilfreich ist, ob ein Element im Set existiert oder nicht. Die Methode gibt entweder true zurück, wenn der Wert vorhanden ist, und false wenn der Wert nicht vorhanden ist. Wenn wir das obige Beispiel beobachten, besteht eine geringe Ungleichheit zwischen der erwarteten Natur der Methode und ihrer Grundrealität. s1.add(123.0000000000000009123) ist ein Beispiel, das die jahrzehntelange Rivalität zwischen JavaScript- und schwimmenden Punktwerten beleuchtet. Dies könnte einfach unter Verwendung der Anzahl .topRecision () vermieden werden. Außerdem wird es in JavaScript immer ermutigt, schwimmende Punkte sorgfältig zu behandeln.
3.3 SET .SIZE:
var s1 = new Set ( [ 1 , 23 , 456 , 78910 ] )
var s2 = new Set ( )
s2 . add ( "akhil" )
s2 . add ( "chandu" )
s2 . add ( "adheeth" )
console . log ( s1 . size ) // returns 4
console . log ( s2 . size ) // returns 3 Set .Size ist keine Methode, sondern eine Eigenschaft des Sets -Objekts, die zur Bestimmung der Größe des Set nützlich sind. Wie Sie aus dem obigen Code -Snippet beobachten können, wird es nur als Accessor -Methode bezeichnet. Wenn wir versuchen, die Eigenschaft mit size() aufzurufen, wirft sie ein Typeerror -Set Set.size aus. Größe ist keine Funktion.
3.4 einstellen .clear ():
var s1 = new Set ( )
s1 . add ( "akhil" )
s1 . add ( "krishna" )
s1 . add ( "pardhu" )
console . log ( s1 . has ( "akhil" ) ) // returns true
console . log ( s1 . has ( "krishna" ) ) // returns true
s1 . clear ( "pardhu" )
s1 . clear ( )
console . log ( s1 . has ( "akhil" ) ) // returns false
console . log ( s1 . has ( "pardhu" ) ) // returns false Set .clear () ist eine Methode, die alle im Satz vorhandenen Elemente löscht. Dies führt zum Entleeren des Set . Wenn wir im obigen Code -Snippet beobachten, gibt es einen Versuch, ein Argument an die set .clear () -Methode zu übergeben und unabhängig davon, welches Argument an die Methode übergeben wird, die sie nur ignoriert und die clear() -Operation am Set ausführt. Außerdem gibt es keine Einschränkung über die Häufigkeit, in der die Operation durchgeführt wird.
3.5 SET .Delete ():
var s1 = new Set ( )
s1 . add ( "akhil" )
s1 . add ( "dusi" )
s1 . add ( "om" )
s1 . add ( "siddu" )
console . log ( s1 . has ( "akhil" ) )
console . log ( s1 . delete ( "akhil" ) )
console . log ( s1 . delete ( "foo" ) )
console . log ( s1 . has ( "akhil" ) )
for ( let item of s1 ) {
console . log ( item )
} Set .delete () ist eine Methode, mit der ein Element aus dem Satz entfernt wird. Die Methode akzeptiert nur ein Argument und gibt einen booleschen Wert true oder false zurück. Wenn mehr als ein Argument an delete() übergeben wird, ignoriert es nur die verbleibenden Argumente und berücksichtigt nur das erste Argument.
3.6 SET .VALUES ():
var s1 = new Set ( )
var s2 = new Set ( )
s1 . add ( "foo" )
s1 . add ( "bar" )
s1 . add ( "foobar" )
s1 . add ( "barfoo" )
for ( let items of s1 . values ( ) ) {
s2 . add ( items )
}
console . log ( s1 . values ( ) ) // returns SetIterator { 'foo', 'bar', 'foobar', 'barfoo' }
console . log ( s2 . values ( ) ) // returns SetIterator { 'foo', 'bar', 'foobar', 'barfoo' }
console . log ( s1 . has ( "foo" ) ) // returns true
console . log ( s2 . has ( "foo" ) ) // returns true Set .Values () ist eine Methode, die die im Set vorhandenen Werte zurückgibt. Wenn wir s1.values() in einer Schleife verwenden, wie im obigen Code -Snippet gezeigt, ist alles zurück, was wir über den Set iterieren. Außerdem mag dies ähnlich der Methode in Map klingen, aber es gibt eine kleine Unterscheidung, die MAP .Values () nur die in der Map vorhandenen Werte zurückgeben würde. Keys () würde nur die Tasten zurückgeben, die jedem Wert/Element zugeordnet sind. Da ein Set einen Schlüssel und Wert hat wie das gleiche Element, gibt es nicht viel zwischen Set .Values () und Set .Keys (). Wir würden mit denselben iterbaren Objekten ohne Unterschied zurückgegeben.
3.7 Einstellen .entries ():
var s1 = new Set ( )
s1 . add ( "foo" )
s1 . add ( "goo" )
s1 . add ( "bar" )
s1 . add ( "gar" )
// the keys are
for ( let pairs of s1 . entries ( ) ) {
console . log ( "key[" + pairs [ 0 ] + "] => " + pairs [ 1 ] )
} Set .ententriies () ist eine Methode, die ein Array von Werten für die im Set vorhandenen Werte zurückgibt. Wir müssen verstehen, dass in einem Set der Schlüssel und der Wert gleich bleiben. Wenn wir also die methode set .ententries () aufrufen, ist alles, was wir erhalten, ein NX2 -Array von Werten, wobei n [0] und n [1] den gleichen Wert enthalten. Wir können auch s1.entries() einer Variablen oder einer Konstanten zuweisen, und in diesem Fall würden wir ein Iteratorobjekt im Gegenzug erhalten, der mit next() gespielt werden könnte.
MISC[Sets] : Schwachstellen
MISC[Sets] : Verwendung von ... Operator
Methoden Teil des JavaScript -Array -Objekts:
4.1 Array .push ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
arr1 . push ( 6 ) ;
console . log ( arr1 ) ; // it prints [1,2,3,4,5,6]Array .push () ist nur eine Mutatorfunktion zum Hinzufügen von Elementen zum Array. Daher können wir das Element einfach als Argument für das Funktionsarray.push () erwähnen, und das erwähnte Element würde als letztes Element im Array hinzugefügt.
4.2 Array .pop ()
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
arr1 . pop ( ) ; // removes last element from the array
arr1 . pop ( 23 ) ; // removes last element despite giving the number as argument
arr1 . pop ( "lol" ) ; // removes last element despite giving the string as argument
console . log ( arr1 ) ; // it prints [1,2,3,4]Array .pop () ist nur eine einfache Mutatorfunktion zum Entfernen des letzten Elements des Arrays. Die Methode nimmt also keine Argumente ein, obwohl sie, wenn wir versuchen, Argumente zu bestehen, sie nicht einnehmen würde. Es führt nur den grundlegenden Betrieb der Entfernung des letzten Elements des Arrays durch.
4.3 Array .Indexof ()
var arr1 = [ "akhil" , "chandu" , "adheeth" , "varma" ] ;
var arr2 = [ "akhil" , "chandu" , "adheeth" , "varma" , "akhil" , "shankar" , "akhil" ] ;
arr1 . indexOf ( "akhil" ) ; // returns 0 since akhil is present at index 0
arr1 . indexOf ( "adheeth" ) ; // returns 2 since adheeth is present at index 2
arr2 . indexOf ( "akhil" ) ; // returns 0 because it is the first occurrence of akhilArray .Indexof () ist eine Accessor -Funktion, die zum Ermitteln des Index eines bestimmten Elements in einem Array verwendet werden kann. Das Argument, das daran übergeben werden soll, ist der Wert des Elements im Array. Es ist auch zu beachten, dass bei mehreren Vorkommen desselben Elements in den Daten das erste Ereignis des Elements im Array angezeigt wird.
4.4 Array .LastIndexof ()
var arr1 = [ "akhil" , "chandu" , "adheeth" , "varma" , "akhil" , "shankar" , "akhil" ] ;
arr1 . lastIndexOf ( "akhil" ) ; // returns 6 since akhil last occurred at index 6
arr1 . lastIndexOf ( "adheeth" ) ; // returns 2 since adheeth last occurred at index 2 Array .LastIndexof () ist eine Accessor -Funktion, die im Verhalten der indexOf ziemlich ähnlich ist. Der Unterschied, der lastIndexOf ist, gibt den Index des letzten Auftretens des Elements im Array zurück.
4.5 Array .Concat ()
var arr1 = [ "akhil" , "chandu" ] ;
var arr2 = [ "adheeth" , "varma" , "kp" ]
var arr3 = [ ]
arr1 . concat ( arr2 ) ; // returns [ 'akhil', 'chandu', 'adheeth', 'varma', 'kp' ]
arr2 . concat ( arr1 ) ; // returns [ 'adheeth', 'varma', 'kp', 'akhil', 'chandu' ]
arr3 = arr1 . concat ( arr2 )
console . log ( arr3 ) // returns [ 'akhil', 'chandu', 'adheeth', 'varma', 'kp' ] Array .Concat () ist eine Accessor -Funktion, mit der neue Arrays aus vorhandenen Arrays erstellt werden. Es dauert ein Array als Argument und nachdem die Funktion ausgeführt wurde, wird das Array im Argument mit dem Array Calling concat() verkettet.
4.6 Array .SPLICE ():
// case 1 :
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
nums = [ 6 , 7 , 8 , 9 , 10 ]
arr1 . splice ( 5 , 0 , nums )
console . log ( arr1 ) ; // it prints [1, 2, 3, 4, 5, [6, 7, 8, 9, 10]]
// case 2 :
var arr2 = [ 'one' ] ;
arr2 . splice ( 1 , 0 , 'two' , 'three' , 'four' , 'five' ) ;
console . log ( arr2 ) ; // it prints ['one', 'two', 'three', 'four', 'five']
// case 3 :
var arr3 = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] ;
arr3 . splice ( 5 , 5 ) ;
console . log ( arr3 ) ; // it prints [1, 2, 3, 4, 5]Array .SPLICE () hat einen unterschiedlichen Satz von Operationen, die ausgeführt werden könnten. Wenn wir Fall 1 beobachten, fügen wir dem Array arr1 aus dem fünften Index Elemente hinzu. Auch wenn wir in Fall 2 beobachten, können wir sehen, dass ohne eine Variable die Elemente zuzuweisen, die hinzugefügt werden sollen, werden als kontinuierliche Argumente übergeben. Es ist zu beachten, dass Splice nicht nur die Wirkung des Hinzufügens von Elementen ausführen kann, sondern auch die Wirkung des Entfernens von Elementen durchführt. Wenn wir in der Funktion Splice () den Wert des zweiten Arguments auswählen, das '0' ist, würden Elemente nur aus dem angegebenen Index hinzugefügt, obwohl die Anzahl der Elemente, die entfernt werden, wenn der Wert nicht '0' ist, die Anzahl der Elemente wäre.
4.7 Array .Shift ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 , "akhil" , "chandu" , "varma" , "kp" , "adheeth" ] ;
arr1 . shift ( ) ;
arr1 . shift ( 123 ) ;
arr1 . shift ( "lolagain" ) ;
console . log ( arr1 ) ; // it prints [4,5,6,"akhil","chandu","varma","kp","adheeth"]Array .Shift () unterscheidet sich nicht von dem oben genannten Methodenarray.pop (), obwohl der Hauptunterschied in Bezug auf den Index des Elements entspricht, das entfernt werden soll. Es entfernt das erste Element des Arrays. Ähnlich wie bei array.pop () enthält diese Methode auch Desnot Argumente, und obwohl ein Argument weitergegeben wird, führt sie weiterhin seine Operation durch.
4.8 Array .unshift ():
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
str = "akhil pandey" ;
arr1 . unshift ( str ) ;
console . log ( arr1 ) ; // it prints ["akhil pandey", 1, 2, 3, 4, 5];Array .Unshift () fällt in die gleiche Kategorie wie Array.push (), da beide als Mutatorfunktionen zum Hinzufügen von Elementen in ein Array verwendet werden. Der einzige Unterschied zwischen beiden Methoden besteht darin, dass das Element als erstes Element des Arrays hinzugefügt wird, wenn wir ein Argument an Array.unshift () übergeben. Wenn wir den obigen Snippet beobachten, können wir sehen, dass der Index des Elements '1' an den nächsten Ort verschoben wird und "Akhil Pandey" als erstes Element des Arrays hinzugefügt wird. Im Gegensatz zu Array.push () sollte diese Methode nicht nur für das Hinzufügen von Elementen missverstanden werden, da sie dem Beginn des Arrays Elemente hinzufügt.
4.9 Array .Reverse ():
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]Array .Reverse () ist nur eine Mutatorfunktion, die verwendet wird, um die Reihenfolge der Elemente im Array umzukehren.
4.10 Array .Sort ():
var arr1 = [ 'varma' , 'chandu' , 'akhil' , 'adheeth' ] ;
var arr2 = [ 5 , 6 , 2 , 9 , 23 ] ;
arr1 . sort ( ) ;
arr2 . sort ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'akhil', 'chandu', 'varma']
console . log ( arr2 ) ; // it prints [2, 5, 6, 9, 23]Array .sort () ist auch eine weitere Mutatorfunktion, mit der die Elemente in Ordnung gebracht werden. Sowohl Zeichenfolgen als auch Zahlen können mit der Methode Array.sort () sortiert werden. Die Sortierung findet in aufsteigender Reihenfolge statt. Wenn also Zeichenfolgen oder Zeichen Elemente sind, findet abhängig von der alphabetischen Skala die Sortierung statt.
4.11 Array .Map ():
function add ( arr ) {
return arr = "My name is " + arr ;
}
var arr1 = [ "akhil" , "varma" , "chandu" , "adheeth" , "kp" ] ;
var combine = arr1 . map ( add ) ;
console . log ( combine ) ;
/* it prints
[ 'My name is akhil',
'My name is varma',
'My name is chandu',
'My name is adheeth',
'My name is kp' ]
*/Array .Map () ist eine Methode, die eher einer Iteratorfunktion ähnelt, aber der grundlegende Unterschied zwischen diesem und Array.foreach () besteht darin, dass Array.Map () ein neues Array mit dem Ergebnis zurückgibt, während Array.foreach () kein neues Array mit dem Funktionsergebnis zurückgibt.
Hinweis: Array.Map () ist eine sehr leistungsstarke Methode und kann auf verschiedene Anwendungen angewendet werden. Obwohl diese Methode über jedes Element mit Array.Map () überprüft werden muss, muss sie sorgfältig angesehen werden und sollten nicht verwendet werden, wenn der Zweck über einige Elemente iteriert wird.
4.14 Array .Reduce ():
function combine ( prev , curr ) {
return prev + curr ;
}
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
var arr2 = [ "one " , "two " , "three " , "four " , "five " ] ;
var numsum = arr1 . reduce ( combine ) ;
var worsum = arr2 . reduce ( combine ) ;
console . log ( numsum ) ; // it prints 15
console . log ( worsum ) ; // it prints "one two three four five "Array .Reduce () ist eine Methode, die mit Arrays verwendet werden kann, indem eine Funktion als Argument aufgenommen wird, wodurch die Funktion über die Array -Elemente iteriert wird. Array.Reduce () iteriert über die Array -Elemente und ergibt somit das Ende des Arrays einen einzelnen Wert.
HINWEIS: Array.ReDuCeright () ähnelt eher Array.Reduce (), aber es iteriert die Array -Elemente vom rechten Element zum linken Element, anstatt den üblichen Weg zu gehen.
TIPS[Arrays] :
MISC[Arrays] :
Manipulation des Array -Objekts durch Schreiben Ihrer eigenen Methoden :
var boo = [ ]
Array . prototype . foo = function ( ) {
console . log ( "We write our method inside this block" )
}
boo . foo ( ) // returns whatever is included inside the above mentioned code blockDas Hinzufügen von Methoden zu Array.Prototyp bedeutet im Wesentlichen, dass wir dem globalen Array -Objekt Methoden hinzufügen. Ein Array.Prototyp würde also tatsächlich bedeuten, dass das Hinzufügen eines neuen Prototyps zum vorhandenen Array -Objekt hinzugefügt wird. Eine bessere Analogie kann also mit dem folgenden Code -Snippet erklärt werden.
Array . prototype . union = function ( bar ) {
var l = this . length ;
var n = bar . length ;
for ( i = 0 ; i < n ; ++ i ) {
this [ l ] = bar [ i ] ;
l ++ ;
}
console . log ( this ) ;
}
var a = [ "one" , "two" ] ;
var b = [ "three" , "four" , "five" , "six" , "seven" ] ;
var c = [ 1 , 2 ] ;
var d = [ 3 , 4 , 5 , 6 , 7 ] ;
a . union ( b ) ;
c . union ( d ) ;Beobachten Sie den obigen Array -Prototyp, wenn wir sorgfältig beobachten können, dass es nichts anderes als eine funktionierende Nachbildung darüber ist, wie das Array -Array der Array -Methode.Concat () funktioniert. In concat () -Methode wird also ein anderes Array als Argument an die Methode und das primäre Array übergeben und erweitert das Array.
Dinge, die im obigen Beispiel suchen müssen, sind, wie benutzerdefinierte Methoden geschrieben werden können, um nicht nur den Array -Prototyp, sondern auch alle von Javscript anerkannten Objekte wie String, Nummer, Regexp oder das Objekt selbst zu entsprechen.
Assoziative Arrays :
Vorzugsweise ist dies ein großer Teil der Sprache, obwohl dies ein wesentlicher Bestandteil vieler Programmiersprachen wie PHP und Python war. Es gibt eine geringfügige Änderung dessen, was es in anderen Programmiersprachen bietet.
[Hinweis]: In Python wird es nicht als assoziative Arrays bezeichnet oder bezeichnet, aber es kommt mit den Namenswörterbüchern.
var a = [ ] ;
var b = [ ] ;
a [ "one" ] = "boo this is my first item" ;
a [ "two" ] = "foo this is my second item" ;
a [ "three" ] = "alas this is final item" ;
b [ 0 ] = "oh not again the first item" ;
b [ 1 ] = "cant help with the second item" ;
b [ 3 ] = "finally got rid with the third item" ;
console . log ( a ) ; // would display the contents of the array 'a'
console . log ( b ) ; // would display the contents of the array 'b'
var len1 = a . length ;
var len2 = b . length ;
var len3 = Object . keys ( a ) . length ;
console . log ( len1 ) ; // would display undefined
console . log ( len2 ) ; // would display 3
console . log ( len3 ) ; // would display 3Der obige Snippet ist eine klassische Fallimplementierung von Arrays mit benannten Indizes oder assoziativen Arrays. Die Implementierung kann wie oben erwähnt und fast alle Array -Operationen durchgeführt werden, mit der Ausnahme, dass einige mit den benannten Indizes sehr reibungslos durchgeführt werden können. Das Problem tritt auf, wenn ein Array mit benannten Indizes nach seiner Länge verlangt wird. Wenn 'Array.Prototype.length ()' 'Methode verwiesen wird, gibt sie nur die Länge des Arrays zurück, das den Numberd -Index hat. Wenn wir benannte Indexes verwenden, ist es nicht gut, da die Indizes Strings sind, aber keine Zahlen mehr.
In einem solchen Fall, wenn wir die Länge des benannten indizierten Arrays zurückgeben müssen, dann Objekt. Keys (ArrayName). Die Länge würde die Länge des Arrays geben. Das gleiche wird erklärt, indem drei Variablen 'len1', '', 'len2', ',' Len3 ', wo beide' len1 ',' len3 'die Länge des Längens der Länge der Länge der Länge der Länge der Länge der Länge der Länge der Länge der Länge der Länge der Länge des Längens, erläutert.
Methoden, die Teil des JavaScript -String -Objekts sind:
5.1 String .Charat ():
var str1 = "akhil" ;
str1 . charAt ( - 1 ) ; // returns '' or empty string
str1 . charAt ( 3 ) ; // returns 'i' as it is located at position 3
str1 . charAt ( 7 ) ; // returns '' or empty string String .Charat () ist eine Methode, die zur Bestimmung des in einem bestimmten Index der angegebenen Zeichenfolge vorhandenen Zeichen verwendet werden kann. Die Funktion nimmt nur ein Argument auf und gibt das Zeichen als Ausgabe zurück. Es ist zu beachten, dass die Funktion, wenn der als Eingang als Eingabe angegebene Index größer als die Stringlänge ist, nur eine leere '' als Ausgabe zurückgibt.
5.2 String .Concat ():
var str1 = "akhil" ;
var str2 = "pandey" ;
str1 . concat ( str2 ) ; // returns the string 'akhilpandey'
str1 . concat ( 1234 ) ; // returns the string 'akhil1234'
str1 . concat ( true ) ; // returns the string 'akhiltrue'
str1 . concat ( null ) ; // returns the string 'akhilnull'
str1 . concat ( undefined ) ; // returns the string 'akhilundefined'
str1 . concat ( [ 1 , 2 , 3 , 4 , 5 ] ) ; // returns the string 'akhil1,2,3,4,5'
str1 . concat ( " " , 12 , 34 , 56 , 78 ) ; // returns the string 'akhil 12345678'
str1 . concat ( { a : "123" , b : "456" } ) ; // returns the string 'akhil[object Object]' String .Concat () ist eine Methode, mit der zwei oder mehr Zeichenfolgen kombiniert werden, um eine neue Zeichenfolge zurückzugeben. Grundsätzlich wird diese Methode für String -Operationen verwendet. Wenn jedoch eine Zeichenfolge normalerweise mit einem anderen Typ verkettet ist, ist der Ergebnis eine Zeichenfolge. Wenn wir das obige Beispiel beobachten, sehen wir str1.concat(true) Hier ist die resultierende Zeichenfolge akhiltrue als String .concat () den Wert beider Argumente und erzeugt eine verkettete Zeichenfolge als Endergebnis. Jetzt gibt es sogar besondere Fälle, wenn eine string versucht wird, mit falsy -Werten verkettet zu werden, das Ergebnis wäre die Kombination des string und Falsy -Wertes.
5.3 String .Indexof ():
5.4 String .LastIndexof ():
5.5 String .Link ():
5.6 String .Search ():
5.4 String .Slice ():
TIPS[Strings]:
String.Slice () : Die Methode String.slice () extrahiert im Wesentlichen einen Teil einer Zeichenfolge und gibt die neue Schnur zurück, die in Scheiben geschnitten wird. Die allgemeine Notation zur Verwendung der String.Slice -Methode ist String.Slice (POS1, POS2), wobei in POS1 die Position des Startindex und POS2 die Position des Endindex ist. Der Punkt, den hier zu beachten ist, ist, wenn wir die Methode String.slice () verwenden, indem wir negative Parameter übergeben, dann zählt und extrahiert sie die Zeichenfolge vom Ende zum Start. Und wenn wir den zweiten Parameter nicht übergeben, extrahiert die Methode den Rest der Zeichenfolge.
String.Substring () : Die Methode String.Slice () und String.Substring () fallen in dieselbe Kategorie von Methoden, die zum Extrahieren von Teil oder Teilen der String aus der Quellzeichenfolge verwendet werden können. Der Unterschied in beiden besteht darin, dass wir negative Indizes nicht verwenden können, wenn die Methode String.substring () verwendet wird. Wenn wir beispielsweise einen negativen Index an die Methode wie String.substring (-7, -1) weitergeben
In JavaScript:
| Typen | Kann Objekte sein | Sind immer Objekte |
|---|---|---|
| Booleschen | ✔ | |
| Zahlen | ✔ | |
| Saiten | ✔ | |
| Daten | ✔ | |
| Mathematik | ✔ | |
| Reguläre Ausdrücke | ✔ | |
| Arrays | ✔ | |
| Funktionen | ✔ |
Im Grunde genommen außer den primitiven Werten sind alle Objekte in JavaScript
6.1 Objects can be created using three methods :
// creating an oject using an Object literal
var staff = {
name : "somename" ,
branch : "somebranch" ,
salary : "somesalary" ,
age : 20
} ; // creating an object using new keyword
var admin = new Object ( ) ;
admin . name = "somename" ;
admin . department = "somedept" ;
admin . userid = 123 ;
admin . age = 20 ; // creating an object using the object constructor
function student ( name , github_nick , url , age ) {
this . name = name ;
this . github = "https://github.com/" + github_nick ;
this . url = url ;
this . age = age ;
} 6.2 Using the constructor for the above defined Object :
var akhil = new student ( "Akhil Pandey" , "AkhilHector" , "https://www.akhilhector.com" , "20" ) ; 6.3 Accessing object methods :
console . log ( akhil . github ) ;
console . log ( akhil . url ) ; 6.4 Using the prototype property :
student . prototype . show = function ( ) {
return this . name + " " + this . github + " " + this . age ;
} 6.5 Adding methods to the prototype :
function student ( name , github_nick , url , age ) {
this . name = name ;
this . github = "https://github.com/" + github_nick ;
this . url = url ;
this . age = age ;
this . show = function ( ) {
return this . name + " " + this . github + " " + this . age ;
}
} NOTE : Javasctipt -Objekte sind veränderlich, was bedeutet, dass sie durch Adresse und nicht von Wert verwiesen werden. Wenn beispielsweise 'Master' ein Objekt ist und 'Master-Backup' auch ein anderes Objekt ist, kann es auch dazu führen, dass das andere Objekt das andere Objekt ändern kann.
{
var master = { foo : "foo" } ;
var master - backup = master ;
master . backup . bar = "bar" ; // this changes master.bar and master-backup.bar
}
Object . access . property = {
"Option1" : "we can use objectName.propertyName" ,
"Option2" : "Either we can write objectName[propertyName]"
} Bei Funktionsschließungen in JavaScript geht es darum, wie die Variablen im lokalen oder globalen Bereich behandelt und verwiesen werden. In JS können Variablen gegeben werden:
Es gibt kein eingebautes Konzept für etwas, das als private Variablen bezeichnet wird. Wenn also ein solches Szenario -Schließungen in JS geschrieben sind, um den Geltungsbereich für Variablen zu schaffen, die privat im Umfang sind.
Currying ist ein Prozess, bei dem eine Funktion erstellt wird, indem mehrere Argumente übernommen und sie teilweise über eine Reihe von Funktionen angewendet werden. Um genau zu sein, können Sie die angegebene Funktion, die mehrere Argumente in eine Reihe von Funktionen einbezieht, die an den Argumenten teilnehmen.
Nehmen wir ein gemeinsames Beispiel:
Schwanzaufrufe sind nichts anderes, als das Konzept rekursiver Funktionen durch Schleife im Wesentlichen zu ersetzen. In gewisser Weise kann dies nicht nur Zeit sparen, sondern auch Platz sparen, dh eine bessere Zeit Komplexität und Raumkomplexität.
// snippet one
function f ( n ) {
if ( n == 0 ) {
return 1 ;
}
else {
return n * f ( n - 1 ) ;
}
}
// snippet two
function f1 ( n ) {
function r ( n , m ) {
if ( n == 0 ) {
return m ;
}
else {
return r ( n - 1 , n * m ) ;
}
}
return r ( n , 1 ) ;
}Wenn Sie beide Algorithmen beobachten, die oben für Fakultäten geschrieben wurden, können wir verstehen, dass f () die herkömmliche rekursive Methode ist, die zum Auffinden des Faktororials verwendet wird, aber F1 () der Heckanruf optimierter Algorithmus ist, der besser und schnell ist.
Obwohl die besten Anstrengungen unternommen wurden, um sicherzustellen, dass die gesamte Dokumentation fehlerfrei ist, gibt es möglicherweise kleine Fälle, in denen möglicherweise Fehler aufgetreten sind. In solchen Fällen stellen Sie bitte ein Problem an und helfen Sie mir, dieses Cheat -Blatt besser zu machen.
