GUI库讲解

浮生A梦

1. 1. removeAllChildren(widget)
   
2. 功能：移除传入控件（widget）的所有子节点。
   
3. 作用范围：只影响传入控件的子节点，不会影响传入控件本身。
   
4. 使用场景：当你需要清空某个控件下的所有子控件，但保留该控件本身时，使用这个函数。例如，你有一个父节点是一个列表，你希望清空列表中的所有元素，但保留列表本身。
   
5. 示例代码：
   
6. lua
   
7. 复制
   
8. -- 假设有一个父节点 parentWidget，它有多个子节点
   
9. local parentWidget = someParentWidget
   
10. parentWidget:removeAllChildren() -- 移除 parentWidget 的所有子节点
    
11. 效果：
    
12. parentWidget 仍然存在，但它的所有子节点都被移除了。
    
13. 2. removeFromParent(widget)
    
14. 功能：将传入控件（widget）从它的父节点上移除。
    
15. 作用范围：只影响传入控件本身，不会影响它的子节点。
    
16. 使用场景：当你需要将某个控件从它的父节点中移除，但保留它的子节点结构时，使用这个函数。例如，你有一个按钮，它是一个父节点的子节点，你希望移除这个按钮，但保留按钮的子节点（比如按钮上的文字）。
    
17. 示例代码：
    
18. lua
    
19. 复制
    
20. -- 假设有一个子节点 childWidget，它是某个父节点的子节点
    
21. local childWidget = someChildWidget
    
22. childWidget:removeFromParent() -- 将 childWidget 从它的父节点上移除
    
23. 效果：
    
24. childWidget 从它的父节点中移除，但它自己的子节点仍然保留。
    
25. 3. 总结区别
    
26. removeAllChildren：
    
27. 作用对象：控件的子节点。
    
28. 结果：控件本身保留，所有子节点被移除。
    
29. removeFromParent：
    
30. 作用对象：控件本身。
    
31. 结果：控件从父节点中移除，但它的子节点结构保持不变。
    
32. 4. 额外说明
    
33. 如果你希望移除一个控件及其所有子节点，可以先调用 removeAllChildren，然后调用 removeFromParent。
    
34. 如果你希望彻底销毁一个控件及其所有子节点，可以使用 destroy 方法。

复制代码

移除（Remove） 和 销毁（Destroy） 是两个不同的概念

1. 1. 移除（Remove）
   
2. 移除操作主要是从节点树（Node Tree）的结构中解开某个节点或节点的子节点，但它并不会销毁这些节点。节点仍然存在，只是不再作为父节点的子节点显示或参与渲染。
   
3. 具体表现：
   
4. removeAllChildren：移除节点的所有子节点，但子节点仍然存在，只是不再属于当前父节点。
   
5. removeFromParent：将节点从其父节点中移除，但节点本身仍然存在。
   
6. 示例：
   
7. lua
   
8. 复制
   
9. -- 假设有一个父节点 parent 和子节点 child
   
10. local parent = cc.Node:create()
    
11. local child = cc.Node:create()
    
12. parent:addChild(child)
    
13. 
    
14. -- 移除 child
    
15. child:removeFromParent()
    
16. 
    
17. -- 此时 child 仍然存在，只是不再属于 parent
    
18. print(child:isRunning()) -- 输出 false，因为 child 不在场景树中
    
19. 作用：
    
20. 移除操作通常用于动态调整节点的层级结构，例如：
    
21. 将一个子节点从一个父节点移动到另一个父节点。
    
22. 清空某个父节点下的所有子节点，但保留父节点本身。
    
23. 2. 销毁（Destroy）
    
24. 销毁操作会彻底删除节点及其所有子节点，释放它们占用的内存资源。销毁后的节点不能再被使用。
    
25. 具体表现：
    
26. destroy：销毁节点及其所有子节点，节点不再存在。
    
27. destroyChildren：销毁节点的所有子节点，但保留节点本身。
    
28. 示例：
    
29. lua
    
30. 复制
    
31. -- 假设有一个父节点 parent 和子节点 child
    
32. local parent = cc.Node:create()
    
