go3

亲密---我感觉,可以用和人和事处的时间长短,并用心

难?不去做?

前作业:

3 . 分布式CAP理论是什么?

了解分布式CAP理论
C: 强一致性,所有节点

4 . 分布式数据库BASE理论是什么?

BASE: 基本可用,最终一致性
简单来说,就是通过让系统,返送对某一时刻一致性的要求,达到

5 . mysql范式, 1,2,3 范式是什么, 逆范式有啥用?

1NF -- 原子性 , 关系数据库自动的
2NF -- 唯一性 , 主键
3NF -- 冗余性约束 , 外键

面试:外键查 , 链表查问得多,毕竟后端
没有外键,也可以链表查?

为了效率,牺牲一些范式,冗余

6 . 事务ACID是什么?

A:原子性,不可分割,要么都执行,要么都不执行
C:一致性,多个事务要保持一致
I:隔离性,多个事务不互相干扰
D:持久性,永久改变

7 . 数据库事务有哪些并发问题,为了解决这些问题,对应哪个隔离级别<
mysql默认的级别有哪些?

脏读:T1读取到了T2未提交的修改的数据
不可重复读:T1没有提交时,读到了T2已经提交事务修改的数据
幻读:T1没有提交时,读到了 T2删除或者增加的字段

隔离级别:
读未提交:上面问题都会出现
读已提交:解决了脏读
可重复读:解决了不可重复读 Mysql默认的级别
串行化: 都解决了,不用--> 把别的都锁死了,效率低

8.分布式应用场景有哪些

分布式存储: mysql,oracle,HDFS(存大量数据TB以上,数据结构复杂(图片,视频什么都有))
分布式缓存: redis, memcache(缓存的,直接到内存,(redis还要给持久化存储到内存),更快,错误率低)
分布式服务: 微服务, SOA
分布式协调: zookeeper (公司里的大脑,集群所有的节点用此管理)
分布式消息队列: mq,kafka
分布式数据平台: storm
分布式等等: solr,Elsearch

作业:

go的面试题, go会的人少,网络能搭就好了,不问的那么细

go

映射,改的是下面的arr()

python是拷贝

mysql也有视图,一样的

len和cap

学新东西如何学?

如果不会的怎么处理?

为什么要看文档,写文档,而不是看视频(来龙去脉)

因为做产品,你要做的是某一部分的.而不是都做了,原理的可能也不需要懂

做技术,追新,而不是别人弄出来了.视频的,来龙去脉都弄出来了,没有价值了,用别人的,别人做出来的为什么会给你用呢!

把所有的gin项目都下载下来(34个),都运行一下,
然后运行,哪个可以运行(10),
然后运行的还有注释(3),再研究

切片

func main(){
    // 创建切片
    // 跟数组区别就是不指定长度
    var s1 []int
    s2 := []int{}  // {} 必须得有值,赋个空
    // := 省略容量,就认为是一样的
    var s3 []int = make([]int ,0)
    var s4 []int = make([]int ,0,0)
    fmt.Println(s1,s2,s3,s4)   //[] [] [] []
}

切片 , 视图修改

func main(){
    arr:= [...]int{0,1,2,3,4,5,6,7}
    fmt.Println("arr[:6]",arr[:6])
    fmt.Println("arr[2:6]",arr[2:6])
    fmt.Println("arr[2:]",arr[2:])
    fmt.Println("arr[:]",arr[:])
}


func main(){
    var s1 []int
    s1 = append(s1,1)
    s1 = append(s1,2,3)
    s1 = append(s1,4,5,6)
    fmt.Println("s1",s1)  //s1 [1 2 3 4 5 6]

    s2 := make([]int,5)
    s2 = append(s2,6)
    fmt.Println(s2)   // [0 0 0 0 0 6]

    //s3:=[]int{1,2,3}

}

切片视图以及len和cap

func main(){
    // go 语言切片是视图的操作
    arr := [...]int{0,1,2,3,4,5,6,7}
    s1 := arr[2:]
    s1[0] = 100
    fmt.Println(s1)  // [100 3 4 5 6 7]

    // 坑
    fmt.Println(arr)  // [0 1 100 3 4 5 6 7]

    s2 := arr[2:6]
    s3 := s2[3:5]
    fmt.Println(s2,s3)  // [100 3 4 5] [5 6]
    // 6哪来的? 也是视图操作, 去arr中取
    // arr中没有的话, panic: runtime error: slice bounds out of range
    //  python 更重于开发,效率高 mvc快 // go 并发高,异步处理好,后端
    // 语法上有区别

    fmt.Println("s2=%v,len(s2)=%d,cap(s2)=%d\n",s2,len(s2),cap(s2))   // %v 类型  cap容量 ,取到最后
    //  [100 3 4 5] 4 6
}

