请输入关键字进行搜索...

程序员鸡皮

文章 分类 评论
60 3 9
联系我
the theme is by @冷文学习者

站点介绍

一名PHP全栈程序员的日常......

重学Javascript基础（六）JavaScript函数的使用

abzzp 2024-10-02 166 0条评论 前端 JavaScript

首页 / 正文
本站是作为记录一名北漂程序员编程学习以及日常的博客，欢迎添加微信BmzhbjzhB咨询交流......

发布于2024-07-04

01.foo等名词的理解

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    

    <script>
        // stackover flow:程序问答网站
        var foo = "xxxxxx"
        function bar(){

        }
        var baz = {
            
        }
    </script>
</body>
</html>

02.函数的声明和调用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 声明一个函数
        // 制作好一个工具，但是这个工具默认情况下是没有被使用
        function SayHello(){
            console.log("Hello!")
            console.log("My name is Coderwhy!")
            console.log("how do you do!")
        }

        // 调用一个函数
        sayHello()
        // 函数可以在任何你想要使用的时候，进行调用
        sayHello()
    </script>
</body>
</html>

03.函数的使用练习

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 练习一：定义一个函数，打印自己的个人信息
        function printInfo(){
            console.log("my name is why")
            console.log("age is 18")
            console.log("height is 1.88")
        }

        printInfo()
        printInfo()

        // 练习二：定义一个函数，在内部计算10和20的和
        function sum(){
            var num1 = 10
            var num2 = 20
            var result = num1 + num2
            console.log("result:",result)
        }

        sum();
    </script>
</body>
</html>

04.函数的参数使用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // name/age/height 称之为函数的参数(形参，形式参数，parmaters)
        function printInfo(name,age,height){
            console.log(`my name is ${name}`)
            console.log(`age is ${age}`)
            console.log(`height is ${height}`)
        }

        // function printInfo(name,age,height){
        //     console.log("my name is"+name)
        //     console.log("age is "+age)
        //     console.log("height is "+height)
        // }

        // why/18/1.88称之为函数的参数（实参,实际参数,arguments)
        printInfo("why",18,1.88)
        printInfo("kobe",30,198)

        // 另外一个案例也做一个重构
        function sum(num1,num2){
            var result = num1 + num2
            console.log("result:",result)
        }

        sum(20,30)
        sum(123,321)
        
    </script>
</body>
</html>

05.函数的参数练习

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 练习一：和某人打招呼
        function sayHello(name){
            console.log(`Hello ${name}`)
        }

        sayHello("Kobe")
        sayHello("James")
        sayHello("Curry")

        // 练习二：给某人唱生日歌
        function singBirthdaySong(name){
            console.log("happy birthday to you")
            console.log("happy birthday to you")
            console.log("happy birthday to "+name)
            console.log("happy birthday to you")
        }

        singBirthdaySong("Kobe")
        singBirthdaySong("Why")
    </script>
</body>
</html>

06.函数的返回值使用

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        var result = prompt("请输入一个数字：")
        // 1.理解函数的返回值
        function sayHello(name){
            console.log(`Hi ${name}`)
        }

        var foo = sayHello("Kobe")
        console.log("foo:",foo)

        // 2.返回值的注意事项
        // 注意事项一：所有函数，如果没有写返回值，那么默认返回undefined
        function foo(){
            console.log("foo函数被执行~")
        }

        var result = foo()
        console.log("foo的返回值：",result)

        // 注意事项二：我们也可以明确的写上return
        // 写上return关键字，但是后面什么内容也没有的时候，也是返回undefined
        function bar(){
            console.log("bar函数被执行~")
            return
        }
        var result = bar();
        console.log("bar的返回值：",result)

        // 注意事项三：如果在函数执行到return关键字时，函数会立即停止执行，退出函数
        function baz(){
            console.log("Hello Baz")
            return
            console.log("Hello World")
            console.log("Hello why")
        }
        baz()

        // 函数的具体返回值
        function sum(num1,num2){
            var result = num1 + num2
            return result
        }

        var total = sum(20,30)
        console.log("total:",total)
    </script>
</body>
</html>

