Explicación detallada de las propiedades y métodos de operación basados en objetos JS

1. Descripción general

En el idioma Java, podemos definir nuestras propias clases y crear objetos basados en estas clases para su uso. En JavaScript, también podemos definir nuestras propias clases, como definir clase de usuario, clase de hashtable, etc.

Actualmente en JavaScript, hay algunas clases estándar, como fecha, matriz, regexp, cadena, matemáticas, números, etc., que nos proporcionan muchas comodidades a la programación. Pero para programas de clientes complejos, estos están lejos de ser suficientes.

A diferencia de Java, Java2 nos proporciona muchas clases estándar, que básicamente satisfacen nuestras necesidades de programación. Sin embargo, JavaScript proporciona pocas clases estándar, y muchas necesidades de programación deben ser implementadas por nosotros mismos. Por ejemplo, JavaScript no tiene una tabla de hashtable, que es inconveniente en el manejo de valores clave.

Por lo tanto, personalmente creo que una vista completa de objeto JavaScript debería ser la siguiente:

2. Conceptos básicos

1. Personaliza el objeto.

Según el mecanismo de extensión de objetos de JS, los usuarios pueden personalizar los objetos JS, que es similar al lenguaje Java.

Correspondientes a objetos personalizados son objetos estándar JS, como fecha, matriz, matemáticas, etc.

2. Prototipo

En JS, esta es una forma de crear propiedades y métodos de objetos, y a través del prototipo, puede agregar nuevas propiedades y métodos a los objetos.

Con el prototipo podemos agregar nuevas propiedades y métodos a los objetos estándar JS, por ejemplo, para los objetos de cadena, podemos agregarle un nuevo método TRIM ().

A diferencia de los lenguajes de programación estrictos como Java, podemos agregar dinámicamente nuevas propiedades a los objetos JS durante el tiempo de ejecución.

Tres, reglas de gramática

1. Método de creación de objetos

1) Método inicializador de objetos

Format: ObjectName = {Property1: Value1, Property2: Value2, ..., Propertyn: Valuen}

La propiedad es la propiedad de un objeto

El valor es el valor del objeto, y el valor puede ser uno de una cadena, un número o un objeto

Por ejemplo: var user = {nombre: "user1", edad: 18};

Var user = {nombre: "User1", Job: {Salario: 3000, Título: Programador}

Métodos que también se pueden inicializar de esta manera, por ejemplo:

 Var user = {name: "user1", edad: 18, getName: function () {return this.name; }}

Lo siguiente se explicará con el enfoque del método del constructor, incluida la definición de atributos y métodos, y también se explicará con referencia al método del constructor.

2) Método del constructor

Escriba un constructor y cree un objeto a través del nuevo método. El constructor podría haber transportado parámetros del constructor

Por ejemplo:

 Función user (nombre, edad) {this.name = name; this.age = edad; this.canfly = false; } var use = new User ();

2. Defina las propiedades del objeto

1) En JS, se pueden definir tres tipos de propiedades para objetos: propiedades privadas, propiedades de instancia y propiedades de clase. Similar a Java, las propiedades privadas solo se pueden usar dentro de los objetos. Las propiedades de instancia deben referenciarse a través de la instancia del objeto, y las propiedades de clase se pueden hacer referencia directamente a través del nombre de la clase.

2) Definición de atributos privados

Los atributos privados solo se pueden definir y usar dentro del constructor.

Formato de sintaxis: var propertyname = value;

Por ejemplo:

 Función user (edad) {this.age = edad; var ischild = edad <12; this.islittlechild = ischild; } var user = new User (15); alerta (user.islittlechild); // La manera correcta alerta (user.ischild); // El error: el objeto no admite esta propiedad o método

3) También hay dos formas de definir los atributos de instancia:

Método prototipo, formato de sintaxis: functionName.prototype.propertyname = valor

Este método, formato de sintaxis: this.propertyname = valor, preste atención a la ubicación utilizada en los siguientes ejemplos

El valor anterior puede ser la creación de caracteres, el número y el objeto.

Por ejemplo:

 function user () {} user.prototype.name = "user1"; User.prototype.age = 18; VAR user = new User (); alerta (user.age); . "... ... ... .la. "" ..... ... ..... ..... ... .....lo.

3) Definición de atributo de clase

Formato de sintaxis: functionName.propertyname = valor

Por ejemplo:

 función user () {} user.max_age = 200; User.min_age = 0; alerta (user.max_age);

Consulte las propiedades de clase de los objetos estándar JS:

Número.max_value // valor numérico máximo math.pi // pi

4) Además de los métodos más formales anteriores, también hay una forma muy especial de definir atributos, formato de sintaxis: obj [índice] = valor

ejemplo:

 Función user (nombre) {this.name = name; this.age = 18; esto [1] = "OK"; esto [200] = "año"; } var user = new User ("User1"); alerta (usuario [1]);

En el ejemplo anterior, es importante tener en cuenta que el atributo de edad no se obtiene a través de este [1], ni se puede obtener esto [0] a través de esto [0]. Es decir, el índice definido por el índice debe referenciarse utilizando el modo de índice, y no definido por el modo de índice, y debe referenciarse de manera normal.

3. Definir el método de objeto

1) Existen tres tipos de métodos que se pueden definir para objetos en JS: métodos privados, métodos de instancia y métodos de clase, similares a Java:

Los métodos privados solo se pueden usar dentro de los objetos

Los métodos de instancia deben ser instanciados antes de que puedan usarse

Los métodos de clase se pueden usar directamente a través de nombres de clases

Nota: La definición del método no se puede llevar a cabo a través del método de índice mencionado anteriormente.

2) Definir métodos privados

Los métodos privados deben definirse dentro del cuerpo del constructor y solo se pueden usar dentro del cuerpo del constructor.

Formato de sintaxis: Función MethodName (Arg1, ..., Argn) {}

Por ejemplo:

 Función user (nombre) {this.name = name; function getNamelength (namestr) {return namestr.length; } this.namelength = getNeMelength (this.name); }

3) Definir un método de instancia, actualmente se pueden usar dos métodos:

Método prototipo, utilizado fuera del constructor, formato de sintaxis:

functionName.prototype.methodName = método;

o

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

Este método, utilizado dentro del constructor, formato de sintaxis:

this.methodName = Method;

o

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

En la descripción de sintaxis anterior, el método es un método que ya existe afuera. El método del objeto que se definirá mediante MethodName significa que se asigna un método externo a un método del objeto directamente.

Definir el método de objeto en forma de función (arg1, ..., argn) {} es algo que los desarrolladores deberían dominar.

Algunos ejemplos de definir un método de instancia: Ejemplo 1

 Función user (nombre) {this.name = name; this.getName = getUsername; this.setName = setUsername; } función getUsername () {return this.name; } Function setUsername (name) {this.name = name; }

Algunos ejemplos de definir un método de instancia: Ejemplo 2

 Función user (nombre) {this.name = name; this.getName = function () {return this.name; }; this.setName = function (newName) {this.name = newname; }; }

Algunos ejemplos de definir un método de instancia: Ejemplo 3

 Función user (nombre) {this.name = name; } User.prototype.getName = getUsername; User.prototype.setName = setUsername (); function getUsername () {return this.name; } Function setUsername (name) {this.name = name; }

Algunos ejemplos de definir un método de instancia: Ejemplo 4

 Función user (nombre) {this.name = name; } User.prototype.getName = function () {return this.name; }; User.prototype.setName = function (newName) {this.name = newname; };

4) Definir métodos de clase

Los métodos de clase deben definirse fuera del constructor y pueden referenciarse directamente por el nombre del constructor.

Formato de sintaxis:

functionName.methodName = Method;

o

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

ejemplo:

 Función user (nombre) {this.name = name; } User.getmaxage = getUsermaxage; función getUsermaxage () {return 200; }

o

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

alerta (user.getmaxage ());

4. Referencias de propiedades y métodos

1) Desde la perspectiva de la visibilidad:

Las propiedades y métodos privados solo se pueden hacer referencia dentro del objeto.

Las propiedades y métodos de instancia se pueden usar en cualquier lugar, pero deben ser referenciados por objetos.

Las propiedades y métodos de clase se pueden usar en cualquier lugar, pero no se puede hacer referencia por una instancia de un objeto (esto es diferente de Java, donde se puede acceder a los miembros estáticos mediante una instancia).

2) Desde el nivel de objeto:

Similar a las referencias a los frijoles Java, se pueden hacer referencias profundas.

Varias formas:

Propiedad simple: obj.propertyname

Propiedades del objeto: obj.innerobj.propertyname

Propiedad del índice: OBJ.Propertyname [índice]

Para referencias más profundas, similar a las anteriores.

3) Del método de definición:

Los atributos definidos a través del método de índice deben referenciarse a través del método de índice.

Los atributos definidos por los métodos no índice deben referenciarse de manera normal.

Tenga en cuenta también: el método del objeto no se puede definir a través del método de índice.

5. Adición y eliminación dinámica de propiedades y métodos

1) Para un objeto que ha sido instanciado, podemos agregar y eliminar dinámicamente sus propiedades y métodos. La sintaxis es la siguiente (suponiendo que la instancia del objeto sea obj):

Aumentar dinámicamente las propiedades del objeto

obj.newpropertyname = valor;

Aumentar dinámicamente el método de objeto

obj.newmethodname = método o = function (arg1, ..., argn) {}

Eliminar dinámicamente las propiedades del objeto

eliminar obj.propertyname

Eliminar el método de objeto de eliminación dinámica

Eliminar obj.metodname

2) Ejemplo:

 Función user (nombre) {this.name = name; this.age = 18; } var user = new User ("User1"); user.sister = "Susan"; alerta (user.sister); // ejecutar a través de eliminar user.sister; alert (user.sister); // Informe Error: el objeto no admite esta propiedad user.getMotherName = function () {return "mary";} alert (user.getMotherName ()); // ejecutar a través de la eliminación de user.getMotherName; Alert (user.getMotherName ()); // Informe Error: el objeto no admite este método

Cuatro, resumen

1. El mecanismo de objetos personalizados es uno de los mecanismos más atractivos para JS. ¡Esto es simplemente excelente para los programadores de C ++ y Java!

2. Hay dos formas de crear un objeto: inicializador de objeto y constructor.

3. Propiedades y métodos del objeto, las restricciones con la visibilidad y los atributos y métodos con una visibilidad diferente se definen de manera diferente.

El artículo anterior se basa en objetos JS, atributos de operación y métodos, que son todos los contenidos que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.