33. local child = cc.Node:create()
    
34. parent:addChild(child)
    
35. 
    
36. -- 销毁 child
    
37. child:destroy()
    
38. 
    
39. -- 此时 child 已经被销毁，无法再使用
    
40. 作用：
    
41. 销毁操作通常用于清理不再需要的节点，以节省内存和资源。例如：
    
42. 游戏关卡结束时销毁关卡中的所有节点。
    
43. 动态创建的节点在不再需要时被销毁。
    
44. 3. 移除与销毁的区别
    
45. 操作        移除（Remove）        销毁（Destroy）
    
46. 作用范围        只影响父子关系，节点仍然存在，但不再属于父节点。        彻底删除节点及其子节点，释放内存。
    
47. 节点状态        节点仍然存在，但不再参与渲染或事件处理。        节点被完全删除，无法再使用。
    
48. 使用场景        动态调整节点层级结构，例如从一个父节点移动到另一个父节点，或者清空子节点。        清理不再需要的节点，节省内存和资源。
    
49. 4. 如何选择
    
50. 如果你只是想调整节点的层级结构（例如将一个节点从一个父节点移动到另一个父节点），使用 移除操作。
    
51. 如果你确定某个节点及其子节点不再需要，且希望释放它们占用的资源，使用 销毁操作。

复制代码

userdata 是一种特殊的数据类型，通常用于表示 C++ 中的对象或资源。由于 userdata 是不透明的，直接查看其内容可能会比较困难。但是，你可以通过以下方法将 userdata 转换为 table 格式，或者查看其内容：

1. 方法 1：通过元表（Metatable）查看 userdata 内容
   
2. userdata 的行为可以通过元表（Metatable）来定义。你可以通过获取和遍历元表来查看 userdata 的属性和方法。
   
3. 以下是一个示例代码：
   
4. lua
   
5. 复制
   
6. local function printUserdataContent(ud)
   
7.     local mt = getmetatable(ud)  -- 获取 userdata 的元表
   
8.     if mt then
   
9.         for k, v in pairs(mt) do
   
10.             print(k, v)
    
11.         end
    
12.     else
    
13.         print("No metatable found for userdata")
    
14.     end
    
15. end
    
16. 方法 2：将 userdata 转换为 table
    
17. 如果 userdata 表示的是一个对象，并且你希望将其属性转换为 table 格式，可以通过反射或其他方式提取其属性。
    
18. 以下是一个简单的示例：
    
19. lua
    
20. 复制
    
21. local function userdataToTable(ud)
    
22.     local result = {}
    
23.     local mt = getmetatable(ud)
    
24.     if mt then
    
25.         for k, v in pairs(mt) do
    
26.             if type(v) ~= "function" then
    
27.                 result[k] = v
    
28.             end
    
29.         end
    
30.     end
    
31.     return result
    
32. end
    
33. 
    
34. -- 使用示例
    
35. local ud = some_userdata
    
36. local tableVersion = userdataToTable(ud)
    
37. print(tableVersion)
    
38. 方法 3：使用 JSON 序列化（如果适用）
    
39. 如果你的 userdata 是从 JSON 数据中创建的，可以尝试将其序列化为 JSON 字符串，然后再解析为 table。
    
40. lua
    
41. 复制
    
42. local json = require("json")  -- 引入 JSON 模块
    
43. local jsonString = json.encode(ud)  -- 将 userdata 序列化为 JSON 字符串
    
44. local tableVersion = json.decode(jsonString)  -- 将 JSON 字符串解析为 table
    
45. print(tableVersion)
    
46. 注意事项
    
47. userdata 的行为和内容取决于其背后的实现。如果 userdata 是由 C++ 创建的，可能需要通过 C++ 提供的接口来访问其内容。
    
48. 如果 userdata 没有元表或无法直接访问其属性，可能需要检查其创建方式或联系相关库的开发者。

复制代码

解包Userdata

1.   local function userdataToTable(ud)
   
2.     local result = {}
   
3.     local mt = getmetatable(ud)
   
4.     if mt then
   