07.函数的练习

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 练习二：传入宽高，返回面积
        function getRectangleArea(width,height){
            return width * height
        }

        var area1 = getRectangleArea(20,30)
        var area2 = getRectangleArea(50,60)
        console.log("area1:",area1)
        console.log("area2:",area2)

        // 练习三：传入半径radius，计算圆形的面积
        function getCircleArea(radius){
            return Math.PI * radius * radius
        }
        var area3 = getRectangleArea(10)
        var area4 = getRectangleArea(25)
        console.log("area3:",area3)
        console.log("area4:",area4)

        // 练习四：传入一个数字n，计算1~n的数字和
        function sumN(n){
            // 1.加对n的判断
            if(n <= 0){
                console.log(`您传入的${n}是有问题的`)
                return
            }

            // 2.整正对1~n的数字进行计算
            // 1~n的数字和
            // 1~5 1 2 3 4 5
            var total = 0
            for(var i=1;i<=n;i++){
                total += i 
            }
            return total
        }

        var result1 = sumN(5)
        var result2 = sumN(10)
        console.log(`result1:${result1},result2:${result2}`)

        var result3 = sumN(-10)
        console.log("result3:",result3)
    </script>
</body>
</html>

08.数字格式化的函数练习

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 从服务器拿到很多的数字
        var playCount1 = 13687 // 13687
        var playCount2 = 5433322 // 543万
        var playCount3 = 8766633333 // 87亿

        // 封装一个工具函数：对数字进行格式化
        // 10_0000_0000就是1000000000语法糖
        // 语法糖的概念：一种简写或者特殊的写法，这种写法相对于原有的写法更加的方便或者阅读性更强
        // 相比于原来的写法，有一点点的甜头，称之为语法糖
        function formatCount(count){
            var result = 0
            if(count >= 10_0000_0000){
                // 超过10_0000_0000值进行转换
                result = Math.floor(count / 10_0000_0000) + "亿"
            }else if(count >= 10_0000){
                result = Math.floor(count / 1_0000) + "万"
            } else {
                result = count
            }

            return result
        }
 
        console.log(formatCount(playCount1))
        console.log(formatCount(playCount2))
        console.log(formatCount(playCount3))
    </script>
</body>
</html>

09.函数中arguments变量

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 1.arguments的认识
        function foo(name,age){
            console.log("传入的参数",name,age)

            // 在函数中都存在一个变量，叫arguments
            console.log(arguments)
            // arguments是一个对象
            console.log(typeof arguments)
            // 对象内部包含了所有传入的参数
            console.log(arguments[0])
            console.log(arguments[1])
            console.log(arguments[2])
            console.log(arguments[3])

            // 对arguments来进行遍历
            for(var i = 0;i<arguments.length;i++){
                console.log(arguments[i])
            }
        }

        foo("why",18,1.88,"广州市")

        // 2.arguments的案例
        function sum(){
            var total = 0
            for(var i =0;i<arguments.length;i++){
                var num = arguments[i]
                total += num
            }
            return total
        }

        console.log(sum(10,20))
        console.log(sum(10,20,30))
        console.log(sum(10,20,30,40))
    </script>
</body>
</html>

10.函数中调用函数

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        function bar(){
            console.log("bar函数被执行了~")
            console.log("--------")
        }
        function foo(){
            // 浏览器默认提供给我们的其他函数
            console.log("foo函数执行")
            console.log("Hello World")
            alert("Hello Coderwhy")

            // 调用自己定义的函数
            bar()

            // 其他代码
            console.log("other coding")
        }

        foo()
    </script>
</body>
</html>

11.递归-递归函数的认识

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        function bar(){

        }

        // 递归调用
        // 默认情况下会产生无线调用的情况
        function foo(){
            console.log("foo函数被执行了")
            foo()
        }

        foo()
    </script>
</body>
</html>

12.递归-递归的案例

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 需求：封装一个函数，函数可以实现x的n次方法
        function pow1(x,n){
            return x ** n
        }
        
        console.log(pow1(2,3))
        console.log(pow1(3,3))

        console.log(Math.pow(2,3))
        console.log(Math.pow(3,3))

        // 一.for 循环实现方式
         // x² = x * x
        // x³ = x * x * x
        function pow2(x,n){
            var result = 1
            for(var i = 0;i<n ;i++){
                result *= x
            }
            return result
        }

        console.log(pow2(2,3))
        console.log(pow2(3,3))

        // 二.递归实现方式（必须有一个结束条件）
        // 优点：写出来的代码比较简介
        // 缺点：性能比较低（占用过多栈内存）
        function pow(x,n){
            return x * pow(x,n-1)
        }
        console.log(pow(2,3))
        console.log(pow(3,3))
        
    </script>
