Golang数据流处理：掌握Reader和Writer接口的技巧

Golang数据流处理：掌握Reader和Writer接口的技巧

    • 引言
    • 理解Reader和Writer接口
      • Reader接口的定义和基本方法
      • Writer接口的定义和基本方法
    • Reader接口的深入探讨
      • Reader接口的实现示例
        • 使用io.Reader读取文件内容
        • 从网络连接中读取数据
      • 常用Reader类型及其应用场景
        • strings.Reader
        • bytes.Buffer
        • os.File
      • 自定义Reader实现
    • Writer接口的深入探讨
      • Writer接口的实现示例
        • 使用io.Writer写入文件内容
        • 向网络连接中写入数据
      • 常用Writer类型及其应用场景
        • bytes.Buffer
        • os.File
        • bufio.Writer
      • 自定义Writer实现
    • Reader和Writer组合使用技巧
      • 利用io.TeeReader进行数据分流处理
      • 使用io.MultiWriter进行多重写入操作
    • 高级技巧：缓冲与性能优化
      • 使用bufio.Reader和bufio.Writer进行缓冲操作提升性能
        • bufio.Reader
        • bufio.Writer
      • 数据流中的错误处理最佳实践
    • 实战案例：构建高效的数据传输系统
      • 案例背景与需求分析
      • 系统架构设计与Reader/Writer角色分配
      • 完整代码实现与解释
      • 代码解释
    • 总结

在这里插入图片描述

引言

在现代软件开发中，数据流处理是一个常见且重要的任务。Golang（也称Go语言）作为一门高效、简洁的编程语言，提供了强大的Reader和Writer接口来帮助开发者处理数据流。这两个接口是Golang io包中的核心组件，广泛应用于文件操作、网络通信和数据处理等领域。

理解并正确使用Reader和Writer接口，对于提高程序的可读性、维护性和性能至关重要。在这篇文章中，我们将深入探讨Golang的Reader和Writer接口，从基本定义到高级用法，以及如何在实际项目中有效地应用它们。无论您是需要读取文件、处理网络数据，还是优化数据传输性能，本教程都将为您提供实用的指导和丰富的代码示例。

接下来，我们将从基础开始，一步步揭开Golang Reader和Writer接口的神秘面纱，并探索它们在实际开发中的强大功能。

理解Reader和Writer接口

在Golang中，Reader和Writer接口是数据流处理的基础。这两个接口定义了标准化的数据读取和写入方法，使得不同类型的数据源和目标能够以统一的方式进行操作。理解这两个接口的基本定义和用法，是掌握Golang数据流处理的关键。

Reader接口的定义和基本方法

Reader接口位于Golang的io包中，其核心方法是：

type Reader interface {
    Read(p []byte) (n int, err error)
}

  • 参数说明：

    • p []byte: 这是一个字节切片，用于存储读取到的数据。

  • 返回值说明：

    • n int: 表示成功读取的字节数。
    • err error: 如果读取过程中发生错误，将返回一个非nil的错误值；如果读取到文件末尾，通常会返回io.EOF。

通过实现这个接口，您可以定义自己的数据源，并使用标准库中的工具对其进行操作。

Writer接口的定义和基本方法

同样地，Writer接口也位于io包中，其核心方法是：

type Writer interface {
    Write(p []byte) (n int, err error)
}

  • 参数说明：

    • p []byte: 包含要写入的数据的字节切片。

  • 返回值说明：

    • n int: 表示成功写入的字节数。
    • err error: 如果写入过程中发生错误，将返回一个非nil的错误值。

通过实现这个接口，您可以定义自己的数据目标，并使用标准库中的工具对其进行操作。

Reader接口的深入探讨

Reader接口是Golang中处理数据读取操作的核心接口。通过实现这个接口，您可以从各种数据源中读取数据，包括文件、网络连接、内存缓冲区等。在本节中，我们将探讨如何使用和实现Reader接口，并介绍一些常用的Reader类型及其应用场景。

Reader接口的实现示例

使用io.Reader读取文件内容

