Go语言入门：熟练使用测试，质量就是“生命”｜青训营

0120

前言

不能正确的使用测试会带来什么？

在Go语言中，如果不能正确地编写和运行测试，可能会导致以下事故和严重后果：

  1. 错误的代码发布： 如果没有正确的测试覆盖，开发人员可能会发布包含错误的代码。这些错误可能导致应用程序崩溃、数据损坏或安全漏洞。没有充分的测试覆盖意味着无法捕捉和修复潜在的问题，从而导致错误的代码进入生产环境。

  2. 功能失效： 如果测试不充分或不正确，可能无法准确地验证代码的功能。这可能导致应用程序的某些功能无法正常工作，影响用户体验和系统的可用性。没有充分的测试覆盖意味着无法保证代码的正确性和功能性。

  3. 性能问题： 没有正确的性能测试，开发人员可能无法发现和解决潜在的性能问题。这可能导致应用程序在实际使用时出现性能瓶颈、资源耗尽或响应时间延迟等问题。性能问题可能对用户体验、系统的可扩展性和可靠性产生负面影响。

  4. 难以维护和调试： 没有良好的测试覆盖率，代码的可维护性和调试性会受到影响。缺乏测试意味着开发人员无法快速验证代码的正确性，也无法在修改代码时准确地检测到引入的错误。这可能导致调试过程变得困难和耗时，并增加代码维护的复杂性。

  5. 持续集成和部署问题： 在持续集成和部署过程中，缺乏正确的测试可能导致问题无法及时发现。这可能导致错误的代码被自动部署到生产环境中，从而引发严重的后果。缺乏自动化测试和集成测试可能使持续集成和部署流程变得不可靠和脆弱。

正确使用测试的重要性

  1. 保证代码质量： 测试是验证代码正确性的关键手段之一。通过编写全面的测试用例，可以确保代码在各种情况下都能按预期工作。测试可以帮助发现和修复潜在的错误、边界情况和异常情况，从而提高代码的质量和可靠性。

  2. 增强代码可维护性： 编写测试是一种良好的编程实践，它可以促使开发人员编写可测试、可组织和可维护的代码。编写可测试的代码意味着代码需要具有良好的模块化和低耦合性，这有助于代码的重用和维护。通过编写测试，开发人员可以更轻松地理解和修改代码，而不会破坏现有的功能。

  3. 提高代码可读性： 编写测试用例可以作为代码的文档，提供使用示例和预期行为。测试用例通常使用简洁明了的语法和清晰的命名，可以帮助其他开发人员更好地理解代码的意图和功能。良好的测试用例可以提高代码的可读性，减少他人理解和使用代码时的困惑。

  4. 支持重构和改进： 有充分的测试覆盖可以给开发人员信心，使他们能够进行重构和改进。重构是改进代码质量和可维护性的重要步骤，但在没有测试的情况下进行重构可能会引入错误。通过有力的测试，可以确保重构后的代码仍然正确工作，并且不会破坏现有的功能。

  5. 促进团队协作： 编写测试用例是团队协作的重要环节。测试用例可以作为开发人员之间的合同，明确代码的预期行为和接口。团队成员可以根据测试用例编写和调试代码，确保代码在各种环境和情况下都能正常工作。测试还可以帮助团队成员更好地理解和使用彼此编写的代码。

测试

Go语言中测试的分类

在Go语言中，常见的测试分类包括回归测试（Regression Testing）、集成测试（Integration Testing）和单元测试（Unit Testing）。

  1. 回归测试（Regression Testing）： 回归测试是用于验证已修改的代码是否影响了现有功能的测试。当进行代码更改、修复错误或添加新功能时，回归测试用于确保修改后的代码没有破坏原有的功能。回归测试通常是自动化的，通过运行一系列预先编写的测试用例来验证代码的正确性。在Go语言中，可以使用测试框架如testing来编写回归测试。

  2. 集成测试（Integration Testing）： 集成测试是用于验证不同组件或模块之间的交互是否正常的测试。在Go语言中，集成测试主要用于测试多个模块或服务之间的接口和协作。集成测试可以涉及多个模块的代码，包括外部依赖，例如数据库、网络服务等。集成测试可以帮助发现模块之间的集成问题，例如接口不一致、依赖错误等。在Go语言中，可以使用测试框架和工具来编写和运行集成测试，例如使用testing框架和httptest包来模拟HTTP请求和响应。

  3. 单元测试（Unit Testing）： 单元测试是对代码中最小的可测试单元进行验证的测试。在Go语言中，单元测试通常是对函数、方法或类型的独立单元进行测试。单元测试的目标是验证单元的行为是否符合预期，通常使用各种测试框架和工具来编写和运行单元测试。在Go语言中，可以使用testing框架和相关的断言库来编写单元测试。单元测试应该关注于测试单个功能点，并尽量减少对外部依赖的影响，通常使用模拟、存根或桩来隔离被测单元和外部依赖。

