Resumen de puntos de conocimiento básico de JavaScript (recomendado)

Las variables definidas fuera de la función deben ser variables globales; Variables definidas dentro de la función, si se declara VAR, entonces la variable es una variable local. Si no se declara var, entonces la variable es una variable global.

Javascript

 var global = "global"; test (); function test () {var local = "local"; document.writeln (global); document.writeLn (local);} document.writeLn (global); document.writeln (local);

2. Dos tipos de galletas

i) Las cookies persistentes se almacenarán en el disco duro del cliente.

ii) Responder Cookie: no se almacenará en el disco duro del cliente, sino que se colocará en la memoria del proceso del navegador. Cuando el navegador esté cerrado, la galleta de respuesta será destruida.

3. En JavaScript, una función es un objeto

4. En JavaScript, no hay concepto de sobrecarga de método (función)

5. Objeto de función

Hay un objeto de función en JavaScript, y todas las funciones personalizadas son de tipo de objeto de función. Todos los parámetros aceptados por el objeto de función son de tipo de cadena, el último parámetro es el cuerpo de la función que se ejecutará, y el parámetro anterior son los parámetros que la función realmente necesita aceptar.

6. Argumentos de objetos implícitos

En JavaScript, cada función tiene argumentos de objetos implícitos, que representan los parámetros realmente pasados ​​a la función. argumentos.length representa el número de parámetros realmente aprobados.

7. Nombre de la función.

Cada objeto de función tiene un atributo de longitud, lo que indica el número de parámetros que la función espera aceptar. Es diferente de los argumentos de las funciones. argumentos.length representa el número de parámetros realmente aceptados por la función.

8. Hay cinco tipos de datos primitivos en JavaScript

Indefinido, nulo, booleano, número y cadena. (Nota: en JavaScript, no hay tipo de datos de char)

Solo hay un valor para el tipo de datos indefinidos: Undefined;

Solo hay un valor para el tipo de datos nulo: nulo;

Hay dos valores del tipo de datos booleanos: Verdadero y Falso;

9. TypyOf Operator

TypeOf es un operador unario seguido del nombre de la variable. Se utiliza para obtener el tipo de datos de la variable. Sus valores de retorno son: indefinido, booleano, número, cadena y objeto.

10. En JavaScript, si la función no declara el valor de retorno, devolverá la relación entre 11, anulado y indefinido

Undefinado en realidad se deriva de NULL. Por ejemplo:

La relación entre nula y indefinida

Javascript

 alerta (indefinido == null); // El navegador devuelve verdadero

11. Conversión de tipo forzado

Hay 3 moldes en JavaScript: boolean (valor), número (valor), cadena (valor).

12. Objeto Objeto

En JavaScript, todos los objetos se heredan de objetos de objetos.

Objeto objeto

Javascript

 var objeto = nuevo objeto (); for (var v en objeto) {alerta (v);}

En el código anterior, el navegador no imprime nada, lo que no significa que el objeto del objeto no tenga ningún atributo. El siguiente código prueba si las propiedades en el objeto se pueden enumerar. Si se devuelve el falso, significa que las propiedades en el objeto no se pueden enumerar.

Las propiedades en los objetos de objetos no pueden enumerarse

Javascript

 alert (object.propertyiseNumerable ("prototipo"));

Si el navegador aparece un cuadro de diálogo falso, significa que las propiedades en el objeto no se pueden enumerar.

A continuación, veamos si las propiedades en el objeto de la ventana pueden enumerarse.

Las propiedades en los objetos de la ventana son enumerables

Javascript

 for (var v en ventana) {console.log (v);}

En Chrome, veremos muchas propiedades impresas en la consola de depuración del navegador, lo que indica que las propiedades en el objeto de la ventana se pueden enumerar.

13. En JavaScript, puede agregar dinámicamente los atributos de un objeto o eliminar dinámicamente los atributos de un objeto.

Agregar dinámicamente/eliminar las propiedades de los objetos

Javascript

 var objeto = new Object (); alert (Object.Username); // Undefined Object.Username = "Zhangsan"; Alert (Object.Username); // Zhangsan Object ["Password"] = "123"; Alert (Object.Password); // 123 Delete Object.Username; // Usnégate.username = "Zhangsan";

