Un résumé quotidien de l'apprentissage javascript (connaissances de base)_compétences javascript

1. Conversion de personnage

 var s1 = "01";
  var s2 = "1.1";
  var s3 = "z";//字母'z'无法转换为数字，所以或返回NaN
  var b = false;
  var f = 1.1;
  var o = { 
   valueOf: function() {
    return -1;
   }
  };
  
  s1 = -s1; //value becomes numeric -1
  s2 = -s2; //value becomes numeric -1.1
  s3 = -s3; //value becomes NaN
  b = -b;  //value becomes numeric 0
  f = -f;  //change to -1.1
  o = -o;  // 1 先执行对象的valueOf()方法返回-1,--1为1
　　　　o = +o;//-1 o的valueOf()值为-1，+-1还是-1

2. Opérations sur les caractères spéciaux

 var result1 = 5 - true; //4 because true is converted to 1
  var result2 = NaN - 1;  //NaN NaN不是一个数字，和任何数字做任何运算都是NaN
  var result3 = 5 - 3;  //2
  var result4 = 5 - "";  //5 because "" is converted to 0
  var result5 = 5 - "2";  //3 because "2" is converted to 2
  var result6 = 5 - null; //5 because null is converted to 0

3. Variable à opération de chaîne

 var value1 = 10;
  var value2 = true;
  var value3 = null;
  var value4;//value4 没有赋值就是underfined 转换为字符串就是'underfined'
  
  alert(String(value1));  //"10"
  alert(String(value2));  //"true"
  alert(String(value3));  //"null"
  alert(String(value4));  //"undefined"

4. Conversion de nombres

var num = 10;
  alert(num.toString());  //"10"默认十进制
  alert(num.toString(2));  //"1010"二进制
  alert(num.toString(8));  //"12"八进制
  alert(num.toString(10));  //"10"十进制
  alert(num.toString(16));  //"a"十六进制

5. Opération de comparaison de chaînes

var result1 = 5 > 3; //true
  var result2 = 5 < 3; //false
  var result3 = "Brick" < "alphabet"; //true 字符串比较按照字母表顺序进行比较 小写字母在大写字母后面
  var result4 = "Brick".toLowerCase() < "alphabet".toLowerCase(); //false字母表顺序比较
  var result5 = "23" < "3"; //true 字符2小于字符3
  var result6 = "23" < 3; //false 此时'23'转换成23了
  var result7 = "a" < 3; //false because "a" becomes NaN 字符'a'无法转换成数字
  var result8 = NaN < 3; //false NaN 和任何数字比较，都无法转换成数字，所以一直是false
  var result9 = NaN >= 3; //false

6. Conversion de caractères

  var num1 = parseInt("AF", 16);  //175 按照16进制输出十进制数据 10*16+15*1
  var num2 = parseInt("AF");   //NaN 没有指定进制，默认按照10进制转换，由于AF不在十进制范围，返回NaN

  alert(num1);
  alert(num2);

7. Utilisation de parseInt

  var num1 = parseInt("1234blue"); //1234
  var num2 = parseInt("");   //NaN 字符''无法转换成数字
   var num3 = parseInt("0xA");   //10 - hexadecimal 16进制的A
  var num4 = parseInt(22.5);   //22
  var num5 = parseInt("70");   //70 - decimal
  var num6 = parseInt("0xf");   //15 16进制为15

8. Utilisation des objets Nombre

  var num1 = Number("Hello world!"); //NaN
  var num2 = Number("");    //0 空字符串可以转换成0 这个parseInt()不一样
   var num3 = Number("000011");  //11
  var num4 = Number(true);   //1

9. Utilisation de NaN 

  alert(NaN == NaN);  //false
  alert(isNaN(NaN));  //true
  alert(isNaN(10));  //false ?10 is a number
  alert(isNaN("10"));  //false ?can be converted to number 10
  alert(isNaN("blue")); //true ?cannot be converted to a number
  alert(isNaN(true));  //false ?can be converted to number 1

10. Nombre maximum du système

var result = Number.MAX_VALUE + 1;
alert(isFinite(result)); // false

