mojo 介绍-Toy模板网

这篇具有很好参考价值的文章主要介绍了mojo 介绍。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

注：本文是根据官方网站翻译得来，其中做了部分修改用于理解文章字义。

mojo介绍

Mojo被设计为Python的超集，因此许多语言功能和你可能在Python中知道的概念可以直接翻译成Mojo。例如一个 Mojo中的“Hello World”程序看起来和Python一模一样：

print("hello world")
hello world

您还可以导入现有的 Python 包并使用它们，就像您用Python编程，但我们稍后会谈到这一点。

但是，重要的是要知道Mojo是一种全新的语言。拥有，而不仅仅是带有额外糖的 Python 的新实现。当你了解有关Mojo的更多信息，您会发现它与Mojo有更多共同点像 Rust 和 C++ 这样的语言，除了它使用 Python 语法并完全支持导入的 Python 包。

所以让我们开始吧！本笔记本介绍了 Mojo 语言的基础知识，并且只需要一点编程经验。

如果您想了解有关该语言的更多详细信息，请查看Mojo编程手册。

语言基础

首先，Mojo是一种编译语言，它的很多性能内存安全功能就是从这一事实派生出来的。Mojo代码可以是提前编译（AOT）或实时（JIT）。mojo也支持REPL 环境，例如运行 Jupyter 笔记本中的代码的环境（命令行 REPL 即将推出）。

像其他编译语言一样，Mojo需要一个函数作为程序的入口点。例如：main()

# 首先创建一个 .mojo 的文件 文档上说文件名可以有表情可以试试

fn main():
	var x: Int = 1
	x +=1 
	print(x)
main()
2

如果你了解Python，你可能会期望“def main（）”而不是“fn main（））”。两者实际上都在Mojo中工作，但使用“fn”的行为有点不同，我们将下面讨论。

当然，在REPL环境中不需要“main（）”函数，因为如上面所示，当我们打印没有“main（）”函数的“helloworld”时。但是，当您想编写自己的.mojo时，需要main（）函数程序。

语法语义

Mojo使用了Python的所有语法和语义。（如果你不是熟悉Python语法，网上有大量很棒的资源可以教你。

例如，像Python一样，Mojo使用换行符和缩进来定义代码。块（不是大括号），Mojo支持Python的所有控制流语法例如条件和循环。if``for

但是，Mojo仍在进行中，因此Python中有一些东西。尚未在 Mojo 中实现（请参阅 Mojo 路线图）。所有缺失的Python功能会及时到来，但Mojo已经包含许多功能和超出 Python 中原有的功能的功能。

因此，以下各节将重点介绍一些语言功能是Mojo独有的（与Python相比）。

Mojo函数可以用“fn”（如上所示）或“def”（如Python中）。“fn”声明强制执行强类型和内存安全行为，而“def”提供Python风格的动态行为。

“fn”和“def”函数都有其值两者兼而有之。然而，为了本介绍的目的，我们将仅关注“fn”函数。有关两者的更多详细信息，请参阅编程手册。

在以下部分中，您将了解“fn”函数是如何强制执行的代码中的强类型和内存安全行为。

您可以使用声明变量，例如上面的“main（）”函数中的“x”`var’创建可变值，或者使用let’创建不可变值。

var: 声明全局变量(表示可以在全局获取到)，在mojo 中用var 声明的变量是可变的

let：声明临时变量(例：在函数或循环中声明，那么只能在函数中获取，在函数外或者其他函数中是获取不到该值的)，let声明的变量是不可变的

继续，在上面的“main（）”函数中将“var”更改为“let”，然后运行它。您将得到如下编译器错误：

fn main():
	let x: Int = 1
	x +=1 
	print(x)
main()

```
error: Expression [15]:7:5: expression must be mutable for in-place operator destination
    x += 1
    ^
```

# 错误：表达式[15]：7:5:对于就地运算符目标，表达式必须是可变的

这是因为“let”使其不可变，所以不能增加值。如果你删除“var”，你会得到一个错误，因为“fn`函数需要显式的变量声明（与“def”函数不同）。

fn main():
    x = 1
main()

"""
error: Expression [1]:6:5: use of unknown declaration 'x', 'fn' declarations require explicit variable declarations
    x = 1
    ^

expression failed to parse (no further compiler diagnostics)
"""

错误：表达式[1]：6:5:使用未知声明“x”、“fn”声明需要显式变量声明
x=1
^
表达式解析失败（没有进一步的编译器诊断）

最后，请注意，“x”变量有一个显式的“Int”类型规范。“fn”中的变量不需要声明类型，但是需要声明var let，有时如果省略声明类型，Mojo将推断类型，如下所示：

fn do_math():
    let x: Int = 1
    let y = 2
    print(x + y)

do_math()

3

函数参数和返回

与局部变量不同，函数中的参数必须指定类型。fn若要从函数返回值，必须使用签名末尾的箭头。fn``->

例如：

fn add(x: Int, y: Int) -> Int:
    return x + y

z = add(1, 2)
print(z)

3

参数可变性和所有权

自变量的可变性和所有权

现在，让我们探讨如何在函数中共享参数值。

请注意，如上所述，“add（）”不会修改“x”或“y”，它只读取价值观事实上，正如所写的，函数不能修改它们，因为fn默认情况下，参数是不可变的引用。

