常量定义

• 红色 = red：红色常量。
• 绿色 = green：绿色常量。
• 蓝色 = blue：蓝色常量。
• 黑色 = black：黑色常量。
• 白色 = white：白色常量。
• 灰色 = gray：灰色常量。
• 透明 = transparent：透明常量。
• 黄色 = yellow：黄色常量。
• 橙色 = orange：橙色常量。
• 紫色 = purple：紫色常量。
• 青色 = cyan：青色常量。
• 粉色 = pink：粉色常量。
• 棕色 = brown：棕色常量。
• 银色 = silver：银色常量。
• 金色 = gold：金色常量。
• 浅灰 = lightgray：浅灰色常量。
• 深灰 = darkgray：深灰色常量。
• 浅蓝 = lightblue：浅蓝色常量。
• 深蓝 = darkblue：深蓝色常量。
• 浅绿 = lightgreen：浅绿色常量。
• 深绿 = darkgreen：深绿色常量。
• 浅红 = lightcoral：浅红色常量。
• 深红 = crimson：深红色常量。
• 字体_超小 = xx-small：超小字体大小。
• 字体_特小 = x-small：特小字体大小。
• 字体_小 = small：小字体大小。
• 字体_中 = medium：中等字体大小。
• 字体_大 = large：大字体大小。
• 字体_特大 = x-large：特大字体大小。
• 字体_超大 = xx-large：超大字体大小。
• 字体_加大 = larger：相对父元素更大的字体大小。
• 字体_缩小 = smaller：相对父元素更小的字体大小。
• 字体样式_斜体 = italic：斜体字体样式。
• 字体样式_斜体小体大写 = oblique：倾斜字体样式。
• 字体装饰_下划线 = underline：下划线字体装饰。
• 字体装饰_上划线 = overline：上划线字体装饰。
• 字体装饰_删除线 = line-through：删除线字体装饰。
• 字体装饰_无 = none：无字体装饰。
• 边距_小 = 5px：小边距值。
• 边距_中 = 10px：中等边距值。
• 边距_大 = 20px：大边距值。
• 背景_居中 = center：背景居中位置。
• 背景_顶部 = top：背景顶部位置。
• 背景_底部 = bottom：背景底部位置。
• 背景_左侧 = left：背景左侧位置。
• 背景_右侧 = right：背景右侧位置。
• 背景覆盖 = cover：背景覆盖模式。
• 背景包含 = contain：背景包含模式。
• 背景_不重复 = no-repeat：背景不重复。
• 背景_水平 = repeat-x：背景水平重复。
• 背景_垂直 = repeat-y：背景垂直重复。
• 背景_平铺 = repeat：背景平铺重复。
• 渐变_线性 = linear-gradient：线性渐变。
• 渐变_径向 = radial-gradient：径向渐变。
• 渐变_角度 = to right：角度渐变方向。
• 主轴对齐_起点 = flex-start：主轴起点对齐。
• 主轴对齐_终点 = flex-end：主轴终点对齐。
• 主轴对齐_居中 = center：主轴居中对齐。
• 主轴对齐_分散 = space-between：主轴两端对齐，项目间等距分布。
• 主轴对齐_平均 = space-around：主轴项目两侧等距分布。
• 主轴对齐_均匀 = space-evenly：主轴项目均匀分布。
• 侧轴对齐_起点 = flex-start：侧轴起点对齐。
• 侧轴对齐_终点 = flex-end：侧轴终点对齐。
• 侧轴对齐_居中 = center：侧轴居中对齐。
• 侧轴对齐_拉伸 = stretch：侧轴拉伸对齐。
• 侧轴对齐_基线 = baseline：侧轴基线对齐。
• 项目对齐_自动 = auto：项目自动对齐。
• 项目对齐_拉伸 = stretch：项目拉伸对齐。
• 项目对齐_居中 = center：项目居中对齐。
• 项目对齐_起点 = flex-start：项目起点对齐。
• 项目对齐_终点 = flex-end：项目终点对齐。
• 项目对齐_基线 = baseline：项目基线对齐。
• 网格对齐_起点 = start：网格起点对齐。
• 网格对齐_终点 = end：网格终点对齐。
• 网格对齐_居中 = center：网格居中对齐。
• 网格对齐_拉伸 = stretch：网格拉伸对齐。
• 网格对齐_平均 = space-around：网格平均分布对齐。
• 网格对齐_分散 = space-between：网格两端对齐。
• 网格对齐_均匀 = space-evenly：网格均匀分布对齐。
• 屏幕_小 = 576px：小屏幕断点。
• 屏幕_中 = 768px：中屏幕断点。
• 屏幕_大 = 992px：大屏幕断点。
• 屏幕_超大 = 1200px：超大屏幕断点。
• 动画_线性 = linear：线性动画时间函数。
• 动画_缓入 = ease-in：缓入动画时间函数。
• 动画_缓出 = ease-out：缓出动画时间函数。
• 动画_缓入缓出 = ease-in-out：缓入缓出动画时间函数。
• 动画_弹性 = ease：缓动（ease）动画时间函数。
• 动画_阶梯 = step-start：阶梯式动画时间函数。
• 动画_反向阶梯 = step-end：反向阶梯动画时间函数。
• 动画填充_无 = none：无动画填充模式。
• 动画填充_向前 = forwards：动画结束后保持最终状态。
• 动画填充_向后 = backwards：动画结束后保持初始状态。
• 动画填充_向前向后 = both：动画结束后保持最终状态，开始前应用初始状态。
• 动画状态_运行 = running：动画运行状态。
• 动画状态_暂停 = paused：动画暂停状态。
• 动画过渡_平滑 = all 0.3s ease：平滑过渡效果。
• 动画过渡_快速 = all 0.1s ease：快速过渡效果。
• 动画过渡_慢速 = all 0.5s ease：慢速过渡效果。
• 动画过渡_弹性 = all 0.6s cubic-bezier(0.68, -0.55, 0.265, 1.55)：弹性过渡效果。
• 透明度_完全透明 = 0：完全透明。
• 透明度_半透明 = 0.5：半透明。
• 透明度_半透明_深 = 0.8：深半透明。
• 透明度_半透明_浅 = 0.2：浅半透明。
• 透明度_不透明 = 1：不透明。
• 阴影_小 = 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24)：小阴影效果。
• 阴影_中 = 0 3px 6px rgba(0,0,0,0.16), 0 3px 6px rgba(0,0,0,0.23)：中等阴影效果。
• 阴影_大 = 0 10px 20px rgba(0,0,0,0.19), 0 6px 6px rgba(0,0,0,0.23)：大阴影效果。
• 阴影_内嵌 = inset 0 2px 4px rgba(0,0,0,0.25)：内嵌阴影效果。
• 编码_UTF8 = UTF-8：UTF-8字符编码。
• 编码_GBK = GBK：GBK字符编码。
• 编码_GB2312 = GB2312：GB2312字符编码。
• 编码_ASCII = ASCII：ASCII字符编码。
• 编码_Unicode = Unicode：Unicode字符编码。
• HTTP_成功 = 200：HTTP成功状态码。
• HTTP_未找到 = 404：HTTP未找到状态码。
• HTTP_服务器错误 = 500：HTTP服务器内部错误状态码。
• HTTP_禁止访问 = 403：HTTP禁止访问状态码。
• HTTP_未授权 = 401：HTTP未授权状态码。
• HTTP_请求超时 = 408：HTTP请求超时状态码。
• HTTP_请求体过大 = 413：HTTP请求体过大状态码。
• HTTP_请求地址过长 = 414：HTTP请求地址过长状态码。
• 日期格式_标准 = yyyy-MM-dd：标准日期格式。
• 日期格式_中文 = yyyy年MM月dd日：中文日期格式。
• 日期格式_美式 = MM/dd/yyyy：美式日期格式。
• 日期格式_欧式 = dd/MM/yyyy：欧式日期格式。
• 时间格式_24小时 = HH:mm:ss：24小时制时间格式。
• 时间格式_12小时 = hh:mm:ss a：12小时制时间格式。
• 日期时间格式_完整 = yyyy-MM-dd HH:mm:ss：完整日期时间格式。
• 日期时间格式_中文完整 = yyyy年MM月dd日 HH时mm分ss秒：中文完整日期时间格式。
• 数字格式_整数 = #：整数数字格式。
• 数字格式_两位小数 = #.00：两位小数数字格式。
• 数字格式_百分比 = #.00%：百分比数字格式。
• 数字格式_千分位 = #,###：千分位数字格式。
• 数字格式_货币 = ¥#,###.00：货币数字格式。
• 数字格式_科学计数 = #.###E+00：科学计数法数字格式。
• 匹配父 = inherit：设置组件的宽高继承父控件对应的尺寸值。
• 自适应 = initial：设置组件的宽高等于其组件中内容的宽高。
• 百分百 = 100%：设置组件的宽高为“100%”。
• 边框_点线 = dotted：点线边框。
• 边框_虚线 = dashed：虚线边框。
• 边框_实线 = solid：实线边框。
• 边框_双线 = double：双线边框。
• 边框_凹槽 = groove：3D凹槽边框。
• 边框_垄状 = ridge：3D垄状边框。
• 边框_内嵌 = inset：3D inset边框。
• 边框_外凸 = outset：3D outset边框。
• 居中 = center：设置组件中的内容水平居中。
• 靠左 = left：设置组件中的内容靠左对齐。
• 靠右 = right：设置组件中的内容靠右对齐。
• 两端对齐 = justify：设置组件中的内容两端对齐。
• 顶边对齐 = top：设置组件中的内容顶边对齐。
• 垂直居中 = middle：设置组件中的内容垂直居中。
• 底边对齐 = bottom：设置组件中的内容底边对齐。
• 显示_块 = block：设置组件显示模式为块级元素。
• 显示_行内 = inline：设置组件显示模式为行内元素。
• 显示_行内块 = inline-block：设置组件显示模式为行内块元素。
• 隐藏元素 = none：设置组件隐藏不显示。
• 布局_弹性 = flex：设置组件布局为弹性布局。
• 布局_网格 = grid：设置组件布局为网格布局。
• 静态定位 = static：设置组件定位为静态定位。
• 相对定位 = relative：设置组件定位为相对定位。
• 绝对定位 = absolute：设置组件定位为绝对定位。
• 固定定位 = fixed：设置组件定位为固定定位。
• 粘性定位 = sticky：设置组件定位为粘性定位。
• 布局方向_垂直 = column：设置当前组件或布局中的子组件或内容从上到下排列。
• 布局方向_水平 = row：设置当前组件或布局中的子组件或内容从左到右排列。
• 布局方向_从下向上 = column-reverse：设置当前组件或布局中的子组件或内容从下到上排列。
• 布局方向_从右向左 = row-reverse：设置当前组件或布局中的子组件或内容从右到左排列。
• 文本输入 = text：设置输入框类型为文本输入。
• 密码输入 = password：设置输入框类型为密码输入。
• 数字输入 = number：设置输入框类型为数字输入。
• 邮箱输入 = email：设置输入框类型为邮箱输入。
• 电话输入 = tel：设置输入框类型为电话输入。
• 日期输入 = date：设置输入框类型为日期输入。
• 文件上传 = file：设置输入框类型为文件上传。
• 默认鼠标 = default：设置鼠标样式为默认箭头。
• 指针鼠标 = pointer：设置鼠标样式为手形指针。
• 文本鼠标 = text：设置鼠标样式为文本输入I型。
• 等待鼠标 = wait：设置鼠标样式为等待状态。
• 禁止鼠标 = not-allowed：设置鼠标样式为禁止操作状态。
• 溢出隐藏 = hidden：设置内容溢出时隐藏。
• 溢出滚动 = scroll：设置内容溢出时显示滚动条。
• 溢出显示 = visible：设置内容溢出时仍然显示。
• 当前窗口 = _self：设置链接在当前窗口打开。
• 新窗口 = _blank：设置链接在新窗口打开。
• 正常粗细 = normal：设置字体粗细为正常。
• 粗体 = bold：设置字体粗细为粗体。
• 较粗 = bolder：设置字体比父元素更粗。
• 较细 = lighter：设置字体比父元素更细。
• 引号 = \"：英文模式下的双引号“"”。

语言关键字

或

• 英文： ||
• 说明： 逻辑‘或’运算符，用于条件判断，遵循短路求值原则，当任一操作数为真时返回真，否则返回假，常用于条件分支和默认值设置。

' 比较两个值，如果有一方符合条件则为真
变量 a = 20
变量 b = 50
如果(a > 10 或 b < 30)
	调试输出("条件为真")
否则
	调试输出("条件为假")
结束 如果

且

• 英文： &&
• 说明： 逻辑‘与’运算符，用于条件判断，遵循短路求值原则，当所有操作数都为真时返回真，否则返回假，常用于多重条件判断。

' 比较两个值，必须两方都符合条件才为真
变量 a = 20
变量 b = 50
如果(a > 10 且 b < 100)
	调试输出("条件为真")
否则
	调试输出("条件为假")
结束 如果

空

• 英文： null
• 说明： 空值，表示有意缺少的对象值，使用‘取数据类型’ 函数返回 'object'，是 JavaScript 的历史遗留问题，用于显式表示变量未指向任何对象或值。

' 设置变量默认初始值为空
变量 a = 空
如果(a == 空)
	调试输出("a为空对象:" + 取数据类型(a))
否则
	调试输出("a不为空")
结束 如果

真

• 英文： true
• 说明： 布尔类型的真值，表示逻辑真，注意在条件判断中所有真值都会转换为‘true’，包括非空字符串、非零数字等。

' 设置变量默认初始值为真
变量 a = 真
如果(a == 真)
	调试输出("a为真")
否则
	调试输出("a不为真")
结束 如果

假

• 英文： false
• 说明： 布尔类型的假值，表示逻辑假，在条件判断中所有假值都会转换为‘false’，包括 0、空字符串、null、undefined等。

' 设置变量默认初始值为假
变量 a = 假
如果(a == 假)
	调试输出("a为假")
否则
	调试输出("a不为假")
结束 如果

类属

• 英文： instanceof
• 说明： 类型判断运算符，用于检测指定实例对象是否属于某个数据类型，语法：对象实例 类属 类型，返回布尔值表示是否属于该类型。

' 判断窗口中某个组件是否属于按钮类型
如果(按钮1 类属 按钮)
	调试输出("按钮1属于按钮类型")
否则
	调试输出("按钮1不属于按钮类型")
结束 如果

变量

• 英文： let
• 说明： 块级作用域变量声明关键字，声明的变量只在当前代码块内有效。

' 定义变量
变量 a = 10
调试输出(a) ' 输出10
' 定义数组
变量 b = [1,2,3]
调试输出(b) ' 输出[1,2,3]
' 定义对象
变量 c = { X:10,Y:20 }
调试输出(c)

判断

• 英文： switch
• 说明： 多分支条件语句，用于基于不同条件执行不同代码块，使用严格相等(===)进行比较，注意：该语句没有“默认”分支。

变量 时间 = 3
判断(时间)
	分支 1
		调试输出("星期一")
	分支 2
		调试输出("星期二")
	分支 3
		调试输出("星期三")
	分支 4
		调试输出("星期四")
	分支 5
		调试输出("星期五")
结束 判断

分支

• 英文： case
• 说明： 判断语句中的条件分支标记，用于指定匹配值，匹配成功后执行分支中的代码。

变量 时间 = 3
判断(时间)
	分支 1
		调试输出("星期一")
	分支 2
		调试输出("星期二")
	分支 3
		调试输出("星期三")
	分支 4
		调试输出("星期四")
	分支 5
		调试输出("星期五")
结束 判断

如果

• 英文： if
• 说明： 条件判断语句，根据条件表达式的结果决定是否执行代码块，可配合否则实现分支逻辑，是程序流程控制的基础结构。

' 条件判断
变量 a = 20
如果(a > 10)
	调试输出("a大于10")
否则
	调试输出("a不大于10")
结束 如果

否则

• 英文： else
• 说明： 条件语句的可选部分，当前面的‘如果’条件不满足时执行。

' 条件判断
变量 a = 5
如果(a > 10)
	调试输出("a大于10")
否则 如果(a < 5)
	调试输出("a小于5")
否则
	调试输出("a为其它区间值")
结束 如果

结束

• 英文： end
• 说明： 流程控制及标识函数，事件，定义等代码结束位置的关键字，用于显式指定代码块结尾。

' 结束关键字用于结束各种流程控制结构及标识语句结尾
如果(真)
	调试输出("条件为真")
结束 如果
' 标识函数结尾
函数 函数名称()
	调试输出("自定义函数")
结束 函数

退出

• 英文： break
• 说明： 退出循环控制语句，用于立即终止并退出循环。

变量 计次  = 0
判断循环(计次 < 10)
	' 当执行第5次循环的时候、提前结束并退出循环
	' 退出循环后、将不再执行后续的循环
	如果(计次 == 5)
		退出
	否则
		' 执行语句
	结束 如果
	计次 = 计次 + 1
结束循环

跳过

• 英文： continue
• 说明： 跳出循环控制语句，用于立即跳出当前这一次循环，而执行下一次（后续）的循环。

变量循环(索引 = 0,10,1)
	' 当 索引 等于 5 的时候、程序将跳过本次循环，不再执行本次循环后面的代码
	' 但下一次循环仍会继续
	如果(索引 == 5)
		跳过
	结束 如果
	调试输出("索引 = " + 索引)
结束循环

静态

• 英文： static
• 说明： 成员修饰符，在类中使用该修饰符的变量或函数，在使用时不需要创建类型或模块对象，直接使用类名调用即可。注意：网页中的普通JS脚本模块不需要静态修饰，在页面中引用脚本后，可以直接使用变量或函数。

' 使用面向对象方式在自定义类中声明静态变量或函数
定义 公用模块1 为 类
	' 定义一个静态变量，静态函数
	变量 静态 URL地址 = "http://www.vcnstudio.com"
	函数 静态 计算圆形面积(半径)
		返回 3.14 * 半径 * 半径
	结束 函数
结束 定义
' 调用静态方法，无需创建实例
变量 结果 = 公用模块1.计算圆形面积(10)
调试输出(结果)

创建

• 英文： new
• 说明： 对象实例化运算符，用于创建类型的实例对象。

' 创建一个按钮对象
变量 按钮1 = 创建 按钮()
按钮1.文本 = "点击我"
添加组件(按钮1)
调试输出(按钮1.文本)

事件

• 英文： event
• 说明： 定义接收事件语句的关键字，用于接收并处理指定组件的事件，轻语言是事件驱动语言，代码由用户操作或系统事件触发执行。

' 定义接收“按钮1被单击”的事件、回调参数请参考组件的回调接口（interface）中的事件（event）定义
事件 按钮1.被单击(源对象,事件源)
	调试输出("按钮1 被单击")
结束 事件

函数

• 英文： function
• 说明： 定义函数的关键字，创建可重复调用的代码块，支持参数、返回值等特性。

' 函数声明
函数 计算和(参数1, 参数2)
	返回 参数1 + 参数2
结束 函数
' 调用函数
变量 结果 = 计算和(10, 20)
调试输出("计算结果: " + 结果)

未定义

• 英文： undefined
• 说明： 表示声明但未赋值的变量或对象，与‘空’的区别在于‘未定义’表示未初始化，‘空’表示空对象引用。

' 声明但未赋值的变量
变量 未赋值变量
调试输出("变量值: " + 未赋值变量) ' 输出: 变量值: 未定义
调试输出("数据类型: " + 取数据类型(未赋值变量)) ' 输出: 数据类型: undefined
' 检查变量是否未定义
如果(未赋值变量 == 未定义)
	调试输出("变量确实未定义")
结束 如果

本对象

• 英文： this
• 说明： 调用上下文关键字，指向当前代码执行时的上下文对象，例如在类中调用本类中定义的变量，函数。

返回

• 英文： return
• 说明： 函数返回语句，终止函数执行并返回指定值。

' 函数返回值或提前终止执行后续语句
函数 计算(数值)
	如果(数值 < 0)
		返回 0 ' 提前返回
	结束 如果
	返回 数值 * 2 ' 返回计算结果
结束 函数
调试输出(计算(5)) ' 输出: 10
调试输出(计算(-1)) ' 输出: 0

变量循环

• 英文： for
• 说明： 循环结构，包含初始化、循环次数和增量值三部分。支持‘退出’和‘跳过’控制循环流程，是最常用的循环结构。

' 语法：
' 参数一：初始值、指定从什么值开始循环
' 参数二：目标值、指定循环到小于哪个值就退出循环
' 参数三：递增值、每次执行循环代码后初始变量增加的值
' 示例：初始变量为0、目标值为10、每次循环后初始变量加2、当初始变量小于10时、将会退出循环。
变量循环(计次 = 0, 10, 2) ' 等效于 for (let 计次 = 0; 计次 < 10; 计次 += 2){ }
	' 循环打印输出“计次”的值
	调试输出("计次" + 计次)
结束循环

计次循环

• 英文：
• 说明： 简化版变量循环，自动处理计数变量递增，适用于已知次数的循环场景。

' 语法：
' 参数一：总循环次数、指定要循环的总次数
' 参数二：计次变量、循环递增计次的变量、每次递增加1
' 示例：循环 10 次、计次变量从 0 开始、每次计次变量加 1 、当循环 10 次后退出循环。
变量 计次 = 0
计次循环(10,计次)
	' 待循环执行的代码、循环输出 计次 变量的值
	调试输出("计次：" + 计次)
结束循环

判断循环

• 英文： while
• 说明： 判断循环，先判断条件再执行循环体，适合不确定循环次数但需要满足条件才执行的场景。

' 语法：
' 参数一：是否符合条件，如果条件为真则执行循环
' 示例：
' 当变量 计次 的值小于10时、则进入循环体内、循环执行代码块内的代码，每次执行完循环代码、让变量计次的值加1；当计次大于10时、不符合条件则不再进入循环体内、程序将跳到结束循环标志、退出循环。
变量 计次 = 0
判断循环(计次 < 10)
	' 循环执行代码、使变量的值加1
	计次 = 计次 + 1
结束循环
调试输出(计次) ' 将输出 10

结束循环

• 英文：
• 说明： 循环控制语句，用于标记循环体的结束位置，每个合法，正确的循环体语句：变量循环、计次循环、判断循环 都必须使用‘结束循环’收尾。

文本型

• 英文： String
• 说明： 字符串数据类型，表示文本数据（使用引号包裹的常量内容），支持Unicode字符。

' 声明文本型变量，初始值使用引号包裹
变量 姓名 = "张三"
变量 说明 = "这是一个文本型变量示例"
' 文本拼接
变量 全名 = 姓名 + "：" + "李四"
调试输出(全名) ' 输出: 张三：李四
' 文本操作
变量 问候语 = "你好，" + 姓名 + "！"
调试输出(问候语)
' 获取文本长度（统计一串文本中有多少个字符）
变量 长度 = 取文本长度(说明)
调试输出("文本长度: " + 长度)
' 查找字符串变量中是否含有‘文本’这两个字
如果(寻找文本(说明, "文本") >= 0)
	调试输出("找到了'文本'关键词")
结束 如果

数值型

• 英文： number
• 说明： 数字数据类型，包括整数和小数，采用 IEEE 754 双精度格式存储，支持各种数学运算和类型转换。

' 声明数值型变量，支持整数，小数，负数
变量 整数 = 42
变量 小数 = 3.14159
变量 负数 = -10
' 数值运算操作
变量 和 = 整数 + 小数
变量 差 = 整数 - 10
变量 积 = 小数 * 2
变量 商 = 整数 / 3
调试输出("和: " + 和)
调试输出("差: " + 差)
调试输出("积: " + 积)
调试输出("商: " + 商)
' 数学函数运算
变量 平方根 = 取平方根(整数)
变量 绝对值 = 取绝对值(负数)
调试输出("平方根: " + 平方根)
调试输出("绝对值: " + 绝对值)

逻辑型

• 英文： boolean
• 说明： 布尔数据类型，只有‘真’和‘假’两个值，用于条件判断和逻辑运算的基础类型。

' 声明逻辑型变量
变量 a = 真
变量 b = 假
' 逻辑比较运算
变量 与运算 = a 且 b  ' 结果为假
变量 或运算 = a 或 b  ' 结果为真
变量 非运算 = (b == 假) ' 结果为真
调试输出("与运算结果: " + 与运算)
调试输出("或运算结果: " + 或运算)
调试输出("非运算结果: " + 非运算)
' 条件判断中使用逻辑型
如果(a)
	调试输出("条件为真")
结束 如果
' 函数返回逻辑型值
函数 比较数值(值1, 值2)
	返回 值1 > 值2
结束 函数
调试输出("比较结果: " + 比较数值(10, 5)) ' 输出: 比较结果: 真

对象

• 英文： object
• 说明： 对象，表示类型的实体，例如：‘按钮’为一个组件类型，‘按钮1’则表示一个按钮的实体对象。

' 创建对象
变量 人员对象 = {姓名: "张三",年龄: 30,职业: "工程师"}
' 访问对象属性
调试输出("姓名: " + 人员对象.姓名)
调试输出("年龄: " + 人员对象.年龄)
' 修改对象属性
人员对象.年龄 = 31
调试输出("新年龄: " + 人员对象.年龄)
' 对象方法
人员对象.介绍 = ()=>{
	返回 "我是" + 本对象.姓名 + "，今年" + 本对象.年龄 + "岁"
}
调试输出(人员对象.介绍())
' 创建并使用组件对象
变量 按钮1 = 创建 按钮()
按钮1.文本 = "点击我"
按钮1.置被单击回调((源对象, 事件源) => {
	调试输出("按钮被点击")
})

域变量

• 英文： var
• 说明： 声明函数作用域变量的关键字，使用该关键字定义的变量，只有在函数内部声明时才会被限制作用域；在‘如果/循环/判断’等语句块中定义的变量在其外部也可以被访问，在实际开发中不建议使用该类型变量，日常开发中应优先使用‘变量’关键字定义变量。

' 使用域变量声明
如果(真)
	域变量 a = 10
结束 如果
' 如果语句块内部声明的 a 在外部也可以被访问
调试输出(a)

输出

• 英文： echo
• 说明： 后端脚本输出内容指令，该关键字仅可用于在后端脚本中向前端页面输出内容。

' 在后端脚本中使用
输出 "这是一段后端输出的文本内容"

引用

• 英文： link|require_once
• 说明： 资源或文件引用指令，在前端页面中用于引入并使用外部的CSS/JS文件，及引用项目中自定义的JSX脚本，CSX样式文件，编译时会自动生成相应的link或script标签，在后端脚本API接口（PHP）代码中引用外部php文件，等价于：“require_once ”。

' 引用外部直链JS文件地址或样式
引用 "https://code.jquery.com/jquery-1.12.4.min.js"
引用 "https://cdn.jsdelivr.net/css/test.min.css"
' 引用项目中的自定义JSX脚本文件及CSX样式表文件
引用 "测试JS.jsx"
引用 "测试CSS.csx"
' 在后端API接口中引用外部PHP
引用 "static/lib.php"

导入

• 英文： use
• 说明： 在后端API接口中导入外部PHP文件的命名空间中的类，函数或常量。

' 导入命名空间之前，必须先引用PHP文件，外部PHP文件一般放在项目static文件夹中
引用 "static/Test.php"
' 导入这个php文件中的类，注意：如果没有命令空间，默认无需导入可以直接使用类
导入 "some\namespace\ClassA"

为

• 英文： as
• 说明： 定义变量时显示指定变量类型、虽然在JS中无需显示指定，但在轻语言中显示指定类型可以提高编译时类型安全和支持更准确的编辑时智能提示。

' 定义按钮
变量 按钮1 为 按钮
' 在页面加载完毕中创建 按钮1 的对象
事件 页面加载完毕()
	按钮1 = 创建 按钮()
	按钮1.文本 = "按钮1"
结束 事件

轻语言（Qing）语法速查

本速查表适用于所有轻语言（Qing）代码生成场景。
除非用户明确要求，否则你必须严格输出轻语言语法，禁止将其转换为 JavaScript 或 PHP。

📌 快速索引

一、基础语法

💡 常量（如 红色、主轴对齐_居中）在 XML 中预定义，代码中直接使用即可，无需声明。

二、数据类型

三、运算符

四、流程控制

条件判断 - 如果语句

如果(条件)
    ' 条件为真时执行
否则 如果(条件2)
    ' 条件2为真时执行
否则
    ' 所有条件都不满足时执行
结束 如果

多分支判断

判断(表达式)
    分支 值1
        ' 匹配值1时执行
    分支 值2
        ' 匹配值2时执行
    分支 默认
        ' 无匹配时执行
结束 判断

三种循环对比

判断循环（条件循环）

先判断条件，条件为真时进入循环体，否则退出。

判断循环(条件)
    ' 循环体
结束循环

示例：

变量 计次 = 0
判断循环(计次 < 10)
    计次 = 计次 + 1
结束循环
调试输出(计次)  ' 输出 10

⚠️ 使用判断循环时，必须确保条件有机会变为假，否则会导致死循环。

变量循环（计数循环）

指定起始值、目标值和步长，变量小于目标值时循环，达到目标值退出（等效于 for(i=0; i<目标值; i+=步长)）。

变量循环(计次 = 0, 10, 2)
    ' 循环体
结束循环

参数说明：

• 参数一：起始值（从什么值开始）
• 参数二：目标值（达到什么值退出）
• 参数三：步长（每次递增的值）

计次循环（简化计数循环）

指定总循环次数，自动从 0 开始递增。

计次循环(总次数, 计次变量)
    ' 循环体
结束循环

示例：

变量 计次 = 0
计次循环(10, 计次)
    调试输出("计次：" + 计次)
结束循环

循环控制

💡 区别：退出 是“结束整个循环”，跳过 是“不执行本次循环的剩余代码，但继续下一次循环”。调用 跳过 之前的代码仍然会执行。

五、函数

函数定义

函数 函数名(参数1, 参数2)
    ' 函数体
    返回 结果
结束 函数

函数调用

变量 结果 = 函数名(参数1, 参数2)

六、事件

事件有两种等价写法：

映射规则：被单击 ↔ 置被单击回调，被双击 ↔ 置被双击回调

VB6风格示例

使用场景：仅支持 .spldg 设计文件中的组件使用，代码中创建的组件不支持。

事件 按钮1.被单击(源对象, 事件源)
    弹出提示("按钮被点击")
结束 事件

Java风格示例

使用场景：同时支持 .spldg 设计文件和代码创建的组件。

按钮1.置被单击回调((源对象, 事件源) => {
    弹出提示("按钮被点击")
})

七、对象与类

创建对象

变量 按钮1 = 创建 按钮()

设置属性

按钮1.文本 = "点击我"
按钮1.宽度 = 120

调用方法

按钮1.置被单击回调(回调函数)

八、拉姆达表达式

拉姆达表达式在轻语言中只能作为参数传递，不能赋值给变量。

正确用法

' 作为参数传递给组件方法
组件1.置被单击回调((参数1, 参数2) => {
    语句1
    语句2
})

错误用法（禁止）

' ❌ 不能赋值给变量
变量 回调 = (参数) => 表达式

' ❌ 不能作为变量初始值
变量 回调 = (参数) => {
    语句1
}

拉姆达表达式的任何语句体（包含单行语句）必须使用花括号 {} 包裹。

九、变量作用域

💡 日常开发中应优先使用 变量，仅在特殊场景下使用 域变量。

十、常用内置函数

💡 以上仅为常用函数，完整列表请参考 前端(JavaScript)函数 相关文档。

十一、语句块嵌套规则

轻语言支持语句块无限嵌套，但必须注意：

1. 嵌套层次不宜过深：建议不超过 3-4 层，以免影响可读性
2. 结束关键字匹配：每个开始关键字必须与其对应的结束关键字匹配，嵌套时注意层级对应

示例

如果(条件)
    ' 外层条件
    变量循环(计次 = 0, 10, 1)
        ' 内层循环
        如果(内层条件)
            ' 内层判断
        结束 如果
    结束循环
结束 如果

十二、结束语句块规则

在轻语言中，所有流程控制语句、函数、事件等代码块，必须使用对应的关键字显式标记结束位置。

规则表

重要说明

1. 所有控制语句都必须显式结束：轻语言不支持类似 C/Java 中使用花括号 {} 隐式界定代码块的方式。

2. 结束关键字必须与开始关键字匹配：

   • 如果 → 结束 如果（不可写成 结束如果，中间必须有空格）
   • 函数 → 结束 函数
   • 事件 → 结束 事件
   • 判断 → 结束 判断
   • 三种循环（变量循环、计次循环、判断循环）→ 统一使用 结束循环

3. 结束循环 是三种循环的通用结束标记，无论使用哪种循环开始，都用 结束循环 收尾。

正确示例

' 如果语句
如果(条件)
    ' 执行代码
否则 如果(条件2)
    ' 执行代码
否则
    ' 执行代码
结束 如果

' 变量循环
变量循环(计次 = 0, 10, 1)
    ' 循环体
结束循环

' 函数定义
函数 计算(参数1, 参数2)
    变量 结果 = 参数1 + 参数2
    返回 结果
结束 函数

' 事件定义
事件 按钮1.被单击(源对象, 事件源)
    弹出提示("按钮被点击")
结束 事件

错误示例（禁止）

' ❌ 错误：缺少结束标记
如果(条件)
    ' 执行代码

' ❌ 错误：结束标记不匹配
函数 计算(参数)
    ' 函数体
结束 如果

' ❌ 错误：循环使用了错误的结束标记
变量循环(计次 = 0, 10, 1)
    ' 循环体
结束 变量循环

💡 规则总结：任何 如果、函数、事件、定义、判断 以及三种循环语句，都必须使用对应的结束关键字收尾。这是轻语言语法的基础规则，AI 在生成代码时必须严格遵守。

十三、其它重要规则

1. 语句结束符：轻语言使用换行符作为语句结束符，不使用分号。
2. 注释：使用 ' 开头（单引号+空格），不支持 // 或 /* */。
3. 关键字：所有流程控制关键字均为中文（如 如果、否则、结束）。
4. 事件回调：置{事件名}回调 是固定命名规则，不可自由命名。
5. 拉姆达：拉姆达待执行语句必须使用 {} 包裹代码块。
6. 空值判断：使用 空 表示空对象，未定义 表示未初始化的变量。
7. 类型判断：使用 对象 类属 类型 判断对象类型。

