English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Parte del objeto
Tipo Object
Object es una colección desordenada que puede contener cualquier tipo de objeto, y todos los otros objetos heredan de este objeto.
Hay dos formas de crear un tipo Object, una es con el operador new y la otra es con notación literal.
1. Creación con new para Object
var obj = new Object();//Nota, también se puede escribir directamente Object()
Nota, la escritura de new Object() es equivalente a la escritura literal obj = {}.
2. Creación con literals:
var obj = {
name : 'trigkit4',
age : 21
};//Es mejor incluir el punto y coma
Al declarar el objeto Object con literals, no se llama al constructor Object() (excepto en FF)
El objeto Object.prototype
Todos los constructores tienen una propiedad prototype, que apunta a un objeto de prototipo.
Object.prototype.print = function(){ console.log(this)};
var obj = new Object();
obj.print() // Object
La instancia obj hereda directamente las propiedades y métodos de Object.prototype
1. Los objetos solo son un tipo especial de datos. Los objetos tienen propiedades y métodos. JavaScript es un lenguaje orientado a objetos, pero JavaScript no utiliza clases. JavaScript se basa en [prototype][1], en lugar de basado en clases.
2. Propiedad: es una variable que pertenece a un objeto específico. Método: es una función que solo puede ser llamada por un objeto específico.
3. Los objetos.js son una colección de propiedades y métodos. Un método es una función, que es un miembro del objeto. Una propiedad es un valor o un grupo de valores (en forma de array o objeto), que es un miembro del objeto.
4. Los objetos.js se basan en constructoras funciones, y al crear un nuevo objeto con una constructora función, se dice que se ha instanciado un nuevo objeto. Las propiedades son variables internas de la constructora función.
Objetos instanciados con constructoras funciones:
cat = new Animal();
Javascript es un lenguaje basado en objetos (object-El lenguaje (based) es un lenguaje basado en objetos, donde todo lo que encuentres es prácticamente un objeto. Sin embargo, no es un lenguaje de programación orientado a objetos (OOP) verdadero, ya que su sintaxis no tiene class (clase).
<script type="text/javascript">
//El objeto es nombre/Conjunto de pares de valores
var browser = { //El objeto está delimitado por corchetes
name:"Firefox",
kernel:"Gecko"
};
</script>
//Se accede a las propiedades del objeto mediante el punto (.) o "[]"
browser.name //"Firefox"
browser["kernel"] //"Gecko"
El objeto (objeto) es una colección de propiedades, cada propiedad se compone de un 'nombre'/La estructura de 'valor-paquete', JavaScript también define un objeto especial: el array, que es una colección ordenada de valores numerados.
JavaScript también define un objeto especial: la función, que es un objeto que tiene código ejecutable asociado, y se ejecuta llamando a la función para obtener el resultado de la operación.
JavaScript no tiene clases, pero ha adoptado un nuevo nombre: 'objeto prototipo', por lo que 'clase == objeto prototipo', detalles en: Escritura de clase en JavaScript (I)
Diferencias y relaciones entre clase (objeto prototipo) y objeto (instancia)
1.clase (objeto prototipo) es abstracta, conceptual y representa una clase de cosas.
2.objeto es específico, real, y representa una cosa específica.
3.clase (objeto prototipo) es un patrón para las instancias de objeto, y las instancias de objeto son individuos de una clase.
Una creencia común es que los valores literales (literales) no son objetos. Esto se debe a un error del analizador de JavaScript, que intenta interpretar el operador de punto como parte de un valor literal de coma flotante.
Hay muchos métodos alternativos que pueden hacer que los valores literales de números se vean como objetos.
2..toString(); // El segundo punto se puede analizar normalmente
2 .toString(); // Atención al espacio antes del punto
(2).toString(); // 2Se calcula primero
Eliminar propiedad
El único método para eliminar una propiedad es usar el operador delete; establecer una propiedad como undefined o null no elimina realmente la propiedad, sino que solo elimina la asociación entre la propiedad y su valor.
Tres características principales de la programación orientada a objetos en JavaScript
Encapsulamiento: Sin considerar la implementación interna, solo se considera el uso de las funciones
Herencia: Heredar nuevas clases de objetos existentes
Polimorfismo: Se refiere a múltiples estados de una referencia en diferentes situaciones,
1.encapsulamiento
El encapsulamiento implica agrupar las propiedades y comportamientos comunes de los objetos en una clase para facilitar su uso. Por ejemplo, para la clase 'Persona', se puede encapsular de la siguiente manera:
Persona{
Edad (primera propiedad)
Altura (segunda propiedad)
Género (tercera propiedad)
Hacer (primer comportamiento)
Caminar (segundo comportamiento)
Hablar (uno de los tres comportamientos)
}
Ventajas del encapsulamiento:
El encapsulamiento protege la integridad de los datos internos;
El encapsulamiento facilita la refactoreación de los objetos;
debilita la耦合 entre módulos, mejorando la reutilización de objetos;
ayuda a evitar conflictos de nombres de espacio;
Vea el siguiente ejemplo:
<script type="text/javascript">
var boy = {}; //Crear un objeto vacío
boy.name = "小明";//asignando valores a las propiedades del objeto prototype
boy.age = 12;
var girl = {};
girl.name = "小红";
girl.age = 10;
</script>
Esto es la encapsulación más simple, encapsulando dos propiedades en un objeto. Sin embargo, esta forma de escritura tiene dos desventajas: primero, si se generan varias instancias, es muy complicado de escribir; segundo, entre la instancia y el prototype, no hay manera de ver cuál es la relación.
Patrón Constructor
Para resolver el problema de la generación de instancias a partir del objeto prototype, Javascript proporciona un patrón de constructor (Constructor).
Lo que se conoce como "constructor" es una función común, pero que utiliza la variable this internamente. Al usar el operador new con un constructor, se puede generar una instancia y la variable this se bindará al objeto de instancia.
Por ejemplo, el objeto prototype de boy y girl se puede escribir así:
<script type="text/javascript">
function Person(name,age){
this.name = name;
this.age = age;
}
</script>
Ahora podemos generar objetos de instancia.
<script type="text/javascript">
var boy = new Person("小明",12);
var girl = new Person("小红",10);
alert(boy.name); //Mingming
alert(boy.age); //12
</script>
En este momento, boy y girl tendrán automáticamente una propiedad constructor, que apunta a su constructor.
alert(boy.constructor == Person); //true
alert(girl.constructor); //Imprima el código completo del constructor, inténtelo usted mismo
El patrón Prototype de Javascript establece que cada constructor tiene una propiedad prototype, que apunta a otro objeto. Todas las propiedades y métodos de este objeto serán heredados por las instancias del constructor.
Esto significa que podemos definir directamente las propiedades y métodos inmutables en el objeto prototype.
<script type="text/javascript">
function Person(name,age){
this.name = name;
this.age = age;
}
Person.protype.type = "humano";
Person.protype.eat = function(){
alert("comer arroz");
}
</script>
luego, genere la instancia:
<script type="text/javascript">
var boy = new Person("小明","12");
var girl = new Person("小红","10");
alert(boy.type);//humanos
boy.eat();//comer
</script>
En este momento, las propiedades type y el método eat() de todas las instancias son la misma dirección de memoria, apuntando al objeto prototype, por lo que se mejora la eficiencia de ejecución.
alert(boy.eat == girl.eat); //true
La propiedad del prototipo es una propiedad integrada, que especifica el constructor de la clase que extiende el objeto.
El código siguiente agrega una nueva propiedad size al constructor de Animal, esta nueva propiedad es una propiedad del prototipo del objeto cat. A través de las propiedades del prototipo, todos los objetos que extienden el constructor de Animal pueden acceder a la propiedad size
cat = new Animal("felino","maullar", "caminar/run");
cat.prototype.size = "graso";
En este caso, todas las propiedades size de los objetos Animal son “graso”. El prototipo es una nueva instancia de Object, ya que sigue siendo un objeto, se pueden agregar nuevas propiedades a este objeto. Al igual que style es un objeto de JavaScript, también se pueden agregar propiedades después de style.
<script type="text/javascript">
/*Definir una clase Person*/
function Person(_name,_age,_salary){
//Las propiedades públicas de la clase Person, la forma de definir propiedades públicas es: ”this.nombreDePropiedad“
this.Name=_name;
//Las propiedades privadas de la clase Person, la forma de definir propiedades privadas es: ”var nombreDePropiedad“
var Age=_age;
var Salary=_salary;
//Definir métodos públicos (métodos privilegiados) de la clase Person, la forma de definir métodos públicos de la clase
es: ”this.functionName=function(){.....}“
this.Show=function(){
alert("Age="+Age+"\t"+"Salary="+Salary);//Se permite acceder a las propiedades privadas de una clase en métodos públicos
}
</script>
Cuando un objeto busca una propiedad, primero recorre sus propias propiedades, si no la encuentra, continúa buscando en el objeto referenciado por [[Prototype]], si aún no la encuentra, continúa buscando en el objeto referenciado por [[Prototype]].[[Prototype]], y así sucesivamente, hasta que [[Prototype]].….[[Prototype]] sea undefined (el [[Prototype]] de Object es undefined)
En términos simples, es a través de la [[Prototype]] del objeto que se guarda la referencia a otro objeto, y a través de esta referencia se realiza la búsqueda de atributos hacia arriba, lo que es la cadena de prototipos.
El objeto null
El propósito de asignar null a una variable en JavaScript es:
Asignar un puntero vacío, lo que facilita entender que la variable está destinada a almacenar objetos. También facilita la depuración
El objeto window global
Cualquier función o variable global en JavaScript es una propiedad de window.
El objeto self es completamente igual al objeto window, self se utiliza generalmente para confirmar que se está en la ventana actual.
Los objetos principales de window tienen lo siguiente:
El objeto document de JavaScript
El objeto frames de JavaScript
El objeto history de JavaScript
El objeto location de JavaScript
El objeto navigator de JavaScript
El objeto screen de JavaScript
Algunos métodos comunes
El método valueof (): devuelve el valor original del objeto especificado
El método split () divide una cadena en un array de cadenas y devuelve este array.
El método indexOf () puede devolver la posición de aparición de una cadena específica en una cadena por primera vez.
El método substring () se utiliza para extraer caracteres entre dos índices específicos de una cadena.
El método substr () se utiliza para extraer una cantidad específica de caracteres de una cadena desde la posición startPos.
El método join () se utiliza para poner todos los elementos de un array en una cadena.
arrayObject.join(Seperator)
El método reverse () se utiliza para invertir el orden de los elementos en un array.
El método slice () puede devolver elementos seleccionados de un array existente.
La literal de objeto
La literal de objeto se utiliza para crear un proceso que contiene una gran cantidad de propiedades, como se muestra a continuación:
<script type="text/javascript">
var company = {
name: "Microsoft",
ages : 39,
employees : 99000,
CEO: "Nadella"
};
</script>
Es necesario prestar atención aquí que las propiedades y los valores de las propiedades están separados por dos puntos (:); las propiedades múltiples están separadas por comas (,). La literal de objeto también puede definir métodos, simplemente escribiendo function en las propiedades del objeto. Esto es una función anónima, y para llamarla solo es necesario escribir su nombre de método ().
<script type="text/javascript">
var dog = {
nombre:"husky",
edad:2,
run:function() {
return "123";
}
}
alert(dog.run());//Si se ingresa dog.run, se mostrará el código de la parte function que sigue
</script>
Empaquetadores de tipos de valores básicos
js tiene cinco tipos básicos de valores: number, string, Boolean, null y undefined. Además de null y undefined, los otros tres tienen lo que se conoce como objetos básicos de paquete. Se pueden crear objetos de paquete utilizando los constructores integrados Number(), String() y Boolean().
var num = new Number(10);
console.log(typeof num);//object
Método Object()
Object() // Devuelve un objeto vacío
Object(undefined) // Devuelve un objeto vacío
Object(null) // Devuelve un objeto vacío
Object(1) // Es equivalente a new Number(1)
Object('foo') // Es equivalente a new String('foo')
Object(true) // Es equivalente a new Boolean(true)
Object([]) // Devuelve el array original
Object({ }) // Devuelve el objeto original
Object(function() { }) // Devuelve la función original
Parte del array
1.Objeto Array
Objeto Array: ofrece soporte para crear matrices de cualquier tipo de datos.
arrayObj = new Array()
arrayObj = new Array([tamaño])
arrayObj = new Array([elemento0[, elemento1[, ..., [elementoN]]]])
Definición: var arr = [2,3,45,6]; var arr = new Array(2,4,5,7)
Ambos no tienen diferencia alguna en la definición, [] tiene un rendimiento alto porque el código es corto.
Usando matrices y literales de objetos: var aTest = []; la elección de la literal de matriz es una buena opción al crear matrices; de manera similar, las literales de objeto también pueden usarse para ahorrar espacio. Las siguientes dos líneas son iguales, pero la que utiliza la literal de objeto es más corta:
var oTest = new Object; //Evitar el uso de
var oTest = { }; //La mejor opción, o var 0Test = [ ];
Recorrer Para lograr el mejor rendimiento en la recorrida de arrays, se recomienda usar el bucle for clásico.
var list = [1, 2, 3, 4, 5, ...... 100000000];
for(var i = 0, l = list.length; i < l; i++) {
console.log(list[i]);
}
En el código anterior, hay un tratamiento que es el de almacenar la longitud del array en l = list.length.
Constructor Array
Debido a que el constructor Array tiene un comportamiento algo ambiguo en cuanto al manejo de los parámetros, siempre se recomienda usar la sintaxis literal de los arrays. - [] - para crear arrays.
Por lo tanto, el siguiente código puede ser muy confuso:
new Array(3, 4, 5); // Resultado: [3, 4, 5]
new Array(3) // Resultado: [], la longitud de este array es 3
Debería evitarse el uso del constructor de array para crear nuevos arrays. Se recomienda usar la sintaxis literal de los arrays. Son más cortos y concisos, lo que aumenta la legibilidad del código.
propiedades de Array de arrays
Array de arrays3propiedades: la propiedad length, la propiedad prototype, la propiedad constructor
1.length propiedad
La propiedad length representa la longitud del array, es decir, el número de elementos que contiene. Ya que los índices de los arrays siempre comienzan en 0, los límites de un array son: 0 y length-1Diferente de la mayoría de los otros lenguajes, la propiedad length de los arrays de JavaScript es mutable, lo cual debe tenerse en cuenta especialmente.
2.prototype propiedad
Devuelve una referencia al prototipo del objeto. La propiedad prototype es común a todos los objetos.
Para explicar el uso de la propiedad prototype del objeto Array, presentamos el siguiente ejemplo.
Agregar un método al objeto Array que devuelva el valor máximo de los elementos del array. Para lograr esto, declare una función, agréguela a Array.prototype y úsela.
function array_max()
{
var i,max=this[0];
for(i=1;i<this.length;i++)
{
if(max<this[i])
max=this[i];
}
return max;
}
Array.prototype.max=array_max;
var x=new Array(1,2,3,4,5,6);
var y=x.max();
Después de ejecutar este código, y guarda el valor máximo del array x, o decimos6.
3.propiedad constructor
representa la función para crear objetos. Nota: La propiedad constructor es miembro de todos los objetos que tienen prototype. Esto incluye todos los objetos nativos de JScript excepto Global y Math. La propiedad constructor guarda una referencia a la función que construye la instancia específica del objeto.
Por ejemplo:
x = new String("Hi");
if(x.constructor==String) //procesar (condición verdadera).
//o
function MyFunc{
//Cuerpo de la función.
}
y=new MyFunc;
if(y.constructor==MyFunc)//procesar (condición verdadera).
Para los arrays:
y = new Array();
Método de objeto Array
Método sort()
Sintaxis
arrayObject.sort(sortby)
sortby opcional. Define el orden de clasificación. Debe ser una función.
var arr = [11,2,28,4,5,1});
console.log(arr.sort());//devolver [1, 11, 2, 28, 4, 5]
¿Por qué aquí?11、28¿Por qué no se ordenan según el orden? Esto se debe a que el 'sort' sin parámetros ordena según el orden de la codificación de caracteres.
Entonces, si quieres ordenar los elementos del array de menor a mayor, ve al siguiente código:
var arr = [11,2,28,4,5,1});
console.log(arr.sort(function(a,b){
devolver a-b;//devolver [1, 2, 4, 5, 11, 28]
});
Si desea ordenar según otros criterios, debe proporcionar una función de comparación, que compara dos valores y luego devuelve un número que indica la relación de orden entre estos valores. La función de comparación debe tener dos parámetros 'a' y 'b', y su valor de retorno debe ser el siguiente:
Si 'a' es menor que 'b', en el array ordenado 'a' debe aparecer antes de 'b', se devuelve un valor menor que 0.
Si 'a' es igual a 'b', se devuelve 0.
Si 'a' es mayor que 'b', se devuelve un valor mayor que 0.
Esto es todo el contenido de este artículo, espero que haya sido útil para su aprendizaje y que apoyen más al tutorial de gritos.