string函数string.byte (s,[,i[,j]])返回字符串内部编码s[i],s[i+1],...,s[j]。i默认是1,j默认是i;
和|string.sub|规则相同。内部编码不一定可移植。      
string.byte("hello",1,5)
在mac上返回104,101,108,108,111string.char (…)接收零个或多个整数。返回由参数编码组成的字符串            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-16 09:08:37
                            
                                169阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            1. string库中所有的字符索引从前往后是1,2,...;从后往前是-1,-2,...
2. string库中所有的function都不会直接操作字符串,而是返回一个结果
s = "[abc]"
string.len(s)        <==返回5
string.rep("abc", 2) <==返回"abcabc"
string.lower("ABC") <==返回"ab            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-16 09:56:49
                            
                                826阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            字符串string 是 Lua 中八大数据类型之一,Lua 中没有字符的概念,所有的文本都是 string。Lua 中的string 是以 8个比特 来储存的。Lua中的字符串与大多数语言字符串一样都是不可变量。所有改变string的操作,都是生成新的string。Lua中string数据结构使用的是哈希算法实现的字符串池。这样的做法是为了保证内存不泄露,且字符串比较时大大提高性能。表示方法 st            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-05 17:46:47
                            
                                262阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Lua 关于string库的常用方法1. string.len(str) 返回字符串长度print(string.len("123"))     -- 3
print(string.len(" "))       -- 12. string.rep(str,n) 返回重复n次的str的字符串-- 关于次数,针对于测试需要,我们可以设定很大的数值
print(string.rep("s",5))            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-27 18:22:49
                            
                                37阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            String库Lua 字符串内部用来标识各个组成字节的下标是从 1 开始的Lua 字符串总是由字节构成的string.byte(s [, i [, j ]])返回字符 s[i]、s[i + 1]、s[i + 2]、······、s[j] 所对应的 ASCII 码。i 的默认值为 1,即第一个字节,j 的默认值为 i 。string.char (...)接收 0 个或更多的整数(整数范围:0~255            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-07 16:50:26
                            
                                212阅读
                            
                                                                             
                 
                
                             
         
            
            
            
              LUA中的正则表达式 Step By Step(Lua字符串库) -------------------------------------------------------------------------------------------------- 
  【基本函数】 
  
  string.gfind(s, pattern)   返回一个迭代器,迭代器每执            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-24 11:31:06
                            
                                35阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            大家直觉地认为".."操作符比string.format慢,这是个误解,实际上从连接字符串的效率来说".."比string.format快多了。先看看实验结果 10000000次实验,基础字符串11个字符 每次连接2个基础字符串 string.format 9秒; ".." 3秒 每次连接3个基础字符串 string.format 12秒; ".." 3秒  1000000次实验,基础字符串11个            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-05 16:09:11
                            
                                68阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            捕获捕获是这样一种机制:可以使用模式串的一部分匹配目标串的一部分。将你想捕获的模式用圆括号括起来,就指定了一个捕获。在string.find使用捕获的时候,函数会返回捕获的值作为额外的结果。这常被用来将一个目标串拆分成多个:pair = "name = Anna"_, _, key, value = string.find(pair, "(%a+)%s*=%s*(%a+)")print(key,            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-25 14:52:51
                            
                                34阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            在string库中功能最强大的函数是:string.find(字符串查找)string.gsub(全局字符串替换)string.gfind(全局字符串查找)string.gmatch(返回查找到字符串的迭代器)这些函数都是基于模式匹配的。与其他脚本语言不同的是,Lua并不使用POSIX规范的正则表达式[4](也写作regexp)来进行模式匹配。主要的原因出于程序大小方面的考虑:实现一个典型的符合P            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-14 18:02:07
                            
                                25阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            函数原型 string.find(s, pattern [, init [, plain]] )  s: 源字符串  pattern: 待搜索模式串  init: 可选, 起始位置  plain: 我没用过    ① 子串匹配:    
     1. print(string.find("haha", 'ah')            
                
         
            
            
            
            C/C++ string库(string.h)提供了几个字符串查找函数,如下:memchr在指定内存里定位给定字符strchr在指定字符串里定位给定字符strcspn返回在字符串str1里找到字符串str2里的任意一个字符之前已查找的字符数量strrchr在字符串里定位给定字符最后一次出现的位置strpbrk在字符串str1里定位字符串str2里任意一个首次出现的字符strspn返回字符串str1            
                
         
            
            
            
            1.关于tableLua官方文档对table库的描述:This library provides generic functions for table manipulation. It provides all its functions inside the table table. 使用起来很简单:local sortn = table.concat( {1,2,3,4}            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-02-17 17:29:56
                            
                                245阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            不可变性 String可以说是最常用的类型了,即字符串类型,String是常量(final关键词修饰的),他的值不能被创建后更改,因为字符串是不可被改变的,所以可以被用来共享。Java语言为String提供了同基本数据类型相似的操作符(+,+=),这里请注意,由于String是不可被改变的,所以每次操作都会会重新生成一个String类型。String a = "a";
System.ou            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-25 11:11:21
                            
                                148阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            --->lua中字符串索引从前往后是1,2,……,从后往前是......,-2,-1      e.g: tmp = “abcd” ,tmp[1] =='a',tmp[2] =='b',tmp[-1] =='d',tmp[-2] =='c'. --->string库中所有的function都不会直接操作字符串,只返回一个结果。 
 --->            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-16 21:18:37
                            
                                62阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            StringsLua 也支持字符串类型 (例如. 文本) . 创建字符串, 使用 "双引号" 或 '单引号' 引用文本即可: > print("hello")
hello 我们可以采用下面方法声明字符串变量: > who = "Lua user"
> print(who)
Lua user 我们也可以使用 .. 操作符, 将字符串整合在一起: > print("hello            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-27 22:37:15
                            
                                84阅读
                            
                                                                             
                 
                
                             
         
            
            
            
                网上找了一些关于gsub模式匹配资料,但是都不全面细致,所以打算翻译官方文档。以下内容翻译自《Lua 5.3 Reference Manual》6.4.1 - Patterns。 ------ 我是一条分割线------    Lua中的模式匹配用正则表达式来描述,它被用于string.find, string            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-05-12 16:21:34
                            
                                75阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Lua字符串可以使用以下三种方式表示:单引号间的一串字符。双引号间的一串字符。[[和]]间的一串字符。string = [["Lua"]]
print("字符串 是",string)
--字符串 是	"Lua"Lua 提供很多内建方法支持字符串的操作:string.upper(argument):-->字符串全部转为大写字母string.lower(argument):-->字符串全部            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-03-07 13:07:50
                            
                                676阅读
                            
                                                                             
                 
                
                             
         
            
            
            
                     【Lua基础系列】之类型与值 (字符串String)          大家好,我是Lampard~~       欢迎来到Lua基础系列的博客       PS:本博客知识参考资料为:《Lu            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-02-24 22:50:23
                            
                                157阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            table.keys 返回指定表格中的全部键。 格式: keys = table.keys(表格对象) 使用方法演示样例: local t = {a = 1, b = 2, c = 3} local keys = table.keys(t) -- keys = {"a", "b", "c"} ~~            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2017-06-26 09:33:00
                            
                                290阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            一、初始化:string str;                     //定义一个空的字符串
    char cstr[] = "I have a dream"; //定义一个字符数组
    str = "I have a dream";         //字符串赋值方法1
    string s1 = str;
    string s2 = "I have a dream";            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-17 00:04:55
                            
                                507阅读