Un résumé rapide des points de connaissances d'apprentissage JavaScript

Comment démarrer rapidement avec VUE3.0 : saisir et découvrir

les recommandations associées : Tutoriel JavaScript

1, Introduction simple à JavaScript

1.1. Un langage de script côté client

qui s'exécute dans le navigateur client. Chaque navigateur dispose d'un langage de script de moteur d'analyse JavaScript : il n'a pas besoin d'être compilé, il peut être directement analysé et exécuté par le navigateur. Il peut améliorer le processus d'interaction entre les utilisateurs et les pages HTML, contrôler les éléments HTML et rendre la page dynamique. . effet et améliorer l'expérience utilisateur

1.2. Historique du développement de JavaScript

En 1992, Nombase a développé le premier langage de script côté client, spécifiquement utilisé pour la vérification de formulaires. Nommé : C--, renommé plus tard : ScriptEase
En 1995, Netscape a développé un langage de script côté client : LiveScript. Plus tard, les experts de SUN ont été invités à modifier LiveScript et à le nommer JavaScript.
En 1996, Microsoft a copié JavaScript et développé le langage JScript.
En 1997, l'ECMA (European Computer Manufacturers Association) a formulé une norme pour les langages de script côté client : ECMAScript, qui unifie les méthodes de codage de tous les langages de script côté client.

JavaScript = ECMAScript + éléments uniques de JavaScript (BOM+DOM)

1.3 Avantages du

langage interprété par JavaScript a.
b. Basé sur des objets
c. Piloté par les événements
d. Type faible
E. Haute sécurité
f. Référence JavaScript multiplateforme

1.4

Si vous devez insérer du JavaScript dans la page HTML, veuillez utiliser la balise <script> .
<script> 和</script> indiquent à JavaScript où commencer et se terminer.
Les lignes de code entre <script> 和</script> contiennent du JavaScript

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

1.5. méthodes de sortie JavaScript

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

Pour un usage personnel, console.log() est plus pratique à utiliser en programmation. Vous pouvez directement visualiser le contenu de sortie via la console F12

1.6.

1.7.Commentaire JavaScript

// Voici le code : un commentaire d'une seule phrase, généralement la touche ctrl + L de l'éditeur.
/* Voici le code*/ : commentaires sur plusieurs lignes, généralement ctrl + maj + L dans l'éditeur.

1.8.Quels sont les identifiants courants en JavaScript ?

1.9.Quels sont les événements HTML courants en JavaScript ?

1.10. Opérateurs JavaScript courants

1.11.Opérateurs d'affectation courants en JavaScript

1.12.Opérateurs de comparaison courants en JavaScript

1.13.Opérateurs logiques courants en JavaScript

2. Décrire en détail la syntaxe de base de JavaScript

2.1 Variables

2.1.1 Définir une variable

// Déclarer une variable nommée test. var test;

var age, name, sex;//Déclarez trois variables d'âge, nom et sexe

//Déclarez les variables en même temps et attribuez des valeurs var age = 10, name = "Xiaoqiang", sex = "1 ";

2.1.2. Règles et spécifications de dénomination des variables

1. Il se compose de lettres, de chiffres, de traits de soulignement et de symboles. Il ne peut pas commencer par un chiffre.
2. Les mots clés ne peuvent pas être utilisés, par exemple : while
3. Spécifications sensibles à la casse : méthode d'écriture conventionnelle
1. Les noms de variables doivent être significatifs.
2. Respectez la nomenclature des cas de chameau. La première lettre de la nomenclature des cas de chameau est en minuscule et la première lettre des mots suivants est en majuscule, comme userName

2.2.

Les types de données incluent : Number类型、String类型、Boolean类型、Undefined类型、Null类型、Object类型

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

2.2.1.Nombre

Type numérique : comprend des entiers et des décimales et peut être exprimé en : décimal, octal, hexadécimal,

tel que :

var num = 10 ; 
//Var décimal num1 = 012 ; 
//var octal num2 = ox123; 

Plage de valeurs

hexadécimales

console.log(Number.MAX_VALUE); 
//La valeur maximale est 5e-324console.log(Number.MIN_VALUE); 
//La valeur minimale est 1,7976931348623157e+308 Infini : Infini : -Le

jugement numérique à l'infini ne peut pas utiliser de décimales pour vérifier les décimales et n'utilise pas NaN pour vérifier s'il s'agit de NaN (NaN ---- pas un nombre) mais vous pouvez utiliser isNaN — n'est-ce pas Le résultat d'un nombre NaN ?
Tels que :

