LearnJS
1.0.0
LearnJsest une tentative de dépeindre les meilleures parties de JavaScript qui sont assez difficiles et difficiles à trouver. Il convient de noter qu'il ne s'agit pas d'un livre / guide sous aucune forme, mais d'une congrégation de meilleures pratiques, de constructions linguistiques et d'autres extraits simples mais efficaces qui nous donnent une essence de la façon dont nous pouvons exploiter le meilleur de la langue.
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 ( ) { } ; Nous devons comprendre le fait qu'en JavaScript, tout est un objet, donc pour supposer que si nous déclarons une chaîne utilisant l'objet String et le comparez avec var a = "" alors le résultat de la comparaison serait faux. Ceci est simplement parce que si nous déclarons une chaîne en utilisant la bad voie et le comparez avec une chaîne déclarée en utilisant le good moyen, nous comparons fondamentalement une chaîne avec un objet (chaîne).
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 One et Two sont les mêmes. Mais la différence fondamentale entre les deux échantillons de code est que l'un utilise des demi-colons dans la sémantique Lang--uage mais alors que l'autre ne le fait pas. Fondamentalement, on nous apprend à utiliser des demi-colons dans des langues telles que C, C ++, Java, etc. car les lignes de code sont terminées à l'aide de '; Mais en JavaScript, tout le scénario est différent. Il n'y a absolument aucune différence dans l'exécution du code avec ou sans demi-colons.
Méthodes partie de l'objet de carte JavaScript:
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 () est la méthode qui est utilisée pour ajouter ou mettre à jour un élément avec une clé et une valeur spécifiques dans une carte. Ici, le premier argument est la clé tandis que le deuxième argument est la valeur. Les touches peuvent être de n'importe quel type, mais il serait préférable d'utiliser objects comme des touches au lieu des strings car si nous utilisons strings comme clés, il n'y aurait pas de différence significative entre Maps et Objects .
2.2 map .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 () est une méthode qui est utilisée pour récupérer un élément de l'objet Map avec une clé spécifique. Ainsi, la clé est transmise comme un argument et l'élément associé à cette clé est renvoyé. Si aucune clé n'est passée en tant qu'argument, la méthode revient avec undefined .
2.3 Carte .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 () est une méthode qui indique si un élément avec la clé demandée est présente ou non dans la carte. La méthode ne prend qu'un seul argument qui est la clé et il renvoie un true si l'élément est présent ou false si l'élément n'est pas présent.
2.4 Map .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 est une propriété d'accessoire qui renvoie le nombre d'éléments présents dans l'objet Map . Puisqu'il s'agit d'une propriété d'accessoire, nous ne devons pas appeler / l'utiliser comme une méthode, donc si m1.size() est appelé, il lance un type Eerror disant que m1.size n'est pas une fonction. Par conséquent, l'appel valide à cette propriété est m1.size .
2.5 Map .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 () est une méthode qui efface / supprime tous les éléments présents dans l'objet Map . La méthode ne prend aucun argument mais lance undefined en retour.
2.6 Map .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 () est une méthode utilisée pour supprimer un élément particulier de l'objet Map . La méthode ne prend qu'un seul argument qui est la clé et si la clé est présente dans la Map elle supprime l'élément et renvoie un true , mais si la clé n'est pas présente dans la Map , il lance un false .
2.7 Map .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 () est une méthode utilisée pour retourner les touches présentes dans l'objet Map pour chaque élément. La méthode renvoie un objet Iterator Map qui peut être utilisé pour connaître les touches présentes dans la Map . Dans l'exemple ci-dessus, il est décrit comment itérer sur map .Keys () en utilisant next() . Il convient de noter que lorsque next() est utilisé sur l'objet Iterator , soit value ou done doit être utilisée car une utilisation directe de next() se traduit par l'affichage d'un Object . iterator.next().value renvoie la valeur de la clé présente dans l'objet Iterator tandis que iterator.next().done renvoie un booléen disant false s'il y a plus de clés présentes dans l'objet Iterator et true s'il n'y a plus de clés.
2.8 Map .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 () est une méthode qui est utilisée pour renvoyer les valeurs présentes dans l'objet Map pour chaque élément. La méthode renvoie un objet Iterator qui peut être utilisé pour connaître les valeurs présentes dans la Map . Dans l'exemple ci-dessus, il est décrit comment itérer sur la carte .Values () en utilisant next() . Il convient de noter que lorsque next() est utilisé sur l'objet Iterator , soit value ou done doit être utilisée car une utilisation directe de next() se traduit par l'affichage d'un Object . iterator.next().value renvoie la valeur d'un élément particulier présent dans l'objet Iterator tandis que iterator.next().done renvoie un booléen disant false s'il y a plus de valeurs présentes dans l'objet Iterator et true s'il n'y a pas plus de valeurs présentes.
2.9 Map .Entries ():
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 () est une méthode qui est poursuivie pour renvoyer les touches et les valeurs présentes dans l'objet Map pour chaque élément. La méthode est assez similaire à MAP .Values () pour le fait qu'il renvoie un objet Iterator qui pourrait être utilisé pour connaître les clés et les valeurs présentes dans la Map . Dans l'exemple ci-dessus, il est présenté sur la façon d'itérer sur la carte .Entries () en utilisant next() . La capacité de la méthode et son mode de fonctionnement sont assez similaires à MAP .Values (), sauf pour le fait que les clés sont également renvoyées avec les valeurs car nous allons itérer l'objet Iterator . Semblable à tout objet Itérateur une fois qu'il atteigne l'extrémité de son avion, il jetterait et undefined . En outre, il convient de noter que toute autre méthode qui s'applique à un objet Iterator pourrait être utilisée avec cela car elle est une seule et même chose.
MISC[Maps] : les faiblesmaps peuvent être considérés comme des cartes avec des différences dans la méthodologie dont les collections de déchets se produisent sous le capot. Pour le dire dans une terminologie plus simple et simple, il doit y avoir une petite leçon conceptuelle racontée afin d'apporter la perspective. Dans JavaScript en général, tout est un objet , le moment où vous en créez un et la mémoire est alloué pour le même et jusqu'à ce que le V8 GC soit automatiquement (abréviation de Garbage collect), l'objet reste comme un nœud dans le graphique. Il est à noter que tant qu'il n'y a pas de références à l'objet créé dans la mémoire, il ne serait pas gc'd, donc tous les objets sont maintenus tightly ou strongly . Donc, essentiellement, la différence qui est apportée avec desmaps faibles est que les clés de l'objet sont désormais weakly maintenues, si l'objet est gc'd par v8 ou par vous, l'entrée serait supprimée du faiblemap mais pas des valeurs. Il n'y a pas de différence frappante entre la façon dont les cartes et les faiblesses fonctionnent, bien que les faiblesses acceptent uniquement les objets comme des clés (strictement). Regardons ci-dessous pour voir comment ils sont initialisés:
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. Il est à noter que bien que la façon dont l'API est faibles interagit avec nous de la même manière que l'objet MAPS , il y a des limites aux opérations fournies par l'API FaibleMaps . Il prend en charge les méthodes get() , set() , has() et delete() à partir de maintenant.
MISC[Maps] : utilisation de ... opérateur
Méthodes Partie de l'objet de définition JavaScript:
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 () est une méthode de mutator pour ajouter des valeurs à un ensemble. La procédure pour y parvenir est simple. Nous appelons la méthode add() à l'objet Set déjà créé et passons la valeur que nous voulons dans l'ensemble en tant qu'argument. Lorsque plus d'un argument est transmis à la méthode add() il ignore simplement les arguments restants et ne considère que le premier argument. Il convient de noter que l'objet Set n'a aucune restriction au type de valeur réalisée et il n'applique aucune restriction lorsque nous faisons le Set hétérogène. NaN , null peut également faire partie d'un Set . Bien qu'il ne soit jamais encouragé à remplir l' Set de valeurs de cette nature.
3.2 set .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 () est une méthode qui est utile pour déterminer si un élément existe dans l' Set ou non. La méthode renvoie soit true si la valeur est présente et false si la valeur n'est pas présente. Si nous observons l'exemple ci-dessus, il existe une petite disparité entre la nature attendue de la méthode et sa réalité fondamentale. s1.add(123.0000000000000009123) est un exemple qui éclaire la rivalité de la décennie entre JavaScript et les valeurs des points flottants. Cela pourrait être évité simplement en utilisant le numéro .toprecision (). De plus, en JavaScript, il est toujours encouragé à gérer attentivement les points flottants.
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 n'est pas une méthode mais c'est une propriété de l'objet SETS utile pour déterminer la taille de l' Set . Comme vous pouvez l'observer à partir de l'extrait de code ci-dessus, il est juste appelé comme une méthode d'accessoire. Si nous essayons d'appeler la propriété en utilisant size() , il lance un TypeError Saying Set.size n'est pas une fonction.
3.4 Set .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 () est une méthode qui efface tous les éléments présents dans l'ensemble. Il en résulte la vidange de l' Set . Si nous observons dans l'extrait de code ci-dessus, il y a une tentative de transmettre un argument à la méthode SET .Clear () et quel que soit son argument transmis à la méthode, il ignore et effectue l'opération clear() sur l' Set . De plus, il n'y a aucune restriction sur le nombre de fois où l'opération est effectuée.
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 () est une méthode utilisée pour retirer un élément de l'ensemble. La méthode n'accepte qu'un seul argument et renvoie une valeur booléenne true ou false . Si plus d'un argument est passé pour delete() , il ignore simplement les arguments restants et ne considère que le premier 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 () est une méthode qui renvoie les valeurs présentes dans l' Set . Si nous utilisons s1.values() dans une boucle comme indiqué dans l'extrait de code ci-dessus, tout ce que nous récupérons est une valeur car nous itons sur l' Set . En outre, cela peut sembler similaire à la méthode dans Map , mais il y a une petite distinction, qui est MAP .Values () ne renverrait que les valeurs présentes dans la Map et la carte .Keys () ne rendrait que les clés associées à chaque valeur / élément. Maintenant, comme un Set a une clé et une valeur en tant que même élément, il n'y a pas beaucoup de distinction entre l'ensemble .Values () et Set .Keys (). Nous serions retournés avec les mêmes objets itérables sans aucune différence.
3.7 SET .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 .Entries () est une méthode qui renvoie un tableau de valeurs pour les valeurs présentes dans l' Set . Nous devons comprendre que dans un Set , la clé et la valeur restent les mêmes, donc lorsque nous appelons la méthode set .entries (), tout ce que nous obtenons est un tableau NX2 de valeurs où n [0] et n [1] contiennent la même valeur. Nous pouvons également affecter s1.entries() à une variable ou à une constante et dans ce cas, nous obtiendrions un objet Iterator en retour qui pourrait être joué autour de next() .
MISC[Sets] : Failessets
MISC[Sets] : utilisation de ... opérateur
Méthodes partie de l'objet de tableau JavaScript:
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 () n'est qu'une fonction mutatrice pour ajouter des éléments au tableau. Nous pouvons donc simplement mentionner l'élément comme argument de la fonction array.push () et l'élément mentionné serait ajouté comme dernier élément du tableau.
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 () n'est qu'une fonction mutatrice simple pour supprimer le dernier élément du tableau. La méthode ne prend donc pas des arguments, bien que si nous essayons de passer des arguments, cela ne les prendrait pas. Il effectue uniquement le fonctionnement de base de la suppression du dernier élément du tableau.
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 () est une fonction accessoire qui peut être utilisée pour trouver l'index d'un élément spécifique dans un tableau. L'argument à réaliser est la valeur de l'élément dans le tableau. En outre, il convient de noter que lorsqu'il y a plusieurs occurrences du même élément dans les données, la première occurrence de l'élément dans le tableau est affichée.
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 () est une fonction accessoire, assez similaire dans le comportement à l' indexOf la fonction. Bien que la différence étant lastIndexOf renvoie l'indice de la dernière occurrence de l'élément dans le tableau.
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 () est une fonction accessoire utilisée pour créer de nouveaux tableaux à partir de tableaux existants. Il prend un tableau comme argument et après l'exécution de la fonction, le tableau de l'argument est concaténé au tableau appelant concat() .
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 () a un ensemble varié d'opérations qui pourraient être effectuées. Si nous observons le cas 1, nous ajoutons des éléments au tableau Arr1 du cinquième indice. De plus, si nous observons dans le cas 2, nous pouvons voir que sans attribuer une variable, les éléments qui doivent être ajoutés sont adoptés sous forme d'arguments continus. Il faut noter que Splice peut non seulement effectuer l'action de l'ajout d'éléments, mais il effectue également l'action de la suppression des éléments. Dans la fonction Splice (), si nous choisissons la valeur du deuxième argument à être «0», les éléments ne seraient qu'à partir de l'index spécifié, bien que si la valeur n'est pas «0», le nombre spécifié serait le nombre d'éléments qui seront supprimés.
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 () n'est pas différent de la méthode mentionnée ci-dessus array.pop (), bien que la différence majeure revienne concernant l'indice de l'élément qui doit être supprimé. Il supprime le premier élément du tableau. Semblable à array.pop (), cette méthode a également des arguments et même si un argument est passé, il continue d'effectuer son fonctionnement.
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 () appartient à la même catégorie que celle de Array.push (), car les deux sont utilisés comme fonctions mutatrices pour ajouter des éléments dans un tableau. La seule différence entre les deux méthodes est que si nous passons un argument à array.unShift (), l'élément serait ajouté comme le premier élément du tableau. Si nous observons l'extrait ci-dessus, nous pouvons voir que l'indice de l'élément «1» est déplacé vers l'endroit suivant et «Akhil Pandey» est ajouté comme le premier élément du tableau. Contrairement à Array.push (), cette méthode ne doit pas être mal comprise pour ajouter des éléments car il ajoute des éléments au début du tableau.
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 () n'est qu'une fonction mutatrice qui est utilisée pour inverser l'ordre des éléments dans le tableau.
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 () est également une autre fonction mutatrice qui est utilisée pour mettre les éléments dans l'ordre. Les chaînes et les nombres peuvent être triés à l'aide de la méthode Array.Sort (). Le tri se déroule dans l'ordre croissant, donc si les chaînes ou les caractères sont des éléments, alors en fonction de l'échelle alphabétique, le tri a lieu.
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 () est une méthode qui ressemble plus à une fonction Iterator, mais la différence fondamentale entre ceci et array.ForEach () est que Array.map () renvoie un nouveau tableau avec le résultat, tandis que Array.ForEach () ne renvoie pas un nouveau tableau avec le résultat de la fonction.
Remarque: Array.map () est une méthode très puissante et peut être appliquée à diverses applications. Bien que puisque cette méthode itère sur chaque élément à l'aide de l'array.map () doit être soigneusement examinée et ne doit pas être utilisée si le but est itérant sur certains éléments.
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 () est une méthode qui peut être utilisée avec les tableaux en prenant une fonction en tant qu'argument, faisant ainsi la fonction d'itérer sur les éléments du tableau. Array.reduce () itère sur les éléments du tableau et donc à la fin de la fin du tableau donne une seule valeur.
Remarque: Array.reduceRight () est plus similaire à Array.reduce (), mais il itère sur les éléments du tableau de l'élément le plus à droite au plus à gauche, au lieu d'aller de la manière habituelle.
TIPS[Arrays] :
MISC[Arrays] :
Manipulation de l'objet Array en écrivant vos propres méthodes :
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 blockL'ajout de méthodes à Array.prototype signifie essentiellement que nous ajoutons des méthodes à l'objet Global Array. Ainsi, un array.prototype signifierait réellement que l'ajout d'un nouveau prototype à l'objet Array existant. Ainsi, une meilleure analogie peut être expliquée avec l'extrait de code ci-dessous.
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 ) ;L'observation du prototype de tableau ci-dessus si nous pouvons l'observer attentivement qu'il n'est rien d'autre qu'une réplique fonctionnelle de la fonctionnalité de la méthode du tableau array.prototype.concat () fonctionne. Ainsi, dans la méthode Concat (), un autre tableau est passé comme argument à la méthode et le tableau principal concat et étend le tableau.
Les choses à rechercher dans l'exemple ci-dessus sont la façon dont les méthodes personnalisées peuvent être écrites afin de convenir à l'objectif spécifique non seulement du prototype de tableau mais aussi de tous les objets reconnus Javscript tels que la chaîne, le nombre, le regexp ou l'objet lui-même.
Tableaux associatifs :
De préférence, c'est quelque peu une grande partie du langage, bien que cela fasse partie intégrante de nombreux langages de programmation comme PHP et Python, il y a un léger changement dans ce qu'il offre dans d'autres langages de programmation.
[Remarque]: Dans Python, il n'est pas appelé ou appelé des tableaux associatifs mais il est livré avec les dictionnaires de noms.
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 3L'extrait ci-dessus est une implémentation de cas classique de tableaux avec des index nommés ou les tableaux associatifs. La mise en œuvre peut être effectuée comme mentionné ci-dessus et presque toutes les opérations de tableau, sauf que certaines peuvent être effectuées très bien avec les index nommés. Le problème se pose lorsqu'un tableau avec des index nommés est demandé sa longueur. Lorsque la méthode 'array.prototype.length ()' est renvoyée, elle ne renvoie que la longueur du tableau qui a un index NumberD, si nous utilisons des index nommés, il n'est pas bon car les index sont des chaînes mais plus des chiffres.
Dans un tel cas, si nous devons retourner la longueur du tableau indexé nommé, alors object. keys (arrayname) .Length donnerait la longueur du tableau. Le même est expliqué en prenant trois variables `` Len1 '', `` Len2 '', `` Len3 '' où les deux «Len1», «Len3» »renvoie la longueur de la longueur de la longueur.
Méthodes qui font partie de l'objet JavaScript String :
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 () est une méthode qui peut être utilisée pour déterminer le caractère présent à un index particulier de la chaîne donnée. La fonction ne prend qu'un seul argument et il renvoie le caractère comme sortie. Il convient de noter que lorsque l'index donné en entrée s'il est supérieur ou inférieur à la longueur de chaîne, la fonction renvoie simplement '' ou une chaîne vide en tant que sortie.
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 () est une méthode qui est utilisée pour combiner deux chaînes ou plus pour renvoyer une nouvelle chaîne. Fondamentalement, cette méthode est utilisée pour les opérations de chaîne, mais si une chaîne est généralement concaténée avec un autre type, le résultat sera une chaîne. Si nous observons l'exemple ci-dessus, nous voyons str1.concat(true) donc ici la chaîne résultante est akhiltrue comme string .concat () combine la valeur des deux arguments et produit une chaîne concaténée en conséquence finale. Maintenant, il y a même des cas spéciaux pour supposer, si une string est essayé de se concaténer avec les valeurs Falsy, le résultat serait la combinaison de la string et de la valeur Falsy.
5.3 String .Indexof ():
5.4 String .LastIndexof ():
5.5 String .Link ():
5.6 String .Search ():
5.4 String .Slice ():
TIPS[Strings]:
String.slice () : La méthode String.slice () extrait essentiellement la partie d'une chaîne et renvoie la nouvelle chaîne qui est tranchée. La notation générale pour l'utilisation de la méthode String.slice est String.slice (POS1, POS2) où dans POS1 est la position de l'indice de départ et POS2 est la position de l'indice de fin. Le point à noter ici est que si nous utilisons la méthode String.slice () en passant des paramètres négatifs, il finit par compter et extraire la chaîne de l'extrémité au début. Et si nous ne passons pas le deuxième paramètre, la méthode extrait le reste de la chaîne.
String.SubString () : La méthode String.slice () et String.Substring () entrent dans la même catégorie de méthodes qui peuvent être utilisées pour extraire des pièces ou des parties de la chaîne à partir de la chaîne source. La différence dans les deux est que nous ne pouvons pas utiliser des index négatifs lors de l'utilisation de la méthode String.SubString (). Par exemple, si nous transmettons un index négatif à la méthode comme String.substring (-7, -1), il ne fait essentiellement pas de tuyau de l'erreur indiquant l'erreur commise avec l'utilisation d'index négatif mais affiche la chaîne dans son ensemble
En javascript:
| Types | Peut être des objets | Sont toujours des objets |
|---|---|---|
| Booléens | ✔ | |
| Nombres | ✔ | |
| Cordes | ✔ | |
| Dates | ✔ | |
| Maths | ✔ | |
| Expressions régulières | ✔ | |
| Tableaux | ✔ | |
| Fonctions | ✔ |
Donc, fondamentalement, sauf que les valeurs primitives sont tous des objets en 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 : Les objets Javasctipt sont mutables, ce qui signifie qu'ils sont référencés par l'adresse et non la valeur. Par exemple, si «Master» est un objet et que «maître-dossier» est également un autre objet, si nous passons les objets, le modification, un peut également entraîner la modification de l'autre objet.
{
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]"
} Les fermetures de fonctions en JavaScript concernent la façon dont les variables sont traitées et mentionnées dans la portée locale ou globale. Dans JS, des variables peuvent être données:
Il n'y a pas de concept intégré pour quelque chose appelé variables privées, donc quand il y a une exigence pour une telle fermeture de scénarios est écrite en JS afin de faire de la portée des variables qui sont privées.
Le curry est un processus de création d'une fonction en prenant plusieurs arguments et en les appliquant partiellement via une série de fonctions. Pour être spécifique, vous pouvez décomposer la fonction donnée qui prend plusieurs arguments en série de fonctions qui participent aux arguments.
Prenons un exemple commun:
Les appels de queue ne sont que essentiellement le remplacement du concept de fonctions récursives par boucle. D'une certaine manière, cela peut non seulement gagner du temps, mais aussi économiser de l'espace, c'est-à-dire une meilleure complexité de temps et une complexité de l'espace.
// 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 ) ;
}Observer à la fois les algorithmes ci-dessus écrits pour factorielle Nous pouvons comprendre que F () est la méthode récursive traditionnelle utilisée pour trouver le factoriel, mais F1 () est l'algorithme optimisé d'appel de queue qui est meilleur et rapide.
Bien que les meilleurs efforts aient été déployés pour s'assurer que l'ensemble de la documentation est sans erreur, il peut y avoir de petits cas où des erreurs auraient pu se produire. Dans de tels cas, veuillez soulever un problème et m'aider à améliorer cette feuille de triche.
