javascript Pembelajaran
javascript secara kasar dapat dibagi menjadi 3 bagian yang berbeda: Inti (ECMAscript), Objek Teks (DOM), Objek Browser (BOM)
Inti (ECMAscript): Kata Kunci, Pernyataan, Operator,
Objek Objek Teks (DOM): DOM akan merencanakan seluruh halaman menjadi dokumen yang terdiri dari level node.
Parsing mengikuti standar dom html W3C:
Referensi dom W3C memberikan perhatian khusus pada deskripsi DOM Node
objek browser BOM. Cookie, browser baru pop-up, ukuran pengaturan browser
Inti (ECMAscript) Objek bawaan global;
Metode: parseInt(), isNan(), encodeURI()...dll. semuanya merupakan metode objek ini
Berikan perhatian khusus pada eval(); simbol bahasa dinamis seperti: eval("alert('hi')"); tetapi metode ini sangat jahat (aspek keamanan)
Deskripsi objek teks (DOM):
<toko buku> <book kategori="memasak"> <title lang="en">Bahasa Italia Sehari-hari</title> <author>Giada De Laurentiis</author> <tahun>2005</tahun> <price>30.00</price > </buku> </toko buku>
1. Dasar-dasar skrip ECMA
$ Tipe lemah variabel; Penunjukan tipe Hongaria: var iOuouValue=100;
$ dapat mengakhiri baris dengan atau tanpa titik koma; tetapi kemudian onsubmit="javascript:function();return false;
"
"typeof" var test=1; alert(typeof testX); //keluaran "tidak terdefinisi"
"NaN" - bukan angka -> isNan("biru"); //keluaran "benar" ->isNan("123") ; //keluaran "salah"
$objek; var o = Objek baru();
Berikut penjelasan khusus bahwa suatu fungsi yang biasa kita tulis adalah sebuah objek.
Var a = {name:"Liu Kaiyi"} ini setara dengan var a = function(){this.name="Liu Kaiyi"}
; nama:"test" ,pass:"123456",addr:"bj"} //Apa ini? ! json
Ketika var str = '{name:"test",pass:"123456",addr:"bj"}'
var objectBean = eval(str); //Berikut adalah objek objectBea.name menggunakan
konsep domain:
<SCRIPT type = teks/javascript>
var sPesan = 'Halo';
fungsi setSesuatu() {
sWarna = 'merah';
sMessage = 'Halo Dunia!';
}
setSesuatu();
peringatan(sPesan); //Halo Dunia!
peringatan(sWarna); //merah
</SCRIPT> <Jenis SCRIPT=teks/javascript>
var sPesan = 'Halo';
fungsi setSesuatu() {
var sWarna = 'merah';
sMessage = 'Halo Dunia!';
}
setSesuatu();
peringatan(sPesan); //Halo Dunia!
peringatan(sWarna); // tidak ada
</SCRIPT>
<Jenis SCRIPT=teks/javascript>
var sPesan = 'Halo';
fungsi setSesuatu() {
var sWarna = 'merah';
var sMessage = 'Halo Dunia!';
}
setSesuatu();
peringatan(sPesan); //Halo
peringatan(sWarna); // tidak ada
</SKRIP>
Meletakkan dasar untuk berorientasi objek: penerapan objek tipe prototipe objek. Referensi
// Warisan paling sederhana
Objek.prototipe.inObj = 1;
fungsi A()
{
ini.inA = 2;
}
A.prototipe.inAProto = 3;
B.prototype = new A; // Hubungkan A ke rantai prototipe B
B.prototipe.konstruktor = B;
fungsi B()
{
ini.diB = 4;
}
B.prototipe.inBProto = 5;
x = B baru;
dokumen.tulis(x.inObj + ', ' + x.inA + ', ' + x.inAProto + ', ' + x.inB + ', ' + x.inBProto)
; , 5
//Meningkatkan kepercayaan diri http://www.json.org/json.js
Object.prototype.toJSONString = function (filter) { return JSON.stringify(this, filter }; bukan?
$ argumen ;
fungsi getFun(){alert(arguments.length);} ;
getFun("xx") //keluaran 1
getFun("xx",23) //keluaran 2
$ pernyataan; di bawah instruksi khusus untuk
for(var i=0i<iCount;i++) atau for(attr in object);
Jika bosan, Anda dapat for( sProp in window ){alert(sProp+"Hey, please!");} //Lihat refleksi javascript
Berorientasi objek:
var bean = new Bean();
1.Fungsi metode pabrik
getAttr(){
alert(this.attr)
}
fungsi Kacang(tattr){
var bean = Objek baru;
bean.attr=
tattr
;
}
Ini pada dasarnya adalah versi peniru dari berorientasi objek
2. Bangun
function Bean(tattr){
this.attr = tattr;
bean.getAttr = function(){
alert(this.attr)
}
Di
atas 2, saat objek Bean dibuat, metode akan "menghasilkan fungsi berulang kali "!
3. Fungsi mode prototipe
Bean(){}
Bean.prototype.attr = "";
Bean.prototype.getAttr=function(){alert(this.attr);}
Selesaikan masalah "fungsi yang dihasilkan duplikat", tetapi masalah baru Bean.prototype.getArray = new Array();
Objek barunya bean1 dan bean2 akan berbagi ruang Array baru (yang tidak ingin kita lihat)
4. Model campuran :) Haha
fungsi Bean(){
this.attr= "";
this.getArray=Array baru;
}
Bean.prototype.getAttr=function(){alert(this.attr);}
5. Prototipe dinamis (perhatikan bahwa mulai sekarang, ini benar-benar berorientasi objek!!!)
function Bean(){
this.attr= "";
this.getArray=Array baru;
//pemuatan kelas saat memuat
if(typeof Bean._initialized == "tidak terdefinisi" ){
Bean.prototype.getAttr=function(){alert(this.attr);};
Bean._initialized= benar
;
}
/****************************************************** ***** ***************/
Warisan objek
1. Peniruan objek! ! (Dapat mendukung banyak warisan, peniru sangat kuat)
fungsi kelasA(sstr){
ini.warna = sstr;
ini.sayColor = function(){
alert(ini.warna);
};
}
fungsi kelasC(){}
fungsi classB(){
this.newMethod =ClassA;
this.newMethod()
;
this.newMethod =ClassC ;
this.newMethod();
hapus ini.newMethod ;
ini.arrt = "google";
}
2.call() apply() juga merupakan peniru,
function classA(sstr){
this.color = sstr;
this.sayColor = function(str){
alert(str+this.color);
};
}
fungsi classB(){
// this.newMethod =ClassA ;
// this.newMethod();
// hapus
this.newMethod
;
"merah"))
this.arrt = "baidu";
}
3. Rantai prototipe pewarisan ortodoks (tetapi tidak mendukung pewarisan berganda)
fungsi classA(){ini.oo="test";}
classA.prototype.color = "merah";
fungsi kelasB(){}
classB.prototype = kelasA baru;
classB.prototype.sayName = fungsi(){
alert( this.color );
}
varbb = kelasB baru;
bb.sayName(); // keluaran berwarna merah
alert(bb.oo); //hasil pengujian
alert(bb instanceof classA);
peringatan(bb instance dari kelasB); //keluaran benar
4. Jika Anda ingin lebih banyak warisan! ! Dan juga mendukung instanceof
Metode pencampuran:
fungsi kelasA(){}
fungsi kelasB(){}
fungsi kelasC(){
classA.panggilan(ini);
classC.panggilan(ini);
}
classC.prototype = new classA;//Perhatikan bahwa instanceof hanya dapat digunakan untuk A