code review 833042: strings.FIelds: slight simplification.

src/pkg/strings/strings.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // A package of simple functions to manipulate strings.
 package strings
 
 import (
         "unicode"
         "utf8"
@@ skipping 143 matching lines @@
 // SplitAfter splits the string s after each instance of sep, returning an array of substrings of s.
 // If sep is empty, SplitAfter splits s after each UTF-8 sequence.
 // If n > 0, SplitAfter splits s into at most n substrings; the last substring will be the unsplit remainder.
 func SplitAfter(s, sep string, n int) []string {
         return genSplit(s, sep, len(sep), n)
 }
 
 // Fields splits the string s around each instance of one or more consecutive white space
 // characters, returning an array of substrings of s or an empty list if s contains only white space.
 func Fields(s string) []string {
+        // First count the fields.
         n := 0
         inField := false
         for _, rune := range s {
                 wasInField := inField
                 inField = !unicode.IsSpace(rune)
                 if inField && !wasInField {
                         n++
                 }
         }
 
+        // Now create them.
         a := make([]string, n)
         na := 0
-        fieldStart := -1
+        fieldStart := -1 // Set to -1 when looking for start of field.
         for i, rune := range s {
                 if unicode.IsSpace(rune) {
                         if fieldStart >= 0 {
                                 a[na] = s[fieldStart:i]
                                 na++
                                 fieldStart = -1
                         }
                 } else if fieldStart == -1 {
                         fieldStart = i
                 }
         }
-        if fieldStart != -1 {
+        if fieldStart != -1 { // Last field might end at EOF.
                 a[na] = s[fieldStart:]
-                na++
         }
-        return a[0:na]
+        return a
 }
 
 // Join concatenates the elements of a to create a single string.   The separator string
 // sep is placed between elements in the resulting string.
 func Join(a []string, sep string) string {
         if len(a) == 0 {
                 return ""
         }
         if len(a) == 1 {
                 return a[0]
@@ skipping 114 matching lines @@
                         }
                         rune, wid = utf8.DecodeRuneInString(s[end-wid : end])
                 }
                 if !unicode.IsSpace(rune) {
                         break
                 }
                 end -= wid
         }
         return s[start:end]
 }