吹的天花乱坠的语言这些年太多了...这东西....越写越玄乎，再看看吧....

你其实可以把Tauri单纯当成一个跨平台工具。开发前后端全部用正常开发那一套。

llvm的话可以无缝跨平台的吧，支持win的![](https://content.hackertalk.net/pub/Y3gAyz-6Exrd8N)

太新了，但是语法真的漂亮，很有前途的语言

gui的话，看你的个人喜好，什么都可以做gui。

我看你学过rust和前端，我觉得你还是用Tauri比较好，因为这玩意是真的简单，而且性能比ele好的不止一点。而且还和你学的东西沾边。其实rust有很多gui框架，比如egui，fltk-rs等等等等。还是看你的喜好。

网页里的3d一般都是threejs或者wasm，你学rust的话大概知道bevy吧，游戏引擎，就可以编译成wasm用到网页上，还有就是threejs，是一个前端库，使用webgl在网页上快捷的渲染3d

而且carbon的语法你真能接受的嘛（小声bb）

没有什么“最”，看你干什么，rust比较适合底层，go比较适合web，但并不代表学了go就做不了底层，学了rust就做不了web。都是工具，熟练掌握各个工具的使用让自己的开发最爽才是正确的。喜欢什么就学什么。~~比如你可以先看看他们的语法哪个适合自己的xp，那个颜值更高（bushi)~~
***
但是，carbon和nim都是首先排除的，这些语言都还在测试阶段，生产还是不可用的，最好用成熟的语言。不然的话那天这些个语言的开发人员不干了或者核心api更改甚至说语法更改。。。

没记错的话有人用这个方法搞过一个嘉然“编程语言”（大雾

我也是搞了半天Rust的数组，Rust有两个可以当数组的东西，多维数组和返回值就搞了半天，本来一小时的事情被我搞了两三天(　↺ω↺)

`io.write`要手动`\n`（懒），性能的话好像差不多的，这种小程序感觉没必要想那么多，`print`或者`io.write`在这里我觉得都差不多（）

go怎么说呢，褒贬不一，但是至少经过了市场的验证，有庞大的用户群体。nim是新语言，未来不一定会发生什么，现在的东西也很少。我觉得你还是学go比较好。

以后学习新语言第一件事：做个生命游戏瞧瞧

之前有用到过，这次就练练手没想那么多，上次我用过清屏的，不知道终端还是c语言问题，效果差强人意，就懒得用了(*ﾟ∇ﾟ)

一直说py，但是缺个py (*ﾟ∇ﾟ)

woc,忘了retune 0了，GitHub补上了并且加了一些东西 :disappointed_relieved: 

好家伙大佬你什么都会哇(ﾟдﾟ)

生命游戏又多了一个唉（可惜我的Julia生命游戏因为没弄懂Julia数组到现在都没写出来）

我觉得Crystal挺不错的，语法几乎和Ruby一样，用llvm作后端，但问题是生态暂时不行，而且暂时不支持Windows

也许非测试使用`io`库进行输入输出更合适？（不清楚，只知道`nim`是这样的，但是`lua`的`print`也比`io.write`性能弱好像）（最近被`nim`的一些特效弄得比较魔怔，勿怪，谢谢）

