Código escrito a mano de parte1
El código escrito a mano en el sitio es un tipo muy común de preguntas de la entrevista en las entrevistas hoy en día, examinando las estructuras básicas de datos y las capacidades de algoritmos.
1. Implementación de la deduplicación de matriz
Deduplicación de matriz básica
Array.prototype.unique = function () {var result = []; this.ForEach (function (v) {if (result.indexof (v) <0) {result.push (v);}}); Resultado de retorno;}• Use la tabla hash para deduplicar, esta es una forma de intercambiar espacio por el tiempo
Array.prototype.unique = function () {var result = [], hash = {}; this.ForEach (function (v) {if (! Hash [v]) {hash [v] = true; resultado.push (v);}}); Resultado de retorno;}Hay un error en el método anterior. Para las matrices [1,2, '1', '2', 3], el resultado de la deduplicación es [1,2,3]. La razón es que el objeto lanzará el índice de atributo cuando el objeto se indexa. Arr ['1'] y arr [1] obtienen los valores de arr [1], por lo que se deben realizar algunos cambios:
Array.prototype.unique = function () {var result = [], hash = {}; this.ForEach (function (v) {var type = typeof (v); // get element type hash [v] || (hash [v] = new array ()); if (hash [v] .indexof (type) <0) {hash [v] .push (type); // type de almacenamiento resultado.push (v);}); Resultado de retorno;}• ordene primero y luego elimine la repetición
Array.prototype.unique = function () {var result = [this [0]]; this.sort (); this.ForEach (function (v) {v! = resultado [resultado.length - 1] && result.push (v); // Compare solo con el último elemento de resultado});}2 Implementación de clasificación rápida
Método 1 (no use el método de matriz JS tanto como sea posible):
función Quicksort (arr) {Qsort (arr, 0, arr.length - 1);} function Qsort (arr, bajo, alto) {if (bajo <how) {var PartKey = particion (arr, bajo, alto); QSORT (arr, bajo, partkey - 1); Qsort (arr, partkey + 1, alto); }} función de función (arr, baja, alta) {var key = arr [low]; // Use el primer elemento como base de clasificación mientras (bajo <alto) {while (bajo <high && arr [high]> = arr [key]) alto--; arr [bajo] = arr [alto]; while (low <high && arr [low] <= arr [key]) Low ++; arr [alto] = arr [bajo]; } arr [Low] = Key; regresar bajo;}Método 2 (usando el método de matriz JS):
función Quicksort (arr) {if (arr.length <= 1) return arr; Var index = Math.floor (arr.length/2); var key = arr.splice (índice, 1) [0]; var izquierda = [], right = []; arr.forEach (function (v) {v <= key? Left.push (v): derecho.push (v);}); return Quicksort (izquierda) .concat ([clave], Quicksort (derecha));}Además, debe tenerse en cuenta que la complejidad de tiempo promedio de la clasificación rápida O (NLOGN), el peor de los casos es un caso ordenado, la complejidad del tiempo se cuadra y la clasificación rápida es inestable.
Parte2 JavaScript relacionado
1 tipos de datos básicos de JavaScript
Los tipos de datos de JavaScript incluyen tipos primitivos y tipos de referencia, y hay cinco tipos primitivos:
Número (valor) string (string) boolean (booleano) nulo (vacío) indefinido (indefinido)
Hay un tipo de referencia:
Objeto (objeto)
A través de typeof (x), puede devolver el "número de datos", "cadena", "booleano", "indefinido" y "objeto" de una variable x. Una cosa a tener en cuenta aquí: el operador de typeOf devuelve objeto para tipos nulos.
"JavaScript Avanzado Programación":
Este es en realidad un error en la implementación inicial de JavaScript, que luego fue utilizado por ECMAScript. NULL ahora se considera un marcador de posición del objeto, explicando así esta contradicción. Pero técnicamente sigue siendo el valor original.
2 hablar sobre la cadena de alcance de JavaScript
Al ejecutar una pieza de código JavaScript (código global o función), el motor JavaScript creará un alcance para ello, también conocido como contexto de ejecución. Después de cargar la página, primero se creará un alcance global, y luego se ejecutará cada función, se establecerá un alcance correspondiente, formando así una cadena de alcance. Cada alcance tiene una cadena de alcance correspondiente, la cabeza de la cadena es el alcance global, y la cola de la cadena es el alcance de la función actual.
El propósito de la cadena de alcance es analizar identificadores. Cuando se crea la función (no se ejecuta), esto, los argumentos, los parámetros nombrados y todas las variables locales en la función se agregarán al alcance actual. Cuando JavaScript necesita encontrar la variable X (este proceso se llama resolución variable), primero buscará si hay un atributo X desde el final de la cadena en la cadena de alcance, es decir, el alcance actual. Si no se encuentra, continúe buscando a lo largo de la cadena de alcance hasta que la cabeza de la cadena, es decir, la cadena de alcance global, y no se encuentra la variable, se cree que no hay una variable X en la cadena de alcance de este código, y se lanza una excepción de error de referencia (referenceError).
3 Cómo entender la cadena prototipo de JavaScript
Cada objeto en JavaScript tiene un atributo prototipo, que lo llamamos un prototipo, y el valor del prototipo también es un objeto, por lo que también tiene su propio prototipo, que conecta una cadena prototipo. El encabezado de la cadena prototipo es objeto, y su prototipo es relativamente especial, con un valor de NULL.
La función de la cadena prototipo se usa para la herencia de objetos. La propiedad prototipo de la función A es un objeto. Cuando esta función se usa como un constructor para crear una instancia, la propiedad prototipo de la función se asignará a todas las instancias de objetos como un prototipo. Por ejemplo, si creamos una nueva matriz, el método de matriz se heredará del prototipo de la matriz.
Al acceder a un atributo de un objeto, primero busque el objeto en sí y vuelva si se encuentra; Si no se encuentra, continúe buscando las propiedades de su objeto prototipo (si aún no se encuentra, en realidad buscará hacia arriba a lo largo de la cadena prototipo hasta la raíz). Mientras no se sobrescribiera, las propiedades del prototipo de objeto se pueden encontrar en todos los casos, y si no se encuentra toda la cadena prototipo, volverá indefinida;
4 Declaración variable de JavaScript por adelantado
La guía autorizada de JavaScript explica esto: las variables de JavaScript están disponibles antes de la declaración, y esta característica de JavaScript se llama informal informalmente, es decir, todas las variables declaradas en las funciones de JavaScript (pero no involucran tareas) están "avanzadas" a la parte superior de la función.
De un ejemplo:
var scope = "global"; function myFunc () {console.log (alcance); var margen = "local";}Lo que imprime la consola no es "global" sino "indefinido". Esto se debe a que en el alcance de la función myFunc, la declaración de alcance variable local avanza a la parte superior de la función. En este momento, el alcance solo declara y no asigna valores, por lo que la salida no está definida. De hecho, el código anterior es el mismo que el siguiente:
var scope = "global"; function myFunc () {var alcance; console.log (alcance); escopo = "local";}5 Cómo comprender y aplicar los cierres de JavaScript
Los conceptos dados en la literatura sobre la definición específica de cierres son muy abstractos. Creo que los cierres son un mecanismo de sintaxis que permite funciones a todas las variables locales de otras funciones.
Por ejemplo:
function outFunc () {var name = "vicFeel"; function infunc () {console.log (nombre); } return infunc;} infunc (); // La consola muestra "VicFeel"Podemos ver este ejemplo de que todavía se puede acceder al nombre de la variable local de Outfunc en la función INFUNC.
Ejemplos de aplicaciones de cierre, simula las propiedades privadas de una clase. Aprovechando las propiedades del cierre, solo se puede acceder a las variables locales en el método Sayage, y también se accede al nombre externamente, lo que implementa las propiedades privadas de la clase.
function user () {this.name = "VicFeel"; // El atributo total var age = 23; // atributo privado this.sayage: function () {console.log ("Mi edad es" + edad); }} var user = new User (); console.log (user.name); // "VicFeel" console.log (user.age); // "Undefined" user.sayage (); // "Mi edad es de 23"Para obtener más información sobre los cierres, recomiendo el registro de red de Ruan Yifeng: aprende el cierre de JavaScript (cierre).
6 La esencia del nuevo objeto de construcción
function user () {this.name = "VicFeel"; this.age = 23;} var user = new User ();A través del nuevo operador, las siguientes operaciones realmente se completan en el usuario del constructor:
• Crear un nuevo objeto cuyo tipo sea objeto;
• Establezca las propiedades internas, accesibles y prototipo de este nuevo objeto establecido en el constructor (que se refiere al constructor apuntado por prototipo.construtor);
• Ejecutar constructor;
• Devuelve el objeto recién creado.
function user () {// this = {}; //this.constructor = user; this.name = "VicFeel"; this.age = 23; // Devuelve esto; } var user = new User ();Si el constructor devuelve un recién creado este objeto por defecto, si una variable se devuelve manualmente, no es válida si la variable es del tipo original, y si es un objeto, se devuelve.
7 agente de JavaScript
Cuando necesitamos agregar eventos a muchos elementos, podemos activar la función de procesamiento agregando eventos a su nodo principal y delegar eventos al nodo principal.
Por ejemplo, necesitamos agregar dinámicamente muchos LI a un UL, y necesitamos atravesar Li para agregar eventos de clic uno por uno.
<ul id = 'list'> </ul> var cuenta = 100; var ullist = document.getElementById ("List"); // nodo de construcción dinámica para (var i = count; i-;) {var lidom = document.createElement ('li'); Ullist.appendChild (lidom); } // enlace Haga clic en evento var linode = ullist.getElementBytagName ("li"); for (var i = 0, l = linodes.length; i <l; i ++) {linode [i] .Onclick = function () {// li Click Event}}Como todos sabemos, las operaciones DOM son muy consultas en el rendimiento. Entonces, la vinculación de eventos repetidos es simplemente un asesino de rendimiento. La idea central del proxy de eventos es escuchar tantos eventos como sea posible a través de la menor cantidad de enlaces posible. ¿Cómo hacerlo? La respuesta es usar el mecanismo de burbujas de eventos para unir el nodo UL (burbuja de eventos) y luego usar eventos.
Var Count = 100; var ullist = document.getElementById ("List"); // nodo de construcción dinámica para (var i = count; i-;) {var lidom = document.createElement ('li'); Ullist.appendChild (lidom); } // enlace Haga clic en evento var linode = ullist.getElementBytagName ("li"); Linode.OnClick = function (e) {if (e.target && e.target.nodename.touppercase == "li") {// li haga clic en evento}}El nuevo contenido se actualizará continuamente ...