5.         for k, v in pairs(mt) do
   
6.          
   
7.                 result[k] = GUI:getName(v)
   
8.         
   
9.         end
   
10.     end
    
11.     return result
    
12. end
    
13. 
    
14. -- 使用示例
    
15. local ud = sender
    
16. local tableVersion = userdataToTable(ud)
    
17. SL:dump(tableVersion,"=--=",3)

复制代码

继承的概念  

1. 在 Lua 中，getmetatable 和元表（Metatable）的概念与传统编程语言中的“继承”并不完全相同，但它们在某些方面有相似之处。元表在 Lua 中主要用于扩展对象的行为，而不是传统意义上的类继承。不过，元表可以实现一种类似于继承的效果，尤其是在表的继承和行为扩展方面。
   
2. 元表的作用
   
3. 元表是一种特殊的表，通过它可以定义对象（如表或 userdata）的行为。元表中可以包含一些特殊的键（称为元方法），这些键定义了对象在特定操作下的行为。例如：
   
4. __index：定义了访问表中不存在的键时的行为。
   
5. __newindex：定义了向表中写入不存在的键时的行为。
   
6. __tostring：定义了对象的字符串表示形式。
   
7. __call：定义了对象被调用时的行为。
   
8. 元表与继承的关系
   
9. 虽然元表本身并不是传统意义上的继承机制，但它可以通过 __index 元方法实现一种类似继承的效果。具体来说，__index 元方法可以用来实现“原型继承”。
   
10. 原型继承的实现
    
11. 在 Lua 中，可以通过将一个表的元表设置为另一个表，从而实现“原型继承”。当访问一个表中不存在的键时，Lua 会通过 __index 元方法查找其元表中的对应键。如果元表中也不存在该键，Lua 会继续查找元表的元表，直到找到为止。这种机制类似于对象的“原型链”。
    
12. 以下是一个简单的示例，展示如何通过元表实现类似继承的效果：
    
13. lua
    
14. 复制
    
15. -- 定义一个“父类”表
    
16. local Parent = {
    
17.     name = "Parent",
    
18.     sayHello = function(self)
    
19.         print("Hello from " .. self.name)
    
20.     end
    
21. }
    
22. 
    
23. -- 定义一个“子类”表
    
24. local Child = {
    
25.     name = "Child"
    
26. }
    
27. 
    
28. -- 设置 Child 的元表，使其继承 Parent 的行为
    
29. setmetatable(Child, {
    
30.     __index = Parent
    
31. })
    
32. 
    
33. -- 测试继承
    
34. Child:sayHello()  -- 输出: Hello from Child

复制代码

• 继承是一种语言层面的特性，允许一个类（子类）继承另一个类（父类）的属性和方法。
• 子类可以扩展父类的行为，也可以覆盖父类的方法。
• 继承是静态的，通常在编译时确定。
  

Lua 的元表（通过 __index 实现类似继承的效果）：

• 元表是一种运行时机制，通过动态查找来实现行为的扩展。
• 它更像是“原型继承”（类似于 JavaScript 的继承方式），而不是传统面向对象语言中的类继承。
• 元表的 __index 元方法允许一个表（子表）“继承”另一个表（父表）的属性和方法，但这种继承是动态的，基于运行时的查找。
  

__index 和 __newindex的区别

1. __index 和 __newindex 确实看起来很相似，但实际上它们的作用和触发场景是不同的。虽然它们都与“键不存在”有关，但一个是用于读取操作，另一个是用于写入操作。以下是它们的具体区别：
   
2. 1. __index 元方法
   
3. __index 是一个元方法，用于定义当尝试读取表中不存在的键时的行为。
   
4. 触发场景
   
5. 当你尝试从一个表中读取一个不存在的键时，Lua 会检查该表的元表中是否定义了 __index 元方法。如果定义了，Lua 会通过 __index 来查找该键的值。
   
6. 作用
   
7. 如果 __index 是一个表，Lua 会在该表中查找缺失的键。
   
8. 如果 __index 是一个函数，Lua 会调用该函数，传递表本身和缺失的键作为参数。
   
9. 示例
   
