普拉多VX

人生一路,不问来时,不知归期

0%

一直在做python后端开发,之前一直会遇见django 和vue结合后的垮域问题。现特记录下解决方法

什么是跨域

解释来源链接:https://www.jianshu.com/p/3961366f9ce9

跨域是指一个域下的文档或脚本试图去请求另一个域下的资源,这里跨域是广义的。
其实我们通常所说的跨域是狭义的,是由浏览器同源策略限制的一类请求场景。

什么是同源策略?

同源策略/SOP(Same origin policy)是一种约定,由Netscape公司1995年引入浏览器,它是浏览器最核心也最基本的安全功能,如果缺少了同源策略,浏览器很容易受到XSS、CSFR等攻击。所谓同源是指”协议+域名+端口”三者相同,即便两个不同的域名指向同一个ip地址,也非同源。

同源策略限制以下几种行为:

  • Cookie、LocalStorage 和 IndexDB 无法读取
  • DOM 和 Js对象无法获得
  • AJAX 请求不能发送

1.安装django-cors-headers

1
pip install django-cors-headers

2.配置settings.py文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

//将corsheaders添加到apps中
INSTALLED_APPS = [
...
'corsheaders',
....
]



#跨域增加忽略
CORS_ALLOW_CREDENTIALS = True
CORS_ORIGIN_ALLOW_ALL = True

CORS_ORIGIN_WHITELIST = (
'http://localhost:8000',
'http://127.0.0.1:8000',
)

CORS_ALLOW_METHODS = (
'DELETE',
'GET',
'OPTIONS',
'PATCH',
'POST',
'PUT',
'VIEW',
)

CORS_ALLOW_HEADERS = (
'XMLHttpRequest',
'X_FILENAME',
'accept-encoding',
'authorization',
'content-type',
'dnt',
'origin',
'user-agent',
'x-csrftoken',
'x-requested-with',
'Pragma',
)


MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'corsheaders.middleware.CorsMiddleware', //将corshaders添加到common之上
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django_user_agents.middleware.UserAgentMiddleware',
]

3.重新启动项目即可

匿名函数

匿名函数就是一个没有名字的函数,只有函数体,函数可以被作为一种类型被赋值给函数类型的变量,匿名函数往往是以变量方式被传递。

匿名函数的定义

1
2
3
4
func (参数列表)(返回值列表) {
函数体

}

调用方式

  • 声明时直接调用
  • 赋值给变量进行调用

实例:匿名函数调用

1.声明时直接调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package main

import "fmt"

//func (参数列表)(返回值列表) {
// 函数体
//
//}

func main(){

func (userId,age int){
fmt.Printf("用户ID:%d,年龄:%d\n",userId,age)
}(1,24) //声明时直接调用

}

2.赋值给变量调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import "fmt"

//func (参数列表)(返回值列表) {
// 函数体
//
//}

func main(){

result :=func (a,b int )int{
return a+b
}

fmt.Println(result(2,6)) //直接赋值给result,然后调用即可

}

全局匿名函数

以上我们的函数调用都是一个局部调用,如何进行全局调用呢,可以将匿名函数赋值给一个全局变量,就可以程序中使用了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package main

import "fmt"
//全局匿名函数
var (
getResult = func(a,b int,meth_type string) int {
if meth_type == "+" {
return a + b
}else if meth_type == "-" {

return a -b
}else if meth_type == "*" {
return a *b
}else{
return 1
}
}

)


func funcMethod(a,b int)(int,int,int){

//加法
add := getResult(a,b,"+") //函数中调用全局匿名函数
//减法
sub := getResult(a,b,"-")
//乘法
mul := getResult(a,b,"*")

return add,sub,mul

}

func main(){

fmt.Println(funcMethod(1,23))


}

函数闭包

闭包就是一个函数与其相关的引用环境组成的一个整体。它本质上是一个函数,但是这个函数会用于函数外的变量,它们共同组成的整体称为闭包。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

package main

import "fmt"

//累积数据,返回值是一个func
func addUpper() func(int) int {
n := 10
n -= 1
c := 20

return func (x int) int {
c -= 2
fmt.Println(c)

n = n +x
return n
}
}

func main(){

t := addUpper() //t变量用于接收返回的函数

fmt.Println(t(5))

}

defer(延迟函数)

defer用来声明一个延迟函数,并把这个函数放到一个栈上,当外部的包含方法return之前,放回参数到调用方法之前调用。通常用于做资源释放,比如关闭io等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

//defer 用于程序释放资源,用于延迟操作。


func f() {
//延迟调用,采用FILO(先进后出原则) 延迟函数执行按后进先出顺序执行,即先出现的defer后执行
i:=0
defer fmt.Println(i)
i++
defer fmt.Println(i)
return

}

func main() {
f() //结果是1 后是0
}

关闭文件io

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func closeFile(){

f, _ := os.Open("Godefer.go")

//将文件名交给带有缓存的IO Reader
r := bufio.NewReader(f)

for {
line, err := r.ReadString('\n') //指定分割符
//判断是否是文件结尾
if err == io.EOF {
break
}
fmt.Print(line)
}

defer f.Close()

}

函数作用域

1.在函数内部声明/定义的变量叫局部变量,作用域仅限于函数内部

1
2
3
4
func change(){  
a := 124 //在change函数体内部声明的变量叫局部变量
fmt.Println(a)
}

2.函数外部声明/定义的变量叫全局变量,作用于在整个包内。如果变量的首字母大写,则可以外部访问调用(作用域为整个程序)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import "fmt"

