Um rápido resumo dos pontos de conhecimento de aprendizagem de JavaScript

Como começar rapidamente com VUE3.0: Insira e aprenda

recomendações relacionadas: JavaScript Tutorial

1, Introdução simples ao JavaScript

1.1. Uma linguagem de script do lado do cliente

que é executada no navegador do cliente. Cada navegador possui uma linguagem de script de mecanismo de análise JavaScript: ela não precisa ser compilada, pode ser analisada e executada diretamente pelo navegador. Pode aprimorar o processo de interação entre usuários e páginas HTML, controlar elementos HTML e tornar a página dinâmica. . Efeito e melhoria da experiência do usuário

1.2. História do desenvolvimento de JavaScript

Em 1992, Nombase desenvolveu a primeira linguagem de script do lado do cliente, usada especificamente para verificação de formulários. Nomeado: C--, posteriormente renomeado: ScriptEase
Em 1995, a Netscape desenvolveu uma linguagem de script do lado do cliente: LiveScript. Mais tarde, especialistas da SUN foram convidados a modificar o LiveScript e nomeá-lo JavaScript
Em 1996, a Microsoft copiou o JavaScript e desenvolveu a linguagem JScript.
Em 1997, a ECMA (Associação Europeia de Fabricantes de Computadores) formulou um padrão para linguagens de script do lado do cliente: ECMAScript, que unifica os métodos de codificação de todas as linguagens de script do lado do cliente.

JavaScript = ECMAScript + coisas únicas do JavaScript (BOM+DOM)

1.3 Vantagens da

linguagem interpretada a.
b. Baseado em objeto
c. Orientado por eventos
d. Tipo fraco
e. Alta segurança
f. Referência de JavaScript multiplataforma

1.4.

Se você precisar inserir JavaScript na página HTML, use a tag <script> .
<script> 和</script> informam ao JavaScript onde começar e terminar.
As linhas de código entre <script> 和</script> contêm JavaScript

<script type="text/javascript" src="${request.contextPath}/static/js/homepage.js"></script>

1.5. formas de saída JavaScript

window.alert()document.write()innerHTML
console.log()

conveniente

console.log() uso em programação. Você pode visualizar diretamente o conteúdo de saída por meio do console F12.

1.7.Comentário JavaScript

// Este é o código: um comentário de uma única frase, geralmente a tecla ctrl + L no editor.
/* Este é o código*/: Comentários multilinhas, geralmente teclas ctrl + shift + L no editor.

1.8.Quais são os identificadores comuns em JavaScript?

1.9.Quais são os eventos HTML comuns em JavaScript?

1.10. Operadores JavaScript comuns

1.11.Operadores de atribuição comuns em JavaScript

1.12.Operadores de comparação comuns em JavaScript

1.13.Operadores lógicos comuns em JavaScript

2. Descrever detalhadamente a sintaxe básica do JavaScript

2.1. Variáveis

​​2.1.1. Definir uma variável

// Declarar uma variável chamada test. var test;

var idade, nome, sexo;//Declara três variáveis ​​de idade, nome e sexo

//Declara variáveis ​​​​ao mesmo tempo e atribui valores var idade = 10, nome = "Xiaoqiang", sexo = "1 ";

2.1.2. Regras e especificações de nomenclatura de variáveis

​​1. Consiste em letras, números, sublinhados e símbolos. Não pode começar com um número.
2. Não podem ser utilizadas palavras-chave, por exemplo: while
3. Especificações que diferenciam maiúsculas de minúsculas: método de escrita convencional
1. Os nomes das variáveis ​​devem ser significativos.
2. Cumprir a nomenclatura camel case A primeira letra da nomenclatura camel case é minúscula e a primeira letra das palavras a seguir é maiúscula, como userName

Number类型、String类型、Boolean类型、Undefined类型、Null类型、Object类型

.

Number类型、String类型、Boolean类型、Undefined类型、Null类型、Object类型

2.2.1.Number

Tipo digital de número: inclui números inteiros e decimais e pode ser expresso em: decimal, octal, hexadecimal,

como:

var num = 10; 
//Var decimal num1 = 012; 
//Octal var num2 = ox123; 

intervalo de valores

hexadecimais

console.log(Number.MAX_VALUE); 
//O valor máximo é 5e-324console.log(Number.MIN_VALUE); 
//O valor mínimo é 1,7976931348623157e+308 Infinito: Infinito: -O

julgamento numérico infinito não pode usar decimais para verificar decimais e não usar NaN para verificar se é NaN (NaN ---- não é um número), mas você pode usar isNaN - não é O resultado de um número NaN?
Tais como:

var num; 
//Declara uma variável, não atribuída console.log(isNaN(num)); 
// Verdadeiro não é um número? O resultado é verdadeiro

2.2.2.String

caractere de escape de string:

por exemplo:

var str = "eu sou um pm\"console.log(str); 
// eu sou um pm

Concatenação de strings:

var str1 = "Sr.";var str2 = "Olá";console.log(str1+str2); 
// Olá senhor,

se o resultado da emenda de strings e números também for o efeito da emenda de string como mostrado acima

2.2.3

Tipo

booleano, os dois atributos true/false

2.2.4.

declarada sem atribuição, a variável Quando declarada apenas, o valor padrão é indefinido.
Por exemplo:

var num;console.log(num); 
// indefinido

2.2.5.Null

Null representa um nulo Se o valor da variável for nulo, ele deve ser definido manualmente

2.2.6.Object

2.3. Conversão do tipo de dados

2.3.1

.

, Number() Qualquer valor pode ser convertido em um valor numérico. Se houver um caractere na string a ser convertida que não seja um valor numérico, NaN será retornado.
Por exemplo:

var num1 = Number("10");console.log(num1); 
// 10var num2 = Number('10adbdn');console.log(num2); 
//NaNvar num3 = Number("10.78");console.log(num3); 
//10.78var num4 = Number('10.65dd');console.log(num4); 
//NaNvar num5 = Number("a10");console.log(num5); 
//NaN

(2), parseInt() converte para inteiro como:

var num1 = parseInt("10");console.log(num1); 
// 10var num2 = parseInt('10adbdn');console.log(num2); 
//10var num3 = parseInt("10.78");console.log(num3); 
//10var num4 = parseInt('10.65dd');console.log(num4); 
//10var num5 =parseInt("a10");console.log(num5); 
//NaN

(3), converte parseFloat() em decimal, como:

var num1 = parseFloat("10");console.log(num1); 
// 10var num2 = parseFloat('10adbdn');console.log(num2); 
//10var num3 = parseFloat("10.78");console.log(num3); 
//10var num4 = parseFloat('10.65dd');console.log(num4); 
//10var num5 = parseFloat("a10");console.log(num5);

A diferença entre (4), Number(), parseInt() e parseFloat()
Number() é mais estrito que parseInt() e parseFloat().
parseInt() é semelhante a parseFloat(), parseFloat analisará o primeiro. Ao encontrar o segundo ou o final não numérico

2.3.2. Converta para o tipo string

(1), toString().
Por exemplo:

var num = 10;console.log(num.toString()); 
//String 10

(2), String()
Por exemplo:

var num1 =5;console.log(String(num1)); 
// String 5

(2), JSON.stringfy()

2.3.3. Converter para booleano tipo

0, string vazia, nulo, indefinido, NaN será convertido para falso, outros serão convertidos para verdadeiro
Por exemplo:

var num1 = Boolean(0);console.log(num1); 
// falsevar num2 = Boolean("");console.log(num2); 
// falsevar num3 = Boolean(null);console.log(num3); 
/ falsevar num4 = Boolean(indefinido);console.log(num4); 
// falsevar num5 = 10;var num6;console.log(Boolean(num5+num6)); 
/ false

2.4. Operador

Tipos de operadores: operadores aritméticos, operadores compostos, operadores relacionais, operadores lógicos

(1), operadores aritméticos: "+" "-" "*" "/" "%"
Expressões aritméticas: expressões conectadas por operadores aritméticos.

