Explicação detalhada das propriedades e métodos de operação com base em objetos JS

1. Visão geral

No idioma Java, podemos definir nossas próprias classes e criar objetos com base nessas classes para uso. No JavaScript, também podemos definir nossas próprias classes, como definir classe de usuário, classe de hashtable etc.

Atualmente no JavaScript, existem algumas classes padrão, como data, matriz, regexp, string, matemática, número, etc., que nos fornecem muitas conveniências para a programação. Mas para programas complexos de clientes, eles estão longe de ser suficientes.

Ao contrário do Java, o Java2 nos fornece muitas classes padrão, o que basicamente atende às nossas necessidades de programação. No entanto, o JavaScript fornece poucas classes padrão, e muitas necessidades de programação precisam ser implementadas por nós mesmos. Por exemplo, o JavaScript não possui uma tabela de hashtable, que é inconveniente no manuseio de valores -chave.

Portanto, eu pessoalmente acho que uma visão completa do objeto JavaScript deve ser a seguinte:

2. Conceitos básicos

1. Personalize o objeto.

De acordo com o mecanismo de extensão de objetos do JS, os usuários podem personalizar objetos JS, que são semelhantes ao idioma Java.

Correspondentes a objetos personalizados são objetos padrão JS, como data, matriz, matemática, etc.

2. Prototipo

No JS, essa é uma maneira de criar propriedades e métodos de objetos e, por protótipo, você pode adicionar novas propriedades e métodos aos objetos.

Com o protótipo, podemos adicionar novas propriedades e métodos aos objetos padrão JS, por exemplo, para objetos de string, podemos adicionar um novo método Trim () a ele.

Ao contrário de linguagens de programação rigorosas, como o Java, podemos adicionar dinamicamente novas propriedades aos objetos JS durante o tempo de execução.

Três, regras gramaticais

1. Método de criação de objetos

1) Método Inicializador do Objeto

Formato: objectName = {propriedade1: value1, propriedade2: value2,…, propriedaden: valuen}

A propriedade é a propriedade de um objeto

valor é o valor do objeto, e o valor pode ser de uma string, um número ou um objeto

Por exemplo: var user = {name: "user1", idade: 18};

var user = {name: "user1", trabalho: {salário: 3000, título: programador}

Métodos que também podem ser inicializados dessa maneira, por exemplo:

 var user = {nome: "user1", idade: 18, getName: function () {return this.name; }}

O seguinte será explicado com o foco do método do construtor, incluindo a definição de atributos e métodos, e também será explicado com referência ao método do construtor.

2) Método do construtor

Escreva um construtor e crie um objeto através do novo método. O construtor poderia ter transportado parâmetros do construtor

Por exemplo:

 função user (nome, idade) {this.name = name; this.age = idade; this.Canfly = false; } var use = new User ();

2. Defina propriedades do objeto

1) No JS, três tipos de propriedades podem ser definidos para objetos: propriedades privadas, propriedades de instância e propriedades de classe. Semelhante ao Java, as propriedades privadas só podem ser usadas dentro de objetos. As propriedades da instância devem ser referenciadas através da instância do objeto, e as propriedades da classe podem ser referenciadas diretamente através do nome da classe.

2) Definição de atributo privado

Atributos privados só podem ser definidos e usados no construtor.

Formato de sintaxe: var PropertyName = value;

Por exemplo:

 função user (idade) {this.age = idade; var ischild = idade <12; this.islittLechild = isChild; } var usuário = novo usuário (15); alert (user.islittlechild); // a maneira correta alerta (user.ischild); // o erro: o objeto não suporta essa propriedade ou método

3) Há também duas maneiras de definir atributos de instância:

Método do protótipo, Sintaxe formato: functionName.prototype.propertyName = Valor

Este método, formato de sintaxe: this.PropertyName = Value, preste atenção ao local usado nos exemplos a seguir

O valor acima pode ser a criação, número e objeto de caracteres.

Por exemplo:

 function user () {} user.prototype.name = "user1"; User.prototype.age = 18; var user = new user (); alerta (user.age); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

3) Definição de atributo de classe

Formato de sintaxe: functionName.PropertyName = Value

Por exemplo:

 função user () {} user.max_age = 200; User.min_age = 0; alert (user.max_age);

Consulte as propriedades da classe dos objetos padrão JS:

Número.max_value // Valor numérico máximo Math.pi // pi Pi

4) Além dos métodos mais formais acima, também há uma maneira muito especial de definir atributos, formato de sintaxe: obj [index] = valor

exemplo:

 função user (nome) {this.name = name; this.age = 18; este [1] = "ok"; este [200] = "ano"; } var user = novo usuário ("user1"); alerta (usuário [1]);

No exemplo acima, é importante observar que o atributo de idade não é obtido com isso [1], nem isso [0] pode ser obtido com isso [0]. Ou seja, o índice definido pelo índice deve ser referenciado usando o modo de índice e não definido pelo modo de índice e deve ser referenciado de maneira normal.

3. Defina o método do objeto

1) Existem três tipos de métodos que podem ser definidos para objetos em JS: métodos privados, métodos de instância e métodos de classe, semelhante ao Java:

Métodos privados só podem ser usados dentro de objetos