10. lua
    
11. 复制
    
12. local parent = {
    
13.     value = 42,
    
14.     getValue = function(self) return self.value end
    
15. }
    
16. 
    
17. local child = {}
    
18. setmetatable(child, { __index = parent })
    
19. 
    
20. print(child.value)        -- 输出：42（从 parent 中查找）
    
21. print(child:getValue())   -- 输出：42（从 parent 中查找方法）
    
22. 在这个例子中，child 表没有 value 和 getValue，但通过元表的 __index，Lua 会在 parent 中查找这些键。
    
23. 2. __newindex 元方法
    
24. __newindex 是一个元方法，用于定义当尝试向表中写入一个不存在的键时的行为。
    
25. 触发场景
    
26. 当你尝试向一个表中写入一个不存在的键时，Lua 会检查该表的元表中是否定义了 __newindex 元方法。如果定义了，Lua 会通过 __newindex 来处理这个写入操作。
    
27. 作用
    
28. 如果 __newindex 是一个表，Lua 会在该表中写入键值对。
    
29. 如果 __newindex 是一个函数，Lua 会调用该函数，传递表本身、键和值作为参数。
    
30. 示例
    
31. lua
    
32. 复制
    
33. local parent = {}
    
34. local child = {}
    
35. setmetatable(child, { __newindex = parent })
    
36. 
    
37. child.key = "value"  -- 实际写入到 parent 表中
    
38. print(parent.key)   -- 输出：value
    
39. 在这个例子中，child 表没有 key，但通过元表的 __newindex，Lua 会将 key = "value" 写入到 parent 表中。
    
40. 3. 区别总结
    
41. __index：
    
42. 触发场景：尝试读取表中不存在的键。
    
43. 作用：允许从另一个表或通过函数动态获取缺失的键的值。
    
44. 用途：实现“原型继承”，扩展表的行为，提供默认值等。
    
45. __newindex：
    
46. 触发场景：尝试写入表中不存在的键。
    
47. 作用：允许将写入操作重定向到另一个表，或者通过函数动态处理写入操作。
    
48. 用途：实现“代理写入”，保护表的内容，记录写入操作等。
    
49. 4. 为什么它们是不同的
    
50. 虽然 __index 和 __newindex 都与“键不存在”有关，但它们分别处理的是读取操作和写入操作。这种区分是必要的，因为读取和写入的行为可能需要不同的逻辑：
    
51. 读取操作可能需要从其他地方获取默认值或动态计算值。
    
52. 写入操作可能需要记录日志、保护数据或重定向到其他存储位置。
    
53. 5. 实际应用
    
54. __index：
    
55. 实现类似继承的效果（如原型继承）。
    
56. 提供默认值或动态计算属性。
    
57. __newindex：
    
58. 保护表的内容（例如，防止直接修改某些属性）。
    
59. 实现缓存机制（例如，将写入操作存储到其他地方）。
    
60. 记录写入操作（例如，用于调试或日志记录）。

复制代码

语法糖规则

1. object:method(args) 是一种语法糖，它本质上等价于 method(object, args)。这种语法糖的主要作用是让代码更直观，明确地表达出方法是属于某个对象的。
   
2. Button:getName() 和 getName(Button) 的区别
   
3. 1. Button:getName()
   
4. 语法糖：Button:getName() 是 Lua 中的语法糖，表示调用 Button 对象的 getName 方法。
   
5. 实际调用：在内部，这会被转换为 getName(Button)，其中 Button 是作为第一个参数传递给 getName 方法的。
   
6. 上下文明确：这种写法明确表示 getName 是 Button 的方法，代码可读性更高。
   
7. 2. getName(Button)
   
8. 普通函数调用：getName(Button) 是普通的函数调用方式，明确地将 Button 作为第一个参数传递给 getName 函数。
   
9. 上下文不明确：这种方式没有明确表达出 getName 是 Button 的方法，只是表明 getName 是一个函数，Button 是它的第一个参数。
   
10. 适用场景：这种方式通常用于调用全局函数或模块中的函数，而不是对象的方法。
    
11. 是否等价？
    
