Lua基础知识入门

news2024/9/21 22:50:03

1 基础知识

标识符：标识符的定义和 C语言相同：字母和下划线_ 开头， 下划线_ + 大写字母一般是lua保留字， 如_VERSION
全局变量：默认情况下，变量总是认为是全局的，不需要申明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil

2 数据类型

数据类型：lua是动态型语言，变量不需要类型定义，直接赋值即可。 值可以存储在变量中，作为参数传递或者结果return
–nil: 无效值， 在条件表达式中相当于false
– boolean： true false, 注意： false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true
– number: 双精度类型的实浮点数 相当于double， 注意：Lua 默认只有一种 number 类型 – double（双精度）类型（默认类型可以修改 luaconf.h 里的定义）
– string：字符串，由一对双引号或者单引号表示
– funtcion: 由c或者lua编写的函数
– userdata：表示任意存储在变量中的c数据结构
– thread：表示执行的独立线路，用于执行协同程序
– table:Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。
– 在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。

–可以使用type函数测试给定变量或者值的类型：
print(type(“Hello world”))
print(type(66))
print(type(‘66’))
print(type(“66”))
print(type(nil))

2.1 多重赋值

Lua可以对多个变量同时赋值，变量用逗号分开，赋值语句右边的值会依次赋给左边的变量。

n = 1
a, b = 10, 2*n

2.2 交换变量

a = 34
b = 12
a, b = b, a
print(a, b) --输出：12   34

3 运算符

3.1 算数运算符

+ 加法
- 减法
* 乘法
/ 除法
% 取余，求出除法的余数
^ 乘幂，计算次方
- 负号，取负值

3.2 逻辑运算符

a = true
b = false
c = nil

print(a and b) -- 与  输出：false
print(a or b)  -- 或  输出：true
print(not a)   -- 非  输出：false

4 字符串相关

字符串的三种表示方式：

  1. 单引号间的一串字符
  2. 双引号间的一串字符
  3. [[…]] 间的一串字符, 支持换行

4.1 字符串操作

4.1.1字符串拼接： …

print("d"  ..  "cj")

4.1.2字符串转换

c = tostring(10) -- 数字 转 字符串 
print(c)

d = tonumber("666") --字符串转数字，若转换失败返回nil
print(d)

e = tonumber("abc")
print(e)

输出：
image.png

4.1.3 获取字符串长度

