LearnJS
1.0.0
LearnJs、JavaScriptの最高の部分を描写する試みです。これはいかなる形の本/ガイドではなく、ベストプラクティス、言語構成、および言語から最高のものを活用する方法の本質を与える他のシンプルで効果的なスニペットの会衆であることに注意してください。
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 ( ) { } ; JavaScriptではすべてがオブジェクトであるという事実を理解する必要があります。そのため、 Stringオブジェクトを使用して文字列を宣言し、 var a = ""と比較すると、比較の結果がfalseであると仮定します。これは、単にbad方法を使用して文字列を宣言し、 good方法を使用して宣言された文字列と比較すると、基本的に文字列をオブジェクト（文字列）と比較しているからです。
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" )
}コードスニペット1と2は同じです。しかし、両方のコードサンプル間の根本的な違いは、一方がラングウージュセマンティクスでセミコロンを使用しているが、もう一方はラングウージュセマンティクスで使用していることです。基本的に、c、c ++、javaなどの言語でセミコロンを使用するように教えられています。しかし、JavaScriptでは、シナリオ全体が異なります。セミコロンの有無にかかわらず、コードの実行にまったく違いはありません。
メソッド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（）は、マップ内に特定のキーと値を持つ要素を追加または更新するために使用されるメソッドです。ここでは、最初の引数が重要ですが、2番目の引数は値です。キーは任意のタイプにすることができますが、 stringsキーとして使用する場合、 MapsとObjectsの間に大きな違いがないため、 stringsの代わりに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（）は、特定のキーを持つMapオブジェクトから要素を取得するために使用されるメソッドです。したがって、キーは引数として渡され、そのキーに関連する要素が返されます。引数としてキーが渡されない場合、メソッドはundefinedで戻ります。
2.3 Map .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（）は、要求されたキーを持つ要素がマップに存在するかどうかを示すメソッドです。このメソッドは、鍵である1つの引数のみを取得し、要素が存在する場合、または要素が存在しない場合はfalseある場合にtrueを返します。
2.4マップ.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は、 Mapオブジェクトに存在する要素の数を返すアクセサのプロパティです。アクセサのプロパティであるため、これをメソッドのように呼び出すべきではないため、 m1.size()が呼び出された場合、 m1.sizeは関数ではないというタイプエラーをスローします。したがって、そのプロパティへの有効な呼び出しは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（）は、 Mapオブジェクトに存在するすべての要素をクリア/削除するメソッドです。この方法は議論をしませんが、見返りにundefined投げます。
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（）は、 Mapオブジェクトから特定の要素を削除するために使用されるメソッドです。このメソッドは、キーである1つの引数のみを取ります。キーがMapに存在する場合、要素を削除してtrueを返しますが、キーがMapに存在しない場合、 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（）は、各要素のMapオブジェクトに存在するキーを返すために使用されるメソッドです。このメソッドは、 Mapに存在するキーを知るために使用できるマップイテレーターオブジェクトを返します。上記の例ではnext()を使用してmap .keys（）を介して反復する方法について概説します。 iteratorオブジェクトでnext() next()使用される場合valueまたはdone使用する必要があることに注意してくださいObject iterator.next().value iterator.next().done iteratorオブジェクトにさらにキーが存在する場合はfalse言っているブールと言っているbooleanの値を返し、キーがこれ以上存在しない場合はtrue返します。
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（）は、各要素のMapオブジェクトに存在する値を返すために使用されるメソッドです。このメソッドは、 Mapに存在する値を知るために使用できるイテレーターオブジェクトを返します。上記の例ではnext()を使用してmap .values（）を介して反復する方法について概説します。 iteratorオブジェクトでnext() next()使用される場合valueまたはdone使用する必要があることに注意してくださいObject iterator.next().value iterator.next false ） iterator.next().done true
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（）は、各要素のMapオブジェクトに存在するキーと値を返すために訴えられるメソッドです。この方法は、 Mapに存在するキーと値を知るために使用できるイテレーターオブジェクトを返すという事実のために、 Map .Values（）に非常に似ています。上記の例ではnext()を使用してマップを繰り返す方法について紹介されています。メソッドの能力とその動作方法は、キーもイテレーターオブジェクトを反復するときに値とともに返されるという事実を除いて、 map .values（）に非常に似ています。任意のイテレータオブジェクトと同様に、飛行機の端に到達すると、投げてundefined 。また、 Iteratorオブジェクトに適用される他の方法は、それが一つと同じであるため、これで使用できることに注意してください。
MISC[Maps] : WeakMapsは、ガベージコレクションがボンネットの下で発生する方法論に違いがあるマップと見なすことができます。それをよりシンプルで単純な用語にするには、視点をもたらすために言われた少しの概念的な教訓が必要です。 JavaScriptでは、広くすべてがオブジェクトであるため、メモリが同じで割り当てられている瞬間、V8が自動的にGC（ガベージ収集の略）がグラフのノードとして残ります。メモリに作成されたオブジェクトへの参照がないまでGC'Dではないため、すべてのオブジェクトがtightlyまたはstrongly保持されることに注意してください。したがって、本質的に、 WeakMapsでもたらされている違いは、オブジェクトのキーが今後weakly保持されていることです。オブジェクトがV8またはあなたによってGC'Dがgc'にある場合、エントリはweakmapから削除されますが、値は値ではありません。 MAPSとWeakMapsの動作方法には厳しい違いはありませんが、 WeakMapsはオブジェクトのみをキーとして（厳密に）受け入れるだけです。以下を見て、それらがどのように初期化されているかを見てみましょう。
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. weakmaps APIがMapsオブジェクトと同じ方法で私たちと対話する方法は、 WeakMaps APIが提供する操作には制限があることに注意してください。 get() 、 set() 、 has() 、 delete()メソッドをサポートしています。
MISC[Maps] :オペレーターの使用
メソッド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（）は、セットに値を追加するためのミューテーター方法です。これを達成するための手順は簡単です。既に作成されたSetオブジェクトにadd()メソッドを呼び出し、引数としてセットに必要な値を渡します。複数の引数がadd()メソッドに渡されると、残りの引数を無視し、最初の引数のみを考慮します。 Setオブジェクトには、渡される値のタイプに対する制限がなく、 Setを異質なものにするときに制限を強制しないことに注意してください。 NaN 、 null Setの一部でもあります。ただし、この性質の価値でSetを埋めることは決して奨励されていません。
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（）は、 Setに要素が存在するかどうかを判断するのに役立つ方法です。メソッドは、値が存在する場合はtrue 、値が存在しない場合はfalseのいずれかを返します。上記の例を観察すると、メソッドの予想される性質とその地上現実の間には小さな格差があります。 s1.add(123.0000000000000009123) JavaScriptと浮動小数点値の間の10年の長いライバル関係にある程度の光を当てる1つの例です。これは、 number .toprecision（）を使用するだけで回避できます。また、JavaScriptでは、フローティングポイントを注意深く処理することが常に奨励されています。
3.3セット.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セット.sizeはメソッドではありませんが、 Setのサイズを決定するのに役立つセットオブジェクトのプロパティです。上記のコードスニペットから観察できるように、それは単にアクセサのように呼ばれます。 size()を使用してプロパティを呼び出すと、 Set.size関数ではないというタイプエラーがスローします。
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（）は、セットに存在するすべての要素をクリアする方法です。これにより、 Setが空になります。上記のコードスニペットで観察した場合、セットに引数を.clear（）メソッドに渡す試みがあり、 Setのclear()操作を無視して実行する方法にどのような引数が渡されるかに関係なく。また、操作が実行される回数に対して制限はありません。
3.5セット.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 )
}セット.delete（）は、セットから要素を削除するために使用される方法です。このメソッドは、1つの引数のみを受け入れ、ブール値trueまたはfalseを返します。複数の引数がdelete()に渡された場合、それは残りの引数を無視し、最初の引数だけを考慮します。
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（）は、 Setに存在する値を返すメソッドです。上記のコードスニペットに示すように、ループでs1.values()を使用する場合、 Setを反復する際に戻るのは値だけです。また、これはMap内のメソッドに似たように聞こえるかもしれませんが、わずかな区別があります。マップ.values（）はMapに存在する値を返すだけです。さて、 Setは同じ要素としてキーと値があるため、 set .values（）とset .keys（）の間にはあまり区別されません。同じ反復可能なオブジェクトで返されますが、違いはまったくありません。
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 （）は、 Setに存在する値の値の配列を返すメソッドです。 Setではキーと値が同じままであることを理解する必要があります。したがって、セットを呼び出すと、n [0]とn [1]が同じ値を含む値のnx2アレイだけです。また、 s1.entries()を変数または定数に割り当てることもできます。その場合、 next()を使用して再生できるイテレーターオブジェクトを取得します。
MISC[Sets] :弱者
MISC[Sets] :オペレーターの使用
メソッドJavaScriptアレイオブジェクトの一部：
4.1配列.push（）：
var arr1 = [ 1 , 2 , 3 , 4 , 5 ] ;
arr1 . push ( 6 ) ;
console . log ( arr1 ) ; // it prints [1,2,3,4,5,6]配列.push（）は、配列に要素を追加するためのミューテーター関数にすぎません。したがって、関数配列の引数として要素を単純に言及することができます。push（）と言及された要素は、配列の最後の要素として追加されます。
4.2配列.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（）は、配列の最後の要素を削除するための単純な変異関数です。したがって、この方法では議論をしませんが、引数を渡そうとすると、それはそれらを取らないでしょう。配列の最後の要素を削除する基本的な動作のみを実行します。
4.3配列.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（）は、配列内の特定の要素のインデックスを見つけるために使用できるアクセサ機能です。これに渡される議論は、配列内の要素の値です。また、データに同じ要素が複数発生している場合、配列内の要素の最初の発生が表示されることに注意してください。
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（）はアクセサ機能であり、動作がindexOf機能と非常に類似しています。ただし、 lastIndexOfであるという違いは、配列内の要素の最後の発生のインデックスを返します。
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（）は、既存の配列から新しい配列を作成するために使用されるアクセサ機能です。引数として配列が必要であり、関数が実行された後、引数の配列は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（）には、実行できるさまざまな操作セットがあります。ケース1を観察すると、5番目のインデックスからArray arr1に要素を追加します。また、ケース2で観察すると、変数を割り当てることなく、追加する予定の要素が継続的な引数として渡されることがわかります。スプライスは要素を追加するアクションを実行できるだけでなく、要素を削除するアクションを実行することもできることに注意してください。関数Splice（）では、2番目の引数の値を「0」に選択する場合、指定されたインデックスからのみ要素が追加されますが、値が「0」でない場合、指定された数は削除される要素の数になります。
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（）は上記のメソッドArray.pop（）と変わりませんが、削除する要素のインデックスに関して大きな違いが生じます。配列の最初の要素を削除します。 array.pop（）と同様に、この方法は引数を取ります。引数が渡されたとしても、操作を実行し続けます。
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（）は、Array.push（）のカテゴリと同じカテゴリに分類されます。これらは、両方ともアレイに要素を追加するための変異関数として使用されるためです。両方のメソッドの唯一の違いは、引数をarray.unshift（）に渡すと、アレイの最初の要素として要素が追加されることです。上記のスニペットを観察すると、要素「1」のインデックスが次の場所にシフトされ、「Akhil Pandey」がアレイの最初の要素として追加されていることがわかります。したがって、array.push（）とは異なり、このメソッドは、アレイの開始に要素を追加するため、要素を追加するためだけに誤解されるべきではありません。
4.9配列.Reverse（）：
var arr1 = [ 1 , 'akhil' , 'varma' , 'chandu' , 'adheeth' ] ;
arr1 . reverse ( ) ;
console . log ( arr1 ) ; // it prints ['adheeth', 'chandu', 'varma', 'akhil', 1]Array .Reverse（）は、配列内の要素の順序を逆転させるために使用されるミューテーター関数にすぎません。
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（）は、要素を順番に配置するために使用されるもう1つの変異体関数でもあります。文字列と数字の両方は、array.sort（）メソッドを使用してソートできます。ソートは昇順で行われるため、文字列または文字が要素である場合、アルファベットスケールに応じて、ソートが行われます。
4.11配列.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（）は、イテレーター関数に似たメソッドですが、このarray.foreach（）の根本的な違いは、array.map（）が結果に新しい配列を返すのに対し、array.foreach（）は関数結果を持つ新しい配列を返しません。
注：array.map（）は非常に強力な方法であり、多様なアプリケーションに適用できます。ただし、この方法はarray.map（）を使用して各要素を繰り返すため、目的がいくつかの要素を反復している場合は使用する必要はありません。
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（）は、関数を引数として取得することで配列で使用できる方法であり、それによってアレイ要素を反復する関数を作成します。 array.reduce（）は、配列要素を繰り返し、アレイの終了に到達すると、単一の値が得られます。
注：array.deduceright（）は、array.reduce（）に似ていますが、通常の方法ではなく、右端要素から左端要素への配列要素を繰り返します。
TIPS[Arrays] :
MISC[Arrays] :
独自の方法を書くことで配列オブジェクトを操作する：
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 blockarray.prototypeにメソッドを追加することは、基本的にグローバル配列オブジェクトにメソッドを追加することを意味します。したがって、array.prototypeは、実際に既存の配列オブジェクトに新しいプロトタイプを追加することを意味します。したがって、以下のコードスニペットでより良い類推を説明できます。
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 ) ;上記のアレイプロトタイプを観察すると、慎重に観察できる場合は、配列メソッドArray.prototype.concat（）がどのように機能するかについての作業レプリカに他なりません。したがって、concat（）メソッドでは、別の配列がメソッドとプライマリアレイconcatの引数として渡され、配列が拡張されます。
上記の例を検索するものは、アレイプロトタイプだけでなく、文字列、数字、regexp、またはオブジェクト自体などのすべてのJavscript認識オブジェクトにも適しているため、カスタムメソッドを作成する方法です。
連想配列：
できれば、これは言語の大部分であり、これはPHPやPythonなどの多くのプログラミング言語の不可欠な部分でしたが、これに他のプログラミング言語で提供するものにはわずかな変更があります。
[注]：Pythonでは、関連するアレイと呼ばれたり、呼ばれたりしていませんが、名前辞書が付属しています。
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 3上記のスニペットは、名前付きインデックスまたは連想配列を備えた配列の古典的なケースの実装です。上記のように実装は行うことができ、いくつかの名前を除くほぼすべての配列オペリションは、名前付きインデックスで非常にスムーズに実行できます。名前付きインデックスを備えた配列がその長さを要求されると、問題が発生します。 'array.prototype.length（）メソッドが参照されると、Numberdインデックスがある配列の長さのみを返します。名前のインデックスを使用すると、インデックスは文字列ではなく数字ではないため良くありません。
そのような場合、指定されたインデックスアレイの長さを返す必要がある場合は、object.keys（arrayname）。長さは配列の長さを与えます。
JavaScript文字列オブジェクトの一部である方法：
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（）は、指定された文字列の特定のインデックスに存在する文字を決定するために使用できる方法です。関数は1つの引数のみを取り、文字を出力として返します。入力として指定されたインデックスが、文字列の長さよりも大きいまたはそれ以下の場合に入力として指定された場合、関数は''または出力として空の文字列を返すだけであることに注意してください。
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（）は、新しい文字列を返すために2つ以上の文字列を結合するために使用される方法です。基本的にこの方法は文字列操作に使用されますが、文字列が通常別のタイプと連結されている場合、結果は文字列になります。上記の例を観察すると、 str1.concat(true)が表示されるため、ここで結果の文字列はstring .concat（）としてakhiltrueです。現在、 string偽りの値と連結しようとした場合、結果はstringと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（） ：メソッドstring.slice（）は、本質的に文字列の一部を抽出し、スライスした新しい文字列を返します。 string.sliceメソッドを使用する一般的な表記は、string.slice（pos1、pos2）です。pos1では開始インデックスの位置、pos2は終了インデックスの位置です。ここで注意すべき点は、ネガティブパラメーターを渡すことによりstring.slice（）メソッドを使用する場合、最後から開始まで文字列をカウントして抽出することになります。また、2番目のパラメーターを渡すと、メソッドは文字列の残りの部分を抽出します。
string.substring（） ：メソッドstring.slice（）およびstring.substring（）は、ソース文字列から文字列の一部または部分を抽出するために使用できる同じカテゴリのメソッドに分類されます。両方の違いは、メソッドstring.substring（）を使用する場合、負のインデックスを使用できないことです。たとえば、string.substring（-7、-1）のようなメソッドのネガティブインデックスを渡すと、ネガティブインデックスを使用するための間違いを示すエラーを基本的にパイプアウトしませんが、文字列全体を表示します。
JavaScript：
| 種類 | オブジェクトにすることができます | 常にオブジェクトです |
|---|---|---|
| ブール人 | ✔ | |
| 数字 | ✔ | |
| 文字列 | ✔ | |
| 日付 | ✔ | |
| 数学 | ✔ | |
| 正規表現 | ✔ | |
| 配列 | ✔ | |
| 関数 | ✔ |
したがって、基本的にプリミティブ値を除いてすべてが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オブジェクトは可変性があります。これは、値ではなくアドレスで参照されることを意味します。たとえば、「マスター」がオブジェクトであり、「マスターバックアップ」も別のオブジェクトである場合、オブジェクトを渡すと、他のオブジェクトも変更する可能性があります。
{
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]"
} JavaScriptの関数閉鎖は、ローカルまたはグローバルの範囲で変数がどのように扱われ、参照されているかについてのすべてです。 JS変数を指定できます。
プライベート変数と呼ばれるものの組み込み概念はありません。したがって、そのようなシナリオ閉鎖の要件がある場合、JSで範囲が範囲内の変数の範囲を作成するために書かれています。
カレーは、複数の引数を取得し、一連の機能を通じて部分的に適用することにより、関数を構築するプロセスです。したがって、具体的には、複数の引数を引用の一部を取得する一連の関数に取り込む特定の関数を分解できます。
よく見てみましょう。
テールコールは、再帰関数の概念を本質的にループに置き換えるだけです。ある意味では、これは時間を節約できるだけでなく、スペースを節約することもできます。つまり、より良い時間の複雑さと空間の複雑さを節約します。
// 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 ) ;
}因子のために上記のアルゴリズムの両方を観察すると、f（）は因子を見つけるために使用される従来の再帰的方法であるが、f1（）はテールコール最適化されたアルゴリズムであり、より良く高速であることを理解できます。
ドキュメント全体がエラーがないことを確認するために最善の努力が払われていますが、間違いが発生した可能性のある小さなインスタンスがあるかもしれません。そのような場合、問題を提起して、このチートシートを改善するのを手伝ってください。
