go学习———结构体应用、字符串的截取、回文字符的判断、break和continue语句

一、结构体应用

定义一个People结构体，具有姓名(name)、年龄(age)、性别（sex）属性。定义 Student结构体，继承的People结构体,并添加(studentId)学号和(professional)专业属性。并且设置Student的 Set()、Get()、学习Study()和比较CompareTo(s1 *Student) bool比较方法，访问权限为私有。

1.实现Stringer接口,自定义输出格式。

2.学习方法只含有一条输出语句并且输出格式为：学生姓名 + “正在学习…”

使用 main 函数测试:

1. 创建两个 Student 结构体指针 student1、student2，赋值并通过比较方法对 比两者是否相同,如果不相同则输出：“两者不相同”
2. 输出 student1,并返回自定义输出格式
3. 调用学生 student2 的study方法。

package main

import (
	"fmt"
)

 //定义一个People结构体类型
  type People struct{
    name string
    age int
    sex int
  }

  //定义一个Student结构体
    type Student struct{
    People  //继承People结构体
    studentId  int
    professional  string
  }

  //用set方法设置属性
  func (s *Student) setName(name string){
    s.name = name
  }

  //用get方法获得属性
  func (s *Student) getName(){
    fmt.Printf("姓名：%s\n",s.name)
  }

  //设置学习study方法使其输出格式为 ： 学生姓名+"正在学习..."
  func (s *Student)study(){
    fmt.Printf("%s 正在学习...\n",s.name)
  }

  //设置CompareTo(s *Student)bool比较方法 访问权限为私有
  //go中根据首字母的大小写来确定可以访问的权限。
  //无论是方法名、常量、变量名还是结构体的名称，
  //如果首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用。
  //可以简单的理解成，首字母大写是公有的，首字母小写是私有的
  func (s *Student)compareTo(ss *Student)bool{
    return *s == *ss
  }

  //实现String接口 自定义输出格式
  func (s *Student)String()string{
      return fmt.Sprintf("name:%s age:%d sex:%d studentId:%d professional:%s\n",s.name,s.age,s.sex,s.studentId,s.professional)
  }
func main() {

    //创建两个Student结构体指针
    //赋值并比较两者是否相等
    //如果不相同则输出："两者不相同"
    s1 := &Student{&People{"哈哈",17,1},123,"go"}
    s2 := &Student{&People{"嘿嘿",17,1},123,"go"}
    if !s1.compareTo(s2){
      fmt.Println("两者不相同")
    }
    //输出s1 并返回自定义格式
    fmt.Println(s1)
    //调用s2 的study方法
    s2.study()
}

二、字符串的截取

1、句子 是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。

给你一个句子 s 和一个整数 k ，请你将 s 截断 ，使截断后的句子仅含 前 k 个单词，返回 截断 s 后得到的句子。

func main() {
	s:="yuanjin is xiao xian nu"
	fmt.Println(truncateSentence(s,2))
}
func truncateSentence(s string, k int) string {
	// 单词个数
	number := 0
	for i, sChar := range s {
		// 如果遇见了空格，说明空格前出现了一个单词
		//（例如：yuanJin is出现了一个空格，空格前出现了1个单词yuanJin）
		if string(sChar) == " " {
			number ++
		}
		// 如果出现的单词个数==你指定的个数k 就把字符串s从这里截断
		if number == k {
		// 你可能这里不懂，你看那个number 当number==k的时候说明达到了要求
		// 比如yuanjin is da sha bi 你number==2的时候想截取的是yuanjin is
		// 这个i是啥，是下标，你把此时的下标赋值给number可以知道是在哪个下标的位置完成了任务。
		// 从而使用s[:number] 在指定下标的位置截断它
			number = i
			break
		}
	}
	return s[:number]
}

三、回文字符串的判断

写一个函数，传入一个字符串判断它是否是回文。
什么叫做回文：一个字符串，所有对称位置的字符相等才叫回文。

func Palindrome(s string) bool {
	// 作为结果判断的依据，初始时true，
	// 如果中途循环中出现了不符合回文的部分，会被修改为false
	result := true
	// len(s)/2 什么叫回文，abccba，abcba这种叫回文，
	// 也就是说你吧长度砍一半进行循环
	// 去让第一个和最后一个，第二个和倒数第二个...去比较
	// 如果你比较到循环结束，说明啥，说明你这一半和另外一半是完全相同的，是符合回文的。
	// 如果中途出现对称位置的字符串不一样，就会修改result为false 然后跳出循环
	// 返回result
	for i := 0; i < len(s)/2; i++ {
		// 如果对称位置的字符串一样，就continue进行下一轮循环，
		// 反之修改为false 并跳出循环，返回函数返回值result
		if string(s[i]) == string(s[len(s)-i-1]) {
			continue
		} else {
			result = false
			break
		}
	}
	return result
}

四、break 和 continue 的用法

【break】

1. 用于循环语句中跳出循环，并开始执行循环之后的语句。
2. break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
3. 在多重循环中，可以用标号 label 标出想 break 的循环。

package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- break ----")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                        fmt.Printf("i2: %d\n", i2)
                        break
                }
        }
//输出结果
i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11

    // 使用标记
    fmt.Println("---- break label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                break re
            }
        }
}
//输出结果
i: 1
i2: 11 

【continue】

1. Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循 环，而是跳过当前循环执行下一次循环语句。

2. for 循环中，执行 continue 语句会触发 for 增量语句的执行。

3. 在多重循环中，可以用标号 label 标出想 continue 的循环。

package main

import "fmt"

func main() {
   /* 定义局部变量 */
   var a int = 10

   /* for 循环 */
   for a < 20 {
      if a == 15 {
         /* 跳过此次循环 */
         a = a + 1;
         continue;
      }
      fmt.Printf("a 的值为 : %d\n", a);
      a++;    
   }  
}

a 的值为 : 10
a 的值为 : 11
a 的值为 : 12
a 的值为 : 13
a 的值为 : 14
a 的值为 : 16
a 的值为 : 17
a 的值为 : 18
a 的值为 : 19

多重循环

package main

import "fmt"

func main() {

    // 不使用标记
    fmt.Println("---- continue ---- ")
    for i := 1; i <= 3; i++ {
        fmt.Printf("i: %d\n", i)
            for i2 := 11; i2 <= 13; i2++ {
                fmt.Printf("i2: %d\n", i2)
                continue
            }
    }
}

i: 1
i2: 11
i2: 12
i2: 13
i: 2
i2: 11
i2: 12
i2: 13
i: 3
i2: 11
i2: 12
i2: 13

 // 使用标记
  package main

 import "fmt"

 func main() {
    fmt.Println("---- continue label ----")
    re:
        for i := 1; i <= 3; i++ {
            fmt.Printf("i: %d\n", i)
                for i2 := 11; i2 <= 13; i2++ {
                    fmt.Printf("i2: %d\n", i2)
                    continue re
                }
        }
}

i: 1
i2: 11
i: 2
i2: 11
i: 3
i2: 11