AI 使用指南：

1. 当用户要求编写轻语言代码时，必须严格遵循本速查表中的轻语言语法规则。
2. 禁止使用 JavaScript 或 PHP 的语句结构（如 if()、for()、function() {}、return、class 等英文关键字）。
3. 允许调用 JavaScript 或 PHP 的原生内置函数（如 console.log()、count()、json_encode() 等），这些是运行时环境提供的功能，可以直接在轻语言代码中使用。
4. 如果用户明确要求使用其他语言，则按用户要求执行，无需遵循本规则。

相关文档

• 文档轻语言网站：变量与数组与对象的定义 —— 变量、数组、对象、函数、拉姆达的详细用法
• 文档轻语言网站：循环语句体结构 —— 三种循环的详细语法与边界语义
• 文档轻语言网站：界面XML定义规范 —— .spldg XML 写法与组件属性
• 文档轻语言网站：程序入口文件 —— App.spl 入口文件与 网站被访问 事件
• 文档轻语言网站：工程项目结构 —— 项目目录与文件扩展名
• 文档轻语言网站：发送网络请求与接口请求 —— 网络请求
• 文档轻语言网站：服务端脚本程序API接口 —— .sph 后端脚本
• 文档轻语言网站：与原生JS混合开发 —— 原生 JS 混合开发
• 文档轻语言网站：静态资源文件的使用 —— 静态资源引用
• 文档前端(JavaScript)函数_字符串 —— 字符串函数
• 文档前端(JavaScript)函数_数组 —— 数组函数
• 文档前端(JavaScript)函数_对象 —— 对象函数
• 文档前端(JavaScript)函数_JSON —— JSON 函数
• 文档前端(JavaScript)函数_存储 —— 保存配置/读取配置
• 文档综合演示：网页留言板开发 —— 综合实战
• 文档综合演示：XML 定义待办事项列表演示 —— 综合实战
• 文档综合演示：贪吃蛇游戏开发演示 —— 综合实战

轻语言网站：变量与数组与对象的定义

文档概述

轻语言网站开发框架采用 JavaScript 作为底层语言，采用中文关键字，以下为轻语言网站开发中的变量、数组、函数、对象的语句定义与使用。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 变量定义语法：变量 名称 = 初始值 与 变量 名称 为 类型
• 局部变量与页面变量的差异及类型要求
• 函数定义语法：无需声明返回类型与参数类型
• 数组定义与操作：[]、索引访问、增删成员
• 对象定义与操作：{}、点取属性、遍历属性
• 拉姆达表达式的语法与限制（必须用 {} 包裹）

涉及关键字与函数

变量与类型关键字：

数组函数：

对象函数：

变量

在网页开发中，定义局部变量时可以指定数据类型，也可以不指定类型，只需要定义变量名称，或在定义时设置变量的初始值即可，但在定义页面变量时，如果是组件或类必须指定变量类型。

代码示例：

' 定义字符串文本变量
变量 页面变量 = "变量定义测试"

' 定义整数变量
变量 X,Y = 0

' 如果是组件或类，必须显示指定变量类型
变量 页面变量_按钮1 为 按钮

事件 页面加载完毕()
    页面变量_按钮1 = 创建 按钮()
    标签1.文本 = "欢迎使用 VcnStudio 网站开发插件！"
结束 事件

事件 按钮1.被单击(源对象,事件源)
    ' 局部变量无需指定变量类型
    变量 局_数据 = 10
    变量 局_已登录 = 假
    变量 局_URL = "http://www.vcnstudio.com"
    调试输出(局_数据)
    调试输出(局_URL)
结束 事件

变量定义要点

• 局部变量：定义时可省略类型，直接赋初始值即可
• 页面变量：定义组件或类的变量时必须用 为 关键字指定类型
• 批量定义：变量 X,Y = 0 可同时定义多个变量并赋相同初始值
• 逻辑型字面量：使用 真/假 表示真值与假值
• 空值：使用 空 表示空对象

函数

在轻语言网页开发中使用函数时，有返回参数值的函数，无需定义返回类型；直接在函数中返回指定数据值即可。

代码示例：

' 无参数、无返回值的函数
函数 无返回值函数()
    调试输出("无返回值的函数被执行")
结束 函数

' 有返回值的函数、不需要定义返回类型，只需要在函数中返回值即可，
' 函数中的参数也不需要定义任何数据类型，所有参数默认可接收所有数据类型
函数 有返回值的函数(参数一,参数二)
    返回 参数一 + 参数二
结束 函数

函数定义要点

• 使用 函数 ... 结束 函数 定义
• 无需声明返回类型，直接用 返回 值 返回
• 参数无需声明类型，所有参数默认可接收任意数据类型
• 无返回值的函数可省略 返回 语句

数组与对象

数组的定义与使用

数组在轻语言网页开发中采用中括号 [ ] 定义，一个数组也表示用一个中括号包裹的数据值。

代码示例：

' 定义数组，只需要给变量设置初始值为 [ ] 即可
变量 数组1 = [ ]
' 定义含有默认整数值的数组，每个元素使用英文逗号分隔
变量 数组2 = [ 1,2,3]
' 定义含有默认文本值的数组
变量 数组3 = ["欢迎","使用","VcnStudio"]
' 使用数组，取出数组中指定位置的值，索引从 0 开始
' 例如：取出上方 数组3 中的第一个值
调试输出(数组3[0])
' 修改数组指定索引位置的值
' 例如：修改上方 数组3 中第2（索引为1）个值
数组3[1] = "中文编程"
调试输出(数组3)
' 获取数组中有多少个成员
调试输出(取数组成员数(数组3))
' 删除数组中指定索引成员
删除成员(数组3,0)
调试输出(数组3)
' 清空数组
数组3 = []

数组操作要点

• 定义：变量 名称 = [ ] 或 变量 名称 = [值1,值2,...]
• 索引：从 0 开始，通过 数组[索引] 访问
• 修改：数组[索引] = 新值
• 成员数：取数组成员数(数组)
• 删除：删除成员(数组,索引)
• 追加：添加成员(数组,值)（详见函数文档）
• 清空：重新赋值为 []

对象的定义与使用

对象在网页开发中采用花括号 { } 定义，在轻语言网页中，使用花括号包裹的键值对数据值，表示一个对象。

代码示例：

' 定义对象，只需要设置初始值为 { } 即可，表示空对象
变量 对象1 = { }
' 空对象中没有任何属性，可以直接通过对象名称点设置属性
' 例如：给 对象1 设置一个类型的属性
对象1.类型 = "测试空对象"
调试输出(对象1)
' 也可以在定义的时候，通过初始值设置对象的属性与属性值
变量 用户1 = { 名称:"张三",年龄:25 }
调试输出(用户1)
' 修改属性的值，由于属性值是完全自定义的，因此IDE没有属性的智能提示，需要手敲
' 将用户1名称属性的值改为：李四
用户1.名称 = "李四"
调试输出(用户1)
' 获取属性的值
调试输出("用户1的年龄：" + 用户1.年龄)
' 遍历对象中的属性和值
变量循环(i = 0,取对象成员数(用户1),1)
    变量 key = 取对象成员名(用户1,i)
    调试输出("属性名称：" + key + "，属性值：" + 用户1[key])
结束循环
' 删除对象中的指定属性，注意：删除应谨慎操作，可能会影响之前的代码
删除对象属性(用户1,"名称")
调试输出(用户1)

对象操作要点

• 定义空对象：变量 名称 = { }
• 定义带初始值对象：变量 名称 = { 属性1:值1, 属性2:值2 }
• 取属性：对象.属性名 或 对象[属性名]
• 设属性：对象.属性名 = 值
• 遍历属性：变量循环(i = 0, 取对象成员数(对象), 1) + 取对象成员名(对象, i)
• 取属性数：取对象成员数(对象)
• 取属性名：取对象成员名(对象, 索引)
• 删除属性：删除对象属性(对象, "属性名")

拉姆达表达式

轻语言网页中的拉姆达表达式与 JavaScript 语言基本一致，不同的区别为：

1.参数可以省略

代码示例：

' 默认表达式写法，带参数
按钮1.置被单击回调((源按钮,源事件)=>{
    调试输出(源按钮)
    调试输出(源事件)
})
' 如果不需要参数可以省略
按钮1.置被单击回调((源按钮,源事件)=>{
    调试输出("按钮1被单击")
})

什么时候拉姆达表达式的参数可以省略呢？

1.在不需要使用参数的时候。

2.在不使用子程序接收回调事件的时候。

2.被执行的代码必须使用 { } 包裹

代码示例：

按钮1.置被单击回调((源按钮,源事件)=>{
    ' 待执行语句必须在{ }中，哪怕只有一句代码，也必须在{ } 中。
    调试输出("按钮1被单击")
})

错误语法：
按钮1.置被单击回调((源按钮,源事件)=>调试输出("按钮1被单击")) ' 调试输出 函数没有在{ }内，轻语言编译器编译时会报错

注意事项

• 页面变量声明类型：在页面级（不在函数/事件内）声明组件或类变量时必须用 为 关键字指定类型，例如 变量 按钮1 为 按钮；局部变量无此要求。
• 数组索引从 0 开始：取出第 N 个元素用 数组[N-1]。
• 对象属性无智能提示：自定义对象属性 IDE 无法提示，需手敲。
• 遍历对象需用循环：通过 变量循环 + 取对象成员数 + 取对象成员名 遍历对象的属性。
• 拉姆达表达式必须用 {} 包裹：单行表达式体也必须用花括号包裹，否则编译报错。
• 拉姆达只能作为参数传递：不能赋值给变量（详见文档轻语言网站：轻语言语法速查）。
• 空 与 未定义：空 表示空对象（null），未定义 表示未初始化的变量（undefined）。
• 逻辑值字面量：使用 真 / 假，不是 true / false。

学习要点总结

相关文档

• 文档轻语言网站：循环语句体结构 —— 变量循环遍历对象/数组
• 文档轻语言网站：轻语言语法速查 —— 函数定义、作用域、拉姆达限制
• 文档前端(JavaScript)函数_数组 —— 取数组成员数、添加成员、删除成员
• 文档前端(JavaScript)函数_对象 —— 取对象成员数、取对象成员名、删除对象属性
• 文档前端(JavaScript)函数_JSON —— JSON编码/JSON解析
• 文档综合演示：XML 定义待办事项列表演示 —— 对象数组与列表渲染实战
• 文档综合演示：手机移动端记事本网页开发 —— 对象数组与本地存储
• 文档综合演示：网页留言板开发 —— 对象数组增删改查

轻语言网站：循环语句体结构

文档概述

顺序结构的程序语句只能被执行一次；如果要想使同样的操作执行多次，就需要使用循环语句。在轻语言中有 3 种主要的循环语句、每个循环语句都有与之对应的唯一结束标志："结束循环"、用以当不符合条件时结束并退出循环。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 三种循环语句：判断循环、变量循环、计次循环 的语法与适用场景
• 变量循环 的边界语义：左闭右开 [起始值, 目标值)
• 判断循环 的死循环风险与避免方法
• 计次循环 的总次数与计次变量
• 退出 与 跳过 循环控制关键字的区别
• 三种循环统一使用 结束循环 作为结束标记

三种循环对比

判断循环

判断循环是最基本的循环结构语句、只要传入的逻辑值、或逻辑表达式满足条件为真、程序将会进入循环体、并一直重复执行语句块中的代码；判断循环语句使用关键字：判断循环 定义，其语句结构为：

判断循环(条件)
    ' 待执行的语句代码

结束循环

示例：

变量 计次 为 整数型 = 0
判断循环(计次 < 10)
    ' 循环执行代码、使变量的值加1
    计次 = 计次 + 1
结束循环
调试输出(计次) ' 将输出 10

上述代码解释：

• 当变量 计次 的值小于10时、则进入循环体内、循环执行代码块内的代码。每次执行完循环代码、让变量计次的值加1；当计次达到（不小于）10时、不符合条件则不再进入循环体内、程序将跳到结束循环标志、退出循环。

注意：使用判断循环时、确保逻辑值有条件返回假、否则将会导致程序陷入死循环无法退出。

变量循环

变量循环；顾名思义是以变量为开始点、进行循环的结构语句体；因为该语句指定了初始值及目标值、因此在实际开发过程中使用的比较多。该循环使用关键字 "变量循环" 定义。其语句结构为：

变量循环(初始变量 = 初始值, 目标值, 递增值)
    ' 待循环的代码

结束循环

语句释义：

• 参数一：初始值、指定从什么值开始循环
• 参数二：目标值、当初始变量小于目标值时继续循环，达到（不小于）目标值时退出循环
• 参数三：递增值、每次执行循环代码后初始变量增加的值

示例：

变量循环(计次 = 0, 10, 2) 
    ' 循环打印输出"计次"的值
    调试输出("计次" + 计次)
结束循环

上述代码解释：

• 初始变量为0、目标值为10、每次循环后初始变量加2、当初始变量小于10时继续循环，达到（不小于）10时退出
• 等效于 for(计次=0; 计次<10; 计次=计次+2)
• 边界语义为左闭右开区间 [0, 10)：包含 0，不包含 10
• 循环执行 5 次（计次 = 0, 2, 4, 6, 8）

计次循环

计次循环、是以次数限制循环的语句、多用于在处理循环时指定次数的场景。用关键字"计次循环"定义、其循环结构语句为：

计次循环(总循环次数, 计次变量)
    ' 循环执行的代码

结束循环

语句解释：

• 参数一：总循环次数、指定要循环的总次数
• 参数二：计次变量、循环递增计次的变量、每次递增加1

示例：

变量 计次 为 整数型 = 0
计次循环(10,计次)
    ' 待循环执行的代码、循环输出 计次 变量的值
    调试输出("计次：" + 计次)
结束循环

上述代码解释：

• 循环 10 次、计次变量从 0 开始、每次计次变量加 1 、当循环 10 次后退出循环
• 计次变量最终值为 9（最后一次循环），循环结束后值为 10

退出循环

如果在执行循环语句过程中、要在中途结束并退出循环（不再执行后续的循环）；可以使用关键字 "退出" 提前结束循环。例如在下方代码中；当计次等于 5 时、则提前退出并结束循环。

示例：

变量 计次 为 整数型 = 0
判断循环(计次 < 10)
    ' 当执行第5次循环的时候、提前结束并退出循环
    ' 退出循环后、将不再执行后续的循环
    如果(计次 == 5)
        退出
    否则
        ' 执行语句
    结束 如果
    计次 = 计次 + 1
结束循环

跳过循环

如果在执行循环语句过程中、想跳过某一次循环（但仍需要继续执行后续的循环）；可以使用关键字 "跳过" 不执行本次循环语句。例如在下方代码语句中；当计次等于5的时候、则跳过该次循环、但仍然会继续执行后续循环。

示例：

变量循环(索引 = 0,10,1)
    ' 当 索引 等于 5 的时候、程序将跳过本次循环，不再执行本次循环后面的代码
    ' 但下一次循环仍会继续
    如果(索引 == 5)
        跳过
    结束 如果
    调试输出("索引 = " + 索引)
结束循环

使用跳过循环时，需注意只有在调用 "跳过" 关键字后面的代码才不会执行、如果在"跳过" 关键字之前的代码；仍会被执行。

循环控制关键字对比

💡 区别：退出 是"结束整个循环"，跳过 是"不执行本次循环的剩余代码，但继续下一次循环"。调用 跳过 之前的代码仍然会执行。

注意事项

• 三种循环统一用 结束循环：无论使用 判断循环、变量循环、计次循环，结束标记都是 结束循环（不是 结束 判断循环 或 结束 变量循环）。
• 判断循环防死循环：必须确保条件最终会变为假，否则会陷入死循环。
• 变量循环边界：变量循环(i=0, 10, 1) 是左闭右开 [0, 10)，循环 10 次（i = 0~9），不包含 10。
• 计次循环从 0 开始：计次循环(10, 计次) 中计次变量从 0 开始，循环 10 次后计次变量值为 10。
• 退出 与 跳过 区别：退出 结束整个循环，跳过 仅跳过本次循环剩余代码。
• 跳过 后续代码不执行：跳过 关键字之后的代码本次循环不再执行，但下一次循环继续。
• 循环嵌套：循环可嵌套使用，每层循环必须有对应的 结束循环。

学习要点总结

相关文档

• 文档轻语言网站：轻语言语法速查 —— 速查表中的循环对比
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明、数组遍历
• 文档轻语言网站：自定义设计列表内容 —— 列表渲染中的循环用法
• 文档综合演示：贪吃蛇游戏开发演示 —— 游戏循环中的判断循环用法
• 文档综合演示：XML 与使用代码动态创建组件演示 —— 变量循环创建组件
• 文档综合演示：XML 定义待办事项列表演示 —— 列表渲染与遍历
• 文档综合演示：手机移动端记事本网页开发 —— 记事本数据遍历

轻语言网站工程项目结构

文档概述

轻语言网站程序采用标准前端三大件（HTML/CSS/JS）+ 自主设计的中文 WEB 框架设计而成，以轻语言作为第一编程语言，并同时支持可视化界面设计。本章介绍一个标准的轻语言网站程序项目的目录结构、各文件扩展名的含义、以及必备的成对关系（.spl 与 .spldg、.usc 与 .uscdg）。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 轻语言网站项目的标准目录结构
• 各文件扩展名的含义与编译输出目标（.spl/.spldg/.jsx/.js/.sph/.usc/.uscdg）
• 必须成对出现的文件类型及其原因
• App.spl 作为入口文件的位置与作用
• 程序集 与 资源 目录的作用
• .vsln 项目索引文件与 _build 编译输出目录

项目目录结构

标准的轻语言网站程序项目结构文件夹目录为：

• 程序集 存放页面布局文件、页面逻辑、公用模块代码、脚本、自定义组件、CSS 样式表等文件。

  • .spl 实现页面逻辑交互的文件，采用轻语言语法规则编写代码，例如：登录页面.spl

  • .spldg 页面布局设计文件，文件内容采用 XML 格式编写，例如：登录页面.spldg

  • .jsx 使用轻语言语法编写的中文 JS 脚本文件，编译时转换为标准 JS 脚本文件。

  • .js 原生 JS 代码脚本文件、使用 JavaScript 语言编写代码。

  • .sph 后端服务器运行的脚本文件，编译时转换为标准的 PHP 代码文件。

  • .usc 用户自定义组件逻辑交互文件。

  • .uscdg 用户自定义组件的界面设计布局文件。

• 资源 存放静态资源文件，例如：图片、文本、视频、音频等等

• App.spl 在浏览器中打开网站时的入口文件

• *.vsln 项目索引文件

• _build 项目编译输出目录，新建项目时不存在，仅在编译时创建生成。

文件扩展名速查表

💡 命名记忆：dg 是 design 的缩写，表示该文件是对应逻辑文件的"界面设计文件"。例如 .spldg 是 .spl 的设计文件，.uscdg 是 .usc 的设计文件。

App.spl

该文件为网站的启动入口文件、当网站每次重新打开、或被访问的时候、都会先执行该文件、开发者可以在该文件中添加初始化相关代码。

事件 网站被访问()
    切换页面("首页")
结束 事件

💡 详细的入口文件用法请参考文档轻语言网站：程序入口文件。

特别注意

1. .spl 与 .spldg 必须成对

• .spl 与 .spldg 在项目中必须同时成对出现，例如：登录页面.spl、登录页面.spldg
• 两个文件的名称必须相同（不含扩展名）
• 若只存在其一，IDE 与编译器将无法正确处理

2. .usc 与 .uscdg 必须成对

• .usc 与 .uscdg 在项目中必须同时成对出现，例如：计时器.usc、计时器.uscdg
• 同样要求两个文件的名称相同

3. 静态资源路径前缀

• 静态资源文件（图片、音视频等）必须放在 资源（static）目录中
• 代码引用时需带上 ./static/ 前缀，详见文档轻语言网站：静态资源文件的使用

4. 入口文件 App.spl 唯一

• App.spl 是整个网站的入口文件，文件名固定不可更改
• 其中必须包含 网站被访问 事件，详见文档轻语言网站：程序入口文件

5. 编译输出目录 _build

• _build 目录仅在编译时创建，不要手动修改
• 项目部署时通常部署 _build 目录下的输出文件

学习要点总结

相关文档

• 文档轻语言网站：程序入口文件 —— App.spl 入口文件详解
• 文档轻语言网站：界面XML定义规范 —— .spldg/.uscdg XML 写法
• 文档轻语言网站：静态资源文件的使用 —— 资源目录用法
• 文档轻语言网站：服务端脚本程序API接口 —— .sph 后端脚本写法
• 文档综合演示：公用模块全局变量函数使用演示 —— .jsx 公用模块用法
• 文档轻语言网站：与原生JS混合开发 —— .js 原生脚本用法
• 文档轻语言网站：轻语言语法速查 —— .spl 语法规则
• 文档自定义组件 —— .usc/.uscdg 自定义组件开发

轻语言网站程序入口文件

文档概述

程序入口文件为项目中的 App.spl 文件。当网站第一次打开或每次重新被打开（包括刷新）时，浏览器都会先执行该文件，并回调 网站被访问 事件。开发者可以在该文件中做一些程序的初始化工作，或根据用户设备类型切换到指定页面（手机端/桌面端）。

入口文件是整个网站的「路由起点」，是 PC/移动端适配、初始页面路由的常用位置。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 入口文件 App.spl 的作用与执行时机
• 必须存在的 网站被访问 事件及其回调时机
• 使用 切换页面(页面名称) 跳转到指定页面
• 使用 取用户代理头信息() 判断设备类型（Android/Windows/iOS 等）
• 使用 寻找文本(源, 目标) 检测子字符串是否存在
• 通过 UA 字符串实现 PC/移动端自适应路由

涉及函数与关键字

关键字： 事件 ... 结束 事件、变量、如果 ... 否则 如果 ... 结束 如果

入口事件：

• 网站被访问() —— 必须存在，不能删除。每次网站被访问（含刷新）时回调

路由函数：

• 切换页面(页面名称) —— 跳转到指定名称的页面（页面名对应 .spldg/.spl 文件名）
• 切换页面(页面名称, 参数) —— 跳转并传参（详见下方"相关文档"）

UA 探测函数：

• 取用户代理头信息() —— 获取浏览器 User-Agent 字符串
• 寻找文本(源文本, 目标文本) —— 查找子文本位置，未找到返回 -1，找到返回索引（从 0 开始）

默认入口文件代码

事件 网站被访问()
    切换页面("首页")
结束 事件

• 网站被访问 事件是必须存在的，不能删除
• 当浏览器通过域名访问网站时，浏览器将回调该事件
• 你可在该入口中初始化网站所需数据或切换到指定网站页面

进阶：根据设备类型自动切换页面

通过读取浏览器的 User-Agent，可以判断用户设备类型，从而将移动端用户跳转到移动端页面，桌面端用户跳转到桌面端页面。

代码示例：

事件 网站被访问()
    变量 userAgent = 取用户代理头信息()
    如果(寻找文本(userAgent,"Android") != -1)
        切换页面("安卓手机页")
    否则 如果(寻找文本(userAgent,"Windows") != -1)
        切换页面("桌面端页")
    结束 如果
结束 事件

关键代码解读

1. 网站被访问 是入口回调

事件 网站被访问()
    切换页面("首页")
结束 事件

• 该事件在 App.spl 中必须存在，删除会导致网站无法启动
• 浏览器每次打开网站或刷新时都会触发该回调
• 该事件是网站的统一「路由起点」

2. UA 字符串判断设备类型

变量 userAgent = 取用户代理头信息()
如果(寻找文本(userAgent,"Android") != -1)
    切换页面("安卓手机页")
否则 如果(寻找文本(userAgent,"Windows") != -1)
    切换页面("桌面端页")
结束 如果

• 取用户代理头信息() 返回浏览器的 UA 字符串
• 寻找文本(源, 目标) 返回目标文本的位置索引，未找到返回 -1，找到返回 >=0 的索引
• 因此 寻找文本(...) != -1 等价于"包含子字符串"
• 常见 UA 关键字：
  • Android（安卓手机）
  • iPhone（苹果手机）
  • iPad（苹果平板）
  • Windows（Windows 桌面）
  • Macintosh（Mac 桌面）
  • Linux（Linux 桌面）

3. 切换页面

切换页面("首页")

• 参数为页面名称，对应 .spldg/.spl 文件名（不含扩展名）
• 若目标页面不存在会报错
• 也支持带参数跳转：切换页面("首页", 参数对象)，目标页面通过 取请求参数() 取出（详见相关文档）

注意事项

• 网站被访问 事件不可删除：入口文件 App.spl 中必须存在该事件，否则网站无法正常启动。
• 入口文件名固定：入口文件名必须为 App.spl，不可改名。
• UA 判断顺序：UA 探测应将移动端关键字优先判断（如先判断 Android、iPhone），再判断桌面端，避免移动设备 UA 中含兼容性字段误判。
• UA 不可靠：UA 可被浏览器或用户篡改，关键判断不能完全依赖 UA；如需要严格判断可结合屏幕宽度等综合判断。
• 每次刷新都会触发：刷新页面也会再次执行 网站被访问，因此该事件中适合做幂等的初始化操作。
• 寻找文本 返回 -1 表示未找到：判断子字符串存在用 != -1，不要用 > 0（索引可能为 0）。
• 目标页面必须存在：切换页面(页面名) 中页面名必须对应实际的 .spldg/.spl 文件，否则报错。

学习要点总结

相关文档

• 文档轻语言网站：工程项目结构 —— 项目目录与 App.spl 的位置
• 文档轻语言网站：界面XML定义规范 —— .spldg 页面文件写法
• 文档轻语言网站：循环语句体结构 —— 流程控制语法
• 文档轻语言网站：轻语言语法速查 —— 事件、条件判断语法
• 文档前端(JavaScript)函数_字符串 —— 寻找文本 等字符串函数
• 文档前端(JavaScript)函数_浏览器 —— 取用户代理头信息 等 UA 相关函数
• 文档综合演示：手机移动端记事本网页开发 —— 移动端页面（类型="wap"）的开发示例
• 文档综合演示：网页留言板开发 —— 多页面切换与参数传递示例
• 文档综合演示：XML 与使用代码动态创建组件演示 —— 切换页面与取请求参数的用法

轻语言（Qing）XML 界面定义规范

文档概述

轻语言（Qing）框架支持两种 UI 创建方式：

1. 纯代码方式：在 .spl 文件中使用 创建 [类名]() 动态创建界面
2. XML 定义方式：在 .spldg 文件中用 XML 描述界面结构，在 .spl 中通过组件名称引用

XML 定义方式适合界面结构固定、可视化设计的场景，让 UI 与逻辑分离。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• .spldg XML 文件的基本结构（<页面> 根节点 + 布局容器）
• PC 端页面与移动端页面（类型="wap"）的差异
• 通用组件 XML 写法：<组件标签 名称="组件名" 属性="值" />
• 组件的 名称 属性在 .spl 代码中的引用方式
• XML 属性与代码属性/方法的对应关系
• 宽高/坐标必须用纯数字、字体大小等需带 px 单位的规则
• .spldg 与 .spl 必须成对存在且文件名相同

XML 文件基本结构

根节点：<页面>

每个 .spldg 文件必须以 <页面> 为根节点，定义页面级属性。

PC电脑网站页面：

<页面 标题="页面标题" 宽度="500" 高度="300">
    <!-- 页面内容 -->
</页面>

手机移动端页面：

<页面 标题="页面标题" 宽度="500" 高度="300" 类型="wap">
    <!-- 页面内容 -->
</页面>

PC电脑网站页面不需要指定类型，手机移动端页面必须设置页面类型属性，属性值必须为：wap

页面属性说明：

布局容器：<绝对布局> / <弹性布局>

页面内的第一层必须是布局容器，用于组织子组件，除非特别说明，默认根布局只能为：绝对布局。

<页面 标题="首页" 宽度="500" 高度="300">
    <绝对布局 名称="根布局" 宽度="100%" 高度="100%">
        <!-- 子组件 -->
    </绝对布局>
</页面>

布局属性说明：

注意：所有布局、尺寸类属性（左边、顶边、宽度、高度）都必须用纯数字，不能出现 "自适应"、"auto"、"wrap_content" 这类文本值。

组件 XML 写法

通用规则

所有组件在 XML 中的写法为：

<组件标签 名称="组件名" 属性1="值1" 属性2="值2" />

• 组件标签：对应组件类名（如 按钮、标签、编辑框）
• 名称属性：必须，用于在 .spl 代码中引用该组件
• 其他属性：对应组件的属性名，值使用字符串或数值

常用组件示例

1. 标签（Label）

<标签 名称="标题标签" 左边="20" 顶边="20" 宽度="200" 高度="40" 
      文本="欢迎使用" 字体大小="24" 文本颜色="#333" />

2. 按钮（Button）

<按钮 名称="登录按钮" 左边="20" 顶边="100" 宽度="120" 高度="40" 
      文本="登录" 背景颜色="#1890ff" 文本颜色="#ffffff" />

3. 编辑框（TextBox）

<编辑框 名称="用户名框" 左边="20" 顶边="60" 宽度="200" 高度="32" 
         提示文本="请输入用户名" />

4. 密码框

<编辑框 名称="密码框" 左边="20" 顶边="100" 宽度="200" 高度="32" 
         提示文本="请输入密码" 类型="password" />

5. 图片框（ImageBox）

<图片框 名称="头像" 左边="20" 顶边="20" 宽度="60" 高度="60" 
         图片="static/avatar.jpg" 图片显示模式="cover" />

6. 弹性布局（FlexLayout）

<弹性布局 名称="主容器" 宽度="100%" 高度="100%" 
          方向="column" 主轴对齐="center" 侧轴对齐="center">
    <!-- 子组件 -->
</弹性布局>

在 .spl 代码中引用 XML 定义的组件

在 XML 中定义了 名称 属性的组件，可以在 .spl 代码中直接通过名称访问其属性和方法。

示例：完整的登录界面

界面文件：登录页面.spldg

<?xml version="1.0" encoding="utf-8"?>
<页面 标题="用户登录" 宽度="667" 高度="424" 背景颜色="#f5f5f5">
  <绝对布局 名称="根布局">
    <弹性布局 名称="弹性布局_登录框" 左边="80" 顶边="42" 高度="265" 宽度="500" 方向="column" 子项间距="20px" 侧轴对齐="center">
      <标签 名称="标签_1" 文本="登录账号" 字体粗细="bold" 字体大小="30px" />
      <表单输入框 名称="表单输入框_用户名" 标题="用户名" 提示文本="请输入用户名" />
      <表单输入框 名称="表单输入框_密码" 标题="密码" 提示文本="请输入密码" 输入类型="password" />
      <按钮 名称="按钮_登录" 文本="登录" 背景颜色="#1890ff" 文本颜色="#ffffff" 边框圆角="4" 高度="40" 宽度="120" />
      <标签 名称="标签_小字备注" 文本="登录小字备注信息" 文本颜色="#5E5B59" />
    </弹性布局>
  </绝对布局>
</页面>

逻辑文件：登录页面.spl

'* ******************************************************************************
'* 版权说明：Copyright（C） All Rights Reserved VcnStudio
'* 程序版本：V1.0
'* 文件描述：登录页面逻辑
'* 修改日志：
'* ******************************************************************************

' 页面变量，整个页面都能使用
变量 页面变量 = "用户登录页面"

' ========== 页面加载事件 ==========
事件 页面加载完毕()
    ' 页面加载后，可以做一些初始化操作
    调试输出("登录页面已加载")
    ' 例如：设置表单宽度占满登录框布局
    置组件宽度("100%",表单输入框_用户名,表单输入框_密码,按钮_登录)
    ' 将整个登录框水平垂直居中到页面中间
    置组件居中(弹性布局_登录框)
    ' 使用原生css样式值设置“小字备注”标签靠左显示
    标签_小字备注.置内联样式("align-self","flex-start")
    ' 如果想让登录框靠上一点，可以取出登录框的实际高度减去一些值
    弹性布局_登录框.顶边 = 弹性布局_登录框.取渲染顶边() - 100
结束 事件

' ========== 登录按钮点击事件 ==========
事件 按钮_登录.被单击(源对象,事件源)
    变量 用户名 = 表单输入框_用户名.内容
    变量 密码 = 表单输入框_密码.内容
    如果(用户名 == "" 或 密码 == "")
        弹出提示("用户名或密码不能为空！")
        返回
    结束 如果
    ' 发送登录请求
    变量 待提交数据 = "username=" + 用户名 + "&password=" + 密码
    请求接口("Api1", "登录账号", (结果,标记) => {
        变量 响应 = JSON解析(结果)
        如果(响应.code == 0)
            保存配置("token", 响应.token)
            切换页面("首页")
        否则
            弹出提示("登录失败：" + 响应.msg)
        结束 如果
    },待提交数据)
结束 事件

XML 属性与代码属性的对应关系

注意事项

• .spldg 与 .spl 必须成对：界面文件和逻辑文件的名称必须相同且必须同时存在。例如：登录页面.spl、登录页面.spldg 必须同时存在；其中 .spldg 是 spl design 的缩写，意为"逻辑文件的界面设计文件"。
• 尺寸与坐标用纯数字：宽度、高度、左边、顶边、右边、底边等赋值时使用整数值（不带单位）。
• 字体大小等需带 px 单位：圆角、字体大小等都必须带默认单位 px，例如：按钮1.字体大小 = "30px"。
• 名称 属性必须唯一：每个组件在 XML 中的 名称 属性必须唯一，用于在 .spl 中引用。
• PC 与移动端差异：PC 端页面无需 类型 属性；移动端页面必须设置 类型="wap"。
• 根布局只能为绝对布局：除非特别说明，默认页面根布局只能为 绝对布局。

AI使用指南

当用户询问关于界面布局的问题时，你需要：

1. 判断用户使用的是纯代码方式还是 XML 定义方式

2. 如果用户想用 XML 定义界面：

   • 提供 .spldg 文件的结构和组件 XML 写法

   • 组件名称必须唯一，用于在 .spl 中引用

   • 事件绑定在 .spl 中使用 事件 组件名.事件名

3. 如果用户想用纯代码方式：

   • 使用 创建 类名() 创建实例

   • 设置属性、添加事件、添加到布局

相关文档