这些测试分类在Go语言中的使用是互补的。单元测试主要用于验证代码的独立单元的正确性，集成测试用于验证多个组件之间的交互，而回归测试用于验证修改后的代码是否破坏了原有的功能。通过综合运用这些测试分类，可以提高代码的质量、可靠性和可维护性，并确保代码在不同层面和环境下的正确性。

从回归测试到单元测试，其代码覆盖率逐步上升，但是成本却在逐步下降。

单元测试

在Go语言中，单元测试是对代码中最小的可测试单元进行验证的测试过程。以下是在Go语言中进行单元测试的详细步骤和常用技巧：

  1. 测试函数的命名和组织： 在Go语言中，测试函数的命名应以Test开头，后面跟随被测试函数的名称，并使用testing包提供的T类型参数来表示测试对象。例如，对于函数Add的单元测试，可以命名为TestAdd。为了组织测试函数，可以在与被测试代码相同的包中创建名为*_test.go的文件，并在其中编写测试函数。

  2. 使用测试框架和断言库： Go语言的标准库中提供了testing包，用于编写和运行单元测试。通过使用testing包提供的函数和类型，可以编写测试函数并执行测试。为了方便断言和验证测试结果，可以使用第三方的断言库，例如github.com/stretchr/testify/assert。这些库提供了丰富的断言函数，可以帮助编写更简洁和可读性更高的测试代码。

  3. 编写测试函数： 在测试函数中，可以调用被测试的函数，并使用断言函数来验证函数的行为和结果。测试函数应该覆盖不同的测试场景和边界情况，以确保被测试的代码在各种情况下都能按预期工作。可以使用t.Errorf或assert库中的断言函数来报告测试失败，并提供有关失败原因的详细信息。

  4. 运行单元测试： 在Go语言中，可以使用以下命令来运行单元测试：

    go test

    该命令会自动查找并执行当前目录及其子目录中的所有测试文件。它会输出测试结果和覆盖率报告，并指示测试是否通过。可以通过命令行参数来控制测试的行为，例如指定特定的测试文件或测试函数。

  5. 测试覆盖率分析： Go语言的测试工具还提供了测试覆盖率分析的功能，可以帮助评估测试的覆盖范围和质量。通过使用以下命令，可以生成测试覆盖率报告：

    go test -cover

    这将显示每个测试文件的覆盖率信息，并指示哪些代码行已被测试覆盖。

  6. 持续集成和自动化测试： 单元测试在持续集成和自动化测试中扮演重要角色。可以将单元测试与持续集成工具（如Jenkins、Travis CI等）集成，以确保每次代码提交都会自动运行测试，并及时发现潜在的问题。自动化测试可以提高开发效率，减少手动测试的工作量，并确保代码的质量和稳定性。

规则

