Go-关键词总结

最新推荐文章于 2023-10-20 17:58:50 发布
最新推荐文章于 2023-10-20 17:58:50 发布
阅读量325 收藏
点赞数
分类专栏： Go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33961117/article/details/105191706
版权
本文详细探讨了 Go 语言中的核心关键词，包括 For 和 For-Range 的使用，如 range 循环数组、map 的遍历及其注意事项；Select 的工作原理，如何在并发环境中使用；Defer 的执行顺序和常见误区；Panic 和 Recover 的交互，以及何时使用它们；最后，对比了 Make 和 New 的区别以及初始化变量在栈和堆的情况。
摘要由CSDN通过智能技术生成

一、For & For-Range

循环的两种方式：for 、 for range

package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i < 10; i++ {
		sum += i
	}
	fmt.Println(sum)
	
  // 初始化语句和后置语句是可选的。
  sum := 1
	for ; sum < 1000; {
		sum += sum
	}
	fmt.Println(sum)
  // for 是 Go 语法内的 while
	for sum < 1000 {
		sum += sum
	}
 
  // for-range
  numbers := [6]int{1, 2, 3, 5}
  for i,x:= range numbers {
    fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)
  }  
}

1-1 range 循环数组返回索引和值

package main
import "fmt"
func main() {  
    x := []string{"a","b","c"}
    for _, v := range x {
        fmt.Println(v) //prints a, b, c
    }
}

1-2 slice、array、map 在 range 中传递方式 - 通常为值传递

在循环的通常情况下，仅传递值，不对原内存地址的值进行修改

package main
import "fmt"
func main() {  
    data := []int{1,2,3}
    for _,v := range data {
        v *= 10 // original item is not changed
    }
    fmt.Println("data:",data) // prints data: [1 2 3]
}

使用索引操作符来修改值，则会将原内存地址的值修改

package main
import "fmt"
func main() {  
    data := []int{1,2,3}
    for i,_ := range data {
        data[i] *= 10
    }
    fmt.Println("data:",data) //prints data: [10 20 30]
}

若变量内部存储的为指针，索引和range 出的值都可对原地址进行修改

package main
import "fmt"
func main() {
	data := []*struct{num int} { {1},{2},{3} }
	for _,v := range data {
		v.num *= 10
	}
	fmt.Println(data) //[0xc0000a6008 0xc0000a6010 0xc0000a6018]
	fmt.Println(data[0],data[1],data[2]) //&{10} &{20} &{30}
	fmt.Println(*data[0],*data[1],*data[2]) //{10} {20} {30}
}

1-3 for 循环中的返回值为内存地址

1-3-1 for 循环的 goroutine 存在数据错误

for 循环中迭代的变量，都是指向同一个内存地址，即 for 循环中创建的闭包都为引用传递，而由于 goroutine 本身的执行速度，很可能主线程已经循环结束，子线程才开始进行执行，导致数据获取的已经不是想象中的那个值。

package main
import (  
    "fmt"
    "time"
)
func main() {  
    data := []string{"one","two","three"}
    for _,v := range data {
        go func() {
            fmt.Println(v)
        }()
    }
    time.Sleep(3 * time.Second)
}
/*
three
three
three
*/

然而，若主线程中存在io等待拖慢速度，会发现 子线程仍然会获取到想象中的值。

package main
import (
	"fmt"
	"time"
)
func main() {
	data := []string{"one","two","three"}
	for _,v := range data {
		go func() {
			fmt.Println(v)
		}()
		time.Sleep(3 * time.Second)
	}
	time.Sleep(3 * time.Second)
}

/*
one
two
three
*/

解决方式：1、保存每次迭代的值 2、每次迭代的值是匿名 goroutine 的参数

