亲密---我感觉,可以用和人和事处的时间长短,并用心
难?不去做?
前作业:
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}
}