Operadores compostos: "+=""-=""*=""/=""%=".
Expressões de operação composta: Expressões (3) conectadas por operadores compostos

, operadores relacionais: ">""<"">=""<="" "" =""!=""!== "
Expressão de operação relacional: expressões conectadas por operadores relacionais

(4), operadores lógicos: "&&" "||" "!"

Expressão 1 && Expressão 2

conectada por operadores lógicos

Se um deles for falso, todo o resultado será falso.

Expressão 1 || Expressão 2.
Se um deles for verdadeiro, todo o resultado será falso

! O resultado da expressão expressão é verdadeiro e todo o resultado é falso.
O resultado da expressão é falso e todo o resultado é verdadeiro

2.5 A prioridade dos operadores

é de alta para baixa:

() O operador unário de maior prioridade ++ – !
Os operadores aritméticos são */% e depois + -
Operadores relacionais > >= < <=
Operador de igualdade == != === !==
Os operadores lógicos são && seguidos por ||
Operador de atribuição

2.6. Função

2.6.1 Introdução

Funções em JavaScript são objetos. Um objeto é uma coleção de pares nome/valor e possui uma conexão oculta com o objeto protótipo. O objeto produzido pelo objeto literal está conectado a Object.prototype. Objetos de função são conectados a Function.prototype (que por sua vez está conectado a Object.prototype). Cada função terá dois atributos ocultos anexados quando for criada: o contexto da função e o código que implementa o comportamento da função

2.6.2 A função usa

function functionname() {aqui está o código a ser executado}

Sintaxe:
Os parênteses podem incluir argumentos separados por vírgulas:

(argumento1, argumento2,…)

O código executado pela função é colocado entre chaves: {}

nome da função(argumento1, argumento2, argumento3) {
    Código a ser executado}

Os parâmetros da função são os nomes listados na definição da função.

da

função são os valores reais recebidos pela função quando a função é chamada

//Crie uma função sumfunction aqui sum(num1, num2) {.
    var resultado = num1 + num2;
    console.log("num1 + num2 = " + resultado);}// Chamada de função sum(10, 20);

execute a função imediatamente:

$(function(){
	

todas

são

de

páginas e são executadas diretamente sum()})

Sintaxe: Reg = /pattern/modifiers; a regularidade literal consiste em duas barras //, e a regra é escrita após a primeira barra: /pattern[As regras podem escrever vários metacaracteres | palavras set|assert...] . Após a segunda barra, escreva o identificador /modifiers [g global match | i ignore case | m newline match ^ posição inicial $ posição final] identificador.
var Reg = /caixa/gi;
Construtor. Sintaxe Reg = new RegExp( pattern , modifiers ); . Não importa como você o cria, ele é o mesmo, modelo de padrão, conteúdo correspondente e modificadores.

var Reg = new RegExp("box","gi");

2.7.2. Método de expressão regular

variável

str = 'a1b2c3a4a5',
    reg = /a/g;console.log(str.match(reg)); //["a", "a", "a"]var str = 'a1b2c3a4a5',
    reg = /a/;console.log(str.search(reg)); //0var str = 'a1b2c3a4a5',
    reg = /a/g;console.log(str.replace(reg,function(){
    console.log(argumentos);
    return 5555;}));var str = 'a,b,c,d',
    reg = /,/g;//console.log(str.split(',')); //["a", "b", "c", "d"]console.log(str.split( reg)) //["a", "b", "c", "d"]

2.7.3.Descrição do método do objeto RegExp

. 2.7.4 Modificadores

Os modificadores também são chamados de identificadores e podem especificar padrões de correspondência. Os modificadores são usados ​​para realizar correspondência global e com distinção entre maiúsculas e minúsculas.
Ignore a correspondência de maiúsculas e minúsculas.
g corresponde globalmente. Sem g, apenas o primeiro elemento é correspondido e nenhuma correspondência é executada.
m executa correspondência multilinha

var patt = /pattern/i; //Ignora correspondência de maiúsculas e minúsculas var patt = /pattern/g; //Correspondência global var patt = /pattern/m

; Caracteres

são caracteres especiais que possuem um significado especial em expressões regulares.
Caracteres especiais de tradução.