</body>
</html>

13.递归-实现斐波那契数列(了解)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 什么是斐波那契数列
        // 数列：1 1 2 3 5 8 13 21 34  55  ... x
        // 位置：1 2 3 4 5 6 7  8   9  10  ... n

        // 1.斐波那契的递归实现
        function fibonacci(n){
            if(n === 1 || n === 2) return 1
            return fibonacci(n-1) + fibonacci(n-2)
        }

        // 2.斐波那契的for循环实现
        function fibonacci(n){
            // 特殊的情况（前两个数字）
            if(n === 1 || n === 2) return 1
            // for循环的实现
            var n1 = 1
            var n2 = 1
            var result = 0
            for(var i = 3;i<=n;i++){
                result = n1 + n2
                n1 = n2
                n2 = result
            }
            return result
        }

        console.log(fibonacci(5))
        console.log(fibonacci(10))
        console.log(fibonacci(20))
        
    </script>
</body>
</html>

14.理解作用域的概念

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 1.作用域的理解：message在哪一个范围可以被使用，称之为message的作用域（scope）
        // 全局变量：全局作用域
        var message = "Hello World"
        if(true){
            console.log(message)
        }
        function foo(){
            console.log("在foo中访问",message)
        }
        foo()

        // 2.es5前是没有块级作用域（var定义的变量是没有块级作用域）
        {
            var count = 100
            console.log("在代码块中访问count:",count)
        }
        console.log("在代码块外面访问count：",count)
        // for循环的代码也是没有自己的作用域
        for(var i = 0;i<3;i++){
            var foo = "foo"
        }
        console.log("for循环外面访问foo：",foo)
        console.log("for循环外面访问i:",i) // 3

        // 3.ES5之前函数代码块是会形成自己的作用域
        // 意味着在函数内部定义的变量外面是访问不到的
        function test(){
            var bar = "bar"
        }
        test()
        // console.log("test函数外面访问bar:",bar)
        // 函数有自己的作用域：函数内部定义的变量只有函数内部能访问
        function sayHello(){
            var nickname = "kobe"
            console.log("sayHello函数的内部：",nickname)
            function hi(){
                console.log("hi function~")
                console.log("在hi函数中访问nickname：",nickname)
            }
            hi()
        }

        sayHello();
        console.log("sayHello外面访问nickname：",nickname)
    </script>
</body>
</html>

15.概念-全局-局部-外部变量理解

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 1.全局变量（global variable)：在全局（script元素中）定义一个变量，
        // 那么这个变量是可以在定义之后的任何范围内被访问的，那么这个变量就称之为是一个全局变量
        var message = "Hello World"

        // 在函数中访问message
        function sayHello(){
            // 外部变量（outer variable）：在函数内部去访问函数之外的变量，访问的变量称之为外部变量
            console.log("sayHello中访问message：",message)

            // 2.局部变量（local variable）：在函数内部定义的变量，只有在函数内部才能精选访问，称之为局部变量
            var nickname = "coderwhy"

            function hi(){
                console.log("hi function~")
                // message 也是一个外部变量
                console.log("hi中访问message：",message)
                // nickname也是一个外部变量
                console.log("hi中访问nickname：",nickname)
            }
            hi()
        }

        sayHello()
    </script>
</body>
</html>

16.变量的访问顺序

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // var message = "Hello World"

        function sayHello(){
            // var message = "Hello Coderwhy"
            function hi(){
                var message = "Hi Kobe"
                console.log(message)
            }
            hi()
        }

        sayHello()
    </script>
</body>
</html>

17.函数表达式的写法

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 函数的声明（声明语句）
        foo()
        function foo(){
            console.log("foo函数被执行了~")
        }
        // 函数的表达式
        console.log(message) // undefined
        var message = "why"

        console.log(bar) 
        bar()
        var bar = function(){
            console.log("bar函数被执行了~")
        }
    </script>
