javascript El aprendizaje de
javascript se puede dividir aproximadamente en 3 partes diferentes: Núcleo (ECMAscript), Objeto de texto (DOM), Objeto de navegador (BOM)
Núcleo (ECMAscript): palabras clave, declaraciones, operadores, objeto
Objeto de texto (DOM): DOM planificará el toda la página en un documento compuesto de niveles de nodos.
El análisis sigue el estándar dom html del W3C:
La referencia dom del W3C presta especial atención a la descripción del nodo DOM,
el objeto del navegador BOM, la ventana emergente del nuevo navegador y el tamaño de configuración del navegador.
Core (ECMAscript) Objeto integrado global;
Métodos: parseInt(), isNan(), encodeURI()...etc son todos métodos de este objeto.
Preste especial atención a eval(); un símbolo del lenguaje dinámico como: eval("alert('hi')"); pero este método es muy malo (aspecto de seguridad)
Descripción del objeto de texto (DOM):
<librería> <libro categoría="cocina"> <título lang="es">Italiano cotidiano</título> <autor>Giada De Laurentiis</autor> <año>2005</año> <precio>30,00</precio > </libro> </librería>
1. Conceptos básicos de ECMAscript
$ Tipo débil variable Designación de tipo húngaro: var iOuouValue=100;
$ puede finalizar la línea con o sin punto y coma; pero luego onsubmit="javascript:function();return false;"
$ palabra clave;
"typeof" var test=1; alert(typeof testX); //salida "indefinido"
"NaN" - no es un número -> isNan("blue"); //salida "true" ->isNan("123") ; //salida "falso"
$ objeto; var o = nuevo Objeto();
que
usualmente escribimos es un objeto.
Este var a = {name:"Liu Kaiyi"} es equivalente a var a = function(){this.name="Liu Kaiyi"};
nombre:"prueba",contraseña:"123456",addr:"bj"} //¿Qué es esto? ! json
Cuando var str = '{name:"test",pass:"123456",addr:"bj"}'
var objectBean = eval(str); // Aquí está el objeto objectBea.name usando
el concepto de dominio:
<tipo SCRIPT = texto/javascript>
var sMessage = 'Hola';
función establecer algo() {
sColor = 'rojo';
sMessage = '¡Hola mundo!';
}
establecer algo();
alerta(sMensaje); //¡Hola mundo!
alerta(sColor); //rojo
</SCRIPT> <SCRIPT tipo=texto/javascript>
var sMessage = 'Hola';
función establecer algo() {
var sColor = 'rojo';
sMessage = '¡Hola mundo!';
}
establecer algo();
alerta(sMensaje); //¡Hola mundo!
alerta(sColor); // nada
</SCRIPT>
<SCRIPT tipo=texto/javascript>
var sMessage = 'Hola';
función establecer algo() {
var sColor = 'rojo';
var sMessage = '¡Hola mundo!';
}
establecer algo();
alerta(sMensaje); //Hola
alerta(sColor); // nada
</SCRIPT>
Sentar las bases para la orientación a objetos: aplicación de objetos del tipo de prototipo de objeto. Referencia
// La herencia más simple.
Object.prototype.inObj = 1
función A();
{
esto.enA = 2;
}
A.prototype.inAProto = 3;
B.prototype = new A; // Conecta A a la cadena de prototipos de B
B.prototipo.constructor = B;
función B()
{
esto.enB = 4;
}
B.prototype.inBProto = 5;
x = nuevo B;
document.write(x.inObj + ', ' + x.inA + ', ' + x.inAProto + ', ' + x.inB + ', ' + x.inBProto)
; , 5
//Aumentar algo de confianza http://www.json.org/json.js
Object.prototype.toJSONString = function (filter) { return JSON.stringify(this, filter }); ¿no es así?
$ argumentos;
función getFun(){alerta(argumentos.longitud);};
getFun("xx") //salida 1
getFun("xx",23) //salida 2
$ declaración; bajo instrucciones especiales para
for(var i=0i<iCount;i++) o for(attr in object);
Si estás aburrido, puedes hacerlo for( sProp in window ){alert(sProp+"Hey, please!");} //Mira el reflejo de javascript
Orientado a objetos:
var bean = new Bean();
1.Función del método de fábrica
getAttr(){
alerta(this.attr)
}
función Bean(tattr){
var bean = nuevo Objeto;
bean.attr =
tattr.getAttr = getAttr
;
}
Es básicamente una versión imitadora de la orientada a objetos.
2. Construya
la función Bean(tattr){
this.attr = tattr;
bean.getAttr = function(){
alert(this.attr);
arriba
de
2, cuando se crea el objeto Bean, el método "generará repetidamente la función" "!
Función
del modo prototipo
Bean(){}Bean.prototype.attr = "";
Bean.prototype.getAttr=function(){alert(this.attr);}
Resuelva el problema de la "función generada duplicada", pero el nuevo problema Bean.prototype.getArray = new Array();
Sus nuevos objetos bean1 y bean2 compartirán el nuevo espacio Array (que no queremos ver)
4. Modelo mixto :) Jaja
function Bean(){
this.attr= "";
this.getArray=nueva matriz;
}
Bean.prototype.getAttr=function(){alert(this.attr);}
5. Prototipo dinámico (¡¡tenga en cuenta que a partir de ahora, está verdaderamente orientado a objetos!!!)
function Bean(){
this.attr= "";
this.getArray=new Array;
//carga de clases al cargar
if(typeof Bean._initialized == "indefinido" ){
Bean.prototype.getAttr=function(){alert(this.attr);};
Bean._initialized = verdadero
;
}
/*************************************************** ***** ****************/
Herencia de objetos
1. ¡Suplantación de objetos! ! (Puede admitir herencia múltiple, el imitador es muy poderoso)
función claseA(sstr){
this.color = sstr;
this.sayColor = function(){
alerta(this.color);
};
}
función claseC(){}
función claseB(){
this.newMethod =ClassA;
this.newMethod();
eliminar this.newMethod;
this.newMethod =ClassC;
this.newMethod();
eliminar this.newMethod;
this.arrt = "google";
}
2.call() apply() también es una imitación,
function classA(sstr){
this.color = sstr;
this.sayColor = function(str){
alert(str+this.color);
};
}
function classB(){
// this.newMethod =ClassA ;
// this.newMethod();
// eliminar this.newMethod ;
classA.call(this,"red");
//classA.apply(this,new Array( "rojo"))
this.arrt = "baidu";
}
3. Cadena de prototipos de herencia ortodoxa (pero no admite herencia múltiple)
función claseA(){this.oo="prueba";}
classA.prototype.color = "rojo";
función claseB(){}
classB.prototype = nueva claseA;
claseB.prototipo.sayName = función(){
alerta (este.color);
}
varbb = nueva claseB;
bb.sayName(); // salida roja
alert(bb.oo); //salida de prueba
alert(bb instanciade claseA); //salida verdadera);
alert(bb instancia de claseB); //salida verdadera;
4. ¡Si quieres más herencia! ! Y también admite instancia de
Método de mezcla:
función claseA(){}
función claseB(){}
función claseC(){
claseA.llamada(esto);
classC.call(esto);
}
classC.prototype = new classA;//Tenga en cuenta que instancia de solo se puede usar para A