在Go语言中，单元测试遵循一些命名规则和最佳实践，以确保测试代码的可读性、可维护性和一致性。

  1. 测试文件命名： Go语言的测试文件应该与被测试的源文件位于同一个包中，并以_test.go结尾。例如，对于名为example.go的源文件，对应的测试文件应该命名为example_test.go。

  2. 测试函数命名： 测试函数的命名应以Test开头，后面跟随被测试函数的名称，并使用驼峰命名法。例如，对于函数Add的单元测试，可以命名为TestAdd。如果被测试的函数有多个测试场景，可以在函数名称后面添加描述性的后缀，以区分不同的测试。例如，TestAdd_WithPositiveNumbers和TestAdd_WithNegativeNumbers。

  3. 使用t *testing.T参数： 在测试函数中，应使用t *testing.T作为参数，以便在测试过程中记录测试结果和错误信息。通过t参数，可以使用t.Errorf或t.Fatalf来报告测试失败，并提供有关失败原因的详细信息。

  4. 初始化和清理： 如果测试需要进行一些初始化或清理工作，可以使用测试函数提供的TestMain函数和t.Setup和t.Teardown方法来实现。TestMain函数在所有测试之前执行，并可以用于设置全局测试环境。t.Setup和t.Teardown方法可以在每个测试函数的开始和结束时执行，以进行测试的初始化和清理工作。

  5. 使用断言库： Go语言的标准库提供了基本的断言函数，例如t.Errorf和t.Fatalf，用于验证测试结果。然而，为了编写更简洁和可读性更高的测试代码，可以使用第三方的断言库，例如github.com/stretchr/testify/assert。这些库提供了丰富的断言函数，可以帮助编写更复杂的测试条件和验证测试结果。

  6. 覆盖率分析： Go语言的测试工具支持测试覆盖率分析，可以通过添加-cover标志来生成覆盖率报告。测试覆盖率报告显示了每个测试文件中被测试代码的覆盖情况，可以帮助评估测试的覆盖范围和质量。

  7. 表格驱动测试： 表格驱动测试是一种常用的测试技术，可以通过使用测试数据表和循环结构来简化和组织测试代码。通过将测试数据和预期结果放在表格中，可以更轻松地添加、修改和扩展测试场景。

  8. 并行测试： Go语言的测试工具支持并行运行测试，以提高测试的执行效率。可以通过添加-parallel标志来指定并行运行的测试数量。然而，需要注意的是，并行测试可能会引入并发问题，因此在编写并行测试时需要谨慎处理共享资源和竞争条件。

这些规则和技巧可以帮助编写干净、可读性高且易于维护的单元测试代码。遵循这些最佳实践，可以提高测试的质量和效率，并确保被测试的代码在各种情况下都能按预期工作。

示例

以下为单元测试的一个简单的示例：

// 源文件：math.go















package math





















// Add 函数将两个整数相加并返回结果




func Add(a, b int) int {




	return a + b


}




// 测试文件：math_test.go















package math





















import (





	"testing"





)







func TestAdd(t *testing.T) {


	result := Add(2, 3)


	expected := 5


	if result != expected {


		t.Errorf("Add(2, 3) = %d; expected %d", result, expected)


	}


}




func TestAdd_WithNegativeNumbers(t *testing.T) {
	result := Add(-2, -3)
	expected := -5
	if result != expected {
		t.Errorf("Add(-2, -3) = %d; expected %d", result, expected)
	}
}

在这个示例中，我们有一个名为Add的函数，它将两个整数相加并返回结果。我们编写了两个单元测试函数来测试这个函数的行为。

第一个测试函数TestAdd测试Add函数对正整数的处理。我们调用Add(2, 3)并将结果与期望值5进行比较。如果结果与期望值不相等，我们使用t.Errorf报告测试失败，并提供详细的错误信息。在这种情况下，如果Add(2, 3)的结果不是5，测试将失败。

第二个测试函数TestAdd_WithNegativeNumbers测试Add函数对负整数的处理。我们调用Add(-2, -3)并将结果与期望值-5进行比较。同样，如果结果与期望值不相等，测试将失败。

要运行这些测试，可以在命令行中使用go test命令：

$ go test

如果所有的测试通过，将会显示以下输出：

PASS



ok      example.com/math    0.001s

如果某个测试失败，将会显示类似以下输出：

--- FAIL: TestAdd (0.00s)

    math_test.go:12: Add(2, 3) = 6; expected 5
FAIL

exit status 1

FAIL    example.com/math    0.001s

在这种情况下，我们的第一个测试TestAdd失败了，因为Add(2, 3)的结果是6，而不是预期的5。

这个示例演示了如何编写基本的单元测试函数，并使用断言来验证测试结果。通过编写全面的测试函数并运行它们，我们可以确保被测试的代码在不同情况下都能按预期工作，并且可以及时发现和修复潜在的问题。

运用assert库

在进行单元测试时，我们可以使用第三方的assert（断言）库。

首先，确保已经安装了断言库：

go get github.com/stretchr/testify/assert

然后，我们可以使用断言库来编写更简洁和可读性更高的测试代码。

// 源文件：math.go















package math





















// Add 函数将两个整数相加并返回结果




func Add(a, b int) int {




	return a + b


}




// 测试文件：math_test.go















package math





















import (





	"testing"







	"github.com/stretchr/testify/assert"

)

func TestAdd(t *testing.T) {
	// 创建断言对象
	assert := assert.New(t)


	result := Add(2, 3)
	expected := 5

	// 使用断言进行验证
	assert.Equal(expected, result, "Add(2, 3) should return 5")
}