要从文件中读取数据，您可以使用标准库中的os.File类型，它已经实现了Reader接口。以下是一个简单的示例，展示如何从文件中读取数据：

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    buffer := make([]byte, 1024)
    for {
        n, err := file.Read(buffer)
        if err != nil && err != io.EOF {
            fmt.Println("Error reading file:", err)
            return
        }
        if n == 0 {
            break
        }
        fmt.Print(string(buffer[:n]))
    }
}

在这个示例中，我们打开一个名为example.txt的文件，然后使用一个字节切片作为缓冲区来逐块读取文件内容。

从网络连接中读取数据

同样地，您也可以从网络连接中读取数据，因为网络连接通常也实现了Reader接口。以下是一个简单的TCP客户端示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        fmt.Println("Error connecting to server:", err)
        return
    }
    defer conn.Close()

    request := "GET / HTTP/1.0\r\n\r\n"
    conn.Write([]byte(request))

    buffer := make([]byte, 4096)
    for {
        n, err := conn.Read(buffer)
        if err != nil {
            fmt.Println("Error reading from connection:", err)
            return
        }
        if n == 0 {
            break
        }
        fmt.Print(string(buffer[:n]))
    }
}

在这个示例中，我们连接到一个服务器并发送HTTP请求，然后读取服务器响应的数据。

常用Reader类型及其应用场景

strings.Reader

strings.Reader用于从字符串中读取数据，非常适合处理小型文本数据：

package main

import (
    "fmt"
    "strings"
)

func main() {
    reader := strings.NewReader("Hello, Golang!")
    
    buffer := make([]byte, 8)
    for {
        n, err := reader.Read(buffer)
        if err != nil && err != io.EOF {
            fmt.Println("Error reading string:", err)
            return
        }
        if n == 0 {
            break
        }
        fmt.Print(string(buffer[:n]))
    }
}
bytes.Buffer

bytes.Buffer是一个可变大小的字节缓冲区，实现了多个接口，包括Reader和Writer。它非常适合在内存中处理二进制或文本数据：

package main

import (
    "bytes"
    "fmt"
)

func main() {
	buffer := bytes.NewBufferString("Buffered data in memory.")
	
	data := make([]byte, 10)
	for {
		n, err := buffer.Read(data)
		if err != nil && err != io.EOF {
			fmt.Println("Error reading buffer:", err)
			return
		}
		if n == 0 {
			break
		}
		fmt.Print(string(data[:n]))
	}
}
os.File

如前所述，os.File用于文件操作，是最常用的Reader之一。

自定义Reader实现

要创建一个自定义Reader，只需实现其核心方法。以下是一个简单的自定义Reader示例，该Reader每次只返回字符’a’：

package main

import (
	"fmt"
	"io"
)

type aReader struct{}

func (a aReader) Read(p []byte) (int, error) {
	for i := range p {
		p[i] = 'a'
	}
	return len(p), nil
}

func main() {
	reader := aReader{}
	buffer := make([]byte, 8)

	n, _ := reader.Read(buffer)
	fmt.Println(string(buffer[:n])) // 输出: aaaaaaaa
}

在这个示例中，我们实现了一个简单的自定义Reader，它会将传入缓冲区填充为字符’a’。

Writer接口的深入探讨

Writer接口与Reader接口相辅相成，是Golang中处理数据写入操作的核心接口。通过实现这个接口，您可以将数据写入各种目标，包括文件、网络连接、内存缓冲区等。在本节中，我们将探讨如何使用和实现Writer接口，并介绍一些常用的Writer类型及其应用场景。

Writer接口的实现示例

使用io.Writer写入文件内容

要将数据写入文件，您可以使用标准库中的os.File类型，它已经实现了Writer接口。以下是一个简单的示例，展示如何将数据写入文件：

package main

import (
    "fmt"
    "os"
)

func main() {
    file, err := os.Create("output.txt")
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    defer file.Close()

    data := []byte("Hello, Golang!\n")
    _, err = file.Write(data)
    if err != nil {
        fmt.Println("Error writing to file:", err)
        return
    }

    fmt.Println("Data written to file successfully.")
}

在这个示例中，我们创建一个名为output.txt的文件，然后将字符串数据写入其中。

向网络连接中写入数据

