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 = "" ، ستكون نتيجة المقارنة خاطئة. هذا ببساطة لأنه إذا أعلننا سلسلة باستخدام الطريقة 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" )
}رمز مقتطف واحد واثنان متماثلان. لكن الفرق الأساسي بين كلتا عينات الكود هو أن المرء يستخدم فاصلة فاصلة في دلالات lang -uage ولكن في حين أن الآخر لا يفعل ذلك. في الأساس ، يتم تعليمنا استخدام فاصلة فاصلة بلغات مثل 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 () هي طريقة تستخدم لإضافة أو تحديث عنصر بمفتاح وقيمة محددة في الخريطة. هنا الوسيطة الأولى هي المفتاح في حين أن الوسيطة الثانية هي القيمة. يمكن أن تكون المفاتيح من أي نوع ولكن سيكون من الأفضل استخدام objects كمفاتيح بدلاً من strings لأنه إذا استخدمنا strings كمفاتيح ، فلن يكون هناك أي فرق كبير بين Maps Objects .
2.2 الخريطة .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 الخريطة .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 الخريطة .has () هي طريقة تشير إلى ما إذا كان هناك عنصر يحتوي على المفتاح المطلوب في الخريطة أم لا. تأخذ الطريقة وسيطة واحدة فقط وهي المفتاح وتُرجع true إذا كان العنصر موجودًا أو false إذا لم يكن العنصر موجودًا.
2.4 الخريطة . الحجم:
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 الخريطة .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 الخريطة .delete () هي طريقة تستخدم لحذف عنصر معين من كائن Map . تأخذ الطريقة وسيطة واحدة فقط وهي المفتاح ، وإذا كان المفتاح موجودًا في Map ، فإنه يحذف العنصر ويعيد true ، ولكن إذا لم يكن المفتاح موجودًا في Map ، فإنه يلقي false .
2.7 خريطة .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 لكل عنصر. تقوم الطريقة بإرجاع كائن ITERATOR MAP الذي يمكن استخدامه لمعرفة المفاتيح الموجودة في Map . في المثال أعلاه ، يتم تحديد كيفية التكرار عبر الخريطة .keys () باستخدام next() . تجدر الإشارة إلى أنه عند استخدام next() على كائن التكرار ، يجب استخدام value أو done لأن الاستخدام المباشر للأمام لـ next() يؤدي إلى عرض Object . iterator.next().value true قيمة المفتاح الموجود في كائن التكرار بينما iterator.next().done false
2.8 خريطة . القيم ():
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 لكل عنصر. تقوم الطريقة بإرجاع كائن Iterator الذي يمكن استخدامه لمعرفة القيم الموجودة في Map . في المثال أعلاه ، يتم تحديد كيفية التكرار عبر الخريطة .values () باستخدام next() . تجدر الإشارة إلى أنه عند استخدام next() على كائن التكرار ، يجب استخدام value أو done لأن الاستخدام المباشر للأمام لـ next() يؤدي إلى عرض Object . iterator.next () true iterator.next().value false قيمة عنصر معين موجود في كائن التكرار بينما iterator.next().done .
2.9 خريطة . 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 الخريطة . Entries () هي طريقة يتم مقاضاتها لإرجاع المفاتيح والقيم الموجودة في كائن Map لكل عنصر. تشبه الطريقة تمامًا الخريطة .values () لحقيقة أنها تُرجع كائن التكرار الذي يمكن استخدامه لمعرفة المفاتيح والقيم الموجودة في Map . في المثال أعلاه next() يتم عرضه حول كيفية التكرار عبر الخريطة . تتشابه قدرة الطريقة وطريقة تشغيلها تمامًا مع القيم الخريطة () باستثناء حقيقة أن المفاتيح يتم إرجاعها أيضًا مع القيم أثناء تكرارها على كائن Iterator . على غرار أي كائن Iterator بمجرد وصوله إلى نهاية طائرته ، فإنه سوف يرمي undefined . وأيضًا ، تجدر الإشارة إلى أنه يمكن استخدام أي طريقة أخرى تنطبق على كائن Iterator مع هذا لأنها واحدة.
MISC[Maps] : يمكن اعتبار الخرائط الضعيفة خرائط مع اختلافات في منهجية تحدث مجموعات القمامة تحت الغطاء. لوضعها في مصطلحات أبسط وواضحة ، يجب أن يكون هناك درس مفاهيمي صغير من أجل تقديم المنظور. في JavaScript على نطاق واسع ، كل شيء هو كائن ، وبالتالي فإن اللحظة التي تنشئ فيها واحدة ويتم تخصيص الذاكرة لنفسه وحتى V8 تلقائيًا GC (قصير لجمع القمامة) ، يظل الكائن عقدة في الرسم البياني. تجدر الإشارة إلى أنه حتى لا توجد إشارات إلى الكائن الذي تم إنشاؤه في الذاكرة ، فلن يكون GC'd ، لذلك يتم الاحتفاظ بجميع الكائنات tightly أو strongly . لذلك ، فإن الفرق الذي يتم إحضاره باستخدام خرائط ضعيفة هو أن مفاتيح الكائن يتم الاحتفاظ بها weakly من الآن فصاعدا ، إذا كان الكائن GC'D بواسطة V8 أو بواسطتك ، فسيتم إزالة الإدخال من خريطة الضعف ولكن ليس قيمًا. لا يوجد فرق صارخ بين الطريقة التي تعمل بها الخرائط والخرائط الضعيفة على الرغم من أن الخرائط الضعيفة تقبل فقط الكائنات كمفاتيح (بدقة). دعونا ننظر أدناه لنرى كيف يتم تهيئتها:
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. تجدر الإشارة إلى أنه على الرغم من أن الطريقة التي تتفاعل بها API DefentMaps معنا بنفس الطريقة التي يفعل بها كائن الخرائط ، إلا أن هناك قيودًا على العمليات التي توفرها واجهة برمجة تطبيقات DefMaps . إنه يدعم 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 () هي طريقة متحولة لإضافة القيم إلى مجموعة. الإجراء لتحقيق هذا واضح ومباشر. نطلق على طريقة add() إلى كائن Set الذي تم إنشاؤه بالفعل ونمر بالقيمة التي نريدها في المجموعة كوسيطة. عندما يتم تمرير أكثر من وسيطة إلى طريقة add() ، فإنها تتجاهل فقط الوسائط المتبقية وتبحث فقط الوسيطة الأولى. تجدر الإشارة إلى أن الكائن Set ليس لديه أي قيود على نوع القيمة التي يتم تمريرها ولا يفرض أي قيود عندما نجعل Set غير متجانسة. NaN ، يمكن أن يكون null أيضًا جزءًا من Set . على الرغم من أنه لا يتم تشجيعه أبدًا على ملء Set بقيم من هذا النوع.
3.2 مجموعة .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) هو مثال يلقي بعض الضوء على التنافس الطويل العقد بين جافا سكريبت وقيم النقطة العائمة. يمكن تجنب ذلك ببساطة باستخدام الرقم .ToPrecision (). أيضًا ، في JavaScript ، يتم تشجيعه دائمًا على التعامل مع النقاط العائمة بعناية.
3.3 SET .SIVE:
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 ليست طريقة ولكنها خاصية لكائن SETS مفيدة لتحديد حجم Set . كما يمكنك أن تلاحظ من مقتطف الرمز أعلاه ، يطلق عليه مجرد طريقة ملحق. إذا حاولنا استدعاء الخاصية باستخدام size() ، فإنه يرمي typeerror يقول 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 () وبغض النظر عن الوسيطة التي يتم تمريرها إلى الطريقة التي تتجاهلها وتنفيذ العملية clear() على Set . أيضًا ، لا يوجد أي قيود على عدد المرات التي يتم فيها تنفيذ العملية.
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 () هي طريقة تستخدم لإزالة عنصر من المجموعة. تقبل الطريقة وسيطة واحدة فقط وتُرجع قيمة منطقية 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 ، ولكن هناك تمييز صغير ، وهو الخريطة . القيم () لن تُرجع فقط القيم الموجودة في Map والخريطة . keys () لن تُرجع فقط المفاتيح المرتبطة بكل قيمة/عنصر. الآن ، نظرًا لأن Set تحتوي على مفتاح وقيمة نفس العنصر ، فليس هناك الكثير من التمييز بين Set .values () و Set .Keys (). سنعود مع نفس الأشياء التي لا يمكن أن تكون مع عدم وجود اختلاف على الإطلاق.
3.7 مجموعة . 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 . Enters () هي طريقة تُرجع مجموعة من القيم للقيم الموجودة في Set . علينا أن نفهم أنه في Set ما يظل المفتاح والقيمة كما هو ، لذلك عندما نسمي المجموعة . يمكننا أيضًا تعيين s1.entries() لمتغير أو ثابت ، وفي هذه الحالة ، سنحصل على كائن التكرار في المقابل الذي يمكن تشغيله باستخدام next() .
MISC[Sets] : الضعف
MISC[Sets] : استخدام ... المشغل
أساليب جزء من كائن صفيف 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 () هي مجرد وظيفة متحولة لإضافة عناصر إلى الصفيف. لذلك يمكننا ببساطة ذكر العنصر كوسيطة إلى صفيف الوظيفة. 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 ، فإننا نضيف عناصر إلى Array ARR1 من الفهرس الخامس. أيضًا إذا لاحظنا في الحالة 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 Array .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 () هي أيضًا وظيفة موكة أخرى تستخدم لوضع العناصر بالترتيب. يمكن فرز كل من السلاسل والأرقام باستخدام طريقة Array.sort (). يحدث الفرز بترتيب تصاعدي ، لذلك إذا كانت الأوتار أو الشخصيات عناصرًا ، فعندئذ يعتمد على المقياس الأبجدي ، يحدث الفرز.
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 () هي طريقة تشبه وظيفة التكرار ، ولكن الفرق الأساسي بين هذا و Array.foreach () هو أن Array.map () يعيد صفيفًا جديدًا بالنتيجة ، في حين أن Array.foreach () لا يعيد مجموعة جديدة بنتيجة الوظيفة.
ملاحظة: Array.map () هي طريقة قوية للغاية ويمكن تطبيقها على تطبيقات متنوعة. على الرغم من أن هذه الطريقة تتكرر على كل عنصر باستخدام Array.map () يجب النظر إليه بعناية ويجب عدم استخدامه إذا كان الغرض يتكرر على بعض العناصر.
4.14 صفيف .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.reduceright () يشبه أكثر من 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 blockإضافة طرق إلى 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. لذلك في Concat () ، يتم تمرير مجموعة أخرى كوسيطة للطريقة ومساعد الصفيف الأساسي ويمتد الصفيف.
الأشياء التي يجب البحث عنها في المثال أعلاه هي كيف يمكن كتابة الأساليب المخصصة من أجل تناسب الغرض المحدد ليس فقط للنموذج الأولي للمصفوفة ولكن أيضًا جميع الكائنات المعترف بها Javscript مثل السلسلة أو الرقم أو RegexP أو الكائن نفسه.
المصفوفات الترابطية :
من الأفضل أن يكون هذا جزءًا كبيرًا من اللغة على الرغم من أن هذا كان جزءًا لا يتجزأ من العديد من لغات البرمجة مثل 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 ()" ، فإنها تُرجع فقط طول الصفيف الذي يحتوي على فهرس الرقم ، إذا استخدمنا الفهارس المسماة ، فهذا ليس جيدًا لأن الفهارس هي سلاسل ولكن لم تعد أرقامًا.
في مثل هذه الحالة ، إذا احتجنا إلى إرجاع طول الصفيف الفهرس المسماة ثم الكائن.
الطرق التي هي جزء من كائن سلسلة 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 () هي طريقة يمكن استخدامها لتحديد الحرف الموجود في فهرس معين من السلسلة المحددة. تستغرق الوظيفة وسيطة واحدة فقط وتُرجع الحرف كمخرجات. تجدر الإشارة إلى أنه عندما يكون الفهرس المعطى كمدخل إذا كان إما أكبر من طول السلسلة أو أقل من طول السلسلة ، فإن الوظيفة تُرجع فقط '' أو سلسلة فارغة كإخراج.
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 () هي طريقة تستخدم لدمج سلسلتين أو أكثر من أجل إرجاع سلسلة جديدة. يتم استخدام هذه الطريقة بشكل أساسي لعمليات السلسلة ، ولكن إذا كانت السلسلة متسلسلة عادةً بنوع آخر ، فستكون النتيجة سلسلة. إذا لاحظنا مثالًا أعلاه ، فإننا نرى str1.concat(true) لذا فإن السلسلة الناتجة هنا هي akhiltrue كسلسلة .concat () تجمع بين قيمة كل من الوسيطات وتنتج سلسلة متسلسلة كنتيجة نهائية. الآن ، هناك حتى حالات خاصة لنفترض ، إذا حاولت string متسلسلة بقيم falsy ، فستكون النتيجة هي مزيج من قيمة string والفلس.
5.3 String .indexof ():
5.4 String .lastIndexof ():
5.5 String .Link ():
5.6 String .Search ():
5.4 String .Slice ():
TIPS[Strings]:
String.Slice () : سلسلة method.slice () تستخرج بشكل أساسي جزء من سلسلة وإرجاع السلسلة الجديدة التي يتم شرائحها. الترميز العام لاستخدام طريقة string.slice هو string.slice (pos1 ، pos2) حيث في pos1 هو موضع فهرس البداية و pos2 هو موضع فهرس الانتهاء. النقطة التي يجب الإشارة إليها هنا هي ما إذا كنا نستخدم طريقة string.slice () عن طريق تمرير المعلمات السلبية ثم ينتهي الأمر بالعد واستخراج السلسلة من النهاية إلى البداية. وإذا لم نمر المعلمة الثانية ، فإن الطريقة تستخرج بقية السلسلة.
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 قابلة للتغيير مما يعني أنه يتم الرجوع إليه بواسطة العنوان وليس القيمة. على سبيل المثال ، إذا كان "Master" كائنًا و "Master-Backup" هو أيضًا كائن آخر ، فعندئذ قمنا بتمرير الكائنات ، فقد يؤدي تغيير المرء إلى تغيير الكائن الآخر أيضًا.
{
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 من أجل تحديد مجال للمتغيرات الخاصة في النطاق.
Currying هي عملية لبناء وظيفة عن طريق أخذ وسائط متعددة وتطبيقها جزئيًا من خلال سلسلة من الوظائف. لكي تكون محددًا ، يمكنك تحطيم الوظيفة المحددة التي تأخذ وسائط متعددة في سلسلة من الوظائف التي تشارك في الحجج.
دعونا نأخذ مثالًا مشتركًا:
مكالمات الذيل ليست سوى استبدال مفهوم الوظائف العودية مع حلقة. بطريقة ما ، لا يمكن أن يوفر هذا الوقت فحسب ، بل يوفر أيضًا المساحة ، أي تعقيد وقت أفضل وتعقيد الفضاء.
// 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 () هي الطريقة المتكررة التقليدية المستخدمة لإيجاد Factorial ، ولكن F1 () هي الخوارزمية المحسنة للمكالمة التيل والتي هي أفضل وسريعة.
على الرغم من بذل أفضل الجهود للتأكد من أن الوثائق بأكملها خالية من الأخطاء ، فقد تكون هناك حالات صغيرة قد تحدث فيها الأخطاء. في مثل هذه الحالات ، يرجى إثارة مشكلة ومساعدتي في جعل ورقة الغش هذه أفضل.