func TestAdd_WithNegativeNumbers(t *testing.T) {
	// 创建断言对象
	assert := assert.New(t)

	result := Add(-2, -3)
	expected := -5

	// 使用断言进行验证
	assert.Equal(expected, result, "Add(-2, -3) should return -5")
}

在这个示例中，我们导入了断言库github.com/stretchr/testify/assert，并使用assert.New(t)创建了一个断言对象。

然后，在每个测试函数中，我们使用断言对象的方法来进行验证。在这个示例中，我们使用了assert.Equal方法来比较结果和期望值，如果它们不相等，断言库会自动报告测试失败，并提供详细的错误信息。

要运行这些测试，可以在命令行中使用go test命令：

$ go test

如果所有的测试通过，将会显示以下输出：

PASS



ok      example.com/math    0.001s

如果某个测试失败，将会显示类似以下输出：

--- FAIL: TestAdd (0.00s)

    math_test.go:15: Add(2, 3) should return 5
FAIL

exit status 1

FAIL    example.com/math    0.001s

以上代码演示了如何使用断言库来编写更简洁和可读性更高的测试代码。断言库提供了丰富的断言方法，可以帮助编写更复杂的测试条件和验证测试结果。通过使用断言库，我们可以减少重复的代码，提高测试代码的可读性，并更容易地定位和修复测试失败的问题。

覆盖率

在Go语言中，单元测试的覆盖率是衡量测试代码对被测试代码的覆盖程度的指标。它表示在运行测试时，被测试代码中有多少行、分支、函数或语句被执行到。

为了计算覆盖率，Go语言提供了一个内置的工具 go test，它可以生成覆盖率报告。通过运行以下命令，我们可以生成覆盖率报告：

go test -cover

下面是一个示例，展示如何计算函数的覆盖率：

// 源文件：math.go















package math





















// Add 函数将两个整数相加并返回结果




func Add(a, b int) int {




	if a > 0 {
		return a + b
	}
	return b
}

// 测试文件：math_test.go















package math





















import (





	"testing"





)







func TestAdd(t *testing.T) {


	result := Add(2, 3)


	expected := 5


	if result != expected {


		t.Errorf("Add(2, 3) = %d; expected %d", result, expected)


	}


}

在这个示例中，math.go文件中的Add函数有两个分支。当a大于0时，它会执行return a + b，否则会执行return b。

测试文件math_test.go中的单元测试函数TestAdd只覆盖了Add函数的一个分支，即a > 0的情况。我们可以运行以下命令来查看覆盖率报告：

$ go test -cover

输出类似于：

PASS



coverage: 50.0% of statements
ok      example.com/math    0.001s

这表示我们的测试代码只覆盖了被测试代码中的50%语句。在这个例子中，我们只测试了Add函数的一个分支，因此覆盖率为50%。

为了提高覆盖率，我们可以编写更多的测试用例来覆盖更多的代码路径。下面是一个修改后的测试代码，覆盖了Add函数的两个分支：

// 测试文件：math_test.go















package math





















import (





	"testing"





)







func TestAdd(t *testing.T) {


	result := Add(2, 3)


	expected := 5


	if result != expected {


		t.Errorf("Add(2, 3) = %d; expected %d", result, expected)


	}



	result = Add(-2, 3)
	expected = 3
	if result != expected {
		t.Errorf("Add(-2, 3) = %d; expected %d", result, expected)
	}
}

现在，我们的测试代码覆盖了Add函数的所有分支。再次运行覆盖率报告命令：

$ go test -cover

输出类似于：

PASS



coverage: 100.0% of statements
ok      example.com/math    0.001s

现在，覆盖率为100%，表示我们的测试代码覆盖了被测试代码中的所有语句。

通过计算覆盖率，我们可以了解我们的测试代码覆盖了被测试代码的哪些部分，从而帮助我们判断测试的完整性和质量。同时，覆盖率报告还可以帮助我们发现被测试代码中可能存在的未覆盖的分支或语句，从而提醒我们编写更全面的测试用例。

Mock测试

在Go语言中，Mock测试是一种测试方法，用于模拟依赖项的行为，以便在测试中进行控制和验证。Mock测试可以用于替代真实的依赖项，以便更容易地测试被测代码的不同情况和边界条件。

