## How to learn payment systems?



![image.png](/static/img/82cac64b721c623bb9fac0667d773a04.image.webp)

## Why is the credit card called “the most profitable product in banks”? How does VISA/Mastercard make money?

The diagram below shows the economics of the credit card payment flow.


![image.png](/static/img/dfdd7c98c1162c1d77a55358f7a00e6b.image.webp)

翻译：

1. 持卡人向商家支付100美元购买产品。

2. 商家通过使用信用卡获得更高的销售额，并需要补偿发卡机构和卡网络提供的支付服务。收单银行与商家设定一个费用，称为“商户折扣费”。

3-4. 收单银行保留0.25美元作为收单利润，而1.75美元支付给发卡银行作为交换费。商户折扣费应覆盖交换费。

交换费由卡网络设定，因为每个发卡银行与每个商家协商费用效率较低。

5. 卡网络与每家银行设定网络评估和费用，银行每月为其服务向卡网络支付费用。例如，VISA每次刷卡收取0.11%的评估费，加上0.0195美元的使用费。

6. 持卡人为发卡银行的服务付费。

> 为什么发卡银行应该得到补偿？

即使持卡人未能支付发卡机构，发卡机构仍会支付商家。
发卡机构在持卡人支付之前先支付给商家。
发卡机构有其他运营成本，包括管理客户账户、提供账单、欺诈检测、风险管理、清算和结算等。

## How does VISA work when we swipe a credit card at a merchatn's shop?


![image.png](/static/img/2e5573c572d13ae610084014d583cae5.image.webp)

VISA、Mastercard和American Express作为卡网络参与资金的清算和结算。收单银行和发卡银行可以是不同的银行，通常也是如此。如果银行不通过中介逐一结算交易，那么每家银行都需要与其他所有银行结算交易。这非常低效。

下图显示了VISA在信用卡支付过程中的作用。涉及两个流程。授权流程发生在客户刷卡时。捕获和结算流程发生在商家在一天结束时想要收款时。

授权流程
* 步骤0：发卡银行向其客户发放信用卡。
* 步骤1：持卡人想要购买产品，并在商家的销售点（POS）终端刷卡。
* 步骤2：POS终端将交易发送给提供POS终端的收单银行。
* 步骤3和4：收单银行将交易发送给卡网络，也称为卡计划。卡网络将交易发送给发卡银行以获取批准。
* 步骤4.1、4.2和4.3：如果交易获得批准，发卡银行冻结资金。批准或拒绝信息被发送回收单银行以及POS终端。

捕获和结算流程
* 步骤1和2：商家在一天结束时想要收款，因此在POS终端上点击“捕获”。交易批量发送给收单银行。收单银行将包含交易的批文件发送给卡网络。
* 步骤3：卡网络对从不同收单银行收集的交易进行清算，并将清算文件发送给不同的发卡银行。
* 步骤4：发卡银行确认清算文件的正确性，并将资金转账给相关的收单银行。
* 步骤5：收单银行然后将资金转账给商家的银行。
* 步骤4：卡网络清理来自不同收单银行的交易。清算是相互抵消的交易进行净额结算的过程，从而减少总交易数量。

在这个过程中，卡网络承担了与每家银行沟通的负担，并收取服务费作为回报。

## Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India

翻译：

什么是UPI？UPI是由印度国家支付公司开发的即时实时支付系统。

目前，它占印度数字零售交易的60%。

UPI = 支付标记语言 + 可互操作支付标准


![image.png](/static/img/6f256138dc0577d3ec7cb324b5fc0fe4.image.webp)

07 Payment systems

## 语法
右边是一个泛型接口，其中类型参数T可以是任务类型


![image.png](/static/img/151eadf4d3c916e9742280e5cc100410.image.webp)