同样地，您也可以向网络连接中写入数据，因为网络连接通常也实现了Writer接口。以下是一个简单的TCP客户端示例：

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        fmt.Println("Error connecting to server:", err)
        return
    }
    defer conn.Close()

    request := "GET / HTTP/1.0\r\n\r\n"
    _, err = conn.Write([]byte(request))
    if err != nil {
        fmt.Println("Error writing to connection:", err)
        return
    }

    fmt.Println("Request sent successfully.")
}

在这个示例中，我们连接到一个服务器并发送HTTP请求。

常用Writer类型及其应用场景

bytes.Buffer

bytes.Buffer不仅可以用于读取，还可以用于写入数据。它非常适合在内存中处理二进制或文本数据：

package main

import (
	"bytes"
	"fmt"
)

func main() {
	var buffer bytes.Buffer
	
	data := []byte("Buffered data in memory.")
	n, err := buffer.Write(data)
	if err != nil {
		fmt.Println("Error writing to buffer:", err)
		return
	}

	fmt.Printf("%d bytes written to buffer.\n", n)
	fmt.Println(buffer.String())
}
os.File

如前所述，os.File用于文件操作，是最常用的Writer之一。

bufio.Writer

通过使用带缓冲的Writer，可以显著提高I/O操作的效率。以下是使用bufio.Writer进行缓冲写入的示例：

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	file, err := os.Create("buffered_output.txt")
	if err != nil {
		fmt.Println("Error creating file:", err)
		return
	}
	defer file.Close()

	writer := bufio.NewWriter(file)

	data := []byte("Buffered write example.\n")
	n, err := writer.Write(data)
	if err != nil {
		fmt.Println("Error writing to buffer:", err)
		return
	}

	writer.Flush() // 确保所有缓冲的数据都被写出

	fmt.Printf("%d bytes written to file.\n", n)
}

自定义Writer实现

要创建一个自定义Writer，只需实现其核心方法。以下是一个简单的自定义Writer示例，该Writer将所有输入转换为大写字母并输出到标准输出：

package main

import (
	"fmt"
	"strings"
)

type upperCaseWriter struct{}

func (u upperCaseWriter) Write(p []byte) (int, error) {
	output := strings.ToUpper(string(p))
	fmt.Print(output)
	return len(p), nil
}

func main() {
	writer := upperCaseWriter{}
	data := []byte("Hello, Golang!\n")

	n, _ := writer.Write(data) // 输出: HELLO, GOLANG!
	fmt.Printf("%d bytes written.\n", n)
}

在这个示例中，我们实现了一个简单的自定义Writer，它会将传入的数据转换为大写字母后输出。

Reader和Writer组合使用技巧

在实际应用中，Reader和Writer接口通常需要组合使用，以实现复杂的数据流操作。Golang提供了一些强大的工具函数，可以帮助开发者更高效地处理数据流。在本节中，我们将探讨一些常用的组合使用技巧，包括数据分流和多重写入操作。

利用io.TeeReader进行数据分流处理

io.TeeReader是一个非常有用的工具，它允许您在从一个Reader读取数据的同时，将读取到的数据写入到一个Writer中。这对于需要同时处理和记录数据的场景非常有用。例如，在读取HTTP响应时，您可能希望将响应内容记录到日志文件中：

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	resp, err := http.Get("http://example.com")
	if err != nil {
		fmt.Println("Error fetching URL:", err)
		return
	}
	defer resp.Body.Close()

	file, err := os.Create("response_log.txt")
	if err != nil {
		fmt.Println("Error creating file:", err)
		return
	}
	defer file.Close()

	tee := io.TeeReader(resp.Body, file)

	buffer := make([]byte, 1024)
	for {
		n, err := tee.Read(buffer)
		if err != nil && err != io.EOF {
			fmt.Println("Error reading response:", err)
			return
		}
		if n == 0 {
			break
		}
		fmt.Print(string(buffer[:n]))
	}

	fmt.Println("Response logged successfully.")
}

在这个示例中，我们使用io.TeeReader来读取HTTP响应，并将其内容同时写入到控制台和日志文件。

使用io.MultiWriter进行多重写入操作

io.MultiWriter允许您将相同的数据同时写入多个目标。这对于需要将日志信息同时输出到多个地方（例如文件和标准输出）的场景非常有用：

package main

