Array baru ()
Array Baru (Len)
Array baru ([item0, [item1, [item2, ...]]]]
Metode untuk menggunakan objek array:
var objarray = array baru ();
objarray.concact ([item1 [, item2 [, ...]]] --------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------------------------------------------- dan kembali, Array asli tidak terpengaruh.
arr.concact ("d", "e");
Akan mengembalikan array yang berisi elemen surat dari "a" ke "e". Dan ARR sendiri tidak terpengaruh.
objarray.join (pemisah) -------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ---- )sama.
objarray.pop () -------- dalam istilah awam, itu adalah untuk memunculkan elemen terakhir dari array. Dikombinasikan dengan metode dorong berikut, dimungkinkan untuk menggunakan array sebagai tumpukan. Metode POP mengembalikan nilai elemen terakhir dari array dan mengurangi atribut panjang dengan 1, yaitu, elemen terakhir hilang segera setelah kembali.
objarray.push ([value1 [, value2 [, ...]]]] ------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- Misalnya: [1,2,3, 4] .push ("a", "b") akan mendapatkan [1,2,3,4, "a", "b"]
objarray.reverse () membalik elemen dalam array. Misalnya: [1,2,3] .reverse () akan mendapatkan [3,2,1].
objarray.shift () ------------ Hapus elemen pertama dari array dan mengembalikan nilai elemen ini. Sifat metode ini sangat mirip dengan metode POP, yaitu untuk menghapus elemen terakhir.
Objarray.slice (Mulai, Akhir) -------------- Mengembalikan subset dari objek array Array asli tidak terpengaruh. Misalnya: [1,2,3,4,5,6] .Slice (1,4) akan mendapatkan [2,3,4]. Ketika mulai atau akhir negatif, mereka digunakan untuk menambahkan nilai panjang. Misalnya: [1,2,3,4,5,6] .slice (-4, -1) akan mendapatkan [3,4,5]. Jika akhir kurang dari atau sama untuk memulai, array kosong akan dikembalikan.
objarray.sort (comparefn) --------------------------------------------- -------------------------------------------------- ------------------ Fungsi CompareFN harus menerima dua parameter elemen1 dan elemen2. yaitu, simpan yang asli) pengembalian 0. Ketika dibandingkan, dihilangkan, elemen -elemen diatur dalam urutan kamus. Sebagai contoh: Untuk fungsi perbandingan yang ditentukan CMP: fungsi CMP (E1, E2) {return e1-e2;}, lalu [3,4,2,7] .sort (CMP) akan mendapatkan [2,3,4,7 ].
objarray.splice (start, deletecount [, item1, item2 [, ...]]]] ini adalah fungsi kompleks untuk menyelesaikan penghapusan, substitusi dan penyisipan elemen array. Di antara mereka, parameter Mulai menunjukkan posisi indeks yang akan dilakukan, dan dihapus mengacu pada jumlah elemen yang akan dihapus dari awal (termasuk posisi awal). Jika dihilangkan, itu berarti bahwa bagian yang tersisa dari array akan menjadi dihapus dari awal. [, item1 [, item2 [, ...]]]] berarti daftar elemen opsional yang dimasukkan sebelum mulai. menyukai:
var arr = [0,1,2,3,4,5,6];
arr.splice (1,1);
Document.write (arr); // Tunjukkan "0, 2, 3, 4, 5, 6"
ARR = [0,1,2,3,4,5,6];
arr.splice (0,0, "a", "b");
Document.write (arr); // Tunjukkan "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); // Tunjukkan "0,1,2, C, D, 5,6"
objarray.unshift (item1 [, item2 [, ...]]]) --------------------------------- -------------------------------------------------- ------------------- Properti dan tipe metode dorong, tetapi metode dorong adalah menambahkan elemen ke ujung array. Misalnya: [1,2,3,4] .unshift ("A", "B") akan mendapatkan ["A", "B", 1,2,3,4].
Penambahan dan penghapusan elemen array JS telah membingungkan.
var arr = array baru ();
arr [0] = "aaa";
arr [1] = "bbb";
arr [2] = "ccc";
//alert(arr.length) ;///3
arr.pop ();
//alert(arr.length);//2
//alert(arraceArr.length-1 );//bbb
arr.pop ();
//alert(arr[arr.length-1 );//aaa
//alert(arr.length);//1
var arr2 = array baru ();
//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);
alert (arr2.length); // 1
peringatan (arr2 [0]); // aaa
peringatan (arr2 [1]); // tidak ditentukan
Shift: Hapus item pertama dari array asli dan kembalikan nilai elemen yang dihapus;
var a = [1,2,3,4,5];
var b = a.shift (); // a: [2,3,4,5] b: 1
Unshift: Tambahkan parameter ke awal array asli dan kembalikan panjang array
var a = [1,2,3,4,5];
var b = A.unshift (-2, -1); // a: [-2, -1,2,3,4,5] b: 7
Catatan: Nilai pengembalian tes di IE6.0 selalu tidak ditentukan, dan nilai pengembalian tes di FF2.0 adalah 7, jadi nilai pengembalian metode ini tidak dapat diandalkan. metode ini.
POP: Hapus item terakhir dari array asli dan kembalikan nilai elemen yang dihapus;
var a = [1,2,3,4,5];
var b = a.pop (); // a: [1,2,3,4] b: 5 // jika Anda tidak perlu kembali, sebut saja saja secara langsung
Dorong: Tambahkan parameter ke ujung array asli dan kembalikan panjang array
var a = [1,2,3,4,5];
var b = A.push (6,7); // A: [1,2,3,4,5,6,7] B: 7
Concat: Mengembalikan array baru, yang terdiri dari menambahkan parameter ke array asli.
var a = [1,2,3,4,5];
var b = a.concat (6,7);
Splice (Mulai, Deletecount, Val1, Val2, ...): Item Deletecount dari posisi awal, dan masukkan Val1, Val2, ...
Saat membersihkan array, cukup berikan startIndex.
Jika semua elemen tidak dihapus, lewati parameter Deletecount.
Splice juga memiliki fungsi penghapusan pertama dan kemudian menambahkan, yaitu, menghapus beberapa elemen terlebih dahulu, dan kemudian menambahkan beberapa elemen pada posisi yang dihapus. .
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); // pop yang sama
a.splice (a.length, 0,6,7);
Reverse: Balikkan array
var a = [1,2,3,4,5];
var b = a.reverse (); // a: [5,4,3,2,1] b: [5,4,3,2,1]
urutkan (orderfunction): urutkan array berdasarkan parameter yang ditentukan
var a = [1,2,3,4,5];
var b = a.sort (); // a: [1,2,3,4,5] b: [1,2,3,4,5]
Slice (Start, End): Mengembalikan array baru yang terdiri dari item dari subskrip mulai yang ditentukan ke subskrip akhir dalam array asli.
var a = [1,2,3,4,5];
var b = a.slice (2,5); // A: [1,2,3,4,5] B: [3,4,5]
Bergabunglah (pemisah): Kelompokkan elemen -elemen array menjadi string, dengan pemisah sebagai pemisah, jika dihilangkan, gunakan koma default sebagai pemisah
var a = [1,2,3,4,5];
var b = a.join ("|"); // A: [1,2,3,4,5] B: "1 | 2 | 3 | 4 | 5"
Berikut adalah cara lain untuk menggunakan array untuk mensimulasikan JavastringBuffer untuk memproses string:
Salinan kode adalah sebagai berikut:
/**
* Fungsi pemrosesan string
*/
function stringBuffer () {
var arr = array baru;
this.append = function (str) {
arr [arr.length] = str;
};
this.toString = function () {
kembalikan arr.join (""); // ping array yang ditambahkan ke dalam string
};
}
Hari ini, saya tiba -tiba menemukan bahwa gabungan adalah cara yang baik untuk mengubah array menjadi string dalam aplikasi, jadi saya merangkumnya menjadi objek dan menggunakan:
Salinan kode adalah sebagai berikut:
/**
*Konversi array menjadi string yang dibagi dengan simbol tertentu
*/
function arrayToString (ARR, pemisah) {
if (! pemisah) pemisah = ""; // jika pemisah nol, itu akan kosong secara default
return arr.join (pemisah);
}
/**
* Temukan string yang terkandung dalam array
*/
function arrayFindString (arr, string) {
var str = arr.join ("");
return str.indexof (string);
}