// 外部变量
var (
Name string = "default"
Age int64

)
func change(){
//修改的就是全局变量
Name = "1234"

}

func main() {

Age = 100
fmt.Println(Name,Age)

change()
Age = 100
fmt.Println(Name,Age)

}

函数声明

golang 的函数声明包含func关键字、函数名、形式参数列表(可省略)、返回值列表及函数体

1
2
3
func FuncName(username string,age int){

}

最简单的函数定义如果,以func开头及函数名

1
2
3
func Simple(){
//表示该函数不需要输入参数,以及没有返回值
}

下面通过两个实例来介绍下函数的使用

1.计算两个数相加。定义一下funcAdd 函数,接收两个参数a,b 类型为int 返回值为int。函数调用时,以函数名()的形式进行调用。

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func funcAdd(a int, b int)int{
return a+b
}

func main(){
fmt.Println(funcAdd(3,5)) //输出结果为8
}

函数返回时还可以直接以变量的形式进行返回

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func funcAdd(a int, b int) (result int){
result=a+b
return //直接输入return进行返回即可
}

func main(){
fmt.Println(funcAdd(7,8))
}

2.计算商品价格。定义一个函数名加ShopPrice,接收几个参数,并且返回商品价格。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func ShopPrice(s_price,number,sale float64)(price float64){
//商品原价 * 数量 * 折扣
// 999.88 * 2 * 98/100
price = s_price * number * sale / 100.00
return
}

func main(){


fmt.Println(ShopPrice(999.25,2,98))

}

可以返回多个数据,传入商品名、价格、数量。最后返回商品及计算结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main

import "fmt"

func ShopDetail(s_price,number,sale float64,name string)(float64, string){
//商品原价 * 数量 * 折扣
// 999.88 * 2 * 98/100
price := s_price * number * sale / 100.00
return price,name
}


func main(){
price,name := ShopDetail(999.25,2,98,"大衣")
fmt.Println("商品:",name,"价格:",price)

}

函数多返回值

在go中,一个函数可以接收多个参数列表,同时也可以返回多个值,便于我们进行处理。

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func AbcFunc(a,b,c int)(int,int,int){ //返回值为3个int数值
return c,b,a //将123 转成321输出
}

func main(){
c,b,a := AbcFunc(1,2,3)
fmt.Println(c,b,a)
}

空白符号的使用

如果在接收参数时,有不想使用的变量数值,可以使用_进行代替,程序不作处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import "fmt"

func nullValue(username string,age int,address string)(string,int,string){

return username,age,address
}


func main(){
//_用于接收任何类型的任何值,如果以“_”表示,那将省略,可以理解为垃圾桶
username,age,_ := nullValue("roddy",27,"sichuan")
fmt.Println(username,age)
}

函数可变参数

向函数传递一个未知数量的参数值时,可以使用…来代替,下面样例就是传递一个数字序列,然后分别打印出来例子。

1
2
3
4
5
6
7
8
9
10
11
func MultipleNumber(args ...int){
for i:=0;i<len(args);i++{
fmt.Println(args[i])
}
}


func main(){

MultipleNumber(1,2,3,5,4,5,6,6,7,8)
}

实例

输入一列数据,返回这组数据的最小值与最大值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "fmt"

func MinMax(input ...int)(min,max int){
min = input[0]
max = input[0]

for i :=0;i<len(input);i++{
if input[i] < min{
min = input[i]
}

if input[i] >max {
max = input[i]
}
}
return
}

func main(){
min,max :=MinMax(1,2,34,5,6,7)
fmt.Println("最小值为:",min,"最大值为:",max)
}

如何使用golang打印一个乘法表

使用模块fmt,语法使用for循环嵌套,然后使用fmt.Printf格式化输出结果。

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
for i:=1;i<=9;i++ {
for c:=1;c<=i;c++{
fmt.Printf("%d * %d = %d ",i,c,i*c)
}
fmt.Println()
}
}

此时输出结果发现,细微发现数字没有对齐

1
2
3
4
5
6
7
8
9
1 * 1 = 1 
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81

改进代码在=%d改成%-2d 2d表示2位数字。-标识缺省

1
fmt.Printf("%d * %d = %-2d ",i,c,i*c)

输出结果

1
2
3
4
5
6
7
8
9
1 * 1 = 1  
2 * 1 = 2 2 * 2 = 4
3 * 1 = 3 3 * 2 = 6 3 * 3 = 9
4 * 1 = 4 4 * 2 = 8 4 * 3 = 12 4 * 4 = 16
5 * 1 = 5 5 * 2 = 10 5 * 3 = 15 5 * 4 = 20 5 * 5 = 25
6 * 1 = 6 6 * 2 = 12 6 * 3 = 18 6 * 4 = 24 6 * 5 = 30 6 * 6 = 36
7 * 1 = 7 7 * 2 = 14 7 * 3 = 21 7 * 4 = 28 7 * 5 = 35 7 * 6 = 42 7 * 7 = 49
8 * 1 = 8 8 * 2 = 16 8 * 3 = 24 8 * 4 = 32 8 * 5 = 40 8 * 6 = 48 8 * 7 = 56 8 * 8 = 64
9 * 1 = 9 9 * 2 = 18 9 * 3 = 27 9 * 4 = 36 9 * 5 = 45 9 * 6 = 54 9 * 7 = 63 9 * 8 = 72 9 * 9 = 81