结构体也可以使用泛型
```go
type LinedListV1[T any] struct {
    head *nodeV1[T]
}

func (l *LinkedListV1[T]) Add (idx int, val T) {
    //TODO implement me 
    panic("implement me")
}

func (l *LinkedListV1[T]) Append(val T){
    //TODO implement me 
    panic("implement me")
}

func (l *LinkedListV1[T]) Delete(idx T){
    //TODO implement me 
    panic("implement me ")
}

type NodeV1[T any] struct {
    data T
}

func UseList(){
    l := &LinkedListV1[int]{}
    l.Add(index: 1, val:123)
    l.Add(index: 1, val:"123") //这里会报错
}
```

方法也可以用泛型

```go
package generics

func Sum[T Number](vals []T) T{
    var res T
    for _,v :=range vals{
        res = res + v // 若sum用的是Any，就不能相加，因为数据类型可能是非数字，所以该用Number来检查
    }
    return res
}

type Integer int
type Number interface {
    int | unint
    // 或者int的衍生类型 ~int | unint
}

func UseSum(){
// 必须使用衍生类型的int
    res:=Sum[int]([]int{123, 123})
    println(res)
    resV1 := Sum[Integer]([]Integer{123,123})
    println(res)
}


func Closable[T io.Closer](){
    var t T
    t.Close()
}
```