• 文档轻语言网站：工程项目结构 —— .spldg/.spl 成对要求
• 文档轻语言网站：轻语言语法速查 —— 事件定义语法、组件属性
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明
• 文档布局类组件_绝对布局 —— 绝对布局属性
• 文档布局类组件_弹性布局 —— 弹性布局属性
• 文档文本类组件_标签 —— 标签属性
• 文档按钮类组件_按钮 —— 按钮属性
• 文档输入类组件_编辑框 —— 编辑框属性
• 文档图像类组件_图片框 —— 图片框属性
• 文档前端(JavaScript)函数_布局 —— 置组件宽度/置组件居中 等
• 文档综合演示：XML 定义待办事项列表演示 —— XML 界面定义实战
• 文档综合演示：XML 与使用代码动态创建组件演示 —— 代码创建组件实战
• 文档综合演示：网页留言板开发 —— 登录界面与表单提交实战
• 文档综合演示：手机移动端记事本网页开发 —— 移动端 类型="wap" 实战

轻语言网站：与原生JS混合开发

文档概述

在轻语言网页开发中，其界面逻辑代码文件（.spl）、与 .jsx 文件代码可以与原生 JS 代码或引用外部 js 文件混合开发，也可以直接使用原生 JS 函数、即浏览器支持的任意 API 函数。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 使用 引用 "URL" 引入外部 JS 文件（CDN 或项目内 ./static/）
• 直接调用原生 JS 内置函数：alert()、console.log() 等
• 使用 document.createElement 创建原生 DOM 元素并加入布局
• 使用 创建 Date() 创建原生 JS 对象
• 调用引入的 JS 库中的函数（如 jQuery 的 $.get）
• 同源策略与跨域（CORS）限制
• 通过 根布局.添加组件(原生元素) 将原生 DOM 加入轻语言布局

涉及关键字与函数

关键字： 引用、变量、事件 ... 结束 事件、创建

引用语句：

• 引用 "网络URL" —— 引入 CDN 上的 JS 文件
• 引用 "./static/路径" —— 引入项目内 static 目录的 JS 文件

原生 JS API：

• alert(文本) —— 弹出提示框
• console.log(内容) —— 控制台输出
• document.createElement(标签名) —— 创建 DOM 元素
• 创建 Date() —— 创建原生 Date 对象
• $.get(地址, 回调) —— jQuery 的 GET 请求

布局方法：

• 布局.添加组件(原生元素) —— 将原生 DOM 元素添加到轻语言布局

使用原生JS文件

代码示例：

' 添加并引用网络地址的 jquery
引用 "https://apps.bdimg.com/libs/jquery/2.1.4/jquery.min.js"

' 添加并引用项目资源文件夹中的外部js库
' 注意：需要添加 "./static/" 资源文件夹的路径前缀，添加网络CDN地址不需要
引用 "./static/js/lunar.min.js"

事件 页面加载完毕()
	
结束 事件

事件 按钮1.被单击(源对象,事件源)
	变量 局_Solar = Solar.fromDate(创建 Date())
    调试输出(局_Solar)
    ' 转阴历
    变量 局_阴历 = 局_Solar.getLunar()
    调试输出(局_阴历.toString())
    调试输出(局_阴历.toFullString())
结束 事件

事件 按钮2.被单击(源对象,事件源)
    ' 注意：这里由于同源策略的安全限制，请求地址只能为同一个IP或域名的地址
    ' 如果直接访问非本源地址，会报跨域错误 Access-Control-Allow-Origin
    $.get("http://www.vcnstudio.com/",(请求结果)=>{
        调试输出(请求结果)
    })
结束 事件

引用外部 JS 要点

• CDN 地址：引用 "https://..." 直接引入网络 JS 文件
• 项目内 JS：引用 "./static/..." 必须带 ./static/ 前缀
• 引用位置：引用 语句写在文件顶部（事件外）
• 调用库函数：引用后可直接使用库中的全局对象，如 Solar.fromDate()、$.get()
• 跨域限制：使用 $.get 等网络请求受同源策略限制

使用JS原生函数

代码示例：

事件 按钮3.被单击(源对象,事件源)
    ' 轻舟网站开发支持直接与原生JS代码混合开发，以及直接使用原生JS函数
    ' 例如：
    ' 网页开发中常见的内置函数，console.log()、alert() 等等
    alert("我是原生Js函数调用的信息框")
    console.log("我是原生js函数调用的控制台输出信息")
结束 事件

事件 按钮4.被单击(源对象,事件源)
    ' 使用纯JS代码创建网页元素
    变量 mBtn = document.createElement("button")
    ' 通过 style 属性设置元素样式
    mBtn.style.width = "200px"
    mBtn.style.height = "100px"
    mBtn.style.backgroundColor = "lightblue"
    mBtn.style.border = "1px solid black"
    mBtn.style.textAlign = "center"
    mBtn.style.lineHeight = "100px"
    mBtn.style.position = "absolute"
    mBtn.style.top = "300px"
    mBtn.style.left = "300px"
    ' 注册组件被单击事件
    mBtn.addEventListener("click",()=>{
        mBtn.textContent = "你点击了这个 div!"
        ' 改变背景颜色
        mBtn.style.backgroundColor = "lightgreen" 
    })
    ' 设置元素文本（这里我们创建的是一个按钮）
    mBtn.textContent = "这是一个使用JS创建的按钮"
    ' 将组件添加到页面根布局中
    根布局.添加组件(mBtn)
结束 事件

原生 JS 函数使用要点

• 内置函数直接调用：alert()、console.log()、document.createElement() 等
• 创建原生对象：创建 Date() 创建原生 JS 对象（创建 关键字替代 new）
• DOM 操作：可直接操作 style、addEventListener、textContent 等原生属性
• 混入布局：通过 布局.添加组件(原生元素) 将原生 DOM 元素加入轻语言布局中
• 事件注册：使用原生 addEventListener("click", 回调) 注册事件

注意事项

• 引用位置：引用 语句必须写在文件顶部（所有事件/函数之外）。
• 项目内 JS 需带前缀：引用 static 目录的 JS 文件必须带 ./static/ 前缀；CDN 地址不需要。
• 同源策略：使用 $.get 等原生网络请求时，请求地址只能为同源（同 IP/域名）地址，跨域会报 Access-Control-Allow-Origin 错误。
• 创建 替代 new：创建原生 JS 对象时使用 创建 类名()，而非 new 类名()。
• DOM 元素加入布局：原生 document.createElement 创建的元素通过 布局.添加组件(元素) 加入轻语言布局。
• 库函数依赖引用：使用库中函数前必须先 引用 对应的 JS 文件，否则会报"未定义"错误。
• 跨域解决方案：如需跨域请求，服务端需配置 CORS 响应头，或使用 JSONP、代理等方式。

学习要点总结

相关文档

• 文档轻语言网站：静态资源文件的使用 —— ./static/ 资源引用
• 文档轻语言网站：发送网络请求与接口请求 —— 轻语言原生网络请求
• 文档轻语言网站：轻语言语法速查 —— 创建 关键字与对象创建
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明
• 文档轻语言网站：工程项目结构 —— .jsx 与 .js 文件的位置
• 文档综合演示：公用模块全局变量函数使用演示 —— .jsx 公用模块用法
• 文档综合演示：贪吃蛇游戏开发演示 —— 原生 JS 与轻语言混合开发实战

轻语言网站：发送网络请求与接口请求

文档概述

网络操作是现代网站程序开发中不可或缺的一部分，通过网络操作可以实现在前端对后端数据的链接，使程序更强大、功能更丰富。

在轻语言网站开发中，同样也支持网络操作，即在页面中与后端通信。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 发送GET请求 的用法：单个请求与批量请求
• 发送POST数据 的用法：单个请求与批量请求
• 请求接口 函数：仅支持请求当前项目中的 .sph 后端脚本
• 通过子函数 + 标记（标记）实现批量请求的统一回调
• 拉姆达表达式接收请求结果的写法
• 跨域（CORS）限制与同源策略
• 部署到 PHP 环境才能看到效果的注意事项

涉及函数

回调函数签名： (请求结果, 标记) => { ... } 或 函数 子函数名(请求结果, 标记)

函数：发送GET请求

代码示例：

事件 按钮1.被单击(源对象,事件源)
    ' 单个请求可以直接使用 拉姆达表达式 接收请求结果
    变量 目标地址 = "http://localhost/dny/Api.php?a=测试输出"
    发送GET请求(目标地址,(请求结果,标记)=>{
        编辑框1.内容 = "单次GET请求：" + 请求结果
    })
结束 事件

事件 按钮3.被单击(源对象,事件源)
    ' 同时发送多个请求、可采用子函数接收请求结果，并通过标记区分
    变量 目标主机地址 = "http://localhost/dny/Api.php?a="
    发送GET请求(目标主机地址 + "Test2",接收GET请求子函数,"Test2")
    发送GET请求(目标主机地址 + "Test3",接收GET请求子函数,"Test3")
结束 事件

' 将请求集中到一个子函数中处理，通过标记区分
' 这个函数需要手动创建，函数名可以任意起名，但参数必须为：请求结果，标记
函数 接收GET请求子函数(请求结果,标记)
    编辑框1.追加文本行("批量GET请求标记：" + 标记 + "，请求结果：" + 请求结果)
结束 函数

GET 请求要点

• 单个请求：使用拉姆达表达式 (请求结果,标记) => { ... } 接收结果
• 批量请求：使用子函数名 + 标记，统一在子函数中通过标记区分来源
• 回调参数：固定为 (请求结果, 标记)，即使不用也不能省略参数位置
• 标记用途：批量请求时区分不同请求的来源

函数：发送POST数据

代码示例：

事件 按钮2.被单击(源对象,事件源)
    变量 目标地址 = "http://localhost/dny/Api.php?a=Post1"
    发送POST数据(目标地址,"key=VcnStudio666",(请求结果,标记)=>{
        编辑框1.内容 = "POST1：" + 请求结果
    })
结束 事件

事件 按钮4.被单击(源对象,事件源)
    变量 目标主机地址 = "http://localhost/dny/Api.php?a="
    发送POST数据(目标主机地址 + "Post1","key=123",接收POST请求子函数,"","Post1")
    发送POST数据(目标主机地址 + "Post2","sign=123456",接收POST请求子函数,"","Post2")
结束 事件

' 与接收GET请求的回调一样，其实可以直接回调函数指向GET请求子函数接收
' 但是为了便于区分，因此POST采用单独的子函数处理回调
函数 接收POST请求子函数(请求结果,标记)
    编辑框1.追加文本行("批量POST请求标记" + 标记 + "，请求结果：" + 请求结果)
结束 函数

POST 请求要点

• 数据格式：键值对字符串，如 "key=VcnStudio666" 或 "key=123&sign=abc"
• 批量请求：发送POST数据(地址, 数据, 子函数名, "", 标记)，第 4 个参数为空串占位
• 回调与 GET 一致：参数固定为 (请求结果, 标记)

函数：请求接口

"请求接口"函数仅支持请求当前项目中使用轻语言编写的后端脚本文件，不支持请求外部网站。

代码示例：

请求接口测试页面.spl

事件 按钮5.被单击(源对象,事件源)
    ' 请求接口 函数是对 GET与POST 请求的一个封装
    ' 仅支持直接访问当前程序中编写的后端接口中的函数，例如：分别访问GET与POST
    ' 发送GET请求
    请求接口("Api","Test1",(请求结果,标记)=>{
        编辑框1.追加文本行("通过接口请求发送GET请求：" + 请求结果)
    })
    ' 发送POST请求
    请求接口("Api","Post1",(请求结果,标记)=>{
        编辑框1.追加文本行("通过接口请求发送POST请求：" + 请求结果)
    },"key=123")
结束 事件

Api.sph

' ****************************************************************************
' 版权说明：Copyright（C） All Rights Reserved VcnStudio
' 程序版本：V1.0
' 文件描述：服务端脚本文件、最终将会编译成 PHP 源代码，
' 　　　　　可在该文件中操作数据库增删改查、读写服务器中的文件。
' 修改日志：
' ****************************************************************************
' 向客户端发送服务器的响应报头（Response Header）
置响应头("Content-Type: text/html; charset=utf-8")
置响应头("Content-Language: zh-CN")

' 引用轻语言封装的PHP核心库，注：如果要删除该引用请确保当前文件中未使用轻语言封装的函数
引用 "library/qing.core.php"

' 调用主函数："文件被访问"、即当在任何前端中访问该文件时，地址中不带任何参数名，都将会先调用该函数
文件被访问()

' 入口函数，函数名可自定义命名，主要作用：
' 当本文件被访问时，获取其前端传来的请求参数值，根据请求参数值调用当前文件中的函数
函数 文件被访问()
    ' 通过URL中的键参获取要执行的函数，这里我们默认规定键名为"a"，例如：
    ' 前端请求地址为：http://xxx.com/本文件名.php?a=测试输出
    ' 其"a"后面的值"测试输出"即为我们要执行的函数，使用"取请求值"函数将其取出后，然后执行。
    变量 待执行函数名 = 取请求值("a")
    如果(为空(待执行函数名))
        输出 "待执行函数不能为空"
    否则
        ' 增加安全验证，只允许执行我们定义的函数
        变量 可被执行的函数列表 = [ "Test1", "Post1" ]
        如果(取成员是否存在(可被执行的函数列表,待执行函数名) == 真)
            输出 执行函数(待执行函数名)
        否则
            输出 "请求执行非法的函数"
        结束 如果
    结束 如果
结束 函数

' 在前端通过发送GET、POST请求、或使用"请求接口"函数调用该函数，或直接在浏览器中访问下面地址
' 地址：http://xxx.com/Api.php?a=Test1
函数 Test1()
    输出 "你发送的请求接收成功；这是反馈信息！"
结束 函数

' 向前端输出当前格式化后的时间信息
' 地址：http://xxx.com/Api.php?a=Post1
函数 获取时间()
    输出 "收到的POST参数：" + 取请求值("key")
结束 函数

请求接口 要点

• 仅限项目内：请求接口 只能请求当前项目中用轻语言编写的 .sph 文件
• 参数1（脚本名）：对应 .sph 文件名（不带扩展名），如 "Api"
• 参数2（函数名）：要调用的后端函数名（会被赋值给 URL 的 a 参数）
• GET 请求：请求接口("Api", "Test1", 回调)
• POST 请求：请求接口("Api", "Post1", 回调, "key=123")
• 回調签名：(请求结果, 标记) => { ... }

三种请求方式对比

注意事项

• 需部署到 PHP 环境：在页面中发送网络请求，需要将编译输出的程序部署到支持 PHP 环境的本地 WEB 环境或上传到服务器中，然后打开网页才能看到效果。
• 同源策略与跨域：发送GET请求/发送POST数据 受浏览器同源策略限制，请求非同源地址会报 Access-Control-Allow-Origin 错误。若需跨域，服务端需配置 CORS 响应头。
• 请求接口 无跨域问题：由于 请求接口 请求的是当前项目内的后端脚本，属于同源请求，不存在跨域问题。
• 批量请求的回调签名：子函数的参数必须为 (请求结果, 标记)，即使不使用标记也必须保留参数位置。
• POST 数据格式：键值对字符串 "key=value"，多个参数用 & 连接："key1=value1&key2=value2"。
• 异步请求：所有请求均为异步，通过回调接收结果，不能直接在请求后立即使用结果。
• 拉姆达回调：单次请求可用拉姆达表达式接收；批量请求建议用子函数统一处理。

学习要点总结

相关文档

• 文档轻语言网站：服务端脚本程序API接口 —— .sph 后端脚本写法
• 文档轻语言网站：与原生JS混合开发 —— 使用 $.get 等 jQuery 网络请求
• 文档轻语言网站：轻语言语法速查 —— 拉姆达表达式语法
• 文档前端(JavaScript)函数_网络请求 —— 网络请求函数详解
• 文档综合演示：网页留言板开发 —— 前后端联调实战
• 文档综合演示：MySQL数据库操作 —— 后端接口操作数据库
• 文档综合演示：WebSocket使用演示 —— WebSocket 实时通信

轻语言网站：静态资源文件的使用

文档概述

网站程序中的所有图片、文本或其它资源文件都必须存放在项目根目录中的 static 文件夹中（即「资源」目录）。在页面代码中使用时，需带上 ./static/ 前缀。本章介绍图片、字体、音频、视频、SVG、图标、JSON/文本等常见资源文件的使用方法。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 静态资源目录的位置与 ./static/ 路径前缀
• 图片资源的赋值方式：图片框.图片 = "./static/logo.jpg"
• 自定义字体文件的引入：添加字体文件 + 字体名引用
• 音频播放与浏览器自动播放策略限制
• 视频播放与尺寸设置
• SVG 图片的两种引入方式：置SVG代码 与 加载SVG文件
• 图标（favicon.ico）的放置位置
• 读取 JSON 与文本文件内容：读JSON文件/读文本文件
• 浏览器同源策略与本地服务器环境的必要性

涉及组件

涉及函数与关键字

关键字： 事件 ... 结束 事件、变量

资源引用方式：

• 相对路径前缀 ./static/ —— 项目内静态资源
• 网络地址（http:///https://） —— 外部 CDN 或远程资源

字体函数：

• 添加字体文件(字体名, 路径, 回调) —— 注册自定义字体，加载完成回调

文件读取函数：

• 读JSON文件(路径, 回调, 是否解析) —— 读取 JSON 文件，回调返回对象或文本
• 读文本文件(路径, 回调) —— 读取文本文件，回调返回文本内容

音频视频属性：

• 音频地址 / 视频地址 —— 设置媒体源
• 视频宽度 / 视频高度 —— 设置视频显示尺寸
• 自动播放 / 开始播放() —— 音频播放控制（受浏览器策略限制）

SVG 方法：

• 置SVG代码(SVG代码文本) —— 直接设置 SVG 源码
• 加载SVG文件(路径) —— 从文件加载 SVG

网站开发常见的资源文件

• 字体文件：用于引入自定义字体，常见格式有 .ttf、.woff、.woff2 等。
• 音频文件：用于网页中的音效、背景音乐等，常见格式有 .mp3、.wav、.ogg 等。
• 视频文件：用于网页中的视频内容，常见格式有 .mp4、.webm、.ogg 等。
• 图标文件：用于网页中的各种图标，常见格式有 .ico、.svg 等，也可以使用图标字体库如 Font Awesome。
• 数据文件：用于存储网页需要的数据，常见格式有 .json、.xml、.csv 等。
• PDF 文件：用于在网页中嵌入或链接 PDF 文档。
• SVG 文件：用于矢量图形，可以直接嵌入 HTML 或作为单独文件引用。

代码使用示例

' 1.图片资源文件的使用
图片框1.图片 = "./static/logo.jpg"

' 2.自定义字体文件的使用
添加字体文件("myfont","./static/fonts/custom.font.ttf",()=>{
    标签1.字体 = "myfont"
})

' 3.播放音频文件
音频播放器1.音频地址 = "../static/music2.mp3"
' 自动播放限制：现代浏览器（Chrome、Firefox、Safari 等）都实现了自动播放策略，但要求用户必须先与页面交互才能播放媒体。
' Promise 拒绝：开始播放函数 返回一个 Promise，当播放被阻止时，这个 Promise 会被拒绝并抛出 NotAllowedError。
' 安全策略：这是浏览器的安全机制，防止网站在用户不知情的情况下播放音频或视频。
' 因此下方两句代码在大部分浏览器中不会生效、必须让用户点击才能播放
'音频播放器1.自动播放 = 真
'音频播放器1.开始播放()

' 4、播放视频文件、由于本地没有找到合适的小素材资源文件作演示，这里使用菜鸟教程里面的一个视频地址
视频播放器1.视频地址 = "https://www.runoob.com/try/demo_source/movie.mp4"
' 视频宽度和元素宽度要手动设置保持一致
视频播放器1.视频宽度 = 320
视频播放器1.视频高度 = 240

' 5.图标文件、图标文件比较简单，只需要在编译输出的项目根目录中
' 放置一个名称为：favicon.ico 的图标文件即可，不需要做其它处理

' 6.置SVG图片
SVG图像框1.置SVG代码("<svg width=\"100\" height=\"100\" viewBox=\"0 0 100 100\"><circle cx=\"50\" cy=\"50\" r=\"40\" fill=\"blue\" /></svg>")
SVG图像框2.加载SVG文件("./static/timer.svg")

读取JSON或文本文件内容

事件 按钮1.被单击(源对象,事件源)
    ' 读取JSON数据文件，并解析
    ' 注意：不能直接在浏览器中打开html页面，需要有服务器环境
    调试输出("读取JSON文件：")
    读JSON文件("./static/jsondata.json",(JSON对象)=>{
        调试输出(JSON对象)
    },真)
结束 事件

事件 按钮2.被单击(源对象,事件源)
    读文本文件("./static/data.txt",(文本内容)=>{
        调试输出(文本内容)
    })
结束 事件

注意：

除了图片、音视频资源与脚本文件之外，使用其它任何资源文件时，都必须在本地服务器环境中打开页面才有效，直接在浏览器中打开 .html 文件将无效。

关键代码解读

1. 图片资源引用

图片框1.图片 = "./static/logo.jpg"

• 必须带 ./static/ 前缀（项目内资源）
• 也可使用网络地址：图片框1.图片 = "https://..."
• .spldg XML 中设置图片属性写法：图片="./static/avatar.jpg"

2. 自定义字体加载

添加字体文件("myfont","./static/fonts/custom.font.ttf",()=>{
    标签1.字体 = "myfont"
})

• 添加字体文件 异步加载字体文件
• 参数：字体名（自定义）、路径、加载完成回调
• 字体加载是异步的，必须在回调中才能使用该字体
• 支持格式：.ttf、.woff、.woff2 等

3. 音频播放与浏览器自动播放限制

音频播放器1.音频地址 = "../static/music2.mp3"
'音频播放器1.自动播放 = 真       ' 大部分浏览器不生效
'音频播放器1.开始播放()           ' 大部分浏览器不生效

• 现代浏览器（Chrome、Firefox、Safari）都实施了自动播放策略
• **必须用户先与页面交互（点击等）**才能播放媒体
• 开始播放() 返回 Promise，被阻止时会抛 NotAllowedError
• 这是浏览器的安全机制，防止网站在用户不知情的情况下播放音视频
• 解决方案：在按钮点击事件中调用 开始播放()

4. 视频播放

视频播放器1.视频地址 = "https://www.runoob.com/try/demo_source/movie.mp4"
视频播放器1.视频宽度 = 320
视频播放器1.视频高度 = 240

• 视频地址可为本地 ./static/ 路径或网络地址
• 视频宽高需手动设置，与组件尺寸保持一致
• 跨域视频需服务端配置 CORS

5. 网站图标 favicon

项目根目录（编译输出目录）放置：favicon.ico

• 网站图标无需代码处理
• 只需在编译输出目录根中放置一个名为 favicon.ico 的文件
• 浏览器会自动请求该文件作为标签页图标

6. SVG 图片两种引入方式

' 方式一：直接写 SVG 源码
SVG图像框1.置SVG代码("<svg width=\"100\" height=\"100\" viewBox=\"0 0 100 100\"><circle cx=\"50\" cy=\"50\" r=\"40\" fill=\"blue\" /></svg>")

' 方式二：从文件加载
SVG图像框2.加载SVG文件("./static/timer.svg")

• 置SVG代码 直接传入 SVG 源码字符串，适合动态生成或小段 SVG
• 加载SVG文件 从 ./static/ 加载 .svg 文件，适合复杂图形
• 两种方式任选其一

7. 读取 JSON 与文本文件

读JSON文件("./static/jsondata.json",(JSON对象)=>{
    调试输出(JSON对象)
},真)

读文本文件("./static/data.txt",(文本内容)=>{
    调试输出(文本内容)
})

• 均为异步读取，通过回调接收内容
• 读JSON文件 第三个参数 真 表示自动解析为对象；假 表示返回原始文本
• 必须在服务器环境中打开页面：浏览器同源策略限制下，file:// 协议无法 AJAX 读取本地文件

注意事项

• 资源目录固定为 static：所有静态资源必须放在 static 目录下，引用时带 ./static/ 前缀。
• 网络地址不需要前缀：引用 CDN 或远程资源时直接使用完整 URL（http:///https://）。
• 音频自动播放受限：现代浏览器禁止无用户交互的自动播放，应在用户点击事件中调用 开始播放()。
• JSON/文本文件需服务器环境：直接双击打开 .html 文件（file://）无法 AJAX 读取文件，必须部署到本地 WEB 环境或服务器。
• 字体加载是异步的：添加字体文件 在回调中才能使用该字体，回调前使用会回退到默认字体。
• 视频尺寸需手动设：视频宽度/视频高度 应与视频播放器组件尺寸保持一致，否则可能拉伸变形。
• favicon 无需代码：仅需在编译输出目录根放一个 favicon.ico，浏览器自动请求。
• SVG 字符串转义：置SVG代码 中 SVG 源码字符串内的双引号需用 \" 转义。
• 跨域资源需 CORS：引用外部域名资源时，目标服务器需配置 Access-Control-Allow-Origin。

学习要点总结

相关文档

• 文档图像类组件_图片框 —— 图片框属性
• 文档图像类组件_SVG图像框 —— SVG 图像框方法
• 文档媒体类组件_音频播放器 —— 音频播放控制
• 文档媒体类组件_视频播放器 —— 视频播放控制
• 文档文本类组件_标签 —— 标签字体属性
• 文档前端(JavaScript)函数_字体 —— 添加字体文件 详解
• 文档前端(JavaScript)函数_文件读取 —— 读JSON文件/读文本文件
• 文档轻语言网站：工程项目结构 —— static 目录位置与项目结构
• 文档轻语言网站：与原生JS混合开发 —— 引用外部 .js 与 CDN 资源
• 文档轻语言网站：界面XML定义规范 —— XML 中引用图片资源
• 文档综合演示：网页留言板开发 —— 项目结构与资源引用实战

轻语言网站：自定义设计列表内容

文档概述

在轻语言网页开发中，用户可以完全通过中文语法自定义任何列表类型的内容，列表内容的展示在网页开发中非常重要，如果把自定义列表内容学会了，制作出漂亮的网页内容将会变得非常容易。

本节分别讲解列表框和宫格框两种容器的自定义渲染方法。两者都遵循「数据集合 + 渲染回调」的分离式渲染模型：先用 添加项目 填充数据，再用 置请求加载项目回调 定义每项的展示视图，最后调用 渲染() 触发显示。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• 列表框的「纯文本数据 + 单标签渲染」模式
• 宫格框的「对象数据 + 复合布局渲染」模式
• 渲染回调的参数：(数据集合, 索引)，通过 数据集合[索引] 取当前项数据
• 在渲染回调中 创建 组件、设置样式、注册点击事件
• 嵌套回调中的变量捕获（如内层 置被单击回调 引用外层 索引）
• 弹性布局的创建与方向设置：创建 弹性布局() + 方向 = "column"
• 宫格框的横向对齐方式：space-between 等弹性对齐值

涉及组件

📌 列表项的展示视图并非预置组件，而是在 置请求加载项目回调 中通过 创建 动态生成的。这是轻语言列表渲染的核心模式——数据与视图分离，由回调决定每项如何展示。

涉及函数与关键字

以下为本节代码中出现的轻语言关键字与内置函数：

关键字： 变量、事件 ... 结束 事件、函数 ... 结束 函数、变量循环 ... 结束循环、创建、返回

列表框/宫格框通用方法：

• 添加项目(数据) —— 向数据集合追加一条数据（可为字符串或对象）
• 置请求加载项目回调(回调) —— 设置渲染回调，框架按索引逐项调用取展示视图
• 渲染() —— 触发按当前数据集合重新渲染

渲染回调参数：

• 数据集合 —— 全部数据集合（数组），通过 数据集合[索引] 取当前项
• 索引 —— 当前正在渲染的项索引（从 0 开始）

组件创建：

• 创建 标签() —— 实例化标签
• 创建 弹性布局() —— 实例化弹性布局
• 创建 图片框() —— 实例化图片框

视图通用方法/属性：

• 置被单击回调(回调) —— 设置被单击回调
• 添加组件(组件) —— 向容器追加子组件
• 字体大小、内边距、文本颜色、边框、边框圆角、宽度、高度 —— 样式属性
• 方向 = "column" —— 弹性布局方向（column 纵向，row 横向）
• 横向对齐方式 = "space-between" —— 宫格框子项横向分布方式

全局函数：

• 弹出提示(文本) —— 浏览器弹出轻提示
• 调试输出(内容) —— 控制台输出

自定义列表内容

列表内容表示内容按照一条一条的排列，下方为一个自定义纯文本显示的列表演示代码。

代码示例：

事件 页面加载完毕()
    渲染纯文本列表框()
结束 事件

' 注意：已在页面设计文件.spldg中添加了“列表框1”组件。
函数 渲染纯文本列表框()
    变量循环(i = 0,10,1)
        列表框1.添加项目("纯文本项目" + i)
    结束循环
    ' 监听浏览器渲染页面时，请求加载项目内容
    ' 这里的项目内容即为列表中的每个项目内容（包含对内容的排版布局）
    ' 在这个事件中，我们可以自定义创建需要展示内容的组件，然后将内容显示到组件中
    列表框1.置请求加载项目回调((数据集合,索引) =>{
        ' 创建一个标签组件、用于显示文本内容
        变量 局_标签 = 创建 标签()
        ' 自定义设置标签的外观
        局_标签.字体大小 = "20px"
        局_标签.内边距 = "10px"
        局_标签.文本颜色 = "#009956"
        ' 监听标签被单击事件
        局_标签.置被单击回调((源对象,事件源) =>{
            弹出提示("项目" + 索引 + "被单击")
        })
        ' 这里需要注意：
        ' 这里的参数 数据集合 为上一步我们添加的项目数据
        ' 参数索引是浏览器返回给我们，告诉我们需要渲染第几个数据
        局_标签.文本 = 数据集合[索引]
        ' 将标签对象返回给浏览器，浏览器将该标签添加到列表中
        返回 局_标签
    })
    ' 渲染并显示列表
    列表框1.渲染()
结束 函数

自定义宫格内容

宫格内容类似表格、宫格方式展示，下方为一个渲染图片与文本的宫格内容展示演示代码。

代码示例：

事件 页面加载完毕()
    渲染图文宫格框()
结束 事件

' 注意：已在页面设计文件.spldg中添加了“宫格框2”组件。
函数 渲染图文宫格框()
    宫格框2.横向对齐方式 = "space-between"
    宫格框2.边框 = "1px #cc1 solid"
    宫格框2.边框圆角 = "2px"
    宫格框2.内边距 = "10px"
    变量循环(i = 0,30,1)
        变量 项目对象 = { }
        项目对象.图片 = "./static/head.jpg"
        项目对象.标题 = "项目" + i
        宫格框2.添加项目(项目对象)
    结束循环
    宫格框2.置请求加载项目回调((数据集合,索引)=>{
        变量 局_根布局 = 创建 弹性布局()
        局_根布局.方向 = "column"
        '局_根布局.边框 = "1px #cc1 solid"
        变量 局_图片框 = 创建 图片框()
        局_图片框.宽度 = "180px"
        局_图片框.高度 = "120px"
        局_图片框.边框 = "1px #ccc solid"
        局_图片框.边框圆角 = "4px"
        局_图片框.图片 = 数据集合[索引].图片
        变量 局_标题标签 = 创建 标签()
        局_标题标签.文本 = 数据集合[索引].标题
        ' 将图片、标题添加到根布局
        局_根布局.添加组件(局_图片框)
        局_根布局.添加组件(局_标题标签)
        ' 注册根布局点击事件
        局_根布局.置被单击回调(()=>{
            弹出提示("图文宫格项目：" + 索引 + "被单击")
            调试输出(数据集合[索引])
        })
        返回 局_根布局
    })
    宫格框2.渲染()
结束 函数

关键代码解读

1. 「数据 + 渲染回调」分离式渲染模型

两个示例都遵循同一模型：

' ① 填充数据
变量循环(i = 0,10,1)
    列表框1.添加项目("纯文本项目" + i)
结束循环
' ② 定义渲染回调（每渲染一项调用一次）
列表框1.置请求加载项目回调((数据集合,索引) =>{
    变量 局_标签 = 创建 标签()
    局_标签.文本 = 数据集合[索引]
    返回 局_标签
})
' ③ 触发渲染
列表框1.渲染()

要点：

• 添加项目 只是向数据集合追加记录，不会立即产生 DOM
• 必须调用 渲染() 后，框架才会遍历数据集合，按索引回调取每一项的视图
• 回调返回的视图由容器自动添加到 DOM，开发者无需手动 添加组件
• 数据可为字符串（列表框示例）或对象（宫格框示例），回调中按 数据集合[索引] 取出

2. 渲染回调的两个参数

列表框1.置请求加载项目回调((数据集合,索引) =>{
    局_标签.文本 = 数据集合[索引]
})

• 数据集合：全部数据的数组引用，通过 数据集合[索引] 取当前项
• 索引：当前正在渲染的项序号（从 0 开始）
• 列表框示例中 数据集合[索引] 是字符串；宫格框示例中 数据集合[索引].图片 是对象属性

3. 嵌套回调中的变量捕获

列表框1.置请求加载项目回调((数据集合,索引) =>{
    变量 局_标签 = 创建 标签()
    局_标签.置被单击回调((源对象,事件源) =>{
        弹出提示("项目" + 索引 + "被单击")
    })
    局_标签.文本 = 数据集合[索引]
    返回 局_标签
})

• 内层 置被单击回调 引用了外层回调的参数 索引
• 用户点击标签时，外层渲染回调早已返回，索引 是否保持当时的值取决于闭包捕获语义
• 官方示例普遍采用这种写法，说明轻语言的拉姆达对回调参数按调用时的值捕获（类似 JavaScript let 语义）
• 每次渲染回调调用时，索引 都是独立的值，因此每个标签点击都能取到正确序号

4. 宫格框的复合项渲染

宫格框2.置请求加载项目回调((数据集合,索引)=>{
    变量 局_根布局 = 创建 弹性布局()
    局_根布局.方向 = "column"
    变量 局_图片框 = 创建 图片框()
    ' ...设置图片框属性...
    变量 局_标题标签 = 创建 标签()
    局_标题标签.文本 = 数据集合[索引].标题
    局_根布局.添加组件(局_图片框)
    局_根布局.添加组件(局_标题标签)
    返回 局_根布局
})

