مجموعة جديدة ()
مجموعة جديدة (لين)
صفيف جديد ([item0 ، [item1 ، [item2 ، ...]]]]]
طرق لاستخدام كائنات الصفيف:
var objarray = new array () ؛
objarray.concact ([item1 [، item2 [، ...]]] ----------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------- والعودة ، لا يتأثر الصفيف الأصلي.
arr.concact ("d" ، "e") ؛
سيعود صفيفًا يحتوي على عناصر الرسالة من "A إلى" E ". ولا تتأثر ARR نفسها.
objarray.join (فاصل) -------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ---- )نفس.
Objarray.pop () -------- من حيث العلمان ، هو الظهور على العنصر الأخير من الصفيف. جنبا إلى جنب مع طريقة الدفع التالية ، من الممكن استخدام المصفوفات كمواجد. تقوم طريقة البوب بإرجاع قيمة العنصر الأخير من الصفيف وطرح سمة الطول بمقدار 1 ، أي العنصر الأخير يضيع فور عودته.
objarray.push ([value1 [، value2 [، ...]]]]] ----------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- ------------------------------------------------- على سبيل المثال: [1،2،3 ، 4] .push ("A" ، "B") ستحصل على [1،2،3،4 ، "A" ، "B"]
objarray.reverse () يدفع العناصر في الصفيف. على سبيل المثال: [1،2،3] سوف تحصل على [3،2،1].
objarray.shift () ------------ إزالة العنصر الأول من الصفيف وإرجاع قيمة هذا العنصر. تشبه طبيعة هذه الطريقة إلى حد كبير طريقة البوب ، وهي إزالة العنصر الأخير.
objarray.slice (start ، end) ------------- إرجاع مجموعة فرعية من كائن الصفيف المصفوفة الأصلية لا تتأثر. على سبيل المثال: [1،2،3،4،5،6]. ستحصل Slice (1،4) على [2،3،4]. عندما تكون البدء أو النهاية سلبية ، يتم استخدامها لإضافة قيمة الطول. على سبيل المثال: [1،2،3،4،5،6]. سيتم الحصول على مرتبة (-4 ، -1) [3،4،5]. إذا كانت النهاية أقل من أو تساوي البدء ، فسيتم إرجاع صفيف فارغ.
objarray.sort (comparefn) ------------------------------------------------ ------------------------------------------------- ------------------- يجب أن تقبل CompareFN وظيفة اثنين من المعلمتين 1 و element2. وهذا هو ، الحفاظ على الأصلي) إرجاع 0. عند مقارنته ، يتم حذف FREANFN ، يتم ترتيب العناصر في ترتيب القاموس. على سبيل المثال: للحصول على وظيفة المقارنة المحددة CMP: الدالة CMP (E1 ، E2) {return E1-E2 ؛} ، ثم [3،4،2،7] .SORT (CMP) [2،3،4،7 ].
objarray.splice (start ، deletecount [، item1 ، item2 [، ...]]]) هذه وظيفة معقدة لإكمال حذف عناصر الصفيف وإدراجها. من بينها ، تشير المعلمة START إلى وضع الفهرس المراد تنفيذه ، ويشير DELETECOUNT إلى عدد العناصر التي سيتم حذفها من البداية (بما في ذلك موضع البداية). تم حذفه من البداية. [، item1 [، item2 [، ...]]]] يعني قائمة اختيارية للعناصر المدرجة قبل البدء. يحب:
var arr = [0،1،2،3،4،5،6] ؛
arr.splice (1،1) ؛
document.write (arr) ؛ // show "0 ، 2 ، 3 ، 4 ، 5 ، 6"
arr = [0،1،2،3،4،5،6] ؛
arr.splice (0،0 ، "a" ، "b") ؛
document.write (arr) ؛ // show "a ، b ، 0،1،2،3،4،5،6"
arr = [0،1،2،3،4،5،6] ؛
Arr.Splice (3،2 ، "C" ، "D") ؛
document.write (arr) ؛ // show "0،1،2 ، c ، d ، 5،6"
objarray.unshift (item1 [، item2 [، ...]]]) ------------------------------- ------------------------------------------------- ----------------- خصائصه ونوع طريقة الدفع ، ولكن طريقة الدفع هي إضافة عناصر إلى نهاية الصفيف. على سبيل المثال: [1،2،3،4] .UNSHIFT ("A" ، "B") سوف تحصل على ["A" ، "B" ، 1،2،3،4].
كانت إضافة وحذف عناصر صفيف JS مربكة.
var arr = new array () ؛
arr [0] = "aaa" ؛
arr [1] = "BBB" ؛
arr [2] = "CCC" ؛
//alert(arr.length) ؛//3
arr.pop () ؛
//alert(arr.length) ؛//2
//alert(arr budaparr.length-1 :) ؛//bbb
arr.pop () ؛
//alert(arr budaparr.length-120) ؛//aaa
//alert(arr.length) ؛//1
var arr2 = new array () ؛
//alert(arr2.length) ؛//0
ARR2 [0] = "AAA" ؛
ARR2 [1] = "BBB" ؛
//alert(arr2.length) ؛//2
arr2.pop () ؛
//alert(arr2.length) ؛//1
arr2 = arr2.slice (0 ، arr2.length-1) ؛
//alert(arr2.length) ؛//0
ARR2 [0] = "AAA" ؛
ARR2 [1] = "BBB" ؛
ARR2 [2] = "CCC" ؛
arr2 = arr2.slice (0،1) ؛
تنبيه (arr2.length) ؛ // 1
تنبيه (ARR2 [0]) ؛ // AAA
تنبيه (ARR2 [1]) ؛ // غير محدد
Shift: احذف العنصر الأول من الصفيف الأصلي وإرجاع قيمة العنصر المحذوف ؛
var a = [1،2،3،4،5] ؛
var B = A.Shift () ؛
إلغاء الهاوية: أضف المعلمة إلى بداية الصفيف الأصلي وأرجع طول الصفيف
var a = [1،2،3،4،5] ؛
var B = A.Unshift (-2 ، -1) ؛
ملاحظة: تكون قيمة إرجاع الاختبار في IE6.0 غير محددة دائمًا ، وقيمة إرجاع الاختبار في FF2.0 ، وبالتالي فإن قيمة إرجاع هذه الطريقة غير موثوق بها. من هذه الطريقة.
POP: احذف العنصر الأخير من الصفيف الأصلي وإرجاع قيمة العنصر المحذوف ؛
var a = [1،2،3،4،5] ؛
var b = a.pop () ؛
اضغط: أضف المعلمة إلى نهاية الصفيف الأصلي وأرجع طول الصفيف
var a = [1،2،3،4،5] ؛
var B = A.Push (6،7) ؛
Concat: إرجاع صفيف جديد ، يتكون من إضافة معلمات إلى الصفيف الأصلي.
var a = [1،2،3،4،5] ؛
var B = A.Concat (6،7) ؛
splice (start ، deletecount ، val1 ، val2 ، ...): deletecount item من موضع البداية ، وإدراج Val1 ، val2 ، ...
عند تطهير المصفوفة ، فقط تمرير startIndex.
إذا لم يتم حذف جميع العناصر ، فالمرض معلمة DELETECOUNT.
لدى Slose أيضًا وظيفة الحذف أولاً ثم إضافة العديد من العناصر ، ثم قم بإضافة العديد من العناصر التي تم حذفها. .
var a = [1،2،3،4،5] ؛
var B = A.Splice (2،2،7،8،9) ؛
var B = A.Splice (0،1) ؛
A.Splice (0،0 ، -2 ، -1) ؛
var B = A.Splice (A.Length-1،1) ؛ // نفس البوب
A.Splice (A.Length ، 0،6،7) ؛
عكس: عكسي المصفوفة
var a = [1،2،3،4،5] ؛
var b = a.reverse () ؛
فرز (OrderFunction): فرز الصفيف حسب المعلمات المحددة
var a = [1،2،3،4،5] ؛
var b = a.sort () ؛
Slice (Start ، End): إرجاع مجموعة جديدة تتكون من عناصر من مجموعة START المحددة إلى التراجع النهائي في الصفيف الأصلي.
var a = [1،2،3،4،5] ؛
var b = a.slice (2،5) ؛
انضم إلى (فاصل): قم بتجميع عناصر الصفيف في سلسلة ، مع فاصل كفاصل ، إذا تم حذفه ، استخدم الفاصلة الافتراضية كفاصل
var a = [1،2،3،4،5] ؛
var B = A.Join ("|") ؛
فيما يلي طريقة أخرى لاستخدام Array لمحاكاة JavastringBuffer لمعالجة السلاسل:
نسخة الكود كما يلي:
/**
* وظيفة معالجة السلسلة
*/
وظيفة StringBuffer () {
var arr = صفيف جديد ؛
this.append = function (str) {
arr [arr.length] = str ؛
} ؛
this.toString = function () {
إرجاع arr.join ("") ؛ // ping الصفيف الذي يلحق بسلسلة
} ؛
}
اليوم ، اكتشفت فجأة أن الانضمام هو وسيلة جيدة لتحويل المصفوفات إلى سلاسل في التطبيق ، لذلك قمت بتغليفها في كائنات واستخدمت:
نسخة الكود كما يلي:
/**
*تحويل المصفوفات إلى سلاسل مقسمة برموز محددة
*/
وظيفة ArrayToString (ARR ، فاصل) {
إذا كان (فاصل) فاصل = "" ؛ // إذا كان الفاصل فارغًا ، فسيكون فارغًا افتراضيًا
إرجاع arr.join (فاصل) ؛
}
/**
* ابحث عن السلسلة الموجودة في الصفيف
*/
وظيفة ArrayFindString (arr ، سلسلة) {
var str = arr.join ("") ؛
إرجاع str.indexof (سلسلة) ؛
}