14. La forma más común de definir objetos en JavaScript

La forma más común de definir objetos

Javascript

 var objeto = {nombre de usuario: "zhangsan", contraseña: 12345}; alert (objeto.username); alert (objeto.password);

15. Array

Definición de matriz

Javascript

 // Método 1 var array = new Array (); array.push (1); array.push (2); array.push (3); alert (array.length); // Método 2 (recomendado) VAR Array = [1,25,4]; array.sort (); alerta (matriz);

Llame al método sort () de la matriz, y el navegador imprime 1, 25, 4, que no es el resultado que esperamos.

Para el método de clasificación de la matriz JavaScript, primero convertirá el contenido para ordenarse en una cadena (llamado método toString ()) y lo ordenará en el orden de las cadenas.

El siguiente método puede obtener los resultados que esperamos (ordenados por el tamaño de la matriz):

Clasificación de matriz

Javascript

 función compare (num1, num2) {var temp1 = parseInt (num1); var temp2 = parseInt (num2); if (temp1 <temp2) {return -1; } else if (temp1 == temp2) {return 0; } else {return 1; }} var array = [1,25,3]; array.sort (comparar); alerta (matriz);

Luego lo implementamos en funciones anónimas:

Clasificación de funciones anónimas

Javascript

 varía var = [1,25,3]; array.sort (function (num1, num2) {var temp1 = parseInt (num1); var temp2 = parseInt (num2); if (temp1 <temp2) {return -1;} else if (temp1 == temp2) {return 0;} else {return 1;}}); alerta (matriz);

16. Cinco formas de definir objetos en JavaScript (no hay un concepto de clases en JavaScript, solo objetos) i) Expanda sus propiedades y métodos basados ​​en objetos existentes

Expandir sus propiedades y métodos basados ​​en objetos existentes

Javascript

 var Object = new Object (); // Agregar nombre de atributo Object.name = "Zhangsan"; // Agregar método SayName Object.sayName = function (name) {this.name = name; alerta (this.name);}; object.sayname ("kyle"); // llame al método SayName, el atributo de nombre se modifica a Kyle y el navegador imprimirá Kyle

La forma más simple no es conveniente de usar y es adecuada para requerir temporalmente un objeto.

ii) crear objetos en fábrica

Método de fábrica sin parámetros:

Javascript

 // función de método de fábrica createObject () {var object = new Object (); // Cree un objeto Object.name = "Zhangsan"; // Agregue un nombre de atributo Object.password = "123"; // Agregar un atributo de contraseña Object.get = function () {// Agregar una alerta de método Get (this.name+","+this.password); }; objeto return; // return este objeto} var objeto1 = createObject (); // calendario un método de fábrica createObject para crear objeto1var object2 = createObject (); // Método de fábrica createObject para crear objeto 2Object1.get (); // Llame al objeto Get Method Get2.get (); // Celular El método de Object Get Object2.get (// Celular Celular El Método de Object Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Get Method

Método de fábrica con parámetros:

Javascript

 función createObject (name, contraseña) {var objeto = new Object (); object.name = name; objeto.password = contraseña; objeto.get = function () {alert (this.name+","+this.password); }; objeto de retorno;} var objeto1 = createObject ("zhangsan", "123"); var object2 = createObject ("lisi", "456"); object1.get (); object2.get ();

Desventajas de los dos métodos de fábrica anteriores sin parámetros y con parámetros:

Cada vez que se crea un objeto, se crea un método GET en la memoria, que es un desperdicio de memoria y afecta el rendimiento. Y nuestra expectativa es crear dos objetos diferentes cuyas propiedades son diferentes, pero los métodos son compartidos. Entonces, a continuación necesitamos mejorar el método CrearObject Factory.

Enfoque de fábrica mejorado:

Javascript

 function get () {alert (this.name+","+this.password);} function createObject (name, contraseña) {var objeto = nuevo objeto (); object.name = name; objeto.password = contraseña; object.get = get; objeto de retorno;} var objeto1 = createObject ("zhangsan", "123"); var object2 = createObject ("lisi", "456"); object1.get (); object2.get ();