var num ; 
//Déclare une variable non affectée console.log(isNaN(num)); 
// N'est-ce pas vrai un nombre ? Le résultat est vrai

2.2.2.Caractère

d'échappement de chaîne de caractères :

, par exemple :

var str = "je suis un pm\"console.log(str); 
// je suis un pm

Concaténation de chaînes :

var str1 = "Mr.";var str2 = "Bonjour";console.log(str1+str2); 
// Bonjour monsieur,

si le résultat de l'épissage des chaînes et des nombres est également l'effet de l'épissage des chaînes comme indiqué ci-dessus

2.2.3.

Booléen Type booléen, les deux attributs true/false

. 2.2.4

Non défini, non défini signifie une variable qui a été. déclarée sans affectation, la variable Lorsqu'elle est uniquement déclarée, la valeur par défaut est indéfinie.
Par exemple :

var num;console.log(num); 
// non défini

2.2.5.Null

Null représente un null Si la valeur de la variable doit être nulle, elle doit être définie manuellement

2.2.6.Object

2.3 Conversion du type de données

2.3.1 Convertir en type numérique

(1). , Number() Toute valeur peut être convertie en valeur numérique S'il y a un caractère dans la chaîne à convertir qui n'est pas une valeur numérique, NaN est renvoyé.
Par exemple :

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() convertit en entier tel que :

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), convertissez parseFloat() en décimal, tel que :

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);

La différence entre (4), Number(), parseInt() et parseFloat()
Number() est plus strict que parseInt() et parseFloat().
parseInt() est similaire à parseFloat(), parseFloat analysera le premier lorsqu'il rencontrera le deuxième ou une fin non numérique.

2.3.2 Convertir en type de chaîne

(1), toString().
Par exemple :

var num = 10;console.log(num.toString()); 
// Chaîne 10

(2), Chaîne()
Par exemple :

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

(2), JSON.stringfy()

2.3.3 Convertir en booléen de type

0, chaîne vide, null, non définie, NaN sera converti en false, les autres seront convertis en true.
Par exemple :

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

2.4. Opérateur

Types d'opérateurs : opérateurs arithmétiques, opérateurs composés, opérateurs relationnels, opérateurs logiques

(1), opérateurs arithmétiques : "+" "-" "*" "/" "%"
Expressions arithmétiques : expressions reliées par des opérateurs arithmétiques.

Opérateurs composés : "+=""-=""*=""/=""%=".
Expressions d'opérations composées : expressions (3) reliées par des opérateurs composés

, opérateurs relationnels : ">""<"">=""<="" "" =""!=""!== "
Expression d'opération relationnelle : expressions reliées par des opérateurs relationnels

(4), opérateurs logiques : "&&" "||" !"

Expression 1 && Expression 2

connectées par des opérateurs logiques

Si l'un d'eux est faux, le résultat entier est faux

Expression 1 ||
Si l'un d'eux est vrai, tout le résultat est faux

! Le résultat de l'expression est vrai, et tout le résultat est faux.
Le résultat de l'expression est faux, et le résultat entier est vrai

2.5 La priorité des opérateurs

est de haut en bas :

() L'opérateur unaire de priorité la plus élevée ++ – !
Les opérateurs arithmétiques sont */% puis + -
Opérateurs relationnels > >= < <=
Opérateur d'égalité == != === !==
Les opérateurs logiques sont && suivi de ||
Opérateur d'affectation

2.6. Fonction

2.6.1 Introduction

Les fonctions en JavaScript sont des objets. Un objet est une collection de paires nom/valeur et possède une connexion cachée avec l'objet prototype. L'objet produit par le littéral d'objet est connecté à Object.prototype. Les objets de fonction sont connectés à Function.prototype (qui lui-même est connecté à Object.prototype). Chaque fonction aura deux attributs cachés attachés lors de sa création : le contexte de la fonction et le code qui implémente le comportement de la fonction

. 2.6.2 La fonction utilise

function functionname() {voici le code à exécuter}

Syntaxe :
Les parenthèses peuvent inclure des arguments séparés par des virgules :

(argument1, argument2, …)

Le code exécuté par la fonction est placé entre accolades : {}

nom de la fonction (argument1, argument2, argument3) {
    Code à exécuter}

Les paramètres de fonction sont les noms répertoriés dans la définition de la fonction.

de la

fonction sont les valeurs réelles reçues par la fonction lorsque la fonction est appelée

