js回顾

运算符

let n1 = 5;
    let n2 = 2;
    let res =  n1 / n2;
    console.log(res);

    res = parseInt(res);
    console.log(res);

    console.log(parseInt('12abc'));
    console.log(parseInt('12.5abc'));
    console.log(parseFloat('12.5.1abc888'));

    // 自增自减
    console.log(n1);

    // ++在前优先级最高，++在后优先级最低(比赋值符=还低)
    // res = n1++;  // 先将n1的值赋值给res，自己再自增1
    // res = ++n1;  // 先自己自增1, 再将n1的值赋值给res
    console.log(res, n1);


    // 逻辑运算符
    let x = 10;
    res = 0 && ++x;
    console.log(res, x);
    res = 100 || ++x;
    console.log(res, x);
    console.log(!!x);


    // 三元运算符
    // 条件 ? 结果1 : 结果2
    res = 10 == '10' ?  '相等' : '不等';
    console.log(res);

流程控制

 // 顺序、分支、循环
    `
    if (条件) {

    } else if (条件) {

    } else {

    }
    `;

    // 随机数 [0, 1) => [m, n]
    // [0, 1) * 11 => [0, 11) parseInt() => [0, 10] + 5 => [5, 15]
    // [0, 1) * (n - m + 1)  => [0, n - m + 1) parseInt() => [0, n - m] + m => [m, n]
    // 公式：parseInt(Math.random() * (max - min + 1)) + min
    let num = parseInt(Math.random() * (40 - 10 + 1)) + 10;
    console.log(num);

    if (num >= 30) {
        console.log('数字超过30');
    } else if (num >= 20) {
        console.log('数字超过20');
    } else {
        console.log('数字超过10');
    }

    // 循环
    `
    while (条件) {
        循环体
    }
    `;
    let count = 1;
    while (count <= 100) {
        if (count % 7 == 0) {
            console.log(count)
        }
        count++
    };

    `
    for (循环变量初始化①; 循环条件②; 循环增量③) {
        循环体④;
    }
    ① ②④③ ... ②④③ ②
    `;

    for (let i = 1; i <= 100; i++) {
        if (i % 11 == 0) {
            console.log(i)
        }
    }

    `
    do {

    } while (条件);
    `;

    count = 0;
    do {
        console.log('循环体一定会执行');
        count++;
    } while (count < 3);

函数

(function () {


    `函数的定义
    function 函数名(参数列表) {
        函数体;
        return 返回值
    }

    function：定义函数的关键字
    函数名：使用函数的依据，就是一个变量，可以赋值给其他变量，也可以存储在容器中，也可以作为函数的参数与返回值
    参数列表：都是按位置传，形参与实参个数不需要统一，但是一定是按位赋值 (你传你的，我收我的)
    函数体：完成功能的主体代码
    返回值：只能返回一个值
    `;

    function fn() {
        console.log('fn run');
        return [1, 2]
    }
    let res = fn();
    console.log(res);
    let func = fn;
    func();

    function my_fn(a, b) {
        console.log('参数', a, b)
    }
    my_fn();  // 你收我不传
    my_fn(10);  // 你收我传不够
    my_fn(10, 20, 30);  // 你收我传多


    `匿名函数
    function () {
        // 没有名字的函数就是匿名函数
    }
    `;
    // 需求需要一个函数地址，就可以传入一个匿名函数
    function fn100(fn) {
        fn()
    }
    fn100( function () { console.log('传进去的匿名函数') } )

    // 用变量接收匿名函数：第二种声明函数的方式
    let f = function (a, b) {
        console.log('ffffffffff')
    };
    f();

    // 为事件提供方法体
    hhh.onclick = function () {
        console.log('hhh 被点击了')
    };

    // 匿名函数自调用：一次性使用
    (function (a, b) {
        console.log('匿名函数自调用:', a, b)
    })(10, 20, 30);

    let abc = 10;

    hhh.onclick = function () {
        console.log(abc);
    };

})()

四种变量

    // if (true) {  // 块级作用域
    //     let a = 10;
    //     const b = 20;
    //     var c = 30;
    //     d = 40;
    // }
    {
        let a = 10;
        const b = 20;
        var c = 30;
        d = 40;
    }
    // console.log(a);  // 有{}就不能被外界访问
    // console.log(b);  // let和const有块级作用域，不允许重复定义
    // console.log(c);  // var没有块级作用域, 但有局部作用域，可以重复定义
    // console.log(d);  // 没有关键字声明的变量是全局变量，在函数内部声明的外部也可以用

    (function () {
        let aa = 100;
        const bb = 200;
        var cc = 300;
        dd = 400;
    })();
    console.log(dd);