zhe.ink 在线工具箱

Go语言教程之边写边学：Golang中的反射：Reflect包的Make相关函数

MakeSlice函数为指定的切片类型、长度和容量创建一个新的零初始化切片值。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var str []string
	var strType reflect.Value = reflect.ValueOf(&str)
	newSlice := reflect.MakeSlice(reflect.Indirect(strType).Type(), 10, 15)

	fmt.Println("Kind :", newSlice.Kind())
	fmt.Println("Length :", newSlice.Len())
	fmt.Println("Capacity :", newSlice.Cap())
}

输出：

Kind : slice
Length : 10
Capacity : 15

MakeMap将创建一个具有指定类型的新映射。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var str map[string]string
	var strType reflect.Value = reflect.ValueOf(&str)
	newMap := reflect.MakeMap(reflect.Indirect(strType).Type())

	fmt.Println("Kind :", newMap.Kind())
}

输出：

Kind : map

MakeChan创建一个具有指定类型和缓冲区大小的新通道。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var str chan string
	var strType reflect.Value = reflect.ValueOf(&str)
	newChannel := reflect.MakeChan(reflect.Indirect(strType).Type(), 512)

	fmt.Println("Kind :", newChannel.Kind())
	fmt.Println("Capacity :", newChannel.Cap())
}

输出：

Kind : chan
Capacity : 512

MakeFunc函数用于获取包装函数fn的给定Type的新函数。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type Sum func(int64, int64) int64

func main() {
	t := reflect.TypeOf(Sum(nil))
	mul := reflect.MakeFunc(t, func(args []reflect.Value) []reflect.Value {
		a := args[0].Int()
		b := args[1].Int()
		return []reflect.Value{reflect.ValueOf(a + b)}
	})
	fn, ok := mul.Interface().(Sum)
	if !ok {
		return
	}
	fmt.Println(fn(5, 6))
}

输出：

Go语言教程之边写边学：Golang中的反射：Reflect包的Field相关函数

NumField函数

返回给定结构中的字段数。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type T struct {
	A int
	B string
	C float64
	D bool
}

func main() {
	t := T{10, "ABCD", 15.20, true}
	typeT := reflect.TypeOf(t)
	fmt.Println(typeT.NumField()) // 4
}

field函数

Field函数用于访问结构字段的名称和类型。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type T struct {
	A int
	B string
	C float64
	D bool
}

func main() {
	t := T{10, "ABCD", 15.20, true}
	typeT := reflect.TypeOf(t)

	for i := 0; i < typeT.NumField(); i++ {
		field := typeT.Field(i)
		fmt.Println(field.Name, field.Type)
	}
}

输出：

A int
B string 
C float64
D bool

FieldByIndex函数

FieldByIndex函数用于获取index对应的嵌套字段

package main

import (
	"fmt"
	"reflect"
)

type First struct {
	A int
	B string
	C float64
}

type Second struct {
	First
	D bool
}

func main() {
	s := Second{First: First{10, "ABCD", 15.20}, D: true}
	t := reflect.TypeOf(s)

	fmt.Printf("%#v\n", t.FieldByIndex([]int{0}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 0}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 1}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 2}))
	fmt.Printf("%#v\n", t.FieldByIndex([]int{1}))
}

输出：