11. Infini

  alert(5 * 6);   //30
  alert(5 * NaN);   //NaN
  alert(Infinity * 0); //NaN
  alert(Infinity * 2); //Infinity
  alert("5" * 5);   //25
  alert(true * 10);  //10
  alert(false * 10);  //0
　　　　　　alert(26 % 5); //1
　　　　　　alert(Infinity % 3); //NaN
　　　　　　alert(3 % 0); //NaN
　　　　　　alert(5 % Infinity); //5
　　　　　　alert(0 % 10); //0
　　　　　　alert(true % 25); //1
　　　　　　alert(3 % false); //NaN

12. pour en boucle

for (var propName in window) {
    document.write(propName);
    document.write("<br />");
  }

13. Comparaison des caractères spéciaux

 alert(null == undefined); //true
  alert(null === undefined); //false
  
  alert("NaN" == NaN);  //false
  alert("NaN" === NaN);  //false
  alert(NaN == NaN);   //false
  alert(NaN === NaN);   //false
  alert(NaN != NaN);   //true
  alert(NaN !== NaN);   //true
  
  alert(false == 0);   //true
  alert(false === 0);   //false
  alert(true == 1);   //true
  alert(true === 1);   //false
  
  alert(null == 0);   //false
  alert(undefined == 0);  //false
  
  alert(5 == "5");   //true
  alert(5 === "5");   //false  

14. Objet booléen

 var message = "Hello world!";
  var messageAsBoolean = Boolean(message);
  
  alert(messageAsBoolean); //true

15. Utiliser la boucle for avec des balises
L'instruction break et l'instruction continue peuvent être utilisées conjointement avec des instructions étiquetées pour revenir à un emplacement spécifique dans le code.
Cela se fait généralement lorsqu'il y a une boucle à l'intérieur d'une boucle, par exemple :

 var num = 0;
  //返回到特定的位置
  outermost:
  for (var i=0; i < 10; i++) {
    for (var j=0; j < 10; j++) {
    if (i == 5 && j == 5) {
     break outermost;
    }
    num++;
   }
  }
  
  alert(num); //55

Dans l'exemple ci-dessus, l'étiquette la plus à l'extérieur représente la première instruction for. Normalement, chaque instruction for exécute le bloc de code 10 fois, ce qui signifie que num sera exécuté 100 fois dans des circonstances normales, et lorsque l'exécution est terminée, num devrait être égal à 100. L'instruction break a ici un paramètre, qui est l'étiquette de l'instruction à laquelle accéder après l'arrêt de la boucle. De cette façon, l'instruction break peut non seulement sortir de l'instruction for interne (c'est-à-dire l'instruction qui utilise la variable j), mais également sortir de l'instruction for externe (c'est-à-dire l'instruction qui utilise la variable i). Par conséquent, la valeur finale de num est 55, car la boucle se terminera lorsque les valeurs de i et j seront toutes deux égales à 5.
L'instruction continue peut être utilisée de la même manière :

var iNum = 0;

outermost:
for (var i=0; i<10; i++) {
 for (var j=0; j<10; j++) {
 if (i == 5 && j == 5) {
 continue outermost;
 }
 iNum++;
 }
}

alert(iNum); //输出 "95"

Dans l'exemple ci-dessus, l'instruction continue forcera la boucle à continuer, non seulement la boucle interne, mais également la boucle externe. Cela se produit lorsque j est égal à 5, ce qui signifie que la boucle interne sera réduite de 5 itérations, ce qui donnera à iNum une valeur de 95.

Astuce : Comme vous pouvez le constater, les instructions étiquetées utilisées conjointement avec break et continue sont très puissantes, mais leur utilisation excessive peut causer des problèmes lors du débogage de votre code. Assurez-vous que les étiquettes que vous utilisez sont descriptives et n'imbriquent pas trop de niveaux de boucles.

Ce qui précède est le résumé d'aujourd'hui de l'apprentissage de JavaScript, et il continuera à être mis à jour chaque jour. J'espère que vous continuerez à y prêter attention.