import (
    "fmt"
    "io"
    "os"
)

func main() {
    file, err := os.Create("multi_output.txt")
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    defer file.Close()

    writer1 := os.Stdout
    writer2 := file

    multiWriter := io.MultiWriter(writer1, writer2)

    data := []byte("This is a test of MultiWriter.\n")
    _, err = multiWriter.Write(data)
    if err != nil {
        fmt.Println("Error writing to multiple destinations:", err)
        return
    }

    fmt.Println("Data written to multiple destinations successfully.")
}

在这个示例中，我们创建了一个多重写入器，将数据同时写入标准输出和文件。

通过这些技巧，您可以更灵活地管理数据流，满足不同的应用需求。

高级技巧：缓冲与性能优化

在处理大量数据时，直接进行I/O操作可能会导致性能瓶颈。通过使用缓冲技术，您可以显著提高程序的效率。Golang提供了bufio包，用于实现带缓冲的I/O操作。在本节中，我们将探讨如何使用缓冲技术提升性能，并讨论数据流中的错误处理最佳实践。

使用bufio.Reader和bufio.Writer进行缓冲操作提升性能

bufio.Reader

bufio.Reader为读取操作提供了一个缓冲层，从而减少了底层I/O调用的次数，提高了读取效率。以下是使用bufio.Reader读取文件的示例：

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("large_file.txt")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    reader := bufio.NewReader(file)
    
    for {
        line, err := reader.ReadString('\n')
        if err != nil {
            if err == io.EOF {
                break
            }
            fmt.Println("Error reading line:", err)
            return
        }
        fmt.Print(line)
    }

    fmt.Println("File read successfully with buffering.")
}

在这个示例中，我们使用bufio.NewReader创建了一个带缓冲的Reader，以提高读取大文件时的效率。

bufio.Writer

bufio.Writer为写入操作提供了一个缓冲层，从而减少了底层I/O调用的次数，提高了写入效率。以下是使用bufio.Writer写入文件的示例：

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    file, err := os.Create("buffered_write.txt")
    if err != nil {
        fmt.Println("Error creating file:", err)
        return
    }
    defer file.Close()

    writer := bufio.NewWriter(file)

    data := []byte("This is an example of buffered writing.\n")
    
    _, err = writer.Write(data)
    if err != nil {
        fmt.Println("Error writing to buffer:", err)
        return
    }

    writer.Flush() // 确保所有缓冲的数据都被写出

    fmt.Println("Data written to file successfully with buffering.")
}

在这个示例中，我们使用bufio.NewWriter创建了一个带缓冲的Writer，以提高写入大文件时的效率。

数据流中的错误处理最佳实践

在处理数据流时，错误处理是一个重要的环节。以下是一些常见的错误处理策略：

  1. 检查错误并采取适当措施：在每次I/O操作后检查返回的错误，并根据错误类型采取相应措施。例如，对于EOF（End of File）错误，可以安全地忽略或终止读取循环。

  2. 日志记录：对于无法立即解决的错误，将其记录到日志中以便后续分析和调试。

  3. 资源释放：确保所有资源（如文件、网络连接等）在发生错误时得到正确释放，以避免资源泄漏。

  4. 用户通知：对于影响用户操作的严重错误，及时通知用户并提供有用的信息以帮助解决问题。

通过合理地应用这些技巧，您可以显著提高程序的数据处理性能，并增强其稳定性和可靠性。

实战案例：构建高效的数据传输系统

在这一部分，我们将通过一个实际案例来展示如何使用Golang的Reader和Writer接口构建一个高效的数据传输系统。这个系统将模拟从一个数据源读取数据并将其传输到多个目标，同时应用我们之前讨论的缓冲和性能优化技巧。

案例背景与需求分析

假设我们需要构建一个数据传输系统，该系统从一个大型文件中读取数据，并将其同时写入到多个输出目标（例如，日志文件和网络服务）。为了确保高效性，我们需要使用缓冲技术来最小化I/O操作的开销，并确保在发生错误时能够正确处理。

系统架构设计与Reader/Writer角色分配

  1. 数据源：一个大型的文本文件。
  2. 数据目标：一个本地日志文件和一个远程网络服务。
  3. 核心组件：
    • 使用bufio.Reader从文件中读取数据。
    • 使用io.MultiWriter将数据同时写入日志文件和网络连接。
    • 使用bufio.Writer对写入操作进行缓冲。

