【1】Lua数据类型

Lua语言共有8种基本类型

[1] nil　　　　空。最简单，有且仅有值nil，表示一个无效值（在条件表达式中相当于false）

[2] boolean　　布尔。包含两个值：false和true

[3] number　　 数字。double（双精度）类型（默认类型可以修改 luaconf.h 里的定义）

[4] string　　 字符串。字符串由一对双引号或单引号来表示

[5] function　 函数。由C或Lua编写的函数

[6] userdata　 自定义类型。表示任意存储在变量中的C数据结构

[7] thread　　 线程。表示执行的独立线程，用于执行协同程序

[8] table　　　表。Lua中的表（table）其实是一个“关联数组”（associative arrays），数组的索引可以是数字或者是字符串。

在Lua里，table的创建是通过“构造表达式”来完成，最简单构造表达式是{}，用来创建一个空表。

【2】各种数据类型示例

（1）各种数据类型

1.1 打印各种数据类型

 print(type("Good Good Study"))  --> string

 print(type(12.34))              --> number

 print(type(print))              --> function

 print(type(type))               --> function

 print(type(true))               --> boolean

 print(type(nil))                --> nil

 print(type(type(X)))            --> string

1.2 打印各种数据类型

 print(type(a))    --> nil

 a =

 print(type(a))    --> number

 a = "Day Day Up"

 print(type(a))    --> string

 a = print

 print(type(a))    --> function

 a(type(a))        --> function

1.3 待续

（2）nil

2.1 nil类型表示一种没有任何有效值，它只有一个值nil。例如：打印一个没有赋值的变量，结果为nil值。

 print(type(X))                  --> nil

2.2 nil 作比较时应该加上双引号：

 print(type(X) == nil)           --> false

 print(type(X) == "nil")         --> true

type(X) == nil结果为false，因为：

 print(type(type(X)))            --> string

2.3 对于全局变量和table，nil还有一个“删除”作用。如下示例：

 luaTable = {, , , , }

 for k, v in pairs(luaTable) do

     print(k .. " - " .. v)

 end

 luaTable[] = nil

 print("After set nil :: ")

 for k, v in pairs(luaTable) do

     print(k .. " - " .. v)

 end

 --[[

 1 - 10

 2 - 20

 3 - 30

 4 - 40

 5 - 50

 After set nil ::

 1 - 10

 3 - 30

 4 - 40

 5 - 50

 --]]

2.4 读入行数据作为数组元素

 --[[读入行 作为数组元素]]

 a = {}

 for i = ,  do

 a[i] = io.read()

 end

 for i, v in pairs(a) do

     print(i .. " ---> " .. v)

 end

 print(a)

 --[[ 执行结果

 10

 11

 12

 13

 14

 1 ---> 10

 2 ---> 11

 3 ---> 12

 4 ---> 13

 5 ---> 14

 ]]

2.5 待续

（3）boolean

3.1 lua语言中nil和false均是属于假，true和其他任何东西都属于真。

C++语言中0、NULL和false均是属于假，true其他任何非空的东西都属于真。

尤其注意：lua中0被视为真。

示例如下：

 print()              --> 0

 print( == false)     --> false

 b = ;

 print(b == true)      --> false

 if( and b) then

     print("0 and b is true")  --> 0 and b is true

 else

     print("0 and b id false")

 end

 if(nil) then

     print("nil is true")

 else

     print("nil is false")  --> nil is false

 end

 print(nil)            --> nil

 print(false == nil)   --> false

 print(true == nil)    --> false

 print(true == "nil")  --> false

 print(false == "nil") --> false

 print(false == "")    --> false

 print( == )     --> true

3.2 待续

（4）number

4.1 待续

（5）string

5.1 字符串由一对双引号或单引号来表示：

 string1 = "this is string1"

 print(string1)    --> this is string1

 string2 = 'this is string2'

 print(string2)    --> this is string2

5.2 除过以上两种表示方式，还可以使用方括号“[[]]”来表示“一块”字符串：

 html = [[

 <html>

 <head></head>

 <body>

     <a href="http://www.baidu.com/">百度首页</a>

 </body>

 </html>

 ]]

 print(html)

 --执行结果：

 --[[

 <html>

 <head></head>

 <body>

     <a href="http://www.baidu.com/">百度首页</a>

 </body>

 </html>

 --]]