str = "dcj666"
print(#str)
print(#"dcj666")

输出：
image.png

5 函数

function lua_func_test(n)
    if 0 == n then
        print("0 == n")
        return 0
    else 
        print("1 == n")
        return n
    end
end

--这与上述是一样的
lua_func_test2 = function(n)
    if 0 == n then
        print("0 == n")
        return 0
    else 
        print("1 == n")
        return n
    end
end

ret = lua_func_test(5)
print(ret)

输出：
image.png

函数支持多值返回：

function lua_func_test_02(a, b, c)
    return a, b, c
end
local i, j, k = lua_func_test_02(11, 22, 33)
print(i, j, k)

输出：
image.png

6 Table

lua的table中可以放置任意类型的数据：如number，string，function等

6.1 数字下标：从 1 开始

注意：lua中数组下标从 1 开始

a = {112,  {}, function () end, "dcj"}
print(a[1])
print(#a) --获取table元素个数

a[1] = 666
print(a[1])

table.insert(a, 2, "666")  --在a[2]处插入"666"
local s = table.remove(a, 2)  --删除a[2]这个元素, 并将删除的元素返回给s

输出：
image.png

function做table的元素

funcList = {
    function(a, b) return a*b end,
    function(a, b) return a-b end,
    function(a) return (-a) end
}
print(funcList[1](3,4))
print(funcList[2](3,4))
print(funcList[3](3))

输出：
image.png

6.2 table下标：指定下标

前面例子中的table都只是一些简单的List（列表），每个元素的下标都是自动从1排列的
实际上，Lua中，下标可以直接在声明时进行指定，像下面这样：

t = {6,7,8,9}
--上面和下面的代码等价
t = {
    [1] = 6,
    [2] = 7,
    [3] = 8,
    [4] = 9,
}

--甚至你可以跳过某些下标
t = {
    [1] = 6,
    [3] = 7,
    [5] = 8,
    [7] = 9,
}
print(t[7]) --输出9

--在声明后赋予元素值也是可以的
t = {}--空的table
t[101] = 10
print(t[101]) --输出10

t = {
    [1] = 123,
    [13] = "abc",
    [666] = "666",
}

print("下标为1的元素:",t[1],type(t[1]))
print("下标为13的元素:",t[13],type(t[13]))
print("下标为666的元素:",t[666],type(t[666]))

输出：
下标为1的元素:  123     number
下标为13的元素: abc     string
下标为666的元素:        666     string

6.3 字符串做下标

前面学习的table下标都是数字，在lua中，下标也可以是字符串：

t = {
	a1 = "aa",
    ["666"] = "666", -- 666 = "666", 这样会报错
  	["apple"] = 10,
    banana = 12,
    pear = 6,
}
--使用["下标"] = 值  和  下标 = 值  都是正确写法, 当第二种方式有歧义时，应该用第一种方式

t["new"] = "new values" -- 也可以新增

--可以用下面两种方式访问：
print(t["apple"]) --输出10
print(t.apple) --输出10

print(t["666"]) --输出666
--print(t.666) --报错

print(t["banana"]) --输出12
print(t.banana) --输出12

print(t["new"]) --输出new values

t = {
    apple = {
        price = 7.52,
        weight = 2.1,
    },
    banana = {
        price = 8.31,
        weight = 1.4,
        year = '2018'
    },
    year = '2019',
    {
        price = 6.21,
        weight = 2.5,
    },
}

print(
    t.price,                --输出nil
    t.apple.price,          --输出7.52
    t.banana.weight,        --输出1.4
    t.year,                 --输出2019
    t[1].price,             --输出6.21
    t[1].weight             --输出2.5
)


print(  
    t["price"],             --输出nil
    t["apple"]["price"],    --输出7.52
    t["banana"]["weight"],  --输出1.4
    t["year"]               --输出2019
)

7 全局表 _G

lua中所有的全局变量都在** _G** 这个table中
例如定义一个全局变量a， 在_G这个table中打印出来：

dcj = 666;
print(_G["dcj"])

table自身也是个全局变量，也在_G中， 并且table.insert中的insert函数是table的下标，也可以将insert打印出来：

print(_G["table"])
print(_G["table"]["insert"])

输出：
image.png

8 boolean类型

注意：lua中只有false和nil表示假， 其余都为真(0也表示真)

a = true
b = false
c = nul

print(1 < 2)
print(1 > 2)
print(1 >= 2)
print(1 <= 2)
print(1 == 2)
print(1 ~= 2)  --  注意：~=表示不等于

print(a and b) -- 与 
print(a or b)  -- 或
print(not a)   -- 非

输出：
image.png

b = 1
print(b > 10 and "yes" or "no")

b = 11
print(b > 10 and "yes" or "no")

输出：no
yes

9 分支判断

a = 2

if a == 1 then
    print("a == 1")
elseif a == 2 then
    print("a == 2")
elseif a == 3 then
    print("a == 3")
else
    print(a)
end

if 0 then
	print("0 is true")
end

输出：
a == 2
0 is true

10 循环

10.1 for循环

image.png
临时变量名可以直接在代码区域使用（但不可更改），每次循环会自动加步长值，并且在到达结束值后停止循环。

for i = 1, 10, 2  do  -- 1表示循环储值，10表示结束值， 2表示步长, i的作用域仅仅在for循环内部
	print(i)
end

print(i) -- 输出nil，i的作用域仅仅在for循环内部

10.2 while循环

local n = 10

while n >= 1 do
	if n==5 then
		break --跳出循环
	end
	
	print(n)
	n = n - 1   -- lua 不支持 n-- 这种操作
end

输出：
image.png

11 迭代器

pairs和ipairs的区别：
:::info
同：都是能遍历集合（表、数组），两者均优先按顺序输出没有key的值；
:::
:::info
异：对于有key的集合：
ipairs从第一个数字key开始，依次输出所有的key+1的键值，遇到字符下标并不会结束遍历，只是不输出而已，如果遇到nil则退出；
pairs无序输出字符类型key或者数字类型key的键值，遇到nil不输出，但不会停止遍历；
:::

11.1 ipairs

t = {"aa", "bb", "cc", "dd", "ee"}

for i = 1, #t  do  --从下标1开始，到下标#t结束(#t表示t的元素个数)
	print(i, t[i])
end

--针对数字下标的数组，可以使用ipairs迭代器
--等同于下面
for i, j  in ipairs(t)  do  -- i表示下标， j存放下标i对应的值
	print(i, j)
end

输出：
image.png

t = {
	[1] = "aaaaaa",
	[2] = "bbbbbbb",
	[3] = "ccccccc",
	[5] = "ddddddddd"  --下标不连续，t[4]为nil，遇到nil会自动停止
}

for i, j  in ipairs(t)  do  -- i表示下标， j表示下标i对应的值
	print(i, j)
end

for i, j  in pairs(t)  do  -- i表示下标， j表示下标i对应的值
	print(i, j)
end

输出：
image.png
结论：
1、ipairs会按照key的顺序输出数据，遇到不连续的数据停止输出；
2、pairs会无序输出所有数据；

table = { 
    [3] = "test3",
    ["test"] = "val1",
    "val3" ,
    [4] = "val2",
    "val4"
}
print("-----------ipairs----------------")
for k,v in ipairs(table) do
    print(k,v)
end
print("-----------pairs----------------")
for k,v in pairs(table) do
    print(k,v)
end

image.png
结论：
1、pairs和ipairs均优先输出没有key的value；
2、pairs会输出所有的数据，不带key的值按顺序输出，带key的值无序输出；
3、ipairs会跳过字符串的key，按顺序输出数字型key的值；

table = { 
    [6] = "test3",
    ["test"] = "val1",
    "val3" ,
    [11] = "val2",
    nil,
    "val4"
}
print("-----------ipairs----------------")
for k,v in ipairs(table) do
    print(k,v)
end
print("-----------pairs----------------")
for k,v in pairs(table) do
    print(k,v)
end

输出：
image.png
结论：
1、ipairs遇到nil会停止输出；
2、pairs遇到nil不会停止输出；

11.2 pairs

针对字符串做数组下标的数组迭代，使用pairs迭代器

t = {
	apple = "aa",
	banana = "bb",
	water = "cc",
}
for i, j  in pairs(t)  do  -- i表示下标， j存放下标i对应的值
	print(i, j)
end

输出：
image.png

12 多文件调用require

require:

  1. 运行指定文件
  2. 末尾不带拓展名
  3. 目录层级用“.”分隔
  4. 只会运行一次
  5. 从package.path中的路径里查找

13 元表、面向对象

t =     {
    a = 66,
}
mt = {
    __add = function(a, b)
        return a.a + b
    end,
    __index = function(table, key)
        return 123
    end
}
setmetatable(t, mt)
print(t+1) --输出67
print(t["dcj"]) --访问一个不存在的下标，会调用__index元方法， 输出123



t = {
    a = 66,
}
mt = {
    __add = function(a, b)
        return a.a + b
    end,
    __index = {
        abc = 123,
        def = 456,
    },
}
setmetatable(t, mt)
print(t["dcj"]) --__index也可以是个table, 在__index也可以是个table找“dcj”元素，输出nil
print(t["abc"]) --__index也可以是个table, 在__index也可以是个table找“abc”元素, 输出123
print(t["def"]) --__index也可以是个table, 在__index也可以是个table找“def”元素, 输出456

image.png

13.1 语法糖：

t = {
    a = 66,
    add = function(tab, sum)
        tab.a = tab.a + sum
    end,
}

t:add(10) -- 等价于 t.add(t, 10), 输出：76
print(t.a)

13.2 面向对象

需要好好理解！！！

bag = {

}
bagmt = {
    put = function(t, item)
        table.insert(t.items, item)
    end,
    take = function(t)
        return table.remove(t.items, item)
    end,
    list = function(t)
        return table.concat(t.items, ", ")
    end,
    clear = function(t)
        t.items = {}
    end,
}
bagmt["__index"] = bagmt
function bag.new()
    local t = {
        items  = {}
    }
    setmetatable(t, bagmt) --当调用t中不存在的函数的时候，就回去t的metatable中去找
    return t
end

--bag.new()函数中会新建一个表t，t设置了元表bagmt， bagmt中有四个元方法(put，take,list，clear)
--由于b中没有put这些方法，所以回去bagmt中找
local b = bag.new()
b:put("apple1") --等价于b.put(b, "apple1")， 将"apple1"放入b的items表中 
b:put("apple2")
b:put("apple3")
b:put("apple4")

print(b:take())

print(b:list())

14 数据打包和解包

aaa = 0x11223344
bbb = 0x55667788

data = string.pack(">LL", aaa, bbb)  --数据打包

print("len:", #data)

for i=1, #data do
    print(i, data:byte(i))
end

a, b = string.unpack(">LL", data)  --数据解包
str_a = string.format("0x%x", a)
str_b = string.format("0x%x", b)

print("str_a: ", str_a)
print("str_b: ", str_b)

输出：
image.png

15 C语言与lua的相关调用

15.1 C语言中调用lua

c代码只需要编译一次，lua可以随时改动；因为lua是动态语言。嵌入lua的好处是c只需要写一次代码，编译一次程序，所有的变化都可以通过修改lua的代码.
main.c 中调用math.lua中的函数

/*
 * @Descripttion: xx模块
 * @Author: cjDong
 * @Date: 2024-07-15 11:30:05
 * @LastEditors: cjDong
 * @LastEditTime: 2024-07-17 14:07:04
 */

#include <stdio.h>

#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"


static int call_func(lua_State *L, const char* funcname, int x, int y)
{
    int ret;
    lua_getglobal(L, funcname); // 查找lua文件中的全局函数，并压入虚拟栈

    /* 压栈，传入参数 */
    lua_pushnumber(L, x);
    lua_pushnumber(L, y);
    
    lua_call(L, 2, 1); /* 执行函数，lua_call 的参数中第二个是参入参数个数，第三个是返回值个数 */

    /* 取出返回值 */
    ret = (int)lua_tonumber(L, -1);

    /*清除返回值的栈*/
    lua_pop(L, 1);

    return ret;
}


int main(int argc, char *argv[])
{
    lua_State *L = luaL_newstate();  /* 创建lua虚拟机 */
    luaL_openlibs(L);     /* 加载lua库，比如math库、table库等 */

    /* 加载lua文件到c语言内存中，进行语法检查，不会编译 */
    luaL_dofile(L, "math.lua");

    /* 调用C函数，这个里面会调用lua函数 */
    call_func(L, "add", 2, 3);
    call_func(L, "sub", 2, 3);
    call_func(L, "mul", 2, 3);
    call_func(L, "div", 2, 3);

    /* 清除Lua */
    lua_close(L);
    
    return 0;
}

function add(x, y)
    print("lua: add function\r\n")
    return x + y
end

function sub(x, y)
    print("lua: sub function\r\n")
    return x - y
end

function mul(x, y)
    print("lua: mul function\r\n")
    return x * y
end

function div(x, y)
    print("lua: div function\r\n")
    return x / y
end

#!/bin/bash

gcc  -o out main.c -llua -ldl -lm

./out

15.2 lua中调用c语言

Q：Lua调用C函数的两种方式？
A：
1、程序主体在C中运行，C函数注册到Lua中。C调用Lua，Lua调用C注册的函数，C得到函数的执行结果。
2、程序主体在Lua中运行，C函数作为库函数供Lua使用。
第一种方式看起来很罗嗦，也很奇怪。既然程序主体运行在C中，而且最终使用的也是C中定义的函数，那么为何要将函数注册给Lua，然后再通过Lua调用函数呢？
相比于第一种方式，第二种方式使用的更加普遍。
一个Lua库（Lua本身所提供的库）实际上是一个定义了若干Lua函数的”chunk”，这些函数通常作为”table”的域来保存。一个C库（C语言编写，注册给Lua使用的库）的实现方式类似于Lua库的实现方式。首先C库中定义提供给Lua使用的函数，其次还需要一个“特殊函数”，它的作用是注册所有C库中的函数，并将它们存储在适当的位置（类似于Lua库中的函数作为”table”的域来保存）。
Lua可以调用C库中的函数，就是通过这个注册的过程实现的。一旦C函数注册到Lua中，Lua就可以直接通过C函数的引用获取到C函数的地址（这也是我们注册的意义，将C函数的地址提供给Lua）。换句话说，一旦C函数注册，Lua调用他们不依赖于函数名，”package”位置，或者是可见规则。
以上两种方式下面都会列举对应的例子，理解第一种方式，将有助于你理解第二种方式的实现流程。

Q：从Lua中调用C所遵循的规则？
A：当C调用Lua函数的时候，必须遵循一些简单的协议来传递参数和获取返回结果。同样的，从Lua中调用C函数，也必须遵循一些协议来传递参数和获得返回结果。此外，从Lua调用C函数我们必须注册函数，也就是说，我们必须把C函数的地址以一个适当的方式传递给Lua解释器。
任何在Lua中注册的C函数必须有同样的原型，
typedef int (*lua_CFunction) (lua_State *L); // 定义在"lua.h"中。
被注册的C函数接收一个单一的lua_State类型的参数，同时返回一个表示返回值个数的数字。函数在将返回值入栈之前无需清理栈，在函数返回之后，Lua会自动清除栈中返回结果下面的所有内容。

15.2.1 方式1：程序主体在C中运行

该方式看起来很罗嗦，也很奇怪。既然程序主体运行在C中，而且最终使用的也是C中定义的函数，那么为何要将函数注册给Lua，然后再通过Lua调用函数呢？

15.2.2 方式2：程序主体在Lua中运行

该方式使用的更加普遍

#include <stdio.h>
#include <math.h>
#include <stdarg.h>
#include <stdlib.h>
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>


/* 所有注册给Lua的C函数具有
 * "typedef int (*lua_CFunction) (lua_State *L);"的原型。
 */
static int l_sin(lua_State *L)
{   
    // 如果给定虚拟栈中索引处的元素可以转换为数字，则返回转换后的数字，否则报错。
    double d = luaL_checknumber(L, 1);
    lua_pushnumber(L, sin(d));  /* push result */

    /* 这里可以看出，C可以返回给Lua多个结果，
     * 通过多次调用lua_push*()，之后return返回结果的数量。
     */
    return 1;  /* number of results */
}



/* 需要一个"luaL_Reg"类型的结构体，其中每一个元素对应一个提供给Lua的函数。
 * 每一个元素中包含此函数在Lua中的名字，以及该函数在C库中的函数指针。
 * 最后一个元素为“哨兵元素”（两个"NULL"），用于告诉Lua没有其他的函数需要注册。
 */
static const struct luaL_Reg mylib[] = {
    {"mysin", l_sin},
    {NULL, NULL}
};



/* 此函数为C库中的“特殊函数”。
 * 通过调用它注册所有C库中的函数，并将它们存储在适当的位置。
 * 此函数的命名规则应遵循：
 * 1、使用"luaopen_"作为前缀。
 * 2、前缀之后的名字将作为"require"的参数。
 */
extern int luaopen_mylib(lua_State* L)
{
    /* void luaL_newlib (lua_State *L, const luaL_Reg l[]);
     * 创建一个新的"table"，并将"mylib"中所列出的函数注册为"table"的域。
     */ 
    luaL_newlib(L, mylib);

    return 1;
}

--[[ 
    这里"require"的参数对应C库中"luaopen_mylib()"中的"mylib"。
     C库就放在"main.lua"的同级目录，"require"可以找到。
]]


local mylib = require "mylib"

-- 结果与上面的例子中相同，但是这里是通过调用C库中的函数实现。
print(mylib.mysin(3.14 / 2))    --> 0.99999968293183

gcc math.c -fPIC -shared -o mylib.so -Wall

lua main.lua

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1933074.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

28_EfficientNetV2网络详解

28_EfficientNetV2网络详解

V1&#xff1a;https://blog.csdn.net/qq_51605551/article/details/140487051?spm1001.2014.3001.5502 1.1 简介 EfficientNetV2是Google研究人员Mingxing Tan和Quoc V. Le等人在2021年提出的一种深度学习模型&#xff0c;它是EfficientNet系列的最新迭代&#xff0c;旨在提…
阅读更多...
golang单元测试性能测试常见用法

golang单元测试性能测试常见用法

关于go test的一些说明 golang安装后可以使用go test工具进行单元测试 代码片段对比的性能测试,使用起来还是比较方便,下面是一些应用场景 平时自己想做一些简单函数的单元测试&#xff0c;不用每次都新建一个main.go 然后go run main.go相对某个功能做下性能测试 看下cpu/内存…
阅读更多...
Anthropic推出1亿美元AI基金，加剧与OpenAI的竞争｜TodayAI

Anthropic推出1亿美元AI基金，加剧与OpenAI的竞争｜TodayAI

人工智能初创公司Anthropic和风险投资公司Menlo Ventures宣布&#xff0c;他们将共同推出一支价值1亿美元的基金&#xff0c;以支持早期初创公司并推动它们使用Anthropic的技术。这个名为Anthology Fund的新基金&#xff0c;将为初创公司提供资金和技术支持&#xff0c;旨在模仿…
阅读更多...
三、GPIO口

三、GPIO口

我们在刚接触C语言时&#xff0c;写的第一个程序必定是hello world&#xff0c;其他的编程语言也是这样类似的代码是告诉我们进入了编程的世界&#xff0c;在单片机中也不例外&#xff0c;不过我们的传统就是点亮第一个LED灯&#xff0c;点亮电阻&#xff0c;电容的兄弟&#x…
阅读更多...
锁策略和CAS指令

锁策略和CAS指令

锁策略 一、锁策略的引入二、锁策略的分类&#xff08;1&#xff09;乐观锁和悲观锁&#xff08;2&#xff09;重量级锁和轻量级锁&#xff08;3&#xff09; 自旋锁和挂起等待锁&#xff08;4&#xff09;可重入锁和不可重入锁&#xff08;5&#xff09;公平锁和非公平锁&…
阅读更多...
SQL面试题练习 —— 统计最大连续登录天数区间

SQL面试题练习 —— 统计最大连续登录天数区间

目录 1 题目2 建表语句3 题解 1 题目 2 建表语句 CREATE TABLE IF NOT EXISTS user_login_tb (uid INT,login_date DATE ); insert into user_login_tb(uid, login_date) values( 1, 2022-08-02),(1, 2022-08-03),(2, 2022-08-03),(2, 2022-08-04),(2, 2022-08-05),(2, 2022-08…
阅读更多...
使用Python的Turtle模块绘制小黄人

使用Python的Turtle模块绘制小黄人

引言 在Python编程的世界里&#xff0c;turtle 模块是一个非常有趣且实用的工具&#xff0c;它允许程序员通过简单的指令控制一个虚拟的画笔&#xff08;称为“海龟”&#xff09;在屏幕上移动和绘制图形。本篇博客将详细介绍如何使用turtle模块来绘制一个卡通人物&#xff0c…
阅读更多...
Redis-布隆过滤器（Bloom Filter）详解

Redis-布隆过滤器（Bloom Filter）详解

文章目录 什么是布隆过滤器 布隆过滤器的优点&#xff1a;布隆过滤器的缺点&#xff1a;其他问题 布隆过滤器适合的场景布隆过滤器原理 数据结构增加元素查询元素删除元素 如何使用布隆过滤器 Google开源的Guava自带布隆过滤器Redis实现布隆过滤器 Redis中配置布隆过滤器Redis…
阅读更多...
给Wordpress添加评分功能到评论表单

给Wordpress添加评分功能到评论表单

今天要 给你的 Wordpress 添加评分功能到评论表单 吗&#xff1f; 评分功能效果图 什么类型的网站需要评分&#xff1f; 资源站教程站其他&#xff0c;我也没想到。。。 但我这个网站&#xff0c;因为是电影类的网站&#xff0c;好像还是有点需要的&#xff0c;所以&#xf…
阅读更多...
完美的用户体验：如何设计一个直观和有效的网站导航？

完美的用户体验：如何设计一个直观和有效的网站导航？

APP的顶部导航栏对我们来说很熟悉。导航栏是UI设计中不可或缺的一部分&#xff0c;几乎每个页面都使用导航栏。虽然导航栏看起来很简单&#xff0c;不需要太多精力&#xff0c;但是设计一个与产品需求和客户目标高度匹配的导航栏并不是那么容易的。导航栏的设计标准有很多细节需…
阅读更多...
SpringBoot集成MQTT实现交互服务通信

SpringBoot集成MQTT实现交互服务通信

引言 本文是springboot集成mqtt的一个实战案例。 gitee代码库地址&#xff1a;源码地址 一、什么是MQTT MQTT&#xff08;Message Queuing Telemetry Transport&#xff0c;消息队列遥测传输协议&#xff09;&#xff0c;是一种基于发布/订阅&#xff08;publish/subscribe&…
阅读更多...
C++ : 移除链表元素/合并两个有序链表题解

C++ : 移除链表元素/合并两个有序链表题解

目录 1.移除链表元素 分析 代码 2.合并两个有序链表 分析 代码 1.移除链表元素 分析 像这种移除元素的&#xff0c;加个哨兵位头节点会比较方便&#xff0c;因为旧的头会有被移除的情况&#xff0c;不好控制。这里只需要用cur指向待遍历的节点&#xff0c;prev指向cur的…
阅读更多...
AI大牛Karpathy创办Eureka Labs专注AI+教育

AI大牛Karpathy创办Eureka Labs专注AI+教育

&#x1f989; AI新闻 &#x1f680; AI大牛Karpathy创办Eureka Labs专注AI教育 摘要&#xff1a;前OpenAI大牛Karpathy离职半年后宣布创办专注AI与教育的公司Eureka Labs&#xff0c;旨在通过生成式AI优化教育体验。公司首个项目LLM101n课程已在GitHub获得高赞&#xff0c;目…
阅读更多...
C++ 继承详解：从基础到深入

C++ 继承详解：从基础到深入

继承是面向对象编程中最强大的功能之一&#xff0c;它不仅促进了代码的重用&#xff0c;还帮助我们构建复杂的系统。在C中&#xff0c;通过继承&#xff0c;我们可以创建一个新的类&#xff08;称为派生类&#xff09;来扩展现有类&#xff08;基类&#xff09;的功能。本文将全…
阅读更多...
基于python的百度资讯爬虫的设计与实现

基于python的百度资讯爬虫的设计与实现

研究背景 随着互联网和信息技术的飞速发展&#xff0c;网络已经成为人们获取信息的主要来源之一。特别是搜索引擎&#xff0c;作为信息检索的核心工具&#xff0c;极大地改变了人们获取信息的方式。其中&#xff0c;百度作为中国最受欢迎的搜索引擎之一&#xff0c;其新闻搜索…
阅读更多...
[GXYCTF2019]Ping Ping Ping1

[GXYCTF2019]Ping Ping Ping1

打开靶机 结合题目名称&#xff0c;考虑是命令注入&#xff0c;试试ls 结果应该就在flag.php。尝试构造命令注入载荷。 cat flag.php 可以看到过滤了空格,用 $IFS$1替换空格 还过滤了flag&#xff0c;我们用字符拼接的方式看能否绕过,ag;cat$IFS$1fla$a.php。注意这里用分号间隔…
阅读更多...
【总结】逻辑运算在Z3中运用+CTF习题

【总结】逻辑运算在Z3中运用+CTF习题

国际赛IrisCTF在前几天举办&#xff0c;遇到了一道有意思的题目&#xff0c;特来总结。 题目 附件如下&#xff1a;&#x1f4ce;babyrevjohnson.tar 解题过程 关键main函数分析如下&#xff1a; int __fastcall main(int argc, const char **argv, const char**envp){int v4…
阅读更多...
Golang | Leetcode Golang题解之第236题二叉树的最近公共祖先

Golang | Leetcode Golang题解之第236题二叉树的最近公共祖先

题目&#xff1a; 题解&#xff1a; func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {parent : map[int]*TreeNode{}visited : map[int]bool{}var dfs func(*TreeNode)dfs func(r *TreeNode) {if r nil {return}if r.Left ! nil {parent[r.Left.Val] rdfs(r.L…
阅读更多...
用 WireShark 抓住 TCP

用 WireShark 抓住 TCP

Wireshark 是帮助我们分析网络请求的利器&#xff0c;建议每个同学都装一个。我们先用 Wireshark 抓取一个完整的连接建立、发送数据、断开连接的过程。 简单的介绍一下操作流程。 1、首先打开 Wireshark&#xff0c;在欢迎界面会列出当前机器上的所有网口、虚机网口等可以抓取…
阅读更多...
气膜体育馆进校园：政策支持与市场前景—轻空间

气膜体育馆进校园：政策支持与市场前景—轻空间

过去20多年&#xff0c;气膜建筑、场馆相关项目在国内落地众多&#xff0c;展现出强大的市场潜力。2022年8月&#xff0c;《北京晚报》粗略统计&#xff0c;北京全市已建有气膜馆百余座&#xff0c;且数量还在不断增加。这一发展趋势不仅仅体现在北京&#xff0c;全国范围内也都…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023