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)。

##接下来的步骤

我们希望这本笔记本涵盖了足够多的基础知识,让你开始学习。它故意简短,所以如果你想了解更多细节,请查看Mojo编程手册

另请参阅其他Mojo笔记本

了解更多有趣和复杂的代码示例。

要查看所有可用的Mojo API,请查看Mojo标准库参考

GitHub 官网地址:https://github.com/modularml/mojo

热门相关:总裁别再玩了   大妆   大妆   充满爱意的少妇献出乳房   不科学御兽