5.3 在对一个数字字符串进行算术操作时，Lua会尝试将这个数字字符串转换为一个数字：

 print("" + )      --> 3

 print("" + "")    --> 7

 print("5 + 6")      --> 5 + 6

 print("" * "")    --> 64

 --print("nil" + 1)  --> syntax error

5.4 如上代码中“nil”+ 1执行报错了，字符串连接使用的是 ..，如下所示：

 print("a"..'b'.."cdefg".." ".."hijk")  --> abcdefg hijk

 print( ..  .. )               --> 112110119

5.5 使用 # 来计算字符串的长度，放在字符串前面。如下示例：

 strLength = "www.baidu.com"

 print(#strLength)          --

 print(#"www.baidu.com")    --

 print(#"www.bai\0du.com")  --

 print(#"www.bai\ndu.com")  --

5.6 字符串函数的应用示例

 --1 大小写转换

 --[[

 string.upper(argument)

 string.lower(argument)

 ]]

 str = "abcdefghijklmnopqrstuvwxyz"

 STR = string.upper(str)

 str1 = string.lower(STR)

 print(str)                -- abcdefghijklmnopqrstuvwxyz

 print(string.upper(str))  -- ABCDEFGHIJKLMNOPQRSTUVWXYZ

 print(STR)                -- ABCDEFGHIJKLMNOPQRSTUVWXYZ

 print(str1)               -- abcdefghijklmnopqrstuvwxyz

 --2 在字符串中替换

 --[[

 string.gsub(main string, find string, replace string, num)

 main string 要替换的字符串

 find string 被替换的字符

 relace string 要替换的字符

 num 替换次数 备注：可以忽略，默认是全部替换

 ]]

 str2 = "aaaaaaa"

 print(string.gsub(str2, "a", "b", )) -- bbbaaaa    3

 print(string.gsub(str2, "a", "c"))    -- ccccccc    7

 --3 搜索指定字符串

 --[[

 在一个指定的目标字符串中搜索指定的内容(第三个参数为起始索引)，返回其具体位置。不存在则返回nil。

 ]]

 str3 = "Welcome to Beijing"

 print(string.find(str3, "Beijing"))         -- 12 18

 local index = string.find(str3, "Beijing")

 print(index)                                --

 print(string.find(str3, "Beijing", ))     -- 12 18

 print(string.find(str3, "Beijing", ))     -- nil

 --4 字符串反转

 --[[

 string.reverse(argument)

 ]]

 str4 = "Welcome to xian."

 print(string.reverse(str4))  -- .naix ot emocleW

 --5 格式化字符串

 --[[返回一个类似于printf的格式化字符串

 string.format(...)

 ]]

 str5 = "the value is :: %d"

 print(string.format(str5, ))   -- the value is :: 10

 --6 整型数值与字符相互转换

 --[[将整型数字转成字符并连接string.char(argument)

 将字符转成整型数字值(可以指定某个字符，默认是第一个字符)

 ]]

 print(string.char(, , , ))   -- abcd

 str6 = "ABCDE"

 print(string.byte("ABCD", ))   --

 print(string.byte("ABCD"))      --

 --7 计算字符串长度

 --[[

 string.len(argument)

 ]]

 print(string.len("abcde"))    --

 --8 返回字符串string的n个拷贝

 --[[

 string.rep(string, n)

 ]]

 print(string.rep("abcde ", ))  -- abcde abcde abcde

 --9 链接两个字符串

 --[[

 ..

 ]]

 print("Welcome ".."to ".."Beijing") -- Welcome to Beijing

 --10 gmatch接口

 --[[string.gmatch(str, pattern)

 返回一个迭代器函数，每一次调用这个函数，返回一个在字符串str找到的下一个符合pattern描述的子串。如果参数pattern描述的字符串没有找到，迭代函数返回nil

 ]]

 local str10_1 = "Hello World By Lua"

 for word in string.gmatch(str10_1, "%a+") do

     print(word)

 end

 --[[执行结果

 Hello

 World

 By

 Lua

 ]]

 local str10_2 = "110abc119,def,120,ghij"

 local ret_func_itor = string.gmatch(str10_2, "%d+")

 -- 查看func_itor类型

 print("ret_func_itor is", ret_func_itor) -- func_itor is    function: 02D1DAC8

 -- 第一次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is     110

 -- 再次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is     119

 -- 再次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is     120

 -- 再次调用函数func_itor

 print("ret_func_itor ret is ", ret_func_itor()) -- ret_func_itor ret is

 -- 使用循环来打印

 local str10_3 = "hello world by Lua"

 local index =

 print("\noutput capture using loop:")

 for word in string.gmatch(str10_3, "%a+") do

     print(index, word)

     index = index +

 end

 --[[执行结果

 output capture using loop:

 1    hello

 2    world

 3    by

 4    Lua

 ]]

 -- 查找属性对

 local str10_4 = "from=world, to=Lua, name=kaizen"

 print("\noutput attr pair capture using loop:")

 for k, v in string.gmatch(str10_4, "(%w+)=(%w+)") do

     print(k, v)

 end

 --[[执行结果

 output attr pair capture using loop:

 from    world

 to    Lua

 name    kaizen

 ]]

 local str10_5 = "fadfasd,.;p[];'asd"

 local func_numitor = string.gmatch(str10_5, "%d+")

 local numret = func_numitor()

 print("\nnumret ret is", numret)

 --[[执行结果

 numret ret is    nil

 ]]

5.7 可以通过数值来指定字符串中的字符

 --[[可以通过数值来指定字符串中的字符。

 数值以转义序列“\<ddd>”给出，其中<ddd>是一个至多3个十进制数字组成的序列]]

 print("\97bcdefg\10hijklmn\49")

 --[[执行结果

 abcdefg

 hijklmn1

 ]]

5.8 字符串格式化format函数

 str = string.format("字符串：%s\n整数：%d\n小数：%f\n十六进制数：%X", "zhongguorenmin", , 1.23, )

 print(str)

 --[[

 字符串：zhongguorenmin

 整数：1

 小数：1.230000

 十六进制数：1C8

 ]]

5.9 待续

（6）function

6.1 在Lua中，函数可以存在变量里:

 function factorial1(n)

     if n ==  then

         return

     else

         return n * factorial1(n - )

     end

 end

 print(factorial1())     --> 120

 factorial2 = factorial1

 print(factorial2())     --> 120

6.2 function可以以匿名函数（anonymous function）的方式通过参数传递

 function testFun(tab, fun)

     for k, v in pairs(tab) do

         print(fun(k, v));

     end

 end

 tab = {key1 = "val1", key2 = "val2"};

 testFun(tab,

 function(key, val) --匿名函数

     return key .. " = " .. val;

 end

 );

 --执行结果

 --[[

 key1 = val1

 key2 = val2

 --]]

6.3 待续

（7）userdata

7.1 待续

（8）thread

8.1 待续

（9）table

9.1 创建一个空表

 --1.创建一个空表

 local tab1 = {}

9.2 初始化表，且遍历表

 --2.直接初始化表

 local tal2 = {"apple", "pear", "orange", "grape"}

 --遍历表

 for k, v in pairs(tal2) do

     print("key", k, ": value", v)

 end

 --执行结果

 --[[

 key    1    : value    apple

 key    2    : value    pear

 key    3    : value    orange

 key    4    : value    grape

 ]]

9.3 关联数组，数组的索引可以是数字或字符串

 array = {}

 array["key"] = "value"

 key = ;

 array[key] =

 array[key] = array[key] + ;

 for k, v in pairs(array) do

     print(k .. " : " .. v)

 end

 --执行结果

 --[[

 key : value

 10 : 31

 --]]

 ar = {}

 for i = ,  do

     ar[i] = i

 end

 ar["key"] = "val"

 print(ar["key"])

 print(ar["none"])

 for k, v in pairs(ar) do

     print(k .. " : " .. v)

 end

 --执行结果

 --[[

 val

 nil

 1 : 1

 2 : 2

 3 : 3

 4 : 4

 5 : 5

 6 : 6

 7 : 7

 8 : 8

 9 : 9

 10 : 10

 key : val

 ]]

9.4 注意观察以上几个示例，Lua里表的初始索引一般以1开始。不同于其他语言把0作为数组的开始索引。

 local tbl = {"apple", "pear", "orange", "grape"}

 for key, val in pairs(tbl) do

     print("Key", key)

 end

 --执行结果

 --[[

 Key    1

 Key    2

 Key    3

 Key    4

 ]]

9.5 表的值置为nil，表示移除引用。

 --当我们定义table a 并设置元素，然后将 a 赋值给 b，则 a 与 b 都指向同一个内存。

 --如果 a 设置为 nil ，则 b 同样能访问 table 的元素。

 --如果没有指定的变量指向a，Lua的垃圾回收机制会清理相对应的内存。

 -- 简单的 table

 mytable = {}

 print("mytable 的类型是 ", type(mytable))

 mytable[] =  "Lua"

 mytable["wow"] = "修改前"

 print("mytable 索引为 1 的元素是 ", mytable[])

 print("mytable 索引为 wow 的元素是 ", mytable["wow"])

 -- alternatetable和mytable的是指同一个 table

 alternatetable = mytable

 print("alternatetable 索引为 1 的元素是 ", alternatetable[])

 print("mytable 索引为 wow 的元素是 ", alternatetable["wow"])

 alternatetable["wow"] = "修改后"

 print("mytable 索引为 wow 的元素是 ", mytable["wow"])

 -- 释放变量

 mytable = nil

 print("mytable 是 ", mytable)

 --print("mytable[1]", mytable[1]) --> syntax error

 -- alternatetable 仍然可以访问

 print("alternatetable 索引为 wow 的元素是 ", alternatetable["wow"])

 alternatetable = nil

 print("alternatetable 是 ", alternatetable)

 --执行结果

 --[[

 mytable 的类型是     table

 mytable 索引为 1 的元素是     Lua

 mytable 索引为 wow 的元素是     修改前

 alternatetable 索引为 1 的元素是     Lua

 mytable 索引为 wow 的元素是     修改前

 mytable 索引为 wow 的元素是     修改后

 mytable 是     nil

 alternatetable 索引为 wow 的元素是     修改后

 alternatetable 是     nil

 ]]

9.6 表操作

[1] concat方法

 --table.concat (table [, sep [, start [, end]]]):

 --concat是concatenate(连锁, 连接)的缩写.

 --table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开

 fruits = {"banana","orange","apple"}

 -- 返回 table 连接后的字符串

 print("连接后的字符串 ",table.concat(fruits))

 -- 指定连接字符

 print("连接后的字符串 ",table.concat(fruits, ", "))

 -- 指定索引来连接 table

 print("连接后的字符串 ",table.concat(fruits, ", ", , ))

 --执行结果

 --[[

 连接后的字符串     bananaorangeapple

 连接后的字符串     banana, orange, apple

 连接后的字符串     orange, apple

 --]]

[2] 插入和移除

 --table.insert (table, [pos,] value):

 --在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.

 --table.remove (table [, pos])

 --返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。

 fruits = {"banana", "orange", "apple"}

 -- 在末尾插入

 table.insert(fruits, "mango")

 print("索引为 4 的元素为 ", fruits[])

 -- 在索引为 2 的键处插入

 table.insert(fruits, , "grapes")

 print("索引为 2 的元素为 ", fruits[])

 print("最后一个元素为 ", fruits[])

 table.remove(fruits)

 print("移除后, 最后一个元素为 ", fruits[])

 table.remove(fruits, )

 print("移除后, 索引为 1 的元素为  ", fruits[])

 --[[

 索引为 4 的元素为     mango

 索引为 2 的元素为     grapes

 最后一个元素为     mango

 移除后, 最后一个元素为     nil

 移除后, 索引为 1 的元素为      grapes

 --]]

[3] 排序

 -table.sort (table [, comp])

 --对给定的table进行升序排序。

 --3.1 默认排序示例

 fruits = {"banana", "orange", "apple", "grapes", "melon"}

 print("排序前")

 for k, v in ipairs(fruits) do

     print(k, v)

 end

 --排序

 table.sort(fruits)

 print("排序后")

 for k, v in ipairs(fruits) do

     print(k, v)

 end

 --执行结果

 --[[

 排序前

 1    banana

 2    orange

 3    apple

 4    grapes

 5    melon

 排序后

 1    apple

 2    banana

 3    grapes

 4    melon

 5    orange

 --]]

 --3.2 键值排序

 local test1 = {a = , f = , d = , c = , b = }

 local key_test = {}

 for val in pairs(test1) do

    table.insert(key_test, val)   --提取test1中的键值插入到key_test表中

 end

 table.sort(key_test)

 for i, v in pairs(key_test) do

    print(v, test1[v])

 end

 --执行结果

 --[[

 a    1

 b    5

 c    8

 d    2

 f    9

 ]]

 --3.3 值排序之数组模式

 local test0 = {, , , , , , , }

 table.sort(test0)  --从小到大排序，默认方式

 for i, v in pairs(test0) do

    io.write(v.." ")

 end

 print("");

 table.sort(test0, function(a, b) return a > b end) --从大到小排序

 for i, v in pairs(test0) do

    io.write(v.." ")

 end

 print(" ")

 --[[

 1 2 3 4 6 7 8 9

 9 8 7 6 4 3 2 1

 ]]

 --3.4 值排序之表单模式

 local test2 =

 {

     {id = , name = "zhao"},

     {id = , name = "liu"},

     {id = , name = "wang"},

     {id = , name = "xi"},

     {id = , name = "qin"},

 }

 table.sort(test2, function(a,b) return a.id < b.id end)

 for i in pairs(test2) do

    print(test2[i].id, test2[i].name)

 end

 --[[

 1    zhao

 2    wang

 5    qin

 8    xi

 9    liu

 ]]

[4] 待续

9.7 计算表长度

 fruits = {"banana", "orange", "apple", "grapes", "melon", nil, "peach"}

 print(#fruits)             --> 7

 print(table.getn(fruits))  --> 7

 local myTable1 = {, , }

 print("table1 length :: ", table.getn(myTable1))   --> 3

 local myTable2 = {, a = , }

 print("table2 length :: ", table.getn(myTable2))   --> 2

 print(myTable2.a)             --> 2

 local myTable3 = {[] = , [] = , [] = }

 print("table3 length :: ", table.getn(myTable3))   --> 3

 local myTable4 = {[] = , [] = , [] = }

 print("table4 length :: ", table.getn(myTable4))   --> 4

 local myTable5 = {[] = , [] = , [] = }

 print("table5 length :: ", table.getn(myTable5))   --> 2

 local myTable6 = {, [] = , }

 print("table6 length :: ", table.getn(myTable6))   --> 3

 local myTable7 = {, nil}

 print("table7 length :: ", table.getn(myTable7))   --> 1

 local myTable8 = {, nil, }

 print("table8 length :: ", table.getn(myTable8))   --> 3

 local myTable9 = {, nil, , nil}

 print("table9 length :: ", table.getn(myTable9))   --> 1

 local myTable10 = {, nil, , nil, , nil}

 print("table10 length :: ", table.getn(myTable10))   --> 3

 local myTable11 = {, nil, , nil, , nil, , nil}

 print("table11 length :: ", table.getn(myTable11))   --> 1

Lua里计算表长度可以使用“#”或者getn接口。示例如下：

你看懂了？你看不懂？难道真看不懂？难道我写错了？

唉~  看不懂就对了。。。。我也看不懂。。。待剖析源码。

9.8 表其他待续

（10）总结

每种数据类型都各有特点，掌握得熟练还需多应用与摸索学习。

【3】总结

Lua是动态类型语言，变量不要类型定义，只需要为变量赋值。值可以存储在变量中，作为参数传递或结果返回。

Good Good Study, Day Day Up.

顺序 选择 循环 总结

Lua数据类型的更多相关文章

  1. lua 数据类型

    lua 数据类型 8 种数据类型 类型 说明 nil 空类型 boolean 布尔类型 number 数值型, 浮点型 string 字符串 function 函数 userdata 用户自定义结构 ...

  2. Lua学习三----------Lua数据类型

    © 版权声明:本文为博主原创文章,转载请注明出处 Lua数据类型 - Lua是动态类型语言,不需要为变量定义类型,只需要为变量赋值 - Lua有8中基本数据类型:nil.boolean.number. ...

  3. lua数据类型与变量

    Lua数据类型与变量 Lua中有  8个基本类型分别为: nil.boolean.number.string.userdata.function.thread和 table. lua变量三种类型:全局 ...

  4. Lua 数据类型和 Redis 数据类型之间转换

    当 Lua 通过 call() 或 pcall() 函数执行 Redis 命令的时候,命令的返回值会被转换成 Lua 数据结构. 同样地,当 Lua 脚本在 Redis 内置的解释器里运行时,Lua ...

  5. 雷林鹏分享：Lua 数据类型

    Lua是动态类型语言,变量不要类型定义,只需要为变量赋值. 值可以存储在变量中,作为参数传递或结果返回. Lua中有8个基本类型分别为:nil.boolean.number.string.userda ...

  6. Lua 学习之基础篇二<Lua 数据类型以及函数库 汇总>

    引言 前面讲了运算符,这里主要对Lua的数据处理相关的数据类型和函数库进行总结归纳,后面会再接着单独分开讲解具体使用. 首先因为Lua 是动态类型语言,变量不要类型定义,只需要为变量赋值. 值可以存储 ...

  7. lua数据类型的的操作(三)

    上一章我们学习了lua的数据类型,以及语法的定义,今天我们学习lua的数据类型操作,其实就是lua库一些api的操作,遇到对数据类型处理时,可以根据lua库提供的操作来实现. 一.字符串操作 1.字符 ...

  8. Lua 与 Redis

    Lua 与 Redis 标签: Java与NoSQL 从 2.6版本 起, Redis 开始支持 Lua 脚本 让开发者自己扩展 Redis - 案例-实现访问频率限制: 实现访问者 $ip 在一定的 ...

  9. Lua 架构 The Lua Architecture

    转载自:http://magicpanda.net/2010/10/lua%E6%9E%B6%E6%9E%84%E6%96%87%E6%A1%A3/ Lua架构文档(翻译) 十 102010 前段时间 ...

随机推荐

  1. 1、python接口测试requests

    import requestsimport jsonr=requests.get('http://www.baidu.com')                        #get 请求方式r=r ...

  2. 洛谷P3567 KUR-Couriers [POI2014] 主席树/莫队

    正解:主席树/莫队 解题报告: 传送门! 这题好像就是个主席树板子题的样子,,,? 毕竟,主席树的最基本的功能就是,维护一段区间内某个数字的个数 但是毕竟是刚get到主席树,然后之前做的一直是第k大, ...

  3. 关于Oxygen版 Eclipse JSP或html 中<option>标签嵌入jstl 如<c:if>出现报错

    Oxygen版 Eclipse JSP或html 中<option>标签嵌入jstl 如<c:if>出现报错 好好的学框架的整合,结果在<option>中加入< ...

  4. explain之key_len计算

    通常在优化SQL查询的时候,我们都会使用explain分析SQL执行计划,通常来说当用到组合索引的时候我们如何判断索引完全用上呢?当然高手看看表结构及SQL语句就知道到底用到了几个字段,对于不熟悉的同 ...

  5. PHP中的回调函数

    回调函数是指调用函数的时候将另一个函数作为参数传递到调用的函数中,而不是传递一个普通的变量作为参数 使用回调函数是为了可以将一段自己定义的功能传到函数内部使用 声明回调函数的方法 变量函数声明 1 2 ...

  6. 用iframe嵌入了一个微信公众号平台文章的URL

    JS: $.ajaxPrefilter( function (options) { if (options.crossDomain && jQuery.support.cors) { ...

  7. 一个toolkit或者一个开源项目如何学习它并使用它

    一个toolkit或者一个开源项目如何学习它并使用它 一般一个流行的toolkit和开源项目,一般都会被广泛地被应用: 那么,我们如何学习它,如何应用它在自己的业务场景中呢? 答案就是:学习源码并借鉴 ...

  8. canvas 写一个刮刮乐抽奖

    <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title> ...

  9. GoWeb-Gin 文件上载

    前些日子,我们Node.JS了一把. 如今,我们还是回到我们伟大的GO来吧 今天,带领大家继续Golang的啦,而且是个上传文件的例子 先给大家看结果 1. 如果是windows端,你需要安装post ...

  10. iOS 新浪微博-3.0 新特性

    每个程序在第一次启动的时候,都会显示新特性.效果如下: 思路: 添加一个ViewController,里面放两个View,一个是UISrollView,另一个pageControl 往UISrollV ...