12. 从功能上来说，Button:getName() 和 getName(Button) 是等价的，因为 Lua 会将 Button:getName() 转换为 getName(Button)。然而，它们在语义上和代码可读性上有明显的区别。
    
13. 语义上的区别
    
14. Button:getName()：
    
15. 表示 getName 是 Button 对象的方法。
    
16. 更符合面向对象编程的习惯，表达出方法属于某个对象。
    
17. getName(Button)：
    
18. 表示 getName 是一个普通的函数，Button 是它的第一个参数。
    
19. 更适合全局函数或模块函数的调用方式。
    
20. 示例代码
    
21. 假设 Button 是一个对象，getName 是它的方法：
    
22. lua
    
23. 复制
    
24. -- 定义一个 Button 对象
    
25. local Button = {
    
26.     name = "MyButton",
    
27.     getName = function(self)
    
28.         return self.name
    
29.     end
    
30. }
    
31. 
    
32. -- 使用语法糖调用方法
    
33. print(Button:getName())  -- 输出: MyButton
    
34. 
    
35. -- 使用普通函数调用方式
    
36. print(Button.getName(Button))  -- 输出: MyButton
    
37. 总结
    
38. 功能上等价：Button:getName() 和 getName(Button) 在功能上是等价的，因为 Lua 会将前者转换为后者。
    
39. 语义上有区别：Button:getName() 更符合面向对象编程的习惯，明确表示 getName 是 Button 的方法；而 getName(Button) 更适合用于普通函数调用。
    
40. 推荐使用：在调用对象的方法时，推荐使用 Button:getName()，因为它更直观、更符合 Lua 的编程习惯。

复制代码

removeChild：从当前节点中移除一个子节点。
removeAllChildren：移除当前节点的所有子节点。
reorderChild：重新排序子节点的层级。
getChildByTag：通过标签获取子节点。
getChildByName：通过名称获取子节点。
getChildren：获取当前节点的所有子节点。
getChildrenCount：获取子节点的数量。
getParent：获取当前节点的父节点。
setParent：设置当前节点的父节点。
removeFromParent：从父节点中移除当前节点。
变换操作

• setPosition：设置节点的 2D 位置。
  
• setPosition3D：设置节点的 3D 位置。
  
• getPosition：获取节点的 2D 位置。
  
• getPosition3D：获取节点的 3D 位置。
  
• setRotation：设置节点的旋转角度（2D）。
  
• setRotation3D：设置节点的 3D 旋转。
  
• getRotation：获取节点的旋转角度（2D）。
  
• getRotation3D：获取节点的 3D 旋转。
  
• setScale：设置节点的缩放比例。
  
• getScale：获取节点的缩放比例。
  
• setSkewX、setSkewY：设置节点的 X 或 Y 方向的倾斜角度。
  
• getSkewX、getSkewY：获取节点的 X 或 Y 方向的倾斜角度。
  
  

属性操作

• setName：设置节点的名称。
  
• getName：获取节点的名称。
  
• setTag：设置节点的标签。
  
• getTag：获取节点的标签。
  
• setVisible：设置节点是否可见。
  
• isVisible：检查节点是否可见。
  
• setOpacity：设置节点的透明度。
  
• getOpacity：获取节点的透明度。
  
• setColor：设置节点的颜色。
  
• getColor：获取节点的颜色。
  
• setAnchorPoint：设置节点的锚点。
  
• getAnchorPoint：获取节点的锚点。
  
  

动作与事件

• runAction：运行一个动作（如动画、移动、旋转等）。
  
• stopAction：停止一个动作。
  
• stopAllActions：停止所有动作。
  
• scheduleUpdate：注册一个更新回调函数。
  
• unscheduleUpdate：取消注册更新回调函数。
  
• registerScriptHandler：注册一个脚本事件处理函数。
  
• unregisterScriptHandler：取消注册脚本事件处理函数。
  
  

层级与变换

• setLocalZOrder：设置节点的局部 Z 顺序。
  
• getLocalZOrder：获取节点的局部 Z 顺序。
  
