Engee 文档
Notebook

数据类型

Julia语言类型系统是动态的，但与此同时它包含静态类型系统的一些优点，允许您指定某些值属于某些类型。

没有对象值和非对象值的划分：Julia中的所有值都是真正的对象，具有属于一个全连接类型图的类型，其中所有节点都与类型一样是一流的。

下面是比较Engee和MATLAB数据类型的汇总表。

/类型(Engee/MATLAB)/位数/最小值/最大值|
|--------------------------|----------------|----------------------|-----------------------|
|Int8/int8| 8 | -2^7 | 2^7 - 1 |
掳忙脠篓脣霉脱脨/UInt8| 8 | 0 | 2^8 - 1 |
掳忙脠篓脣霉脱脨/Int16| 16 | -2^{15} | 2^{15} - 1 |
掳忙脠篓脣霉脱脨/UInt16| 16 | 0 | 2^{16} - 1 |
|Int32/int32掳忙脠篓脣霉脱脨| 32 | -2^{31} | 2^{31} - 1 |
掳忙脠篓脣霉脱脨/UInt32| 32 | 0 | 2^{32} - 1 |
|Int64/int64| 64 | -2^{63} | 2^{63} - 1 |
掳忙脠篓脣霉脱脨/uint64| 64 | 0 | 2^{64} - 1 |
/Int128/否| 128 | -2^{127} | 2^{127} - 1 |
/UInt128/否| 128 | 0 | 2^{128} - 1 |
/Bool/逻辑/8/1/假(0)|真(1)/
/Float16/No/16/半精度/半精度|
/Float32|单|32/单精度/单精度|
/Float64|双|64/双精度/双精度|
|(Nifj或Qifj)/fi(i,x,n,m)/(最小8,最大64)/(最小1,最大1024)/定点数/定点数|

类型声明

操作员 :: 它可用于将类型注释附加到程序中的表达式和变量。 这样做有两个主要原因。

  1. 作为一个安装，以帮助确认您的程序正在按照您的期望工作。
  2. 为编译器提供有关类型的附加信息，并且在某些情况下这可以提高性能。

当添加到计算值的表达式, :: 运算符被读作"是一个实例"。

In [ ]: 
(1+2)::Int
Out[0]:
3

当添加到赋值左侧的变量时 :: 声明变量始终具有指定的类型，类似于静态类型语言（如C）中的类型声明。

In [ ]: 
function foo()
    x::Int8 = 100
end
Out[0]:
foo (generic function with 1 method)
In [ ]: 
x = foo()
Out[0]:
100
In [ ]: 
typeof(x)
Out[0]:
Int64

如果对变量的某个赋值意外更改其类型，则此功能可用于防止可能发生的性能问题。

此"声明"行为仅在某些上下文中发生，并适用于整个当前范围，甚至在声明之前。

In [ ]: 
local x::Int8  # in a local declaration

类型声明也可以应用于全局变量。

In [ ]: 
a = 10
Out[0]:
10
In [ ]: 
typeof(a)
Out[0]:
Int64
In [ ]: 
function foo(y)
        global a = 15   # throws an error when foo is called
        return a + y
end
Out[0]:
foo (generic function with 2 methods)
In [ ]: 
foo(10)
Out[0]:
25

声明也可以附加到函数定义。:

In [ ]: 
function sinc(x)::Float64
    if x == 0
        return 1
    end
    return sin(pi*x)/(pi*x)
end

sinc(1.1)
Out[0]:
-0.08942105846213334

抽象类型

抽象类型不能被创建，并且只能作为类型图中的节点，从而描述作为其后代的相关具体类型集。

In [ ]: 
abstract type Pointy{T} end
In [ ]: 
Pointy{Int64} <: Pointy
Out[0]:
true
In [ ]: 
Pointy{1} <: Pointy
Out[0]:
true
In [ ]: 
Pointy{Float64} <: Pointy{Real}
Out[0]:
false

元组的类型

元组是没有函数本身的函数参数的抽象。 函数参数最重要的方面是它们的顺序和类型。 因此，元组类型类似于参数化的不可变类型，其中每个参数都是单个字段的类型。 例如，由两个元素组成的元组的类型类似于以下不可变类型:

In [ ]: 
struct Tuple2{A,B}
    a::A
    b::B
end

但是，有三个关键区别:

  1. 元组类型可以有任意数量的参数。
  2. 元组类型在其参数中是协变的: Tuple{Int} 它是 Tuple{Any}. 因此 Tuple{Any} 它被认为是抽象类型，只有当它们的参数是特定的时，元组类型才是特定的。
  3. 元组没有字段名称；字段只能通过索引访问。

元组值写在括号和逗号中。 在构建元组时，按需生成相应的元组类型。:

In [ ]: 
typeof((1,"foo",2.5))
Tuple{Int64, String, Float64}
Out[0]:
Tuple{Int64, String, Float64}
In [ ]: 
Tuple{Int,AbstractString} <: Tuple{Real,Any}
Out[0]:
true
In [ ]: 
Tuple{Int,AbstractString} <: Tuple{Real,Real}
Out[0]:
false

Vararg元组的类型

元组类型的最后一个参数可以是一个特殊值。 Vararg，表示任意数量的有限元:

In [ ]: 
mytupletype = Tuple{AbstractString,Vararg{Int}}
Tuple{AbstractString, Vararg{Int64}}
Out[0]:
Tuple{AbstractString, Vararg{Int64}}
In [ ]: 
isa(("1",1,2), mytupletype)
Out[0]:
true
In [ ]: 
isa(("1",1,2,3.0), mytupletype)
Out[0]:
false

命名元组

命名元组是类型的实例 NamedTuple，它有两个参数：指定字段名称的字符元组和指定字段类型的元组类型。 为方便起见 NamedTuple 这些类型是用 @NamedTuple 的宏。

In [ ]: 
typeof((a=1,b="hello")) # prints in macro form
@NamedTuple{a::Int64, b::String}
Out[0]:
@NamedTuple{a::Int64, b::String}

参数基元类型

基元类型也可以参数化声明。 例如，指针表示为原始类型，将在Julia中声明，如下所示:

In [ ]: 
# 64-bit system:
primitive type P{T} 64 end
In [ ]: 
P{Int64} <: P
Out[0]:
true
In [ ]: 
P{Float64} <: P
Out[0]:
true

结论

此演示显示了主要类型的数据，以及它们的声明和应用的可能性。
有关详细信息，请参阅有关[整数和浮点数запятой](https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/#Integers-and-Floating-Point-Numbers），以及在关于[数据类型]的文章中（https://docs.julialang.org/en/v1/manual/types/#man-types ），在此基础上实施了这一示范。