Tipo de dados
O JavaScript é um idioma do tipo fraco , mas não está sem tipos. JavaScript pode reconhecer os 7 tipos diferentes de valores diferentes:
Tipos de dados básicos
1.Boolean
2.Number
3.String
4.null
5.UNDEFINED
6. símbolo
Objeto
1.Array
2.Regexp
3.Date
4.Math
5 ....
Você pode usar o tipoof para determinar o tipo de dados. O operador retorna uma string, mas nem todos os resultados retornados estão alinhados com as expectativas.
typeof false // "boolean" typeof .2 // "número" tipo de nan // "número" typeof '' // "string" typeof indefinido // "indefinido" símbolo () // "símbolo" typeof new date () // "objeto" typeof [] // "objeto" "", "Tipoft //" functionof () // "objeto" "//" objeto "" ""
variável
No aplicativo, use variáveis para nomear o valor. O nome da variável é chamado de identificadores
declaração
1. Use a palavra -chave var: escopo da função
2. Use a palavra -chave Let: Block Scope Local Variable
3. Uso direto: escopo global
var global_var = 1; função fn () {var fn_var = 2; if (fn_var> 10) {let block_var = 3; global_var2 = 4;}}Declare apenas nenhuma atribuição, o valor padrão da variável é indefinido
A palavra -chave const pode declarar variáveis imutáveis e também é escopo. O entendimento de objetos imutáveis requer atenção
const num = 1; const obj = {prop: 'value'}; num = 2; // não -descoberto TypeError: atribuição para variável constante.obj ['prop'] = 'value2'; obj = []; // Tipo não capturado: atribuição para variável constante.Aprimoramento variável
O JavaScript pode se referir a variáveis declaradas posteriormente sem jogar conceitos diferentes. Este conceito é chamado de promoção da declaração variável (elevação)
console.log (a); // undefinedvar a = 2;
Equivalente a
var a; console.log (a); a = 2;
função
Uma função é uma sub -rotina que pode ser chamada pelo código externo (ou recursivamente chamado pela própria função).
Definir funções
1. Declaração da função
2. Expressões de função
3. Construtor de função
4. Função de seta
função fn () {} var fn = function () {} var fn = new Função (arg1, arg2, ... argn, funcbody) var fn = (param) => {}argumentos
1. Argumentos: um objeto semelhante a uma matriz que contém parâmetros passados para a função de execução atual
2.arguments.length: o número de parâmetros passados para a função
3.arguments.caller: chame a função que atualmente executa a função
4.arguments.callee: a função atualmente sendo executada
function foo () {retorna argumentos;} foo (1, 2, 3); // argumentos [3] // {"0": 1, "1": 2, "2": 3}descansar
function foo (... args) {return args;} foo (1, 2, 3); // Array [3] // [1, 2, 3] função fn (a, b, ... args) {return args;} fn (1, 2, 3, 4, 5); // Array [3] // [3, 4, 5]padrão
Os valores padrão podem ser acordados ao definir os parâmetros da função.
função fn (a = 2, b = 3) {return a + b;} fn (2, 3); // 5fn (2); // 5fn (); // 5Objeto
Objetos em JavaScript são coleções de chave variável
Definir objetos
1. Literal
2. Construtor
var obj = {prop: 'value', fn: function () {}}; var date = new Date ();Construtor
Não há diferença entre um construtor e uma função normal. Chamar com a nova palavra -chave é um construtor. O uso do construtor pode instanciar um objeto.
Existem dois possíveis retornos da função
1. Ligue explicitamente de retorno para devolver a avaliação da expressão após o retorno
2. Nenhum retorno é chamado e devolvido indefinido
função pessoas (nome, idade) {this.name = nome; this.age = idade;} var people = new People ('byron', 26);O construtor retorna valor
1. Sem valor de retorno
2. Tipo de dados simples
3. Tipo de objeto
O construtor retorna uma instância do construtor nos dois primeiros casos. Esse recurso é usado instantando o objeto.
O terceiro construtor desempenha o mesmo que a função comum e retorna o resultado da expressão após o retorno
protótipo
1. Cada função possui um atributo de objeto do protótipo e existe um atributo construtor no objeto, que aponta para a própria função por padrão.
2. Cada objeto tem um atributo __proto__, e os pontos do zodíaco para o protótipo de seu tipo pai
function pessoa (nome) {this.name = name;} person.prototype.print = function () {console.log (this.name);}; var p1 = new pessoa ('byron'); var p2 = new pessoa ('casper'); p1.print (); p2.print ();isso e o escopo
O escopo pode ser entendido de uma maneira popular
1. Quem sou eu
2. Que tipo de cavaleiro eu tenho
Quem eu sou respondido
O cavaleiro é minha variável local
Esta cena
Funções normais
1. Modo rigoroso: indefinido
2. Modo não rigoroso: objeto global
3.Node: Global
4. Navegador: janela
Construtor: uma instância de um objeto
Método do objeto: o próprio objeto
Ligue e aplique
1.fn.call (contexto, arg1, arg2,…, argn)
2.fn.apply (contexto, args)
função isNumber (obj) {return object.prototype.tostring.call (obj) === '[número do objeto]';}Function.prototype.bind
Bind retorna uma nova função, o escopo da função é o parâmetro de ligação
função fn () {this.i = 0; setInterval (function () {console.log (this.i ++);}. bind (this), 500)} fn (); () => {}A função de seta é um novo recurso fornecido pelo ES6, é a expressão da função abreviada, com escopo lexical e esse valor
função fn () {this.i = 0; setInterval (() => {console.log (this.i ++);}, 500)} fn ();herdar
No cenário JavaScript, a herança tem dois objetivos, e a subclasse precisa obter a classe dos pais:
1. Propriedades do objeto
2. Método do objeto
Função herda (filho, pai) {var _Proptotype = object.create (parent.prototype); _ proptotype.constructor = child.prototype.constructor; child.prototype = _proptypey;} function; name, idade) {this.name = name; this.name;} função em inglês (nome, idade, idioma) {People.call (este, nome, idade); this.Language = idioma;} herda (inglês, pessoas); inglês.prototype.Introduce = function () {console.log ('Hi, eu sou' + this.getName ()); {People.Call (este, nome, idade); this.Language = idioma;} herda (chinês, povo); chinês.prototype.Introduce = function () {console.log ('hello, eu sou' + this.getName ()); console.log ('eu disse' +, this.language); Chinês ('salada de óleo', 27, 'chinês'); en.introduce (); cn.inTroduce ();Classe ES6 e herança
"Use rigoroso"; classe People {construtor (nome, idade) {this.name = name; this.age = Age;} getName () {return this.name;}} classe em inglês estende pessoas {construtor (nome, idade, idioma) {consult (nome, idade); thisOGAGE = idioma; this.getName ()); console.log ('eu falo' + this.Language);}} let en = new English ('byron', 26, 'inglês'); en.introduce ();gramática
Declaração de etiqueta
laço:
para (var i = 0; i <10; i ++) {for (var j = 0; j <5; j ++) {console.log (j); if (j === 1) {break loop;}}} console.log (i);Declarações e expressões
var x = {a: 1}; {a: 1} {a: 1, b: 2}Executar a função imediatamente
(function () {} ()); (function () {}) (); [function () {} ()]; ~ function () {} ();! function () {} ();+ function () {} ();- function () {} (); delete function () {} (); tipoof function () {} (); void function () {} (); new);) {}; function () {} (); 1> function () {} ();Funções avançadas
Funções de ordem superior são funções que tratam as funções como parâmetros ou valores de retorno como funções.
Função de retorno de chamada
[1, 2, 3, 4] .ForEach (function (item) {console.log (item);});Encerramento
O fechamento consiste em duas partes
1. Função
2. Ambiente: variáveis locais dentro do escopo quando a criação da função
função makecounter (init) {var init = init || 0; return function () {return ++ init;}} var contador = makecounter (10); console.log (contador ()); console.log (contador ()); console.log (contador ());Erro típico
para (var i = 0; i <doms.length; i ++) {doms.eq (i) .on ('clique', function (ev) {console.log (i);});} para (var i = 0; i <doms.length; i ++) {(function) {doms.eq (i) .on ('' '', (i ++) {(function) {Doms.eq (i). {console.log (i);});}) (i);}Funções preguiçosas
função eventBInderGenerator () {if (window.addeventListener) {Função de retorno (elemento, tipo, manipulador) {element.addeventListener (tipo, hanlder, false);}}} {return function (elemento, tipo, manipulador) {element.attachEvent ('» + tipo, handler.bind (handler.bind (type, handler) {element.attachEvent (' no ' + tipo, handler.bin. EventBIndergeRerator ();Caril
Uma maneira de permitir o uso de parâmetros parciais para gerar funções
function iStype (type) {Return function (obj) {return object.prototype.toString.call (obj) === '[object' + type + '' ';}} var iSNumber = iStype (' Número '); console.log (isnumber (1)); iStype ('Array'); console.log (isarray (1)); console.log (isarray ([1, 2, 3])); função f (n) {return n * n;} função g (n) {return n * 2;} console.log (f (g (5))); tubo de função (f, g) {return function () {return f.call (null, g.apply (null, argumments));}} var f (f, g);Recursão de cauda
1. Chamada de cauda significa que a última etapa de uma função é chamar outra função
2. A própria chamada chamada, chamada recursão
3. Se a cauda se chamar, é chamada de recursão de cauda
Recursão é propensa a erros de "pilha de transbordamento" (estouro de pilha)
função fatorial (n) {if (n === 1) retornar 1; retornar n * fatorial (n - 1);} fatorial (5) // 120Mas para recursão de cauda, como existe apenas um registro de chamada, o erro "Stack Overflow" nunca ocorrerá
Função Fatorial (n, total) {if (n === 1) retorna total; retorno fatorial (n - 1, n * total);} fatorial (5, 1) // 120A curry reduz os parâmetros
função currying (fn, n) {return function (m) {return fn.call (this, m, n);};} função TailFactorial (n, total) {if (n === 1) Retorno total; retorno tailfactorial (n - 1, n * total);} const = Fatorial =Anticurriização
Function.prototype.uncurry = function () {return this.call.bind (this);};empurrar generalização
var push = array.prototype.push.uncurry (); var arr = []; push (arr, 1); push (arr, 2); push (arr, 3); console.log (arr);
O conteúdo acima é a descrição completa dos requintados exemplos clássicos da linguagem JavaScript (compilação) introduzida a você pelo editor. Espero que seja útil para todos!