完整代码实现与解释

以下是完整的代码实现：

package main

import (
    "bufio"
    "fmt"
    "io"
    "net"
    "os"
)

func main() {
    // 打开数据源文件
    sourceFile, err := os.Open("large_data.txt")
    if err != nil {
        fmt.Println("Error opening source file:", err)
        return
    }
    defer sourceFile.Close()

    // 创建本地日志文件
    logFile, err := os.Create("data_log.txt")
    if err != nil {
        fmt.Println("Error creating log file:", err)
        return
    }
    defer logFile.Close()

    // 连接到远程网络服务
    conn, err := net.Dial("tcp", "example.com:9000")
    if err != nil {
        fmt.Println("Error connecting to network service:", err)
        return
    }
    defer conn.Close()

    // 创建带缓冲的Reader
    reader := bufio.NewReader(sourceFile)

    // 创建MultiWriter，将数据同时写入日志文件和网络连接
    multiWriter := io.MultiWriter(logFile, conn)

    // 创建带缓冲的Writer
    writer := bufio.NewWriter(multiWriter)

    buffer := make([]byte, 4096)
    
    for {
        n, err := reader.Read(buffer)
        if err != nil && err != io.EOF {
            fmt.Println("Error reading from source file:", err)
            return
        }
        if n == 0 {
            break
        }

        _, writeErr := writer.Write(buffer[:n])
        if writeErr != nil {
            fmt.Println("Error writing to targets:", writeErr)
            return
        }
        
        writer.Flush() // 确保所有缓冲的数据都被写出
    }

    fmt.Println("Data transfer completed successfully.")
}

代码解释

  • 打开数据源文件：使用标准库中的os.Open函数打开源文件。
  • 创建本地日志文件：使用os.Create函数创建一个新的日志文件。
  • 连接到远程网络服务：使用net.Dial函数建立TCP连接。
  • 创建带缓冲的Reader：使用bufio.NewReader为读取操作提供缓冲支持。
  • 创建MultiWriter：使用io.MultiWriter将相同的数据流发送到多个目标（即日志文件和网络连接）。
  • 创建带缓冲的Writer：使用bufio.NewWriter为写入操作提供缓冲支持，以提高效率。

通过以上步骤，我们构建了一个高效的数据传输系统，能够从大文件中读取数据并同时将其发送到多个目标。在实际应用中，这种模式可以广泛用于日志记录、数据同步和备份等场景。

总结

在本文中，我们深入探讨了Golang中的Reader和Writer接口，了解了它们在数据流处理中的重要性，并通过多个实用的示例展示了如何在实际开发中应用这些接口。以下是我们所涵盖的关键点：

  • 理解Reader和Writer接口：我们介绍了Reader和Writer接口的基本定义及其核心方法，帮助您掌握数据读取和写入的基础。

  • Reader接口的深入探讨：通过示例，我们展示了如何从文件、网络连接等多种数据源中读取数据，并介绍了常用的Reader类型，如strings.Reader、bytes.Buffer和os.File。

  • Writer接口的深入探讨：我们同样通过示例展示了如何将数据写入文件、网络连接等目标，并介绍了常用的Writer类型，如bytes.Buffer、os.File和带缓冲的bufio.Writer。

  • 组合使用技巧：通过介绍工具函数如io.TeeReader和io.MultiWriter，我们展示了如何同时处理和记录数据，以及如何将相同的数据流发送到多个目标。

  • 高级技巧：缓冲与性能优化：我们讨论了如何使用缓冲技术提升I/O操作的效率，以及在数据流处理中进行错误处理的最佳实践。

  • 实战案例：构建高效的数据传输系统：通过一个完整的代码实现，我们演示了如何结合使用上述技术构建一个高效的数据传输系统，从而满足复杂的数据处理需求。

希望这篇文章能够帮助您更好地理解并应用Golang中的Reader和Writer接口，以提高程序的数据处理能力和效率。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/876057.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

相图的科学应用，陶瓷材料创新

相图的科学应用，陶瓷材料创新