• setGlobalZOrder：设置节点的全局 Z 顺序。
  
• getGlobalZOrder：获取节点的全局 Z 顺序。
  
• setIgnoreAnchorPointForPosition：设置是否忽略锚点来计算位置。
  
• isIgnoreAnchorPointForPosition：检查是否忽略锚点来计算位置。
  
  

其他

• convertToNodeSpace：将世界坐标转换为节点坐标。
  
• convertToWorldSpace：将节点坐标转换为世界坐标。
  
• getBoundingBox：获取节点的边界框。
  
• setCascadeColorEnabled、setCascadeOpacityEnabled：设置是否对子节点级联颜色或透明度。
  
• isCascadeColorEnabled、isCascadeOpacityEnabled：检查是否对子节点级联颜色或透明度。
  
  

节点操作

• addChild：将一个子节点添加到当前节点。
  
• removeChild：从当前节点中移除一个子节点。
  
• removeAllChildren：移除当前节点的所有子节点。
  
• reorderChild：重新排序子节点的层级。
  
• getChildByTag：通过标签获取子节点。
  
• getChildByName：通过名称获取子节点。
  
• getChildren：获取当前节点的所有子节点。
  
• getChildrenCount：获取子节点的数量。
  
• getParent：获取当前节点的父节点。
  
• setParent：设置当前节点的父节点。
  
• removeFromParent：从父节点中移除当前节点。
  
  

变换操作

• setPosition：设置节点的 2D 位置。
  
• setPosition3D：设置节点的 3D 位置。
  
• getPosition：获取节点的 2D 位置。
  
• getPosition3D：获取节点的 3D 位置。
  
• setRotation：设置节点的旋转角度（2D）。
  
• setRotation3D：设置节点的 3D 旋转。
  
• getRotation：获取节点的旋转角度（2D）。
  
• getRotation3D：获取节点的 3D 旋转。
  
• setScale：设置节点的缩放比例。
  
• getScale：获取节点的缩放比例。
  
• setSkewX、setSkewY：设置节点的 X 或 Y 方向的倾斜角度。
  
• getSkewX、getSkewY：获取节点的 X 或 Y 方向的倾斜角度。
  
  

属性操作

• setName：设置节点的名称。
  
• getName：获取节点的名称。
  
• setTag：设置节点的标签。
  
• getTag：获取节点的标签。
  
• setVisible：设置节点是否可见。
  
• isVisible：检查节点是否可见。
  
• setOpacity：设置节点的透明度。
  
• getOpacity：获取节点的透明度。
  
• setColor：设置节点的颜色。
  
• getColor：获取节点的颜色。
  
• setAnchorPoint：设置节点的锚点。
  
• getAnchorPoint：获取节点的锚点。
  
  

动作与事件

• runAction：运行一个动作（如动画、移动、旋转等）。
  
• stopAction：停止一个动作。
  
• stopAllActions：停止所有动作。
  
• scheduleUpdate：注册一个更新回调函数。
  
• unscheduleUpdate：取消注册更新回调函数。
  
• registerScriptHandler：注册一个脚本事件处理函数。
  
• unregisterScriptHandler：取消注册脚本事件处理函数。
  
  

层级与变换

• setLocalZOrder：设置节点的局部 Z 顺序。
  
• getLocalZOrder：获取节点的局部 Z 顺序。
  
• setGlobalZOrder：设置节点的全局 Z 顺序。
  
• getGlobalZOrder：获取节点的全局 Z 顺序。
  
• setIgnoreAnchorPointForPosition：设置是否忽略锚点来计算位置。
  
• isIgnoreAnchorPointForPosition：检查是否忽略锚点来计算位置。
  
  

其他

• convertToNodeSpace：将世界坐标转换为节点坐标。
  
• convertToWorldSpace：将节点坐标转换为世界坐标。
  
• getBoundingBox：获取节点的边界框。
  
• setCascadeColorEnabled、setCascadeOpacityEnabled：设置是否对子节点级联颜色或透明度。
  
• isCascadeColorEnabled、isCascadeOpacityEnabled：检查是否对子节点级联颜色或透明度。