var

Mojo 引入了新的和语句，让我们创建变量。**let**``**var**

如果我们愿意，我们可以指定一个类似或变量的类型，就像我们在 TypeScript 中所做的那样。 允许变量更改; 不会。所以它不像 JavaScript 和 - 没有提升，并且是恒定的。Int``String``**var**``**let**``let``var``var``let

def your_function（a， b）： let c = a # 取消注释以查看错误： # c = b # 错误： c 是不可变的，如果 c ！= b： let d = b print（d）your_function（2， 3)

2. s 用于更快的抽象struct

我们在C++、Go 等中都有它们。

结构是类似于Python类的Mojo功能，但它们是不同的，因为Mojo类是静态的：你不能添加更多的运行时方法。这是一种权衡，因为它不太灵活，但速度更快。

struct MyPair： var first： Int var second： Int # 我们在这里使用 'fn' 而不是 'def' - 我们将很快解释 fn __init__（inout self， first： Int， second： Int）： self.first = first self.second = second  fn __lt__（self， rhs： MyPair） -> Bool： return self.first < rhs.first 或 （self.first == rhs.first and自我秒< rhs.秒）

这里有一种方法比：所有字段都必须显式定义更严格。struct``class

3.强型式检验

这些结构不仅给了我们灵活性，还允许我们在 Mojo 中编译时检查变量类型，就像 TypeScript 编译器所做的那样。

def pairTest（） -> Bool： let p = MyPair（1， 2） # 取消注释以查看错误： # 返回 p < 4 # 给出编译时错误返回 True

是一个 ， 是一个 ;Mojo根本不允许这种比较。4``Int``p``MyPair

4. 方法重载

C++、Java、Swift 等都有这些。

函数重载是指有多个同名函数接受具有不同数据类型的参数。

看看这个：

struct Complex： var re： F32 var im： F32 fn __init__（inout self， x： F32）： “”“”从实数制作复数。 self.re = x self.im = 0.0 fn __init__（inout self， r： F32， i： F32）： “”“”从其实部和虚部组成复数。 self.re = r self.im = i

像JavaScript和Python这样的无类型语言根本不可能有函数重载，原因很明显。

尽管在基于参数/类型的模块/文件函数和类方法中允许重载，但它不能仅基于返回类型工作，并且函数参数需要具有类型。如果不这样做，重载将不起作用;所有将发生的是最近定义的函数将覆盖所有以前定义的具有相同名称的函数。

5. 与 Python 模块轻松集成

拥有无缝的Python支持是Mojo迄今为止最大的卖点。

在Mojo中使用Python模块很简单。作为超集，您需要做的就是使用模块名称调用该方法。**Python.import_module()**

在这里，我正在导入，这是世界上最受欢迎的Python库之一。**numpy**

从PythonInterface import Python# 把它想象成 Python中的 'import numpy as np' let np = Python.import_module（“numpy”）# 现在就像你在 Python 数组中使用 numpy = np.array（[1， 2， 3]）print（array）

你可以对任何 Python 模块做同样的事情;一个限制是您必须导入整个模块才能访问单个成员。

所有 Python 模块在 Mojo 中的运行速度将提高 35,000 倍。

6. — 定义函数的新方法fn

fn`基本上是有更严格的规则。`defdef`灵活，可变，对**Python友好**; 是恒定的，稳定的，并且**Python丰富**。这就像 JavaScript 的严格模式，但只是为了 .`fn``defstruct MyPair:    fn __init__(inout self, first: Int, second: Int):        self.first = first        self.second = second

fn的规则：

• 不可变的参数：默认情况下，参数是不可变的（包括），因此您不会错误地改变它们。self
• 必需的参数类型：您必须为其参数指定类型。
• 必需的变量声明：在使用它们之前，您必须在 中声明局部变量（当然，使用 和）。fn``let``var
• 显式异常声明：如果抛出异常，你必须明确指出 - 就像我们在 Java 中使用关键字所做的那样。fn``throws

7. 可变和不可变的函数参数

按值传递与按引用传递。

你可能在像C++这样的语言中遇到这个概念。

Python 的函数使用按引用传递，就像在 JavaScript 中一样;您可以改变在 .但是Mojo使用按值传递，所以你在里面得到的是传递对象的副本。因此，您可以随心所欲地更改该副本;这些更改不会影响主对象。**def**``def``**def**``def

按引用传递提高了内存效率，因为我们不必为函数创建对象的副本。

但是新功能呢？与 Python 一样，它默认使用按引用传递，但关键的区别在于这些引用是不可变的。因此，我们可以读取函数中的原始对象，但不能对其进行变异。fn``def

不可变参数

borrowedMojo中一个新鲜的，新的，多余的关键字。

因为所做的是使 Mojo 函数中的参数不可变 - 默认情况下它们是不可变的。在处理占用大量内存的对象时，这是非常宝贵的，或者我们不允许复制我们正在传递的对象。borrowed``fn

例如：

fn use_something_big（借用 a： SomethingBig， b： SomethingBig）： “”“'a' 和 'b' 都是不可变的，因为'借用'是默认值。 a.print_id（） // 10  b.print_id（） // 20 let a = SomethingBig（10）let b = SomethingBig（20）use_something_big（a， b）

我们不是在函数中复制巨大的对象，而是简单地将引用作为不可变的参数传递。SomethingBig``fn

可变参数

如果我们想要可变参数，我们将使用 new 关键字：**inout**

结构 Car： var id_number： Int var color： String fn __init__（inout self， id： Int）：  self.id_number = id self.color = 'none' # self 如上所述通过引用传递突变。 fn set_color（inout self， color： String）： self.color = color # 默认情况下，像 self 这样的参数作为借用传递。 fn print_id（自我）： # 与： fn 相同 print_id（借用的自我）： print（'Id： {0}， 颜色： {1}'） 汽车 = Car（11）car.set_color（'红色'） # 无错误self`在函数中是不可变的，因此我们在这里需要修改 中的字段。`fn``inout``color``set_color

关键要点

• Mojo：是一种新的AI编程语言，具有C的速度和Python的简单性。
• **let**和声明：Mojo 介绍和语句，用于创建可选类型变量。 变量是可变的，变量不是。**var**``let``var``var``let
• 结构：Mojo具有静态结构，类似于Python类，但由于它们的不变性而更快。
• 强类型检查：Mojo支持编译时类型检查，类似于TypeScript。
• 方法重载：Mojo允许函数重载，其中同名函数可以接受不同的数据类型。
• Python模块集成：Mojo提供无缝的Python支持，运行Python模块的速度明显更快。
• **fn** 函数定义：Mojo中的fn关键字是Python的更严格的版本，需要不可变的参数和显式的异常声明。def
• 可变和不可变参数：Mojo引入了可变（）和不可变（）函数参数。inout``borrowed

结语

当我们见证Mojo的揭幕时，思考这种以AI为中心的新语言如何彻底改变编程领域是很有趣的。通过易于使用的Python提供弥合性能差距，并引入强大的功能，如强大的类型检查，可能预示着人工智能开发的新时代。让我们怀着好奇心和渴望来拥抱这种转变，以充分发挥Mojo的潜力。