Os métodos de instância devem ser instanciados antes que possam ser usados

Os métodos de classe podem ser usados diretamente através de nomes de classe

Nota: A definição do método não pode ser realizada através do método do índice mencionado acima.

2) Definir métodos privados

Os métodos privados devem ser definidos no corpo do construtor e só podem ser usados no corpo do construtor.

Formato de sintaxe: function MethodName (arg1,…, argn) {}

Por exemplo:

 função user (nome) {this.name = name; função getnameLength (nameST) {return namest.length; } this.nameLength = getNameLength (this.name); }

3) Defina um método de instância, atualmente dois métodos podem ser usados:

Método de protótipo, usado fora do construtor, formato de sintaxe:

functionName.prototype.methodName = método;

ou

functionName.prototype.methodName = function (arg1,…, argn) {};

Este método, usado dentro do construtor, formato de sintaxe:

this.methodName = método;

ou

this.methodName = function (arg1,…, argn) {};

Na descrição da sintaxe acima, o método é um método que já existe fora. O método do objeto a ser definido pelo MethodName significa que um método externo é atribuído diretamente a um método do objeto.

Definir o método do objeto na forma de função (arg1,…, argn) {} é algo que os desenvolvedores devem dominar.

Alguns exemplos de definição de um método de instância: Exemplo 1

 função user (nome) {this.name = name; this.getName = getUserName; this.setName = setUserName; } function getUserName () {return this.name; } Função setUserName (nome) {this.name = name; }

Alguns exemplos de definição de um método de instância: Exemplo 2

 função user (nome) {this.name = name; this.getName = function () {return this.name; }; this.setName = function (newName) {this.name = newName; }; }

Alguns exemplos de definição de um método de instância: Exemplo 3

 função user (nome) {this.name = name; } User.prototype.getName = getUserName; User.prototype.setName = setUserName (); function getUserName () {return this.name; } Função setUserName (nome) {this.name = name; }

Alguns exemplos de definição de um método de instância: Exemplo 4

 função user (nome) {this.name = name; } User.prototype.getName = function () {return this.name; }; User.prototype.setName = function (newName) {this.name = newName; };

4) Definir métodos de classe

Os métodos de classe precisam ser definidos fora do construtor e podem ser referenciados diretamente pelo nome do construtor.

Formato de sintaxe:

functionName.MethodName = Method;

ou

functionName.methodName = function (arg1,…, argn) {};

exemplo:

 função user (nome) {this.name = name; } User.getMaxage = getUserMaxage; function getUserMaxage () {return 200; }

ou

User.getMaxage = function () {return 200;};

alert (user.getMaxage ());

4. Referências de propriedades e métodos

1) Da perspectiva da visibilidade:

Propriedades e métodos privados só podem ser referenciados dentro do objeto.

Propriedades e métodos da instância podem ser usados em qualquer lugar, mas devem ser referenciados por objetos.

As propriedades e métodos da classe podem ser usados em qualquer lugar, mas não podem ser referenciados por uma instância de um objeto (isso é diferente de Java, onde membros estáticos podem ser acessados por uma instância).

2) Do nível do objeto:

Semelhante às referências ao feijão Java, referências profundas podem ser feitas.

Várias maneiras:

Propriedade simples: obj.propertyname

Propriedades do objeto: obj.innerobj.propertyname

Propriedade do índice: obj.propertyname [índice]

Para referências mais profundas, semelhantes às acima.

3) A partir do método de definição:

Os atributos definidos através do método do índice devem ser referenciados pelo método do índice.

Os atributos definidos pelos métodos não índices devem ser referenciados de maneira normal.

Observe também: o método do objeto não pode ser definido através do método do índice.

5. Adição dinâmica e exclusão de propriedades e métodos

1) Para um objeto que foi instanciado, podemos adicionar e excluir dinamicamente suas propriedades e métodos. A sintaxe é a seguinte (assumindo que a instância do objeto seja obj):

Aumentar dinamicamente as propriedades do objeto

obj.newPropertyName = value;

Aumente dinamicamente o método do objeto

obj.newMethodName = método ou = function (arg1,…, argn) {}

Excluir dinamicamente as propriedades do objeto

Exclua obj.propertyName

Exclua dinamicamente o método do objeto

exclua obj.methodname

2) Exemplo:

 função user (nome) {this.name = name; this.age = 18; } var user = novo usuário ("user1"); user.sister = "Susan"; alert (user.sister); // Execute o user.sister delete; alert (user.sister); // Erro de relatório: o objeto não suporta este propriedade user.getMotherName = function () {return "Mary";} alert (user.getMotherName ()); // Execute o userte.getMotherName; alert (user.getMotherName ()); // Erro de relatório: o objeto não suporta este método

Quatro, resumo

1. O mecanismo de objeto personalizado é um dos mecanismos mais atraentes para JS. Isso é simplesmente ótimo para programadores C ++ e Java!

2. Existem duas maneiras de criar um objeto: Inicializador de objeto e construtor.

3. Propriedades e métodos do objeto, restrições com visibilidade e atributos e métodos com visibilidade diferente são definidos de maneira diferente.

O artigo acima é baseado em objetos JS, atributos de operação e métodos, que são todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.