一直切,看视图,不append了

func main(){
    arr := [...]int{0,1,2,3,4,5,6,7}
    s1 := arr[2:6]
    s2 := s1[3:5]
    s3:= append(s2,10)
    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(arr)
    //[2 3 4 5]
    //[5 6]
    //[5 6 10]
    //[0 1 2 3 4 5 6 10]
    s4:= append(s3,11)
    fmt.Println(s4)  // [5 6 10 11]
    fmt.Println(arr)  // [0 1 2 3 4 5 6 10]  //不添加了,容量一直到7 , 替换了10 后来没法添加了

}

copy()

func main(){
    data  := []int{0,1,2,3,4,5,6,7,8,9}
    s1 := data[3:]
    s2 := data[:3]
    fmt.Println(s1,s2)  // [3 4 5 6 7 8 9] [0 1 2]
    // 将第二个切片元素,拷贝到第一个里面
    // 从前面往后面覆盖
    copy(s2,s1)
    fmt.Println("s1",s1)   // s1 [3 4 5 6 7 8 9]
    fmt.Println(s2)  // [3 4 5]
    fmt.Println(data)  // [3 4 5 3 4 5 6 7 8 9]
}

Map : 类似字典

func main(){
    // 1
    var m1 map[int]string
    fmt.Println(m1 == nil)  // true
    // 2
    m2 := map[int]string{}
    m3 := make(map[int]string)   // 和 var一样的
    m4 := make(map[int]string,5)  //指定长度的

    fmt.Println(m1,m2,m3,m4)  // map[] map[] map[] map[]

}

Map 初始化

func main(){
    // 初始化
    var m1 map[int]string = map[int]string{1:"xx",2:"yy",3:"xx",4:"yy",5:"xx",6:"yy"}

    fmt.Println(m1)  // map[1:xx 2:yy] 无序的 , 2:,1:,
    m2:= map[int]string{1:"id",2:"name"}
    m2[1] = "gender"
    m2[3] = "hobby"  //没有的话会追加
    fmt.Println(m2)   // map[1:gender 2:name 3:hobby]

    // 遍历
    for k,v := range m1{
        fmt.Printf("%d--->%s\n",k,v)  //2--->yy   3--->xx
    }

    // 删除 delete()
    delete(m1,3)   // 删除为3的  删除没有的不报错,处理了
    fmt.Println(m1)     // map[1:xx 2:yy 4:yy 5:xx 6:yy]
}

结构体

// 创建一个学生的类
type Student struct{
    id int
    name string
    sex byte
    age int
    addr string
}

func main(){
    // 1. 直接初始化
    var s1 Student = Student{1,"张三",'f',18,"沙河"}  // byte 用单引号
    fmt.Println(s1)

    // 2. 指定初始化成员
    s2 := Student{id:2,age:20}   // {1 张三 102 18 沙河}
    fmt.Println(s2)   // {2  0 20 }
    // 3. 结构体作为指针变量初始化
    var s3 *Student = &Student{3,"李四",'f',20,"沙河"}
    // 取一个字段
    fmt.Println((*s3).id)  //便于知道哪个是指针   // 3
    fmt.Println(s3.id)   // 3

    // 指针和非指针对象区别: 传递出去是引用还是值传递 ..
}

2

// 创建一个学生的类
type Student1 struct{
    id int
    name string
    sex string
    age int
    addr string
}
// 定义普通传递
func tmpStudent1(tmp Student1){
    tmp.id = 111
    fmt.Println("tmp=",tmp)
}


// 定义指针传递
func tmpStudent2(p *Student1){
    p.id = 222
    fmt.Println("p=",p)
}


func main(){
    // 1. 直接初始化
    var s1 Student1 = Student1{1,"张三","f",18,"沙河"}  // byte 用单引号
    tmpStudent1(s1)
    fmt.Println(s1)
    //tmp= {111 张三 f 18 沙河}
    //{1 张三 f 18 沙河}

    tmpStudent2(&s1)
    fmt.Println(s1)   // 改了

    //p= &{111 张三 f 18 沙河}
    //{111 张三 f 18 沙河}

    // 2. 指定初始化成员
    s2 := Student1{id:2,age:20}   // {1 张三 102 18 沙河}
    fmt.Println(s2)   // {2  0 20 }
    // 3. 结构体作为指针变量初始化
    var s3 *Student1 = &Student1{3,"李四","f",20,"沙河"}
    // 取一个字段
    fmt.Println((*s3).id)  //便于知道哪个是指针   // 3
    fmt.Println(s3.id)   // 3
    
    // 指针和非指针对象区别: 传递出去是引用还是值传递 ..
}