Defina el método GET fuera de la función CreateObject, de modo que el método GET se comparta para cada objeto creado. Haga que un objeto de función se comparta por múltiples objetos, en lugar de que cada objeto tenga un objeto de función.

iii) Método del constructor para crear un objeto

Constructor sin parámetros:

Javascript

 function Person () {// Antes de ejecutar la primera línea de código, el motor JS generará un objeto para nosotros this.name = "zhangsan"; this.password = "123"; this.getInfo = function () {alert (this.name+","+this.password); }; // Hay una declaración de retorno implícita aquí para devolver el objeto generado previamente (que también es un lugar diferente del método de fábrica)} var p1 = new Person (); p1.getInfo ();

Constructor con parámetros

Javascript

 Funcion Person (nombre, contraseña) {this.name = name; this.password = contraseña; this.getInfo = function () {alert (this.name+","+this.password); };} var p1 = nueva persona ("zhangsan", "123"); var p2 = nueva persona ("lisi", "456"); p1.getInfo (); p2.getInfo ();

iv) Creación de objetos prototipo (prototipo)

El prototipo es una propiedad en el objeto objeto

prototipo

Javascript

 function persona () {} persona.prototype.name = "zhangsan"; persona.prototype.password = "123"; persona.prototype.getInfo = function () {alert (this.name+","+this.password);}; var p1 = new Person (); var p2 = new Person (); p1.name = "kyle"; // Después de generar el objeto, cambie el atributo p1.getInfo (); p2.getinfo ();

Hay dos problemas con simplemente usar prototipos: primero, no puede asignar valores iniciales a los atributos en el constructor, y solo puede cambiar los valores de atributo después de que se genera el objeto.

prototipo

Javascript

 función persona () {} persona.prototype.name = new array (); persona.prototype.password = "123"; persona.prototype.getInfo = function () {alert (this.name+","+this.password);}; var p1 = new Person (); var p2 = new Person (); p1.name.push ("zhangsan"); p1.name.push ("lisi"); p1.password = "456"; p1.getInfo (); p2.getinfo ()

El navegador imprimirá: Zhangsan, Lisi, 456 y Zhangsan, Lisi, 123.

Si se crea un objeto utilizando el método prototipo, todos los objetos generados compartirán las propiedades en el prototipo, y si un objeto cambia la propiedad, también se reflejará en otros objetos. Por lo tanto, no es posible usar simplemente el método prototipo, y también debe combinarse con otros métodos. Continuaremos presentándolo a continuación.

Use Prototype + Constructor para definir objetos

Javascript

 función persona () {this.name = new Array (); this.password = "123";} persona.prototype.getInfo = function () {alert (this.name+","+this.password);}; var p1 = new Person (); var p2 = new Person (); p1.name.push ("zhangsan"); p2.name.push ("lisi"); p1.getinfo (); p2.getinfo ();

Use el método Prototype + Constructor para definir objetos. Las propiedades entre objetos no interfieren entre sí, y cada objeto comparte el mismo método. Esta es una mejor manera.

v) método de prototipo dinámico

Javascript

 función persona () {this.name = "zhangsan"; this.password = "123"; if (typeof persona.flag == "indefinido") {alerta ("invocado"); Persona.prototype.getInfo = function () {alert (this.name + "," + this.password); } Persona.flag = true; }} var p1 = new Person (); var p2 = new Person (); p1.getInfo (); p2.getInfo ();

En el método de prototipo dinámico, en el constructor, todos los objetos comparten un método a través de cantidades de indicador, y cada objeto tiene sus propios atributos. Cuando el código anterior crea un objeto por primera vez, primero usa una declaración de juicio para ver si se ha definido el atributo de indicador. Si no está definido, agregue el método GetInfo a través del prototipo y luego configure el indicador en verdadero. Luego, cuando el objeto se crea la segunda vez, la declaración IF se considera falsa y se ejecuta. Esto logra el resultado deseado, las propiedades del objeto creado no interfieren entre sí y se comparten los métodos de objeto.

17. Herencia de objetos en JavaScript (5 maneras)