//Créez une fonction sumfunction ici sum(num1, num2) {.
    var résultat = num1 + num2 ;
    console.log("num1 + num2 = " + result);}// Appel de fonction sum(10, 20);

exécute la fonction immédiatement :

$(function(){
	//Pas seulement les fonctions, toutes les sorties de variables, etc. écrites ici sont des chargements de page et s'exécutent directement sum()})

Expressions régulières JavaScript

2.7.1 Créer

des littéraux d'expression régulière. Syntaxe : Reg = /pattern/modifiers; la régularité littérale se compose de deux barres obliques//, et la règle est écrite après la première barre oblique : /pattern[Les règles peuvent écrire divers métacaractères | mots set|assert...] . Après la deuxième barre oblique, écrivez l'identifiant /modifiers [g global match | i ignore case | m newline match |
var Reg = /boîte/gi;
Constructeur. Syntaxe Reg = new RegExp( pattern , modifiers ); modèle, les modificateurs sont des chaînes pour le moment. Quelle que soit la façon dont vous le créez, il s'agit du même modèle de modèle, du contenu correspondant et des modificateurs.

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

2.7.2. Description de la méthode d'expression régulière

spécifiée 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(arguments);
    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.Description de la méthode de l'objet RegExp

. 2.7.4 Modificateurs

Les modificateurs sont également appelés identifiants et peuvent spécifier des modèles de correspondance. Les modificateurs sont utilisés pour effectuer une correspondance globale et sensible à la casse.
j'ignore la correspondance de casse.
g correspond globalement Sans g, seul le premier élément est mis en correspondance et aucune correspondance n'est effectuée.
m effectue une correspondance multiligne

var patt = /pattern/i; //Ignore la correspondance de casse var patt = /pattern/g; //Correspondance globale var patt = /pattern/m; //Effectue une correspondance multiligne

2.7.5. Les caractères

sont des caractères spéciaux qui ont une signification particulière dans les expressions régulières.
Caractères de traduction spéciaux.

. Un seul caractère, sauf la nouvelle ligne n et la tabulation r. 
 Caractère d'échappement, symboles d'échappement ayant une signification particulière vers des symboles ordinaires : .d Nombres [0~9]D Non-chiffress EspacesS Non-espacesw Caractères [lettres|chiffres|trait de soulignement]W Non- caractère b limite de mot (sauf (mot) alphanumérique_ sont toutes des limites de mot) B limite de non-mot

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

2.8. Objets communs JavaScript

2.8.1 .Date object

Un objet Date est un objet lié à la date et à l'heure. Il est dynamique et vous devez utiliser le mot-clé new pour créer une instance, telle que :
var Mesdonnées=nouvelle Date();
L'objet Date ne fournit pas de propriétés d'accès direct, uniquement des méthodes pour obtenir et définir la date, comme indiqué dans le tableau suivant.

2.8.2. Objet String

L'objet String est un objet de traitement de chaîne fourni par JavaScript. Il ne peut être référencé qu'après avoir créé une instance d'objet. Il fournit des propriétés et des méthodes de traitement de chaînes (similaires à Java).
Longueur de la propriété : renvoie le nombre de caractères dans la chaîne.
Remarque : Un caractère chinois est aussi un caractère ! !

2.8.3.

Propriétés de l'objet mathématique :

Méthodes des objets mathématiques :

les fonctions trigonométriques (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) renvoient des valeurs en radians. Vous pouvez convertir des radians en degrés en divisant Math.PI/180 ou par d'autres méthodes.

Exemple 1 : Écrivez une fonction qui renvoie un entier aléatoire de min à max, incluant min mais excluant max

. , maximum) {
  return min + Math.random() * (max - min);}

Exemple 2 : Écrivez une fonction pour générer une chaîne aléatoire de longueur n La plage de valeurs des caractères de la chaîne comprend 0 à 9, a à z, A à Z.

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

Classification du

d'objets

1. Tableau bidimensionnel L'essence d'un tableau bidimensionnel est que les éléments du tableau sont également des tableaux.

2

de la colonne 2 et ligne 1 de a.

Un tableau clairsemé contient des valeurs à partir de 0 L'index non contigu de départ du tableau. Dans les tableaux clairsemés, la valeur de l'attribut length est généralement supérieure au nombre réel d'éléments (rare)
Exemple

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

Attribut d'objet tableau

attribut objet 1.length :

alert(arr.length); //Affiche la longueur du tableau 10arr.length=15; /Augmentez la longueur du tableau, l'attribut length est variable alert(arr.length ); //Montre que la longueur du tableau est devenue 15

2.attribut prototype

L'attribut prototype renvoie une référence au prototype du type d'objet. La propriété prototype est commune aux objets.
NomObjet.prototype
Le paramètre objectName est le nom de l'objet objet.
Description : utilisez l'attribut prototype pour fournir un ensemble de fonctions de base de la classe de l'objet. Les nouvelles instances d'un objet « héritent » des opérations assignées au prototype de l'objet.
Pour les objets tableau, utilisez l’exemple suivant pour illustrer l’utilisation de l’attribut prototype.
Ajoutez une méthode à l'objet tableau qui renvoie la valeur maximale de l'élément dans le tableau. Pour ce faire, déclarez une fonction, ajoutez-la à Array.prototype et utilisez-la.

fonction array_max( ){
   var je, max = ceci[0];
   pour (i = 1; i < this.length; i++){
       si (max < ceci[i])
       max = ceci[je];
   }
   return max;}Array.prototype.max = array_max;var x = new Array(1, 2, 3, 4, 5, 6);var y = x.max( );

3.attribut constructeur

L'attribut constructeur représente le créé fonction de l'objet.
object.constructor //object est le nom de l'objet ou de la fonction.
Description : l'attribut constructeur est membre de tous les objets dotés d'un prototype. Ils incluent tous les objets natifs JScript à l'exception des objets Global et Math. L'attribut constructeur contient une référence à la fonction qui construit une instance d'objet spécifique.

Par exemple :

x = new String("Hi");if (x.constructor == String) // Processus (la condition est vraie). //ou fonction MyFunc {// Corps de la fonction. }y = new MyFunc;if (y.constructor == MyFunc) // Processus (la condition est vraie).

Méthode objet tableau <br/> Description : Une partie de celle-ci est une nouvelle fonctionnalité d'ECMAScript5 (non prise en charge par IE678).

explique principalement certaines nouvelles fonctionnalités

concat
La fonction de concat est d'épisser des tableaux. Il convient de noter qu'un élément de tableau peut également être utilisé comme élément épissé. Dans ce cas, le tableau sera aplati puis épissé avec d'autres éléments pour former un nouveau tableau. , mais il ne sera pas aplati deux fois. concat ne modifie pas le tableau d'origine.

Par exemple :

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]]