面向对象

继承

// 人
type Person struct {
    name string
    sex string
    age int
}
type Student2 struct {
    //
    Person   //继承
    id int
    addr string
}
func main(){
    // 给继承的对象赋值
    s1 := Student2{Person{"张三","female",20},1,"北京"}
    s2 := Student2{Person:Person{name:"李四"},id:2}
    fmt.Println(s1)  // {{张三 female 20} 1 北京}
    fmt.Println(s2)   // {{李四  0} 2 }
}

同名

type Student2 struct {
    // 匿名字段
    Person   //继承
    id int
    addr string

    // 同名字段
    name string
}
func main(){
var s Student2
    s.name = "zs"
    fmt.Println(s)   //{{  0} 0  zs}
    //为父类字段赋值
    s.Person.name= "王五"   
    fmt.Println(s)   // {{王五  0} 0  zs}
}

自定义类型

package main
// 人
type Person3 struct {
    name string
    sex string
    age int
}

// 基础类型
type mystr string

type Student3 struct {
    Person3   //自定义类型
    mystr  //自定义类型
    int   //内置类型
} 

func main(){
    
}
//用法和上面是一样的

指针类型的匿名字段

type Person4 struct {
    name string
    sex string
    age int
}

type Studnet4 struct {
    *Person4
    id int
    addr string
}
func main(){
    // 指针类型的匿名字段
    s1 := Studnet4{&Person4{"zs","female",11,},1,"shahe"}
    fmt.Println(s1)    // {0xc00005c360 1 shahe}
    fmt.Println(s1.name)     //zs

}

• 给string提供mystr,

面向对象方法

type MyInt int

// 传统定义方式
func Add(a,b MyInt)MyInt{
    return a+b
}
// 面向对象的定义方式

func (a MyInt) Add(b MyInt) MyInt{
    return a+b
}

func main(){
    var a MyInt = 1
    var b MyInt = 2
    fmt.Println("Add(a,b)=",Add(a,b))   // Add(a,b)= 3  //面向过程其实
    fmt.Println("a.Add(b)", a.Add(b))   // a.Add(b) 3   //面向对象
}

面向对象自定义类型

// 结构体作为接收者
type Person5 struct {
    name string
    sex string
    age int
}

type Studnet5 struct {
    Person5
    id int
    addr string
}
// 算是封装了
func (p Person5) testxx(){
    fmt.Println(p.name,p.sex)   // p是别名
}
func main(){
    s1 := Studnet5{Person5{"zhang","f",11},1,"shahe"}
    s1.testxx()  // zhang f
}

中国和美国, 相差五年, 看5年前的美国,参考一点 ---或者可以研究一下(火了比较稳得),刚火的,机会更大了.但是一阵

ios 和 Android相当简单,不用写前端,后台传数据,.但是也容易被替代,刚开始20.然后现在不行了. 学技术不要学太简单的,容易被换

未来的三驾马车:java 大数据 go 区块链 python 人工智能
基础语言之上的

20万 python 百万级的数据 用java

// 引用语义
func (p *Person6) setInfoPointer(){
    (*p).name = "zhangsan"
    p.sex = "f"
    p.age = 22
    fmt.Println(p.name,p.sex,p.age)   // p是别名
}

//值语义
func (p Person6) setInfoValue(){
    p.name = "zhangsan"
    p.sex = "f"
    p.age = 23
    fmt.Println(p.name,p.sex,p.age)   // p是别名
}
func main(){
    p1 := Studnet6{Person6{"zhang","f",11},1,"shahe"}
    fmt.Println("方法调用前=",p1)
    (&p1).setInfoPointer()
    fmt.Println("方法调用后=",p1)


    p2 := Studnet6{Person6{"san","f",21},1,"shahe"}
    fmt.Println("方法调用前=",p2)
    p2.setInfoValue()
    fmt.Println("方法调用后=",p2)

    //方法调用前= {{zhang f 11} 1 shahe}
    //zhangsan f 22
    //方法调用后= {{zhangsan f 22} 1 shahe}
    //方法调用前= {{san f 21} 1 shahe}
    //zhangsan f 23
    //方法调用后= {{san f 21} 1 shahe}
}

原文地址：https://www.cnblogs.com/Doner/p/11393674.html