对了，附一自己的[nim实例](https://www.bilibili.com/video/BV1Te4y1W7Lu)

建议你学一下终端ascii控制字符（以及Unicode转义字符），这样界面将非常amazing~

Rust 管理团队又出事了，老是整些幺蛾子

不说别的，反正我觉得rust的cargo蛮不错的

谢谢各位大佬的回答！我是业余爱好者，主业是做医药的。

最早开始接触编程是给 Obsidian 写插件，学了一些些 TypeScript 和 Vue 3 ，也就基本够用的水平。Rust 学到了多线程，后面感觉很难还没敢继续深入学习…… 不过学着学着突然就冒出了很多以前我没听说过的新语言，也不知道学哪个好，故才问此问题。

我其实是想写一些跨平台的研究工具（带 GUI 的），涉及科学计算所以要求计算结果比较精确。Electron 可以吗（这个框架好像很火啊，新版 QQ 好像也是用的这个）？还是 Tauri 比较好？Python 是不是也可以开发 GUI 程序啊不过会不会性能不太好？或者大佬还有没有其它的推荐呢 :heart: ？

还有我有一个非常好奇的问题，就是像这些网页里的 3D引擎 到底是怎么做出来的 :open_mouth: ？！一个人的话有机会开发出来吗？

![](https://content.hackertalk.net/pub/3PVyQK-13PPAGd)

哇，现在py里py气的生命游戏代码已经有3种编程语言版本的了[doge]

RT，最近一溜子冒出了很多新的编程语言，什么 golang、rust、carbon、nim，有没有大佬分析一下当下最值得学习的新语言，孩子眼花缭乱了都…… :dizzy_face: 

有没有大佬分析一下最值得学习的新语言

## 简介
我们将会使用Lua实现一个简单的波兰表达式的终端计算器。
## 开始
在Lua中，获取控制台输入内容是十分容易的一件事情，控制台输入的内容在Lua中将会变成一个数组`arg[]`，然后我们直接拿走就好。  
```shell
lua compute.lua + 1 2
```
在上面的控制台里我们一共输入了三个内容“+”，“1”和“2”，在Lua里，控制台传入的数据都是字符串。  
我们可以在`compute.lua`中获取他们
```lua
print(arg[1]) -- +
print(arg[2]) -- 1
print(arg[3]) -- 2
```
剩下的就简单了，只需要写一个简单的波兰表达式的计算函数  
```lua
function Calculate(symbol, a, b)
    -- 错误处理
    if ((type(symbol) ~= "string" or (type(a) or type(b)) ~= "number")) then
        return "错误：未知输入类型"
    end
    if (symbol == "+") then
        return a+b
    elseif (symbol == "-") then
        return a-b
    elseif (symbol == "*") then
        return a*b
    elseif (symbol == "/") then
        return a/b
    else
        -- 错误处理
        return "错误：未知符号类型"
    end
end
```
解析控制台的命令
```lua
Shell_symbol = arg[1]
-- 抓换类型
Shell_a = tonumber(arg[2])
Shell_b = tonumber(arg[3])
```
最后输出结果
```lua
print(Calculate(Shell_symbol, Shell_a, Shell_b))
```

## 完整代码
```lua
Shell_symbol = arg[1]
Shell_a = tonumber(arg[2])
Shell_b = tonumber(arg[3])

function Calculate(symbol, a, b)
    if ((type(symbol) ~= "string" or (type(a) or type(b)) ~= "number")) then
        return "错误：未知输入类型"
    end
    if (symbol == "+") then
        return a+b
    elseif (symbol == "-") then
        return a-b
    elseif (symbol == "*") then
        return a*b
    elseif (symbol == "/") then
        return a/b
    else
        return "错误：未知符号类型"
    end
end


print(Calculate(Shell_symbol, Shell_a, Shell_b))
```

五分钟做一个Lua控制台程序

好久都没在黑客说发帖了，今天转载个证明我还活着[doge]

---

Rust 是由 Mozilla 研究院开发的编程语言。Rust 将底层的性能控制与高级语言的便利性和安全保障结合在了一起。

而 Rust 并不需要一个垃圾回收器或者运行时即可实现这个目的，这使得 Rust 库可以成为一种 C 语言的替代品。

Rust 第一版（0.1 版）发布于 2012 年 1 月，3 年以来一直在紧锣密鼓地迭代。

因为更新太频繁，一般建议使用每夜构建版而不是稳定版，直到最近 1.0 版本的发布。

2015 年 3 月 15 日，Rust 1.0 发布，完美向后兼容，最新的每夜构建版提供了缩短编译时间等新特性。

Rust 采用了持续迭代模型，每 6 周一个发布版。Rust 1.1 beta 版在 1.0 发布时同时发布。

尽管 Rust 相对来说是一门底层语言，它提供了一些常见于高级语言的函数式编程的特性。这让 Rust 不仅高效，并且易用。

```rust

// 这是注释，单行注释...

/* ...这是多行注释 */

///////////////

// 1. 基础   //

///////////////

// 函数 (Functions)

// `i32` 是有符号 32 位整数类型(32-bit signed integers)

fn add2(x: i32, y: i32) -> i32 {

    // 隐式返回 (不要分号)

    x + y

}

// 主函数(Main function)

fn main() {

    // 数字 (Numbers) //

    // 不可变绑定

    let x: i32 = 1;

    // 整形/浮点型数 后缀

    let y: i32 = 13i32;

    let f: f64 = 1.3f64;

    // 类型推导

    // 大部分时间，Rust 编译器会推导变量类型，所以不必把类型显式写出来。

    // 这个教程里面很多地方都显式写了类型，但是只是为了示范。

    // 绝大部分时间可以交给类型推导。

    let implicit_x = 1;

    let implicit_f = 1.3;

    // 算术运算

    let sum = x + y + 13;

    // 可变变量

    let mut mutable = 1;

    mutable = 4;

    mutable += 2;

    // 字符串 (Strings) //

    // 字符串字面量

    let x: &str = "hello world!";

    // 输出

    println!("{} {}", f, x); // 1.3 hello world

    // 一个 `String` – 在堆上分配空间的字符串

    let s: String = "hello world".to_string();

    // 字符串分片(slice) - 另一个字符串的不可变视图

    // 基本上就是指向一个字符串的不可变指针，它不包含字符串里任何内容，只是一个指向某个东西的指针

    // 比如这里就是 `s`

    let s_slice: &str = &s;

    println!("{} {}", s, s_slice); // hello world hello world

    // 数组 (Vectors/arrays) //

    // 长度固定的数组 (array)

    let four_ints: [i32; 4] = [1, 2, 3, 4];

    // 变长数组 (vector)

    let mut vector: Vec<i32> = vec![1, 2, 3, 4];

    vector.push(5);

    // 分片 - 某个数组(vector/array)的不可变视图

    // 和字符串分片基本一样，只不过是针对数组的

    let slice: &[i32] = &vector;

    // 使用 `{:?}` 按调试样式输出

    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]

    // 元组 (Tuples) //

    // 元组是固定大小的一组值，可以是不同类型

    let x: (i32, &str, f64) = (1, "hello", 3.4);

    // 解构 `let`

    let (a, b, c) = x;

    println!("{} {} {}", a, b, c); // 1 hello 3.4

    // 索引

    println!("{}", x.1); // hello

    //////////////

    // 2. 类型 (Type)  //

    //////////////

    // 结构体（Sturct)

    struct Point {

        x: i32,

        y: i32,

    }

    let origin: Point = Point { x: 0, y: 0 };

    // 匿名成员结构体，又叫“元组结构体”（‘tuple struct’）

    struct Point2(i32, i32);

    let origin2 = Point2(0, 0);

    // 基础的 C 风格枚举类型（enum）

    enum Direction {

        Left,

        Right,

        Up,

        Down,

    }

    let up = Direction::Up;

    // 有成员的枚举类型

    enum OptionalI32 {

        AnI32(i32),

        Nothing,

    }

    let two: OptionalI32 = OptionalI32::AnI32(2);

    let nothing = OptionalI32::Nothing;

    // 泛型 (Generics) //

    struct Foo<T> { bar: T }

    // 这个在标准库里面有实现，叫 `Option`

    enum Optional<T> {

        SomeVal(T),

        NoVal,

    }

    // 方法 (Methods) //

    impl<T> Foo<T> {

        // 方法需要一个显式的 `self` 参数

        fn get_bar(self) -> T {

            self.bar

        }

    }

    let a_foo = Foo { bar: 1 };

    println!("{}", a_foo.get_bar()); // 1

    // 接口（Traits） （其他语言里叫 interfaces 或 typeclasses） //

    trait Frobnicate<T> {

        fn frobnicate(self) -> Option<T>;

    }

    impl<T> Frobnicate<T> for Foo<T> {

        fn frobnicate(self) -> Option<T> {

            Some(self.bar)

        }

    }

    let another_foo = Foo { bar: 1 };

    println!("{:?}", another_foo.frobnicate()); // Some(1)

    ///////////////////////////////////

    // 3. 模式匹配 (Pattern matching) //

    ///////////////////////////////////

    let foo = OptionalI32::AnI32(1);

    match foo {

        OptionalI32::AnI32(n) => println!("it’s an i32: {}", n),

        OptionalI32::Nothing  => println!("it’s nothing!"),

    }

    // 高级模式匹配

    struct FooBar { x: i32, y: OptionalI32 }

    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };

    match bar {

        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>

            println!("The numbers are zero!"),

        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>

            println!("The numbers are the same"),

        FooBar { x: n, y: OptionalI32::AnI32(m) } =>

            println!("Different numbers: {} {}", n, m),

        FooBar { x: _, y: OptionalI32::Nothing } =>

            println!("The second number is Nothing!"),

    }

    ///////////////////////////////

    // 4. 流程控制 (Control flow) //

    ///////////////////////////////

    // `for` 循环

    let array = [1, 2, 3];

    for i in array {

        println!("{}", i);

    }

    // 区间 (Ranges)

    for i in 0u32..10 {

        print!("{} ", i);

    }

    println!("");

    // 输出 `0 1 2 3 4 5 6 7 8 9 `

    // `if`

    if 1 == 1 {

        println!("Maths is working!");

    } else {

        println!("Oh no...");

    }

    // `if` 可以当表达式

    let value = if true {

        "good"

    } else {

        "bad"

    };

    // `while` 循环

    while 1 == 1 {

        println!("The universe is operating normally.");

    }

    // 无限循环

    loop {

        println!("Hello!");

    }

    ////////////////////////////////////////////////

    // 5. 内存安全和指针 (Memory safety & pointers) //

    ////////////////////////////////////////////////

    // 独占指针 (Owned pointer) - 同一时刻只能有一个对象能“拥有”这个指针

    // 意味着 `Box` 离开他的作用域后，会被安全地释放

    let mut mine: Box<i32> = Box::new(3);

    *mine = 5; // 解引用

    // `now_its_mine` 获取了 `mine` 的所有权。换句话说，`mine` 移动 (move) 了

    let mut now_its_mine = mine;

    *now_its_mine += 2;

    println!("{}", now_its_mine); // 7

    // println!("{}", mine); // 编译报错，因为现在 `now_its_mine` 独占那个指针

    // 引用 (Reference) – 引用其他数据的不可变指针

    // 当引用指向某个值，我们称为“借用”这个值，因为是被不可变的借用，所以不能被修改，也不能移动

    // 借用一直持续到生命周期结束，即离开作用域

    let mut var = 4;

    var = 3;

    let ref_var: &i32 = &var;

    println!("{}", var); //不像 `mine`, `var` 还可以继续使用

    println!("{}", *ref_var);

    // var = 5; // 编译报错，因为 `var` 被借用了

    // *ref_var = 6; // 编译报错，因为 `ref_var` 是不可变引用

    // 可变引用 (Mutable reference)

    // 当一个变量被可变地借用时，也不可使用

    let mut var2 = 4;

    let ref_var2: &mut i32 = &mut var2;

    *ref_var2 += 2;

    println!("{}", *ref_var2); // 6

    // var2 = 2; // 编译报错，因为 `var2` 被借用了

}
```

## 更深入的资料

Rust 还有很多很多其他内容 - 这只是 Rust 最基本的功能，帮助你了解 Rust 里面最重要的东西。

如果想深入学习 Rust，可以去读

[The Rust Programming Language](http://doc.rust-lang.org/book/index.html)

或者上 reddit [/r/rust](http://reddit.com/r/rust) 订阅。

同时 irc.mozilla.org 的 #rust 频道上的小伙伴们也非常欢迎新来的朋友。

你可以在这个在线编译器 [Rust playpen](http://play.rust-lang.org) 上尝试 Rust 的一些特性

或者上[官方网站](http://rust-lang.org).

> 原著P1start，使用CC-BY-SA许可

[转载]Rust基本语法速成

和Haxe一样能转换成各种语言。不过看起来更现代，不知道真正的表现如何，有人用过吗？

Nim语言怎么样？

孩子不是专业的程序员，因为觉得自己没能力控制好内存安全，同时想要可扩展性强的 web 生态，所以打算入 Tauri 的坑了。

目前遇到的问题是，Tauri 前端用 TypeScript ，后端用 Rust ，但后端其实也可以直接生成 html 代码发送给前端 :dizzy_face: 。

所以哪些代码应该放在前端，哪些代码应该放在后端呢？前后端的配合策略怎样才比较好？

谢谢各位大佬 :pray: ！

大佬们可以分享一下 Tauri 前后端的配合策略吗?

## 一个十分简单的生命游戏实例
```rust
fn main() {
    // 初始化世界
    let mut map: [[i32; 12]; 12] = [[0; 12]; 12];
    // 初始化数据
    map = lode(map);

    let mut loop_num: u32 = 0;
    while loop_num != 6 {
        // 进行判断
        map = comput(map);
        // 绘制世界
        display(map);

        loop_num += 1;
    }
}

fn lode(data: [[i32; 12]; 12]) -> [[i32; 12]; 12] {
    let mut _data: [[i32; 12]; 12] = data;
    // 初始化生命数据
    _data[1][2] = 1;
    _data[1][3] = 1;
    _data[3][1] = 1;
    _data[3][2] = 1;
    _data[3][3] = 1;

    _data
}

fn comput(data: [[i32; 12]; 12]) -> [[i32; 12]; 12] {
    let mut _data: [[i32; 12]; 12] = data;

    for h in 0..12 {
        for w in 0..12 {
            // 设定变量储存周边生命
            let mut state :i32 = 0;
            // 探测生命
            if !(h==0 || w==0) {
                state = state + _data[h-1][w-1];
            }
            if !(h==0) {
                state = state + _data[h-1][w];
            }
            if !(h==0 || w==11) {
                state = state + _data[h-1][w+1];
            }
            if !(w==0) {
                state = state + _data[h][w-1];
            }
            if !(w==11) {
                state = state + _data[h][w+1];
            }
            if !(h==11 || w==0) {
                state = state + _data[h+1][w-1];
            }
            if !(h==11) {
                state = state + _data[h+1][w];
            }
            if !(h==11 || w==11) {
                state = state + _data[h+1][w+1];
            }

            if state > 3 || state < 2 {
                _data[h][w] = 0;
            } else if state == 3 {
                _data[h][w] = 1;
            }
        }
    }

    _data
}

fn display(_data: [[i32; 12]; 12]) {
    for h in 0..12 {
        for w in 0..12 {
            if _data[h][w] == 1 {
                print!(" # ");
            } else {
                print!("   ");
            }
        }
        println!(" ");
    }
}
```

[Rust] 生命游戏实例, 你的第一行代码何必是hello,world

语法糖吃的有点傻~
```python
import copy
import os

m, n = 10, 10
world = [[0 for _ in range(0, m)] for _ in range(0, n)]
world[0][1], world[1][2], world[2][0], world[2][1], world[2][2] = 1, 1, 1, 1, 1

while True:
    os.system('cls')
    _world = copy.deepcopy(world)
    for i in range(0, m):
        for j in range(0, n):
            state = 0
            if not (i == 0 or j == 0):
                state += world[i - 1][j - 1]
            if not i == 0:
                state += world[i - 1][j]
            if not (i == 0 or j == n - 1):
                state += world[i - 1][j + 1]
            if not j == 0:
                state += world[i][j - 1]
            if not j == n - 1:
                state += world[i][j + 1]
            if not (i == m - 1 or j == 0):
                state += world[i + 1][j - 1]
            if not i == m - 1:
                state += world[i + 1][j]
            if not (i == m - 1 or j == n - 1):
                state += world[i + 1][j + 1]

            if state < 2 or state > 3:
                    _world[i][j] = 0
            elif state == 3:
                    _world[i][j] = 1
            print(('\033[47m  \033[0m' if _world[i][j] else '  '), end='')
        print()
    world = copy.deepcopy(_world)
    input()
```

【Python】py里py气的生命游戏示例，你的第一行代码何必是hello,world

> Mojo combines the usability of Python with the performance of C, unlocking unparalleled programmability of AI hardware and extensibility of AI models.

目标是为 AI 开发服务，组合 python 的工具优势和 C 的性能，代码风格很点像 python：

```python
def softmax(lst):
  norm = np.exp(lst - np.max(lst))
  return norm / norm.sum()

struct NDArray:
  def max(self) -> NDArray:
    return self.pmap(SIMD.max)

struct SIMD[type: DType, width: Int]:
  def max(self, rhs: Self) -> Self:
    return (self >= rhs).select(self, rhs)
```

link: https://www.modular.com/mojo

训练框架据说性能提升很多倍，先踩个点围观  :stuck_out_tongue: 

![](https://content.hackertalk.net/pub/OOJ7E8-x5eXJ7a)

Swift 之父创业做的新语言：mojo

用来学习的话还是生命游戏比较不错呢 （<ゝω・）☆

[Github](https://github.com/Xuanluo-Qiu/C/blob/main/LifeGame/main.c) (ゝ∀･)

```c
#include <stdio.h>

// 地图数据
int map_data[12][12];

// 初始化游戏数据
void lod_data() {
    // 初始化地图
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 12; j++) {
            map_data[j][i] = 0;
        }
    }
    // 初始化生命数据
    map_data[0][1] = 1;
    map_data[1][2] = 1;
    map_data[2][0] = 1;
    map_data[2][1] = 1;
    map_data[2][2] = 1;
}

// 游戏逻辑
void control() {
    // 设定变量储存周边生命
    int state_data;
    // 遍历地图
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 12; j++) {
            // 探测生命
            if (map_data[i+1][j] == 1) {
                state_data++;
            }
            if (map_data[i-1][j] == 1) {
                state_data++;
            }
            if (map_data[i][j-1] == 1) {
                state_data++;
            }
            if (map_data[i][j+1] == 1) {
                state_data++;
            }
            if (map_data[i+1][j+1] == 1) {
                state_data++;
            }
            if (map_data[i+1][j-1] == 1) {
                state_data++;
            }
            if (map_data[i-1][j+1] == 1) {
                state_data++;
            }
            if (map_data[i-1][j-1] == 1) {
                state_data++;
            }

            // 决定生死
            if (state_data >= 3) {
                if (map_data[i][j] == 0) {
                    map_data[i][j] = 1;
                } else {
                    map_data[i][j] = 0;
                }
            } else {
                map_data[i][j] = 1;
            }
            // 重制数据
            state_data = 0;
        }
    }
}

// 渲染世界
void lod_world() {
    printf("\n");
    for (int i = 0; i < 12; i++) {
        for (int j = 0; j < 12; j++) {
            printf("[%d]", map_data[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

int main() {
    // 加载世界数据
    lod_data();
    // 更改次数
    for (int i=0; i<2; i++) {
        // 进行判定
        control();
    }
    lod_world();
}
```

【C】py里py气的生命游戏示例，你的第一行代码何必是hello,world

```c
#include <stdio.h>
#define 你好 int
#define 洛天依 main
#define ， (
#define 呃 )
#define 我想 {
#define 😘 }
#define 😅 ;
#define 对你说 printf
#define 咳 return
#define 😋 0

你好 洛天依 ，
呃 我想 对你说 ， "hello, world!"
呃 😅 咳 😋 😅 😘
```

[整活]突然发现C语言这么玩蛮可爱的

标识符

483DAB9E-B587-4DAE-936C-201F5BC4BCBA

备注

Error Domain=kCFStreamErrorDomainSSL Code=-9806"(null)" UserInfo=/NSLocalizedRecoverySuggestion=Errorcode definition can be found in Apple's SecureTransport.h}

请求信息

CONNECT m.m******(手动打码).pt:443 HTTP/1.1

请求头部

Host: m.m*******.ptConnection: keep-alive

发送请求头部

未发送

服务端开始响应

未响应

请求完成2024/04/26 10:11:40.529

 app无法登录，抓包数据。网页版可以登录，求分析求解

前些天一直在找便宜的云服务器，偶然间发现一免费的云平台，这里推荐给大家。

就是阿贝云，网站是https://www.abeiyun.com

说一下感受

1、阿贝云虽然是一小众的云平台，重在免费，该有的东西都有，还能免备案这是最舒服的。

2、使用了一天，上了项目，网速不慢。

3、唯一要指出来就是磁盘太小。

分享免费云服务器

拉取了rustbuster的v3.0.3版本文件, 二进制文件无法使用, 执行结果如下:

```bash
[root_cn@archlinux target]$ ./rustbuster-v3.0.3-x86_64-unknown-linux-gnu
./rustbuster-v3.0.3-x86_64-unknown-linux-gnu: error while loading shared libraries: libssl.so.1.1: cannot open shared object file: No such file or directory
```

拉取了main源码, 想自行尝试编译, 然后卡在了openssl, 以下为报错信息:

```rust
The following warnings were emitted during compilation:

warning: openssl-sys@0.9.47: build/expando.c:4:24: error: pasting "RUST_VERSION_OPENSSL_" and "(" does not give a valid preprocessing token
warning: openssl-sys@0.9.47:     4 | #define VERSION2(n, v) RUST_VERSION_##n##_##v
warning: openssl-sys@0.9.47:       |                        ^~~~~~~~~~~~~
warning: openssl-sys@0.9.47: build/expando.c:5:23: note: in expansion of macro ‘VERSION2’
warning: openssl-sys@0.9.47:     5 | #define VERSION(n, v) VERSION2(n, v)
warning: openssl-sys@0.9.47:       |                       ^~~~~~~~
warning: openssl-sys@0.9.47: build/expando.c:10:1: note: in expansion of macro ‘VERSION’
warning: openssl-sys@0.9.47:    10 | VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
warning: openssl-sys@0.9.47:       | ^~~~~~~

error: failed to run custom build command for `openssl-sys v0.9.47`

Caused by:
  process didn't exit successfully: `/mnt/d/work/file/rust/rustbuster/target/debug/build/openssl-sys-c5a482a9e0e49574/build-script-main` (exit status: 101)
  --- stdout
  cargo:rustc-cfg=const_fn
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_LIB_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_LIB_DIR
  OPENSSL_LIB_DIR unset
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_INCLUDE_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_INCLUDE_DIR
  OPENSSL_INCLUDE_DIR unset
  cargo:rerun-if-env-changed=X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR
  X86_64_UNKNOWN_LINUX_GNU_OPENSSL_DIR unset
  cargo:rerun-if-env-changed=OPENSSL_DIR
  OPENSSL_DIR unset
  cargo:rustc-link-lib=ssl
  cargo:rustc-link-lib=crypto
  OPT_LEVEL = Some("0")
  TARGET = Some("x86_64-unknown-linux-gnu")
  HOST = Some("x86_64-unknown-linux-gnu")
  CC_x86_64-unknown-linux-gnu = None
  CC_x86_64_unknown_linux_gnu = None
  HOST_CC = None
  CC = None
  CFLAGS_x86_64-unknown-linux-gnu = None
  CFLAGS_x86_64_unknown_linux_gnu = None
  HOST_CFLAGS = None
  CFLAGS = None
  CRATE_CC_NO_DEFAULTS = None
  DEBUG = Some("true")
  CARGO_CFG_TARGET_FEATURE = Some("fxsr,sse,sse2")
  running: "cc" "-O0" "-ffunction-sections" "-fdata-sections" "-fPIC" "-g" "-fno-omit-frame-pointer" "-m64" "-Wall" "-Wextra" "-E" "build/expando.c"
  cargo:warning=build/expando.c:4:24: error: pasting "RUST_VERSION_OPENSSL_" and "(" does not give a valid preprocessing token
  cargo:warning=    4 | #define VERSION2(n, v) RUST_VERSION_##n##_##v
  cargo:warning=      |                        ^~~~~~~~~~~~~
  cargo:warning=build/expando.c:5:23: note: in expansion of macro ‘VERSION2’
  cargo:warning=    5 | #define VERSION(n, v) VERSION2(n, v)
  cargo:warning=      |                       ^~~~~~~~
  cargo:warning=build/expando.c:10:1: note: in expansion of macro ‘VERSION’
  cargo:warning=   10 | VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
  cargo:warning=      | ^~~~~~~
  exit status: 1

  --- stderr
  thread 'main' panicked at /home/root_cn/.cargo/registry/src/mirrors.sjtug.sjtu.edu.cn-4f7dbcce21e258a2/openssl-sys-0.9.47/build/main.rs:126:13:

  Header expansion error:
  Error { kind: ToolExecError, message: "Command \"cc\" \"-O0\" \"-ffunction-sections\" \"-fdata-sections\" \"-fPIC\" \"-g\" \"-fno-omit-frame-pointer\" \"-m64\" \"-Wall\" \"-Wextra\" \"-E\" \"build/expando.c\" with args \"cc\" did not execute successfully (status code exit status: 1)." }

  Failed to find OpenSSL development headers.

  You can try fixing this setting the `OPENSSL_DIR` environment variable
  pointing to your OpenSSL installation or installing OpenSSL headers package
  specific to your distribution:

      # On Ubuntu
      sudo apt-get install libssl-dev
      # On Arch Linux
      sudo pacman -S openssl
      # On Fedora
      sudo dnf install openssl-devel

  See rust-openssl README for more information:

      https://github.com/sfackler/rust-openssl#linux

  note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
warning: build failed, waiting for other jobs to finish...
```

经过检查openssl与rust均为最新版本, 

```bash
[root_cn@archlinux target]$ sudo pacman -S rust
[sudo] password for root_cn:
warning: rust-1:1.77.2-1 is up to date -- reinstalling
resolving dependencies...
looking for conflicting packages...

Package (1)  Old Version  New Version  Net Change

extra/rust   1:1.77.2-1   1:1.77.2-1     0.00 MiB

Total Installed Size:  249.41 MiB
Net Upgrade Size:        0.00 MiB

:: Proceed with installation? [Y/n] n
[root_cn@archlinux target]$ sudo pacman -S openssl
warning: openssl-3.2.1-1 is up to date -- reinstalling
resolving dependencies...
looking for conflicting packages...

Package (1)   Old Version  New Version  Net Change

core/openssl  3.2.1-1      3.2.1-1        0.00 MiB

Total Installed Size:  11.45 MiB
Net Upgrade Size:       0.00 MiB

:: Proceed with installation? [Y/n] n
```

在网上找了一下, 查到资料, 在[rust-openssl的issues](https://github.com/sfackler/rust-openssl/issues/1227)中提到类似报错, 得到解释如下:

> If you are cross compiling to MUSL, you either need to point openssl-sys to the location that you have a copy of OpenSSL cross compiled to MUSL, or tell it to build a copy of OpenSSL itself with the vendored feature.
>
>	如果你是交叉编译到MUSL，你需要将openssl-sys指向你有一个交叉编译到MUSL的OpenSSL副本的位置，或者告诉它用vendored特性构建一个OpenSSL本身的副本。

由于不会rust, 依靠关键词"交叉编译"+"cargo"搜索到了[cargo交叉编译rust程序](https://blog.csdn.net/tyc880616/article/details/104371502), 顺着找到文件:

```
[root_cn@archlinux .cargo]$ cat ~/.cargo/config
[source.crates-io]
replace-with = 'sjtu' # 指定使用下面哪个源，修改为source.后面的内容即可

# 中国科学技术大学
[source.ustc]
registry = "https://mirrors.ustc.edu.cn/crates.io-index"

# 上海交通大学
[source.sjtu]
registry = "https://mirrors.sjtug.sjtu.edu.cn/git/crates.io-index/"

# 清华大学
[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

# rustcc社区
[source.rustcc]
registry = "https://code.aliyun.com/rustcc/crates.io-index.git"
```

没有找到交叉编译的设置, 由于本人不会rust, 线索断了, 尝试向大家寻求一波帮助, 非常感谢阅读.



急切寻求rust编译问题帮助(archlinux, openssl)

永久免费，无需注册

[https://good.xjai.top](https://good.xjai.top)

分享免费GPT4站点

[MoienTajik/AspNetCore-Developer-Roadmap (github.com)](https://github.com/MoienTajik/AspNetCore-Developer-Roadmap/blob/master/ReadMe.zh-Hant.md)

![](https://github.com/MoienTajik/AspNetCore-Developer-Roadmap/raw/master/aspnetcore-developer-roadmap.zh-Hant.png)



【轉貼】ASP.NET Core Developer Roadmap in 2024

南京大学数字金融 - 新华报业集团联合诚邀全职博士后！

【研究方向涵盖】

数智传播、数智金融经济、数据金融经济、数智政务、数智监管治理，以及“大数据、大模型、大计算”全新范式等方向理论与实践

 【具体研究领域】

包括 Bigdata4SocialScience、AI4SocialScience、LLM4SocialScience、Blockchain4SocialScience，以及先进信息技术融合创新在数智金融经济、数智传播社会、数智健康医疗、数智政务治理中的应用。

【薪资待遇优渥】

年薪可达 30 万人民币左右，另有绩效奖金及江苏省和南京市人才补贴。具体薪资需与HR面议，总收入依据专业背景和技能经验而定（计算机 AI 背景者薪资更优）。

【欢迎学科交叉、专业背景不限】

不限制专业背景，致力于构建一个多元、开放、包容的科研环境，因此，欢迎计算机、软件、大数据、人工智能、区块链、隐私计算、数据安全、数据科学等背景的博士人才，也热切邀请具有人文社科背景的博士加入我们的团队，共同探索信息技术与社会科学的交叉前沿。也欢迎其他编程能力强的理工科博士毕业生（即使没有AI等背景也欢迎）。

【南京大学研究中心】

南京大学研究中心为双院士领军的校级科研和创新平台，详情请见：fintech.nju.edu.cn。

【团队氛围】

学科交叉、理论与实践相结合、国际化视野、行业前沿视角和项目。

【联系我们】

请感兴趣的朋友将个人简历发送至邮箱:blockchainfintech@126.com。

【更多招募】 南京大学研究中心招收硕士生、博士生、博士后、青年教师、研究员，也欢迎访问、客座、联培以及科研助理（有些岗位可兼职或远程合作）等

欢迎加入我们，您将在这个富有挑战性和机遇的环境中，开启广阔的职业发展道路，实现个人价值与学术梦想的双赢！

期待您的加入，携手共创数智未来！

南京大学研究中心诚募博士后



![](https://image.hackertalk.net/images/62537abc-405f-44da-a67e-9f18082f3d74)















sqlmap -u "xxxxx.com/#/login" --all  --delay 1 --batch --random-agent

[CRITICAL]can't establish SSL connection.

![](https://image.hackertalk.net/images/4a856cac-750c-4972-aa1f-4bf02f000394)

sqlmap -r win.txt --dbs

**

[CRITICAL] anti-CSRF token 'XSRF-TOKEN' can't be found 


**