package main
import (  
    "fmt"
    "time"
)
func main() {  
    data := []string{"one","two","three"}
    for _,v := range data {
        vcopy := v // 保存每次迭代的值，值传递，仅仅复制值
        go func() {
            fmt.Println(vcopy)
        }()
    }
    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

ackage main
import (  
    "fmt"
    "time"
)
func main() {  
    data := []string{"one","two","three"}
    for _,v := range data {
        go func(in string) {
            fmt.Println(in)
        }(v) // 作为参数传入执行
    }
    time.Sleep(3 * time.Second)
    //goroutines print: one, two, three
}

注意：若循环的对象是指针，则每次取的地址都不同，则不存在指向错误。

package main

import (
   "fmt"
   "time"
)

type field struct {
   name string
}

func (p *field) print() {
   fmt.Println(p.name)
}
func main() {
   data := []*field{{"one"}, {"two"}, {"three"}}
   for _, v := range data {
      fmt.Printf("----->%v\n", v)
      go v.print()
   }
   time.Sleep(3 * time.Second)
}

/*
----->&{one}
----->&{two}
----->&{three}
three
two
one
*/

1-3-2 由于指向内存地址导致的匿名函数作用域错误

import (
	"fmt"
)

func main(){
	var msgs []func()
	array := []string{
		"1", "2", "3", "4",
	}

	for _, e := range array{

			msgs = append(msgs, func(){
			fmt.Println(e)
		})
	}

	for _, v := range msgs{
		v()
	}
}
/*
4
4
4
4
*/
// 由于 e 指向的是内存地址，每次循环内存地址内保存的值会被修改，所以出错

1-4 可以边修改边循环，遍历不会获取修改数据 - 循环前拷贝

v := []int{1, 2, 3}
for i := range v {
    v = append(v, i)
}

1-4-1 map 的遍历中修改

map 的内部实现是一个链式 hash 表，为保证每次的无序，初始化时，都会随机遍历一个开始的位置。且，once.Do 函数用于保护已遍历的数据，如果后续删除的元素在之前没有被遍历到，则后续遍历不会出现。

var m = map[int]int{1: 1, 2: 2, 3: 3}
//only del key once, and not del the current iteration key
var o sync.Once 
for i := range m {
    o.Do(func() {
        for _, key := range []int{1, 2, 3} {
            if key != i {
                fmt.Printf("when iteration key %d, del key %d\n", i, key)
                delete(m, key)
                break
            }
        }
    })
    fmt.Printf("%d%d ", i, m[i])
}
1-4-1-1 遍历中删除未遍历到的map元素，后续不会遍历到已经删除的元素
//遍历中删除map元素，不会遍历到已经删除的元素
package main

import "fmt"

func main() {
	var createElemDuringIterMap = func() {
		var m = map[int]int{1: 1, 2: 2, 3: 3}
		for i := range m {
			delete(m, 2)
			fmt.Printf("%d%d ", i, m[i])
		}
	}
	for i := 0; i < 10; i++ {
		//  will not show 22
		createElemDuringIterMap()
		fmt.Println()
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-821eIF7f-1585530422471)(Go-Keywords.assets/image-20200313152016305.png)]

1-4-1-2 遍历中删除已遍历到的元素，后续遍历 vlaue 为空
package main

import "fmt"

func main() {
	var createElemDuringIterMap = func() {
		var m = map[int]int{1: 1, 2: 2, 3: 3}
		for i := range m {
			delete(m, 1)
			fmt.Printf("%d%d ", i, m[i])
		}
	}
	for i := 0; i < 10; i++ {
		//  will not show 22
		createElemDuringIterMap()
		fmt.Println()
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CtburoDz-1585530422472)(Go-Keywords.assets/image-20200313152725507.png)]

1-4-1-3 遍历中新增元素，可能会遍历到后增的元素。
// 遍历中新增元素，可能会遍历到后增的元素。
package main

import "fmt"

func main() {
	var createElemDuringIterMap = func() {
		var m = map[int]int{1: 1, 2: 2, 3: 3}
		for i := range m {
			m[4] = 4
			fmt.Printf("%d%d ", i, m[i])
		}
	}
	for i := 0; i < 10; i++ {
		//some line will not show 44, some line will
		createElemDuringIterMap()
		fmt.Println()
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k8gCePLy-1585530422473)(Go-Keywords.assets/image-20200313152105372.png)]

1-5 遍历大数据前的拷贝造成的内存浪费优化

package main
import (
	"fmt"
)

func main(){
	arr := [...]int{102400:0}
  for i, n := range arr {
    //just ignore i and n for simplify the example
    _ = i 
    _ = n 
}
}

优化的两种方式：

  1. 取址遍历 for i, n := range &arr
  2. 对数组做切片引用 for i, n := range arr[:]
arr := [...]int{102400:0}
  for i, n := range &arr {
  	// do anything
}

二、Select

select 是 Go 中的一个控制结构，类似于用于 channel 的 switch 语句。每个 case 必须是一个 channel 操作，要么是发送要么是接收。

select 能让 goroutine 同事等待 多个 channel 的可读可写。

当满足多个 case 时，select 随机执行一个可运行的 case。
如果没有 case 可运行，它将阻塞，直到有 case 可运行。
一个默认的子句应该总是可运行的。

select {
case i := <-c:
    // 使用 i
default:
    // 从 c 中接收会阻塞时执行
}

package main

import "fmt"

func fibonacci(c, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case c <- x:
			x, y = y, x+y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibonacci(c, quit)
}
/*
0
1
1
2
3
5
8
13
21
34
quit
*/

三、Defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

package main

import "fmt"

func main() {
	defer fmt.Println("world")

	fmt.Println("hello")
}

3-1 Defer 在当前函数末尾调用执行

被 defer 调用是在包含 defer 的函数末尾，而非同个代码块的末尾。

如果在一个长时间运行的函数内的一个循环内调用 defer 用于清理资源，则会出错。

package main
import (  
    "fmt"
    "os"
    "path/filepath"
)
func main() {  
    if len(os.Args) != 2 {
        os.Exit(-1)
    }
    start, err := os.Stat(os.Args[1])
    if err != nil || !start.IsDir(){
        os.Exit(-1)
    }
    var targets []string
    filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if !fi.Mode().IsRegular() {
            return nil
        }
        targets = append(targets,fpath)
        return nil
    })
    for _,target := range targets {
        f, err := os.Open(target)
        if err != nil {
            fmt.Println("bad target:",target,"error:",err) //prints error: too many open files
            break
        }
        defer f.Close() 
      	//will not be closed at the end of this code block
        //do something with the file...
    }
}