## 代码演示
[标准实现参考](https://github.com/ecodeclub/ekit/tree/dev/slice)
### 求和
### 求最大值、最小值
```go
func Max[T Number](vals []T) T{
    t:=vals[0]
    for i :=1; i< len(vals);i++ {
        if t <vals[i]{
            t=vals[i]
            }
        }
    return t
}

func Min[T Number](vals []T) T{
    t:=vals[0]
    for i :=1; i< len(vals);i++ {
        if t >vals[i]{
            t=vals[i]
            }
        }
    return t
}

```
### 过滤和查找
```go
func Find[T any](vals []T, filter func(t T)bool) T{
    for _,v :=range vals{
        if filter(v) {
            return v
        }
    }
    var t T
    return t

}

```
### 在切片特定索引位置插入元素
```go
func Insert[T any](ids int, vals []int) {
    if idx <0 || idx >= len(vals) {
        panic("idx 不合法")
    }
    //先扩容
    vas = append(vals, val)
    for i:=len(vals)-1; i>idx; i-- {
        if i-1>=0{
            vals[i]=vals[i-1]
        }
    }
    vals[idx] = val
    return vals
}

//调用使用

package main

import "fmt"

func main(){
    fmt.Printf("%v \n", Insert[int](0, 12, []int{1,2}))
    fmt.Printf("%v \n", Insert[int](2, 12, []int{1,2}))
    fmt.Printf("%v \n", Insert[int](1, 12, []int{1,2}))
}
```

07 Go泛型

## 接口定义
基本语法： type 名字 interface{}
* 里面只能有方法，方法也不需要func关键字


> 什么是接口？：接口是一组行为的抽象
* 尽量用接口，以实现面向接口编程

原则上任务：即便是任务开发，也应该面向接口编程

![image.png](/static/img/7048f9215c1c20fe1942c6d21c4db6e6.image.png)

当你怀疑要不要定义接口的时候，加上去。


## 结构体定义
* 基本语法：
```go
type  Name struct{
    fieldName FieldType
    //....
}
```

![image.png](/static/img/e33b3ff60b6ab42825732472326b697d.image.png)
结构体和结构体的字段都遵循大小写控制访问性的原则。

通过. 这个符号来访问字段或者方法。


## 结构体初始化
* Go没有构造函数
* 初始化语法：struct{}
* 获取指针
    * &struct {}
    * new(Struct)

new可理解为Go会为你的变量分配内存，并且把内存都置为0.


![image.png](/static/img/7939caafefa2b8aef6eb64d7b8c89f0f.image.png)

有两种形态：
* 按照字段名赋值
* 按照字段顺序赋值：不推荐使用，非常不利于后期维护


![image.png](/static/img/35cc67aa5f82ddb166051973f3c83b67.image.png)

## 结构体与指针
go的指针和别的语言的概念一样，本质上都是一个内存地址。
* 和c、c++一样，*表示指针，&取地址
* 如果声明了一个指针，但是没有赋值，那么他是nil。


![image.png](/static/img/5a1ec4d55dd184a98d22a0e94e75e4a9.image.png)
 
 ## 方法接收器
 
 一个方法可以定义在这个结构体上，也可以定义在这个结构体的指针上。
 
 前者叫做结构体接收器，后者叫做指针接收器。
 
 
![image.png](/static/img/66a40e9ccc6512cbe94f392c049de168.image.png)


结构体接收器内部修改字段，不会生效。因为方法调用本身是值传递的。

目前没有统一的说法什么时候用什么接收器，你在初学的时候：遇事不决用指针。

也就是：
* 如果是基本类型，结构体，那么就相当于复制一份了
* 如果是指针，那么就复制了一份指针（也就是地址），但是指向的结构体还是同一个
* 内置类型复制了一份，但是他们的内部数据结构，还是同一个。（初学你就可以这么理解）


![image.png](/static/img/341119a6c3c29a84c261e1ddda25950a.image.png)

## 结构体自引用

如果在结构体内部还要引用自身，那么只能使用指针。

准确来说，在整个引用链上，如果构成循环，那就只能用指针。

如果引用链路很长，你比较难发现这种错误。


![image.png](/static/img/a407f9f8b0d4ca6932b0d95aa8e09dc3.image.png)

## 衍生类型
* 基本语法： type typeA type B

我一般在想使用第三方库，又没有办法修改远吗，又想扩展整个库的结构体的方法的情况下，就用这个。

记住衍生核心：衍生类型是一个全新的类型。

衍生类型可以互相转换，使用（）进行转换

注意：typeB实现了某个接口，不等于TypeA也实现了某个接口


![image.png](/static/img/e8606c4c892f263099a8930f2d25a524.image.png)

## 类型别名
* 基本语法： type TypeA=Type B
    * 别名，除了换了一个名字，没有任何区别
    * 他和衍生类型的区别就是用了=


类型别名一般用在导出类型、兼容性修改里面，也不常见。


![image.png](/static/img/3e892edfef0edc44e313bbf26c04c68e.image.png)


## 结构体实现接口

当看到某个东西走起来像鸭子、有勇气来像鸭子、饺子来也像鸭子，那么这个东西就被称为鸭子。

当一个结构体具备的接口的所有方法的时候，他就实现了这个接口。

![image.png](/static/img/c230ad6733d11d1fd5ad470c7fea831d.image.png)

## 组合
组合是go里面独有的语法概念，基本语法形态是：
```go
type A struct{
    B
}
```
组合可以是以下几种情况：
* 接口组合接口
* 结构体组合结构体
* 结构体组合结构体指针
* 结构体组合接口

可以组合多个。

![image.png](/static/img/6a7ec372bcc572d84d5b2cde897f4c99.image.png)

## 组合的特性
* 当A组合了B之后
    * 可以直接在A上调用B的方法
    * B实现的所有接口，都认为A已经实现了

* A组合B之后，在初始化A的时候将B看做普通字段来初始化
* 组合不是继承，没有多态

右边的例子输出什么？
* hello，inner
* hello，outer

![image.png](/static/img/2d7699ec2bcdaf48741109fdc607fe84.image.png)

06 go接口与类型定义

## 数组
语法是：
[CAP] Type
1. 初始化要指定长度（或者叫做容量）
2. 可以直接初始化
3. arr[i]的形式访问元素
4. len和cap操作用于获取数组长度
5. 使用for range 来循环




![image.png](/static/img/0bbfb90f75d56a99e3ad4e2db549a293.image.png)
## 切片
语法是： []type
1. 直接初始化
2. make初始化：make([]type,length,capacity)
3. arr[i]的形式访问元素
4. append追加元素
5. len获取元素数量
6. cap获取切片容量
7. 推荐写法: s1:=make([]type,0,capacity)
8. 使用for range来遍历


![image.png](/static/img/02255102c513e29b7236f209ce600689.image.png)

___
数组和切片的区别

![image.png](/static/img/5938606000d5ea17a737c6c81717b399.image.png)


:::info{title="如何理解切片？"}
最直观的对比：ArrayList，即基于数组的list的实现，切片的底层也是数组

跟Array的区别：
1. 切片操作是有限的，不支持随机增删（即没有add，delete方法，需要自己写代码）
2. 只有append操作
3. 切片支持子切片操作，和原本切片是共享底层数组
:::
### 子切片
数组和切片都可以通过[start:end]的形式来获取子切片：
1. arr[start:end]，获得[start,end)之间的元素
2. arr[:end],获得[0,end)之间的元素
3. arr[start:]，获得[start,len(arr))之间的元素。


![image.png](/static/img/f9bb5b1900fbe7ab81c4fd32a6f0a0f5.image.png)


:::warning{title="内存共享问题"}
核心：共享数组

子切片和切片究竟会不会互相影响，就抓住一点：他们是不是还共享数组？

什么意思？
1. 就是如果它们结构没有变化，那肯定是共享的；但是结构变化了，就可能不是共享了。

什么情况下结构会变化？ **扩容了**

所以，切片与子切片，切片作为参数传递到别的方法、结构体里面，任何情况下你要判断是否内存共享，那么就一点：**有没有扩容**
:::


![image.png](/static/img/cbce5b2277c5ffc8bc8de9e6eca2b4a4.image.png)


## map
map是go里面的内置类型之一，使用起来也很简单。
* 初始化
    * make方法：记得预估容量
    * 直接初始化元素

* 赋值：使用中括号


![image.png](/static/img/e912a21e160d7ad9e6979879de1eddf9.image.png)


读取元素：有两个返回值
* 第一个是值，第二个是这个元素是否存在
* 如果只有一个返回值，那么就是对应的元素；元素不存在，那么就是对应类型的零值


![image.png](/static/img/6ef8429b32ab3baa5a0d71e44af00576.image.png)

读取长度：len
* 遍历：for，第一个是key，第二个是value
* 删除：使用delete方法

注意：map的遍历是随机的，也就是你遍历两边，输出的结果都不一样。


![image.png](/static/img/f91dc44f5a44a22d4398b7ed350c4cc7.image.png)

### comparable概念
* 在Switch里面，值必须是可比较的
* 在map里面，key也必须是可比较的

所谓可比较的，在go里面就是指：GO在编译的时候、运行的时候能够判断出来元素是不相等的。

初学的时候，你就知道：
* 基本类型和string都是可比较的
* 如果元素是客比较的，那么该数据也是可比较的

参考这里的[详细说明](https://go.dev/ref/spec#Comparison_operators)

面试也基本不可能面到这个内容，你有一个概念就行。


### 代码演示
1. go是强类型语言，能不能设计一个方法，可以计算任意数字类型切片的和的方法？
    * func SumInt64([]int64)只能用于int64
    * func SumInt32([]int32)只能用于int32
    * ……
3. 获得map的所有key、所有value
## channel：这个后面讲并发的时候再讲

05 内置类型：数组与切片

## 方法声明

* 四个部分
```
    * 关键字func
    * 方法名字：首字母是否大写决定了作用域
    * 参数列表：[<name type>]
    * 返回列表: [<name type>]
```    
    


名字+参数列表+返回值，也叫做方法签名（signatrue）
    
   
![image.png](/static/img/9665bf0ae39d06b926b1bafd9376751b.image.png)
    

## 方法声明：返回值

Go的方法和别的语言比起来，有一个很大的不同：

 * 可以有很多个返回值，并且返回值可以有名字

带名字的返回值，就相当于你声明了一个作用域在整个方法的局部变量。
    
用不用带名字的返回值纯粹是个人风格，你看自己喜好。

    
![image.png](/static/img/1e86f1d8e492ae2158810d49c960f555.image.png)
    
## 方法调用
方法调用只需要用足够的参数去接受返回值，并且传入了调用参数就可以。
    
有多个返回值的时候，如果你忽略一些返回值，可以使用 _
    
> 记住一条核心原则：同一个作用域内，如果左边出现了新的变量，那么就需要使用:=来接受返回值。
    
    
![image.png](/static/img/8d7318ad19624be8a3fc50f18e9b0ad8.image.png)


## 方法调用：递归

一个方法内部可以调用它自己，这就是所谓的递归

递归要小心，如果递归嵌套太深的话，可能会出现栈溢出错误。
* 治标的话，栈溢出可以考虑通过增加栈大小来解决
* 治本的话，还是要找到对应的递归代码，进行修改。


![image.png](/static/img/0cff9dd3549d8a986c06fd120f6de0d0.image.png)

    

## 函数式编程入门：方法做为变量

方法本身就可以赋值给某个变量，而这个变量就可以直接发起调用。

下图中的myFunc3本质上是一个变量，只不过这个变量等于Func3


![image.png](/static/img/a9af2d27583644263dcb36e243f77806.image.png)


## 函数式编程入门：局部方法
可以在方法内部声明一个局部方法，它的作用域就在本方法内


![image.png](/static/img/7f3da622e3903900bcda6a8fdf6792bb.image.png)
    

## 函数式编程入门：方法作为返回值
方法可以作为返回值

注意，不是方法的返回值，是方法本身就可以作为返回值

后面你们经常会看到我的这种用法，它本身也是闭包的一种应用

右图中的sayhello就是返回来的那个方法，所以可以直接调用


![image.png](/static/img/9ec0902ee4c2d8de9c0d762498621414.image.png)


## 函数式编程入门：匿名方法发起调用

在前面你已经见过声明一个匿名方法，然后赋值给一个变量

那么你也可以声明一个匿名方法，而后可以立刻发起调用

右图中hello就是匿名函数直接发起调用之后返回的数据

这种用法在defer中用的多。


![image.png](/static/img/9e77029fdf9f11f829149c2f97b53a5e.image.png)
    



## 函数式编程入门：闭包

闭包，方法+它绑定的运行上下文

图返回的是闭包，它由两部分构成：
* 方法
* 运行时上下文：它只引用啦name这一个变量

闭包也是一个面试redden，所以你至少需要记住闭包的定义。

闭包如果使用不当可能会引起内存泄漏的问题。即一个对象被闭包引用的话，它是不会被垃圾回收的。

记住这个结论，后面面试用得上。


![image.png](/static/img/50a0e522ca3e131039b4a37bf4324f10.image.png)


## 不定参数

GO支持不定参数。不定参数是指最后一个参数，可以传入任意多个值

注意必须是最后一个参数才可以声明为不定参数

不定参数在方法内部可以被当成切片来使用。

Option模式大量应用来不定参数。


![image.png](/static/img/bcd659bdd972ab9b691e0ddbf5af8485.image.png)

## defer
Go里面有一个机制，允许你从方法返回的前一刻，执行一段逻辑

这个也就是defer，也叫做延迟调用

defer类似栈，也就是后进先出。也就是，先定义的后执行；后定义的先执行。

图中我们利用匿名函数定义了两个defer

![image.png](/static/img/e1203297898cc6fa6097b3309d9300f8.image.png)

图中的这种写法：叫做匿名函数的立刻发现调用。

![image.png](/static/img/669c018d7fd5884d92aaa71829461ab0.image.png)


## defer 与闭包

我们通常都用闭包来写defer，所以就会涉及到一个问题，就是defer执行的时候怎么确定里面的值？

![image.png](/static/img/c0039578cc9477502e7a418cbde8fc7d.image.png)
输出：1

确定值的原则：
* 作为参数传入的：定义defer的时候就确定来。
* 作为闭包引入的：执行defer对应的方法时候才确定


![image.png](/static/img/51e0a0ec6bbf989ca1fcc78787c8c141.image.png)


## defer修改返回值

如果是带名字的返回值，那么可以修改这个返回值，否则不能修改。

![image.png](/static/img/77801b735ce7ad44d611c8cdc27416ba.image.png)

![image.png](/static/img/4123f84046ed307f7fa0836e90c39c19.image.png)
注意：最右边的并没有修改a，而是修改a指向的结构体