Leer este artículo requiere experiencia de programación en otros idiomas.
Los tipos simples en JavaScript incluyen:
1. Números
2. Cadena
3. Booleano (verdadero y falso)
4.NULL
5.Nofinado
Otros tipos son objetos (no debemos confundirnos por el valor de retorno del operador de typing), por ejemplo:
1. Función
2. Array
3. Expresiones regulares
4. Objeto (los objetos son objetos naturales)
Base de objetos
En JavaScript, los objetos son colecciones de propiedades (los objetos son matrices asociativas), cada propiedad incluye:
1. El nombre del atributo debe ser una cadena
2. El valor del atributo puede ser otro valor que no sea indefinido
Crear un objeto a través del objeto literal:
La copia del código es la siguiente:
// Crear un objeto vacío a través del objeto Literal {}
var vacía_object = {};
El nombre del atributo y el valor del atributo del objeto:
La copia del código es la siguiente:
var starte = {
// "primer nombre" es el nombre del atributo, y "Jerome" es el valor del atributo
"primer nombre": "Jerome",
// "último nombre" es el nombre del atributo, y "Howard" es el valor del atributo
"último nombre": "Howard"
};
Si el nombre del atributo es un identificador legal, se pueden omitir las comillas:
La copia del código es la siguiente:
VAR Flight = {
Aerolínea: "Oceanic",
Número: 815,
departamento: {
IATA: "Syd",
Hora: "2004-09-22 14:55",
Ciudad: "Sydney"
},
llegada: {
IATA: "LAX",
Hora: "2004-09-23 10:42",
Ciudad: "Los Ángeles"
}
};
Echemos un vistazo al ejemplo de acceso a la propiedad:
La copia del código es la siguiente:
var propietario = {nombre: "name5566"};
propietario.name; // "Name5566"
propietario ["nombre"]; // "Name5566"
propietario.job; // indefinido
propietario.job = "Coder"; // o propietario ["Job"] = "Coder";
Si el nombre del atributo no es un identificador legal, debe envolverse en citas. El valor de la propiedad que no existe no está definido. Los objetos se pasan por referencia en lugar de por valor:
La copia del código es la siguiente:
var x = {};
Var propietario = x;
propietario.name = "name5566";
X.Name; // x.name === "name5566"
Aquí X y el propietario se refieren al mismo objeto.
Los atributos de un objeto se pueden eliminar utilizando el operador Eliminar:
La copia del código es la siguiente:
eliminar obj.x; // Eliminar el atributo x del objero obj
Prototipo del objeto
Cada objeto está vinculado a un objeto prototipo, y el objeto puede heredar los atributos del objeto prototipo. Creamos un objeto a través del objeto literal, cuyo objeto prototipo es un objeto.prototype Object (el objeto.prototype Object en sí no tiene objeto prototipo). Cuando creamos un objeto, podemos establecer el objeto prototipo del objeto (y luego discutir el método de configuración específico). Al intentar obtener (no modificar) un atributo de un objeto, si el objeto no existe, JavaScript intenta obtener el atributo del objeto prototipo de este objeto, si no hay tal atributo en el objeto prototipo, luego busque el objeto prototipo de este objeto prototipo, y así sucesivamente hasta el objeto. En comparación con la obtención de atributos, cuando modificamos el atributo de un objeto, no afectará el objeto prototipo.
Conceptos básicos funcionales
Las funciones también son objetos en JavaScript, que están vinculados a la función. Prototipo Prototype Object (function.prototype enlaces a object.prototype). La función tiene una propiedad llamada Prototype, y su valor es un objeto. Este objeto tiene un constructor de propiedades, y el valor del constructor es esta función:
La copia del código es la siguiente:
var f = function () {}
typeof f.prototype; // 'objeto'
typeof f.prototype.constructor; // 'función'
F === F.Prototype.Constructor; // verdadero
Las funciones son objetos, puede usar funciones como usar objetos, es decir, las funciones se pueden guardar en variables y matrices, y se pueden pasar como parámetros a las funciones, y las funciones se pueden definir dentro de las funciones. Como nota al margen, la función tiene dos propiedades ocultas:
1. El contexto de la función
2. Código de funciones
La función se crea de la siguiente manera:
La copia del código es la siguiente:
var f = function add (a, b) {
devolver a + b;
}
console.log (f); // Salida [Función: Agregar]
El nombre de la función después de la función de palabra clave es opcional. Formulamos el nombre de la función principalmente para varios fines:
1. Para una llamada recursiva
2. Los depuradores, herramientas de desarrollo, etc. se utilizan para identificar funciones
Muchas veces no necesitamos nombres de funciones, y las funciones sin nombres de funciones se denominan funciones anónimas. Una lista de parámetros está envuelta entre paréntesis. JavaScript no requiere la coincidencia de parámetros reales y parámetros formales, por ejemplo:
La copia del código es la siguiente:
var add = function (a, b) {
devolver a + b;
}
agregar (1, 2, 3); // El parámetro real y el parámetro formal no coinciden
Si hay demasiados parámetros reales, se ignorará los parámetros reales excesivos. Si hay muy pocos parámetros reales, entonces el valor de los parámetros formales no asignados no está definido. La función debe tener un valor de retorno. Si el valor de retorno no se especifica a través de la declaración de retorno, el valor de retorno de la función está indefinido.
Una función y las variables externas a las que accede forman un cierre. Este es el encanto clave de JavaScript.
Llamadas de funciones
Cuando se llama a cada función, se reciben dos parámetros adicionales:
1.Estre
2. argumentos
El valor de esto está relacionado con el patrón de llamadas específico. Hay cuatro patrones de llamadas en JavaScript:
1. Modo de llamadas de método. Si la propiedad de un objeto es una función, se denomina método. Si se llama a un método a través de OM (args), este es un objeto O (que se puede ver que esto y o están unidos solo cuando se llaman), por ejemplo:
La copia del código es la siguiente:
var obj = {
Valor: 0,
incremento: función (v) {
this.Value += (typeof v === 'número'? V: 1);
}
};
obj.increment (); // this === obj
2. Modo de llamada de función. Si una función no es la propiedad de un objeto, se llamará como una función, y esto está vinculado al objeto global, por ejemplo:
La copia del código es la siguiente:
mensaje = 'Hola mundo';
var p = function () {
console.log (this.message);
}
pag(); // Salida 'Hola mundo'
Este comportamiento a veces es confuso, vea un ejemplo:
La copia del código es la siguiente:
obj = {
Valor: 0,
increment: function () {
var helper = function () {
// Agregar 1 al valor en el objeto global
this.Value += 1;
}
// ayudante se llama como una función
// Por lo tanto, este es un objeto global
ayudante();
}
};
obj.increment (); // obj.value === 0
Los resultados que esperamos deberían ser:
La copia del código es la siguiente:
obj = {
Valor: 0,
increment: function () {
var que = esto;
var helper = function () {
que.value += 1;
}
ayudante();
}
};
obj.increment (); // obj.value === 1
3. Modo de llamada de constructor. Las funciones que tienen la intención de usar el nuevo prefijo se llaman constructores, por ejemplo:
La copia del código es la siguiente:
// La prueba se llama constructor
var test = function (string) {
this.message = string;
}
var mytest = nuevo test ("hola mundo");
Se puede llamar a una función con NUEVO (tales funciones generalmente comienzan con la capitalización). Después de agregar nuevo, se creará un objeto vinculado a la propiedad prototipo de esta función, y este objeto en el constructor es este objeto.
4. Aplicar el modo de llamada. El método de aplicación de la función se usa para llamar a la función, que tiene dos parámetros, el primero es este y el segundo es una matriz de parámetros, por ejemplo:
La copia del código es la siguiente:
var add = function (a, b) {
devolver a + b;
}
var retir = add.apply (nulo, [3, 4]); // ret === 7
Al llamar a la función, podemos acceder a una matriz de clases llamadas argumentos (matriz de JavaScript no real) que contiene todos los argumentos, por lo que podemos implementar parámetros de longitud variable:
La copia del código es la siguiente:
var add = function () {
var sum = 0;
para (var i = 0; i <arguments.length; ++ i) {
sum += argumentos [i];
}
suma de retorno;
}
Agregar (1, 2, 3, 4);
anormal
Ahora hablemos sobre el mecanismo de manejo de excepciones de JavaScript. Utilizamos la declaración de lanzamiento para lanzar excepciones y la instrucción Try-Cache para atrapar y manejar excepciones:
La copia del código es la siguiente:
var add = function (a, b) {
if (typeof a! == 'número' || typeof b! == 'número') {
// lanza una excepción
tirar {
Nombre: 'typeError',
Mensaje: 'Agregar números de necesidades'
};
}
devolver a + b;
}
// atrapar y manejar excepciones
intentar {
agregar ("siete");
// e es el objeto de excepción lanzado
} catch (e) {
console.log (e.name + ':' + e.message);
}
Agregar propiedades a los tipos de JavaScript
Los constructores existen en la mayoría de los tipos en JavaScript:
1. El constructor del objeto es objeto
2. El constructor de la matriz es una matriz
3. El constructor de la función es la función
4. El constructor de la cadena es una cadena
5. El constructor del número es el número
6. El constructor del booleano es booleano
7. El constructor de la expresión regular es regexp
Podemos agregar propiedades (a menudo agregar métodos) al prototipo del constructor para que esta propiedad esté disponible para variables relacionadas:
La copia del código es la siguiente:
Número.prototype.integer = function () {
Devolver matemáticas [this <0? 'techo': 'piso'] (esto);
}
(1.1) .integer (); // 1
Alcance
JavaScript necesita crear ámbitos a través de funciones:
La copia del código es la siguiente:
función() {
// ...
} ();
Una función anónima se crea y se ejecuta aquí. Alcance para ocultar variables que no desea estar expuesto:
La copia del código es la siguiente:
var obj = function () {
// ocultar valor, no se puede acceder externamente
valor var = 0;
devolver {
// Solo este método puede modificar el valor
increment: function () {
valor += 1;
},
// Solo este método puede leer el valor
getValue: function () {
valor de retorno;
}
};
} ();
obj.increment ();
obj.getValue () === 1;
heredar
Hay muchas formas de implementar la herencia en JavaScript.
Al crear un objeto, podemos configurar el objeto prototipo asociado con el objeto, y lo hacemos:
La copia del código es la siguiente:
// Crear un objeto O con su objeto prototipo {x: 1, y: 2}
var o = object.create ({x: 1, y: 2});
El método Object.Create se define en ECMAScript 5. Si usa ECMAScript 3, puede implementar un método Crear usted mismo:
La copia del código es la siguiente:
// Si el método object.create no está definido
if (typeof object.create! == 'function') {
// Crear método objeto.create
Object.create = function (o) {
var f = function () {};
F.Prototype = O;
// Crear un nuevo objeto, el objeto prototipo de este objeto es O
devolver nuevo f ();
};
}
A través del método Object.Create, realizamos una herencia basada en prototipos: un nuevo objeto hereda directamente las propiedades de un objeto antiguo (en relación con la herencia basada en clases, no hay necesidad de la existencia de la clase aquí, y el objeto hereda directamente el objeto). ejemplo:
La copia del código es la siguiente:
var myMammal = {
Nombre: 'Herb the Mammal',
get_name: function () {
devolver esto.name;
},
dice: function () {
Devuelve esto.saying || '';
}
};
// heredar mymammal
var mycat = object.create (mymammal);
mycat.name = 'Henrietta';
mycat.saying = 'meow';
mycat.purr = function (n) {
var i, s = '';
para (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
regreso s;
};
mycat.get_name = function () {
devuelve this.says () + '' + this.name + '' + this.says ();
};
El código anterior es simple, pero no puede proteger a los miembros privados. Podemos usar el modo de módulo. En el modo de módulo, una función genera un cierto tipo de objeto y utiliza el alcance de la función para proteger a los miembros privados del acceso externo:
La copia del código es la siguiente:
// función de mamíferos, utilizada para construir objetos de mamíferos
var mammal = function (spec) {
// Ese es el objeto construido
var that = {};
// se puede acceder al método público get_name externamente
que.get_name = function () {
// Spec.Name no se puede acceder directamente desde afuera
return spec.name;
};
// El método público dice que se puede acceder externamente
que.says = function () {
// especificación. Demandando no hay acceso directo a
devolución de especificaciones. Saying || '';
};
devolver eso;
};
// crear un objeto de mamíferos
var myMammal = Mammal ({nombre: 'Herb'});
// Función CAT, utilizada para construir el objeto CAT
var cat = function (spec) {
Spec.saying = spec.saying || 'maullido';
// El gato hereda del mamífero, así que primero construya el objeto de mamíferos
var that = mammal (spec);
// Agregar método público rorrera
que.purr = function (n) {
var i, s = '';
para (i = 0; i <n; i += 1) {
if (s) {
s += '-';
}
s += 'r';
}
regreso s;
};
// modificar el método público get_name
que.get_name = function () {
devolver eso.says () + '' ' + espec.name +
'' + que.says ();
devolver eso;
};
};
// Crear objeto de gato
var mycat = cat ({nombre: 'Henrietta'});
En el modo de módulo, la herencia se logra llamando al constructor. Además, también podemos acceder a los métodos de la clase principal en la subclase:
La copia del código es la siguiente:
Objeto.prototype.superior = function (name) {
var that = this, método = que [nombre];
Función de retorno () {
return Method.apply (que, argumentos);
};
};
var coolcat = function (spec) {
// Obtener el método get_name de la subclase
var that = Cat (Spec), super_get_name = that.superior ('get_name');
que.get_name = function (n) {
return 'me gusta' + super_get_name () + 'baby';
};
devolver eso;
};