解决方式：将需要清理资源的代码，包装成函数，在函数内部调用 defer。

package main
import (  
    "fmt"
    "os"
    "path/filepath"
)
func main() {  
    if len(os.Args) != 2 {
        os.Exit(-1)
    }
    start, err := os.Stat(os.Args[1])
    if err != nil || !start.IsDir(){
        os.Exit(-1)
    }
    var targets []string
    filepath.Walk(os.Args[1], func(fpath string, fi os.FileInfo, err error) error {
        if err != nil {
            return err
        }
        if !fi.Mode().IsRegular() {
            return nil
        }
        targets = append(targets,fpath)
        return nil
    })
    for _,target := range targets {
        func() {
            f, err := os.Open(target)
            if err != nil {
                fmt.Println("bad target:",target,"error:",err)
                return
            }
            defer f.Close() //ok
            //do something with the file...
        }()
    }
}

3-2 Defer 先传值后调用

Defer 的函数，传入的参数会立刻拷贝求值，直到外层函数返回该函数前都不会被调用。

package main

import "fmt"

func main() {
	a := 1
	defer fmt.Printf("defer %v\n", a)
	a = 2;
	fmt.Printf("main %v\n", a)
}
/*
main 2
defer 1
*/

解决方式：向 defer 传入匿名函数

因为拷贝的是函数指针，所以会在外层函数执行完毕在计算参数

package main

import "fmt"

func main() {
	a := 1
	defer func() { fmt.Printf("defer %v\n", a) }()
	a = 2
	fmt.Printf("main %v\n", a)
}
/*
main 2
defer 2
*/

3-2-1 defer 求值抛错