tranche
slice (a, b) a et b peuvent prendre des nombres négatifs, ce qui signifie qu'un tableau est intercepté de la position a à la position b. C'est un intervalle fermé à gauche et ouvert à droite. A et b peuvent prendre des nombres négatifs. nombres. S'il s'agit d'un nombre négatif, cela signifie les derniers éléments 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 ]

épissure
splice supprime des éléments et ajoute de nouveaux éléments au tableau
object.splice(a) supprime un élément de la gauche
object.splice(a, b) intercepte les éléments b à partir de la position a
object.splice(a, b, c, d) intercepte les éléments b à partir de la position a et insère c et d ou plus d'éléments dans le tableau d'origine. Il convient de noter que splice modifiera le tableau d'origine

var arr=[1, 2 ,3,4,5];arr.splice(2);//[3,4,5]arr;//[1,2];Le tableau d'origine a été modifié 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]

;
La fonction foreach() parcourt le tableau du début à la fin. Il existe trois paramètres : les éléments du tableau, l'index des éléments et le tableau lui-même

var arr = [1, 2, 3, 4, 5]; elements , l'index de l'élément, le tableau lui-même console.log(x + '|' + index + '|' + (a === arr));});// 1|0|true// 2| 1|vrai/ / 3|2|vrai// 4|3|vrai// 5|4|vrai

réduire()
La fonction réduire() du tableau applique une fonction à [x1, x2, x3...] de ce tableau. Cette fonction doit recevoir deux paramètres. réduire() continue le résultat et effectue un calcul cumulatif avec l'élément suivant de la séquence. est :

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

var arr = [1, 2, 3];var somme = arr.reduce ( fonction(x, y) {
     return x + y}, 0); //Le paramètre 0 est facultatif. Si le paramètre 0 est écrit, les deux valeurs transmises pour la première fois sont 0 et 1. Sinon, les deux premières valeurs​​ passé pour la première fois sont les deux premières valeurs du tableau value, le résultat du calcul est 6arr; //[1, 2, 3]arr = [3, 9, 6];var max = arr. réduire (fonction (x, y) {
     console.log(x + "|" + y);
     return x > y ? x : y;});// 3|9// 9|6max; //