就论点惯例而言，这被称为“借用”，尽管作为“fn”函数的默认值，可以使用borrowed声明如下（其行为与上面的“add（）”完全相同）：

fn add(borrowed x: Int, borrowed y: Int) -> Int:
    return x + y

如果希望参数是可变的，则需要声明该参数inout。这意味着对参数in侧所做的更改函数在函数外可见。

例如，此函数可以修改原始变量：

fn add_inout(inout x: Int, inout y: Int) -> Int:
    x += 1
    y += 1
    return x + y

var a = 1
var b = 2
c = add_inout(a, b)
print(a)
print(b)
print(c)

2
3
5

另一种选择是将参数声明为“owned”，这提供了函数对值的完全所有权（使他成为可变的，并保证是唯一的）。这样，函数可以修改值，而不用担心影响函数外的变量。例如：

fn set_fire(owned text: String) -> String: 
    text += "🔥"
    return text

fn mojo():
    let a: String = "mojo"
    let b = set_fire(a)
    print(a)
    print(b)

mojo()

"""
mojo
mojo🔥
"""

在这种情况下，Mojo复制“a”并将其作为“text”参数传递。原来的“a”字符串仍然有效。

但是，如果您想赋予函数值的所有权，而不想要复制（对于某些类型来说，这可能是一项昂贵的操作），然后当您将a传递给函数时，可以添加^“transfer”运算符。这个transfer运算符有效地破坏了本地变量名——任何试图稍后对它的调用会导致编译器错误。

请在上面代码，将调用更改为“set_fire（）”，如下所示：


let b = set_fire(a^) # ^ 可以理解为将原数据变量进行摧毁使其不可访问

由于transfer操作符有效地破坏了`一个“变量”，因此当下面的“print（）”函数尝试使用“a”时变量不再初始化。如果删除“print（a）”，则效果良好。

注意：目前，Mojo总是在函数返回值时进行复制。

总结：

borrowed: 让参数只能读不可更改原变量，可以在函数中进行调用运算等
inout：可以进行修改原变量，进行赋值运算等`a +=1`
owned: 完全获取操作权，对传递的参数进行copy 这时参数与传递的变量是两个不同的变量，修改参数并不会修改原变量。
^： 在传递参数后面添加^ 会摧毁原变量使后面的代码不可访问报错。

结构

Structures

您可以为“结构”中的类型（或“对象”）构建“struct”. A。Mojo中的“struct”类似于Python中的“class”：它们都支持方法，字段、运算符重载、元编程的装饰器等。然而，Mojo结构是完全静态时let——它们在编译时被绑定，所以它们,不允许对结构进行动态调用或任何运行时的更改。（Mojo会还支持将来的类。）

例如，这里有一个基本结构：

struct MyPair:
    var first: Int
    var second: Int

    # 这个“初始值设定项”的行为与其他语言中的构造函数类似
    fn __init__(inout self, first: Int, second: Int):
        self.first = first
        self.second = second
    
    fn dump(inout self):
        print(self.first)
        print(self.second)

# 以下是使用它的方法：

def pair_test() -> Bool:
    let p = MyPair(1, 2)
    # 取消注释以查看错误：
    # return p < 4 # 给出编译时错误，这里的错误根据上下文解释是因为let静态声明类对象是被绑定，不允许对他进行调用和任何修改。
    return True

如果您熟悉Python，那么“init（）”方法和“self` 这个方法你们应该很熟悉。如果您不熟悉Python，请注意，当我们调用“dump（）”时，实际上并没有为“self”参数传递值。“self”的值是随结构的当前实例自动提供的（类似于其他一些语言中使用的“this”名称）。

this 可以根据c语言中的this指针理解，网上有很多资料。下面是查询的一些简单代码：

struct Car  // 结构体
{	
    int price;
};

void SetPrice(struct Car* this, int p){ // 结构体 car 的指针`this`
    this->price = p;  // 相当于给结构体中 price赋值 price = p 
}
int main(){
    struct Car car; // 创建结构体变量 car
    SetPrice(&car, 20000); // 给car 结构体的price 变量赋值
    return 0;
}

// C 语言是没有类定义 class 关键词，但是有跟 class 类似的定义，那就是 struct 结构体。
SetPrice 函数的第一个参数 this 指针的作用，就是为了给结构体 Car 域里的变量赋值。
this 指针的作用：其作用就是指向成员函数所作用的对象，所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。

Python集成

尽管Mojo仍在进行中，还不是Python的完整超集，但我们已经构建了一种按原样导入Python模块的机制，因此您可以立即利用现有的Python代码。在后台，该机制使用CPython解释器来运行Python代码，因此它可以与当今所有的Python模块无缝配合。

例如，以下是导入和使用NumPy的方法（您必须安装Python“NumPy”，但在这种情况下，它已经安装在Mojo Playground中）：

from python import Python

let np = Python.import_module("numpy")

ar = np.arange(15).reshape(3, 5)
print(ar)
print(ar.shape)

"""
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
(3, 5)
"""

注意：Mojo还不是Python的功能完整超集，因此Python中的一些语言模式或功能目前不起作用。因此，您不能总是复制粘贴Python代码并在Mojo中运行它。请报告您在GitHub上发现的任何问题(https://github.com/modularml/mojo/issues)。