由于先求值，但传入的参数为空等情况，会导致抛错。

type Test struct {
    Max int
}

func (t *Test) Println() {
    fmt.Println(t.Max)
}

func deferExec(f func()) {
    f()
}

func call() {
    var t *Test
  	// 求值时，t 为 nil
    defer deferExec(t.Println)

    t = new(Test)
}

3-3 多个 defer 的执行顺序是 LIFO（先进后出）

package main

import "fmt"

func main(){
    defer func(){
        fmt.Println("1")
    }()

    defer func(){
        fmt.Println("2")
    }()

    defer func(){
        fmt.Println("3")
    }()


}
/*
3
2
1
*/

四、Panic & Recover

  • Panic： 能够改变程序的控制流，函数调用panic 时会立刻停止执行函数的其他代码，并在执行结束后在当前 Goroutine 中递归执行调用方的延迟函数调用 defer；
  • Recover： 可以中止 panic 造成的程序崩溃。它是一个只能在 defer 中发挥作用的函数，在其他作用域中调用不会发挥任何作用；

注意：

  • panic 只会触发当前 Goroutine 的延迟函数调用；
  • recover 只有在 defer 函数中调用才会生效；
  • panic 允许在 defer 中嵌套多次调用；
package main
import "fmt"
func main() {  
    defer func() {
        fmt.Println("recovered:",recover())
    }()
    panic("not good")
}

4-1 Recover 只能在 Defer 一层包裹下调用

// recover 不可在其他函数中包裹调用
package main
import "fmt"
func doRecover() {  
    fmt.Println("recovered =>",recover()) //prints: recovered => <nil>
}
func main() {  
    defer func() {
        doRecover() //panic is not recovered
    }()
    panic("not good")
}

4-2 Panic 只触发当前 Goroutine 的 Defer 调用 - 跨协程失效

多个 Goroutine 之间没有太多的关联，一个 Goroutine 在 panic 时也不应该执行其他 Goroutine 的延迟函数。

package main

import (
	"time"
)

func main() {
	defer println("in main")
	go func() {
		defer println("in goroutine")
		panic("")
	}()

	time.Sleep(1 * time.Second)
}
// main 函数中的 defer 语句并没有执行，执行的只有当前 Goroutine 中的 defer。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P5aqJh4p-1585530422473)(Go-Keywords.assets/image-20200313160302172.png)]

4-3 Panic 可嵌套调用

package main

import (
	"fmt"
)

func main() {
	defer fmt.Println("in main")
	defer func() {
		defer func() {
			panic("panic again and again")
		}()
		panic("panic again")
	}()

	panic("panic once")
}
// 注意 Defer 的触发顺序（LIFO）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0MZl2SaV-1585530422474)(Go-Keywords.assets/image-20200313160752563.png)]

4-4 VS Errors Interface

通常情况下往往使用 Errors 接口用于异常情况的处理

只有在程序无法在异常情况下继续正常执行的时候，使用 panic 来终止程序，再使用 recover 恢复程序，

一般情况下，应该避免使用 panic 和 recover，尽可能使用 errors 替代。

4-4-1 使用 panic 的应用场景

  1. 不可恢复的错误，让程序不能继续进行。
    比如说Web服务器无法绑定到指定端口。在这种情况下，panic是合理的，因为如果端口绑定失败接下来的逻辑继续也是没有意义的。
  2. coder的人为错误
    假设我们有一个接受指针作为参数的方法，然而使用了nil作为参数调用此方法。在这种情况下，我们可以用panic，因为该方法需要一个有效的指针

4-4-2 Errors Interface

type error interface {
    Error() string
}
type networkProblem struct {
	message string
	code    int
}
func (np networkProblem) Error() string {
	return fmt.Sprintf("network error! message: %s, code: %v", np.message, np.code)
}

func main() {
  np := networkProblem{
	message: "we received a problem",
	code:    404,
}
fmt.Println(np.Error())
// prints "network error! message: we received a problem, code: 404"
}

五、Make & New