Comparaison de 9 tableaux et objets généraux

Comparaison des tableaux et des chaînes

2.9.JSON

2.9.1.stringify()

est

utilisé pour sérialiser les objets js en chaînes JSON.

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

En plus d'accepter des objets, stringify() Vous pouvez accepte également 2 paramètres. Le premier paramètre est un filtre, qui peut être une collection de tableaux de propriétés d'objet ou une fonction ; le deuxième paramètre est une option indiquant s'il faut conserver le

filtre de tableau indenté dans la chaîne JSON :

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

Filtre de fonction :

json=JSON.stringify(person,function(key,value){
    interrupteur (clé) {
        cas "nom":
           valeur de retour+",wang";
        cas "âge":
           retourner indéfini ;
        défaut:
           valeur de retour ;
    }});//{"name": "xiaoming,wang"}

Notez que si la fonction renvoie undéfini, cet attribut sera ignoré :

json

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

2.9.2.toJSON()

Ajoutez la méthode toJSON() à l'objet :

var person={
    nom: "xiaoming",
    âge:12,
    versJSON:fonction(){
        return this.name+" est "+this.age;
    }}json=JSON.stringify(person);console.log(json); //"xiaoming is 12"

2.9.3.parse()

En plus d'accepter une chaîne json, parse() peut également accepter un paramètre de fonction. Cette fonction accepte 2 valeurs, une clé et une valeur ;

var person=JSON.parse('{"name":"xiaoming","age":12}');var person=JSON.parse('{"name " :"xiaoming","age":12}',fonction(clé,valeur){
    si(key=="âge"){
        valeur de retour +10 ;
    }
    autre{
        valeur de retour ;
    }});

2.10.Ajax

2.10.1. Étapes de création :

1. Créer un objet asynchrone XMLHttpRequest.
2. Définissez la méthode de demande et l'adresse de la demande
3. Ensuite, utilisez send pour envoyer la demande
4. Surveiller les changements de statut
5. Enfin, recevez les données renvoyées

Exemple :

const xhr = new XMLHttpRequest()xhr.open('GET', './data/test.json', true)xhr.onreadystatechange = function () {
  si (xhr. readyState === 4) {
    si (xhr.status === 200) {
      console.log(JSON.parse(xhr.responseText))
    } autre {
      console.log('Autres situations...')
    }
  }}xhr.send()

2.10.2.Application Ajax dans jQuery

$.ajax({
                    type : "post", //URL de la méthode de requête : "a.php", //L'adresse du lien du serveur dataType : "json", //Le format de transmission et de réception des données data :{
                        nom d'utilisateur:"james",
                        mot de passe : "123456"
                    },
                    success:function(data){//Function console.log(data) appelée lors de la réception réussie des données;//data sont les données renvoyées par le serveur},
                    error:function(request){//La fonction appelée lors de l'échec de la demande de données alert("Une erreur s'est produite :"+request.status);
                    }});

2.10.3.Structure

de la méthode GET

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

Explication du paramètre :