为了进行Mock测试，我们可以使用一些第三方的库，例如 github.com/stretchr/testify/mock。这个库提供了一个简单而强大的Mock框架，用于创建和管理Mock对象。

下面是一个示例代码，展示如何使用 github.com/stretchr/testify/mock 库进行Mock测试：

首先，确保已经安装了 github.com/stretchr/testify/mock包：

go get github.com/stretchr/testify/mock

然后，我们可以使用该库来创建Mock对象，并定义它的行为。

// 源文件：email.go












package email













// Sender 接口定义了发送邮件的方法
type Sender interface {
	Send(to, subject, body string) error
}




// Client 是一个使用 Sender 接口发送邮件的客户端
type Client struct {
	Sender Sender
}




// SendEmail 使用 Client 的 Sender 发送邮件
func (c *Client) SendEmail(to, subject, body string) error {
	return c.Sender.Send(to, subject, body)
}

// 测试文件：email_test.go












package email













import (





	"testing"







	"github.com/stretchr/testify/assert"

	"github.com/stretchr/testify/mock"
)

// MockSender 是一个模拟的 Sender
type MockSender struct {
	mock.Mock
}




// Send 是模拟的 Send 方法
func (m *MockSender) Send(to, subject, body string) error {
	args := m.Called(to, subject, body)
	return args.Error(0)
}


func TestSendEmail_Success(t *testing.T) {
	// 创建 MockSender
	mockSender := new(MockSender)

	// 设置模拟的 Send 方法的行为
	mockSender.On("Send", "test@example.com", "Hello", "Hello, World!").Return(nil)

	// 创建 Client，并将 MockSender 设置为其依赖项
	client := &Client{
		Sender: mockSender,
	}

	// 调用被测试的方法
	err := client.SendEmail("test@example.com", "Hello", "Hello, World!")

	// 验证 MockSender 的方法是否被调用
	mockSender.AssertCalled(t, "Send", "test@example.com", "Hello", "Hello, World!")

	// 验证结果是否符合预期
	assert.NoError(t, err)
}

func TestSendEmail_Error(t *testing.T) {
	// 创建 MockSender
	mockSender := new(MockSender)

	// 设置模拟的 Send 方法的行为
	mockSender.On("Send", "test@example.com", "Hello", "Hello, World!").Return(errors.New("failed to send email"))

	// 创建 Client，并将 MockSender 设置为其依赖项
	client := &Client{
		Sender: mockSender,
	}

	// 调用被测试的方法
	err := client.SendEmail("test@example.com", "Hello", "Hello, World!")

	// 验证 MockSender 的方法是否被调用
	mockSender.AssertCalled(t, "Send", "test@example.com", "Hello", "Hello, World!")

	// 验证结果是否符合预期
	assert.Error(t, err)
}

在这个示例中，我们定义了一个 Sender 接口和一个 Client 结构体，Client 结构体使用 Sender 接口来发送邮件。

在测试文件中，我们创建了一个 MockSender 结构体，它实现了 Sender 接口，并使用 github.com/stretchr/testify/mock 库的 mock.Mock 类型来管理模拟的行为。

在测试函数 TestSendEmail_Success 中，我们创建了一个 MockSender 对象，并使用 On 方法设置了模拟的 Send 方法的行为。然后，我们创建了一个 Client 对象，并将 MockSender 对象设置为其依赖项。最后，我们调用被测试的方法 SendEmail，并使用 mockSender.AssertCalled 方法验证模拟的方法是否被调用。

类似地，在测试函数 TestSendEmail_Error 中，我们设置了模拟的 Send 方法返回一个错误，然后进行相应的验证。

通过使用Mock测试，我们可以控制依赖项的行为，并针对不同的情况编写测试用例。这使得我们能够更全面地测试被测代码的逻辑和边界条件，而不受真实依赖项的限制。

基准测试

在Go语言中，基准测试（Benchmark）是一种用于衡量代码性能的测试方法。通过基准测试，我们可以评估代码在不同输入下的执行速度和资源消耗情况。基准测试可以帮助我们找出性能瓶颈，并进行优化。

要进行基准测试，我们需要创建一个以 Benchmark 开头的测试函数，并使用 testing.B 类型的参数。这个参数提供了一些方法来控制和报告基准测试的执行情况。

下面是一个示例代码，展示如何编写基准测试函数：

// 源文件：math.go















package math





















// Add 函数将两个整数相加并返回结果




func Add(a, b int) int {




	return a + b


}