当我们想要在 Go 语言中初始化一个结构时，可能会用到两个不同的关键字 — make 和 new。

  • make 的作用是初始化内置的数据结构，即变量的内部机构：切片、哈希表和 Channel；
  • new 的作用是根据传入的类型在堆上分配一片内存空间并返回指向这片内存空间的指针；

golang-make-and-ne

5-1 初始化时的栈和堆变量

Go 中，使用 new() 或者 make() 创建变量，变量的位置（栈、堆）是由编译器决定的。编译器根据变量的大小和泄露分析的结果来决定分配的位置。这意味着，在局部变量上返回引用是没有问题的。

// 获取变量分配的位置
// If you need to know where your variables are allocated pass the "-m" gc flag to "go build" or "go run" 
go run -gcflags -m app.go
LSYHhhhh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go 关键字
weixin_42720316的博客
04-09 249
1， const 关键字用来定义常量 const name type = value （不论全局还是局部，必须要赋值） var 在函数体外用来全局变量的声明和赋值 var name type = value（值可省） type 用来接口和结构的声明 type name struct{} type name interface{} ...
go语言关键字图示
weixin_34004750的博客
04-23 141
Go语言一共有25个关键字，除了select，上文基本上已经一网打尽了。为了加深印象，我们用一张结构图来说明一下： 这张图如果看不清的话，我们将其拆成两张图，再注掉分支流程那部分的局部图： 分支流程部分的放大图：...
go语言关键字
weixin_44837729的博客
06-20 3169
1.break：break用于跳出循环 2.default：用于选择结构的默认选项（switch、select） 3.func：用于函数定义 4.select：Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。 5.case：选择结构标签 6.chan：定义channel 7.interface：定义接口 8.const：定义常量 9.continue：跳过本次循环 10.defer：延迟执行函数 11.go：并发执行 12.map：ma
go的25个关键字
qq_27373475的博客
08-06 948
go的25个关键字： break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return va...
go中的关键字-go(下)
爱无止
11-29 598
1. goroutine源码分析纯爱小说 https://www.shupu.org/ 1.1 初始化 　　go程序的启动流程分为四步 call osinit， 这里就是设置了全局变量ncpu = cpu核心数量 call schedinit make & queue new G （runtime.newproc, go func()也是调用这个函数来创建goroutine） c...
良好企业文化的塑造-海尔带给我们的启示-关键词.doc
12-22
企业内部推行“日清工作法”，即每天对工作进行清理和总结，发现问题立即改正，确保工作质量和效率。这种严谨的质量文化，使得海尔产品在全球市场上赢得了良好的口碑。 此外，海尔的企业文化还体现在其“持续创新”...
Go-gads-GoogleAdwordsUnofficialAPI
08-13
《Go-gads-GoogleAdwordsUnofficialAPI：Go语言实现的非官方Google AdWords API详解》 在数字营销领域，Google AdWords是一个强大的工具，它允许企业通过在线广告来推广产品和服务。然而，直接使用AdWords的官方API...
Go-ZiMuZu.tvAlfredWorkflowGolang实现
08-14
Golang，又名Go语言，是由Google公司开发的一种静态类型的、编译型的、并发型且具有垃圾回收功能的编程语言。它的设计目标是提高开发者的生产力和代码的运行效率，特别适合于构建网络服务和系统工具。在Alfred ...
go-redis-pubsub-example
05-21
总结来说，"go-redis-pubsub-example"项目是一个很好的学习资源，它演示了如何使用Go语言和`gopkg.in/redis.v2`库来实现Redis的发布订阅功能，对于理解Go语言的并发编程以及Redis的通信机制有着实际的应用价值。
Go-mafsa-MA-FSA实现拥有最小完美哈希
08-14
总结来说，"Go-mafsa-MA-FSA实现拥有最小完美哈希"是一个关于使用Go语言实现高效字符串处理和存储的工具，结合了MA-FSA的快速搜索能力和最小完美哈希的空间优化。这个工具对于处理大规模字符串集合，如日志分析、...
go基础语法之关键字
u011385940的专栏
03-15 830
在项目中新建api目录，定义a.go文件。
【Go】Go 文本匹配 - 正则表达式基础与编程中的应用
Tsang的博客
08-16 922
本文共计8361字，预计阅读时间18分钟
Go，从命名开始！Go的关键字和标识符全列表手册和代码示例！
最新发布
Lamb的博客
10-20 177
关键字（Keywords）是编程语言中预定义的一组特殊词汇，每个关键字都有一个明确的功能和用途。在Go编程语言中，关键字起着构建程序逻辑框架的作用，是程序语义和结构的基础。本篇文章旨在深入探究关键字在Go中的定位与应用，以理解其在程序设计中的重要性。Go语言有25个预定义的关键字，这些关键字用于各种特定目的，从声明变量和函数，到流程控制和并发编程。标识符是编程语言中用于识别各种编程元素（如变量、函数、类型等）的名字。在Go语言中，标识符有一组特定的规则和约定。下面将详细解析这些规则和特性。
Go 中用range关键字获取命令行参数
weixin_42720316的博客
04-10 165
1 package main 2 3 import "fmt" 4 import "os" 5 6 func main(){ 7 fmt.Println(len(os.Args)) 8 for i, arg := range os.Args{ 9 fmt.Println(i, arg) 10 } 11 } 输出 ...
一文详解Go的25个关键字含义、用途和代码示例详解
SteveRocket's-Blog
06-13 1193
一文详解Go的25个关键字含义、用途和代码示例详解 Go语言中的关键字是编写程序的基本构建块，它们具有不同的作用。通过使用这些关键字，可以定义变量、函数、类型、接口、映射、包、遍历数据结构、返回值、多路复用、结构体、条件语句、类型、变量、跳出循环、匹配条件、定义通道、定义常量、跳过循环、匹配默认条件、在函数返回前执行操作、匹配否定条件、在switch语句中转移控制流、实现循环结构、定义函数、启动goroutine、跳转到指定标签处执行代码、根据条件执行语句块、导入其他包中的函数和类型、定义接口等，实现不同的
【go语言 基础系列】关键字、内置数据及声明
natpan的博客
10-15 204
【关键字】 if else for range select switch case break continue fallthrough package import var type const struct func interface map chan defa...
Golang基础(闭包、值传递与引用传递)
qq_31387691的博客
10-20 1438
一.闭包概述 闭包不是Go语言独有的概念,在很多编程语言中都有闭包 闭包就是解决局部变量不能被外部访问一种解决方案 是把函数当作返回值的一种应用 二.代码演示 总体思想为:在函数内部定义局部变量,把另一个函数当作返回值,局部变量对于返回值函数就相当于全局变量,所以多次调用返回值函数局部变量的值跟随变化 package main ​ import "fmt" ​ func main() { //res其实就是test1返回值函数,和之前匿名函数变量一个道理
go语言的25个关键字（基础）
Zoffan的博客
02-20 3632
go语言的25个关键字 程序声明 1-2 import 导入，package 包（1，文件名和包名不需要一致，包名约定使用小写字符。2，一个go包里面的多个文件必须使用相同的包名，3，一个包就是一个文件夹。4，包名导入的是默认名称，可以起别的名字覆盖默认名称，import by “bytes”） 程序实体的定义和声明 3 chan 通道（就是因为channel，才让go语言不同于其他语言，channel理解为消息队列，先进先出，创建channel有一下几种形式， 下面展示一些 创建channel。 var
TextRank算法抽取关键词
热门推荐
GodxvA
09-17 1万+
PageRank由于TextRank是由大名鼎鼎的Google的PageRank算法转化而来，所以这里先介绍一下PageRank算法。PageRank最开始用来计算网页的重要性。在衡量一个网页的排名时，直觉告诉我们： （1）一个网页被更多网页链接时，就应该越重要，其排名就应该越靠前。 （2）排名高的网页应具有更大的表决权，即当一个网页被排名高的网页所链接时，其重要性也应该提高。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值