reflect.StructField{Name:"First", PkgPath:"", Type:(*reflect.rtype)(0x4bda40), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:true}
reflect.StructField{Name:"A", PkgPath:"", Type:(*reflect.rtype)(0x4ad800), Tag:"", Offset:0x0, Index:[]int{0}, Anonymous:false} 
reflect.StructField{Name:"B", PkgPath:"", Type:(*reflect.rtype)(0x4adf80), Tag:"", Offset:0x8, Index:[]int{1}, Anonymous:false} 
reflect.StructField{Name:"C", PkgPath:"", Type:(*reflect.rtype)(0x4ad400), Tag:"", Offset:0x18, Index:[]int{2}, Anonymous:false}
reflect.StructField{Name:"D", PkgPath:"", Type:(*reflect.rtype)(0x4ad200), Tag:"", Offset:0x20, Index:[]int{1}, Anonymous:false

FieldByName函数

FieldByName函数用于通过给定的字段名称获取和设置结构字段值。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type T struct {
	A int
	B string
	C float64
}

func main() {
	s := T{10, "ABCD", 15.20}
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("A"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("B"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("C"))

	reflect.ValueOf(&s).Elem().FieldByName("A").SetInt(50)
	reflect.ValueOf(&s).Elem().FieldByName("B").SetString("Test")
	reflect.ValueOf(&s).Elem().FieldByName("C").SetFloat(5.5)

	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("A"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("B"))
	fmt.Println(reflect.ValueOf(&s).Elem().FieldByName("C"))
}

输出：

10
ABCD
15.2
50  
Test
5.5

Go语言教程之边写边学：Golang中的反射：Reflect包的ValueOf函数

ValueOf函数来创建一个reflect。表示变量值的Value实例。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	v1 := []int{1, 2, 3, 4, 5}
	fmt.Println(reflect.ValueOf(v1))

	v2 := "Hello World"
	fmt.Println(reflect.ValueOf(v2))

	v3 := 1000
	fmt.Println(reflect.ValueOf(v3))
	fmt.Println(reflect.ValueOf(&v3))

	v4 := map[string]int{"mobile": 10, "laptop": 5}
	fmt.Println(reflect.ValueOf(v4))

	v5 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(reflect.ValueOf(v5))

	v6 := true
	fmt.Println(reflect.ValueOf(v6))
}

输出：

[1 2 3 4 5]
Hello World
1000
0xc0000a00b8
map[laptop:5 mobile:10]
[1 2 3 4 5]
true

Go语言教程之边写边学：Golang中的反射：Reflect包的TypeOf函数

TypeOf函数返回reflect类型的值，即传递给TypeOf函数的变量的类型。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	v1 := []int{1, 2, 3, 4, 5}
	fmt.Println(reflect.TypeOf(v1))

	v2 := "Hello World"
	fmt.Println(reflect.TypeOf(v2))

	v3 := 1000
	fmt.Println(reflect.TypeOf(v3))

	v4 := map[string]int{"mobile": 10, "laptop": 5}
	fmt.Println(reflect.TypeOf(v4))

	v5 := [5]int{1, 2, 3, 4, 5}
	fmt.Println(reflect.TypeOf(v5))

	v6 := true
	fmt.Println(reflect.TypeOf(v6))
}

输出：

[]int
string        
int
map[string]int
[5]int        
bool

Go语言教程之边写边学：Golang中的反射：Reflect包的swapper函数

Swapper函数用于交换所提供切片中的元素。您也可以以巧妙的方式使用此功能来反转或排序切片。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	theList := []int{1, 2, 3, 4, 5}
	swap := reflect.Swapper(theList)
	fmt.Printf("Original Slice :%v\n", theList)

	// 按下标交换元素swap(1, 3)
	fmt.Printf("After Swap :%v\n", theList)

	// 反转slice元素for i := 0; i < len(theList)/2; i++ {
		swap(i, len(theList)-1-i)
	}
	fmt.Printf("After Reverse :%v\n", theList)
}

输出：

Original Slice :[1 2 3 4 5]
After  Swap :[1 4 3 2 5]
After Reverse :[5 2 3 4 1]

Go语言教程之边写边学：Golang中的反射：Reflect包的DeepEqual函数

无论x和y是否"深度相等"，DeepEqual都返回True或False。当数组值的相应元素深度相等时，数组值深度相等。如果结构值的对应字段(导出和未导出)非常相等，则它们非常相等。切片值在以下情况下非常相等(它们都是nil或都是非nil，它们具有相同的长度，并且它们指向同一基础数组的相同初始条目)。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

type mobile struct {
	price float64
	color string
}

func main() {
	// DeepEqual is used to check two slices are equal or not
	s1 := []string{"A", "B", "C", "D", "E"}
	s2 := []string{"D", "E", "F"}
	result := reflect.DeepEqual(s1, s2)
	fmt.Println(result)

	// DeepEqual is used to check two arrays are equal or not
	n1 := [5]int{1, 2, 3, 4, 5}
	n2 := [5]int{1, 2, 3, 4, 5}
	result = reflect.DeepEqual(n1, n2)
	fmt.Println(result)

	// DeepEqual is used to check two structures are equal or not
	m1 := mobile{500.50, "red"}
	m2 := mobile{400.50, "black"}
	result = reflect.DeepEqual(m1, m2)
	fmt.Println(result)
}