. Um único caractere, exceto nova linha n e tabulação r. 
 Caractere de escape, símbolos de escape com significado especial em símbolos comuns: .d Números [0~9]D Não-númeross EspaçosS Não-espaçosw Caracteres [letras|dígitos|sublinhado]W Não- caractere b limite de palavra (exceto (palavra) alfanumérico_ são todos limites de palavras) B limite não-palavra

var reg = /./;//match.var reg = /\/;//match var reg = / //;//Match /var str = '\';var reg = /\/g;console.log(reg.test(str)); //true

2.8.1

.Date objeto

Um objeto Date é um objeto relacionado a data e hora. É dinâmico e você deve usar a palavra-chave new para criar uma instância, como:
var Meusdados=nova Data();
O objeto Date não fornece propriedades de acesso direto, apenas métodos para obter e definir a data, conforme mostrado na tabela a seguir

2.8.2. Objeto String

O objeto String é um objeto de processamento de string fornecido por JavaScript. Ele pode ser referenciado somente após a criação de uma instância de objeto. Ele fornece propriedades e métodos para processamento de strings (semelhante ao Java).
Comprimento da propriedade — Retorna o número de caracteres na string.
Nota: Um caractere chinês também é um caractere! !

Propriedades

do objeto matemático

Métodos de objetos matemáticos:

funções trigonométricas (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) retornam valores em radianos. Você pode converter radianos em graus dividindo Math.PI/180 ou por outros métodos.

Exemplo 1: Escreva uma função que retorna um número inteiro aleatório de min a max, incluindo min, mas excluindo

a função max getRandomArbitrary(min). , máximo) {
  return min + Math.random() * (max - min);}

Exemplo 2: Escreva uma função para gerar uma string aleatória de comprimento n. O intervalo de valores dos caracteres da string inclui 0 a 9, a a z, A a Z.

function getRandomInt(min, max) {
  return min + Math.floor(Math.random() * (max - min + 1));}função randomStr(n){
  var dict = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  varstr='';
  for(i = 0; i < n;i++){
    str += dict[getRandomInt(0,62)];
  }
  return str;}var str = getRandStr(10);console.log(str);

2.8.4

.
1. Matriz bidimensional A essência de uma matriz bidimensional é que os elementos da matriz também são matrizes.

2

da coluna 2 e linha 1 de a

. a partir de 0 O índice inicial não contíguo da matriz. Em matrizes esparsas, o valor do atributo comprimento geralmente é maior que o número real de elementos (incomum)
Exemplo

var a=["a","b",,,,"c",,];

Atributo do objeto array

1.length atributo:

alert(arr.length); /Aumenta o comprimento do array, o atributo length é variável alert(arr.length ); //Mostra que o comprimento do array passou a ser 15

2.atributo protótipo

O atributo protótipo retorna uma referência ao protótipo do tipo de objeto. A propriedade protótipo é comum aos objetos.
nomeDoobjeto.prototype
O parâmetro objectName é o nome do objeto objeto.
Descrição: Utilize o atributo protótipo para fornecer um conjunto de funções básicas da classe do objeto. Novas instâncias de um objeto “herdam” as operações atribuídas ao protótipo do objeto.
Para objetos array, use o exemplo a seguir para ilustrar o uso do atributo protótipo.
Adicione um método ao objeto array que retorne o valor máximo do elemento no array. Para fazer isso, declare uma função, adicione-a a Array.prototype e use-a.

função array_max(){
   var i, max = this[0];
   for (i = 1; i < este.comprimento; i++){
       if (max <este[i])
       máximo = isto[i];
   }
   

max

;}Array.prototype.max = array_max;var x = new Array(1, 2, 3, 4, 5, 6);var y = x.max( )

; função de objeto.
object.constructor //object é o nome do objeto ou função.
Descrição: O atributo construtor é membro de todos os objetos com protótipo. Eles incluem todos os objetos nativos JScript, exceto objetos Global e Math. O atributo construtor contém uma referência à função que constrói uma instância de objeto específica.

Por exemplo:

x = new String("Hi");if (x.constructor == String) // Processo (a condição é verdadeira). //ou função MyFunc {// Corpo da função. }y = new MyFunc;if (y.constructor == MyFunc) // Processo (condição é verdadeira).

Método de objeto array <br/> Descrição: Parte dele é um novo recurso do ECMAScript5 (não suportado pelo IE678).

explica principalmente alguns novos recursos

concat
A função do concat é unir arrays. Deve-se observar que um elemento do array também pode ser usado como um elemento emendado. Nesse caso, o array será achatado e então emendado com outros elementos para formar um novo array. , mas não será nivelado duas vezes. concat não modifica o array original.

Por exemplo:

var arr=[1,2,3,4,5];arr.concat([10,11],13);//[1,2,3,4,5,10,11,13] arr .concat([1,[2,3]]);//[1,2,3,4,5,1,[1,3]]

fatia
a fatia (a, b) a e b pode receber números negativos, o que significa que uma matriz é interceptada da posição a para a posição b. É um intervalo que é fechado à esquerda e aberto à direita A e b pode assumir valores negativos. números Se for um número negativo, significa os últimos elementos a/ b

var arr=[1,2,3,4,5];arr.slice(1,3);//[2,3]arr. slice(1);//[2,3,4, 5]arr.slice(1,-1);//[2,3,4]arr.slice(-4,-3);//[2 ]

emenda
splice remove elementos e adiciona novos elementos ao array
object.splice(a) exclui um elemento da esquerda
object.splice(a, b) intercepta b elementos começando na posição a
object.splice(a, b, c, d) intercepta b elementos começando na posição a e insere c e d ou mais elementos no array original. Deve-se notar que splice modificará o array original

var arr=[1, 2 ,3,4,5];arr.splice(2);//[3,4,5]arr;//[1,2];O array original foi modificado var arr=[1,2,3 ,4 ,5];arr.splice(2,2);//[3,4]arr;//[1,2,5];var arr=[1,2,3,4,5];arr .splice (1,1,'a','b');//[2]arr;//[1,"a","b",3,4,5]

;
A função foreach() percorre o array do início ao fim. Existem três parâmetros: elementos do array, índice de elementos e o próprio array

var arr = [1, 2, 3, 4, 5]; elements , o índice do elemento, o próprio array console.log(x + '|' + index + '|' + (a === arr));});// 1|0|true// 2| 1|verdadeiro/ / 3|2|verdadeiro// 4|3|verdadeiro// 5|4|verdadeiro

reduzir()
A redução() do Array aplica uma função a [x1, x2, x3...] deste Array. Esta função deve receber dois parâmetros reduzir() continua o resultado e realiza um cálculo cumulativo com o próximo elemento da sequência. é:

[x1, x2, x3, x4].reduzir(f) = f(f(f(x1, x2), x3), x4)

var arr = [1, 2, 3];var soma = arr.reduzir ( função (x, y) {
     return x + y}, 0); //O parâmetro 0 é opcional. Se o parâmetro 0 for escrito, os dois valores passados ​​pela primeira vez são 0 e 1. Caso contrário, os dois primeiros valores. passados ​​​​pela primeira vez são os dois primeiros valores do valor da matriz, o resultado do cálculo é 6arr; reduzir(função(x, y) {
     console.log(x + "|" + y);
     return x > y ? x : y;});// 3|9// 9|6max

;

Comparação de arrays e strings

métodos

de

array

.

={name:"xiaoming",age:12}var json=JSON.stringify(person); //{"name":"xiaoming","age":12}

Além de aceitar objetos, stringify() Você pode também aceita 2 parâmetros. O primeiro parâmetro é um filtro, que pode ser uma coleção de array de propriedades do objeto ou uma função; o segundo parâmetro é uma opção que indica se o

filtro de array recuado deve ser mantido na string JSON:

json=JSON.stringify( person,['name']); //{"name":"xiaoming"}

Filtro de função:

json=JSON.stringify(person,function(key,value){
    mudar(chave){
        caso "nome":
           valor de retorno+",wang";
        caso "idade":
           retornar indefinido;
        padrão:
           valor de retorno;
    }});//{"name":"xiaoming,wang"}

