diff --git a/cache/memory.go b/cache/memory.go
index b90d227c..0233be7d 100644
--- a/cache/memory.go
+++ b/cache/memory.go
@@ -202,7 +202,7 @@ func (bc *MemoryCache) vaccuum() {
 		if bc.items == nil {
 			return
 		}
-		for name, _ := range bc.items {
+		for name := range bc.items {
 			bc.item_expired(name)
 		}
 	}
diff --git a/orm/db.go b/orm/db.go
index 10f65fee..060d83bc 100644
--- a/orm/db.go
+++ b/orm/db.go
@@ -324,7 +324,7 @@ func (d *dbBase) Read(q dbQuerier, mi *modelInfo, ind reflect.Value, tz *time.Lo
 	query := fmt.Sprintf("SELECT %s%s%s FROM %s%s%s WHERE %s%s%s = ?", Q, sels, Q, Q, mi.table, Q, Q, wheres, Q)
 
 	refs := make([]interface{}, colsNum)
-	for i, _ := range refs {
+	for i := range refs {
 		var ref interface{}
 		refs[i] = &ref
 	}
@@ -423,7 +423,7 @@ func (d *dbBase) InsertValue(q dbQuerier, mi *modelInfo, isMulti bool, names []s
 	Q := d.ins.TableQuote()
 
 	marks := make([]string, len(names))
-	for i, _ := range marks {
+	for i := range marks {
 		marks[i] = "?"
 	}
 
@@ -693,7 +693,7 @@ func (d *dbBase) DeleteBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Con
 	}
 
 	marks := make([]string, len(args))
-	for i, _ := range marks {
+	for i := range marks {
 		marks[i] = "?"
 	}
 	sql := fmt.Sprintf("IN (%s)", strings.Join(marks, ", "))
@@ -824,7 +824,7 @@ func (d *dbBase) ReadBatch(q dbQuerier, qs *querySet, mi *modelInfo, cond *Condi
 	}
 
 	refs := make([]interface{}, colsNum)
-	for i, _ := range refs {
+	for i := range refs {
 		var ref interface{}
 		refs[i] = &ref
 	}
@@ -964,7 +964,7 @@ func (d *dbBase) GenerateOperatorSql(mi *modelInfo, fi *fieldInfo, operator stri
 	switch operator {
 	case "in":
 		marks := make([]string, len(params))
-		for i, _ := range marks {
+		for i := range marks {
 			marks[i] = "?"
 		}
 		sql = fmt.Sprintf("IN (%s)", strings.Join(marks, ", "))
@@ -1460,7 +1460,7 @@ func (d *dbBase) ReadValues(q dbQuerier, qs *querySet, mi *modelInfo, cond *Cond
 	}
 
 	refs := make([]interface{}, len(cols))
-	for i, _ := range refs {
+	for i := range refs {
 		var ref interface{}
 		refs[i] = &ref
 	}
diff --git a/orm/models_test.go b/orm/models_test.go
index 1a92ef5d..6ca9590c 100644
--- a/orm/models_test.go
+++ b/orm/models_test.go
@@ -242,14 +242,14 @@ type User struct {
 
 func (u *User) TableIndex() [][]string {
 	return [][]string{
-		[]string{"Id", "UserName"},
-		[]string{"Id", "Created"},
+		{"Id", "UserName"},
+		{"Id", "Created"},
 	}
 }
 
 func (u *User) TableUnique() [][]string {
 	return [][]string{
-		[]string{"UserName", "Email"},
+		{"UserName", "Email"},
 	}
 }
 
@@ -287,7 +287,7 @@ type Post struct {
 
 func (u *Post) TableIndex() [][]string {
 	return [][]string{
-		[]string{"Id", "Created"},
+		{"Id", "Created"},
 	}
 }
 
diff --git a/orm/orm_raw.go b/orm/orm_raw.go
index 1393d414..1452d6fc 100644
--- a/orm/orm_raw.go
+++ b/orm/orm_raw.go
@@ -585,7 +585,7 @@ func (o *rawSet) readValues(container interface{}, needCols []string) (int64, er
 
 				cols = columns
 				refs = make([]interface{}, len(cols))
-				for i, _ := range refs {
+				for i := range refs {
 					var ref sql.NullString
 					refs[i] = &ref
 
@@ -711,7 +711,7 @@ func (o *rawSet) queryRowsTo(container interface{}, keyCol, valueCol string) (in
 			} else {
 				cols = columns
 				refs = make([]interface{}, len(cols))
-				for i, _ := range refs {
+				for i := range refs {
 					if keyCol == cols[i] {
 						keyIndex = i
 					}
diff --git a/orm/orm_test.go b/orm/orm_test.go
index e1c8e0f0..14eadabd 100644
--- a/orm/orm_test.go
+++ b/orm/orm_test.go
@@ -586,29 +586,29 @@ func TestInsertTestData(t *testing.T) {
 	throwFail(t, AssertIs(id, 4))
 
 	tags := []*Tag{
-		&Tag{Name: "golang", BestPost: &Post{Id: 2}},
-		&Tag{Name: "example"},
-		&Tag{Name: "format"},
-		&Tag{Name: "c++"},
+		{Name: "golang", BestPost: &Post{Id: 2}},
+		{Name: "example"},
+		{Name: "format"},
+		{Name: "c++"},
 	}
 
 	posts := []*Post{
-		&Post{User: users[0], Tags: []*Tag{tags[0]}, Title: "Introduction", Content: `Go is a new language. Although it borrows ideas from existing languages, it has unusual properties that make effective Go programs different in character from programs written in its relatives. A straightforward translation of a C++ or Java program into Go is unlikely to produce a satisfactory result—Java programs are written in Java, not Go. On the other hand, thinking about the problem from a Go perspective could produce a successful but quite different program. In other words, to write Go well, it's important to understand its properties and idioms. It's also important to know the established conventions for programming in Go, such as naming, formatting, program construction, and so on, so that programs you write will be easy for other Go programmers to understand.
+		{User: users[0], Tags: []*Tag{tags[0]}, Title: "Introduction", Content: `Go is a new language. Although it borrows ideas from existing languages, it has unusual properties that make effective Go programs different in character from programs written in its relatives. A straightforward translation of a C++ or Java program into Go is unlikely to produce a satisfactory result—Java programs are written in Java, not Go. On the other hand, thinking about the problem from a Go perspective could produce a successful but quite different program. In other words, to write Go well, it's important to understand its properties and idioms. It's also important to know the established conventions for programming in Go, such as naming, formatting, program construction, and so on, so that programs you write will be easy for other Go programmers to understand.
 This document gives tips for writing clear, idiomatic Go code. It augments the language specification, the Tour of Go, and How to Write Go Code, all of which you should read first.`},
-		&Post{User: users[1], Tags: []*Tag{tags[0], tags[1]}, Title: "Examples", Content: `The Go package sources are intended to serve not only as the core library but also as examples of how to use the language. Moreover, many of the packages contain working, self-contained executable examples you can run directly from the golang.org web site, such as this one (click on the word "Example" to open it up). If you have a question about how to approach a problem or how something might be implemented, the documentation, code and examples in the library can provide answers, ideas and background.`},
-		&Post{User: users[1], Tags: []*Tag{tags[0], tags[2]}, Title: "Formatting", Content: `Formatting issues are the most contentious but the least consequential. People can adapt to different formatting styles but it's better if they don't have to, and less time is devoted to the topic if everyone adheres to the same style. The problem is how to approach this Utopia without a long prescriptive style guide.
+		{User: users[1], Tags: []*Tag{tags[0], tags[1]}, Title: "Examples", Content: `The Go package sources are intended to serve not only as the core library but also as examples of how to use the language. Moreover, many of the packages contain working, self-contained executable examples you can run directly from the golang.org web site, such as this one (click on the word "Example" to open it up). If you have a question about how to approach a problem or how something might be implemented, the documentation, code and examples in the library can provide answers, ideas and background.`},
+		{User: users[1], Tags: []*Tag{tags[0], tags[2]}, Title: "Formatting", Content: `Formatting issues are the most contentious but the least consequential. People can adapt to different formatting styles but it's better if they don't have to, and less time is devoted to the topic if everyone adheres to the same style. The problem is how to approach this Utopia without a long prescriptive style guide.
 With Go we take an unusual approach and let the machine take care of most formatting issues. The gofmt program (also available as go fmt, which operates at the package level rather than source file level) reads a Go program and emits the source in a standard style of indentation and vertical alignment, retaining and if necessary reformatting comments. If you want to know how to handle some new layout situation, run gofmt; if the answer doesn't seem right, rearrange your program (or file a bug about gofmt), don't work around it.`},
-		&Post{User: users[2], Tags: []*Tag{tags[3]}, Title: "Commentary", Content: `Go provides C-style /* */ block comments and C++-style // line comments. Line comments are the norm; block comments appear mostly as package comments, but are useful within an expression or to disable large swaths of code.
+		{User: users[2], Tags: []*Tag{tags[3]}, Title: "Commentary", Content: `Go provides C-style /* */ block comments and C++-style // line comments. Line comments are the norm; block comments appear mostly as package comments, but are useful within an expression or to disable large swaths of code.
 The program—and web server—godoc processes Go source files to extract documentation about the contents of the package. Comments that appear before top-level declarations, with no intervening newlines, are extracted along with the declaration to serve as explanatory text for the item. The nature and style of these comments determines the quality of the documentation godoc produces.`},
 	}
 
 	comments := []*Comment{
-		&Comment{Post: posts[0], Content: "a comment"},
-		&Comment{Post: posts[1], Content: "yes"},
-		&Comment{Post: posts[1]},
-		&Comment{Post: posts[1]},
-		&Comment{Post: posts[2]},
-		&Comment{Post: posts[2]},
+		{Post: posts[0], Content: "a comment"},
+		{Post: posts[1], Content: "yes"},
+		{Post: posts[1]},
+		{Post: posts[1]},
+		{Post: posts[2]},
+		{Post: posts[2]},
 	}
 
 	for _, tag := range tags {
@@ -1248,7 +1248,7 @@ func TestQueryM2M(t *testing.T) {
 	post := Post{Id: 4}
 	m2m := dORM.QueryM2M(&post, "Tags")
 
-	tag1 := []*Tag{&Tag{Name: "TestTag1"}, &Tag{Name: "TestTag2"}}
+	tag1 := []*Tag{{Name: "TestTag1"}, {Name: "TestTag2"}}
 	tag2 := &Tag{Name: "TestTag3"}
 	tag3 := []interface{}{&Tag{Name: "TestTag4"}}
 
@@ -1311,7 +1311,7 @@ func TestQueryM2M(t *testing.T) {
 
 	m2m = dORM.QueryM2M(&tag, "Posts")
 
-	post1 := []*Post{&Post{Title: "TestPost1"}, &Post{Title: "TestPost2"}}
+	post1 := []*Post{{Title: "TestPost1"}, {Title: "TestPost2"}}
 	post2 := &Post{Title: "TestPost3"}
 	post3 := []interface{}{&Post{Title: "TestPost4"}}
 
diff --git a/orm/utils.go b/orm/utils.go
index df6147c1..88168763 100644
--- a/orm/utils.go
+++ b/orm/utils.go
@@ -195,7 +195,7 @@ func snakeString(s string) string {
 		}
 		data = append(data, d)
 	}
-	return strings.ToLower(string(data[:len(data)]))
+	return strings.ToLower(string(data[:]))
 }
 
 // camel string, xx_yy to XxYy
@@ -220,7 +220,7 @@ func camelString(s string) string {
 		}
 		data = append(data, d)
 	}
-	return string(data[:len(data)])
+	return string(data[:])
 }
 
 type argString []string
diff --git a/router.go b/router.go
index b9d649a2..c1bda637 100644
--- a/router.go
+++ b/router.go
@@ -88,7 +88,7 @@ func (l *logFilter) Filter(ctx *beecontext.Context) bool {
 	if requestPath == "/favicon.ico" || requestPath == "/robots.txt" {
 		return true
 	}
-	for prefix, _ := range StaticDir {
+	for prefix := range StaticDir {
 		if strings.HasPrefix(requestPath, prefix) {
 			return true
 		}
@@ -171,7 +171,7 @@ func (p *ControllerRegistor) Add(pattern string, c ControllerInterface, mappingM
 			p.addToRouter(m, pattern, route)
 		}
 	} else {
-		for k, _ := range methods {
+		for k := range methods {
 			if k == "*" {
 				for _, m := range HTTPMETHOD {
 					p.addToRouter(m, pattern, route)
@@ -332,7 +332,7 @@ func (p *ControllerRegistor) AddMethod(method, pattern string, f FilterFunc) {
 		methods[strings.ToUpper(method)] = strings.ToUpper(method)
 	}
 	route.methods = methods
-	for k, _ := range methods {
+	for k := range methods {
 		if k == "*" {
 			for _, m := range HTTPMETHOD {
 				p.addToRouter(m, pattern, route)
diff --git a/session/memcache/sess_memcache.go b/session/memcache/sess_memcache.go
index 5827a0a9..24aecb82 100644
--- a/session/memcache/sess_memcache.go
+++ b/session/memcache/sess_memcache.go
@@ -179,7 +179,6 @@ func (rp *MemProvider) SessionRegenerate(oldsid, sid string) (session.SessionSto
 	} else {
 		client.Delete(oldsid)
 		item.Key = sid
-		item.Value = item.Value
 		item.Expiration = int32(rp.maxlifetime)
 		client.Set(item)
 		contain = item.Value
diff --git a/session/sess_mem.go b/session/sess_mem.go
index 627a3246..dd066703 100644
--- a/session/sess_mem.go
+++ b/session/sess_mem.go
@@ -1,199 +1,199 @@
-// Copyright 2014 beego Author. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package session
-
-import (
-	"container/list"
-	"net/http"
-	"sync"
-	"time"
-)
-
-var mempder = &MemProvider{list: list.New(), sessions: make(map[string]*list.Element)}
-
-// memory session store.
-// it saved sessions in a map in memory.
-type MemSessionStore struct {
-	sid          string                      //session id
-	timeAccessed time.Time                   //last access time
-	value        map[interface{}]interface{} //session store
-	lock         sync.RWMutex
-}
-
-// set value to memory session
-func (st *MemSessionStore) Set(key, value interface{}) error {
-	st.lock.Lock()
-	defer st.lock.Unlock()
-	st.value[key] = value
-	return nil
-}
-
-// get value from memory session by key
-func (st *MemSessionStore) Get(key interface{}) interface{} {
-	st.lock.RLock()
-	defer st.lock.RUnlock()
-	if v, ok := st.value[key]; ok {
-		return v
-	} else {
-		return nil
-	}
-}
-
-// delete in memory session by key
-func (st *MemSessionStore) Delete(key interface{}) error {
-	st.lock.Lock()
-	defer st.lock.Unlock()
-	delete(st.value, key)
-	return nil
-}
-
-// clear all values in memory session
-func (st *MemSessionStore) Flush() error {
-	st.lock.Lock()
-	defer st.lock.Unlock()
-	st.value = make(map[interface{}]interface{})
-	return nil
-}
-
-// get this id of memory session store
-func (st *MemSessionStore) SessionID() string {
-	return st.sid
-}
-
-// Implement method, no used.
-func (st *MemSessionStore) SessionRelease(w http.ResponseWriter) {
-}
-
-type MemProvider struct {
-	lock        sync.RWMutex             // locker
-	sessions    map[string]*list.Element // map in memory
-	list        *list.List               // for gc
-	maxlifetime int64
-	savePath    string
-}
-
-// init memory session
-func (pder *MemProvider) SessionInit(maxlifetime int64, savePath string) error {
-	pder.maxlifetime = maxlifetime
-	pder.savePath = savePath
-	return nil
-}
-
-// get memory session store by sid
-func (pder *MemProvider) SessionRead(sid string) (SessionStore, error) {
-	pder.lock.RLock()
-	if element, ok := pder.sessions[sid]; ok {
-		go pder.SessionUpdate(sid)
-		pder.lock.RUnlock()
-		return element.Value.(*MemSessionStore), nil
-	} else {
-		pder.lock.RUnlock()
-		pder.lock.Lock()
-		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
-		element := pder.list.PushBack(newsess)
-		pder.sessions[sid] = element
-		pder.lock.Unlock()
-		return newsess, nil
-	}
-}
-
-// check session store exist in memory session by sid
-func (pder *MemProvider) SessionExist(sid string) bool {
-	pder.lock.RLock()
-	defer pder.lock.RUnlock()
-	if _, ok := pder.sessions[sid]; ok {
-		return true
-	} else {
-		return false
-	}
-}
-
-// generate new sid for session store in memory session
-func (pder *MemProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
-	pder.lock.RLock()
-	if element, ok := pder.sessions[oldsid]; ok {
-		go pder.SessionUpdate(oldsid)
-		pder.lock.RUnlock()
-		pder.lock.Lock()
-		element.Value.(*MemSessionStore).sid = sid
-		pder.sessions[sid] = element
-		delete(pder.sessions, oldsid)
-		pder.lock.Unlock()
-		return element.Value.(*MemSessionStore), nil
-	} else {
-		pder.lock.RUnlock()
-		pder.lock.Lock()
-		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
-		element := pder.list.PushBack(newsess)
-		pder.sessions[sid] = element
-		pder.lock.Unlock()
-		return newsess, nil
-	}
-}
-
-// delete session store in memory session by id
-func (pder *MemProvider) SessionDestroy(sid string) error {
-	pder.lock.Lock()
-	defer pder.lock.Unlock()
-	if element, ok := pder.sessions[sid]; ok {
-		delete(pder.sessions, sid)
-		pder.list.Remove(element)
-		return nil
-	}
-	return nil
-}
-
-// clean expired session stores in memory session
-func (pder *MemProvider) SessionGC() {
-	pder.lock.RLock()
-	for {
-		element := pder.list.Back()
-		if element == nil {
-			break
-		}
-		if (element.Value.(*MemSessionStore).timeAccessed.Unix() + pder.maxlifetime) < time.Now().Unix() {
-			pder.lock.RUnlock()
-			pder.lock.Lock()
-			pder.list.Remove(element)
-			delete(pder.sessions, element.Value.(*MemSessionStore).sid)
-			pder.lock.Unlock()
-			pder.lock.RLock()
-		} else {
-			break
-		}
-	}
-	pder.lock.RUnlock()
-}
-
-// get count number of memory session
-func (pder *MemProvider) SessionAll() int {
-	return pder.list.Len()
-}
-
-// expand time of session store by id in memory session
-func (pder *MemProvider) SessionUpdate(sid string) error {
-	pder.lock.Lock()
-	defer pder.lock.Unlock()
-	if element, ok := pder.sessions[sid]; ok {
-		element.Value.(*MemSessionStore).timeAccessed = time.Now()
-		pder.list.MoveToFront(element)
-		return nil
-	}
-	return nil
-}
-
-func init() {
-	Register("memory", mempder)
-}
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package session
+
+import (
+	"container/list"
+	"net/http"
+	"sync"
+	"time"
+)
+
+var mempder = &MemProvider{list: list.New(), sessions: make(map[string]*list.Element)}
+
+// memory session store.
+// it saved sessions in a map in memory.
+type MemSessionStore struct {
+	sid          string                      //session id
+	timeAccessed time.Time                   //last access time
+	value        map[interface{}]interface{} //session store
+	lock         sync.RWMutex
+}
+
+// set value to memory session
+func (st *MemSessionStore) Set(key, value interface{}) error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	st.value[key] = value
+	return nil
+}
+
+// get value from memory session by key
+func (st *MemSessionStore) Get(key interface{}) interface{} {
+	st.lock.RLock()
+	defer st.lock.RUnlock()
+	if v, ok := st.value[key]; ok {
+		return v
+	} else {
+		return nil
+	}
+}
+
+// delete in memory session by key
+func (st *MemSessionStore) Delete(key interface{}) error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	delete(st.value, key)
+	return nil
+}
+
+// clear all values in memory session
+func (st *MemSessionStore) Flush() error {
+	st.lock.Lock()
+	defer st.lock.Unlock()
+	st.value = make(map[interface{}]interface{})
+	return nil
+}
+
+// get this id of memory session store
+func (st *MemSessionStore) SessionID() string {
+	return st.sid
+}
+
+// Implement method, no used.
+func (st *MemSessionStore) SessionRelease(w http.ResponseWriter) {
+}
+
+type MemProvider struct {
+	lock        sync.RWMutex             // locker
+	sessions    map[string]*list.Element // map in memory
+	list        *list.List               // for gc
+	maxlifetime int64
+	savePath    string
+}
+
+// init memory session
+func (pder *MemProvider) SessionInit(maxlifetime int64, savePath string) error {
+	pder.maxlifetime = maxlifetime
+	pder.savePath = savePath
+	return nil
+}
+
+// get memory session store by sid
+func (pder *MemProvider) SessionRead(sid string) (SessionStore, error) {
+	pder.lock.RLock()
+	if element, ok := pder.sessions[sid]; ok {
+		go pder.SessionUpdate(sid)
+		pder.lock.RUnlock()
+		return element.Value.(*MemSessionStore), nil
+	} else {
+		pder.lock.RUnlock()
+		pder.lock.Lock()
+		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
+		element := pder.list.PushBack(newsess)
+		pder.sessions[sid] = element
+		pder.lock.Unlock()
+		return newsess, nil
+	}
+}
+
+// check session store exist in memory session by sid
+func (pder *MemProvider) SessionExist(sid string) bool {
+	pder.lock.RLock()
+	defer pder.lock.RUnlock()
+	if _, ok := pder.sessions[sid]; ok {
+		return true
+	} else {
+		return false
+	}
+}
+
+// generate new sid for session store in memory session
+func (pder *MemProvider) SessionRegenerate(oldsid, sid string) (SessionStore, error) {
+	pder.lock.RLock()
+	if element, ok := pder.sessions[oldsid]; ok {
+		go pder.SessionUpdate(oldsid)
+		pder.lock.RUnlock()
+		pder.lock.Lock()
+		element.Value.(*MemSessionStore).sid = sid
+		pder.sessions[sid] = element
+		delete(pder.sessions, oldsid)
+		pder.lock.Unlock()
+		return element.Value.(*MemSessionStore), nil
+	} else {
+		pder.lock.RUnlock()
+		pder.lock.Lock()
+		newsess := &MemSessionStore{sid: sid, timeAccessed: time.Now(), value: make(map[interface{}]interface{})}
+		element := pder.list.PushBack(newsess)
+		pder.sessions[sid] = element
+		pder.lock.Unlock()
+		return newsess, nil
+	}
+}
+
+// delete session store in memory session by id
+func (pder *MemProvider) SessionDestroy(sid string) error {
+	pder.lock.Lock()
+	defer pder.lock.Unlock()
+	if element, ok := pder.sessions[sid]; ok {
+		delete(pder.sessions, sid)
+		pder.list.Remove(element)
+		return nil
+	}
+	return nil
+}
+
+// clean expired session stores in memory session
+func (pder *MemProvider) SessionGC() {
+	pder.lock.RLock()
+	for {
+		element := pder.list.Back()
+		if element == nil {
+			break
+		}
+		if (element.Value.(*MemSessionStore).timeAccessed.Unix() + pder.maxlifetime) < time.Now().Unix() {
+			pder.lock.RUnlock()
+			pder.lock.Lock()
+			pder.list.Remove(element)
+			delete(pder.sessions, element.Value.(*MemSessionStore).sid)
+			pder.lock.Unlock()
+			pder.lock.RLock()
+		} else {
+			break
+		}
+	}
+	pder.lock.RUnlock()
+}
+
+// get count number of memory session
+func (pder *MemProvider) SessionAll() int {
+	return pder.list.Len()
+}
+
+// expand time of session store by id in memory session
+func (pder *MemProvider) SessionUpdate(sid string) error {
+	pder.lock.Lock()
+	defer pder.lock.Unlock()
+	if element, ok := pder.sessions[sid]; ok {
+		element.Value.(*MemSessionStore).timeAccessed = time.Now()
+		pder.list.MoveToFront(element)
+		return nil
+	}
+	return nil
+}
+
+func init() {
+	Register("memory", mempder)
+}
diff --git a/utils/mail.go b/utils/mail.go
index aa219626..4959268c 100644
--- a/utils/mail.go
+++ b/utils/mail.go
@@ -292,7 +292,7 @@ func qpEscape(dest []byte, c byte) {
 	const nums = "0123456789ABCDEF"
 	dest[0] = '='
 	dest[1] = nums[(c&0xf0)>>4]
-	dest[2] = nums[(c&0xf)]
+	dest[2] = nums[(c & 0xf)]
 }
 
 // headerToBytes enumerates the key and values in the header, and writes the results to the IO Writer
diff --git a/utils/pagination/paginator.go b/utils/pagination/paginator.go
index e537f1ad..e813f798 100644
--- a/utils/pagination/paginator.go
+++ b/utils/pagination/paginator.go
@@ -92,18 +92,18 @@ func (p *Paginator) Pages() []int {
 		case page >= pageNums-4 && pageNums > 9:
 			start := pageNums - 9 + 1
 			pages = make([]int, 9)
-			for i, _ := range pages {
+			for i := range pages {
 				pages[i] = start + i
 			}
 		case page >= 5 && pageNums > 9:
 			start := page - 5 + 1
 			pages = make([]int, int(math.Min(9, float64(page+4+1))))
-			for i, _ := range pages {
+			for i := range pages {
 				pages[i] = start + i
 			}
 		default:
 			pages = make([]int, int(math.Min(9, float64(pageNums))))
-			for i, _ := range pages {
+			for i := range pages {
 				pages[i] = i + 1
 			}
 		}
diff --git a/utils/slice.go b/utils/slice.go
index 25032b7f..e413004d 100644
--- a/utils/slice.go
+++ b/utils/slice.go
@@ -51,7 +51,7 @@ func SliceRandList(min, max int) []int {
 	t0 := time.Now()
 	rand.Seed(int64(t0.Nanosecond()))
 	list := rand.Perm(length)
-	for index, _ := range list {
+	for index := range list {
 		list[index] += min
 	}
 	return list
diff --git a/validation/util.go b/validation/util.go
index 249462d4..367da5dc 100644
--- a/validation/util.go
+++ b/validation/util.go
@@ -137,7 +137,7 @@ func getRegFuncs(tag, key string) (vfs []ValidFunc, str string, err error) {
 	if err != nil {
 		return
 	}
-	vfs = []ValidFunc{ValidFunc{"Match", []interface{}{reg, key + ".Match"}}}
+	vfs = []ValidFunc{{"Match", []interface{}{reg, key + ".Match"}}}
 	str = strings.TrimSpace(tag[:index]) + strings.TrimSpace(tag[end+len("/)"):])
 	return
 }