</body>
</html>

18.Javascript的头等函数

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 函数作为一等（头等）公民
        // 1.函数可以被赋值给变量（函数表达式写法）
        var foo1 = function(){
            console.log("foo1函数被执行~")
        }
        foo1()

        // 2.让函数在变量之间来回传递
        var foo2 = foo1
        foo2()

        // 3.函数可以另外一个函数的参数
        function bar(fn){
            console.log("fn:",fn)
            fn()
        }
        bar(foo1)

        // 4.函数作为另外一个函数的返回值
        // functioin sayHello(){
        //     function hi(){
        //         console.log("hi kobe")
        //     }
        //     return hi
        // }

        // var fn = sayHello()
        // fn()

        // 5.将函数存储在另外一个数据结构中
        var obj = {
            name:"why",
            eating:function(){
                console.log("eating")
            }
        }
        obj.eating()
        function bar1(){
            console.log("bar1函数被执行~")
        }
        function bar2(){
            console.log("bar2函数被执行~")
        }
        function bar3(){
            console.log("bar3函数被执行~")
        }
        // 事件总线的封装
        var fns = [bar1,bar2,bar3]
        // 函数式编程：使用函数来作为头灯公民使用函数，这种编程方式（范式）
        // Javascript支持函数式编程
    </script>
</body>
</html>

19.回调函数的理解

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    
    <script>
        // 1.函数回调的理解
        function foo(fn){
            // 通过fn去调用bar函数的过程，称之为函数的回调
            fn()
        }
        function bar(){
            console.log("bar函数被执行了~")
        }
        foo(bar)

        // 2.函数回调的案例
        // function request(url,callback){
        //     console.log("根据URL向服务器发送网络请求")
        //     console.log("需要花费比较长的时间拿到对应的结果")
        //     var list = ["Javascript","Javascript练习","javascript高级编程"]
        //     callback(list)
        // }

        // function handleResult(res){
        //     console.log("在handleResult中拿到结果：",res)
        // }
        // request("url",handleResult)

        // 3.函数回调的重构案例
        function request(url,callback){
            console.log("根据URL向服务器发送网络请求")
            console.log("需要花费比较长的时间拿到对于的结果")
            var list = ["javascript","javascript学习","Javascript高级编程"]
            callback(list)
        }
        // 传入的函数是没有名字，匿名函数
        request("url",function(res){
            console.log("在handleResult中拿到结果：",res);
        })
    </script>
</body>
</html>

20.立即执行函数的演练

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        // 1.普通函数的使用过程
        function foo(){
            console.log("foo函数被执行~")
        }
        foo()
        foo(); // ()[]{}
        // 2.定义函数，定义完这个函数之后，会要求这个函数被立即执行
        // {} 代码块/对象类型
        // （） 控制优先级(2+3)*5/函数的调用/函数的参数
        // [] 定义数组/从数组-对象中取值/对象的计算属性
        // 立即执行函数（常用的写法）
        (function(){
            console.log("立即执行函数被调用~")
        })("why")
        console.log(result)
        
    </script>
</body>
</html>

21.立即执行函数的应用一

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script src="./js/xiaoming.js"></script>
    <script src="./js/lilei.js"></script>
    <script src="./js/xm_util.js"></script>

    <script>
        // 应用场景一：防止全局变量的名称冲突
        // 立即执行函数和普通的代码有什么区别？
        // 在立即执行函数中定义的变量是有自己的作用域的
        (function(){
            var message = "Hello World"
            // console.log(message)
        })()
        // console.log(message)
        // var message = "Hello World"
        // console.log(message)
    </script>
</body>
</html>
// js/lilei.js
(function(){
    var message = "Hello LiLei"
    console.log(message)
})()

// js/xiaoming.js
// esmodule -> import/export -> es5中立即执行函数
var xmModule = (function(){
    var xmModule = {}
    var message = "Hello XiaoMing"
    console.log(message)
    console.log(message.length)

    xmModule.message = message
    return xmModule
})()

// js/xm_util.js
(function(){
    console.log(xmModule.message)
})()

