Noções básicas de JavaScript aprenda comigo-day5

---

prefácio

Este artigo explica principalmente o uso de argumentos, o encapsulamento de funções, objetos, etc.;

---

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

Primeiro, o uso de argumentos

1. Apenas funções possuem objetos de argumentos, e cada função tem objetos de argumentos embutidos
2. Argumentos armazena todos os argumentos passados
​​3. Argumentos são chamados de pseudo-arrays;

1. A diferença entre argumentos e matrizes

1. Possui a propriedade length dos elementos do array;
2. É armazenado da mesma forma que um array de acordo com o índice;
3. Não possui alguns métodos de um array real, como 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. Use argumentos para inverter os elementos do array;

Nota: Para os seguintes elementos do array de entrada, para argumentos, o número de elementos recebidos é 1. Para operar os dados internos dos elementos do array recebidos, você precisa de arguments[0], primeiro obtenha os elementos do array e, em seguida, execute a próxima operação nos elementos do array. ;

  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. Encapsulamento de funções

Para facilitar o uso das funções implementadas pelo código, você pode encapsular o fragmento de código que implementa uma determinada função na função usando return, e cada vez que você usá-lo, você pode passar diretamente os parâmetros formais para chamar a função .

2.1 Inversão de matriz empacotada

Implemente a inversão de um elemento de matriz; o
código é o seguinte (exemplo):

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 Encapsulando a classificação de bolhas

Organize os elementos internos dos elementos da matriz de entrada de pequeno para grande ou de grande para pequeno;

O código é o seguinte (exemplo):

 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 Encapsulamento para julgar programa de ano bissexto

Ano bissexto: divisível por 4 e não divisível por 100, ou divisível por 400

O código é o seguinte (exemplo):

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

3. Uma função chama outra função

Dentro de uma função pode-se chamar outra função definida;

O código é o seguinte (exemplo):

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

Quatro, duas maneiras de declaração de função

4.1 A palavra-chave function declara uma função

O código é o seguinte (exemplo):

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

4.2 Expressões de Função

Declare uma variável para passar uma função anônima para a variável; as expressões de função são declaradas da mesma forma que as variáveis, exceto que as variáveis ​​armazenam valores e as expressões de função armazenam funções;

O código é o seguinte (exemplo):

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

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

5. Escopo JavaScript (antes do ES6)

5.1 O papel do escopo

O escopo limita o escopo das variáveis ​​no código, de forma a garantir a confiabilidade do código, o mesmo nome de variável não terá conflitos de nomenclatura em escopos diferentes
Nota: ES6 somente possui escopo em nível de bloco;

5.1 Tipos de escopos

5.1.1 Escopo global

A tag de script inteira e os arquivos js individuais estão no escopo global.As
variáveis ​​no escopo local não podem ser acessadas no escopo global;

5.1.2 Escopo local

Dentro da função está o escopo local;

O código é o seguinte (exemplo):
num1 dentro da função a seguir e num1 fora não terá um conflito de nomenclatura;

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

6. Tipos de variáveis

6.1 Variáveis ​​globais

Variáveis ​​no escopo global
Nota: 1. Variáveis ​​não declaradas dentro de uma função também são variáveis ​​globais
2. Variáveis ​​no escopo externo não podem ser acessadas no escopo interno;

6.2 Variáveis ​​locais

As variáveis ​​no escopo local são chamadas de variáveis ​​locais;
Nota: 1. Os parâmetros formais da função também são chamados de variáveis ​​locais;
2. A função interna pode acessar as variáveis ​​da função externa

7. Cadeia de escopo JavaScript

Cadeia de escopo: Quando a função interna acessa as variáveis ​​da função externa, ela adota o princípio da proximidade e seleciona o valor da variável mais próxima da função interna;

O código é o seguinte (exemplo):

        var num = 10;

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

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

            }
            fun();
        }
        fn();

8. Pré-análise de JavaScript

O mecanismo js tem duas etapas para executar o código js: 1. Pré-analisar 2. Executar o código js;

8.1 Etapas de Preparação

8.1.1 Promoção variável

A promoção de variáveis ​​é promover todas as declarações de variáveis ​​para a frente do escopo atual; Nota: as operações de atribuição não são promovidas! ! !

8.1.2 Função de elevação

O içamento de função é elevar todas as declarações de função para a frente do escopo atual; Nota: as chamadas de função não são içadas! ! !

O código é o seguinte (exemplo):

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

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

        //     }

9. Objetos

Um objeto é uma coleção não ordenada de propriedades e métodos;

9.1 Como os objetos são criados

9.1.1 Literais de objetos criam objetos

O código é o seguinte (exemplo):

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

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

9.1.2 A nova palavra-chave cria um objeto

Objetos criados com a palavra-chave new usam diretamente o método de atribuição ao adicionar propriedades e métodos ao objeto;

O código é o seguinte (exemplo):

 // 利用 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 Construtores criam objetos

O construtor deve encapsular o objeto em uma função; as propriedades e métodos do objeto no construtor precisam ser adicionados com a palavra-chave this e quando o construtor é chamado, a palavra-chave new precisa ser adicionada;

O código é o seguinte (exemplo):

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

Nota: O construtor retorna automaticamente o objeto, não há necessidade de retornar;

9.2 Como usar objetos

9.2.1 Chamando Propriedades do Objeto

método um:

O código é o seguinte (exemplo):

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

Método Dois:

O código é o seguinte (exemplo):

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

9.2.2 Chamando métodos dentro de um objeto

O código é o seguinte (exemplo):

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

Nota: Não esqueça de adicionar () ao chamar o método dentro do objeto! ! !

9.3 A diferença entre as propriedades internas e métodos de objetos e variáveis ​​e funções

9.3.1 Diferenças entre propriedades e variáveis

Variável: 1. A variável é declarada e atribuída separadamente 2. Ela existe sozinha e o nome da variável é referenciado diretamente ao usá-la;

Atributos: 1. Os atributos não precisam ser declarados e dependem do objeto para existir 2. Quando usados, devem ser: object.attribute name;

9.3.2 A diferença entre métodos e funções

Semelhanças : todos eles executam um determinado pedaço de código para alcançar uma determinada função;
semelhanças e diferenças: a função é declarada e chamada separadamente, o método está dentro da função e depende do objeto para existir, e a nova palavra-chave deve ser adicionada ao ligar;

O código é o seguinte (exemplo):

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

            }
        }

        function fn() {
    
    

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

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

9.4 O processo de execução da palavra-chave do objeto new

O código é o seguinte (exemplo):

// 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 Atravessando objetos

Percorrer um objeto é semelhante a iterar sobre propriedades e métodos em um objeto;

O código é o seguinte (exemplo):

// 遍历对象 
        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