陶瓷材料因其优异的物理和化学性能，在航空航天、电子、生物医学等多个领域展现出广阔的应用前景。陶瓷材料的性能很大程度上取决于其微观结构，包括晶粒大小、相组成和分布。相图作为描述陶瓷材料在不同条件下的相变行为和相平衡关系的图表反映了陶瓷材料…
阅读更多...
10年Python程序员教你多平台采集10万+电商数据【附实例】

10年Python程序员教你多平台采集10万+电商数据【附实例】

10万级电商数据采集需要注意什么？ 在进行10万级电商数据采集时，有许多关键因素需要注意： 1. 采集平台覆盖：确保可以覆盖主流的电商平台，如淘宝、天猫、京东、拼多多等。 2. 数据字段覆盖：检查是否可以对平…
阅读更多...
什么是VHDX文件？

什么是VHDX文件？

VHDX文件是Docker环境中使用的一种虚拟硬盘文件格式，专门用于存储Docker容器 的镜像和数据。这种文件格式，VHDX，代表Virtual Hard Disk Extended，是一种用于虚拟化环境的硬盘文件格式，支持动态扩展、快照、加密等功能&…
阅读更多...
python基础知识 （五）--容器、索引、切片、字符串的遍历、查找、修改元素

python基础知识 （五）--容器、索引、切片、字符串的遍历、查找、修改元素

目录 容器 容器大总结 索引 切片 字符串的遍历 for循环语法： while循环语法： 查找元素 修改元素 例题 1.验证码 2.抽取大红包 3.a和b互换位置 容器 在Python中，常见容器有： （1）字符串&#x…
阅读更多...
C++：类和对象全解

C++：类和对象全解

C：类和对象全解 一、类的定义和初始化（一）类的定义1、类的成员变量（1）成员变量（2）成员函数 2、实例化对象（1）采用普通构造函数（2）采用初始化列表 …
阅读更多...
数据可视化与分析：数据时代的关键工具

数据可视化与分析：数据时代的关键工具

一、引言 数据可视化与分析是大数据时代中最为重要的技术之一。随着数据量的不断增加，如何有效地理解、解释和利用数据，已经成为各行各业面临的关键挑战。数据可视化通过图表、图形和互动界面将数据以直观的方式呈现，帮助用户快速识别数据中…
阅读更多...
SMA2:代码实现详解——Image Encoder篇（Hiera章）

SMA2:代码实现详解——Image Encoder篇（Hiera章）

SMA2:代码实现详解——Image Encoder篇（Hiera） 写在前面 大家在SMA2:代码实现详解——Image Encoder篇（FpnNeck）下的留言我已收到，感谢大家的支持，后面如果遇到比较难以讲清的部分可能会使用视频的形式。…
阅读更多...
Python 课程9-資料庫操作

Python 课程9-資料庫操作

前言 在现代软件开发中，数据库是核心组件之一，它负责数据的存储、管理和检索。无论是简单的应用程序还是复杂的企业级系统，数据库操作都是必不可少的。本教程将深入讲解如何使用 Python 进行数据库操作，涵盖使用 sqlite3 进行本地…
阅读更多...
OpenHarmony（鸿蒙南向开发）——轻量系统STM32F407芯片移植案例

OpenHarmony（鸿蒙南向开发）——轻量系统STM32F407芯片移植案例

往期知识点记录： 鸿蒙（HarmonyOS）应用层开发（北向）知识点汇总 鸿蒙（OpenHarmony）南向开发保姆级知识点汇总~ OpenHarmony（鸿蒙南向开发）——轻量和小型系统三方库移植指南…
阅读更多...
Android SystemUI组件（06）导航栏创建分析虚拟按键

Android SystemUI组件（06）导航栏创建分析虚拟按键

该系列文章总纲链接：专题分纲目录 Android SystemUI组件 本章关键点总结 & 说明： 说明：本章节持续迭代之前章节的思维导图，主要关注左侧SystemBars分析中导航栏部分即可。 1 导航栏创建之makeStatusBarView 通过上一篇文章的…
阅读更多...
代理IP设置后IP不变？可能的原因及解决方法

代理IP设置后IP不变？可能的原因及解决方法