El primer método: suplantación de objetos

Imitar la herencia de los objetos

Javascript

 // Función de clase Presidente Parent (nombre de usuario) {this.Username = username; this.sayhello = function () {alert (this.username); };} // Subclase Function Child (nombre de usuario, contraseña) {// Las siguientes tres líneas de código son las más críticas este.method = parent; this.method (nombre de usuario); Eliminar este.method; this.password = contraseña; this.sayworld = function () {alert (this.password); };} var p = nuevo padre ("zhangsan"); var c = nuevo niño ("lisi", "123"); P.Sayhello (); C.Sayhello (); C.SayWorld ()

El segundo método: llamar ()

El segundo método de implementación de herencia, el método de llamada, el método de llamada es un método definido en el objeto de función, por lo que cada función que definimos tiene este método. El primer parámetro del método de llamada se pasará a esto en la función, comenzando desde el segundo parámetro, y asignado a los parámetros en la función uno por uno.

Llame heredar la clase principal

Javascript

 función test (str) {alert (this.name+","+str);} var object = new Object (); object.name = "zhangsan"; // test.call es equivalente a llamar a la función de prueba test.call (objeto, "html5war"); // Asignar objeto a este

A continuación, utilizamos el método de llamada para implementar la herencia de los objetos

Javascript

 // Función de clase Presidente Parent (nombre de usuario) {this.Username = username; this.sayhello = function () {alert (this.username); };} // Subclase Function Child (nombre de usuario, contraseña) {parent.call (this, username); this.password = contraseña; this.sayworld = function () {alert (this.password); };} var p = nuevo padre ("zhangsan"); var c = nuevo niño ("lisi", "123"); p.sayhello (); c.sayhello (); c.sayworld ();

El tercer método: aplicar ()

Aplicar hereda la clase principal

Javascript

 // Función de clase Presidente Parent (nombre de usuario) {this.Username = username; this.sayhello = function () {alert (this.username); };} // Subclase Function Child (nombre de usuario, contraseña) {parent.apply (this, new Array (nombre de usuario)); this.password = contraseña; this.sayworld = function () {alert (this.password); };} var p = nuevo padre ("zhangsan"); var c = nuevo niño ("lisi", "123"); p.sayhello (); c.sayhello (); c.sayworld ();

El método de aplicación es muy similar al método de llamada. El método de aplicación también es un método definido en un objeto de función, por lo que cada función que definimos tiene este método.

Hay una diferencia entre el método de aplicación y el método de llamada: parent.apply (this, nueva matriz (nombre de usuario)); El segundo parámetro aprobado es una matriz, mientras que el método de llamada pasó algunos parámetros de datos discretos. No se puede decir que estos dos métodos sean buenos y malos, depende del escenario de uso específico.

El cuarto método: el método de cadena prototipo (no se puede pasar parámetros al constructor)

Herencia de la cadena prototipo

Javascript

 function parent () {} parent.prototype.hello = "hello"; parent.prototype.sayhello = function () {alert (this.hello);}; function child () {} child.prototype = new Parent (); Child.prototype.world = "mundo"; Child.prototype.sayworld = function () {alert (this.world);}; var c = nuevo niño (); C.Sayhello (); C.SayWorld ();

Desventajas de simplemente usar el método de cadena prototipo: no hay forma de pasar los parámetros, solo puede esperar hasta que se cree el objeto antes de modificarlo. Resolvamos este problema en combinación con otras formas.

El quinto método: método mixto (recomendado)

Utilice métodos híbridos para implementar la herencia de objetos

Javascript

 function parent (hello) {this.hello = hello;} parent.prototype.sayhello = function () {alert (this.hello);} function child (hola, mundo) {parent.call (this, hello); this.world = world;} child.prototype = new Parent (); child.prototype.sayworld = function () {alert (this.world);} var c = new Child ("Hola", "Mundo"); C.Sayhello (); C.SayWorld ();

El resumen anterior de los puntos de conocimiento básicos de JavaScript (recomendado) es todo el contenido que comparto con usted. Espero que pueda darle una referencia y espero que pueda apoyar más a Wulin.com.