// 基准测试文件：math_benchmark_test.go












package math





















import (





	"testing"





)







func BenchmarkAdd(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Add(2, 3)
	}
}

在这个示例中，我们定义了一个简单的 Add 函数，用于将两个整数相加并返回结果。

在基准测试文件中，我们创建了一个以 Benchmark 开头的测试函数 BenchmarkAdd。在这个函数中，我们使用 b.N 来控制基准测试的迭代次数。在每次迭代中，我们调用 Add 函数，并传入固定的参数。

要运行基准测试，我们可以使用 go test 命令，并指定 -bench 标志：

$ go test -bench=.

输出类似于：

goos: darwin

goarch: amd64

pkg: example.com/math

BenchmarkAdd-8   	1000000000	         2.30 ns/op
PASS

ok  	example.com/math	2.974s

在这个输出中，BenchmarkAdd-8 表示基准测试函数的名称和并行性。1000000000 表示迭代次数。2.30 ns/op 表示每次迭代的平均执行时间。

通过基准测试的结果，我们可以评估代码的性能。我们可以使用不同的输入参数、不同的算法或优化技术来改进代码的性能，并通过基准测试来验证优化效果。

下面是对示例代码的优化思路和优化结果：

示例代码中的 Add 函数已经非常简单和高效，很难进行实质性的优化。但我们可以尝试一些微小的优化，例如使用位运算来代替加法运算。修改后的代码如下：

// 优化后的源文件：math.go












package math





















// Add 函数将两个整数相加并返回结果




func Add(a, b int) int {




	for b != 0 {
		carry := a & b
		a = a ^ b
		b = carry << 1
	}
	return a
}

我们可以再次运行基准测试，以比较优化前后的性能差异：

$ go test -bench=.

输出类似于：

goos: darwin

goarch: amd64

pkg: example.com/math

BenchmarkAdd-8   	1000000000	         0.255 ns/op
PASS

ok  	example.com/math	0.315s

通过基准测试的结果，我们可以看到优化后的代码相对于优化前的代码在性能上有所提升。在这个例子中，优化后的代码的每次迭代平均执行时间为 0.255 ns/op，而优化前的代码为 2.30 ns/op。这表明优化后的代码执行更快。

在进行优化时，我们应该根据实际情况进行测试和评估。同时，我们还应该关注代码的可读性和可维护性，避免过度优化导致代码难以理解和维护。

© 版权声明
文章版权归作者所有，未经允许请勿转载，侵权请联系 admin@trc20.tw 删除。
THE END

# 青训营笔记
喜欢就支持一下吧
点赞0

Warning: mysqli_query(): (HY000/3): Error writing file '/tmp/MYMj9mBR' (Errcode: 28 - No space left on device) in /www/wwwroot/583.cn/wp-includes/class-wpdb.php on line 2345
admin的头像-五八三
相关推荐
可视化引擎Antv G6初体验（一）| 青训营-五八三
可视化引擎Antv G6初体验（一）| 青训营
可视化引擎Antv G6初体验（一）| 青训营
2年前 80
Go 语言入门指南：基础语法和常用特性解析 (中)-五八三
Go 语言入门指南：基础语法和常用特性解析 (中)
Go 语言入门指南：基础语法和常用特性解析 (中)
2年前 77
使用 Vue 实现页面访问拦截-五八三
使用 Vue 实现页面访问拦截
使用 Vue 实现页面访问拦截
2年前 67
HTML语义化的案例分析：分析一些实际网站的HTML结构，对比非语义化标签的差异 ｜ 青训营-五八三
HTML语义化的案例分析：分析一些实际网站的HTML结构，对比非语义化标签的差异 ｜ 青训营
HTML语义化的案例分析：分析一些实际网站的HTML结构，对比非语义化标签的差异 ｜ 青训营
2年前 54
pprof性能分析排查实战 | 青训营-五八三
pprof性能分析排查实战 | 青训营
pprof性能分析排查实战 | 青训营
2年前 43
Pinia 实践 | 青训营笔记-五八三
Pinia 实践 | 青训营笔记
Pinia 实践 | 青训营笔记
2年前 42
评论 抢沙发
头像
欢迎您留下宝贵的见解！
提交
头像

昵称

图形验证码
取消
昵称

请填写用户信息：

  • 昵称(必填)
  • 邮箱(必填)
代码

请输入代码：

确认
图片
热门推荐