Observe que se a função retornar indefinido, este atributo será ignorado;

json

=JSON.stringify(person,null,4);
    "nome": "xiaoming",
    "age": 12}

2.9.2.toJSON()

Adicione o método toJSON() ao objeto:

var person={
    nome:"xiaoming",
    idade: 12,
    toJSON:função(){
        retornar este.nome+" é "+esta.idade;
    }}json=JSON.stringify(person);console.log(json); //"xiaoming is 12"

2.9.3.parse()

Além de aceitar uma string json, parse() também pode aceitar um parâmetro de função. Esta função aceita 2 valores, uma chave e um valor;

var person=JSON.parse('{"name":"xiaoming","age":12}');var person=JSON.parse('{"name " :"xiaoming","idade":12}',function(chave,valor){
    if(chave=="idade"){
        valor de retorno+10;
    }
    outro{
        valor de retorno;
    }});

2.10.Ajax

2.10.1. Etapas de criação:

1. Crie um objeto assíncrono XMLHttpRequest.
2. Defina o método de solicitação e o endereço da solicitação
3. Em seguida, use send para enviar a solicitação
4. Monitore as mudanças de status
5. Por fim, receba os dados retornados.

Exemplo:

const xhr = new XMLHttpRequest()xhr.open('GET', './data/test.json', true)xhr.onreadystatechange = function () {
  if (xhr. readyState === 4) {
    if (xhr.status === 200) {
      console.log(JSON.parse(xhr.responseText))
    } outro {
      console.log('Outras situações...')
    }
  }}xhr.send()

2.10.2.Aplicativo Ajax em jQuery

$.ajax({
                    type: "post", //Método de solicitação url: "a.php", //O endereço do link do servidor dataType: "json", //O formato de transmissão e recebimento de dados:{
                        nome de usuário:"james",
                        senha:"123456"
                    },
                    sucesso:função(dados){//Função console.log(dados) chamada ao receber dados com sucesso;//dados são os dados retornados pelo servidor},
                    error:function(request){//A função chamada quando a solicitação de dados falha alert("Ocorreu um erro:"+request.status);
                    }});

2.10.3.Estrutura

do método GET

$.get(url, [data], [callback], [type])

Explicação do parâmetro:

//Etapa 1: Crie um objeto assíncrono var ajax = new XMLHttpRequest(); //Etapa 2: Defina os parâmetros de url da solicitação. O primeiro parâmetro é o tipo de solicitação e o segundo parâmetro é o urlajax.open( "get", " users.json");//Etapa 3: Enviar uma solicitação ajax.send();//Etapa 4: Registrar o evento onreadystatechange. Quando o estado muda, ajax.onreadystatechange = function () {
    if (ajax.readyState == 4 && ajax.status == 200) {
        //Etapa 5: Se você puder inserir este julgamento, significa que os dados retornaram perfeitamente e a página solicitada existe console.log(ajax.responseText); //Insira o conteúdo da resposta}}

; Método POST

Tem a mesma estrutura e uso do método $.get(), mas ainda existem algumas diferenças entre eles.

2.10.5.

Post é mais seguro que get se solicitado no modo get. os parâmetros da solicitação serão emendados no verso da URL, a segurança é baixa. Ao solicitar no modo post, os parâmetros da solicitação serão agrupados no corpo da solicitação, o que é mais seguro.
2. Diferença de quantidade: A quantidade de dados transmitidos pelo método get é pequena e não pode ultrapassar 2kb, enquanto a quantidade de dados solicitados pelo método post é grande e não há limite.
3. Velocidade de transmissão: A velocidade de transmissão do get é maior que a do post
Como o método de uso é o mesmo, desde que a função jQuery seja alterada, o programa pode ser alternado entre solicitações GET e solicitações POST

2.11.Cookie

2.11.1.js função de operação de leitura de cookie

getCookie(c_name){ if (document.cookie . length>0){ //Primeiro verifique se o cookie está vazio. Se estiver vazio, retorne "" c_start=document.cookie.indexOf(c_name + "=") //Verifique se o cookie existe através do indexOf(). do objeto String. Se não existir, é -1 if (c_start!=-1){ c_start=c_start + c_name.length+1 //O último +1 na verdade representa o número "=", obtendo assim o número "=". posição inicial do valor do cookie c_end= document.cookie.indexOf(";",c_start) //Na verdade, fiquei um pouco tonto quando vi pela primeira vez o segundo parâmetro de indexOf(). posição do índice...Esta frase é para obter a posição final do valor. Como você precisa considerar se é o último item, você pode julgar se o sinal ";" existe se (c_end==-1) c_end=document.cookie.length　
return unescape(document.cookie.substring(c_start,c_end)) //O valor é obtido através de substring(). Se você quiser entender o unescape(), você deve primeiro saber o que o escape() faz. É uma base muito importante. Se você quiser saber mais, você pode pesquisar os detalhes da codificação do cookie. o artigo} } return "" }

2.11.2 .Operação de armazenamento simples de cookies

$.cookie("groupCode",222)

2.11.3.Tempo de expiração da configuração de

cookies document.cookie = "name=value;expires=date"

2.11.4 .Modificação de cookie

username

console.log

(cookies);

";document.cookie = "username=; expira=qui, 01 de janeiro de 1970 00:00:00 GMT";var cookies = document.cookie;console.log(cookies);

2.12. Loop

2.12.1. for loop

for is o loop mais comumente usado, usado principalmente para fazer loop de matrizes

let arr = [1,2,3];for (let i=0; i<arr.length; i++){
 console.log(i,arr[i])}// 0 1// 1 2// 2 3

2.12.2.Array.forEach()

Sintaxe: arr.forEach(callback(currentValue [, index [, array]])[, thisArg]);

callback é uma função executada para cada elemento do array. A função recebe três parâmetros, currentValue (o elemento atual que está sendo processado no array), index (o índice do elemento atual que está sendo processado no array. ), array (o array no qual o método forEach() está operando)

thisArg é o valor usado como this quando o retorno de chamada da função de retorno de chamada é executado.

deixe arr = [1, 2, , 3] deixe arrCopy1 = []arr.map((item, índice, arr) => {
     arrCopy1.push(item * 2)})console.log(arrCopy1)// [2, 4, 6]

forEach() executa a função de retorno de chamada uma vez para cada elemento do array. Itens excluídos ou não inicializados serão ignorados (por exemplo, em arrays esparsos. )
Ao contrário de map() e reduzir(), não tem valor de retorno e sempre retorna indefinido.
ForEach() não tem como abortar ou sair do loop forEach() a não ser lançar uma exceção.

2.12.3.while

A instrução while pode executar um loop para executar um trecho de código especificado sob a premissa de que uma determinada expressão condicional é verdadeira, até que o loop termine quando essa expressão não for verdadeira.

Exemplo:

let n = 0 while (n <). 3) {
  n++;}console.log(n);//saída esperada: 3Nota

: Use a instrução break para interromper o loop antes que o resultado da avaliação da condição seja verdadeiro.

2.12.4.do…while

A instrução do…while cria um loop que é executado. a instrução especificada até que o valor da condição seja falso. Detecta a condição após a execução da instrução, para que a instrução especificada seja executada pelo menos uma vez

Exemplo:

const list = ['a', 'b', 'c']let i = 0do {
  console.log(lista[i]) //valor
  console.log(i) //índice
  i = i + 1} while (i <list.length)

2.12.5.for…in

O loop for…in pode ser usado para percorrer a lista de atributos enumeráveis ​​do objeto (incluindo a cadeia [[Prototype]]) e

é usado principalmente para percorrer o objeto, o valor do atributo pode ser obtido por meio da lista de atributos

para (let property in object) {.
  console.log(propriedade) //nome da propriedade
  Console.log (Object [Propriedade]) // Valor da propriedade}

Recomendações relacionadas: Javascript Aprendizagem Tutorial

O acima é um resumo detalhado dos pontos de conhecimento de aprendizado de JavaScript.