在使用代理IP时，有时会遇到代理设置后IP地址却没有变化的情况。这种问题可能会让人感到困惑，但其实背后有多种原因。本文将详细探讨这些原因，并提供相应的解决方法，帮助你顺利解决问题。 可能的原因 代理IP设置后IP地址不变的原…
阅读更多...
Spring的核心思想

Spring的核心思想

目录 一、Spring要解决的问题 二、Spring的核心结构 三、核心思想 3.1.1 什么是IOC 3.1.2 IOC解决的问题：耦合 3.1.3 IOC和DI的区别 3.2.1 什么是AOP 3.2.2 AOP解决的问题：耦合 3.2.3 为什么叫做面向切面编程 一、Spring要解决的问题 问题1&am…
阅读更多...
maya-vray渲染蒙版

maya-vray渲染蒙版

要用一个叫vrayMulWrapper的材质球，把alpha Conterbution调到-1，勾选matte surface启用蒙版物体。
阅读更多...
爬虫逆向学习(六)：补环境过某数四代

爬虫逆向学习(六)：补环境过某数四代

声明：本篇文章内容是整理并分享在学习网上各位大佬的优秀知识后的实战与踩坑记录 引用博客： https://blog.csdn.net/shayuchaor/article/details/103629294 https://blog.csdn.net/qq_36291294/article/details/128600583 https://blog.csdn.net/weixin_…
阅读更多...
时序预测 | Matlab实现GA-CNN遗传算法优化卷积神经网络时间序列预测

时序预测 | Matlab实现GA-CNN遗传算法优化卷积神经网络时间序列预测

时序预测 | Matlab实现GA-CNN遗传算法优化卷积神经网络时间序列预测 目录 时序预测 | Matlab实现GA-CNN遗传算法优化卷积神经网络时间序列预测预测效果基本介绍程序设计参考资料 预测效果 基本介绍 时序预测 | Matlab实现GA-CNN遗传算法优化卷积神经网络时间序列预测&#xff…
阅读更多...
巴西电商市场规模、前景及支付方式（pix、Boleto）

巴西电商市场规模、前景及支付方式（pix、Boleto）

一、巴西电商市场分析 作为拉丁美洲最大经济体，巴西在拉丁美洲经济中占据领先地位，根据巴西地理与统计研究所(IBGE)的数据，2023年巴西GDP达到2.2万亿美元，跃居世界第九大经济体。数字化进程以及经济多元化推进正在推动该国中产阶…
阅读更多...
TiDB 数据库核心原理与架构_Lesson 01 TiDB 数据库架构概述课程整理

TiDB 数据库核心原理与架构_Lesson 01 TiDB 数据库架构概述课程整理

作者： 尚雷5580 原文来源： https://tidb.net/blog/beeb9eaf 注：本文基于 TiDB 官网 董菲老师 《TiDB 数据库核心原理与架构（101) 》系列教程之 《Lesson 01 TiDB 数据库架构概述》内容进行整理和补充。 课程链接：…
阅读更多...
PowerBI 关于FILTERS函数和VALUES函数

PowerBI 关于FILTERS函数和VALUES函数

本人是powerbi新手，最近在使用Filters()函数和Values()函数时，有点不太明白它们之间的区别，u有时它们得到的结果是一样的，有时却不一样。 官方文档里，Filters()是表示返回直接作为筛选器应用到 columnName 的值 FILT…
阅读更多...
凸优化学习（1）——什么是凸优化、凸集、凸函数

凸优化学习（1）——什么是凸优化、凸集、凸函数

🍅 写在前面 👨‍🎓 博主介绍：大家好，这里是hyk写算法了吗，一枚致力于学习算法和人工智能领域的小菜鸟。 🔎个人主页：主页链接（欢迎各位大佬光临指导） ⭐️近…
阅读更多...
Python之NumPy超详细学习指南：从入门到精通（上篇）

Python之NumPy超详细学习指南：从入门到精通（上篇）

文章目录 Python NumPy学习指南：从入门到精通第一部分：NumPy简介与安装1. 什么是NumPy？2. 安装NumPy使用pip安装：使用Anaconda安装： 第二部分：NumPy数组基础1. NumPy数组的创建从列表创建一维数组&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023