22.立即执行函数的应用二

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <button class="btn">按钮1</button>
    <button class="btn">按钮2</button>
    <button class="btn">按钮3</button>
    <button class="btn">按钮4</button>

    <script>
        // 慢慢来，反而是快的
        // 1.获取一个按钮监听点击
        // // 1.拿到html元素
        // var btnEl = document.querySelector(".btn")
        // console.log(btnEl)
        // // 2.监听对应按钮的点击
        // btnEl.onclick = function(){
        //     console.log("你点击了按钮1")
        // }

        // 2.获取所有的按钮监听点击
        // 没有使用立即执行函数
        debugger
        // var btnEls = document.querySelectorAll(".btn")
        // for(var i = 0;i<btnEls.length ;i++){
        //     var btn = btnEls[i];
        //     btn.onclick = function(){
        //         console.log(`按钮${i+1}发生了点击`)
        //     }
        // }

        // 使用立即执行函数
        var btnEls = document.querySelectorAll(".btn")
        for(var i = 0;i<btnEls.length; i++){
            var btn = btnEls[i];
            (function(m){
                btn.onclick = function(){
                    console.log(`按钮${m+1}发生了点击`)
                }
            })(i)
        }

        console.log(i)
    </script>
</body>
</html>

23.立即执行函数的其他写法(了解)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <button class="btn">按钮1</button>
    <button class="btn">按钮2</button>
    <button class="btn">按钮3</button>
    <button class="btn">按钮4</button>

    <script>
        // 慢慢来，反而是快的
        // 1.获取一个按钮监听点击
        // // 1.拿到html元素
        // var btnEl = document.querySelector(".btn")
        // console.log(btnEl)
        // // 2.监听对应按钮的点击
        // btnEl.onclick = function(){
        //     console.log("你点击了按钮1")
        // }

        // 2.获取所有的按钮监听点击
        // 没有使用立即执行函数
        debugger
        // var btnEls = document.querySelectorAll(".btn")
        // for(var i = 0;i<btnEls.length ;i++){
        //     var btn = btnEls[i];
        //     btn.onclick = function(){
        //         console.log(`按钮${i+1}发生了点击`)
        //     }
        // }

        // 使用立即执行函数
        var btnEls = document.querySelectorAll(".btn")
        for(var i = 0;i<btnEls.length; i++){
            var btn = btnEls[i];
            (function(m){
                btn.onclick = function(){
                    console.log(`按钮${m+1}发生了点击`)
                }
            })(i)
        }

        console.log(i)
    </script>
</body>
</html>

感谢大家观看，我们下次见

版权所属: abzzp
本文链接: https://xvzhu.cn/archives/51.html
协议授权: 《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》
下一篇 上一篇

评论(0)

最新评论

  • abzzp

    十天看一部剧，还可以吧[[呲牙]]

  • ab

    @梦不见的梦 行，谢谢提醒,我优化一下

  • 梦不见的梦

    网站的速度有待提升，每次打开都要转半天还进不来呢

  • abzzp

    @React实战爱彼迎项目(二) - 程序员鸡皮 哪里有问题了，报错了吗？[[微笑]]

  • abzzp

    @Teacher Du 那是怕你们毕不了业，我大学那会儿给小礼品[[发呆]]

  • Teacher Du

    我们大学那会，献血还给学分~

  • 夜

    @ab 我想去学网安，比如网警，但分也贼高😕

  • ab

    @夜 加油，你一样也可以成为程序员的，需要学习资料可以V我

  • 夜

    佬发布的好多技术文章似乎我只能评论这篇，真正的程序员！！哇塞 我也想去献血，过两年就成年了可以去献血了

日历

2024年11月

日一二三四五六
     12
3456789
10111213141516
17181920212223
24252627282930

标签云

vue JavaScript React Golang 观后感 ES6 读后感

友情链接

时光日志 云烟博客 boys博客 白雾茫茫丶

文章目录

推荐关键字： vue JavaScript React Golang 观后感 ES6 读后感

站点公告
本站是作为记录一名北漂程序员编程学习以及日常的博客，欢迎添加微信BmzhbjzhB咨询交流......
点击小铃铛关闭
配色方案
高贵黑
默认配色
墨蓝色
优雅白