Les bases de JavaScript apprennent de moi-jour5

---

avant-propos

Cet article explique principalement l'utilisation des arguments, l'encapsulation des fonctions, des objets, etc. ;

---

提示：以下是本篇文章正文内容，下面案例可供参考

Tout d'abord, l'utilisation d'arguments

1. Seules les fonctions ont des objets arguments, et chaque fonction a des objets arguments intégrés
2. Les arguments stockent tous les arguments passés
3. Les arguments sont appelés pseudo-tableaux.

1. La différence entre les arguments et les tableaux

1. Il a la propriété length des éléments de tableau ;
2. Il est stocké de la même manière qu'un tableau selon l'index ;
3. Il n'a pas certaines méthodes d'un tableau réel ; comme pop(), push() , etc.;

   // arguments 的使用  只有函数才有 arguments对象  而且是每个函数都内置好了这个arguments
        // 作用: 里面存储了所有传递过来的实参
        function fn() {
    
    
            // console.log(arguments); // 里面存储了所有传递过来的实参  arguments = [1,2,3]
            // console.log(arguments.length);
            // console.log(arguments[2]);
            // 我们可以按照数组的方式遍历arguments
            for (var i = 0; i < arguments.length; i++) {
    
    
                console.log(arguments[i]);
            }
        }
        fn(1, 2, 3);
        fn(1, 2, 3, 4, 5);
        // 伪数组 并不是真正意义上的数组
        // 1. 具有数组的 length 属性
        // 2. 按照索引的方式进行存储的
        // 3. 它没有真正数组的一些方法 pop()  push() 等等

2. Utilisez des arguments pour inverser les éléments du tableau ;

Remarque : Pour les éléments de tableau d'entrée suivants, pour les arguments, le nombre d'éléments reçus est 1. Pour exploiter les données internes des éléments de tableau reçus, vous avez besoin d'arguments[0], obtenez d'abord les éléments du tableau, puis effectuez l'opération suivante sur les éléments du tableau. ;

  function reverse () {
    
    
            var newArr = [];
            for(var i = arguments[0].length - 1 ; i >= 0; i--){
    
    
                newArr[newArr.length] = arguments[0][i];
            }
            return newArr;
        }
        console.log(reverse([1,2,3,4,5]));

2. Encapsulation des fonctions

Afin de faciliter l'utilisation des fonctions implémentées par le code, vous pouvez encapsuler le fragment de code qui implémente une certaine fonction dans la fonction en utilisant return, et chaque fois que vous l'utilisez, vous pouvez directement passer les paramètres formels pour appeler la fonction .

2.1 Retournement de tableau compressé

Implémenter le retournement d'un élément de tableau ; le
code est le suivant (exemple) :

function reverse (arr){
    
    
            var newArr = [];
            for(var i = arr.length - 1; i >= 0; i--){
    
    
                newArr[newArr.length] = arr[i];
            }
            return newArr;            
        }
        console.log(reverse([1,2,3,4,5]));

2.2 Encapsulation du tri à bulles

Disposez les éléments internes des éléments du tableau d'entrée de petit à grand ou de grand à petit ;

