Lea los comentarios cuidadosamente para más detalles. Hablemos menos tonterías aquí y solo subamos el código.
La copia del código es la siguiente:
<! Doctype html>
<html>
<Evista>
<meta charset = "utf-8">
<title> Documento de prueba </title>
<script type = "text/javaScript">
// En esencia, las propiedades y los métodos son los mismos, y los métodos son funciones cuyas propiedades son de tipo de referencia.
// Un objeto tiene 4 propiedades:
// 1, los atributos definidos por el constructor a través de esta palabra clave
// 2, los atributos definidos por el constructor a través de la palabra clave var
// 3, propiedades agregadas al objeto prototipo del constructor
// 4, los atributos agregados dinámicamente por el objeto
// se pueden acceder a las propiedades públicas de la instancia: 1, 2, 3, 4 a través de los atributos definidos por esta palabra clave
// atributos privados de la instancia: 2 atributos definidos por la palabra clave var. Accesible 2
// Compartir propiedades de una instancia: 3 atributos agregados a través del prototipo señalado por la instancia. Accesible 1,3,4
// Propiedades estáticas de la instancia: 4 Propiedades agregadas dinámicamente por el objeto. Accesible 1,3,4
//Resumir:
// atributos de instancia: 1, público
// 2, privado
// 4, estático
// atributos prototipo: 3, compartir
// Esto se define como un atributo privilegiado. Todo accesible
// var se define como una propiedad privada.
// Los atributos agregados dinámicamente son atributos públicos. Las propiedades privadas no son accesibles
// El atributo prototipo señalado por el objeto de instancia es el atributo prototipo. Los atributos privados no son accesibles, con menor prioridad que los atributos públicos
// Los atributos de instancia consisten principalmente en atributos públicos y atributos de privilegios. Se puede acceder a ambos mediante propiedades externas y prototipo. La principal diferencia es si se pueden acceder a los atributos privados
// La precedencia del atributo prototipo es menor que la del atributo de instancia. Se puede acceder a los atributos externamente y de instancia (excepto los atributos privados)
// -----------------------------------------------------------------------------------------------
// Propiedades públicas: atributos expuestos al entorno externo. También es un atributo del objeto.
// Atributos privados: los atributos dentro de los objetos a menudo son inaccesibles. Solo es significativo considerarlos a nivel de constructor.
// Propiedades estáticas: propiedades agregadas dinámicamente. También es un atributo del objeto.
// Propiedades compartidas: atributos compartidos por todas las instancias generadas por los constructores.
función user () {
// Propiedades públicas: atributos que tiene cada nuevo objeto de instancia de usuario.
// es un atributo de instancia, y todos los atributos de instancia no comparten memoria.
// Accesible externamente.
this.name = 'byronvis';
// Método privilegiado: un método que se ha utilizado para cada nuevo objeto de instancia de usuario.
// es un método de instancia, todos los métodos de instancia no comparten memoria.
// Accesible externamente.
// Las propiedades públicas son accesibles.
// Se pueden acceder a las propiedades privadas.
this.sayName = function () {
alerta (this.name);
alerta (this.school);
alerta (edad); // La declaración variable se avanzará automáticamente.
alerta (this.sex);
};
// Atributos privados: no accesible externamente.
// Solo tiene sentido para los constructores, no para los nuevos objetos de instancia de usuario.
var edad = 22;
// Método privado: no accesible externamente.
// Solo tiene sentido para los constructores, no para los nuevos objetos de instancia de usuario.
function saysage () {
alerta (edad);
}
sayage ();
}
// Atributos compartidos: memoria compartida.
User.prototype.school = 'zky';
// Métodos comunes: se puede acceder a los atributos públicos.
// Memoria compartida.
User.prototype.sayschool = function () {
alerta (this.school);
alerta (this.name);
alerta (this.sex);
alerta (edad);
};
var obj = new User ();
// Propiedades estáticas: son las propiedades de instancia agregadas dinámicamente.
obj.sex = 'hombre';
// Método estático: es el método de instancia agregado dinámicamente.
obj.saysex = function () {
alerta (this.sex);
alerta (this.name);
alerta (this.school);
alerta (edad);
};
// -----------------------------------------------------------------------------------------------
/// Demuestre que los atributos definidos por esta palabra clave son esencialmente los mismos que se agregan dinámicamente, y pueden considerarse como atributos públicos de objetos de instancia.
// Verificación: esta palabra clave define propiedades para acceder a propiedades agregadas dinámicamente
// obj.sayname (); // verdadero
// Verificación: los atributos agregados dinámicamente acceden a los atributos definidos por esta palabra clave
// obj.saysex (); // verdadero
// Verificación: las propiedades públicas acceden a las propiedades privadas
// obj.sayname (); // verdadero
obj.saysex (); // falso
// Verificación: Atributos compartidos acceden a los atributos privados
// obj.sayschool (); // falso
</script>
</ablo>
<Body>
Documentos de prueba
</body>
</html>
¿Has entendido los atributos de ejemplo y los atributos de prototipo? Este artículo es muy detallado y recomendado para todos. Espero que sea útil para mis amigos.