输出：

false
true 
false

Go语言教程之边写边学：Golang中的反射：Reflect 包的copy函数

Go中的反射是元编程的一种形式。反射允许我们在运行时检查类型。它还提供了在运行时检查、修改和创建变量、函数和结构的功能。Go reflect包为您提供了在运行时检查和操作对象的功能。对于开发人员来说，反射是一个非常强大的工具，它扩展了任何编程语言的视野。类型、种类和值是用于查找信息的三个重要反射部分。

copy函数将源的内容复制到目标中，直到目标被填满或源已用尽。它返回复制的元素数。目标和源必须具有Slice或Array类型，并且目标和源必须具有相同的元素类型。

示例代码：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	destination := reflect.ValueOf([]string{"A", "B", "C"})
	source := reflect.ValueOf([]string{"D", "E", "F"})

	// Copy() function is used and it returns the number of elements copied
	counter := reflect.Copy(destination, source)
	fmt.Println(counter)

	fmt.Println(source)
	fmt.Println(destination)
}

输出：

3
[D E F]
[D E F]

为了进行seo优化，出站链接需要带ref参数吗？

在SEO优化中，出站链接是否需要带ref参数，并没有固定的答案。这取决于具体情况，包括你的网站目标、链接类型以及对方网站的要求。

以下是一些可能需要考虑的因素：

跟踪转化：如果你希望跟踪通过出站链接产生的转化（例如，销售或订阅），那么在出站链接中包含ref参数是有用的。这可以让你在自家的数据分析工具中更准确地追踪这些转化。
SEO策略：在某些情况下，你可能会希望通过出站链接来传递一些特定的关键词或元数据信息。在这种情况下，使用ref参数可能是有用的。
用户体验：如果ref参数对于用户来说没有明显的意义或者作用，那么可能不需要包含它。否则，它可能会导致用户体验的困扰，影响用户点击和交互。
链接可读性：如果出站链接的长度已经很长或者复杂，那么可能没有必要添加ref参数。因为这可能会降低链接的可读性，影响用户点击。

需要注意的是，每个网站可能有不同的要求和策略。在进行SEO优化时，最好与你的网站目标、用户体验和其他网站营销策略进行协调。

javascript中重定向到另一个页面的方法

在JavaScript中，您可以使用window.location对象来重定向到另一个页面。例如，如果您想重定向到"https://zhe.ink"，您可以使用以下代码：

javascriptwindow.location.href = "https://www.example.com";

当这行代码被执行时，用户的浏览器会被导向至"https://zhe.ink"。window.location.href会改变当前页面地址，但不会重新加载页面，这使得它可以用于实现页面的平滑跳转。

如果您想让页面完全刷新，您可以使用window.location.replace()方法，如下所示：

javascriptwindow.location.replace("https://www.example.com");

这种方法会导致浏览器的历史记录中保存新的页面地址，但是不会触发与页面刷新相关的浏览器事件。

链接后面带ref参数的作用是什么？

链接后面带ref参数的作用是用于跟踪链接的来源和转化情况。ref参数通常用于网站的分析和营销策略中，可以帮助网站管理员了解用户是如何到达网站的，以及用户在网站上的行为。

ref参数通常是一个参数，附加在URL后面，用于标识链接的来源。例如，如果一个链接是从搜索引擎中点击过来的，可以将ref参数设置为"google"，表示该链接是从Google搜索结果页面中点击过来的。

通过跟踪ref参数，网站管理员可以了解哪些来源带来了最多的流量，哪些来源转化率最高，以及哪些来源的用户参与度最高。这些信息可以帮助网站管理员优化营销策略，提高网站的流量和转化率。

农历

五行

冲煞

彭祖

方位

宜

忌

吉神

凶神

极简任务管理 help

+ 0 0 0

Task Idea Collect