• 宫格项的展示视图是一个复合组件：以弹性布局为根，内含图片框 + 标签
• 创建 弹性布局() 实例化弹性布局，方向 = "column" 设为纵向排列（图片在上、标题在下）
• 用 添加组件 把图片框和标签挂到弹性布局下
• 最后 返回 局_根布局，宫格框会把这个复合视图添加到对应网格中

5. 宫格框的横向对齐方式

宫格框2.横向对齐方式 = "space-between"

• space-between 让子项在主轴上两端对齐、中间均分
• 其他常用值：flex-start（左对齐）、center（居中）、space-around（等间距环绕）
• 实际对应 CSS justify-content 属性

6. 列表框 vs 宫格框的对比

注意事项

• 数据与视图分离：添加项目 不产生 DOM，必须调用 渲染() 才会触发回调生成视图。
• 循环边界语义：变量循环(i = 0, 10, 1) 等效于 for(i=0; i<10; i++)，即 i 小于目标值时循环、达到目标值时退出，左闭右开区间 [0, 10)，循环执行 10 次（i=0~9）。本节示例 变量循环(i = 0,10,1) 添加 10 项数据，变量循环(i = 0,30,1) 添加 30 项数据。
• 渲染回调返回值：回调必须 返回 一个视图组件，容器才能将其加入 DOM。若返回 空 则该项不显示。
• 嵌套闭包捕获：内层 置被单击回调 引用外层 索引 时，依赖拉姆达按值捕获语义。官方示例普遍采用此写法，生成代码时可参照；若遇异常应改用参数绑定。
• 复合视图根布局：宫格项的展示视图若为复合结构，应以一个容器（如弹性布局）作为根，把子组件挂到根下后返回根，不要返回多个组件。
• 方向 属性：弹性布局 方向 = "column" 为纵向，"row" 为横向。默认值因组件而异，建议显式设置。
• 图片路径：示例中 "./static/head.jpg" 为相对路径，实际项目中图片需放在 static 目录下。
• 弹出提示 字符变体：本节代码中 弹出提示 在不同文档中可能有字符显示差异（如 弹出提示`），实际为同一函数。

学习要点总结

相关文档

• 文档列表类组件_列表框 —— 列表框的完整属性与方法
• 文档列表类组件_宫格框 —— 宫格框的完整属性与方法
• 文档布局类组件_弹性布局 —— 弹性布局的创建、方向、对齐
• 文档文本类组件_标签 —— 标签的属性与方法
• 文档图像类组件_图片框 —— 图片框的属性
• 文档框架基础类_容器视图 —— 容器通用方法（添加组件等）
• 文档框架基础类_视图 —— 视图通用方法（置被单击回调等）
• 文档轻语言网站：循环语句体结构 —— 变量循环、计次循环 的完整说明
• 文档轻语言网站：轻语言语法速查 —— 关键字、运算符、拉姆达表达式
• 文档综合演示：网页留言板开发 —— 列表框数据驱动渲染的完整示例
• 文档综合演示：手机移动端记事本网页开发 —— 列表框渲染笔记项
• 文档综合演示：XML 定义待办事项列表演示 —— XML 定义列表的另一种方式
• 文档综合演示：XML 与使用代码动态创建组件演示 —— 创建 动态实例化组件的更多场景

轻语言网站：服务端脚本程序API接口

文档概述

本章讲解如何在轻语言网页程序中编写后端脚本文件（.sph），轻语言网站程序中的后端脚本文件采用轻语言语法编写，编译时输出为标准 PHP 文件，可在该文件中操作数据库增删改查、读写服务器中的文件。

学习目标

阅读本文档后，你应当能够掌握以下内容：

• .sph 后端脚本文件的基本结构与执行流程
• 文件被访问() 入口函数的请求路由机制
• 取请求值("a") 取出 URL 参数并动态执行对应函数
• 安全验证：通过函数白名单防止非法调用
• 输出 函数向客户端返回数据
• 模块化引用：引用 "模块名" 在 .sph 之间复用代码
• 字符串连接 + 的限制（至少一边为字面字符串）
• 置响应头 设置响应报头
• 引用 "library/qing.core.php" 引入核心库

涉及关键字与函数

关键字： 引用、函数 ... 结束 函数、变量、如果 ... 否则 ... 结束 如果、返回、输出

后端专用函数：

语法格式

采用面向过程编写代码，所有语句从上到下依次执行。

示例：Api1.sph

' ****************************************************************************
' 版权说明：Copyright（C） All Rights Reserved VcnStudio
' 程序版本：V1.0
' 文件描述：服务端脚本文件、最终将会编译成 PHP 源代码，
' 　　　　　可在该文件中操作数据库增删改查、读写服务器中的文件。
' 修改日志：
' ****************************************************************************
' 向客户端发送服务器的响应报头（Response Header）
置响应头("Content-Type: text/html; charset=utf-8")
置响应头("Content-Language: zh-CN")

' 引用轻语言封装的PHP核心库，注：如果要删除该引用请确保当前文件中未使用轻语言封装的函数
引用 "library/qing.core.php"

' 调用主函数："文件被访问"、即当在任何前端中访问该文件时，地址中不带任何参数名，都将会先调用该函数
文件被访问()

' 入口函数，函数名可自定义命名，主要作用：
' 当本文件被访问时，获取其前端传来的请求参数值，根据请求参数值调用当前文件中的函数
函数 文件被访问()
    ' 通过URL中的键参获取要执行的函数，这里我们默认规定键名为"a"，例如：
    ' 前端请求地址为：http://xxx.com/本文件名.php?a=测试输出
    ' 其"a"后面的值"测试输出"即为我们要执行的函数，使用"取请求值"函数将其取出后，然后执行。
    变量 待执行函数名 = 取请求值("a")
    如果(为空(待执行函数名))
        输出 "待执行函数不能为空"
    否则
        ' 增加安全验证，只允许执行我们定义的函数
        变量 可被执行的函数列表 = [ "测试输出", "获取时间" ,"读TXT文件内容"]
        如果(取成员是否存在(可被执行的函数列表,待执行函数名) == 真)
            输出 执行函数(待执行函数名)
        否则
            输出 "请求执行非法的函数"
        结束 如果
    结束 如果
结束 函数

' 在前端通过发送GET、POST请求、或使用"请求接口"函数调用该函数，或直接在浏览器中访问下面地址
' 地址：http://xxx.com/Api.php?a=测试输出
函数 测试输出()
    输出 "你发送的请求接收成功；这是反馈信息！"
结束 函数

' 向前端输出当前格式化后的时间信息
' 地址：http://xxx.com/Api.php?a=获取时间
函数 获取时间()
    输出 "当前时间：" + 格式化时间("Y-m-d",取现行时间戳())
结束 函数

' 向前端输出服务器中指定位置的".txt"文本文件
' 地址：http://xxx.com/Api.php?a=读TXT文件内容
函数 读TXT文件内容()
    输出 "ceshi.txt 内容：" + 读文件内容("/static/ceshi.txt")
结束 函数

' 内部函数，未添加到 可被执行的函数列表 中，因此前端请求时不会执行该函数
函数 内部私有函数()
    返回 "这是内部函数，URL不可访问"
结束 函数

关键代码解读

1. .sph 文件执行流程

置响应头("Content-Type: text/html; charset=utf-8")    ' 1. 设置响应头
引用 "library/qing.core.php"                          ' 2. 引入核心库
文件被访问()                                            ' 3. 调用入口函数（从上到下执行）

• 文件从上到下顺序执行
• 先设置响应头、引入核心库，再调用入口函数
• 入口函数名可自定义，但需在文件顶层调用一次

2. 请求路由：通过 URL 的 a 参数分发

变量 待执行函数名 = 取请求值("a")
如果(为空(待执行函数名))
    输出 "待执行函数不能为空"
否则
    变量 可被执行的函数列表 = [ "测试输出", "获取时间" ,"读TXT文件内容"]
    如果(取成员是否存在(可被执行的函数列表,待执行函数名) == 真)
        输出 执行函数(待执行函数名)
    否则
        输出 "请求执行非法的函数"
    结束 如果
结束 如果

• 约定 URL 中的 a 参数值为要调用的函数名
• 例如 ?a=测试输出 将调用 测试输出() 函数
• 必须使用白名单校验：仅允许执行预定义的函数列表，防止非法调用

3. 安全机制：函数白名单

变量 可被执行的函数列表 = [ "测试输出", "获取时间" ,"读TXT文件内容"]
如果(取成员是否存在(可被执行的函数列表,待执行函数名) == 真)
    输出 执行函数(待执行函数名)
否则
    输出 "请求执行非法的函数"
结束 如果

• 所有允许通过 URL 调用的函数必须加入白名单数组
• 未在白名单中的函数（如 内部私有函数）无法通过 URL 访问
• 取成员是否存在(数组, 值) 判断值是否在数组中

4. 输出与返回

函数 测试输出()
    输出 "你发送的请求接收成功；这是反馈信息！"
结束 函数

• 输出 内容 将内容作为响应体返回给客户端
• 返回 值 仅在函数内返回值，不直接输出到客户端
• 通常入口函数中使用 输出 执行函数(函数名) 将函数返回值输出

变量

与前端定义变量语法完全一致。

代码示例：

' 定义字符串文本变量
变量 页面变量 = "变量定义测试"

' 定义整数变量
变量 X,Y = 0

函数

与前端定义函数的语法完全一致。

代码示例：

' 无参数、无返回值的函数
函数 无返回值函数()
    调试输出("无返回值的函数被执行")
结束 函数

' 有返回值的函数、不需要定义返回类型，只需要在函数中返回值即可，
' 函数中的参数也不需要定义任何数据类型，所有参数默认可接收所有数据类型
函数 有返回值的函数(参数一,参数二)
    返回 参数一 + 参数二
结束 函数

模块化引用、代码复用

轻语言编写的后端脚本文件，最终编译输出为标准单个 .php 脚本文件，因此在轻语言中每个 .sph 可以被独立运行，也可以被引用到其它 .sph 文件中使用。

模块文件示例：Module1.sph

' ****************************************************************************
' 版权说明：Copyright（C） All Rights Reserved VcnStudio
' 程序版本：V1.0
' 文件描述：后端脚本复用封装的函数。
' 修改日志：
' ****************************************************************************
' 注释标记当前文件为模块，提供给IDE做语法分析时自动完成智能提示，不参与编译判断
' @模块 = 真

函数 Module1_取当前格式化时间()
    返回 "当前时间：" + 格式化时间("Y-m-d",取现行时间戳())
结束 函数

函数 Module1_计算加法(参数1,参数2)
    返回 参数1 * 参数2
结束 函数

接口文件示例：App1.sph

' ****************************************************************************
' 版权说明：Copyright（C） All Rights Reserved VcnStudio
' 程序版本：V1.0
' 文件描述：测试模块函数的服务端脚本文件、最终将会编译成 PHP 源代码
' 修改日志：
' ****************************************************************************

' 向客户端发送服务器的响应报头（Response Header）
置响应头("Content-Type: text/html; charset=utf-8")
置响应头("Content-Language: zh-CN")

' 引用轻语言封装的PHP核心库，注：如果要删除该引用请确保当前文件中未使用轻语言封装的函数
引用 "library/qing.core.php"

' 引用项目中的模块脚本文件
引用 "Module1"

' 调用主函数："文件被访问"、即当在任何前端中访问该文件时，地址中不带任何参数名，都将会先调用该函数
文件被访问()

' 入口函数，函数名可自定义命名，主要作用：
' 当本文件被访问时，获取其前端传来的请求参数值，根据请求参数值调用当前文件中的函数
函数 文件被访问()
    ' 通过URL中的键参获取要执行的函数，这里我们默认规定键名为"a"，例如：
    ' 前端请求地址为：http://xxx.com/本文件名.php?a=测试输出
    ' 例如：http://xxx.com/Api1.php?a=取当前格式化时间
    ' 其"a"后面的值"测试输出"即为我们要执行的函数，使用"取请求值"函数将其取出后，然后执行。
    变量 待执行函数名 = 取请求值("a")
    如果(为空(待执行函数名))
        输出 "待执行函数不能为空"
    否则
        如果(待执行函数名 == "取当前格式化时间")
            输出 Module1_取当前格式化时间()
        否则 如果(待执行函数名 == "计算加法")
            如果(为空(取请求值(key1)) 或 为空(取请求值(key2)))
                输出 "目标计算参数获取失败，请确认提交请求时是否传入了key1、key2参数值"
            否则
                输出 Module1_计算加法(10,20)
            结束 如果
        结束 如果
    结束 如果
结束 函数

模块化要点

• 使用 引用 "模块名" 引入其它 .sph 文件
• 模块文件建议添加 ' @模块 = 真 注释标记，便于 IDE 识别
• 模块中的函数通过 模块名_函数名() 的方式调用（约定）
• 模块函数不会通过 URL 直接访问，需在入口中显式调用

注意事项

• 字符串连接 + 的限制：原生 PHP 中以 . 连接字符串，在轻语言中可用 + 连接，但必须满足 + 两边至少有一个 Token 为静态字符串常量值（即用双引号括起来的值）。

变量 测试1 = "姓名：" + "张三"  ' 正确合法
变量 年龄 = 23
变量 测试2 = "年龄：" + 年龄  ' 正确合法
变量 前缀= "【签名】"
变量 测试3 = 前缀 + "这是一段字符串，年龄："  + 年龄  ' 正确合法

变量 水果1 = "苹果"
变量 水果2 = "香蕉"
变量 水果3 = 水果1 + 水果2 ' 错误：两边都不是字面字符串

• 白名单必须校验：通过 URL 调用的函数必须在白名单中，防止非法调用。
• 文件被访问 函数名可自定义：入口函数名可以任意命名，但需在文件顶层显式调用。
• 输出 与 返回 区别：输出 直接将内容作为响应返回给客户端；返回 仅在函数内返回值。
• 核心库引用：引用 "library/qing.core.php" 提供轻语言封装的 PHP 函数，若删除需确保未使用这些函数。
• 模块文件路径：引用 "Module1" 不要带扩展名，编译器自动查找 .sph。
• 响应头位置：置响应头 必须在任何 输出 之前调用，否则无效。
• 输出顺序：由于是顺序执行，入口函数调用必须在所有定义之后。

学习要点总结

相关文档

• 文档轻语言网站：发送网络请求与接口请求 —— 前端如何请求 .sph 接口
• 文档轻语言网站：工程项目结构 —— .sph 文件在项目中的位置
• 文档轻语言网站：轻语言语法速查 —— 函数定义、变量声明语法
• 文档轻语言网站：变量与数组与对象的定义 —— 变量与函数定义
• 文档后端(PHP)函数_请求 —— 取请求值 等请求函数
• 文档后端(PHP)函数_响应 —— 输出/置响应头 等响应函数
• 文档后端(PHP)函数_时间 —— 取现行时间戳/格式化时间
• 文档后端(PHP)函数_文件 —— 读文件内容 等文件操作
• 文档后端(PHP)函数_数组 —— 取成员是否存在 等数组函数
• 文档综合演示：MySQL数据库操作 —— 后端脚本操作数据库实战
• 文档综合演示：网页留言板开发 —— 前后端联调实战

前端(JavaScript)函数_储存类

文档概述

轻语言网站开发中的储存类操作函数、基于浏览器 localStorage 封装用于本地数据存储，包含数据读写、数据删除、存储空间管理等功能，每个网站最大存储空间为5M，超过5M的数据将无法保存，常用于用户偏好设置、数据缓存、离线存储等场景。

• 持久化存储：保存配置 / 读取配置 基于 localStorage，关闭浏览器后数据仍然保留
• 会话存储：保存临时数据 / 取临时保存数据 基于 sessionStorage，关闭浏览器标签页后数据自动清除
• 存储容量：单个域名下最大 5MB，适合存储用户偏好、缓存数据、表单草稿等小体量数据

💡 存储复杂对象：localStorage 只能存储字符串，因此存储对象/数组时需先用 JSON编码 序列化为字符串，读取时再用 JSON解析 还原为对象。

函数：保存配置(键名,值)

存储指定键值对到本地存储中。代码示例：保存配置("用户名", "张三")

' 存储简单的字符串数据
保存配置("用户名", "张三")

' 存储复杂对象（需先用 JSON编码 序列化为 JSON 字符串）
变量 用户信息 = {
	"姓名": "李四",
	"年龄": 25,
	"邮箱": "lisi@example.com"
}
保存配置("用户信息", JSON编码(用户信息))

' 存储数字和布尔值
保存配置("访问次数", 10)
保存配置("是否登录", 真)

函数：读取配置(键名)

从本地存储中获取指定键对应的值。代码示例：变量 用户名 = 读取配置("用户名")

' 获取简单数据
变量 用户名 = 读取配置("用户名")

' 获取并解析复杂对象
变量 用户信息JSON = 读取配置("用户信息")
如果(用户信息JSON != 空)
	变量 用户信息 = JSON解析(用户信息JSON)
	调试输出("用户姓名: " + 用户信息.姓名)
结束 如果

' 获取数字和布尔值（需要类型转换）
变量 访问次数 = 到整数(读取配置("访问次数"))
变量 是否登录 = (读取配置("是否登录") == "真")

函数：删除配置(键名)

从本地存储中移除指定键及其对应的值。代码示例：删除配置("用户名")

' 删除特定的缓存项
删除配置("用户名")

' 删除复杂对象缓存
删除配置("用户信息")

' 在用户退出时清理个人信息
按钮_退出登录.置被单击回调((源对象, 事件) => {
	删除配置("用户名")
	删除配置("用户信息")
	删除配置("访问次数")
	删除配置("是否登录")
	切换页面("登录页")
})

函数：清空配置()

清空所有存储在本地存储中的数据。代码示例：清空配置()

' 清空所有本地存储数据
清空配置()

' 在需要重置应用时使用
按钮_重置应用.置被单击回调((源对象, 事件) => {
	清空配置()
	弹出提示("应用已重置，请重新登录")
	切换页面("登录页")
})

函数：取配置记录数()

返回存储对象中包含多少条配置数据。代码示例：变量 配置数 = 取配置记录数()

' 获取配置项的数量
变量 配置数 = 取配置记录数()
调试输出("当前共有 " + 配置数 + " 项配置")

' 根据缓存数量决定处理逻辑
如果(取配置记录数() > 0)
	调试输出("存在配置数据，可以进行恢复")
否则
	调试输出("无配置数据，需要初始化")
结束 如果

函数：保存临时数据(键名,值)

存储指定键值对到会话存储中。代码示例：保存临时数据("表单数据", 表单内容)

' 存储临时表单数据
变量 表单内容 = {
	"姓名": 姓名输入框.内容,
	"电话": 电话输入框.内容
}
保存临时数据("表单数据", JSON编码(表单内容))

' 存储页面间临时传递的数据
保存临时数据("来源页面", "用户列表页")

' 存储购物车临时信息
保存临时数据("购物车商品数", 购物车.取商品数())

函数：取临时保存数据(键名)

从会话存储中获取指定键对应的值。代码示例：变量 表单数据 = 取临时保存数据("表单数据")

' 获取临时表单数据
变量 表单数据JSON = 取临时保存数据("表单数据")
如果(表单数据JSON != 空)
	变量 表单数据 = JSON解析(表单数据JSON)
	姓名输入框.内容 = 表单数据.姓名
	电话输入框.内容 = 表单数据.电话
结束 如果

' 获取页面间传递的临时数据
变量 来源页面 = 取临时保存数据("来源页面")
如果(来源页面 == "用户列表页")
	返回按钮.显示模式 = 显示_块
结束 如果

函数：删除临时数据(键名)

从会话存储中移除指定键及其对应的值。代码示例：删除临时数据("表单数据")

' 删除临时表单数据
删除临时数据("表单数据")

' 提交表单后清除临时数据
提交按钮.置被单击回调((源对象, 事件) => {
	' 执行提交操作
	提交表单()

	' 清除临时存储的表单数据
	删除临时数据("表单数据")
	弹出提示("提交成功")
})

函数：清空临时数据()

清空所有存储在会话存储中的数据。代码示例：清空临时数据()

' 清空所有会话存储数据
清空临时数据()

' 用户注销时清除会话数据
注销按钮.置被单击回调((源对象, 事件) => {
	清空临时数据()
	切换页面("登录页")
})

函数：取临时数据记录数()

返回临时存储对象中包含多少条数据。代码示例：变量 临时数据数 = 取临时数据记录数()

' 获取临时数据项的数量
变量 临时数据数 = 取临时数据记录数()
调试输出("当前会话共有 " + 临时数据数 + " 项临时数据")

' 检查是否有临时数据
如果(临时数据数 > 0)
	调试输出("检测到临时数据，正在恢复...")
	恢复临时数据()
结束 如果

学习要点

相关文档

• 文档前端(JavaScript)函数_数据转换类 —— JSON编码、JSON解析、到整数、到文本 等类型转换函数
• 文档前端(JavaScript)函数_数据操作类 —— 数据深拷贝、合并、遍历等操作
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明、对象与数组的基本语法
• 文档综合演示：手机移动端记事本网页开发 —— 记事本数据持久化存储实战
• 文档综合演示：公用模块全局变量函数使用演示 —— 跨页面共享数据与配置存储实战

前端(JavaScript)函数_历史类

文档概述

轻语言网站开发中的历史类操作函数、用于管理浏览器历史记录，包含页面历史记录操作、前进后退控制、历史状态管理等功能，常用于单页应用路由、历史记录管理、页面状态恢复等场景。

• 历史记录查询：取历史记录数 返回历史列表中的网址数量，用于判断是否有上一页可返回
• 前进后退：后退页面 / 前进页面 等价于浏览器左上角的后退/前进按钮，无对应页面时操作无效
• 指定跳转：加载指定历史页面 支持数字参数（相对位置）或字符串参数（URL 匹配）

💡 历史记录注意：后退页面/前进页面 是异步操作，且依赖历史记录存在。新标签页打开的页面历史记录为 1，无法后退。加载指定历史页面(-1) 等价于 后退页面，加载指定历史页面(1) 等价于 前进页面。

函数：取历史记录数()

返回历史列表中的网址数。

' 获取历史记录数量
变量 记录数 = 取历史记录数()
调试输出("历史记录数: " + 记录数)

' 判断是否有上一页可返回
如果(记录数 > 1)
	返回按钮.显示模式 = 显示_块
调试输出("可以返回上一页")
否则
	返回按钮.显示模式 = 显示_隐藏
调试输出("无历史记录可返回")
结束 如果

' 页面加载时根据历史记录控制返回按钮显示
页面.置被创建回调(() => {
	如果(取历史记录数() > 1)
		返回按钮.显示模式 = 显示_块
	否则
		返回按钮.显示模式 = 显示_隐藏
	结束 如果
})

函数：后退页面()

返回到上一个页面；如果上个页面存在的话。

' 返回上一页
后退页面()

' 点击返回按钮返回上一页
返回按钮.置被单击回调(() => {
	后退页面()
})

' 表单取消时返回
取消按钮.置被单击回调(() => {
	后退页面()
})

' 带历史记录判断的安全后退
返回按钮.置被单击回调(() => {
	如果(取历史记录数() > 1)
		后退页面()
	否则
		切换页面("首页")  ' 无历史记录则跳首页
	结束 如果
})

函数：前进页面()

前进到历史记录中的位于当前页面的下一个页面。

' 前进到下一页
前进页面()

' 点击前进按钮
前进按钮.置被单击回调(() => {
	前进页面()
})

' 监听前进后退状态更新按钮
页面.置被显示回调(() => {
	如果(取历史记录数() > 1)
		前进按钮.可用 = 真
	后退按钮.可用 = 真
	否则
		前进按钮.可用 = 假
	结束 如果
})

函数：加载指定历史页面(值)

加载历史列表中的某个具体的页面，该参数值可以是数字，（-1上一个页面，1前进一个页面)，或一个字符串，字符串必须是局部或完整的URL，该函数会去匹配字符串的第一个URL。

' 后退2页（跳过中间页面）
加载指定历史页面(-2)

' 前进1页
加载指定历史页面(1)

' 刷新当前页（相当于0）
加载指定历史页面(0)

' 通过URL匹配跳转（匹配历史记录中的URL）
加载指定历史页面("about.html")

' 通过完整URL跳转
加载指定历史页面("https://www.example.com/news")

' 返回首页（相对位置跳转）
首页按钮.置被单击回调(() => {
	加载指定历史页面("index.html")
})

学习要点

相关文档

• 文档前端(JavaScript)函数_URL地址操作类 —— 取URL完整地址、重载页面 等URL操作
• 文档前端(JavaScript)函数_浏览器操作类 —— 切换页面、弹出提示 浏览器控制函数
• 文档前端(JavaScript)函数_窗口操作 —— 打开窗口、关闭窗口 窗口管理函数
• 文档前端(JavaScript)函数_储存类 —— 保存配置 存储页面状态用于恢复
• 文档前端(JavaScript)函数_文档操作 —— 查找元素ByID 等DOM操作函数

前端(JavaScript)函数_字符串操作

文档概述

轻语言网站开发中的字符串相关操作函数、用于处理文本和字符串内容，包含获取随机字符串、判断文本是否包含目标文本、取文本长度、翻转文本、替换文本内容等功能，常用于在编码中处理字符串、文本内容相关场景。

• 文本查找：寻找文本(正序)、倒找文本(逆序) 返回索引；取包含文本 返回布尔值；未找到均返回 -1
• 文本截取：取文本左边/取文本右边/取文本中间（按位置长度）、取指定文本左边/取指定文本右边/取指定文本中间（按标记文本）、取字符(单字符)
• 文本替换：子文本替换(替换首个)、子文本替换全部(替换全部)、格式化文本({0}占位符)
• 文本清洗：删首尾空/删首空/删尾空/删全部空(去空白)、到全角/到半角(全半角转换)
• 文本分析：取文本长度(字符数)、取文本字节长度(UTF-8字节数)、取文本行数、翻转文本、到小写/到大写、取相等

💡 字符长度与字节长度：取文本长度 返回字符数（中文1字=1），取文本字节长度 返回 UTF-8 字节数（中文1字=3字节）。数据库字段长度限制、网络传输长度限制通常按字节计算，验证时需用 取文本字节长度。

函数：为空(值 为 泛型)

获取并判断指定文本变量或字符串、或对象是否为空值。

' 检查字符串是否为空
变量 文本1 = ""
变量 文本2 = "  "
变量 文本3 = "hello"
调试输出(为空(文本1))  ' 真
调试输出(为空(文本2))  ' 真（纯空格也算空）
调试输出(为空(文本3))  ' 假
' 检查对象是否为空
' 注：轻语言的空值关键字为 空，等价于原生 JS 的 null
变量 空对象 = 空
调试输出(为空(空对象))  ' 真

函数：取随机字符串(长度 为 整数型)

取出指定位数长度的随机字符串（由小写字母加数字组成），注意：长度必须大于0。

' 生成8位随机字符串（常用于验证码、临时密码）
变量 随机串 = 取随机字符串(8)
调试输出("随机字符串: " + 随机串)  ' 如：a3f9x2k1
' 生成16位随机字符串（用于token）
变量 令牌 = 取随机字符串(16)
调试输出("令牌: " + 令牌)
' 生成4位验证码
变量 验证码 = 取随机字符串(4)
调试输出("验证码: " + 验证码)

函数：取包含文本(源文本 为 文本型,目标文本 为 文本型)

获取指定源文本中是否包含目标文本；如果包含则返回真、否则返回假。

' 检查邮箱是否包含@符号
变量 邮箱 = "user@example.com"
如果(取包含文本(邮箱, "@"))
	调试输出("邮箱格式包含@符号")
否则
	调试输出("邮箱格式不正确")
结束 如果
' 检查文本中是否包含敏感词
变量 评论内容 = "这个产品非常好用"
如果(取包含文本(评论内容, "垃圾"))
	调试输出("评论包含敏感词")
否则
	调试输出("评论内容正常")
结束 如果

函数：取文本长度(内容 为 文本型)

获取文本字符数量，例如：一段文本由5个汉字组成，则返回5。

' 获取中英文混合文本的字符数
变量 文本 = "Hello世界"
调试输出("字符数: " + 取文本长度(文本))  ' 7
' 验证用户输入长度
变量 用户名 = "张三"
如果(取文本长度(用户名) < 2)
	弹出提示("用户名至少需要2个字符")
结束 如果
' 获取空文本的长度
调试输出(取文本长度(""))  ' 0
' 注：传入 空（轻语言空值关键字，等价于原生 JS 的 null）时返回 0
调试输出(取文本长度(空))  ' 0

函数：取文本字节长度(文本内容)

获取文本字节长度，默认使用UTF8编码计算，保证跨设备一致性。

' 计算中英文混合文本的字节长度（UTF-8编码下中文占3字节）
变量 英文 = "abc"
变量 中文 = "你好"
调试输出("英文字节: " + 取文本字节长度(英文))  ' 3
调试输出("中文字节: " + 取文本字节长度(中文))  ' 6
' 验证数据库字段长度限制
变量 用户输入 = "这是用户输入的内容"
如果(取文本字节长度(用户输入) > 255)
	弹出提示("输入内容超出255字节限制")
结束 如果

函数：翻转文本(文本内容 为 文本型)

将文本从右到左反转后返回。

' 反转字符串
变量 原文本 = "Hello World"
变量 反转后 = 翻转文本(原文本)
调试输出(反转后)  ' dlroW olleH
' 反转中文文本
变量 中文 = "你好世界"
调试输出(翻转文本(中文))  ' 界世好你
' 判断回文
变量 词 = "上海自来水来自海上"
如果(词 == 翻转文本(词))
	调试输出("是回文")
结束 如果

函数：寻找文本(欲被搜寻文本 为 文本型,欲寻找文本 为 文本型,开始位置 为 整数型)

从指定文本中寻找欲寻找的文本，可以设定起始位置，如果未找到返回-1；如果找到后返回从左至右以0为开始的索引位置。

' 查找关键词在文本中的位置
变量 文本 = "Hello World, Hello JavaScript"
变量 位置 = 寻找文本(文本, "Hello")
调试输出("首次出现位置: " + 位置)  ' 0
' 从指定位置开始查找
变量 位置2 = 寻找文本(文本, "Hello", 1)
调试输出("第二次出现位置: " + 位置2)  ' 13
' 查找不存在的内容
变量 位置3 = 寻找文本(文本, "Python")
调试输出("查找结果: " + 位置3)  ' -1

函数：倒找文本(欲被搜寻文本 为 文本型,欲寻找文本 为 文本型,开始位置 为 整数型)

在指定文本中从右到左寻找文本；返回找到的文本的位置；如果未找到返回-1、注意参数三开始位置是指从右向左的方向；例如：文本总长度为10、要从右向左找开始位置则为10或大于文本长度即可。

' 从右向左查找关键词最后出现的位置
变量 文本 = "apple banana apple orange"
变量 位置 = 倒找文本(文本, "apple")
调试输出("最后出现位置: " + 位置)  ' 13
' 查找文件扩展名（最后一个.的位置）
变量 文件名 = "archive.tar.gz"
变量 点位置 = 倒找文本(文件名, ".")
变量 扩展名 = 取文本右边(文件名, 取文本长度(文件名) - 点位置 - 1)
调试输出("扩展名: " + 扩展名)  ' gz

函数：到小写(文本内容 为 文本型)

将字符串的字母全部转成小写；返回转换后的字符串。

' 将大写字母转为小写
变量 文本 = "HELLO World"
调试输出(到小写(文本))  ' hello world
' 统一用户输入格式用于比较
变量 用户输入 = "YES"
如果(到小写(用户输入) == "yes")
	调试输出("用户确认了操作")
结束 如果
' 处理邮箱地址
变量 邮箱 = "User@Example.COM"
调试输出(到小写(邮箱))  ' user@example.com

函数：取相等(文本1 为 文本型,文本2 为 文本型)

获取并判断当前两个字符串或文本变量是否相等。

' 比较两个字符串是否相等
变量 密码1 = "123456"
变量 密码2 = "123456"
变量 密码3 = "654321"
调试输出(取相等(密码1, 密码2))  ' 真
调试输出(取相等(密码1, 密码3))  ' 假
' 验证码校验
变量 正确验证码 = "ABCD"
变量 用户输入 = "ABCD"
如果(取相等(正确验证码, 用户输入))
	弹出提示("验证码正确")
否则
	弹出提示("验证码错误")
结束 如果

函数：到大写(文本内容 为 文本型)

将字符串的字母全部转成大写；返回转换后的字符串。

' 将小写字母转为大写
变量 文本 = "hello world"
调试输出(到大写(文本))  ' HELLO WORLD
' 统一代码格式
变量 国家代码 = "cn"
调试输出(到大写(国家代码))  ' CN
' 生成订单编号
变量 订单前缀 = "ord"
变量 订单号 = 到大写(订单前缀) + "-" + 取随机字符串(8)
调试输出("订单号: " + 订单号)  ' ORD-a3f9x2k1

函数：取文本左边(文本内容 为 文本型,长度 为 整数型)

从字符串左边开始；取出指定长度的字符；返回取出的字符串。

' 取出文本前几个字符
变量 文本 = "Hello World"
调试输出(取文本左边(文本, 5))  ' Hello
' 截取姓名的姓氏（中文）
变量 姓名 = "张三丰"
调试输出("姓氏: " + 取文本左边(姓名, 1))  ' 张
' 截取日期前缀
变量 日期时间 = "2024-01-15 10:30:00"
变量 日期 = 取文本左边(日期时间, 10)
调试输出("日期: " + 日期)  ' 2024-01-15

函数：取文本右边(文本内容 为 文本型,长度 为 整数型)

从字符串右边开始；取出指定长度的字符；返回取出的字符串。

' 取出文本最后几个字符
变量 文本 = "Hello World"
调试输出(取文本右边(文本, 5))  ' World
' 获取文件扩展名
变量 文件名 = "photo.jpg"
变量 扩展名 = 取文本右边(文件名, 3)
调试输出("扩展名: " + 扩展名)  ' jpg
' 获取手机号后四位
变量 手机号 = "13812345678"
变量 后四位 = 取文本右边(手机号, 4)
调试输出("后四位: " + 后四位)  ' 5678

函数：取文本中间(待操作文本 为 文本型,开始位置 为 整数型,结束位置 为 整数型)

取出指定开始，结束位置的文本。

' 从指定位置截取文本片段
变量 文本 = "Hello World"
调试输出(取文本中间(文本, 0, 5))  ' Hello
调试输出(取文本中间(文本, 6, 11))  ' World
' 提取身份证中的出生日期
变量 身份证 = "110105199001011234"
变量 出生日期 = 取文本中间(身份证, 6, 14)
调试输出("出生日期: " + 出生日期)  ' 19900101
' 从URL中提取域名部分
变量 网址 = "https://www.example.com/path"
变量 开始 = 寻找文本(网址, "://") + 3
变量 结束 = 寻找文本(网址, "/", 开始)
调试输出("域名: " + 取文本中间(网址, 开始, 结束))  ' www.example.com

函数：取指定文本右边(文本内容 为 文本型,左边文本 为 文本型)

取出指定文本的右边；例如：取指定文本右边("123456","4")；结果为56。

' 取出指定标记后的内容
变量 文本 = "姓名:张三"
调试输出(取指定文本右边(文本, ":"))  ' 张三
' 提取URL参数值
变量 网址 = "https://example.com?id=12345"
变量 参数值 = 取指定文本右边(网址, "id=")
调试输出("ID: " + 参数值)  ' 12345
' 提取文件路径中的文件名
变量 路径 = "/home/user/document.txt"
变量 文件名 = 取指定文本右边(路径, "/")
调试输出("文件名: " + 文件名)  ' document.txt

函数：取指定文本左边(文本内容 为 文本型,右边文本 为 文本型)

取出指定文本的左边；例如：取指定文本左边("123456","4")；结果为123。

' 取出指定标记前的内容
变量 文本 = "张三:男"
调试输出(取指定文本左边(文本, ":"))  ' 张三
' 提取文件名（不含扩展名）
变量 文件名 = "photo.jpg"
变量 名称 = 取指定文本左边(文件名, ".")
调试输出("文件名: " + 名称)  ' photo
' 提取邮箱用户名部分
变量 邮箱 = "user@example.com"
变量 用户名 = 取指定文本左边(邮箱, "@")
调试输出("用户名: " + 用户名)  ' user

函数：取指定文本中间(内容 为 文本型,左侧文本 为 文本型,右侧文本 为 文本型)

取出字符串中指定的文本的中间字符串；例如：取指定文本中间("123456","4","6") 结果为5。

' 提取两个标记之间的内容
变量 HTML = "<title>我的网页</title>"
变量 标题 = 取指定文本中间(HTML, "<title>", "</title>")
调试输出("标题: " + 标题)  ' 我的网页
' 提取括号中的内容
变量 文本 = "函数(参数1,参数2)结束"
变量 参数 = 取指定文本中间(文本, "(", ")")
调试输出("参数: " + 参数)  ' 参数1,参数2
' 提取JSON字符串中的值
变量 JSON文本 = "{\"name\":\"张三\",\"age\":25}"
变量 姓名 = 取指定文本中间(JSON文本, "\"name\":\"", "\"")
调试输出("姓名: " + 姓名)  ' 张三

函数：取指定文本中间批量(文本内容 为 文本型,左边文本 为 文本型,右边文本 为 文本型)

取出字符串中；所有的指定文本的中间文本；并返回数组，例如：见文本操作例程。

' 批量提取HTML标签中的内容
变量 HTML = "<li>苹果</li><li>香蕉</li><li>橙子</li>"
变量 水果列表 = 取指定文本中间批量(HTML, "<li>", "</li>")
调试输出("水果数量: " + 取数组成员数(水果列表))  ' 3
调试输出("第一个: " + 水果列表[0])  ' 苹果
' 批量提取所有链接地址
变量 内容 = "链接：<a href=\"url1\">链接1</a> 和 <a href=\"url2\">链接2</a>"
变量 链接列表 = 取指定文本中间批量(内容, "href=\"", "\"")
变量循环(i = 0, 取数组成员数(链接列表), 1)
	调试输出("链接: " + 链接列表[i])
结束循环

函数：删首尾空(文本内容 为 文本型)

删除字符串的首尾空白字符（包括空格、制表符、换行、回车以及其它 Unicode 空白字符），返回删除后的文本。

' 清理用户输入的首尾空格
变量 用户输入 = "  Hello World  "
调试输出(删首尾空(用户输入))  ' Hello World
' 清理含换行符的文本
变量 多行文本 = "\n  内容  \r\n"
调试输出(删首尾空(多行文本))  ' 内容
' 表单数据清洗
变量 用户名 = "  zhangsan  "
如果(删首尾空(用户名) == "")
	弹出提示("用户名不能为空")
结束 如果

函数：删首空(文本内容 为 文本型)

删除字符串开始位置的空格。

' 仅删除开头的空格，保留结尾空格
变量 文本 = "  Hello World  "
变量 结果 = 删首空(文本)
调试输出("[" + 结果 + "]")  ' [Hello World  ]
' 处理缩进文本
变量 代码 = "    function test() {"
调试输出(删首空(代码))  ' function test() {

函数：删尾空(文本内容 为 文本型)

删除字符串结尾的空格。

' 仅删除结尾的空格，保留开头空格
变量 文本 = "  Hello World  "
变量 结果 = 删尾空(文本)
调试输出("[" + 结果 + "]")  ' [  Hello World]
' 清理文件路径末尾的空格
变量 路径 = "/home/user/   "
调试输出(删尾空(路径))  ' /home/user/

函数：子文本替换(待操作文本 为 文本型,欲替换文本 为 文本型,用作替换的文本 为 文本型)

将文本中指定字符串替换成另一个字符串；返回替换后的字符串；注意：该替换只会替换寻找到的第一个字符串；如果需要替换全部可使用“子文本替换全部”。

' 替换第一个匹配的文本
变量 文本 = "今天是星期一，明天也是星期一"
变量 结果 = 子文本替换(文本, "星期一", "星期二")
调试输出(结果)  ' 今天是星期二，明天也是星期一
' 替换敏感词
变量 评论 = "这个垃圾产品太垃圾了"
变量 过滤后 = 子文本替换(评论, "垃圾", "***")
调试输出(过滤后)  ' 这个***产品太垃圾了
' 替换占位符
变量 模板 = "欢迎您，{name}！"
变量 内容 = 子文本替换(模板, "{name}", "张三")
调试输出(内容)  ' 欢迎您，张三！

函数：子文本替换全部(待操作文本 为 文本型,欲替换文本 为 文本型,用作替换的文本 为 文本型)

文本中指定字符串全部替换成另一个字符串；返回替换后的字符串。

' 替换所有匹配的文本
变量 文本 = "今天是星期一，明天也是星期一"
变量 结果 = 子文本替换全部(文本, "星期一", "星期二")
调试输出(结果)  ' 今天是星期二，明天也是星期二
' 全局过滤敏感词
变量 评论 = "这个垃圾产品太垃圾了"
变量 过滤后 = 子文本替换全部(评论, "垃圾", "***")
调试输出(过滤后)  ' 这个***产品太***了
' 替换所有空格为下划线
变量 文件名 = "my document file.txt"
变量 新文件名 = 子文本替换全部(文件名, " ", "_")
调试输出(新文件名)  ' my_document_file.txt

函数：分割文本(待操作文本 为 文本型,分割符 为 文本型,启用正则模式 为 逻辑型)

按指定分隔符分割文本字符串；返回分割后的文本数组，参数三：启用正则模式 可省略，如果设置为真，则分割符将以正则形式作为分隔符，此时：“.”，“|”等符号将以正则方式参与文本的分割。

' 按逗号分割文本
变量 文本 = "苹果,香蕉,橙子,葡萄"
变量 水果数组 = 分割文本(文本, ",")
调试输出("数量: " + 取数组成员数(水果数组))  ' 4
调试输出("第一个: " + 水果数组[0])  ' 苹果
' 使用正则模式分割（按任意空白字符分割）
变量 句子 = "Hello   World   JavaScript"
变量 单词 = 分割文本(句子, "\\s+", 真)
调试输出("单词数: " + 取数组成员数(单词))  ' 3
' 分割CSV数据
变量 CSV行 = "张三,25,男,北京"
变量 字段 = 分割文本(CSV行, ",")
调试输出("姓名: " + 字段[0] + "，年龄: " + 字段[1])

函数：格式化文本(模板内容 为 文本型,值 为 文本型)

将指定字符串与值通过占位符格式化显示、例如：格式化文本("今天星期{0}、一起去看花！",1)、执行该函数后、将会返回：今天星期1、一起去看花！注意：如果字符串中含有单引号、单引号必须写为两个、另一个单引号作为转义功能；例如在处理数据库命令时："name=‘’{0}‘’,age=23" ；原本的单引号需使用两个。

' 使用占位符格式化文本
变量 结果1 = 格式化文本("今天星期{0}、一起去看花！", 1)
调试输出(结果1)  ' 今天星期1、一起去看花！
' 格式化欢迎信息
变量 用户名 = "张三"
变量 结果2 = 格式化文本("欢迎您，{0}！您是第{1}位访客。", 用户名, 100)
调试输出(结果2)  ' 欢迎您，张三！您是第100位访客。
' 格式化日期信息
变量 年 = 2024
变量 月 = 1
变量 日 = 15
变量 日期 = 格式化文本("{0}年{1}月{2}日", 年, 月, 日)
调试输出(日期)  ' 2024年1月15日

函数：取字符(文本内容 为 文本型,位置 为 整数型)

获取指定文本内容中指定位置处的单个字符，位置从0开始。

' 获取指定位置的单个字符
变量 文本 = "Hello"
调试输出(取字符(文本, 0))  ' H
调试输出(取字符(文本, 1))  ' e
调试输出(取字符(文本, 4))  ' o
' 遍历字符串中的每个字符
变量 中文 = "你好世界"
变量循环(i = 0, 取文本长度(中文), 1)
	调试输出("第" + (i+1) + "个字符: " + 取字符(中文, i))
结束循环
' 获取身份证最后一位（校验码）
变量 身份证 = "110105199001011234"
变量 校验码 = 取字符(身份证, 取文本长度(身份证) - 1)
调试输出("校验码: " + 校验码)  ' 4

函数：删全部空(待操作文本)

删除字符串中所有的空格。代码示例：变量 结果文本 = 删全部空(待操作文本)

' 格式化手机号码
变量 格式化号码 = "138 1234 5678"
变量 纯号码 = 删全部空(格式化号码)
调试输出("纯号码: " + 纯号码)  ' 13812345678
' 处理身份证号码输入
变量 身份证输入 = "110 101 1990 0101 1234"
变量 纯身份证 = 删全部空(身份证输入)
如果(取文本长度(纯身份证) == 18)
	调试输出("身份证号码格式正确: " + 纯身份证)
结束 如果

函数：取文本行数(待操作文本)

计算字符串中有多少行。代码示例：变量 行数 = 取文本行数(待操作文本)

' 计算多行文本的行数
变量 多行文本 = "第一行\n第二行\n第三行\n第四行"
变量 行数 = 取文本行数(多行文本)
调试输出("文本共有 " + 行数 + " 行")  ' 4
' 处理用户评论
变量 用户评论 = "这是一条评论\n这是第二行\n这是第三行"
变量 评论行数 = 取文本行数(用户评论)
如果(评论行数 > 10)
	调试输出("评论过长，请精简到10行以内")
否则
	调试输出("评论符合要求，共 " + 评论行数 + " 行")
结束 如果

函数：到全角(待操作文本)

将指定字符串内容从半角转成全角，返回转换后的全角内容。

' 将半角字母数字转为全角
变量 半角文本 = "ABC123"
变量 全角文本 = 到全角(半角文本)
调试输出(全角文本)  ' ＡＢＣ１２３
' 将半角标点转为全角
变量 标点 = "Hello, World!"
调试输出(到全角(标点))  ' Ｈｅｌｌｏ， Ｗｏｒｌｄ！
' 用于中文排版对齐
变量 数据 = "价格:100元"
调试输出(到全角(数据))  ' 价格：１００元

函数：到半角(待操作文本)

将指定字符串内容从全角转成半角，返回转换后的半角内容。

' 将全角字母数字转为半角
变量 全角文本 = "ＡＢＣ１２３"
变量 半角文本 = 到半角(全角文本)
调试输出(半角文本)  ' ABC123
' 将全角标点转为半角
变量 标点 = "Ｈｅｌｌｏ，Ｗｏｒｌｄ！"
调试输出(到半角(标点))  ' Hello,World!
' 清理用户输入的全角字符
变量 用户输入 = "１３８１２３４５６７８"
变量 标准手机号 = 到半角(用户输入)
调试输出("手机号: " + 标准手机号)  ' 13812345678

学习要点

相关文档

• 文档前端(JavaScript)函数_正则表达类 —— 正则匹配、正则替换 等高级文本处理函数
• 文档前端(JavaScript)函数_数据转换类 —— 到文本、到大写、URL编码 等转换函数
• 文档前端(JavaScript)函数_数组操作 —— 分割文本 返回数组的遍历处理
• 文档前端(JavaScript)函数_储存类 —— 配合 取文本长度 做数据校验后存储
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明与基础语法

前端(JavaScript)函数_URL地址操作类

文档概述

轻语言网站开发中的URL地址操作函数、用于处理浏览器地址栏的URL信息，包含获取URL参数、设置URL、解析地址信息、处理查询字符串等功能，常用于页面路由、参数传递、URL解析等场景。

• URL结构分解：协议://主机名:端口/路径名?查询部分#锚部分，可分别用 取URL协议/取URL主机名/取URL端口/取URL路径名/取URL查询部分/取URL地址锚 获取
• 页面控制：重载页面 用于刷新当前页面，常用于数据更新后强制刷新

💡 URL 解析对照：以 https://www.example.com:8080/news/list?id=10&cat=tech#article 为例，取URL协议→"https:"、取URL主机名→"www.example.com"、取URL端口→"8080"、取URL路径名→"/news/list"、取URL查询部分→"?id=10&cat=tech"、取URL地址锚→"#article"。

函数：取URL地址锚()

获取当前 URL 的锚部分（从 # 号开始的部分）。

' 获取页面锚点（常用于单页应用路由）
变量 锚 = 取URL地址锚()
调试输出("锚部分: " + 锚)  ' 如：#article

' 根据锚点加载对应内容
变量 锚点 = 取URL地址锚()
如果(锚点 == "#用户列表")
	加载用户列表()
否则 如果(锚点 == "#商品列表")
	加载商品列表()
结束 如果

函数：取URL主机名及端口()

获取当前 URL 的主机名和端口。

变量 主机及端口 = 取URL主机名及端口()
调试输出("主机及端口: " + 主机及端口)  ' 如：www.example.com:8080

' 区分开发环境与生产环境
变量 当前主机 = 取URL主机名及端口()
如果(当前主机 == "localhost:8080")
	调试输出("当前为开发环境")
否则
	调试输出("当前为生产环境")
结束 如果

函数：取URL主机名()

获取当前 URL 的主机名。

变量 主机名 = 取URL主机名()
调试输出("主机名: " + 主机名)  ' 如：www.example.com

' 根据域名切换配置
变量 域名 = 取URL主机名()
如果(域名 == "api.test.com")
	调试输出("使用测试API")
否则 如果(域名 == "api.prod.com")
	调试输出("使用生产API")
结束 如果

函数：取URL完整地址()

获取当前完整的 URL。

变量 完整地址 = 取URL完整地址()
调试输出("完整URL: " + 完整地址)

' 分享当前页面地址
变量 当前页面 = 取URL完整地址()
复制文本(当前页面)
弹出提示("页面地址已复制，可分享给好友")

函数：取URL路径名()

获取当前 URL 的路径名。

变量 路径名 = 取URL路径名()
调试输出("路径名: " + 路径名)  ' 如：/news/list

' 根据路径高亮导航菜单
变量 路径 = 取URL路径名()
如果(寻找文本(路径, "news") != -1)
	新闻菜单.添加样式("active")
结束 如果

函数：取URL端口()

获取当前 URL 服务器使用的端口号。

变量 端口 = 取URL端口()
调试输出("端口: " + 端口)  ' 如：8080

' 根据端口判断环境
变量 当前端口 = 取URL端口()
如果(当前端口 == "443" 或 当前端口 == "")
	调试输出("使用HTTPS默认端口")
结束 如果

函数：取URL协议()

获取当前 URL 的协议。

变量 协议 = 取URL协议()
调试输出("协议: " + 协议)  ' 如：https:

' 强制HTTPS跳转
变量 当前协议 = 取URL协议()
如果(当前协议 == "http:")
	切换页面("https://" + 取URL主机名() + 取URL路径名())
结束 如果

函数：取URL查询部分()

获取当前 URL 的查询部分（从 ? 号开始的部分）。

变量 查询部分 = 取URL查询部分()
调试输出("查询部分: " + 查询部分)  ' 如：?id=10&cat=tech

' 提取查询参数值需配合 字符串操作 函数
变量 查询 = 取URL查询部分()
变量 起始 = 寻找文本(查询, "id=") + 3
变量 结束 = 寻找文本(查询, "&", 起始)
调试输出("id值: " + 取文本中间(查询, 起始, 结束))

函数：重载页面()

重新加载当前页面。

' 重新加载当前页面
重载页面()

' 点击刷新按钮时重新加载
刷新按钮.置被单击回调(() => {
	重载页面()
})

' 数据更新后提示并刷新
保存按钮.置被单击回调(() => {
	弹出提示("保存成功，正在刷新")
	重载页面()
})

学习要点

相关文档

• 文档前端(JavaScript)函数_字符串操作 —— 寻找文本、取文本中间 等用于解析URL查询字符串
• 文档前端(JavaScript)函数_历史类 —— 前进页面、后退页面 浏览历史控制
• 文档前端(JavaScript)函数_浏览器操作类 —— 切换页面、弹出提示 浏览器操作函数
• 文档前端(JavaScript)函数_数据转换类 —— URL编码、URL解码 网址编码函数
• 文档前端(JavaScript)函数_储存类 —— 保存配置 存储当前URL参数

前端(JavaScript)函数_对象操作

文档概述

轻语言网站开发中的对象操作函数、基于 JavaScript 对象操作 Object 类封装，包含对象属性获取、对象成员操作、对象比较、对象转换等功能，常用于数据处理、对象管理、JSON操作等场景。

• 对象遍历：取对象成员数 + 取对象成员名 组合可遍历对象的所有属性，类似 Object.keys().length
• 成员检测：取对象是否包含 等价于 Object.prototype.hasOwnProperty()，判断对象自身是否含有指定属性
• 对象序列化：配合 JSON编码 / JSON解析 可实现对象的字符串化与还原，用于存储、传输

💡 对象与数组区别：对象使用 {} 定义、以"键值对"形式存储数据，通过 对象.属性 或 对象["属性"] 访问；数组使用 [] 定义、以"索引"形式存储数据，通过 取数组成员(数组, 索引) 访问。

函数：取对象成员数(目标对象)

获取指定对象中的成员数量。代码示例：变量 成员数 = 取对象成员数(目标对象)

' 获取用户对象的属性数量
变量 用户 = {
	"姓名": "张三",
	"年龄": 25,
	"职业": "工程师"
}
变量 成员数 = 取对象成员数(用户)
调试输出("用户对象有 " + 成员数 + " 个属性")

' 检查配置对象是否包含预期数量的属性
变量 配置 = {
	"主题": "dark",
	"语言": "zh-CN",
	"通知": 真
}
如果(取对象成员数(配置) < 3)
	调试输出("配置不完整")
结束 如果

函数：取对象成员名(目标对象,索引)

获取指定对象中指定索引位置处的成员属性名。代码示例：变量 属性名 = 取对象成员名(目标对象, 0)

' 遍历对象的所有属性名
变量 商品 = {
	"名称": "手机",
	"价格": 2999,
	"品牌": "XX品牌"
}
变量 属性总数 = 取对象成员数(商品)
变量循环(i = 0, 属性总数, 1)
	变量 属性名 = 取对象成员名(商品, i)
	调试输出("第 " + (i+1) + " 个属性名: " + 属性名)
结束循环

' 获取第一个属性名
变量 第一个属性 = 取对象成员名(商品, 0)
调试输出("第一个属性: " + 第一个属性)  ' 名称

函数：取对象是否包含(目标对象,成员名)

获取指定对象中是否包含指定成员；包含返回真、否则返回假。代码示例：变量 是否包含 = 取对象是否包含(目标对象, "属性名")

' 检查用户对象是否包含特定属性
变量 用户信息 = {
	"用户名": "user123",
	"邮箱": "user@example.com",
	"注册时间": "2023-01-01"
}
如果(取对象是否包含(用户信息, "手机号"))
	调试输出("用户已绑定手机号")
否则
	调试输出("用户未绑定手机号")
结束 如果

' 检查必需字段是否存在
变量 必需字段 = ["用户名", "邮箱", "密码"]
变量循环(i = 0, 取数组成员数(必需字段), 1)
	变量 字段 = 取数组成员(必需字段, i)
	如果(!取对象是否包含(用户信息, 字段))
		调试输出("缺少必需字段: " + 字段)
	结束 如果
结束循环

函数：取对象是否为空(目标对象)

判断指定对象是否为空。代码示例：变量 是否为空 = 取对象是否为空(目标对象)

' 检查响应数据是否为空
变量 响应数据 = { }
如果(取对象是否为空(响应数据))
	调试输出("未获取到有效数据")
否则
	调试输出("数据获取成功")
结束 如果

' 检查用户输入数据
变量 用户输入 = {
	"姓名": "",
	"电话": ""
}
如果(取对象是否为空(用户输入))
	调试输出("用户未输入任何信息")
否则
	调试输出("用户已输入信息")
结束 如果

函数：删除对象属性(目标对象,属性名称)

删除指定对象中的指定属性。代码示例：删除对象属性(目标对象, "属性名")

' 从用户信息中删除敏感信息
变量 用户信息 = {
	"用户名": "user123",
	"密码": "secret123",
	"邮箱": "user@example.com",
	"余额": 1000
}
' 删除密码等敏感信息
删除对象属性(用户信息, "密码")
删除对象属性(用户信息, "余额")
调试输出("安全的用户信息: " + JSON编码(用户信息))

' 动态删除对象属性
变量 配置 = {
	"开发模式": 真,
	"调试信息": "详细",
	"生产环境": 假
}
如果(!配置.生产环境)
	删除对象属性(配置, "调试信息")
结束 如果

学习要点

相关文档

• 文档前端(JavaScript)函数_数据转换类 —— JSON编码、JSON解析 对象序列化函数
• 文档前端(JavaScript)函数_数组操作 —— 取数组成员、取数组成员数 数组操作函数
• 文档前端(JavaScript)函数_字符串操作 —— 取文本长度、寻找文本 等文本处理函数
• 文档轻语言网站：变量与数组与对象的定义 —— 变量、对象、数组的基本语法
• 文档综合演示：公用模块全局变量函数使用演示 —— 全局对象与公用模块实战

前端(JavaScript)函数_屏幕操作类

文档概述

轻语言网站开发中的屏幕操作函数、用于获取和操作屏幕显示信息，包含屏幕分辨率、屏幕尺寸、滚动位置、视口尺寸等屏幕相关功能，常用于响应式设计、全屏操作、屏幕适配等场景。

• 屏幕尺寸：取屏幕宽度/取屏幕高度 返回屏幕总尺寸；取屏幕可用宽度/取屏幕可用高度 返回去除任务栏后的可用尺寸
• 色彩信息：取屏幕颜色深度/取屏幕像素深度 返回色彩位数（通常为24位或32位）

💡 屏幕尺寸 vs 窗口尺寸：取屏幕宽度/取屏幕高度 返回物理屏幕总尺寸（含任务栏）；取屏幕可用宽度/取屏幕可用高度 返回去除系统任务栏后的可用区域。两者常用于响应式布局判断与全屏适配。

函数：取屏幕可用高度()

返回屏幕的高度（不包括Windows任务栏）。

变量 可用高度 = 取屏幕可用高度()
调试输出("可用高度: " + 可用高度 + "px")

' 根据可用高度设置弹窗最大高度
变量 最大高度 = 取屏幕可用高度() - 100
弹窗.高度 = 最大高度

函数：取屏幕可用宽度()

返回屏幕的宽度（不包括Windows任务栏）。

变量 可用宽度 = 取屏幕可用宽度()
调试输出("可用宽度: " + 可用宽度 + "px")

' 居中显示窗口
变量 窗口宽度 = 800
变量 窗口左边距 = (取屏幕可用宽度() - 窗口宽度) / 2
主窗口.左边距 = 窗口左边距

函数：取屏幕高度()

返回屏幕的总高度。

变量 屏幕高度 = 取屏幕高度()
调试输出("屏幕高度: " + 屏幕高度 + "px")

' 判断屏幕方向（横屏/竖屏）
如果(取屏幕宽度() > 取屏幕高度())
	调试输出("横屏模式")
否则
	调试输出("竖屏模式")
结束 如果

函数：取屏幕宽度()

返回屏幕的总宽度。

变量 屏幕宽度 = 取屏幕宽度()
调试输出("屏幕宽度: " + 屏幕宽度 + "px")

' 响应式布局判断
变量 宽度 = 取屏幕宽度()
如果(宽度 >= 1920)
	调试输出("大屏设备")
否则 如果(宽度 >= 1366)
	调试输出("中屏设备")
否则
	调试输出("小屏设备")
结束 如果

函数：取屏幕颜色深度()

返回目标设备或缓冲器上的调色板的比特深度。

变量 颜色深度 = 取屏幕颜色深度()
调试输出("颜色深度: " + 颜色深度 + "位")

' 检测低色位设备
如果(颜色深度 < 24)
	调试输出("低色位设备，建议使用简化色彩")
结束 如果

函数：取屏幕像素深度()

返回屏幕的颜色分辨率（每象素的位数）。

变量 像素深度 = 取屏幕像素深度()
调试输出("像素深度: " + 像素深度 + "位")

' 高色位设备可使用更丰富的色彩
如果(像素深度 >= 32)
	调试输出("支持高色彩显示")
结束 如果

学习要点

相关文档

• 文档前端(JavaScript)函数_窗口操作 —— 打开窗口、关闭窗口、窗口尺寸控制
• 文档前端(JavaScript)函数_浏览器操作类 —— 切换页面、弹出提示 浏览器操作
• 文档前端(JavaScript)函数_URL地址操作类 —— 重载页面 等URL操作
• 文档前端(JavaScript)函数_文档操作 —— 查找元素ByID 等DOM操作
• 文档前端(JavaScript)函数_储存类 —— 保存配置 存储用户屏幕偏好设置

前端(JavaScript)函数_数学运算

文档概述

轻语言网站开发中的数学运算相关操作函数、用于执行数值计算和数学处理，包含四舍五入、取随机整数、取余数、数值转换等数学运算功能，常用于数值计算、随机数生成、数学公式计算等场景。

• 基础运算：取绝对值、取次方、取平方根、取余数、取最大值/取最小值 实现常用数学计算
• 取整方式：向上取整（ceil）、向下取整（floor）、四舍五入取整（round）、取整数部分（trunc）四种取整方式各有差异
• 三角函数：取正弦/取余弦/取正切 及其反函数 取反正弦/取反余弦/取反正切，角度与弧度互转用 弧度 * 180 / Math.PI
• 对数指数：取指数（e^x）、取自然对数（ln）、取对数By底为10（log10）、取对数By底为2（log2）
• 随机数：取随机小数（0~1）、取随机整数(最小值, 最大值)（指定区间整数）

💡 角度与弧度转换：轻语言三角函数使用弧度制。角度转弧度：角度 * Math.PI / 180；弧度转角度：弧度 * 180 / Math.PI。其中 Math.PI 为原生 JS 圆周率常量，轻语言支持直接使用。

函数：取绝对值(值)

返回参数值的绝对值。代码示例：变量 绝对值 = 取绝对值(值)

' 计算两点间距离时使用绝对值
变量 温度差 = 取绝对值(今日温度 - 昨日温度)
调试输出("温差: " + 温度差 + " 度")
' 处理负数输入
变量 用户输入 = -5
变量 正数 = 取绝对值(用户输入)
调试输出("绝对值: " + 正数)  ' 输出: 5

函数：取次方(X,Y)

计算 X 的 Y 次方。代码示例：变量 结果 = 取次方(X, Y)

' 计算面积和体积
变量 边长 = 5
变量 正方形面积 = 取次方(边长, 2)  ' 5^2 = 25
变量 立方体体积 = 取次方(边长, 3)  ' 5^3 = 125
调试输出("正方形面积: " + 正方形面积)
调试输出("立方体体积: " + 立方体体积)
' 计算平方根（相当于1/2次方）
变量 数值 = 16
变量 平方根 = 取次方(数值, 0.5)  ' 16^(1/2) = 4
调试输出("平方根: " + 平方根)

函数：取反正弦(值)

返回一个数的反正弦值，结果为 -π/2 到 π/2 弧度之间。代码示例：变量 角度 = 取反正弦(值)

' 计算三角形的角度
变量 对边 = 3
变量 斜边 = 5
变量 正弦值 = 对边 / 斜边  ' 0.6
变量 弧度 = 取反正弦(正弦值)
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 角度 = 弧度 * 180 / Math.PI
调试输出("角度: " + 角度 + " 度")  ' 约 36.87 度

函数：取反余弦(值)

返回一个数的反余弦值，结果为 0 到 π 弧度之间。代码示例：变量 角度 = 取反余弦(值)

' 计算三角形的角度
变量 邻边 = 4
变量 斜边 = 5
变量 余弦值 = 邻边 / 斜边  ' 0.8
变量 弧度 = 取反余弦(余弦值)
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 角度 = 弧度 * 180 / Math.PI
调试输出("角度: " + 角度 + " 度")  ' 约 53.13 度

函数：取反正切(值)

返回一个数的反正切值，结果为 -π/2 到 π/2 弧度之间。代码示例：变量 角度 = 取反正切(值)

' 计算直线的倾斜角
变量 对边 = 3
变量 邻边 = 4
变量 正切值 = 对边 / 邻边  ' 0.75
变量 弧度 = 取反正切(正切值)
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 角度 = 弧度 * 180 / Math.PI
调试输出("倾斜角: " + 角度 + " 度")  ' 约 36.87 度

函数：取角度反正切(Y, X)

返回从 x 轴到点 (x, y) 之间的角度的反正切值。代码示例：变量 角度 = 取角度反正切(Y, X)

' 计算点相对于原点的角度
变量 X坐标 = 1
变量 Y坐标 = 1
变量 弧度 = 取角度反正切(Y坐标, X坐标)
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 角度 = 弧度 * 180 / Math.PI
调试输出("角度: " + 角度 + " 度")  ' 45 度
' 处理各个象限的情况
变量 角度1 = 取角度反正切(1, -1) * 180 / Math.PI  ' 第二象限
变量 角度2 = 取角度反正切(-1, -1) * 180 / Math.PI  ' 第三象限
变量 角度3 = 取角度反正切(-1, 1) * 180 / Math.PI  ' 第四象限

函数：向上取整(值)

返回大于或等于给定数字的最小整数。代码示例：变量 整数 = 向上取整(值)

' 计算需要的包装箱数量
变量 商品总数 = 123
变量 每箱容量 = 10
变量 需要箱子数 = 向上取整(商品总数 / 每箱容量)
调试输出("需要箱子数: " + 需要箱子数)  ' 13 个箱子
' 处理价格计算
变量 价格 = 99.01
变量 整数价格 = 向上取整(价格)
调试输出("整数价格: " + 整数价格)  ' 100

函数：取余弦(值)

返回一个数的余弦值，值的范围在 -1 到 1 之间。代码示例：变量 余弦值 = 取余弦(值)

' 计算波形运动的位置
变量 时间 = 1
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 频率 = 2 * Math.PI  ' 每秒一个周期
变量 相位 = 0
变量 幅度 = 10
变量 位置 = 幅度 * 取余弦(频率 * 时间 + 相位)
调试输出("位置: " + 位置)
' 计算三角形的邻边长度
变量 斜边 = 5
变量 角度 = 30 * Math.PI / 180  ' 转换为弧度
变量 邻边 = 斜边 * 取余弦(角度)
调试输出("邻边长度: " + 邻边)

函数：取双曲余弦(值)

返回一个数的双曲余弦值。代码示例：变量 双曲余弦值 = 取双曲余弦(值)

' 计算悬链线形状
变量 x = 1
变量 悬链线值 = 取双曲余弦(x)
调试输出("悬链线值: " + 悬链线值)
' 数学计算中的应用
变量 参数 = 2
变量 结果 = 取双曲余弦(参数)
调试输出("cosh(" + 参数 + ") = " + 结果)

函数：取指数(值)

返回 E^x，其中 x 是参数，E 是自然对数的底数。代码示例：变量 指数值 = 取指数(值)

' 计算复利增长
变量 本金 = 1000
变量 利率 = 0.05
变量 时间 = 2
变量 最终金额 = 本金 * 取指数(利率 * 时间)
调试输出("最终金额: " + 最终金额)
' 自然增长模型
变量 初始值 = 100
变量 增长率 = 0.1
变量 时间 = 5
变量 结果 = 初始值 * 取指数(增长率 * 时间)
调试输出("增长结果: " + 结果)

函数：向下取整(值)

返回小于或等于给定数字的最大整数。代码示例：变量 整数 = 向下取整(值)

' 计算折扣后的价格
变量 原价 = 99.99
变量 折扣价 = 向下取整(原价)
调试输出("折扣价: " + 折扣价)  ' 99
' 分页计算
变量 总记录数 = 123
变量 每页记录数 = 10
变量 总页数 = 向下取整(总记录数 / 每页记录数)
调试输出("总页数: " + 总页数)  ' 12

函数：取最大值(值1, 值2, ...)

返回一组数值中的最大值。代码示例：变量 最大值 = 取最大值(值1, 值2, ...)

' 找出最高分数
变量 分数1 = 85
变量 分数2 = 92
变量 分数3 = 78
变量 最高分 = 取最大值(分数1, 分数2, 分数3)
调试输出("最高分: " + 最高分)  ' 92
' 确保数值不超过上限
变量 值 = 150
变量 上限 = 100
变量 结果 = 取最大值(值, 上限)
调试输出("限制后结果: " + 结果)  ' 100

函数：取最小值(值1, 值2, ...)

返回一组数值中的最小值。代码示例：变量 最小值 = 取最小值(值1, 值2, ...)

' 找出最低温度
变量 温度1 = 15
变量 温度2 = 12
变量 温度3 = 18
变量 最低温度 = 取最小值(温度1, 温度2, 温度3)
调试输出("最低温度: " + 最低温度)  ' 12
' 确保数值不低于下限
变量 值 = -5
变量 下限 = 0
变量 结果 = 取最小值(值, 下限)
调试输出("限制后结果: " + 结果)  ' 0

函数：四舍五入取整(值)

返回一个数字四舍五入后最接近的整数。代码示例：变量 整数 = 四舍五入取整(值)

' 计算平均分
变量 总分 = 87.6
变量 平均分 = 四舍五入取整(总分)
调试输出("平均分: " + 平均分)  ' 88
' 处理货币计算
变量 金额 = 123.456
变量 整数金额 = 四舍五入取整(金额)
调试输出("整数金额: " + 整数金额)  ' 123

函数：取正弦(值)

返回一个数的正弦值，值的范围在 -1 到 1 之间。代码示例：变量 正弦值 = 取正弦(值)

' 计算波形运动的位置
变量 时间 = 1
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 频率 = 2 * Math.PI  ' 每秒一个周期
变量 相位 = 0
变量 幅度 = 10
变量 位置 = 幅度 * 取正弦(频率 * 时间 + 相位)
调试输出("位置: " + 位置)
' 计算三角形的对边长度
变量 斜边 = 5
变量 角度 = 30 * Math.PI / 180  ' 转换为弧度
变量 对边 = 斜边 * 取正弦(角度)
调试输出("对边长度: " + 对边)

函数：取双曲正弦(值)

返回一个数的双曲正弦值。代码示例：变量 双曲正弦值 = 取双曲正弦(值)

' 数学计算中的应用
变量 参数 = 1
变量 结果 = 取双曲正弦(参数)
调试输出("sinh(" + 参数 + ") = " + 结果)
' 物理公式计算
变量 x = 2
变量 sinh_x = 取双曲正弦(x)
调试输出("sinh(" + x + ") = " + sinh_x)

函数：取平方根(值)

返回一个数的平方根。代码示例：变量 平方根 = 取平方根(值)

' 计算直角三角形的斜边
变量 直角边1 = 3
变量 直角边2 = 4
变量 斜边 = 取平方根(取次方(直角边1, 2) + 取次方(直角边2, 2))
调试输出("斜边长度: " + 斜边)  ' 5
' 计算标准差
变量 方差 = 16
变量 标准差 = 取平方根(方差)
调试输出("标准差: " + 标准差)  ' 4

函数：取正切(值)

返回一个数的正切值。代码示例：变量 正切值 = 取正切(值)

' 计算坡度
' 注：Math.PI 为原生 JS 常量（圆周率π），轻语言支持直接使用
变量 角度 = 30 * Math.PI / 180  ' 30度转换为弧度
变量 坡度 = 取正切(角度)
调试输出("坡度: " + 坡度)
' 计算直角三角形的对边与邻边比值
变量 对边 = 3
变量 邻边 = 4
变量 正切值 = 对边 / 邻边
调试输出("正切值: " + 正切值)  ' 0.75

函数：取双曲正切(值)

返回一个数的双曲正切值。代码示例：变量 双曲正切值 = 取双曲正切(值)

' 数学计算中的应用
变量 参数 = 1
变量 结果 = 取双曲正切(参数)
调试输出("tanh(" + 参数 + ") = " + 结果)
' 机器学习激活函数
变量 x = 0.5
变量 tanh_x = 取双曲正切(x)
调试输出("tanh(" + x + ") = " + tanh_x)

函数：取自然对数(值)

返回一个数的自然对数（以 e 为底）。代码示例：变量 对数值 = 取自然对数(值)

' 计算复利时间
变量 最终金额 = 2000
变量 本金 = 1000
变量 利率 = 0.05
变量 时间 = (取自然对数(最终金额 / 本金)) / 利率
调试输出("所需时间: " + 时间 + " 年")
' 数学计算
' 注：Math.E 为原生 JS 常量（自然常数 e），轻语言支持直接使用
变量 数值 = Math.E  ' 自然常数 e
变量 ln_e = 取自然对数(数值)
调试输出("ln(e) = " + ln_e)  ' 1

函数：取对数By底为10(值)

返回一个数以 10 为底的对数。代码示例：变量 对数值 = 取对数By底为10(值)

' 计算声音强度等级（分贝）
变量 实际强度 = 1000
变量 基准强度 = 1
变量 分贝 = 10 * 取对数By底为10(实际强度 / 基准强度)
调试输出("声音强度: " + 分贝 + " dB")
' 科学计算
变量 数值 = 1000
变量 log10值 = 取对数By底为10(数值)
调试输出("log10(" + 数值 + ") = " + log10值)  ' 3

函数：取对数By底为2(值)

返回一个数以 2 为底的对数。代码示例：变量 对数值 = 取对数By底为2(值)

' 计算二进制位数
变量 数值 = 256
变量 位数 = 取对数By底为2(数值) + 1
调试输出(数值 + " 需要 " + 位数 + " 位二进制表示")
' 算法复杂度计算
变量 元素数量 = 1024
变量 时间复杂度 = 取对数By底为2(元素数量)
调试输出("时间复杂度: O(" + 时间复杂度 + ")")

函数：取整数部分(值)

返回一个数的整数部分，去除小数部分。代码示例：变量 整数 = 取整数部分(值)

' 提取整数部分
变量 浮点数 = -3.7
变量 整数部分 = 取整数部分(浮点数)
调试输出("整数部分: " + 整数部分)  ' -3
' 与 floor 和 ceil 的区别
变量 正数 = 3.7
变量 负数 = -3.7
调试输出("trunc(" + 正数 + ") = " + 取整数部分(正数))  ' 3
调试输出("trunc(" + 负数 + ") = " + 取整数部分(负数))  ' -3

函数：取随机小数()

返回一个大于或等于 0 且小于 1 的随机小数。代码示例：变量 随机数 = 取随机小数()

' 生成0到1之间的随机数
变量 随机小数 = 取随机小数()
调试输出("随机小数: " + 随机小数)
' 生成指定范围的随机数
变量 最小值 = 10
变量 最大值 = 20
变量 范围随机数 = 最小值 + 取随机小数() * (最大值 - 最小值)
调试输出("范围随机数: " + 范围随机数)

函数：表达式计算(表达式)

将给定的表达式计算得出结果。代码示例：变量 结果 = 表达式计算(表达式)

' 计算数学表达式
变量 表达式 = "2 + 3 * 4"
变量 结果 = 表达式计算(表达式)
调试输出(表达式 + " = " + 结果)  ' 14
' 动态计算
' 注：表达式内 Math.pow/Math.sqrt 为原生 JS 函数，需用原生 JS 语法
变量 公式 = "Math.pow(2, 3) + Math.sqrt(16)"
变量 计算结果 = 表达式计算(公式)
调试输出(公式 + " = " + 计算结果)  ' 12

函数：取随机整数(最小值,最大值)

获取指定区间的随机整数。代码示例：变量 随机整数 = 取随机整数(最小值, 最大值)

' 生成指定范围的随机整数
变量 随机数 = 取随机整数(1, 100)
调试输出("1到100之间的随机数: " + 随机数)
' 模拟骰子投掷
变量 骰子点数 = 取随机整数(1, 6)
调试输出("骰子点数: " + 骰子点数)

函数：四舍五入(值,保留)

对浮点数进行四舍五入操作，保留指定位小数。代码示例：变量 结果 = 四舍五入(值, 保留)

' 保留两位小数
变量 价格 = 123.456
变量 保留两位 = 四舍五入(价格, 2)
调试输出("保留两位小数: " + 保留两位)  ' 123.46
' 保留一位小数
变量 数值 = 3.14159
变量 保留一位 = 四舍五入(数值, 1)
调试输出("保留一位小数: " + 保留一位)  ' 3.1

函数：取余数(被除数,除数)

计算两个数相除得到的余数。代码示例：变量 余数 = 取余数(被除数, 除数)

' 判断奇偶数
变量 数字 = 7
变量 余数 = 取余数(数字, 2)
如果(余数 == 0)
	调试输出(数字 + " 是偶数")
否则
	调试输出(数字 + " 是奇数")
结束 如果
' 循环索引计算
变量 数组长度 = 5
变量 当前索引 = 7
变量 实际索引 = 取余数(当前索引, 数组长度)
调试输出("实际索引: " + 实际索引)  ' 2

学习要点

相关文档

• 文档前端(JavaScript)函数_数据转换类 —— 到整数、到小数、为非数字 等类型转换函数
• 文档前端(JavaScript)函数_字符串操作 —— 取文本长度、寻找文本 等字符串处理函数
• 文档前端(JavaScript)函数_数组操作 —— 数组遍历与随机元素访问
• 文档前端(JavaScript)函数_时间类 —— 时间戳计算与日期数学运算
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明与基础语法

前端(JavaScript)函数_数据操作类

文档概述

轻语言网站开发中的数据操作函数、用于处理数据读取和写入操作，包含JSON文件读取、XML文件读取、CSV文件读取、文本文件读取、文件下载等功能，常用于数据加载、文件处理、数据导入等场景。

• 剪贴板操作：复制文本(写入剪贴板) / 取剪贴板文本(读取剪贴板) 实现网页内复制粘贴功能
• 文件读取（异步）：读JSON文件 / 读XML文件 / 读CSV文件 / 读文本文件 均为异步操作，通过回调函数返回结果
• XML解析：解析XML文本 将 XML 字符串转为可操作的 DOM 对象，用 getElementsByTagName 取节点
• 回调语法：使用箭头函数 (参数) => { ... } 作为回调，原生 JS 语法，轻语言支持直接使用

💡 异步读取注意：文件读取函数是异步执行的，数据只能在回调函数内部使用，不能在回调外访问。如需在外部使用，需用 保存配置 / 全局变量存储，或串联调用下一个操作。

函数：复制文本(待复制文本)

复制指定文本内容到系统剪贴板。代码示例：复制文本("需要复制的内容")

' 复制一段文本到剪贴板
复制文本("这是要复制的内容")
' 复制变量值到剪贴板
变量 用户名 = "张三"
变量 邮箱地址 = "example@example.com"
复制文本(用户名 + " 的邮箱是: " + 邮箱地址)

函数：取剪贴板文本(回调函数)

从系统剪贴板获取文本内容并通过回调函数返回，回调函数返回一个参数：(文本值)。代码示例：取剪贴板文本(回调函数)

' 获取剪贴板内容并在回调函数中处理
取剪贴板文本((文本值)=>{
	调试输出("剪贴板内容: " + 文本值)
})			
' 将剪贴板内容设置到编辑框中
取剪贴板文本((文本值)=>{
	编辑框1.文本 = 文本值
})

函数：解析XML文本(XML文本)

将XML格式的字符串解析为XML文档对象。

' 解析XML字符串
变量 XML字符串 = "<用户><姓名>张三</姓名><年龄>25</年龄></用户>"
变量 XML对象 = 解析XML文本(XML字符串)
' 获取XML中的值
' 注：getElementsByTagName("姓名")[0].textContent 为原生 JS DOM 操作语法，轻语言支持直接使用
变量 姓名 = XML对象.getElementsByTagName("姓名")[0].textContent
变量 年龄 = XML对象.getElementsByTagName("年龄")[0].textContent

函数：读JSON文件(文件路径, 回调函数, 是否解析为JSON对象)

异步读取JSON文件，通过回调函数返回结果，回调函数返回一个参数：(JSON对象或字符串)，参数：是否解析为JSON对象、设置为真回调函数返回JSON对象、否则返回JSON字符串，该参数默认为假，可以省略。代码示例：读JSON文件("/data/config.json", 回调函数)

' 读取JSON文件并作为字符串处理
读JSON文件("/static/data/config.json", (数据)=>{
	调试输出("JSON内容: " + 数据)
})
' 读取JSON文件并解析为JSON对象
读JSON文件("/static/data/users.json", (数据)=>{
	' 数据已经是解析后的JSON对象，可直接操作对象中的属性
	调试输出("用户: " + 数据.用户)
	' 假设需要遍历JSON对象
	变量循环(i = 0, 取对象成员数(数据), 1)
		变量 成员名 = 取对象成员名(数据, i)
		调试输出("属性: " + 数据[成员名])
	结束循环
}, 真)

函数：读XML文件(文件路径, 回调函数)

异步读取XML文件，通过回调函数返回XML内容，回调函数返回一个参数：(XML字符串) 。代码示例：读XML文件("/data/config.xml", 回调函数)

' 读取XML文件
' 注：箭头函数 ()=>{} 为原生 JS 回调语法，轻语言支持直接使用
读XML文件("/static/data/config.xml", (XML内容)=>{
	调试输出("XML内容: " + XML内容)
	' 解析XML内容
	变量 XML文档 = 解析XML文本(XML内容)
	' 注：getElementsByTagName 为原生 JS DOM 方法，轻语言支持直接使用；可改用 取数组成员数(XML文档.getElementsByTagName("*"))
	变量 节点数 = 取数组成员数(XML文档.getElementsByTagName("*"))
	调试输出("XML节点数: " + 节点数)
})

函数：读CSV文件(文件路径, 回调函数)

异步读取CSV文件，通过回调函数返回解析后的二维数组。

' 读取并处理CSV文件
读CSV文件("/static/data/users.csv", (数据)=>{
	' 数据是一个二维数组，[行,列]
	调试输出("CSV数据:" + 数据)
	' 遍历数据并输出
	变量循环(i = 0, 取数组成员数(数据), 1)
		变量 行 = 数据[i]
		调试输出("第" + (i+1) + "行数据:")
		变量 列数据 = ""
		变量循环(j = 0, 取数组成员数(行), 1)
			列数据 = 列数据 + 行[j] + ","
		结束循环
		调试输出(列数据)
	结束循环
})

函数：读文本文件(文件路径, 回调函数)

异步读取文本文件，通过回调函数返回文件内容，回调函数返回一个参数：(文本内容) 。

' 读取文本文件内容
读文本文件("/static/docs/readme.txt", (内容)=>{
	调试输出("文件内容:")
	调试输出(内容)
})
' 将文本文件内容显示到指定标签中
读文本文件("/static/docs/license.txt", (内容)=>{
	标签1.文本 = 内容
})

学习要点

相关文档

• 文档前端(JavaScript)函数_对象操作 —— 取对象成员数、取对象成员名 对象遍历函数
• 文档前端(JavaScript)函数_数组操作 —— 取数组成员、取数组成员数 数组遍历函数
• 文档前端(JavaScript)函数_数据转换类 —— JSON编码、JSON解析 数据序列化函数
• 文档前端(JavaScript)函数_储存类 —— 异步读取后用 保存配置 持久化存储数据
• 文档前端(JavaScript)函数_网络操作类 —— 访问接口ByPOST 等网络请求函数

前端(JavaScript)函数_数据转换类

文档概述

轻语言网站开发中的数据转换函数、用于数据类型和格式转换，包含进制转换、金额大小写转换、数据类型转换、编码转换等功能，常用于数据格式化、类型转换、编码处理等场景。

• 类型转换核心：到整数、到小数、到数值、到文本 实现字符串与数值之间的互转，是表单数据处理的基础
• JSON序列化：JSON编码（对象→字符串）与 JSON解析（字符串→对象）成对使用，用于存储、传输复杂数据
• 进制与编码：到十六进制 / 到十进制 用于颜色值、字节数据处理；URL编码 / URL解码 用于网址参数处理
• 特殊场景：到大写金额 用于财务票据；为非数字 用于输入验证；取数据类型 用于运行时类型判断

💡 类型转换注意：从 localStorage 读取的数字是字符串型，参与数学运算前需用 到整数/到小数 转换；JSON解析 要求字符串必须是标准 JSON 格式（键名必须用双引号），否则会抛出错误。

函数：到整数(值)

将指定值（一般为字符串）转换为整数。代码示例：变量 整数 = 到整数(值)

' 将字符串转换为整数
变量 字符串数字 = "123"
变量 整数 = 到整数(字符串数字)
调试输出("转换结果: " + 整数)  ' 123
' 处理带小数的数字字符串
变量 带小数 = "45.67"
变量 整数部分 = 到整数(带小数)
调试输出("整数部分: " + 整数部分)  ' 45
' 处理无效输入
变量 无效输入 = "abc123"
变量 结果 = 到整数(无效输入)
如果(为非数字(结果))
	调试输出("转换失败")
否则
	调试输出("转换结果: " + 结果)
结束 如果

函数：到小数(值)

将指定值（一般为字符串）转换为小数。代码示例：变量 小数 = 到小数(值)

' 将字符串转换为小数
变量 字符串小数 = "123.45"
变量 小数 = 到小数(字符串小数)
调试输出("转换结果: " + 小数)  ' 123.45
' 处理科学计数法
变量 科学计数 = "1.23e2"
变量 转换结果 = 到小数(科学计数)
调试输出("转换结果: " + 转换结果)  ' 123
' 处理混合字符串
变量 混合字符串 = "3.14abc"
变量 部分结果 = 到小数(混合字符串)
调试输出("部分转换: " + 部分结果)  ' 3.14

函数：JSON解析(JSON文本)

解析JSON文本字符串并将其转成JSON对象，注意：JSON文本格式必须为标准格式，非标准格式将会抛出错误。

' 解析用户信息JSON
变量 用户JSON = "{\"姓名\":\"张三\",\"年龄\":25,\"城市\":\"北京\"}"
变量 用户对象 = JSON解析(用户JSON)
' 注：对象.属性 为原生 JS 对象属性访问语法，轻语言支持直接使用
调试输出("用户姓名: " + 用户对象.姓名)
调试输出("用户年龄: " + 用户对象.年龄)
' 解析数组形式的JSON
变量 数组JSON = "[{\"id\":1,\"name\":\"项目1\"},{\"id\":2,\"name\":\"项目2\"}]"
变量 数组对象 = JSON解析(数组JSON)
' 注：数组对象[i].name 为原生 JS 数组与对象访问语法，轻语言支持直接使用
变量循环(i = 0, 取数组成员数(数组对象), 1)
	调试输出("项目" + (i+1) + ": " + 数组对象[i].name)
结束循环

函数：JSON编码(JSON对象)

将JSON对象编码为JSON字符串。

' 将对象转换为JSON字符串
变量 用户信息 = {
	"姓名": "李四",
	"年龄": 30,
	"职业": "程序员"
}
变量 JSON字符串 = JSON编码(用户信息)
调试输出("JSON字符串: " + JSON字符串)
' 转换数组对象
变量 商品列表 = [
	{"名称": "商品1", "价格": 100},
	{"名称": "商品2", "价格": 200}
]
变量 商品JSON = JSON编码(商品列表)
调试输出("商品JSON: " + 商品JSON)

函数：取数据类型(值)

获取数据或变量类型。代码示例：变量 类型 = 取数据类型(值)

' 检查不同数据类型的变量
变量 数字 = 123
变量 字符串 = "hello"
变量 布尔值 = 真
变量 数组 = [1, 2, 3]
变量 对象 = {"name": "test"}
' 注：轻语言的空值关键字为 空，等价于原生 JS 的 null
变量 空值 = 空
变量 未定义
调试输出("数字类型: " + 取数据类型(数字))      ' number
调试输出("字符串类型: " + 取数据类型(字符串))   ' string
调试输出("布尔值类型: " + 取数据类型(布尔值))   ' boolean
调试输出("数组类型: " + 取数据类型(数组))      ' object
调试输出("对象类型: " + 取数据类型(对象))      ' object
' 注：历史遗留问题，null 的 typeof 返回 "object"
调试输出("空值类型: " + 取数据类型(空值))      ' object
调试输出("未定义类型: " + 取数据类型(未定义))   ' undefined
' 区分数组和普通对象
' 注：instanceof Array 为原生 JS 运算符，轻语言支持直接使用
如果(取数据类型(数组) == "object" 且 数组 instanceof Array)
	调试输出("这是一个数组")
结束 如果

函数：为非数字(值)

判断给定值是否为非数字值。代码示例：变量 是否非数字 = 为非数字(值)

' 检查值是否为有效数字
变量 数字字符串 = "123"
变量 非数字字符串 = "abc"
变量 空字符串 = ""
' 注：轻语言的空值关键字为 空，等价于原生 JS 的 null
变量 空值 = 空
如果(!为非数字(到小数(数字字符串)))
	调试输出(数字字符串 + " 是有效数字")
结束 如果
如果(为非数字(到小数(非数字字符串)))
	调试输出(非数字字符串 + " 不是有效数字")
结束 如果
' 处理用户输入验证
变量 用户输入 = 输入框_年龄.文本
如果(为非数字(到整数(用户输入)) 或 到整数(用户输入) <= 0)
	弹出提示("请输入有效的年龄")
否则
	调试输出("有效年龄: " + 到整数(用户输入))
结束 如果

函数：URL编码(值)

把字符串编码为 URI。代码示例：变量 编码值 = URL编码(值)

' 编码包含特殊字符的URL
变量 原始URL = "https://example.com/search?q=hello world&category=技术类"
变量 编码URL = URL编码(原始URL)
调试输出("编码后URL: " + 编码URL)
' 编码中文参数
变量 查询词 = "云计算技术"
变量 编码查询 = URL编码(查询词)
变量 完整URL = "https://example.com/search?q=" + 编码查询
调试输出("完整URL: " + 完整URL)
' 编码URL组件
变量 参数值 = "hello@world.com"
变量 编码参数 = URL编码(参数值)
调试输出("编码参数: " + 编码参数)

函数：URL解码(值)

解码某个编码的 URI。代码示例：变量 解码值 = URL解码(值)

' 解码URL中的特殊字符
变量 编码URL = "https://example.com/search?q=%E4%B8%AD%E6%96%87"
变量 解码URL = URL解码(编码URL)
调试输出("解码后URL: " + 解码URL)
' 解码查询参数
变量 编码参数 = "%E4%BA%91%E8%AE%A1%E7%AE%97%E6%8A%80%E6%9C%AF"
变量 解码参数 = URL解码(编码参数)
调试输出("解码参数: " + 解码参数)  ' 云计算技术
' 处理从浏览器获取的URL参数
' 注：window.location.href 为原生 JS BOM 属性，轻语言支持直接使用
变量 当前URL = window.location.href
变量 解码URL = URL解码(当前URL)
调试输出("当前页面: " + 解码URL)

函数：到数值(值)

将字符串转换为数值型数据。代码示例：变量 数值 = 到数值(值)

' 将字符串转换为数值
变量 字符串数字 = "123.45"
变量 数值 = 到数值(字符串数字)
调试输出("数值: " + 数值)  ' 123.45
' 处理布尔值转换
变量 布尔真 = 真
变量 布尔假 = 假
变量 真值 = 到数值(布尔真)  ' 1
变量 假值 = 到数值(布尔假)  ' 0
调试输出("真值: " + 真值 + ", 假值: " + 假值)
' 处理日期转换
变量 日期 = 创建时间对象("2023-01-01")
变量 时间戳 = 到数值(日期)
调试输出("时间戳: " + 时间戳)

函数：到文本(值)

将变量或某个对象转换为字符串数据值。代码示例：变量 文本 = 到文本(值)

' 将数值转换为字符串
变量 数值 = 123
变量 文本 = 到文本(数值)
调试输出("文本: " + 文本)  ' "123"
' 将布尔值转换为字符串
变量 布尔值 = 真
变量 布尔文本 = 到文本(布尔值)
调试输出("布尔文本: " + 布尔文本)  ' "true"
' 将数组转换为字符串
变量 数组 = [1, 2, 3]
变量 数组文本 = 到文本(数组)
调试输出("数组文本: " + 数组文本)  ' "1,2,3"
' 将对象转换为字符串
变量 对象 = {"name": "张三", "age": 25}
变量 对象文本 = 到文本(对象)
调试输出("对象文本: " + 对象文本)

函数：到十六进制(值)

将变量转换为16进制。代码示例：变量 十六进制文本 = 到十六进制(值)

' 将十进制数转换为十六进制
变量 十进制数 = 255
变量 十六进制 = 到十六进制(十进制数)
调试输出("十六进制: " + 十六进制)  ' "ff"
' 转换RGB颜色值
变量 红 = 255
变量 绿 = 128
变量 蓝 = 64
变量 RGB十六进制 = "#" + 到十六进制(红) + 到十六进制(绿) + 到十六进制(蓝)
调试输出("RGB颜色: " + RGB十六进制)  ' "#ff8040"
' 格式化十六进制输出
变量 数值 = 10
变量 格式化十六进制 = "0x" + 到大写(到十六进制(数值))
调试输出("格式化十六进制: " + 格式化十六进制)  ' "0xA"

函数：到十进制(值)

将16进制字符串转换为十进制数值。代码示例：变量 十进制数 = 到十进制(值)

' 将十六进制字符串转换为十进制
变量 十六进制字符串 = "ff"
变量 十进制数 = 到十进制(十六进制字符串)
调试输出("十进制: " + 十进制数)  ' 255
' 处理带前缀的十六进制
变量 带前缀 = "0xFF"
' 注：slice(2) 为原生 JS 字符串方法，可改用 取文本右边(带前缀, 取文本长度(带前缀) - 2) 或 取文本中间
变量 结果 = 到十进制(取文本右边(带前缀, 取文本长度(带前缀) - 2))
调试输出("十进制结果: " + 结果)  ' 255
' 转换颜色值
变量 颜色值 = "A0"
变量 十进制颜色 = 到十进制(颜色值)
调试输出("颜色分量值: " + 十进制颜色)  ' 160

函数：到大写金额(值)

将数值转成中文大写金额。代码示例：变量 大写金额 = 到大写金额(值)

' 将数值转换为中文大写金额
变量 金额 = 1234.56
变量 大写金额 = 到大写金额(金额)
调试输出("大写金额: " + 大写金额)  ' 壹仟贰佰叁拾肆元伍角陆分
' 处理整数金额
变量 整数金额 = 1000
变量 整数大写 = 到大写金额(整数金额)
调试输出("整数大写: " + 整数大写)  ' 壹仟元整
' 处理小额金额
变量 小额 = 0.56
变量 小额大写 = 到大写金额(小额)
调试输出("小额大写: " + 小额大写)  ' 伍角陆分

学习要点

相关文档

• 文档前端(JavaScript)函数_储存类 —— 保存配置 / 读取配置 配合 JSON编码/JSON解析 存储对象
• 文档前端(JavaScript)函数_字符串操作 —— 取文本长度、取文本右边、到大写 等字符串函数
• 文档前端(JavaScript)函数_URL地址操作类 —— 取URL参数值、取URL文件名 等网址处理函数
• 文档前端(JavaScript)函数_对象操作 —— 取对象成员数、取对象成员名 等对象遍历函数
• 文档前端(JavaScript)函数_数组操作 —— 取数组成员、取数组成员数 数组遍历函数

前端(JavaScript)函数_数组操作

文档概述

轻语言网站开发中的数组相关操作函数、用于处理数组的创建、修改、查询和转换，包含获取数组长度、取数组元素、删除元素、添加元素、数组排序、数组去重、数组过滤等功能，常用于数据处理、列表管理、批量操作等场景。

• 元素访问：取数组成员(数组, 索引) 取元素，取数组成员数(数组) 取长度，不能用 数组[i] / 数组.length（轻语言数组语法）
• 增删操作：添加成员(末尾) / 添加成员首(开头) / 删除成员(按索引) / 删除成员首(队首) / 删除成员尾(队尾) / 清空数组
• 数据处理：清除重复成员(去重) / 过滤文本数组(筛选) / 数组排序(排序) / 翻转数组(反转) / 重置数组(批量赋值)
• 查询统计：取成员下标(查位置) / 取最大值 / 取最小值 / 取数组相等(比较) / 合并数组

💡 数组与对象区别：数组用 [] 定义、以索引存取（用 取数组成员）；对象用 {} 定义、以键值对存取（用 对象.属性）。变量循环(i = 0, 取数组成员数(数组), 1) 是遍历数组的标准写法，注意是左闭右开区间 [0, 长度)。

函数：取数组成员(待操作数组,索引)

获取指定数组中，指定索引位置的成员值，数组索引从0开始。

' 获取数组中指定位置的成员
变量 水果 = ["苹果", "香蕉", "橙子"]
调试输出(取数组成员(水果, 0))  ' 苹果
调试输出(取数组成员(水果, 1))  ' 香蕉
调试输出(取数组成员(水果, 2))  ' 橙子
' 遍历数组所有成员
变量 数字 = [10, 20, 30, 40, 50]
变量 总和 = 0
变量循环(i = 0, 取数组成员数(数字), 1)
	总和 = 总和 + 取数组成员(数字, i)
结束循环
调试输出("总和: " + 总和)  ' 150
' 获取最后一个成员
变量 最后一个 = 取数组成员(水果, 取数组成员数(水果) - 1)
调试输出("最后一个: " + 最后一个)  ' 橙子

函数：取数组成员数(待操作数组)

获取指定数组的成员数量。代码示例：变量 数量 = 取数组成员数(待操作数组)

' 获取用户列表的成员数量
变量 用户列表 = ["张三", "李四", "王五"]
变量 用户数 = 取数组成员数(用户列表)
调试输出("用户数量: " + 用户数)  ' 3
' 检查数组是否为空
变量 空数组 = []
如果(取数组成员数(空数组) == 0)
	调试输出("数组为空")
结束 如果
' 处理可能为空（轻语言空值关键字）的数组
变量 未定义数组
变量 成员数 = 取数组成员数(未定义数组)
调试输出("成员数: " + 成员数)  ' 0

函数：置数组成员值(待操作数组,位置,值)

修改数组中指定位置的成员值；数组下标是从0开始的、例如：要将某个整数数组的第2个位置的值修改成10；示例代码：置数组成员值(数组1,1,10)

' 修改数组指定位置的值
变量 数组1 = [1, 2, 3, 4, 5]
置数组成员值(数组1, 1, 10)
调试输出(数组1[1])  ' 10
' 修改多个成员值
变量 分数 = [80, 85, 90, 95]
置数组成员值(分数, 0, 88)
置数组成员值(分数, 3, 92)
调试输出("修改后: " + JSON编码(分数))  ' [88,85,90,92]
' 交换两个成员的位置
变量 数据 = ["A", "B", "C"]
变量 临时 = 取数组成员(数据, 0)
置数组成员值(数据, 0, 取数组成员(数据, 2))
置数组成员值(数据, 2, 临时)
调试输出("交换后: " + JSON编码(数据))  ' ["C","B","A"]

函数：清除重复成员(待操作数组)

清除数组的重复成员；注意：逻辑型数组使用该函数需注意长度。

' 清除数组中的重复值
变量 数字 = [1, 2, 2, 3, 3, 3, 4, 5, 5]
清除重复成员(数字)
调试输出("去重后: " + JSON编码(数字))  ' [1,2,3,4,5]
' 清除字符串数组中的重复值
变量 姓名 = ["张三", "李四", "张三", "王五", "李四"]
清除重复成员(姓名)
调试输出("去重后: " + JSON编码(姓名))  ' ["张三","李四","王五"]
' 从用户访问记录中提取不重复用户
变量 访问记录 = ["user1", "user2", "user1", "user3", "user2"]
清除重复成员(访问记录)
调试输出("不重复用户数: " + 取数组成员数(访问记录))  ' 3

函数：过滤文本数组(待操作数组,关键字,是否返回包含)

根据指定关键字过滤一个文本数组；如果关键字为空，则不作匹配返回原始数组，如果参数三为真；则只返回数组中包含关键字的成员；为假则返回不包含关键字的成员（含空成员对象，因为空成员对象不包含关键字）。

' 过滤包含关键字的成员
变量 水果 = ["苹果", "香蕉", "红苹果", "橙子", "青苹果"]
变量 包含苹果 = 过滤文本数组(水果, "苹果", 真)
调试输出("包含苹果: " + JSON编码(包含苹果))  ' ["苹果","红苹果","青苹果"]
' 过滤不包含关键字的成员
变量 不含苹果 = 过滤文本数组(水果, "苹果", 假)
调试输出("不含苹果: " + JSON编码(不含苹果))  ' ["香蕉","橙子"]
' 搜索过滤用户列表
变量 用户列表 = ["张三", "李四", "张伟", "王五", "张强"]
变量 张姓用户 = 过滤文本数组(用户列表, "张", 真)
调试输出("张姓用户: " + JSON编码(张姓用户))  ' ["张三","张伟","张强"]

函数：取最大值(待操作数组)

获取一个整数型数组中的最大值，如果参数数组为空或数组长度为0会抛出异常：“数组不能为空且长度不能为0”。

' 获取数组中的最大值
变量 分数 = [85, 92, 78, 95, 88]
变量 最高分 = 取最大值(分数)
调试输出("最高分: " + 最高分)  ' 95
' 获取温度数据中的最高温度
变量 温度 = [23, 25, 28, 31, 29, 27]
变量 最高温度 = 取最大值(温度)
调试输出("最高温度: " + 最高温度 + "°C")  ' 31°C
' 获取价格中的最大值
变量 价格 = [9.9, 19.9, 29.9, 39.9]
调试输出("最高价: " + 取最大值(价格))  ' 39.9

函数：取最小值(待操作数组)

获取一个整数型数组中的最小值，如果参数数组为空或数组长度为0会抛出异常：“数组不能为空且长度不能为0”。

' 获取数组中的最小值
变量 分数 = [85, 92, 78, 95, 88]
变量 最低分 = 取最小值(分数)
调试输出("最低分: " + 最低分)  ' 78
' 获取温度数据中的最低温度
变量 温度 = [23, 25, 28, 31, 29, 27]
变量 最低温度 = 取最小值(温度)
调试输出("最低温度: " + 最低温度 + "°C")  ' 23°C
' 获取价格中的最小值
变量 价格 = [9.9, 19.9, 29.9, 39.9]
调试输出("最低价: " + 取最小值(价格))  ' 9.9

函数：合并数组(待操作数组1,待操作数组2)

合并两个数组并返回合并后的结果。代码示例：变量 新数组 = 合并数组(数组1, 数组2)

' 合并两个用户列表
变量 列表1 = ["张三", "李四"]
变量 列表2 = ["王五", "赵六"]
变量 合并列表 = 合并数组(列表1, 列表2)
调试输出("合并后: " + JSON编码(合并列表))  ' ["张三","李四","王五","赵六"]
' 合并数字数组
变量 数字1 = [1, 2, 3]
变量 数字2 = [4, 5, 6]
变量 合并数字 = 合并数组(数字1, 数字2)
调试输出("合并数字: " + JSON编码(合并数字))  ' [1,2,3,4,5,6]
' 处理空数组
变量 空数组 = []
变量 有效数组 = ["元素1", "元素2"]
变量 结果 = 合并数组(空数组, 有效数组)
调试输出("结果: " + JSON编码(结果))  ' ["元素1","元素2"]

函数：添加成员(待操作数组,值)

添加一个元素到数组末尾，并返回数组的新长度。代码示例：变量 新长度 = 添加成员(待操作数组, 值)

' 向购物车添加商品
变量 购物车 = ["苹果", "香蕉"]
变量 新长度 = 添加成员(购物车, "橙子")
调试输出("购物车: " + JSON编码(购物车))  ' ["苹果","香蕉","橙子"]
调试输出("商品数量: " + 新长度)  ' 3
' 动态添加数据
变量 数据列表 = []
添加成员(数据列表, "数据1")
添加成员(数据列表, "数据2")
添加成员(数据列表, "数据3")
调试输出("数据列表: " + JSON编码(数据列表))  ' ["数据1","数据2","数据3"]

函数：清空数组(待操作数组)

清除数组中的所有元素，并返回数组的新长度。

' 清空购物车
变量 购物车 = ["苹果", "香蕉", "橙子"]
调试输出("清空前购物车: " + JSON编码(购物车))
变量 新长度 = 清空数组(购物车)
调试输出("清空后购物车: " + JSON编码(购物车))  ' []
调试输出("购物车长度: " + 新长度)  ' 0
' 重置数据
变量 数据缓存 = [1, 2, 3, 4, 5]
清空数组(数据缓存)
调试输出("缓存已清空，长度: " + 取数组成员数(数据缓存))  ' 0

函数：清空成员(待操作数组)

设置指定数组中的所有成员对象为空，仍保留其长度。

' 清空数组成员值但保留长度
变量 数据 = [1, 2, 3, 4, 5]
清空成员(数据)
调试输出("长度: " + 取数组成员数(数据))  ' 5（长度不变）
' 注：清空后成员值变为 空（轻语言空值关键字，等价于原生 JS 的 null）
调试输出("内容: " + JSON编码(数据))  ' [null,null,null,null,null]
' 重置用户选择状态
变量 选中状态 = [真, 真, 假, 真]
清空成员(选中状态)
' 选中状态现在为 [null,null,null,null]

函数：数组排序(待操作数组,正序排列)

对数值型数组元素进行排序，仅支持数值型成员排序。参数：正序排列 为真则从小到大排序、为假则从大到小排序。代码示例：数组排序(待操作数组, 真)

' 数值数组从小到大排序（正序）
变量 数字数组1 = [3, 1, 4, 1, 5, 9, 2, 6]
数组排序(数字数组1, 真)  ' 正序：从小到大
调试输出("正序排列: " + JSON编码(数字数组1))  ' [1,1,2,3,4,5,6,9]
' 数值数组从大到小排序（倒序）
变量 数字数组2 = [3, 1, 4, 1, 5, 9, 2, 6]
数组排序(数字数组2, 假)  ' 倒序：从大到小
调试输出("倒序排列: " + JSON编码(数字数组2))  ' [9,6,5,4,3,2,1,1]

函数：取数组相等(数组1,数组2)

获取并判断两个数组是否完全相等。

' 比较两个数组是否相等
变量 数组1 = [1, 2, 3]
变量 数组2 = [1, 2, 3]
变量 数组3 = [1, 2, 4]
调试输出(取数组相等(数组1, 数组2))  ' 真
调试输出(取数组相等(数组1, 数组3))  ' 假
' 比较字符串数组
变量 列表1 = ["苹果", "香蕉"]
变量 列表2 = ["苹果", "香蕉"]
变量 列表3 = ["苹果", "橙子"]
调试输出(取数组相等(列表1, 列表2))  ' 真
调试输出(取数组相等(列表1, 列表3))  ' 假
' 比较不同长度的数组
变量 短数组 = [1, 2]
变量 长数组 = [1, 2, 3]
调试输出(取数组相等(短数组, 长数组))  ' 假

函数：翻转数组(待操作数组)

将数组元素翻转顺序。代码示例：翻转数组(待操作数组)

' 翻转数字序列
变量 数字数组 = [1, 2, 3, 4, 5]
翻转数组(数字数组)
调试输出("翻转后: " + JSON编码(数字数组))  ' [5,4,3,2,1]
' 实现回文检测
变量 原数组 = ["a", "b", "c"]
变量 备份数组 = 合并数组([], 原数组)  ' 创建备份
翻转数组(备份数组)
如果(JSON编码(原数组) == JSON编码(备份数组))
	调试输出("是回文数组")
否则
	调试输出("不是回文数组")
结束 如果
' 倒序显示历史记录
变量 历史记录 = ["最新", "较新", "较旧", "最旧"]
翻转数组(历史记录)
调试输出("倒序历史: " + JSON编码(历史记录))  ' ["最旧","较旧","较新","最新"]

函数：重置数组(待操作数组,值)

将数组的所有成员均重新设置为指定的值。

' 将数组所有成员重置为同一值
变量 分数 = [85, 92, 78, 95]
重置数组(分数, 0)
调试输出("重置后: " + JSON编码(分数))  ' [0,0,0,0]
' 重置选中状态为未选中
变量 选中状态 = [真, 假, 真, 真]
重置数组(选中状态, 假)
调试输出("重置后: " + JSON编码(选中状态))  ' [false,false,false,false]
' 重置文本数组
变量 标签 = ["红", "绿", "蓝"]
重置数组(标签, "默认")
调试输出("重置后: " + JSON编码(标签))  ' ["默认","默认","默认"]

函数：取成员下标(待操作数组,值)

取出指定成员的下标值；如果成员不存在则返回 -1。

' 查找值在数组中的位置
变量 水果 = ["苹果", "香蕉", "橙子", "葡萄"]
变量 下标 = 取成员下标(水果, "橙子")
调试输出("橙子的下标: " + 下标)  ' 2
' 查找不存在的值
变量 不存在 = 取成员下标(水果, "西瓜")
调试输出("西瓜的下标: " + 不存在)  ' -1
' 查找用户在列表中的位置
变量 用户列表 = ["张三", "李四", "王五"]
变量 位置 = 取成员下标(用户列表, "李四")
如果(位置 != -1)
	调试输出("找到用户，位置: " + 位置)  ' 1
否则
	调试输出("用户不存在")
结束 如果

函数：删除成员(待操作数组,索引)

删除指定索引处的元素，并返回数组的新长度。代码示例：变量 新长度 = 删除成员(待操作数组, 索引)

' 从购物车中删除指定商品
变量 购物车 = ["苹果", "香蕉", "橙子", "葡萄"]
变量 删除索引 = 1  ' 香蕉的位置
变量 新长度 = 删除成员(购物车, 删除索引)
调试输出("购物车: " + JSON编码(购物车))  ' ["苹果","橙子","葡萄"]
调试输出("剩余商品数: " + 新长度)  ' 3
' 删除重复元素
变量 数组 = [1, 2, 2, 3, 2, 4]
' 从后往前删除，避免索引变化影响
变量循环(i = 取数组成员数(数组) - 1, 0, -1)
	如果(数组[i] == 2)
		删除成员(数组, i)
	结束 如果
结束循环
调试输出("去重后: " + JSON编码(数组))  ' [1,3,4]

函数：添加成员首(待操作数组,值)

添加一个元素到数组开头，并返回数组的新长度。代码示例：变量 新长度 = 添加成员首(待操作数组, 值)

' 在任务队列开头添加紧急任务
变量 任务队列 = ["普通任务1", "普通任务2"]
变量 新长度 = 添加成员首(任务队列, "紧急任务")
调试输出("任务队列: " + JSON编码(任务队列))  ' ["紧急任务","普通任务1","普通任务2"]
调试输出("任务数: " + 新长度)  ' 3
' 按优先级添加元素
变量 优先级列表 = ["中优先级", "低优先级"]
添加成员首(优先级列表, "高优先级")
调试输出("优先级列表: " + JSON编码(优先级列表))  ' ["高优先级","中优先级","低优先级"]

函数：删除成员首(待操作数组)

删除数组的第一个元素，并返回数组的新长度。代码示例：变量 新长度 = 删除成员首(待操作数组)

' 处理任务队列，完成第一个任务
变量 任务队列 = ["任务1", "任务2", "任务3"]
变量 剩余任务数 = 删除成员首(任务队列)
调试输出("已完成第一个任务")
调试输出("剩余任务: " + JSON编码(任务队列))  ' ["任务2","任务3"]
调试输出("剩余任务数: " + 剩余任务数)  ' 2
' 实现队列的出队操作
变量 队列 = ["元素1", "元素2", "元素3"]
' 注：数组[索引] 为原生 JS 数组访问语法，轻语言支持直接使用；也可用 取数组成员(数组, 索引)
变量 首元素 = 队列[0]
删除成员首(队列)
调试输出("出队元素: " + 首元素)  ' 元素1

函数：删除成员尾(待操作数组)

删除数组的最后一个元素，并返回数组的新长度。代码示例：变量 新长度 = 删除成员尾(待操作数组)

' 实现栈的出栈操作
变量 栈 = ["元素1", "元素2", "元素3"]
' 注：数组[索引] 为原生 JS 数组访问语法，轻语言支持直接使用；也可用 取数组成员(数组, 索引)
变量 栈顶元素 = 栈[取数组成员数(栈) - 1]
变量 新长度 = 删除成员尾(栈)
调试输出("出栈元素: " + 栈顶元素)  ' 元素3
调试输出("栈剩余元素: " + JSON编码(栈))  ' ["元素1","元素2"]
调试输出("栈大小: " + 新长度)  ' 2
' 撤销最近的操作
变量 操作历史 = ["打开文件", "编辑文本", "保存文件"]
删除成员尾(操作历史)
调试输出("撤销后历史: " + JSON编码(操作历史))  ' ["打开文件","编辑文本"]

函数：数组到文本(待操作数组,连接符)

将数组元素转换为字符串，并以指定分隔符分隔。代码示例：变量 文本 = 数组到文本(待操作数组, 连接符)

' 将标签数组转换为字符串
变量 标签 = ["重要", "紧急", "待办"]
变量 标签字符串 = 数组到文本(标签, ", ")
调试输出("标签: " + 标签字符串)  ' 重要, 紧急, 待办
' 构造CSS类名
变量 类名数组 = ["btn", "btn-primary", "active"]
变量 类名字符串 = 数组到文本(类名数组, " ")
调试输出("类名: " + 类名字符串)  ' btn btn-primary active
' 创建CSV行
变量 数据 = ["张三", "25", "工程师"]
变量 CSV行 = 数组到文本(数据, ",")
调试输出("CSV行: " + CSV行)  ' 张三,25,工程师

学习要点

相关文档

• 文档前端(JavaScript)函数_对象操作 —— 取对象成员数、取对象成员名 对象遍历函数
• 文档前端(JavaScript)函数_数据转换类 —— JSON编码、JSON解析、到整数 等函数
• 文档前端(JavaScript)函数_字符串操作 —— 数组到文本 的逆操作 文本到数组 等
• 文档前端(JavaScript)函数_数学运算 —— 取最大值、取最小值 的数学版本（参数为多值而非数组）
• 文档轻语言网站：变量与数组与对象的定义 —— 数组与对象的基本语法

前端(JavaScript)函数_文档操作

文档概述

轻语言网站开发中的文档操作函数、用于操作HTML页面文档对象，包含获取页面元素、创建元素、设置属性、操作DOM、事件绑定等文档操作功能，常用于页面元素操作、动态内容生成、DOM操作等场景。

• 元素查找：查找元素ByID(单个) / 查找元素By类名(集合) / 查找元素By标签名(集合) / 查找元素By选择器(首个) / 查找全部元素By选择器(集合)
• 元素创建与文档写入：创建元素 创建新DOM节点；写文本到页面/写文本行到页面 向页面输出内容
• 资源加载：加载JS模块/加载JS文件/加载CSS文件 动态加载外部资源
• 代码执行：执行JS代码 通过 eval 执行原生JS代码字符串

💡 原生 JS DOM 注解：文档操作函数返回的DOM对象，其属性如 innerHTML、value、style、src、onclick 等为原生 JS DOM 属性，轻语言支持直接使用。遍历DOM集合时使用 取数组成员数() 和 取数组成员(集合, i)，而非 .length 和 集合[i]。

函数：查找元素ByID(ID)

通过元素ID在当前页面中查找元素标签、并返回其DOM对象。

' 通过ID查找元素并修改其内容
变量 元素 = 查找元素ByID("myTitle")
' 注：innerHTML 为原生 JS DOM 属性，轻语言支持直接使用
如果(元素 != 空)
	元素.innerHTML = "新标题"
结束 如果
' 通过ID获取输入框的值
变量 输入框 = 查找元素ByID("username")
' 注：value 为原生 JS DOM 属性，轻语言支持直接使用
变量 用户名 = 输入框.value
调试输出("用户名: " + 用户名)

函数：查找元素By类名(类名)

根据指定的 class 样式类名获取界面指定元素节点；返回DOM对象集合。

' 查找所有class为"item"的元素
变量 元素列表 = 查找元素By类名("item")
调试输出("找到 " + 取数组成员数(元素列表) + " 个元素")
' 遍历所有匹配的元素
' 注：style.color 为原生 JS DOM 属性，轻语言支持直接使用
变量循环(i = 0, 取数组成员数(元素列表), 1)
	取数组成员(元素列表, i).style.color = "red"
结束循环
' 查找按钮类元素并设置点击事件
变量 按钮 = 查找元素By类名("btn-primary")
如果(取数组成员数(按钮) > 0)
	' 注：onclick、箭头函数 ()=>{} 为原生 JS 语法，轻语言支持直接使用
	取数组成员(按钮, 0).onclick = () => { 调试输出("按钮被点击") }
结束 如果

函数：查找元素By标签名(标签名称)

根据元素指定的标签名称获取界面指定元素节点；注意：标签名称只能为HTML原生名称、扩展组件不支持。

' 查找页面中所有的div元素
变量 div元素 = 查找元素By标签名("div")
调试输出("div数量: " + 取数组成员数(div元素))
' 查找所有段落标签
' 注：style.fontSize 为原生 JS DOM 属性，轻语言支持直接使用
变量 段落 = 查找元素By标签名("p")
变量循环(i = 0, 取数组成员数(段落), 1)
	取数组成员(段落, i).style.fontSize = "16px"
结束循环
' 查找所有图片标签并获取src
' 注：src 为原生 JS DOM 属性，轻语言支持直接使用
变量 图片 = 查找元素By标签名("img")
变量循环(i = 0, 取数组成员数(图片), 1)
	调试输出("图片地址: " + 取数组成员(图片, i).src)
结束循环

函数：查找元素By选择器(匹配表达式)

使用选择器"querySelector"查询界面中指定元素节点，返回第一个匹配的元素。

' 通过CSS选择器查找元素
变量 元素 = 查找元素By选择器("#myTitle")
' 注：innerHTML 为原生 JS DOM 属性，轻语言支持直接使用
元素.innerHTML = "通过ID选择器找到"
' 通过类选择器查找第一个匹配元素
变量 按钮 = 查找元素By选择器(".btn-primary")
' 注：style.backgroundColor 为原生 JS DOM 属性，轻语言支持直接使用
按钮.style.backgroundColor = "blue"
' 通过属性选择器查找
变量 输入框 = 查找元素By选择器("input[type='text']")
' 注：value 为原生 JS DOM 属性，轻语言支持直接使用
调试输出("输入框值: " + 输入框.value)
' 通过复合选择器查找
变量 选中项 = 查找元素By选择器("div.container > ul li.active")

函数：查找全部元素By选择器(匹配表达式)

使用选择器"querySelectorAll"查询界面中符合要求的所有指定元素节点；返回一个对象数组。

' 查找所有class为item的元素
变量 元素列表 = 查找全部元素By选择器(".item")
' 注：元素列表[i].style 为原生 JS DOM 操作语法，轻语言支持直接使用
变量循环(i = 0, 取数组成员数(元素列表), 1)
	取数组成员(元素列表, i).style.border = "1px solid #ccc"
结束循环
' 查找特定容器下的所有按钮
变量 按钮 = 查找全部元素By选择器("#toolbar button")
调试输出("工具栏按钮数: " + 取数组成员数(按钮))
' 查找所有选中的复选框
变量 选中项 = 查找全部元素By选择器("input[type='checkbox']:checked")
调试输出("选中数量: " + 取数组成员数(选中项))

函数：预处理文档()

删除当前页面空文本节点，并连接相邻节点。

' 规范化文档结构，清理空节点
预处理文档()
' 在动态添加/删除大量节点后调用
变量 容器 = 查找元素ByID("content")
' 注：innerHTML 为原生 JS DOM 属性，轻语言支持直接使用；创建元素 等效于 document.createElement
容器.innerHTML = ""
容器.appendChild(创建元素("div"))
预处理文档()  ' 清理可能产生的空文本节点

函数：写文本到页面(内容)

写（输出）指定文本内容到当前页面。

' 在页面中直接写入HTML内容
写文本到页面("<h1>欢迎来到我的网站</h1>")
' 写入段落和链接
写文本到页面("<p>这是一个<a href='about.html'>关于我们</a>的页面</p>")
' 注意：页面加载完成后调用会覆盖整个页面内容

函数：写文本行到页面(内容)

写（输出）指定文本行内容到当前页面，该函数会自动在写出的内容后面添加换行符。

' 写入多行内容（每行自动换行）
写文本行到页面("<p>第一行内容</p>")
写文本行到页面("<p>第二行内容</p>")
写文本行到页面("<p>第三行内容</p>")
' 在<pre>标签中效果更明显
写文本行到页面("<pre>")
写文本行到页面("代码行1")
写文本行到页面("代码行2")
写文本行到页面("</pre>")

函数：加载JS模块(目标JS文件,加载完成回调)

加载指定JS文件中导出的模块，在加载完成回调参数中以事件方式返回，返回一个参数：模块对象，可通过该对象取出JS文件中导出的指定模块类。

' 加载位于项目 static 文件夹中的 myModule.js 模块文件
加载JS模块("myModule.js", (模块对象) => {
	' 使用模块中的功能
	模块对象.某个导出函数()
})

函数：加载JS文件(目标JS文件,加载完成回调)

加载指定JS文件，在加载完成回调参数中以事件方式返回，返回一个参数：加载成功的JS文件地址。

' 加载位于项目 static 文件夹中的 MyJS.js 文件
加载JS文件("MyJS.js",(被加载JS文件) =>{
	调试输出("成功加载的JS文件：" + 被加载JS文件)
})

函数：加载CSS文件(目标CSS文件,加载完成回调)

加载指定CSS文件，在加载完成回调参数中以事件方式返回，返回一个参数：加载成功的CSS文件地址。

' 加载位于项目 static 文件夹中的 style.css 样式文件
加载CSS文件("style.css", (被加载CSS文件) => {
	调试输出("成功加载的CSS文件：" + 被加载CSS文件)
})

函数：执行JS代码(待执行JS代码)

执行指定JS代码，函数内部采用"eval"函数执行。

' 执行JS原生函数
执行JS代码("alert('信息提示')")
' 执行任意符合JavaScript语法的代码字符串
' 注：参数为字符串形式的原生 JS 代码，需用原生 JS 语法（new Date 为原生 JS 构造函数）
执行JS代码("let x = new Date(); 调试输出(x)")

函数：创建元素(标签名称)

创建指定标签元素对象。

' 创建 div 标签
变量 dom = 创建元素("div")
' 创建 button 标签
变量 btn = 创建元素("button")
' 添加到根布局或面板
弹性布局1.添加组件(dom)
弹性布局1.添加组件(btn)

学习要点

相关文档

• 文档前端(JavaScript)函数_窗口操作 —— 置组件居中、批量赋值 等组件布局函数
• 文档前端(JavaScript)函数_字符串操作 —— 寻找文本、取文本中间 用于DOM文本处理
• 文档前端(JavaScript)函数_数组操作 —— 取数组成员数、取数组成员 用于DOM集合遍历
• 文档前端(JavaScript)函数_对象操作 —— 取对象属性、置对象属性 对象属性操作
• 文档前端(JavaScript)函数_数据操作类 —— 解析XML文本 等数据解析函数

前端(JavaScript)函数_时钟类

文档概述

轻语言网站开发中的时钟类操作函数、用于实现定时器和延时功能，包含设置定时器、清除定时器、延时执行、倒计时等功能，常用于定时任务、动画控制、延时操作等场景。

• 周期定时器：创建时钟 按指定间隔（毫秒）重复执行子函数，返回时钟ID；类似 setInterval
• 延时执行器：延时执行 在指定等待时间（毫秒）后执行一次子函数，类似 setTimeout
• 资源管理：销毁时钟 / 销毁延时执行 用于停止定时器，避免内存泄漏

💡 时钟管理关键：创建时钟 与 销毁时钟 必须成对使用，延时执行 与 销毁延时执行 同理。组件销毁时（如页面切换、元素移除）必须停止对应的时钟，否则会造成内存泄漏。间隔时间单位为毫秒，1000ms = 1秒。

函数：创建时钟(子函数,间隔时间)

创建一个根据指定间隔时间（单位：毫秒）周期调用子程序的定时器时钟对象；返回创建成功后的时钟ID。

' 创建一个每秒执行一次的时钟
变量 时钟ID = 创建时钟(()=>{
	调试输出("时钟执行中: " + 取本地现行时间())
}, 1000)

' 创建一个每5秒更新一次标签内容的时钟
变量 时钟ID2 = 创建时钟(()=>{
	标签1.文本 = "当前时间: " + 取本地现行时间()
}, 5000)

' 倒计时功能实现
变量 剩余秒数 = 60
变量 倒计时ID = 创建时钟(()=>{
	剩余秒数 = 剩余秒数 - 1
	倒计时标签.文本 = 到文本(剩余秒数) + "秒"
	如果(剩余秒数 <= 0)
		销毁时钟(倒计时ID)
		弹出提示("倒计时结束")
	结束 如果
}, 1000)

函数：销毁时钟(ID)

销毁创建的指定时钟对象。代码示例：销毁时钟(时钟ID)

' 销毁之前创建的时钟
销毁时钟(时钟ID)

' 在适当的时候停止时钟，避免内存泄漏
按钮1.置被单击回调((源对象, 事件源)=>{
	销毁时钟(时钟ID2)
	调试输出("时钟已停止")
})

' 页面卸载时清理所有时钟
页面.置被卸载回调(() => {
	销毁时钟(时钟ID)
	销毁时钟(时钟ID2)
})

函数：延时执行(子函数,等待时间)

创建一个根据指定等待时间（单位：毫秒）之后执行的子程序；返回创建成功后的时钟ID；注：本时钟只会在指定等待时间后调用一次子程序。代码示例：延时执行(子函数, 3000)

' 延时3秒后执行某个操作
变量 延时ID = 延时执行(()=>{
	弹出提示("3秒钟已到!")
}, 3000)

' 延时执行页面元素的显示
变量 延时ID2 = 延时执行(()=>{
	面板1.显示模式 = 显示_块
	面板1.文本 = "延时加载的内容"
}, 2000)

' 延时跳转页面
变量 跳转ID = 延时执行(()=>{
	切换页面("首页")
}, 5000)

函数：销毁延时执行(ID)

销毁创建的延时时钟对象。代码示例：销毁延时执行(延时ID)

' 在延时执行前取消操作
销毁延时执行(延时ID)

' 示例：创建一个可取消的延时操作
变量 延时ID3
延时ID3 = 延时执行(()=>{
	切换页面("下一页面")
}, 5000)

' 提供取消按钮
取消按钮.置被单击回调((sender, event)=>{
	销毁延时执行(延时ID3)
	弹出提示("操作已取消")
})

学习要点

相关文档

• 文档前端(JavaScript)函数_时间类 —— 取本地现行时间、创建时间对象 等时间函数
• 文档前端(JavaScript)函数_浏览器操作类 —— 切换页面、弹出提示 浏览器操作
• 文档前端(JavaScript)函数_文档操作 —— 查找元素ByID 等DOM操作，配合时钟更新UI
• 文档前端(JavaScript)函数_数据转换类 —— 到文本 等类型转换，配合时钟显示数据
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明与基础语法

前端(JavaScript)函数_时间类

文档概述

轻语言网站开发中的时间日期操作函数、用于处理时间和日期数据，包含创建时间对象、获取年月日时分秒星期、格式化日期时间、计算时间差、时间戳转换、日期比较等功能，常用于时间显示、日期计算、时间格式化等场景。

• 时间获取：取年/取月/取日/取时/取分/取秒/取星期 可分别获取时间各部分，参数为空取当前时间
• 格式化输出：取现行日期/取现行时间/时间对象到文本 将时间对象转为字符串，可指定分隔符
• 时间创建：创建时间对象(字符串) / 创建指定时间对象(各分量) 两种创建方式
• 时间计算：取时间差 返回两时间对象的毫秒差；文本到时间戳 将时间字符串转为时间戳

💡 时间戳与时间差：取时间差(A, B) 返回 A-B 的毫秒数（1秒=1000毫秒）。计算两时间相差天数：取时间差(A, B) / 1000 / 60 / 60 / 24。取星期 返回 0-6，0 表示星期日。

函数：创建时间对象(时间字符串)

创建Date对象，参数为空则返回当前时间。时间字符串格式如 '2026/07/20 10:00:00'。

' 获取当前时间
变量 当前时间 = 创建时间对象()
调试输出(当前时间)

' 解析指定时间字符串
变量 指定时间 = 创建时间对象("2026/08/10 14:30:00")
调试输出(指定时间)

函数：取年(时间对象)

获取时间对象的年份，参数为空则取当前年。

变量 年 = 取年()
调试输出(年)  ' 如：2026

' 判断闰年
变量 当前年 = 取年()
如果(取余数(当前年, 4) == 0 且 取余数(当前年, 100) != 0)
	调试输出(当前年 + " 是闰年")
否则 如果(取余数(当前年, 400) == 0)
	调试输出(当前年 + " 是闰年")
否则
	调试输出(当前年 + " 是平年")
结束 如果

函数：取月(时间对象)

获取时间对象的月份（1-12），参数为空则取当前月。

变量 月 = 取月()
调试输出(月)  ' 1-12

' 根据月份显示季节
变量 当前月 = 取月()
如果(当前月 == 10 或 当前月 == 11 或 当前月 == 12)
	调试输出("冬季")
否则 如果(当前月 == 1 或 当前月 == 2 或 当前月 == 3)
	调试输出("春季")
否则 如果(当前月 == 4 或 当前月 == 5 或 当前月 == 6)
	调试输出("夏季")
否则 如果(当前月 == 7 或 当前月 == 8 或 当前月 == 9)
	调试输出("秋季")
否则
	调试输出("未知月份")
结束 如果

函数：取日(时间对象)

获取时间对象的日（1-31），参数为空则取当前日。

变量 日 = 取日()
调试输出(日)  ' 1-31

' 显示当前日期
变量 当前日期 = 取年() + "年" + 取月() + "月" + 取日() + "日"
调试输出(当前日期)

函数：取时(时间对象)

获取时间对象的小时（0-23），参数为空则取当前时。

变量 时 = 取时()
调试输出(时)  ' 0-23

' 根据时间显示问候语
变量 当前时 = 取时()
如果(当前时 < 6)
	调试输出("凌晨好")
否则 如果(当前时 < 12)
	调试输出("上午好")
否则 如果(当前时 < 18)
	调试输出("下午好")
否则
	调试输出("晚上好")
结束 如果

函数：取分(时间对象)

获取时间对象的分钟（0-59），参数为空则取当前分。

变量 分 = 取分()
调试输出(分)  ' 0-59

函数：取秒(时间对象)

获取时间对象的秒数（0-59），参数为空则取当前秒。

变量 秒 = 取秒()
调试输出(秒)  ' 0-59

函数：取星期(时间对象)

获取时间对象的星期几（0-6，0表示星期日），参数为空则取当前星期。

变量 星期 = 取星期()
调试输出(星期)  ' 0-6

' 显示中文星期
变量 星期名 = ["日", "一", "二", "三", "四", "五", "六"]
变量 星期几 = 取数组成员(星期名, 取星期())
调试输出("星期" + 星期几)  ' 如：星期一

函数：取现行日期(分隔符)

获取当前日期字符串，分隔符可选，默认 '/'，例如 '2026/08/10'。

变量 日期 = 取现行日期("-")
调试输出(日期)  ' 2026-08-10

' 默认分隔符
变量 日期2 = 取现行日期()
调试输出(日期2)  ' 2026/08/10

函数：取现行时间(分隔符)

获取当前时间字符串，分隔符可选，默认 ':'，例如 '14:30:25'。

变量 时间 = 取现行时间(":")
调试输出(时间)  ' 14:30:25

' 完整日期时间
变量 当前 = 取现行日期("-") + " " + 取现行时间(":")
调试输出(当前)  ' 2026-08-10 14:30:25

函数：创建指定时间对象(年, 月, 日, 时, 分, 秒)

根据指定年月日时分秒创建Date对象（月为1-12，时、分、秒可选）。

变量 时间 = 创建指定时间对象(2026, 8, 10, 10, 0, 0)
调试输出(时间)

' 仅指定年月日
变量 生日 = 创建指定时间对象(1990, 5, 15)
调试输出(生日)

函数：时间对象到文本(时间对象, 日期分隔符)

将Date对象格式化为 'YYYY/MM/DD HH:MM:SS' 字符串，分隔符可选，默认 '/'。

变量 文本 = 时间对象到文本(创建时间对象(), "-")
调试输出(文本)  ' 2026-08-10 14:30:25

' 格式化指定时间
变量 指定时间 = 创建指定时间对象(2026, 1, 1)
变量 格式文本 = 时间对象到文本(指定时间, "/")
调试输出(格式文本)  ' 2026/01/01 00:00:00

函数：取时间差(时间对象A, 时间对象B)

返回两个时间对象的毫秒差值（A - B）。

变量 差 = 取时间差(创建时间对象("2026-08-10 12:00:00"), 创建时间对象("2026-08-10 10:00:00"))
调试输出(差)  ' 7200000 (2小时的毫秒数)

' 计算两时间相差天数
变量 开始 = 创建时间对象("2026-08-01")
变量 结束 = 创建时间对象("2026-08-10")
变量 毫秒差 = 取时间差(结束, 开始)
变量 天数 = 向下取整(毫秒差 / 1000 / 60 / 60 / 24)
调试输出("相差 " + 天数 + " 天")  ' 9

函数：文本到时间戳(时间字符串)

将时间字符串转换为毫秒时间戳，若解析失败返回-1。

变量 时间戳 = 文本到时间戳("2026-08-10 14:30:00")
调试输出(时间戳)  ' 毫秒数

' 判断解析是否成功
变量 戳 = 文本到时间戳("无效时间")
如果(戳 == -1)
	调试输出("时间格式无效")
否则
	调试输出("时间戳: " + 戳)
结束 如果

学习要点

相关文档

• 文档前端(JavaScript)函数_时钟类 —— 创建时钟、延时执行 定时器函数
• 文档前端(JavaScript)函数_数据转换类 —— 到文本、到数值 等类型转换函数
• 文档前端(JavaScript)函数_数学运算 —— 取余数、向下取整 等数学函数
• 文档前端(JavaScript)函数_数组操作 —— 取数组成员 用于星期名映射
• 文档前端(JavaScript)函数_储存类 —— 保存配置 存储时间相关用户偏好

前端(JavaScript)函数_正则表达类

文档概述

轻语言网站开发中的正则表达式相关操作函数、用于文本模式匹配和处理，包含正则匹配、正则搜索、正则替换、正则验证等功能，常用于文本验证、数据提取、格式化处理等场景。

• 正则字面量语法：使用 /表达式/标志 形式定义正则（如 /\d+/g），原生 JS 语法，轻语言支持直接使用
• 匹配与搜索区别：正则匹配 返回所有匹配项数组（无匹配返回 空）；正则搜索 返回首次匹配位置索引（未找到返回 -1）
• 替换支持反向引用：正则替换 中可用 $1、$2 引用捕获组内容

💡 正则表达式入门：常用元字符 \d(数字)、\w(字母数字下划线)、\s(空白)、.(任意字符)；量词 *(0+次)、+(1+次)、?(0/1次)、{n,m}(n到m次)；标志 g(全局)、i(忽略大小写)、m(多行)。

函数：正则匹配(待操作内容,表达式)

在指定待操作内容中搜索与正则表达式的匹配项，然后将匹配项作为数组返回。代码示例：变量 匹配结果 = 正则匹配(待操作内容, 表达式)

' 提取文本中的所有数字
变量 文本 = "今年是2023年，人口有14亿，GDP增长了5.5%"
变量 数字表达式 = /\d+\.?\d*/g
变量 数字匹配 = 正则匹配(文本, 数字表达式)
调试输出("提取的数字: " + JSON编码(数字匹配))  ' ["2023","14","5.5"]

' 提取邮箱地址
变量 邮箱文本 = "联系我: john@example.com 或 mary@test.org"
变量 邮箱表达式 = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g
变量 邮箱匹配 = 正则匹配(邮箱文本, 邮箱表达式)
调试输出("邮箱地址: " + JSON编码(邮箱匹配))  ' ["john@example.com","mary@test.org"]

' 验证手机号格式
变量 手机号 = "13812345678"
变量 手机号表达式 = /^1[3-9]\d{9}$/
变量 手机号匹配 = 正则匹配(手机号, 手机号表达式)
' 注：无匹配时返回 空（轻语言空值关键字，等价于原生 JS 的 null）
如果(手机号匹配 != 空)
	调试输出("手机号格式正确")
否则
	调试输出("手机号格式错误")
结束 如果

函数：正则搜索(待操作内容,表达式)

使用正则方式根据表达式搜索指定内容；找到返回索引、否则返回-1。代码示例：变量 位置 = 正则搜索(待操作内容, 表达式)

' 查找关键词首次出现的位置
变量 文档 = "这是一份重要的技术文档，文档中包含了关键技术要点"
变量 关键词表达式 = /技术/
变量 位置 = 正则搜索(文档, 关键词表达式)
调试输出("关键词首次出现位置: " + 位置)  ' 7

' 检查是否包含敏感词
变量 评论 = "这个产品真的很好用，没有任何问题"
变量 敏感词表达式 = /垃圾|废物|差劲/
变量 搜索结果 = 正则搜索(评论, 敏感词表达式)
如果(搜索结果 != -1)
	调试输出("发现敏感词，位置: " + 搜索结果)
否则
	调试输出("未发现敏感词")
结束 如果

' 查找邮箱格式内容
变量 文本 = "联系方式: email@test.com"
变量 邮箱表达式 = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/
变量 邮箱位置 = 正则搜索(文本, 邮箱表达式)
如果(邮箱位置 != -1)
	调试输出("邮箱位置: " + 邮箱位置)
结束 如果

函数：正则替换(待操作内容,新内容,表达式)

使用正则方式根据表达式匹配指定内容并将其替换为新内容。代码示例：变量 结果 = 正则替换(待操作内容, 新内容, 表达式)

' 替换文本中的敏感词
变量 原文 = "这个产品真是垃圾，完全没法用"
变量 敏感词表达式 = /垃圾/
变量 替换结果 = 正则替换(原文, "**", 敏感词表达式)
调试输出("替换后: " + 替换结果)  ' 这个产品真是**，完全没法用

' 格式化电话号码
变量 电话 = "电话:13812345678"
变量 电话表达式 = /(\d{3})(\d{4})(\d{4})/
变量 格式化结果 = 正则替换(电话, "电话:$1-$2-$3", 电话表达式)
调试输出("格式化后: " + 格式化结果)  ' 电话:138-1234-5678

' 去除多余空格
变量 多空格文本 = "这    是   一   个   测试   文本"
变量 空格表达式 = /\s+/g
变量 去空格结果 = 正则替换(多空格文本, " ", 空格表达式)
调试输出("整理后: " + 去空格结果)  ' 这 是 一 个 测试 文本

学习要点

相关文档

• 文档前端(JavaScript)函数_字符串操作 —— 寻找文本、倒找文本、子文本替换 等字符串处理函数
• 文档前端(JavaScript)函数_数据转换类 —— JSON编码、JSON解析 等数据序列化函数
• 文档前端(JavaScript)函数_数组操作 —— 正则匹配返回的数组遍历与处理
• 文档前端(JavaScript)函数_储存类 —— 配合正则做表单数据验证后存储
• 文档轻语言网站：变量与数组与对象的定义 —— 变量声明与基础语法

前端(JavaScript)函数_浏览器操作类

文档概述

轻语言网站开发中的浏览器操作函数、用于获取和控制浏览器信息，包含浏览器版本检测、用户代理获取、浏览器特性判断等功能，常用于浏览器兼容性检测、功能适配、环境判断等场景。

• 浏览器信息：取浏览器名称/取浏览器版本信息/取浏览器引擎/取用户代理头信息 获取浏览器基本信息
• 环境检测：取浏览器运行平台/取浏览器语言/取浏览器状态/取Cookie启用状态 检测运行环境
• Cookie管理：读COOKIE/写COOKIE/置COOKIE 读写、设置浏览器Cookie

💡 Cookie 操作说明：读COOKIE("") 返回所有cookie；指定字段存在返回字段值，否则返回空字符串。写COOKIE 单字段写入并指定有效天数；置COOKIE 一次性写入多个键值对，参数格式为 "key1=value1;key2=value2"。

函数：取浏览器代码名()

获取当前浏览器的代码名称。

变量 代码名 = 取浏览器代码名()
调试输出("浏览器代码名: " + 代码名)  ' 如：Mozilla

函数：取浏览器名称()

获取当前浏览器的名称。

变量 名称 = 取浏览器名称()
调试输出("浏览器名称: " + 名称)  ' 如：Netscape

' 根据浏览器名称判断类型
变量 浏览器 = 取浏览器名称()
变量 UA = 取用户代理头信息()
如果(寻找文本(UA, "Chrome") != -1)
	调试输出("Chrome 浏览器")
否则 如果(寻找文本(UA, "Firefox") != -1)
	调试输出("Firefox 浏览器")
否则 如果(寻找文本(UA, "Safari") != -1)
	调试输出("Safari 浏览器")
结束 如果

函数：取浏览器版本信息()

获取当前浏览器的平台和版本信息。

变量 版本信息 = 取浏览器版本信息()
调试输出("版本信息: " + 版本信息)

函数：取Cookie启用状态()

获取当前浏览器中是否启用cookie的状态。

变量 启用 = 取Cookie启用状态()
调试输出("Cookie已启用: " + 启用)

' Cookie 未启用时提示用户
如果(启用 == 假)
	弹出提示("请启用浏览器Cookie以正常使用登录功能")
结束 如果

函数：取浏览器运行平台()

获取当前浏览器运行的操作系统平台。

变量 平台 = 取浏览器运行平台()
调试输出("运行平台: " + 平台)  ' 如：Win32

' 根据平台适配界面
变量 当前平台 = 取浏览器运行平台()
如果(寻找文本(当前平台, "Win") != -1)
	调试输出("Windows 系统")
否则 如果(寻找文本(当前平台, "Mac") != -1)
	调试输出("macOS 系统")
否则 如果(寻找文本(当前平台, "Linux") != -1)
	调试输出("Linux 系统")
结束 如果

函数：取用户代理头信息()

获取由客户机发送服务器的user-agent头部的值。

变量 UA = 取用户代理头信息()
调试输出("User-Agent: " + UA)

' 判断设备类型
变量 代理 = 取用户代理头信息()
如果(寻找文本(代理, "Mobile") != -1 或 寻找文本(代理, "Android") != -1)
	调试输出("移动设备")
否则
	调试输出("桌面设备")
结束 如果

函数：取浏览器位置()

获取当前浏览器的地理位置信息。

变量 位置信息 = 取浏览器位置()
调试输出(位置信息)

函数：取浏览器语言()

获取当前浏览器使用的语言。

变量 语言 = 取浏览器语言()
调试输出("浏览器语言: " + 语言)  ' 如：zh-CN

' 根据语言加载对应资源
变量 当前语言 = 取浏览器语言()
如果(寻找文本(当前语言, "zh") != -1)
	加载中文资源()
否则 如果(寻找文本(当前语言, "en") != -1)
	加载英文资源()
结束 如果

函数：取浏览器状态()

获取当前浏览器是否在线的状态。

变量 是否在线 = 取浏览器状态()
调试输出("在线状态: " + 是否在线)

' 离线状态提示
如果(取浏览器状态() == 假)
	弹出提示("您当前处于离线状态，部分功能不可用")
结束 如果

函数：取浏览器引擎()

获取当前浏览器使用的引擎（产品）。

变量 引擎 = 取浏览器引擎()
调试输出("浏览器引擎: " + 引擎)  ' 如：Gecko

函数：读COOKIE(字段名)

获取当前站点cookie，如果指定字段参数为空字符串，则返回所有cookie，若指定字段存在则返回指定字段cookie值，否则返回空。

' 读取指定字段的cookie
变量 用户名 = 读COOKIE("username")
调试输出("用户名: " + 用户名)

' 读取用户登录令牌
变量 令牌 = 读COOKIE("token")
如果(令牌 == "")
	调试输出("用户未登录")
否则
	调试输出("登录令牌: " + 令牌)
结束 如果

' 读取所有cookie
变量 所有cookie = 读COOKIE("")
调试输出("所有cookie: " + 所有cookie)

' 用户登录状态检查
变量 登录状态 = 读COOKIE("login")
如果(登录状态 == "true")
	显示用户信息()
否则
	跳转登录页()
结束 如果

函数：写COOKIE(字段名,值,有效天数)

向cookie列表中写入指定字段值及有效时间，单位为天。

' 写入用户名cookie，有效期7天
写COOKIE("username", "张三", 7)

' 写入登录令牌，有效期30天
写COOKIE("token", "abc123xyz", 30)

' 写入用户偏好设置
写COOKIE("theme", "dark", 365)
写COOKIE("language", "zh-CN", 365)

' 写入临时cookie（会话级别，1天）
写COOKIE("temp", "临时数据", 1)

' 登录成功后保存登录信息
登录按钮.置被单击回调(() => {
	写COOKIE("userid", "1001", 7)
	写COOKIE("login", "true", 7)
	弹出提示("登录成功")
})

函数：置COOKIE(COOKIE键值对字符串值)

设置全部或追加COOKIE值，参数值格式须为键值对格式，例如：“user=demo1;sign=123456”

' 一次设置多个cookie
置COOKIE("user=demo1;sign=123456")

' 设置用户登录信息
置COOKIE("userid=1001;role=admin;login=true")

' 追加新的cookie
置COOKIE("theme=dark;fontsize=14")

学习要点

相关文档

• 文档前端(JavaScript)函数_字符串操作 —— 寻找文本、取文本中间 用于解析UA和Cookie字符串
• 文档前端(JavaScript)函数_储存类 —— 保存配置、读取配置 基于localStorage的本地存储
• 文档前端(JavaScript)函数_URL地址操作类 —— 取URL完整地址、重载页面 URL操作函数
• 文档前端(JavaScript)函数_窗口操作 —— 打开窗口、关闭窗口 窗口管理函数
• 文档前端(JavaScript)函数_网络操作类 —— HTTP请求 等网络通信函数

前端(JavaScript)函数_窗口操作

文档概述

轻语言网站开发中的窗口操作函数、用于控制浏览器窗口行为，包含页面跳转、窗口打开、CSS/JS文件加载、组件居中、页面标题设置等窗口操作功能，常用于页面导航、资源加载、窗口控制等场景。

• 对话框与提示：信息框/确认框/弹出提示/弹出输入框 提供不同交互级别的用户提示
• 窗口控制：切换页面/打开新窗口/关闭窗口/置窗口尺寸/移动窗口 控制窗口行为
• 页面信息：取页面标题/置页面标题/取页面图标/置页面图标/取页面背景色/置页面背景色 管理页面元信息
• 组件布局：置组件居中/置组件水平居中/置组件垂直居中/批量赋值/置组件宽度 控制组件布局
• 数据编码：BASE64编码/BASE64解码 用于简单的字符串编码转换
• 页面参数：切换页面 传递数据，取请求参数 接收数据

💡 页面切换传参：切换页面("页面名", "key1=value1&key2=value2") 传递键值对格式数据，目标页面用 取请求参数() 接收参数对象，通过 参数["key"] 访问具体值。注意：传递值必须为文本且为键值对格式。

函数：信息框(信息内容)

显示一个警告对话框，参数为待显示的信息内容。

' 显示简单的信息提示
信息框("欢迎来到本网站！")
' 显示操作结果
信息框("保存成功！")
' 显示带变量的信息
变量 用户名 = "张三"
信息框("您好，" + 用户名 + "！")

函数：确认框(确认内容)

显示一个确认对话框，返回用户点击确认或取消的结果。

' 删除前确认
变量 结果 = 确认框("确定要删除这条记录吗？")
如果(结果)
	调试输出("用户确认删除")
	' 执行删除操作...
否则
	调试输出("用户取消删除")
结束 如果
' 退出前确认
变量 是否退出 = 确认框("您有未保存的修改，确定要退出吗？")
如果(是否退出)
	关闭窗口()
结束 如果

函数：弹出提示(提示信息,持续时间)

在页面底部弹出一个文本提示，默认2秒后自动消失，参数持续时间单位：毫秒。代码示例：弹出提示("操作成功", 3000)

' 在页面底部弹出提示信息，持续3秒钟
弹出提示("操作成功", 3000)
' 使用默认持续时间（2秒）
弹出提示("保存完成")

函数：弹出输入框(提示信息)

弹出一个可提示用户输入的对话框，并返回用户的输入内容。

' 弹出一个输入对话框，并返回用户输入的内容
变量 输入结果 = 弹出输入框("请输入用户名")
调试输出("用户输入：" + 输入结果)

函数：调试输出(值)

将指定的值，对象，数组值输出到浏览器控制台（Console），一般浏览器按电脑键盘“F12”键可打开浏览器调试控制台。

' 输出字符串
调试输出("这是一条调试信息")
' 输出变量值
变量 用户名 = "张三"
变量 年龄 = 25
调试输出("姓名: " + 用户名 + "，年龄: " + 年龄)
' 输出数组
变量 水果 = ["苹果", "香蕉", "橙子"]
调试输出(水果)
' 输出对象
变量 用户 = { "姓名": "李四", "年龄": 30 }
调试输出(用户)

函数：调试输出对象(对象)

在控制台中输出指定对象信息。

变量 坐标 = { X: 100, Y: 200 }
' 输出对象信息
调试输出对象(坐标)

函数：请求窗口聚焦()

将焦点设置到当前窗口。

' 将焦点设置到当前窗口
请求窗口聚焦()
' 从子窗口回到主窗口时聚焦
变量 子窗口 = 打开新窗口("child.html")
子窗口.关闭()
请求窗口聚焦()  ' 回到主窗口

函数：请求窗口失焦()

移除当前窗口的焦点。

' 移除当前窗口焦点
请求窗口失焦()
' 在打开新窗口后让当前窗口失焦
打开新窗口("popup.html")
请求窗口失焦()

函数：滚动页面内容(X坐标, Y坐标)

将窗口页面内容滚动到指定坐标位置，坐标原点：页面左上角。代码示例：滚动页面内容(0, 500)

' 滚动到页面顶部
滚动页面内容(0, 0)
' 滚动到指定坐标位置，X=100，Y=500
滚动页面内容(100, 500)

函数：滚动相对位置(X偏移, Y偏移)

将窗口页面内容相对于当前位置滚动指定的偏移量。代码示例：滚动相对位置(0, 100)

' 向下滚动100像素
滚动相对位置(0, 100)
' 向右滚动50像素，向下滚动200像素
滚动相对位置(50, 200)

函数：停止加载()

停止窗口加载资源，类似浏览器的停止按钮。

' 停止页面加载
停止加载()
' 在用户点击取消按钮时停止加载
取消按钮.置被单击回调(() => {
	停止加载()
	弹出提示("已停止加载")
})

函数：置窗口尺寸(宽度,高度)

设置窗口尺寸大小，单位：像素。代码示例：置窗口尺寸(800, 600)

' 将窗口尺寸设置为800x600像素
置窗口尺寸(800, 600)
' 设置为全屏尺寸
置窗口尺寸(取窗口宽度(), 取窗口高度())

函数：调整窗口尺寸(宽度增减,高度增减)

调整窗口尺寸大小，窗口左上角位置不变，根据参数值增减窗口宽高，单位：像素。代码示例：调整窗口尺寸(100, 50)

' 窗口宽度增加100像素，高度增加50像素
调整窗口尺寸(100, 50)
' 窗口宽度减少50像素，高度减少100像素
调整窗口尺寸(-50, -100)

函数：打印页面()

打开打印对话框打印当前页面。

' 打印当前页面
打印页面()
' 点击按钮触发打印
打印按钮.置被单击回调(() => {
	打印页面()
})

函数：移动窗口(X坐标,Y坐标)

将窗口的左上角移动到一个指定的坐标。代码示例：移动窗口(100, 100)

' 将窗口移动到屏幕坐标(100, 100)位置
移动窗口(100, 100)
' 将窗口移动到屏幕中心
移动窗口((取屏幕宽度()-取窗口宽度())/2, (取屏幕高度()-取窗口高度())/2)

函数：取选中对象()

返回表示用户选择的文本范围或光标的当前位置的对象。

' 获取用户选择的文本范围或光标当前位置
变量 选中内容 = 取选中对象()
调试输出(选中内容)

函数：BASE64解码(值)

解码使用 base64 编码的字符串。

' 解码Base64字符串
变量 密文 = "SGVsbG8gV29ybGQ="
变量 明文 = BASE64解码(密文)
调试输出("解码结果: " + 明文)  ' Hello World
' 解码Token获取用户信息
变量 Token = "eyJ1c2VyIjoiemhhbmdzYW4ifQ=="
变量 用户数据 = BASE64解码(Token)
调试输出("用户数据: " + 用户数据)

函数：BASE64编码(值)

用于创建一个 base64 编码的字符串。

' 编码字符串为Base64
变量 明文 = "Hello World"
变量 密文 = BASE64编码(明文)
调试输出("编码结果: " + 密文)  ' SGVsbG8gV29ybGQ=
' 编码用户信息生成简单Token
变量 用户信息 = "user=张三&role=admin"
变量 Token = BASE64编码(用户信息)
调试输出("Token: " + Token)

函数：关闭窗口()

关闭当前窗口。

' 关闭当前窗口
关闭窗口()
' 用户确认后关闭
变量 结果 = 确认框("确定要关闭窗口吗？")
如果(结果)
	关闭窗口()
结束 如果

函数：切换页面(页面名称,数据值)

切换当前窗口内容为指定页面的内容，参数二为需要传递的数据值，可省略。

' 切换页面时不传递数据，切换到"我的"页面
切换页面("我的")
' 切换页面时向目标窗口传递数据，注意传递的值只能为文本值且为键值对格式
切换页面("窗口1","key=1&value=data2")
' 传递多个参数
切换页面("详情页", "id=123&name=产品名称&type=电子")

函数：打开新窗口(页面名称)

在新窗口中打开指定页面；等效于：“window.open”函数，示例：打开新窗口("窗口1")。

' 在新窗口中打开"主页"
打开新窗口("主页")
' 在新窗口中打开指定页面并获取窗口对象
变量 新窗口 = 打开新窗口("详情页")
' 可以通过新窗口对象进行进一步操作

函数：添加CSS文件(地址)

添加并引入指定路径的 CSS 文件。代码示例：添加CSS文件("/static/css/style.css")

' 添加外部CSS文件
添加CSS文件("https://cdn.example.com/styles.css")
' 添加本地CSS文件
添加CSS文件("/static/css/style.css")

函数：添加字体文件(字体名称,字体文件地址,加载完毕回调函数,预设参数)

添加并引入指定字体文件到当前页面。

' 添加并使用自定义字体
添加字体文件("CustomFont", "/static/fonts/custom.woff2", ()=>{
	' 字体加载完成后的使用
	标签1.字体 = "CustomFont"
})
' 带预设参数的字体加载
添加字体文件("MyFont", "/static/fonts/myfont.woff2",()=>{
	' 字体加载完成后的使用
	标签1.字体 = "MyFont"
},{"style": "normal", "weight": "400"})

函数：置页面标题(新标题)

设置当前页面的标题。代码示例：置页面标题("我的应用 - 首页")

' 设置页面标题
置页面标题("我的应用 - 首页")
' 动态设置标题
置页面标题("用户中心 - " + 用户名)

函数：取页面标题()

获取当前页面的标题。

' 获取当前页面标题
变量 当前标题 = 取页面标题()
调试输出("页面标题: " + 当前标题)

函数：置页面图标(图标地址)

设置当前页面的图标。

' 设置页面图标
置页面图标("/static/images/logo.png")
' 动态切换页面图标（如夜间模式）
变量 当前主题 = 取缓存数据("theme")
如果(当前主题 == "dark")
	置页面图标("/static/images/logo-dark.png")
否则
	置页面图标("/static/images/logo-light.png")
结束 如果

函数：取页面图标()

获取当前页面的图标。

' 获取当前页面图标地址
变量 当前图标 = 取页面图标()
调试输出("当前图标: " + 当前图标)
' 检查图标是否已设置
如果(取页面图标() == "")
	置页面图标("/static/images/default.png")
结束 如果

函数：置页面背景色(颜色值)

设置当前页面背景颜色。

' 设置页面背景色
置页面背景色("#f0f0f0")
' 根据时间切换背景色
变量 当前小时 = 取时()
如果(当前小时 >= 6 且 当前小时 < 18)
	置页面背景色("#ffffff")  ' 白天白色背景
否则
	置页面背景色("#333333")  ' 夜晚深色背景
结束 如果

函数：取页面背景色()

获取当前页面背景颜色。

' 获取当前页面背景色
变量 当前背景色 = 取页面背景色()
调试输出("背景色: " + 当前背景色)
' 判断当前主题
如果(取页面背景色() == "#333333")
	调试输出("当前为夜间模式")
否则
	调试输出("当前为日间模式")
结束 如果

函数：取本窗口对象()

获取当前窗口（Window）对象。

变量 当前窗口 = 取本窗口对象()
调试输出(当前窗口)

函数：窗口已关闭()

获取并返回当前窗口是否已经被关闭。

变量 是否关闭 = 窗口已关闭()
调试输出("窗口已关闭: " + 是否关闭)

函数：取文档高度()

获取并返回窗口的文档显示区的高度。

变量 文档高度 = 取文档高度()
调试输出("文档高度: " + 文档高度 + "px")

函数：取文档宽度()

获取并返回窗口的文档显示区的宽度。

变量 文档宽度 = 取文档宽度()
调试输出("文档宽度: " + 文档宽度 + "px")

函数：取窗口框架数()

获取并返回窗口中的框架数量。

变量 框架数 = 取窗口框架数()
调试输出("框架数: " + 框架数)

函数：取窗口名称()

获取并返回窗口的名称。

变量 窗口名 = 取窗口名称()
调试输出("窗口名称: " + 窗口名)

函数：取窗口源引用()

获取并返回 创建此窗口的 来源窗口对象，通俗的讲：就是这个窗口是从那个窗口创建或切换过来的。

变量 来源窗口 = 取窗口源引用()
调试输出(来源窗口)

函数：取窗口高度()

获取并返回窗口的外部高度，包含工具条与滚动条。

变量 窗口高度 = 取窗口高度()
调试输出("窗口高度: " + 窗口高度 + "px")

函数：取窗口宽度()

获取并返回窗口的外部宽度，包含工具条与滚动条。

变量 窗口宽度 = 取窗口宽度()
调试输出("窗口宽度: " + 窗口宽度 + "px")

函数：取页面X偏移()

获取并返回当前页面相对于窗口显示区左上角的X位置。

变量 页面X偏移 = 取页面X偏移()
调试输出("X偏移: " + 页面X偏移)

函数：取页面Y偏移()

获取并返回当前页面相对于窗口显示区左上角的Y位置。

变量 页面Y偏移 = 取页面Y偏移()
调试输出("Y偏移: " + 页面Y偏移)

函数：取父窗口()

获取并返回父窗口。

变量 父窗口 = 取父窗口()
调试输出(父窗口)

函数：取窗口X坐标()

获取并返回相对于屏幕窗口的x坐标。

变量 窗口X坐标 = 取窗口X坐标()
调试输出("窗口X坐标: " + 窗口X坐标)

函数：取窗口Y坐标()

获取并返回相对于屏幕窗口的y坐标。

变量 窗口Y坐标 = 取窗口Y坐标()
调试输出("窗口Y坐标: " + 窗口Y坐标)

函数：取顶层父窗口()

获取并返回最顶层的父窗口。

变量 顶层窗口 = 取顶层父窗口()
调试输出(顶层窗口)

函数：置组件水平居中(...视图组件)

设置指定组件在页面中相对于页面宽度水平居中。代码示例：置组件水平居中(按钮1, 输入框1)

' 将单个组件水平居中
置组件水平居中(登录按钮)
' 将多个组件同时水平居中
置组件水平居中(按钮1, 输入框1, 标签1)

函数：置组件垂直居中(...视图组件)

设置指定组件在页面中相对于页面高度垂直居中。代码示例：置组件垂直居中(面板1)

' 将组件垂直居中
置组件垂直居中(主面板)
' 将多个组件垂直居中
置组件垂直居中(面板1, 面板2)

函数：置组件居中(...视图组件)

设置指定组件在页面中垂直水平居中。代码示例：置组件居中(对话框1)

' 将组件完全居中（水平+垂直）
置组件居中(登录对话框)					
' 将多个组件居中
置组件居中(面板1, 面板2)

函数：批量赋值(属性名称,目标值,...视图组件)

对指定对象的属性批量赋值，例如要同时设置多个可视组件的宽度或背景颜色。

' 批量设置组件宽度
批量赋值("宽度", "80%", 编辑框1, 编辑框2, 编辑框3)
' 批量设置组件背景颜色
批量赋值("背景颜色", "#f0f0f0", 面板1, 面板2, 面板3)
' 批量设置组件可见性
批量赋值("可视", "hidden", 组件1, 组件2, 组件3)

函数：置组件宽度(值,...视图组件)

设置指定组件的宽度值，参数二支持同时设置多个组件的宽度。代码示例：置组件宽度(300, 按钮1, 输入框1)

' 设置单个组件宽度
置组件宽度(200, 按钮1)
' 同时设置多个组件宽度
置组件宽度("50%", 面板1, 面板2)
' 使用不同单位设置宽度
置组件宽度("200px", 组件1)
置组件宽度("80%", 组件2)

函数：置组件高度(值,...视图组件)

设置指定组件的高度值，参数二支持同时设置多个组件的高度。代码示例：置组件高度(400, 面板1)

' 设置组件高度
置组件高度(300, 主面板)
' 同时设置多个组件高度
置组件高度("60vh", 面板1, 面板2)

函数：置组件顶边(值,...视图组件)

设置指定组件的顶边值，参数二支持同时设置多个组件的顶边。代码示例：置组件顶边(50, 面板1)

' 设置组件距离顶部的位置
置组件顶边(100, 弹窗1)
' 同时设置多个组件的顶边
置组件顶边(20, 标签1, 输入框1)

函数：置组件左边(值,...视图组件)

设置指定组件的左边值，参数二支持同时设置多个组件的左边。代码示例：置组件左边(100, 面板1)

' 设置组件距离左边的位置
置组件左边(50, 侧边栏)
' 同时设置多个组件的左边位置
置组件左边(10, 标签1, 输入框1)

函数：取请求参数()

获取从其它页面切换到本页面时，传递过来的参数值，返回一个参数值对象。

' 获取页面跳转时传递的参数，假设上一个窗口切换到本页面时传递的参数为 ?id=123&name=test
变量 参数值 = 取请求参数()
如果(参数值 != 空)
	变量 用户ID = 参数值["id"]
	变量 用户名 = 参数值["name"]
	' 使用参数值
	调试输出("用户名：" + 用户名 + "，用户ID：" + 用户ID)
结束 如果

学习要点

相关文档

• 文档前端(JavaScript)函数_URL地址操作类 —— 重载页面、取URL完整地址 URL操作函数
• 文档前端(JavaScript)函数_历史类 —— 后退页面、前进页面 浏览历史控制
• 文档前端(JavaScript)函数_浏览器操作类 —— 读COOKIE、写COOKIE Cookie操作
• 文档前端(JavaScript)函数_屏幕操作类 —— 取屏幕宽度、取屏幕高度 屏幕信息获取
• 文档前端(JavaScript)函数_文档操作 —— 查找元素ByID 等DOM操作函数
• 文档前端(JavaScript)函数_时间类 —— 取时、取年 等时间函数，配合定时切换背景

前端(JavaScript)函数_网络操作类

文档概述

轻语言网站开发中的网络操作函数、用于处理HTTP请求和网络通信，包含HTTP请求、文件上传、下载、接口调用、网络状态检测等功能，常用于API调用、数据交换、文件传输等场景。

• 接口请求：请求接口 调用本程序后端接口文件；发送GET请求/发送POST数据 发起HTTP请求
• 文件上传：上传文件By接口 通过后端接口上传文件
• 回调异步：所有请求函数均为异步，通过回调函数接收结果，回调参数通常为 (请求结果, 标记)

💡 请求异步与跨域：所有网络请求函数均为异步操作，通过回调函数处理响应。GET/POST请求默认仅支持同源域名，跨域需服务端配置CORS。请求超时默认5秒，可通过最后参数自定义。返回的JSON字符串需用 JSON解析 转为对象后访问属性。

函数：请求接口(接口文件名,后端函数名,回调函数,待提交数据,协议头,标记值)

请求本程序中指定后端接口文件；向其发送或获取数据；回调函数返回两个参数：(请求结果,标记)。代码示例：请求接口(接口文件名, 后端函数名, 回调函数, 待提交数据)

' 发送GET请求获取用户信息，user 为接口文件名，getUserInfo为后端函数名
请求接口("user", "getUserInfo", (结果, 标记)=>{
	如果(结果 != "")
		变量 用户数据 = JSON解析(结果)
		调试输出("用户名: " + 用户数据.姓名)
	否则
		调试输出("获取用户信息失败")
	结束 如果
})
' 发送POST请求提交用户数据
变量 提交数据 = "name=张三&age=25&email=zhangsan@example.com"
请求接口("user", "saveUserInfo", (结果, 标记)=>{
	如果(结果 == "success")
		弹出提示("用户信息保存成功")
	否则
		弹出提示("保存失败")
	结束 如果
}, 提交数据)
' 带自定义协议头的请求
变量 自定义协议头 = {
	"Authorization": "Bearer token123",
	"Content-Type": "application/json"
}
变量 JSON数据 = JSON编码({"name": "李四", "age": 30})
请求接口("api", "updateUser", (结果, 标记)=>{
	调试输出("更新结果: " + 结果)
}, JSON数据, 自定义协议头, "更新用户")

函数：上传文件By接口(接口文件名,后端函数名,待上传文件对象,回调函数)

通过调用接口向服务端（服务器）上传一个文件；回调函数返回一个参数：(请求结果)。代码示例：上传文件By接口(接口文件名, 后端函数名, 待上传文件对象, 回调函数)

' 上传用户选择的文件
' 注：箭头函数 ()=>{} 为原生 JS 回调语法，轻语言支持直接使用
文件选择框1.置文件选择完毕回调((源对象, 文件列表)=>{
	' 注：数组[索引] 为原生 JS 数组访问语法，轻语言支持直接使用；也可用 取数组成员(数组, 索引)
	变量 选中文件 = 文件列表[0]
	如果(选中文件 != 空)
		上传文件By接口("file", "upload", 选中文件, (结果)=>{
			如果(结果 != "fail")
				弹出提示("文件上传成功")
				调试输出("文件URL: " + 结果)
			否则
				弹出提示("文件上传失败")
			结束 如果
		})
	结束 如果
})
' 上传图片文件
文件选择框2.置文件选择完毕回调((源对象, 文件列表)=>{
	变量 文件对象 = 文件列表[0]
	如果(文件对象 != 空)
		上传文件By接口("image", "uploadImage", 文件对象, (结果)=>{
			如果(结果 != "fail")
				图片预览.资源 = 结果
				弹出提示("图片上传成功")
			否则
				弹出提示("图片上传失败")
			结束 如果
		})
	结束 如果
})

函数：发送GET请求(地址,回调函数,标记值,超时)

向服务端发送GET请求获取内容、注意：默认仅支持访问同源域名地址；若访问跨域地址，请在服务端允许跨域，回调函数返回两个参数值：(请求结果,标记)，参数超时默认5秒，可省略。代码示例：发送GET请求(地址, 回调函数)

' 获取天气信息
变量 天气API = "https://api.weather.com/v1/weather?city=Beijing"
' 注：箭头函数 ()=>{} 为原生 JS 回调语法，轻语言支持直接使用
发送GET请求(天气API, (结果, 标记)=>{
	如果(结果 != "")
		变量 天气数据 = JSON解析(结果)
		' 注：对象.属性 为原生 JS 对象属性访问语法，轻语言支持直接使用
		调试输出("当前温度: " + 天气数据.温度 + "°C")
	否则
		调试输出("获取天气信息失败")
	结束 如果
})
' 获取新闻列表
变量 新闻API = "/api/news/list?page=1&size=10"
发送GET请求(新闻API, (结果, 标记)=>{
	如果(结果 != "")
		变量 新闻列表 = JSON解析(结果)
		' 更新界面显示新闻
		' 注：数组[索引] 为原生 JS 数组访问语法，轻语言支持直接使用；也可用 取数组成员(数组, 索引)
		变量循环(i = 0, 取数组成员数(新闻列表), 1)
			新闻容器.添加子项(创建新闻项(新闻列表[i]))
		结束循环
	否则
		弹出提示("获取新闻失败")
	结束 如果
}, "新闻列表")
' 带超时设置的请求
变量 外部API = "https://external-api.com/data"
发送GET请求(外部API, (结果, 标记)=>{
	如果(结果 != "")
		处理数据(JSON解析(结果))
	否则
		弹出提示("请求超时或失败")
	结束 如果
}, "", 10000)  ' 10秒超时

函数：发送POST数据(地址,待提交数据,回调函数,协议头,标记值,超时)

向服务端发送POST请求获取内容、注意：默认仅支持访问同源域名地址；若访问跨域地址，请在服务端允许跨域，回调函数返回两个参数：(请求结果,标记)，参数超时默认5秒，可省略。代码示例：发送POST数据(地址, 待提交数据, 回调函数)

' 用户登录
变量 登录地址 = "/api/user/login"
变量 登录数据 = "username=admin&password=123456"
发送POST数据(登录地址, 登录数据, (结果, 标记)=>{
	变量 响应 = JSON解析(结果)
	如果(响应.状态 == "success")
		弹出提示("登录成功")
		切换页面("dashboard")
	否则
		弹出提示("登录失败: " + 响应.消息)
	结束 如果
})
' 提交表单数据
变量 提交地址 = "/api/form/submit"
变量 表单对象 = {
	"name": 姓名输入框.文本,
	"email": 邮箱输入框.文本,
	"phone": 电话输入框.文本,
	"message": 留言输入框.文本
}
变量 JSON数据 = JSON编码(表单对象)
变量 协议头 = {
	"Content-Type": "application/json"
}
发送POST数据(提交地址, JSON数据, (结果, 标记)=>{
	变量 响应 = JSON解析(结果)
	如果(响应.状态 == "success")
		弹出提示("提交成功")
		清空表单()
	否则
		弹出提示("提交失败")
	结束 如果
}, 协议头)
' 发送带有认证信息的请求
变量 API地址 = "/api/protected/data"
变量 数据 = "query=getUserData"
变量 认证协议头 = {
	"Authorization": "Bearer " + 获取Token(),
	"Content-Type": "application/x-www-form-urlencoded"
}
发送POST数据(API地址, 数据, (结果, 标记)=>{
	如果(结果 != "")
		处理用户数据(JSON解析(结果))
	否则
		弹出提示("请求失败，请重新登录")
		切换页面("login")
	结束 如果
}, 认证协议头, "获取用户数据", 8000)

学习要点