刷脸_百度百科
刷脸是一种电子考勤方式，即通过人脸识别技术进行考勤。人脸识别具有、人脸通类似于以前用的刷卡机、指纹考勤机的东西，只不过是通过人脸识别技术进行考勤或者门禁设置。它是一种基于人的脸部特征信息进行身份认证的。只要把信息采集输入人脸通之后，每次上班刷脸对准人脸通就实现了考勤记录。
刷脸技术背景
人脸识别是一种基于人的相貌特征信息进行身份认证的生物特征识别技术，技术的最大特征是能避免个人信息泄露，并采用非接触的方式进行识别。人脸识别与识别、掌纹识别、识别、骨骼识别、心跳识别等都属于人体生物特征识别技术，都是随着光电技术、、图像处理技术与模式识别等技术的快速发展应运而生的。可以快捷、精准、卫生地进行身份认定；具有不可复制性，即使做了手术，该技术也能从几百项脸部特征中找出“原来的你”。人脸识别系统在世界上的应用已经相当广泛。在中国就已广泛的应用于公安、安全、海关、金融、军队、机场、边防口岸、安防等多个重要行业及领域，以及智能门禁、门锁、考勤、手机、数码相机、智能玩具等民用市场。
刷脸发展优势
取代传统的打卡、刷卡、利大于弊。传统的考勤方式需要员工每天随身携卡，很多员工因早晨时间匆忙而忘记带、而指纹打卡由于接触人多，容易引起细菌交叉感染。传统考勤方式不严密，员工会利用漏洞让同事带打卡，大大降低了员工的工作效率。只要带着自己的一张脸就能完全实现考勤记录，时间还不到一秒钟就解决问题，不会受光线影响更不用担心辨别错误，人脸通机器识别率在95%以上，具有非接触、识别速度快、准确率高不受光线的影响等显著优点，而且避免因按指纹引起一些细菌交叉传染。
某公司开发出了一套世界领先的人脸识别系统，其应用研究已经取得了突破性进展。人脸识别考勤机取代传统的指纹识别系统已经指日可待，以后的上班族极有可能由“刷卡”、“刷手指”变成“刷脸”一族。 2008年，结合国内外人脸识别市场的发展趋势，充分发挥自己在手写识别领域的技术和市场领导者优势，研发出生物识别的关键技术人脸识别技术及相关产品，正式拉开国内人脸识别产业化的序幕。
在全球倡导数字化生活的大环境之下，人们对于“刷脸”需求和热情几乎是与日俱增。中国是拥有世界上第一庞大的大国。人脸识别应用的发展潜力在现阶段的中国显的尤为重要，巨大的人口基数以及越来越频繁的流动性，14亿人口如何充分利用高新技术进行准确的识别，进而在各行业进行广泛应用，是关系到整个国家管理的大话题。如果在ATM机上使用了人脸识别系统，对人们的生活会带来诸多的方便和安全。
刷脸网络用语
网络和生活中常用来说的一句话：你不刷卡，难道刷脸呀？ 形容脸皮厚，常蹭点小便宜的行为。在网络用语中广为流传，也许会成为今后几年的！
刷脸支付系统
芬兰一家企业推出全球首个“刷脸”支付系统。刷脸等身份信息显示出后，在触摸显示屏上点击确认完成交易。无需信用卡、钱包或手机。整个交易过程不超5秒钟。不过，也有人认为，“这点时间，通常也就够你拿出钱包”。
芬兰初创公司Uniqul已为这套基于面部识别技术的“刷脸”支付系统申请专利。
示意图结账时，消费者只需在收银台面对POS机屏幕上的摄像头，系统自动拍照，扫描消费者面部，再把图像与数据库中的存储信息进行对比。消费者面部信息同时与支付系统相关联。等到消费者的身份信息显示出来后，他/她只需在触摸显示屏上点击“OK”确认，全部交易过程即告完成。
《每日邮报》报道称，整个交易过程可在5秒钟内完成，“这点时间，通常也就够你拿出钱包”。
“刷脸”系统目前正在芬兰首都赫尔辛基进行测试。对于安装Uniqul的商户，公司初步计划免费提供终端设备。
Uniqul公司已启动“刷脸”支付系统的注册工作，用户可以通过任何一种支付系统注册，从传统的银行卡到Paypal或Square账户，均可关联自己的Uniqul账户。
Uniqul公司在一份声明中说：“对既要在住处附近购买生活日用品，又要在工作地点购买午餐的上班族而言，这是享用Uniqul便利支付的理想套餐。”
这一支付系统还采用较为罕见的收费模式：个人用户按月支付费用，收费则根据账户所覆盖地域的不同划分等级。以赫尔辛基为例，在选定的支付地点1.6公里半径范围内，每月收费0 .99欧元(约合1.3美元)；覆盖整个城市，每月收费1.99欧元(2.6美元)；覆盖整个城市及邻近郊区，每月收费2.99欧元(3.9美元)。最高级别用户每月收费6.99欧元(9.2美元)，主要针对经常出差、需要“完全摆脱钱包”的人。
随着技术发展，面部识别系统未来将安装在自动提款机上；美国迪博尔德集团公司则正在研发基于面部识别系统的第三方转账平台。
步骤一:结账时，消费者只需在收银台面对POS机屏幕上的摄像头，系统自动拍照，扫描消费者面，再把图像与数据库中的存储信息进行对比。
步骤二:消费者面部信息同时与支付系统相关联，等到消费者的身份信息显示出来后，他/她只需在触摸显示屏上点击“OK”确认，全部交易过程即告完成。
Uniqul公司一名发言人说，“刷脸”支付系统旨在提升交易安全性和速度，其安全系数堪称“军用级别”，甚至能够准确分辨出双胞胎的差别。“当你靠近收银台后，在后台，我们的算法会分析你的生物遗传数据，在数据库中找到你的账户，”他说。
刷脸刷脸神器考勤
魏晓勇是四川大学计算机科学系主任，因在课堂上演示徒手劈砖被网友称为“劈砖教授”。走红后不久，一则“川大点名已开始‘刷脸’”的微博在网上疯传，该神器的发明者便是曾红极一时的川大劈砖教授——魏骁勇。
魏晓勇教授称，这个“刷脸”考勤系统开发的初衷是为教学分析提供数据参考。该系统可以记录每堂课学生坐的位置以及活动，并且能将数据存盘。
“坐在前面的学生与老师的交互关系比较多，学生可以通过老师的眼神、肢体，印证自己的想法，从而得到鼓励。”“我们点名并不是强制出勤的手段，开发系统的初衷最主要是好玩。”魏骁勇介绍，这个考勤系统于2010年开发，2011年3月正式使用，并且已经获得国家专利。
专家：肯定还要其他内置限制条件
“肯定还有其他的内置限制条件”，四川大学计算机科学系主任魏骁勇教授表示，从学科发展来说，在大规模的群体中，单纯依靠人脸，进行个体身份识别的技术，还没成熟到这个程度。
魏骁勇说，这种“刷脸”技术，其实还并不成熟，特别是应用在金融支付领域里，必须保证100%成功率。“小规模范围内的可以实现，我之前发明的“刷脸神器考勤”成功率只有85%，不仅仅是依靠人脸。比如说，班级里面几个玩的好的同学会经常一起坐一起，这都是有规律可循的。像这种大规模群体的引用，肯定还有其他的内置限制条件。”
对该技术，很多网友担心妆不能太浓。魏骁勇回应，脸部识别技术肯定要有特定的限制条件，比如，要有固定的姿势、差异不大的光线等。“和钱有关的，大家都会比较敏感。网上报道出来的消息，没有任何细节透露，我们也不好评判。”
刷脸刷脸测颜值
在这个看脸的时代，网络词汇“”已经被广泛应用于衡量人物的容貌，而测量一个人的颜值高低，使用刷脸APP就能知道。
《刷脸》应用支持拍照或选取已有照片，采用人脸识别技术，智能识别人脸、五官几何位置定位、计算性别、年龄、微笑度等人脸属性，对比脸部黄金比例，从而计算出颜值。具有一定的科学性，但准确性并不高，始终是娱乐成分颇多。
企业信用信息一体机的简介和特点
按模块条件查看
一体机的简介和特点
阅读：1276次
来源：网络媒体
摘要：一体机知识入门-特点-分类篇:简要讲述了一体机的定义以及其分辨率、墨油、消耗功率等内容。以下内容由买购网整理，提供给您参考。
一体机的简介和特点 一体机，是数码速印机的一种，简单而言就是集传真、打印与复印等功能为一体的机器。其影像是通过油墨形成的，而不象复印机是通过碳粉形成。但是在操作及外形上，今天的一体机都象一台典型的复印机。 一体机的工作原理与传统油印机相似，均是通过油墨穿过蜡纸上的细微小孔（小孔组成了与原稿相同的图像），将图像印于纸上。但其蜡纸并非传统油印机上用的蜡纸或扫描蜡纸，而是热敏蜡纸，由一层非常薄的胶片和棉脂合成的。因此，在这些胶片上制作非常细小的孔，这使得它能印出非常精细的高质量印刷品。 1.一体机的分辩率： 通过热敏头，可在高科技材料蜡纸的聚脂胶片上，每英寸长度内可熔穿400个点（小孔），并可在每12点的长度内制出4个字，与热敏传真机的原理相似，但它具有每英寸300-400点的高分辨率和高灵敏度。 2.一体机的油墨： 其所用油墨不同于普通油墨，它由乳化剂将墨、水、油三者由里至外组成颗粒，成为速干油墨。一旦制版完成，就可用数量不多的油墨，印刷几千份纸张。 3.一体机的消耗功率： 印刷品上的油墨下得很快，不需要定影过程。所以一体机消耗的功率也是很低的，机器在等待状态下不需要保持测试或预热，这也节省了能量的消耗，在印刷状态下最大功率消耗仅为220W，而一般的中型复印机要消耗1500w左右的功率。
您可能关心的页面： 、 、 、
相关标签：
免责声明：
凡注明"来源：XXX"的知识/资讯/名人/访谈等文章，均由企业/经销商/用户自行通过本网站系统平台投稿编辑整理发布或转载自其它媒体，仅供学习与参考等非商业用途性质使用，并不代表本网站赞同其观点和对其真实性负责。
如有侵犯您的版权，请联系我们，我们将及时删除。
提交说明：
注册登录发布：
精彩推荐&|&Recommend
1912人关注
1431人关注
1649人关注
1848人关注
1309人关注
按条件查看：
按商城(推荐购物网站)查看：
按模块筛选：
热卖网店：
广东省通信管理局　　希望你看到这篇文章的时候还是在公交车和地铁上正在上下班的时间，我希望我的这篇文章可以让你利用这段时间了解一门语言。当然，希望你不会因为看我的文章而错过站。呵呵。
　　如果你还不了解 Go 语言的语法，还请你移步先看一下上篇&&《》
　　goroutine
　　GoRoutine 主要是使用 go 关键字来调用函数，你还可以使用匿名函数，如下所示：
package mainimport "fmt" func f (msg string) {
fmt.Println (msg)} func main (){
go f ("goroutine")
go func (msg string) {
fmt.Println (msg)
}("going")}
　　我们再来看一个示例，下面的代码中包括很多内容，包括时间处理，随机数处理，还有 goroutine 的代码。如果你熟悉C语言，你应该会很容易理解下面的代码。
　　你可以简单的把 go 关键字调用的函数想像成 pthread_create。下面的代码使用 for 循环创建了 3 个线程，每个线程使用一个随机的 Sleep 时间，然后在 routine ()函数中会输出一些线程执行的时间信息。
package main import "fmt"import "time"import "math/rand" func routine (name string, delay time.Duration) {
t0 := time.Now ()
fmt.Println (name, " start at ", t0)
time.Sleep(delay)
t1 := time.Now ()
fmt.Println (name, " end at ", t1)
fmt.Println (name, " lasted ", t1.Sub(t0))} func main () {
//生成随机种子
rand.Seed (time.Now () .Unix ())
var name string
for i:=0; i&3; i++{
name = fmt.Sprintf("go_%02d", i) //生成 ID
//生成随机等待时间，从0-4秒
go routine (name, time.Duration (rand.Intn (5)) * time.Second)
//让主进程停住，不然主进程退了，goroutine 也就退了
var input string
fmt.Scanln (&input)
fmt.Println ("done")}
　　运行的结果可能是：
2012-11-04 19:46:35.8974894 +0800 +0800go_01
2012-11-04 19:46:35.8974894 +0800 +0800go_02
2012-11-04 19:46:35.8974894 +0800 +0800go_01
2012-11-04 19:46:36.8975894 +0800 +0800go_01
1.0001sgo_02
2012-11-04 19:46:38.8987895 +0800 +0800go_02
3.0013001sgo_00
2012-11-04 19:46:39.8978894 +0800 +0800go_00
　　goroutine 的并发安全性
　　关于 goroutine，我试了一下，无论是 Windows 还是 Linux，基本上来说是用操作系统的线程来实现的。不过，goroutine 有个特性，也就是说，如果一个 goroutine 没有被阻塞，那么别的 goroutine 就不会得到执行。这并不是真正的并发，如果你要真正的并发，你需要在你的 main 函数的第一行加上下面的这段代码：
import "runtime"...runtime.GOMAXPROCS (4)
　　还是让我们来看一个有并发安全性问题的示例（注意：我使用了C的方式来写这段 Go 的程序）
　　这是一个经常出现在教科书里卖票的例子，我启了 5 个 goroutine 来卖票，卖票的函数 sell_tickets 很简单，就是随机的 sleep 一下，然后对全局变量 total_tickets 作减一操作。
package main import "fmt"import "time"import "math/rand"import "runtime" var total_tickets int32 = 10; func sell_tickets (i int){
if total_tickets & 0 { //如果有票就卖
time.Sleep( time.Duration (rand.Intn (5)) * time.Millisecond)
total_tickets-- //卖一张票
fmt.Println ("id:", i, "
ticket:", total_tickets)
}} func main () {
runtime.GOMAXPROCS (4) //我的电脑是 4 核处理器，所以我设置了4
rand.Seed (time.Now () .Unix ()) //生成随机种子
for i := 0; i & 5; i++ { //并发 5 个 goroutine 来卖票
go sell_tickets (i)
//等待线程执行完
var input string
fmt.Scanln (&input)
fmt.Println (total_tickets, "done") //退出时打印还有多少票}
　　这个程序毋庸置疑有并发安全性问题，所以执行起来你会看到下面的结果：
$go run sell_tickets.goid: 0
ticket: 9 id: 0
ticket: 8 id: 4
ticket: 7 id: 1
ticket: 6 id: 3
ticket: 5 id: 0
ticket: 4 id: 3
ticket: 3 id: 2
ticket: 2 id: 0
ticket: 1 id: 3
ticket: 0 id: 1
ticket: -1 id: 4
ticket: -2 id: 2
ticket: -3 id: 0
ticket: -4 -4 done
　　可见，我们需要使用上锁，我们可以使用互斥量来解决这个问题。下面的代码，我只列出了修改过的内容：
package mainimport "fmt"import "time"import "math/rand"import "sync"import "runtime" var total_tickets int32 = 10;var mutex = &sync.Mutex{} //可简写成：var mutex sync.Mutex func sell_tickets (i int){
for total_tickets&0 {
mutex.Lock()
if total_tickets & 0 {
time.Sleep( time.Duration (rand.Intn (5)) * time.Millisecond)
total_tickets--
fmt.Println (i, total_tickets)
mutex.Unlock ()
}}.............
　　原子操作
　　说到并发就需要说说原子操作，相信大家还记得我写的那篇《无锁队列的实现》一文，里面说到了一些 CAS & CompareAndSwap 的操作。Go 语言也支持。你可以看一下相当的文档
　　我在这里就举一个很简单的示例：下面的程序有 10 个 goroutine，每个会对 cnt 变量累加 20 次，所以，最后的 cnt 应该是 200。如果没有 atomic 的原子操作，那么 cnt 将有可能得到一个小于 200 的数。
　　下面使用了 atomic 操作，所以是安全的。
package main import "fmt"import "time"import "sync/atomic" func main () {
var cnt uint32 = 0
for i := 0; i & 10; i++ {
go func () {
for i:=0; i&20; i++ {
time.Sleep(time.Millisecond)
atomic.AddUint32(&cnt, 1)
time.Sleep(time.Second)//等一秒钟等 goroutine 完成
cntFinal := atomic.LoadUint32(&cnt)//取数据
fmt.Println ("cnt:", cntFinal)}
　　这样的函数还有很多，参看 （被墙）
　　Channel 信道
　　Channal 是什么？Channal 就是用来通信的，就像 Unix 下的管道一样，在 Go 中是这样使用 Channel 的。
　　下面的程序演示了一个 goroutine 和主程序通信的例程。这个程序足够简单了。
package main import "fmt" func main () {
//创建一个 string 类型的 channel
channel := make (chan string)
//创建一个 goroutine 向 channel 里发一个字符串
go func () { channel &- "hello" }()
msg := &- channel
fmt.Println (msg)}
　　指定 channel 的 buffer
　　指定 buffer 的大小很简单，看下面的程序：
package mainimport "fmt" func main () {
channel := make (chan string, 2)
go func () {
channel &- "hello"
channel &- "World"
msg1 := &-channel
msg2 := &-channel
fmt.Println (msg1, msg2)}
　　Channel 的阻塞
　　注意，channel 默认上是阻塞的，也就是说，如果 Channel 满了，就阻塞写，如果 Channel 空了，就阻塞读。于是，我们就可以使用这种特性来同步我们的发送和接收端。
　　下面这个例程说明了这一点，代码有点乱，不过我觉得不难理解。
package main import "fmt"import "time" func main () {
channel := make (chan string) //注意: buffer 为1
go func () {
channel &- "hello"
fmt.Println ("write \"hello\" done!")
channel &- "World" //Reader 在 Sleep，这里在阻塞
fmt.Println ("write \"World\" done!")
fmt.Println ("Write go sleep...")
time.Sleep(3*time.Second)
channel &- "channel"
fmt.Println ("write \"channel\" done!")
time.Sleep(2*time.Second)
fmt.Println ("Reader Wake up...")
msg := &-channel
fmt.Println ("Reader: ", msg)
msg = &-channel
fmt.Println ("Reader: ", msg)
msg = &-channel //Writer 在 Sleep，这里在阻塞
fmt.Println ("Reader: ", msg)}
　　上面的代码输出的结果如下：
Reader Wake up...Reader:
hellowrite "hello" done!write "World" done!Write go sleep...Reader:
Worldwrite "channel" done!Reader:
　　Channel 阻塞的这个特性还有一个好处是，可以让我们的 goroutine 在运行的一开始就阻塞在从某个 channel 领任务，这样就可以作成一个类似于线程池一样的东西。关于这个程序我就不写了。我相信你可以自己实现的。
　　多个 Channel 的 select
package mainimport "time"import "fmt" func main () {
//创建两个 channel - c1 c2
c1 := make (chan string)
c2 := make (chan string)
//创建两个 goruntine 来分别向这两个 channel 发送数据
go func () {
time.Sleep(time.Second * 1)
c1 &- "Hello"
go func () {
time.Sleep(time.Second * 1)
c2 &- "World"
//使用 select 来侦听两个 channel
for i := 0; i & 2; i++ {
case msg1 := &-c1:
fmt.Println ("received", msg1)
case msg2 := &-c2:
fmt.Println ("received", msg2)
　　注意：上面的 select 是阻塞的，所以，才搞出 ugly 的 for i &2这种东西。
　　Channel select 阻塞的 Timeout
　　解决上述那个 for 循环的问题，一般有两种方法：一种是阻塞但有 timeout，一种是无阻塞。我们来看看如果给 select 设置上 timeout 的。
timeout_cnt := 0
case msg1 := &-c1:
fmt.Println ("msg1 received", msg1)
case msg2 := &-c2:
fmt.Println ("msg2 received", msg2)
&-time.After (time.Second * 30)：
fmt.Println ("Time Out")
timout_cnt++
if time_cnt & 3 {
　　上面代码中高亮的代码主要是用来让 select 返回的，注意 case 中的 time.After 事件。
　　Channel 的无阻塞
　　好，我们再来看看无阻塞的 channel，其实也很简单，就是在 select 中加入 default，如下所示：
case msg1 := &-c1:
fmt.Println ("received", msg1)
case msg2 := &-c2:
fmt.Println ("received", msg2)
default: //default 会导致无阻塞
fmt.Println ("nothing received!")
time.Sleep(time.Second)
　　Channel 的关闭
　　关闭 Channel 可以通知对方内容发送完了，不用再等了。参看下面的例程：
package main import "fmt"import "time"import "math/rand" func main () {
channel := make (chan string)
rand.Seed (time.Now () .Unix ())
//向 channel 发送随机个数的 message
go func () {
cnt := rand.Intn (10)
fmt.Println ("message cnt :", cnt)
for i:=0; i& i++{
channel &- fmt.Sprintf("message-%2d", i)
close(channel) //关闭 Channel
var more bool = true
var msg string
for more {
//channel 会返回两个值，一个是内容，一个是还有没有内容
case msg, more = &- channel:
fmt.Println (msg)
fmt.Println ("channel closed!")
　　定时器
　　Go 语言中可以使用 time.NewTimer 或 time.NewTicker 来设置一个定时器，这个定时器会绑定在你的当前 channel 中，通过 channel 的阻塞通知机器来通知你的程序。
　　下面是一个 timer 的示例。
package main import "time"import "fmt" func main () {
timer := time.NewTimer (2*time.Second)
&- timer.C
fmt.Println ("timer expired!")}
　　上面的例程看起来像一个 Sleep，是的，不过 Timer 是可以 Stop 的。你需要注意 Timer 只通知一次。如果你要像C中的 Timer 能持续通知的话，你需要使用 Ticker。下面是 Ticker 的例程：
package main import "time"import "fmt" func main () {
ticker := time.NewTicker (time.Second)
for t := range ticker.C {
fmt.Println ("Tick at", t)
　　上面的这个 ticker 会让你程序进入死循环，我们应该放其放在一个 goroutine 中。下面这个程序结合了 timer 和 ticker
package main import "time"import "fmt" func main () {
ticker := time.NewTicker (time.Second)
go func () {
for t := range ticker.C {
fmt.Println (t)
//设置一个 timer，10钞后停掉 ticker
timer := time.NewTimer (10*time.Second)
&- timer.C
ticker.Stop ()
fmt.Println ("timer expired!")}
　　Socket 编程
　　下面是我尝试的一个 Echo Server 的 Socket 代码，感觉还是挺简单的。
　　Server 端
package main import (
"io") const RECV_BUF_LEN = 1024 func main () {
listener, err := net.Listen("tcp", "0.0.0.0:6666")//侦听在 6666 端口
if err != nil {
panic ("error listening:"+err.Error ())
fmt.Println ("Starting the server")
conn, err := listener.Accept() //接受连接
if err != nil {
panic ("Error accept:"+err.Error ())
fmt.Println ("Accepted the Connection :", conn.RemoteAddr ())
go EchoServer (conn)
}} func EchoServer (conn net.Conn) {
buf := make ([]byte, RECV_BUF_LEN)
defer conn.Close()
n, err := conn.Read(buf);
switch err {
conn.Write( buf[0:n] )
case io.EOF:
fmt.Printf("Warning: End of data: %s \n", err);
fmt.Printf("Error: Reading data : %s \n", err);
　　Client 端
package main import (
"net") const RECV_BUF_LEN = 1024 func main () {
conn,err := net.Dial ("tcp", "127.0.0.1:6666")
if err != nil {
panic (err.Error ())
defer conn.Close()
buf := make ([]byte, RECV_BUF_LEN)
for i := 0; i & 5; i++ {
//准备要发送的字符串
msg := fmt.Sprintf("Hello World, %03d", i)
n, err := conn.Write([]byte (msg))
if err != nil {
println ("Write Buffer Error:", err.Error ())
fmt.Println (msg)
//从服务器端收字符串
n, err = conn.Read(buf)
if err !=nil {
println ("Read Buffer Error:", err.Error ())
fmt.Println (string (buf[0:n]))
//等一秒钟
time.Sleep(time.Second)
　　系统调用
　　Go 语言那么C，所以，一定会有一些系统调用。Go 语言主要是通过两个包完成的。一个是 ，一个是 。（注意，链接被墙）
　　这两个包里提供都是 Unix-Like 的系统调用，
syscall 里提供了什么 Chroot/Chmod/Chmod/Chdir&，Getenv/Getgid/Getpid/Getgroups/Getpid/Getppid&，还有很多如 Inotify/Ptrace/Epoll/Socket/&的系统调用。
os 包里提供的东西不多，主要是一个跨平台的调用。它有三个子包，Exec（运行别的命令）， Signal（捕捉信号）和 User（通过 uid 查 name 之类的）
　　syscall 包的东西我不举例了，大家可以看看《Unix 高级环境编程》一书。
　　os 里的取几个例：
　　环境变量
package main import "os"import "strings"
func main () {
os.Setenv ("WEB", "") //设置环境变量
println (os.Getenv ("WEB")) //读出来
for _, env := range os.Environ () { //穷举环境变量
e := strings.Split(env, "=")
println (e[0], "=", e[1])
　　执行命令行
　　下面是一个比较简单的示例
package mainimport "os/exec"import "fmt"func main () {
cmd := exec.Command ("ping", "127.0.0.1")
out, err := cmd.Output ()
if err!=nil {
println ("Command Error!", err.Error ())
fmt.Println (string (out))}
　　正规一点的用来处理标准输入和输出的示例如下：
package main import (
"os/exec") func main () {
cmd := exec.Command ("tr", "a-z", "A-Z")
cmd.Stdin = strings.NewReader ("some input")
var out bytes.Buffer
cmd.Stdout = &out
err := cmd.Run ()
if err != nil {
log.Fatal (err)
fmt.Printf("in all caps: %q\n", out.String ())}
　　命令行参数
　　Go 语言中处理命令行参数很简单：(使用 os 的 Args 就可以了)
func main () {
args := os.Args
fmt.Println (args) //带执行文件的
fmt.Println (args[1:]) //不带执行文件的}
　　在 Windows 下，如果运行结果如下：
　　C:\Projects\Go&go run args.go aaa bbb ccc ddd
　　[C:\Users\haoel\AppData\Local\Temp\go-build\command-line-arguments\_
　　obj\a.out.exe aaa bbb ccc ddd]
　　[aaa bbb ccc ddd]
　　那么，如果我们要搞出一些像 mysql -uRoot -hLocalhost -pPwd 或是像 cc -O3 -Wall -o a a.c 这样的命令行参数我们怎么办？Go 提供了一个 package 叫 flag 可以容易地做到这一点
package mainimport "flag"import "fmt" func main () {
//第一个参数是&参数名&，第二个是&默认值&，第三个是&说明&。返回的是指针
host := flag.String ("host", "", "a host name ")
port := flag.Int("port", 80, "a port number")
debug := flag.Bool ("d", false, "enable/disable debug mode")
//正式开始 Parse 命令行参数
flag.Parse ()
fmt.Println ("host:", *host)
fmt.Println ("port:", *port)
fmt.Println ("debug:", *debug)}
　　执行起来会是这个样子：
#如果没有指定参数名，则使用默认值$ go run flagtest.gohost: port: 80debug: false #指定了参数名后的情况$ go run flagtest.go -host=localhost -port=22 -dhost: localhostport: 22debug: true #用法出错了（如：使用了不支持的参数，参数没有=）$ go build flagtest.go$ ./flagtest -debug -host localhost -port=22flag provided but not defined: -debugUsage of flagtest:
-d=false: enable/disable debug mode
-host="": a host name
-port=80: a port numberexit status 2
　　感觉还是挺不错的吧。
　　一个简单的 HTTP Server
　　代码胜过千言万语。呵呵。这个小程序让我又找回以前用C写 CGI 的时光了。（Go 的官方文档是《》）
package main import (
"net/http"
"io/ioutil"
"path/filepath") const http_root = "/home//" func main () {
http.HandleFunc ("/", rootHandler)
http.HandleFunc ("/view/", viewHandler)
http.HandleFunc ("/html/", htmlHandler)
http.ListenAndServe (":8080", nil)} //读取一些 HTTP 的头func rootHandler (w http.ResponseWriter, r *http.Request) {
fmt.Fprintf (w, "rootHandler: %s\n", r.URL.Path)
fmt.Fprintf (w, "URL: %s\n", r.URL)
fmt.Fprintf (w, "Method: %s\n", r.Method)
fmt.Fprintf (w, "RequestURI: %s\n", r.RequestURI )
fmt.Fprintf (w, "Proto: %s\n", r.Proto)
fmt.Fprintf (w, "HOST: %s\n", r.Host)} //特别的 URL 处理func viewHandler (w http.ResponseWriter, r *http.Request) {
fmt.Fprintf (w, "viewHandler: %s", r.URL.Path)} //一个静态网页的服务示例。（在 http_root 的 html 目录下）func htmlHandler (w http.ResponseWriter, r *http.Request) {
fmt.Printf("htmlHandler: %s\n", r.URL.Path)
filename := http_root + r.URL.Path
fileext := filepath.Ext (filename)
content, err := ioutil.ReadFile (filename)
if err != nil {
fmt.Printf("
404 Not Found!\n")
w.WriteHeader (http.StatusNotFound)
var contype string
switch fileext {
case ".html", "htm":
contype = "text/html"
case ".css":
contype = "text/css"
case ".js":
contype = "application/javascript"
case ".png":
contype = "image/png"
case ".jpg", ".jpeg":
contype = "image/jpeg"
case ".gif":
contype = "image/gif"
contype = "text/plain"
fmt.Printf("ext %s, ct = %s\n", fileext, contype)
w.Header () .Set ("Content-Type", contype)
fmt.Fprintf (w, "%s", content)
　　Go 的功能库有很多，大家自己慢慢看吧。我再吐个槽&&Go 的文档真不好读。例子太少了。
　　先说这么多吧。这是我周末两天学 Go 语言学到的东西，写得太仓促了，而且还有一些东西理解不到位，还大家请指正！