Leia os comentários com cuidado para obter detalhes. Vamos falar menos bobagens aqui e apenas fazer o upload do código.
A cópia do código é a seguinte:
<! Doctype html>
<html>
<head>
<meta charset = "utf-8">
<title> Documento de teste </title>
<script type = "text/javascript">
// Em essência, as propriedades e métodos são os mesmos, e os métodos são funções cujas propriedades são do tipo referência.
// Um objeto tem 4 propriedades:
// 1, os atributos definidos pelo construtor através dessa palavra -chave
// 2, os atributos definidos pelo construtor através da palavra -chave VAR
// 3, propriedades adicionadas ao objeto de protótipo do construtor
// 4, os atributos adicionados dinamicamente pelo objeto
// Propriedades públicas da instância: 1, 2, 3, 4 podem ser acessadas através dos atributos definidos por essa palavra -chave
// Atributos privados da instância: 2 atributos definidos pela palavra -chave var. Acessível 2
// Compartilhe propriedades de uma instância: 3 atributos adicionados através do protótipo apontado pela instância. Acessível 1,3,4
// Propriedades estáticas da instância: 4 propriedades adicionadas dinamicamente pelo objeto. Acessível 1,3,4
//Resumir:
// Atributos da instância: 1, público
// 2, privado
// 4, estático
// Atributos do protótipo: 3, compartilhe
// Isso é definido como um atributo privilegiado. Tudo acessível
// var é definido como uma propriedade privada.
// Os atributos adicionados dinamicamente são atributos públicos. Propriedades privadas não são acessíveis
// O atributo do protótipo apontado pelo objeto de instância é o atributo do protótipo. Atributos privados não são acessíveis, com menor prioridade do que atributos públicos
// Os atributos da instância consistem principalmente em atributos públicos e atributos de privilégio. Ambos podem ser acessados por propriedades externas e protótipos. A principal diferença é se os atributos privados são acessíveis
// A precedência do atributo de protótipo é menor que a do atributo de instância. Pode ser acessado externamente e atributos de instância (exceto atributos privados)
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Propriedades públicas: atributos expostos ao ambiente externo. É também um atributo do objeto.
// Atributos privados: Os atributos internos são frequentemente inacessíveis. Só é significativo considerá -los no nível do construtor.
// Propriedades estáticas: Propriedades adicionadas dinamicamente. É também um atributo do objeto.
// Propriedades compartilhadas: atributos compartilhados por todas as instâncias geradas pelos construtores.
função user () {
// Propriedades públicas: atributos que cada novo objeto de instância do usuário possui.
// é um atributo de instância e todos os atributos de instância não compartilham memória.
// acessível externamente.
this.name = 'byronvis';
// Método privilegiado: um método que foi usado para cada novo objeto de instância do usuário.
// é um método de instância, todos os métodos de instância não compartilham memória.
// acessível externamente.
// As propriedades públicas são acessíveis.
// Propriedades privadas são acessíveis.
this.sayName = function () {
alerta (this.name);
alerta (this.school);
alerta (idade); // a declaração variável será automaticamente avançada.
alerta (this.sex);
};
// Atributos privados: não acessível externamente.
// Só faz sentido para os construtores, não para novos objetos de instância do usuário.
var idade = 22;
// Método privado: não é acessível externamente.
// Só faz sentido para os construtores, não para novos objetos de instância do usuário.
function sayage () {
alerta (idade);
}
sayage ();
}
// Atributos compartilhados: memória compartilhada.
User.prototype.school = 'zky';
// Métodos comuns: os atributos públicos podem ser acessados.
// Memória compartilhada.
User.prototype.sayschool = function () {
alerta (this.school);
alerta (this.name);
alerta (this.sex);
alerta (idade);
};
var obj = new User ();
// Propriedades estáticas: as propriedades da instância são adicionadas dinamicamente.
obj.sex = 'homem';
// Método estático: o método da instância é adicionado dinamicamente.
obj.saysex = function () {
alerta (this.sex);
alerta (this.name);
alerta (this.school);
alerta (idade);
};
// ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//// prova que os atributos definidos por essa palavra -chave são essencialmente os mesmos que os adicionados dinamicamente e podem ser considerados como atributos públicos dos objetos de instância.
// Verificação: Esta palavra -chave define propriedades para acessar propriedades adicionadas dinamicamente
// obj.sayname (); // true
// Verificação: atributos adicionados dinamicamente acessar os atributos definidos por esta palavra -chave
// obj.saysex (); // true
// Verificação: Propriedades públicas Acesse propriedades privadas
// obj.sayname (); // true
obj.saysex (); // false
// Verificação: atributos compartilhados Acesse atributos privados
// obj.saySchool (); // false
</script>
</head>
<Body>
Documentos de teste
</body>
</html>
Você entendeu os atributos de exemplo e atributos de protótipo? Este artigo é muito detalhado e recomendado a todos. Espero que seja útil para meus amigos.