//Étape 1 : Créer un objet asynchrone var ajax = new XMLHttpRequest(); //Étape 2 : Définir les paramètres d'URL de la requête. Le premier paramètre est le type de requête et le deuxième paramètre est l'urlajax.open demandé. "get", "users.json");//Étape 3 : Envoyer une requête ajax.send();//Étape 4 : Enregistrez l'événement onreadystatechange Lorsque l'état change, ajax.onreadystatechange = function () {.
    si (ajax.readyState == 4 && ajax.status == 200) {
        //Étape 5 : Si vous pouvez saisir ce jugement, cela signifie que les données ont été parfaitement renvoyées et que la page demandée existe console.log(ajax.responseText); //Entrez le contenu de la réponse}}

; Méthode POST

Elle a la même structure et la même utilisation que la méthode $.get(), mais il existe encore quelques différences entre elles.

2.10.5 Différences entre get et post

1. Post est plus sûr que get si demandé en mode get ; les paramètres de la requête seront collés à l'arrière de l'URL, la sécurité est faible lors d'une demande en mode post, les paramètres de la requête seront encapsulés dans le corps de la requête, ce qui est plus sécurisé.
2. Différence de quantité : la quantité de données transmises par la méthode get est faible et ne peut pas dépasser 2 Ko, tandis que la quantité de données demandée par la méthode post est importante et il n'y a pas de limite.
3. Vitesse de transmission : la vitesse de transmission de get est supérieure à celle de la poste.
Parce que la méthode d'utilisation est la même, tant que la fonction jQuery est modifiée, le programme peut être basculé entre les requêtes GET et les requêtes POST

2.11.Cookie

2.11.1.js fonction d'opération de lecture de cookie

getCookie(c_name){ if (document.cookie . length>0){ //Vérifiez d'abord si le cookie est vide, retournez "" c_start=document.cookie.indexOf(c_name + "=") //Vérifiez si le cookie existe via indexOf(). de l'objet String. S'il n'existe pas, il vaut -1 if (c_start!=-1){ c_start=c_start + c_name.length+1 //Le dernier +1 représente en fait le nombre "=", obtenant ainsi le position de départ de la valeur du cookie c_end= document.cookie.indexOf(";",c_start) //En fait, j'étais un peu étourdi lorsque j'ai vu pour la première fois le deuxième paramètre de indexOf(). Plus tard, je me suis souvenu que cela signifiait le début spécifié. position d'index...Cette phrase sert à obtenir la position finale de la valeur. Parce que vous devez déterminer s'il s'agit du dernier élément, vous pouvez juger si le signe ";" existe si (c_end==-1) c_end=document.cookie.length　
return unescape(document.cookie.substring(c_start,c_end)) //La valeur est obtenue via substring(). Si vous voulez comprendre unescape(), vous devez d'abord savoir ce que fait escape(). C'est une base très importante. Si vous voulez en savoir plus, vous pouvez également effectuer une recherche. l'article} } return "" }

2.11.2 .Opération de stockage simple des cookies

$.cookie("groupCode",222)

2.11.3.Définition du délai d'expiration du

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

2.11.4 .Modification du cookie

document.cookie = "username=zhangsan ";document.cookie = "username=lisi";var cookies = document.cookie;console.log(cookies);

2.11.5.Suppression du cookiedocument.cookie

= "username=zhangsan" ";document.cookie = "username=; expires=Jeudi 1er janvier 1970 00:00:00 GMT";var cookies = document.cookie;console.log(cookies);

2.12. Boucle

2.12.1. for boucle

for is la boucle la plus couramment utilisée, principalement utilisée pour boucler des tableaux

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()

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

le rappel est une fonction exécutée pour chaque élément du tableau. La fonction reçoit trois paramètres, currentValue (l'élément actuel en cours de traitement dans le tableau), index (l'index de l'élément actuel en cours de traitement dans le tableau). ), array (le tableau sur lequel la méthode forEach() opère)

thisArg est la valeur utilisée comme ceci lorsque la fonction de rappel est exécutée.

let arr = [1, 2, , 3]let arrCopy1 = []arr.map((élément, index, arr) => {
     arrCopy1.push(item * 2)})console.log(arrCopy1)// [2, 4, 6]

forEach() exécute la fonction de rappel une fois pour chaque élément du tableau. Les éléments supprimés ou non initialisés seront ignorés (par exemple sur les tableaux clairsemés). )
Contrairement à map() et réduire(), il n'a pas de valeur de retour et renvoie toujours undefind.
ForEach() n'a aucun moyen d'abandonner ou de sortir de la boucle forEach() autre que lancer une exception.

2.12.3.while

L'instruction while peut exécuter une boucle pour exécuter un morceau de code spécifié en partant du principe qu'une certaine expression conditionnelle est vraie, jusqu'à ce que la boucle se termine lorsque cette expression n'est pas vraie.

Exemple :

let n = 0 while (n <. 3) {
  n++;}console.log(n);//résultat attendu : 3Remarque

 : utilisez l'instruction break pour arrêter la boucle avant que le résultat de l'évaluation de la condition ne soit vrai.

2.12.4.do…while

L'instruction do…while crée une boucle qui s'exécute. l'instruction spécifiée jusqu'à ce que la valeur de la condition soit fausse. Détecter la condition après l'exécution de l'instruction, afin que l'instruction spécifiée soit exécutée au moins une fois

Exemple :

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

2.12.5.for…in

La boucle for…in peut être utilisée pour parcourir la liste d'attributs énumérables de l'objet (y compris la chaîne [[Prototype]]) et

est principalement utilisé pour parcourir l'objet, la valeur de l'attribut peut être obtenue via la liste d'attributs

pour (laisser la propriété dans l'objet) {
  console.log(propriété) //nom de la propriété
  Console.log (objet [propriété]) // Valeur de la propriété}

Recommandations connexes: Tutoriel d'apprentissage JavaScript

Ce qui précède est un résumé détaillé des points de connaissances d'apprentissage JavaScript.