Tipo de datos
JavaScript es un lenguaje de tipo débil , pero no está exento de tipos. JavaScript puede reconocer los siguientes 7 tipos diferentes de valores:
Tipos de datos básicos
1.Booleano
2. Number
3. String
4.NULL
5.Nofinado
6. Símbolo
Objeto
1.Arráneo
2.Regexp
3. Date
4. Math
5 ....
Puede usar Tipof para determinar el tipo de datos. El operador devuelve una cadena, pero no todos los resultados devueltos están en línea con las expectativas.
typeOf False // "boolean" typeof .2 // "número" typeOf nan // "número" typeOf '// "string" typeOf undefined // "Undefined" typeOf Symbol () // "Symbol" typeOf New Date () // "Object" TypeOf [] // "Object" TypeOf Alert // "Function" TypeOf NULL // "Object" TypeOf Not_DeFined_Var
variable
En la aplicación, use variables para nombrar el valor. El nombre de la variable se llama identificadores
declaración
1. Use la palabra clave var: alcance de función
2. Use la palabra clave, deje que el alcance de bloqueo de la variable local
3. Uso directo: alcance global
var global_var = 1; function fn () {var fn_var = 2; if (fn_var> 10) {let block_var = 3; global_var2 = 4;}}Solo no declare asignación, el valor predeterminado de la variable está indefinido
La palabra clave const puede declarar variables inmutables, y también está en bloque. La comprensión de los objetos inmutables requiere atención
const num = 1; const obj = {prop: 'valor'}; num = 2; // typeError no capturado: asignación a variable constante.obj ['prop'] = 'value2'; obj = []; // typeError no capturado: asignación a una variable constante.Mejora variable
JavaScript puede referirse a variables declaradas más tarde sin lanzar diferentes conceptos. Este concepto se llama promoción de la declaración variable (elevación)
console.log (a); // UndefinedVar a = 2;
Equivalente a
var a; console.log (a); a = 2;
función
Una función es una subrutina que puede llamarse por código externo (o llamado recursivamente por la función misma).
Definir funciones
1. Declaración de funciones
2. Expresiones de funciones
3. Constructor de funciones
4. Función de flecha
function fn () {} var fn = function () {} var fn = new function (arg1, arg2, ... argn, funcky) var fn = (param) => {}argumentos
1. Argumentos: un objeto similar a una matriz que contiene parámetros pasados a la función de ejecución actual
2. Argumentos. Longitud: el número de parámetros pasados a la función
3.argumentos.caller: llame a la función que actualmente ejecuta la función
4.argumentos.callee: la función actualmente se está ejecutando
function foo () {return arguments;} foo (1, 2, 3); // Argumentos [3] // {"0": 1, "1": 2, "2": 3}descansar
función foo (... args) {return args;} foo (1, 2, 3); // matriz [3] // [1, 2, 3] función fn (a, b, ... args) {return args;} fn (1, 2, 3, 4, 5); // matriz [3] // [3, 4, 5]por defecto
Los valores predeterminados se pueden acordar al definir los parámetros de la función.
función fn (a = 2, b = 3) {return a + b;} fn (2, 3); // 5fn (2); // 5fn (); // 5Objeto
Los objetos en JavaScript son colecciones con teclas variables
Definir objetos
1. Literal
2. Constructor
var obj = {prop: 'value', fn: function () {}}; var date = new Date ();Constructor
No hay diferencia entre un constructor y una función normal. Llamar con la nueva palabra clave es un constructor. El uso del constructor puede instanciar un objeto.
Hay dos posibles retornos de la función
1. Explícitamente la devolución de llamadas para devolver la evaluación de la expresión después de la devolución
2. No se llama no devolución y se devuelve indefinido
Función People (nombre, edad) {this.name = name; this.age = age;} var personas = New People ('Byron', 26);Valor de devoluciones de constructor
1. Sin valor de retorno
2. Tipo de datos simple
3. Tipo de objeto
El constructor devuelve una instancia del constructor en los dos primeros casos. Esta característica se utiliza instanciando el objeto.
El tercer constructor realiza lo mismo que la función ordinaria, y devuelve el resultado de la expresión después de retorno
prototipo
1. Cada función tiene un atributo de objeto de prototipo, y hay un atributo de constructor en el objeto, que apunta a la función en sí misma de forma predeterminada.
2. Cada objeto tiene un atributo __proto__, y el zodiaco apunta al prototipo de su tipo principal
Function Person (name) {this.name = name;} persona.prototype.print = function () {console.log (this.name);}; var p1 = new Person ('byron'); var p2 = new Person ('casper'); p1.print (); p2.print ();esto y alcance
El alcance se puede entender de manera popular
1. Quién soy yo
2. ¿Qué tipo de jinetes tengo?
¿A quién respondí esto?
El jinete es mi variable local
Esta escena
Funciones normales
1. Modo estricto: indefinido
2. Modo no rictamente: objeto global
3.Node: Global
4. Navegador: ventana
Constructor: una instancia de un objeto
Método de objeto: Objeto en sí mismo
llamar y aplicar
1.fn.call (context, arg1, arg2, ..., argn)
2.fn.apply (contexto, args)
función isNumber (obj) {return object.prototype.ToString.call (obj) === '[número de objeto]';}Function.prototype.bind
Bind Devuelve una nueva función, el alcance de la función es el parámetro de enlace
function fn () {this.i = 0; setInterval (function () {console.log (this.i ++);}. bind (this), 500)} fn (); () => {}La función de flecha es una nueva característica proporcionada por ES6, se abrevia de expresión de la función, con alcance léxico y este valor
function fn () {this.i = 0; setInterval (() => {console.log (this.i ++);}, 500)} fn ();heredar
En el escenario de JavaScript, la herencia tiene dos objetivos, y la subclase necesita obtener la clase principal:
1. Propiedades del objeto
2. Método de objeto
function hereds (child, parent) {var _propTotype = object.create (parent.prototype); _ proptotype.constructor = child.prototype.constructor; child.prototype = _propTotype;} function People (nombre, edad) {this.name = name; this.age =} People.prototipo. this.name;} function English (nombre, edad, idioma) {personas.call (this, name, edad); this.language = idioma;} heredes (inglés, personas); inglés.prototype.introduce = function () {console.log ('Hi, i IM' + this.getName ()); consolando.log ('yo hablo' + this. {People.call (this, nombre, edad); this.language = idioma;} heredes (chino, personas); chino.prototype.introduce = function () {console.log ('hello, soy' + this.getName ()); console.log ('Dije' + this.language);} Var en = nuevo inglés ('byron', 26, ',' inglés '); Chino ('aceite de ensalada', 27, 'chino'); en.introduce (); cn.introduce ();Clase ES6 y herencia
"Use estricto"; clase personas {constructor (name, edad) {this.name = name; this.age = age;} getName () {return this.name;}} class English extiende personas {constructor (name, edad, idioma) {super (name, age); this.language = idioma;} introducir () {console.log ('Hi, i am' + + + + + ' + + this.getName ()); console.log ('hablo' + this.language);}} Let en = nuevo inglés ('byron', 26, 'inglés'); en.introduce ();gramática
declaración de etiqueta
bucle:
for (var i = 0; i <10; i ++) {for (var j = 0; j <5; j ++) {console.log (j); if (j === 1) {break loop;}}} console.log (i);Declaraciones y expresiones
var x = {a: 1}; {a: 1} {a: 1, b: 2}Ejecutar la función inmediatamente
(function () {} ()); (function () {}) (); [function () {} ()]; ~ function () {} ();! function () {} ();+ function () {} ();- function () {} (); delete function () {} (); typeOf function () {} (); void functer () {} (); new function () {} (); new function () {} (); var f = funct () {} (); 1, () {) {} (} (); 1 ^} (} (} (} (} (} (} (} (} (} (} (); function () {} (); 1> function () {} ();Funciones avanzadas
Las funciones de orden superior son funciones que tratan las funciones como parámetros o valores de retorno como funciones.
Función de devolución de llamada
[1, 2, 3, 4] .ForEach (función (item) {console.log (item);});Cierre
El cierre consta de dos partes
1. Función
2. Entorno: variables locales dentro del alcance cuando la creación de funciones
función makecounter (init) {var init = init || 0; Función de retorno () {return ++ init;}} var contador = makecounter (10); console.log (contador ()); console.log (contador ()); console.log (contador ());Error típico
para (var i = 0; i <doms.length; i ++) {Doms.eq (i) .on ('click', function (ev) {console.log (i);});} para (var i = 0; i <doms.length; i ++) {(function (i) {doms.eq (i) .on ('click', function (ev) {console.log (i);});}) (i);}Funciones perezosas
function eventBinDergenerator () {if (window.adDeventListener) {return function (element, type, handler) {element.adDeventListener (type, hanlder, falso);}} else {return function (element, type, handler) {element.attachevent ('en' + type, handler.bind (element, window.event);} o} EventBinDergenerator ();Curry
Una forma de permitir el uso de parámetros parciales para generar funciones
function isType (type) {return function (obj) {return object.prototype.ToString.call (obj) === '[objeto' + type + ']';}} var isnumber = isType ('number'); console.log (isNumber (1)); console.log (iSnumber iStype ('array'); console.log (isarray (1)); console.log (isarray ([1, 2, 3])); función f (n) {return n * n;} function g (n) {return n * 2;} console.log (f (g (5))); función tubería (f, g) {function return () {return f.call (null, g.apply (null, argumentos));}} var fn = tubipe (f, g); console.log (fn (5);Recursión de cola
1. La llamada de la cola significa que el último paso de una función es llamar a otra función
2. La función se llama en sí misma, llamada recursión
3. Si la cola se llama a sí misma, se llama recursión de cola
La recursión es propensa a errores de "desbordamiento de pila" (desbordamiento de pila)
función factorial (n) {if (n === 1) return 1; return n * factorial (n - 1);} factorial (5) // 120Pero para la recursión de la cola, dado que solo hay un registro de llamadas, el error de "desbordamiento de pila" nunca ocurrirá
función factorial (n, total) {if (n === 1) Total de retorno; retorno factorial (n - 1, n * total);} factorial (5, 1) // 120El curry reduce los parámetros
función currying (fn, n) {function de return (m) {return fn.call (this, m, n);};} function tailfactorial (n, total) {if (n === 1) Total de retorno; return Tailfactorial (n - 1, n * total);} const factorial = currying (cola de cola, 1); factorial (5) // 120Anti-curria
Function.prototype.uncurry = function () {return this.call.bind (this);};generalización
var push = array.prototype.push.uncurry (); var arr = []; push (arr, 1); push (arr, 2); push (arr, 3); console.log (arr);
El contenido anterior es la descripción completa de los exquisitos ejemplos clásicos del lenguaje JavaScript (compilación) introducido por el editor. ¡Espero que sea útil para todos!