Le code est le suivant (exemple) :

 function sort(arr){
    
    
            for(var i = 0 ;i < arr.length - 1; i++){
    
    
                for(var j = 0 ;j < arr.length - i -1; j++){
    
    
                    if(arr[j] > arr[j+1]){
    
    
                        var temp = 0;
                        temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
            return arr;
        }
        console.log(sort([1,4,6,2,8,0]));

2.3 Encapsulation pour juger du programme des années bissextiles

Année bissextile : divisible par 4 et non divisible par 100, ou divisible par 400

Le code est le suivant (exemple) :

//闰年：能被4整除且不能被100整除，或能被400整除
 function  isRunYear(year){
    
    
            return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
        }
        console.log(isRunYear(2000));

3. Une fonction appelle une autre fonction

A l'intérieur d'une fonction peut appeler une autre fonction définie ;

Le code est le suivant (exemple) :

 //在函数内部是可以调用另一个函数
        function fn1() {
    
    
            console.log(11);
            fn2(); // 在fn1 函数里面调用了 fn2 函数
        }
        fn1();

Quatre, deux façons de déclarer la fonction

4.1 Le mot clé function déclare une fonction

Le code est le suivant (exemple) :

// 1. 利用函数关键字自定义函数(命名函数)
        function fn() {
    
    
        }

4.2 Expressions de fonction

Déclarez une variable pour passer une fonction anonyme dans la variable ; les expressions de fonction sont déclarées de la même manière que les variables, sauf que les variables stockent des valeurs et les expressions de fonction stockent des fonctions ;

Le code est le suivant (exemple) :

// 2. 函数表达式(匿名函数) 
        // var 变量名 = function() {};
        var fun = function(aru) {
    
    
            console.log('我是函数表达式');
            console.log(aru);

        }
        fun('老师');
        // (1) fun是变量名 不是函数名  
        // (2) 函数表达式声明方式跟声明变量差不多，只不过变量里面存的是值 而 函数表达式里面存的是函数
        // (3) 函数表达式也可以进行传递参数

5. Portée JavaScript (avant ES6)

5.1 Le rôle de la portée

La portée limite la portée des variables dans le code, afin d'assurer la fiabilité du code, le même nom de variable n'aura pas de conflits de nommage dans différentes portées ;
Remarque : ES6 n'a qu'une portée au niveau du bloc ;

5.1 Types de portées

5.1.1 Portée mondiale

L'intégralité de la balise de script et les fichiers js individuels se trouvent dans la portée globale
. Les variables de la portée locale ne sont pas accessibles dans la portée globale ;

5.1.2 Portée locale

À l'intérieur de la fonction se trouve la portée locale ;

Le code est le suivant (exemple) :
num1 à l'intérieur de la fonction suivante et num1 à l'extérieur n'auront pas de conflit de nom ;

var num1 = 10;
        function fun(aru) {
    
    
            var num1 = 10; // num1就是局部变量 只能在函数内部使用
            num2 = 20;
        }
        fun();

6. Types de variables

6.1 Variables globales

Variables dans la portée globale
Remarque : 1. Les variables non déclarées à l'intérieur d'une fonction sont également des variables globales
2. Les variables dans la portée externe ne sont pas accessibles dans la portée interne ;

6.2 Variables locales

Les variables de la portée locale sont appelées variables locales ;
Remarque : 1. Les paramètres formels de la fonction sont également appelés variables locales ;
2. La fonction interne peut accéder aux variables de la fonction externe

7. Chaîne de portée JavaScript

Chaîne de portée : lorsque la fonction interne accède aux variables de la fonction externe, elle adopte le principe de proximité et sélectionne la valeur de la variable la plus proche de la fonction interne ;

Le code est le suivant (exemple) :

        var num = 10;

        function fn() {
    
     // 外部函数
            var num = 20;

            function fun() {
    
     // 内部函数
                console.log(num);

            }
            fun();
        }
        fn();

8. Pré-analyse JavaScript

Le moteur js comporte deux étapes pour exécuter le code js : 1. Pré-analyse 2. Exécuter le code js ;

8.1 Étapes de préparation

8.1.1 Promotion variable

La promotion des variables consiste à promouvoir toutes les déclarations de variables au premier plan de la portée actuelle ; Remarque : les opérations d'affectation ne sont pas promues ! ! !

8.1.2 Fonction levage

Le hissage de fonction consiste à hisser toutes les déclarations de fonction au premier plan de la portée actuelle ; Remarque : les appels de fonction ne sont pas hissés ! ! !

Le code est le suivant (exemple) :

 fun(); // 报错  坑2 
        var fun = function() {
    
    
                console.log(22);

            }
            // 函数表达式 调用必须写在函数表达式的下面
            // 相当于执行了以下代码
            // var fun;
            // fun();
            // fun = function() {
    
    
            //         console.log(22);

        //     }

9. Objets

Un objet est une collection non ordonnée de propriétés et de méthodes ;

9.1 Comment les objets sont créés

9.1.1 Les littéraux d'objet créent des objets

Le code est le suivant (exemple) :

// 1.利用对象字面量创建对象 {}
        // var obj = {};  // 创建了一个空的对象 
        var obj = {
    
    
                uname: '张三疯',
                age: 18,
                sex: '男',
                sayHi: function() {
    
    
                    console.log('hi~');

                }
            }
            // (1) 里面的属性或者方法我们采取键值对的形式  键 属性名 ： 值  属性值 
            // (2) 多个属性或者方法中间用逗号隔开的
            // (3) 方法冒号后面跟的是一个匿名函数

9.1.2 Le nouveau mot clé crée un objet

Les objets créés avec le nouveau mot-clé utilisent directement la méthode d'affectation lors de l'ajout de propriétés et de méthodes à l'objet ;

Le code est le suivant (exemple) :

 // 利用 new Object 创建对象
        var obj = new Object(); // 创建了一个空的对象
        obj.uname = '张三疯';
        obj.age = 18;
        obj.sex = '男';
        obj.sayHi = function() {
    
    
                console.log('hi~');

            }
            // (1) 我们是利用 等号 = 赋值的方法 添加对象的属性和方法
            // (2) 每个属性和方法之间用 分号结束
        console.log(obj.uname);
        console.log(obj['sex']);
        obj.sayHi();
        var obj1 = new Object();
        obj1.uname = 'mingren'
        obj1.age = '18';
        obj1.fn1 = function(){
    
    
            console.log('我是名人');
        }
        obj1.fn1();

9.1.3 Les constructeurs créent des objets

Le constructeur doit encapsuler l'objet dans une fonction ; les propriétés et les méthodes de l'objet dans le constructeur doivent être ajoutées avec le mot clé this, et lorsque le constructeur est appelé, le nouveau mot clé doit être ajouté ;

Le code est le suivant (exemple) :

// function 构造函数名() {
    
    
        //     this.属性 = 值;
        //     this.方法 = function() {}
        // }
        // new 构造函数名();

Remarque : Le constructeur renvoie automatiquement l'objet, pas besoin de revenir ;

9.2 Comment utiliser les objets

9.2.1 Appel des propriétés de l'objet

première méthode :

Le code est le suivant (exemple) :

 // (1). 调用对象的属性 我们采取 对象名.属性名 . 我们理解为 的
        console.log(obj.uname);

Deuxième méthode :

Le code est le suivant (exemple) :

 // (2). 调用属性还有一种方法 对象名['属性名']
        console.log(obj['age']);

9.2.2 Appel de méthodes à l'intérieur d'un objet

Le code est le suivant (exemple) :

(3) 调用对象的方法 sayHi   对象名.方法名()
 obj.sayHi();

Remarque : N'oubliez pas d'ajouter () lors de l'appel de la méthode à l'intérieur de l'objet ! ! !

9.3 La différence entre les propriétés et méthodes internes des objets et des variables et fonctions

9.3.1 Différences entre propriétés et variables

Variable : 1. La variable est déclarée et affectée séparément 2. Elle existe seule, et le nom de la variable est directement référencé lors de son utilisation ;

Attributs : 1. Les attributs n'ont pas besoin d'être déclarés et dépendent de l'objet pour exister 2. Lorsqu'ils sont utilisés, ils doivent être : objet.nom d'attribut ;

9.3.2 La différence entre les méthodes et les fonctions

Similitudes : ils exécutent tous un certain morceau de code pour réaliser une certaine fonction ;
similitudes et différences : la fonction est déclarée et appelée séparément, la méthode est à l'intérieur de la fonction et dépend de l'objet pour exister, et le nouveau mot-clé doit être ajouté lors de l'appel ;

Le code est le suivant (exemple) :

// 变量、属性、函数、方法的区别
        // 1.变量和属性的相同点 他们都是用来存储数据的 
        var num = 10;
        var obj = {
    
    
            age: 18,
            fn: function() {
    
    

            }
        }

        function fn() {
    
    

        }
        console.log(obj.age);
        // console.log(age);

        // 变量 单独声明并赋值  使用的时候直接写变量名 单独存在
        // 属性 在对象里面的不需要声明的 使用的时候必须是 对象.属性
        // 2. 函数和方法的相同点 都是实现某种功能  做某件事
        // 函数是单独声明 并且调用的 函数名() 单独存在的
        // 方法 在对象里面 调用的时候 对象.方法()

9.4 Le processus d'exécution du mot clé object new

Le code est le suivant (exemple) :

// new关键字执行过程
        // 1. new 构造函数可以在内存中创建了一个空的对象 
        // 2. this 就会指向刚才创建的空对象
        // 3. 执行构造函数里面的代码 给这个空对象添加属性和方法
        // 4. 返回这个对象
        function Star(uname, age, sex) {
    
    
            this.name = uname;
            this.age = age;
            this.sex = sex;
            this.sing = function(sang) {
    
    
                console.log(sang);

            }
        }
        var ldh = new Star('刘德华', 18, '男');

9.5 Traverser des objets

Parcourir un objet revient à parcourir les propriétés et les méthodes d'un objet ;

Le code est le suivant (exemple) :

// 遍历对象 
        var obj = {
    
    
                name: 'pink老师',
                age: 18,
                sex: '男',
                fn: function() {
    
    }
            }
            // console.log(obj.name);
            // console.log(obj.age);
            // console.log(obj.sex);
            // for in 遍历我们的对象
            // for (变量 in 对象) {
    
    

        // }
        for (var k in obj) {
    
    
            console.log(k); // k 变量 输出  得到的是 属性名
            console.log(obj[k]); // obj[k] 得到是 属性值

        }
        // 我们使用 for in 里面的变量 我们喜欢写 k  或者  key