「全新」 編程語言 Julia開箱體驗

---

本文共 851字，閱讀大約須要 3分鐘 ！

---

概 述

Julia 是一個 「全新」的高性能動態編程語言，前兩天迎來了其 1.0 正式版的重大更新。Julia集 Python、C、R、Ruby 之所長，感受就像一種腳本語言，而且對交互式使用有很好的支持。並且其天生的高性能、通用性與專業性使得其很是適用於科學數值計算、機器學習項目等前沿場景。我看完這個消息之後也火燒眉毛想嘗試一下。

注： 本文原載於 My Personal Blog：， CodeSheep · 程序羊 ！

本文內容腦圖以下：

---

Julia的特性

• 高性能：Julia 經過 LLVM 爲多個平臺編譯高效本地代碼，性能很高
• 動態性：編程範式靈活，代碼信噪比極高
• 通用性：易於表達OOP和函數式編程範式，而且其標準庫提供異步I / O，進程控制，日誌記錄，概要分析，包管理器等。
• 專業性：擅長數值計算，支持許多數值數據類型，而且提供開箱即用的並行性。
• 可組合性：Julia 的包之間能夠很好地協同工做。

正是因爲這些特性，才使其應用場景寬泛，並且都是當下前沿熱門應用場景：

---

編程環境支持

Julia經過提供了一系列插件支持，從而能夠在大多數常見的編輯器中進行編程，具體包括

• Atom
• VS Code
• Jupyter
• Vim
• Emacs
• SublimeText

---

Julia安裝和部署

Julia 提供了各類平臺和環境的安裝包，具體能夠去其官網進行下載：

安裝很是簡單，像 Windows平臺，基本上只須要點按下一步便可安裝到位，而 MacOS平臺使用 brew包管理器也僅需 一行命令 便可完成安裝。

下面我以 Linux CentOS 7.4 平臺爲例，介紹一些其安裝過程：

CentOS7 上 Julia 安裝也無需複雜的過程，只須要下載對應的可執行版本，並置於系統的命令路徑中便可愉快的使用：

wget https://julialang-s3.julialang.org/bin/linux/x64/1.0/julia-1.0.0-linux-x86_64.tar.gz
tar zxvf julia-1.0.0-linux-x86_64.tar.gz
cd /usr/bin
ln -s /root/julia-1.0.0/bin/julia

此時執行 julia 命令便可啓動 Julia控制檯，順便來向世界問一下好吧：

下面作一些上手實驗，大體來感覺一下該語言精煉、靈活的風格。即便不使用任何文字說明，也能很容易地理解各個命令的含義，這也說明該語言很好上手。

---

Julia上手體驗

• 變量操做

julia> x=10
10

julia> x+1
11

julia> x^2
100

julia> pi
π = 3.1415926535897...

julia> sqrt(100)
10.0

julia> ~123
-124

julia> 123 & 234
106

julia> ~UInt32(123)
0xffffff84

julia> [1,2,3] .^ 3
3-element Array{Int64,1}:
  1
  8
 27

julia> 1 == 1
true

julia> NaN == NaN
false

julia> NaN != NaN
true

julia>

julia> 'x'
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

julia> Int('x')
120

julia> str = "Hello, world.\n"
"Hello, world.\n"

julia> str[1]
'H': ASCII/Unicode U+0048 (category Lu: Letter, uppercase)

julia> str[end]
'\n': ASCII/Unicode U+000a (category Cc: Other, control)

julia> str[4:9]
"lo, wo"

julia> greet = "Hello"
"Hello"
julia> whom = "world"
"world"
julia> "$greet, $whom.\n"
"Hello, world.\n"

julia> findfirst(isequal('x'), "xylophone")
1
julia> findnext(isequal('o'), "xylophone", 1)
4
julia> findnext(isequal('o'), "xylophone", 5)
7
julia> findnext(isequal('o'), "xylophone", 8)

julia> occursin("world", "Hello, world.")
true
julia> repeat(".:Z:.", 10)
".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

julia> occursin(r"^\s*(?:#|$)", "not a comment")
false
julia> occursin(r"^\s*(?:#|$)", "# a comment")
true
julia> match(r"^\s*(?:#|$)", "# a comment")
RegexMatch("#")

• 類型轉換和提高

julia> x = 12
12

julia> typeof(x)
Int64

julia> convert(UInt8, x)
0x0c

julia> convert(AbstractFloat, x)
12.0

julia> a = Any[1 2 3; 4 5 6]
2×3 Array{Any,2}:
 1  2  3
 4  5  6

julia> convert(Array{Float64}, a)
2×3 Array{Float64,2}:
 1.0  2.0  3.0
 4.0  5.0  6.0

julia> promote(1, 2.5)
(1.0, 2.5)

julia> promote(2, 3//4)
(2//1, 3//4)

julia> promote(1.5, im)
(1.5 + 0.0im, 0.0 + 1.0im)

julia> promote(1 + 2im, 3//4)
(1//1 + 2//1*im, 3//4 + 0//1*im)

• 函數

julia> f(x,y) = x + y
f (generic function with 1 method)

julia> f(2,3)
5

julia> g = f
f (generic function with 1 method)

julia> g(2,3)
5

julia> ∑(x,y) = x + y
∑ (generic function with 1 method)

julia> ∑(2, 3)
5

julia> +(1,2,3)
6

julia> x -> x^2 + 2x - 1
#3 (generic function with 1 method)

julia> map(x -> x^2 + 2x - 1, [1,3,-1])
3-element Array{Int64,1}:
  2
 14
 -2

julia> function foo(a,b)
                a+b, a*b
          end;

julia> foo(2,3)
(5, 6)

julia> x, y = foo(2,3);

julia> x
5

julia> y
6

• 控制流

julia> z = begin
         x = 1
         y = 2
         x + y
       end
3

julia> function test(x, y)
         if x < y
           println("x is less than y")
         elseif x > y
           println("x is greater than y")
         else
           println("x is equal to y")
         end
       end
test (generic function with 1 method)

julia> test(1, 2)
x is less than y

julia> test(2, 1)
x is greater than y

julia> test(1, 1)
x is equal to y

julia> println(x < y ? "less than" : "not less than")
less than

julia> while i <= 5
         println(i)
         i += 1
       end
1
2
3
4
5

julia> for i = 1:5
         println(i)
       end
1
2
3
4
5

• 對象構造

外部構造方式：

julia> struct Foo
           bar
           baz
       end

julia> 

julia> fun=Foo(1,2)
Foo(1, 2)

julia> fun.bar
1

julia> fun.baz
2

julia> Foo(x) = Foo(x,x)
Foo

julia> Foo(1)
Foo(1, 1)

julia> Foo() = Foo(0)
Foo

julia> Foo()
Foo(0, 0)

內部構造方式：

julia> struct OrderedPair
           x::Real
           y::Real
           OrderedPair(x,y) = x > y ? error("out of order") : new(x,y)
       end

julia> 

julia> OrderedPair(1, 2)
OrderedPair(1, 2)

julia> OrderedPair(2,1)
ERROR: out of order
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] OrderedPair(::Int64, ::Int64) at ./REPL[45]:4
 [3] top-level scope at none:0

• 迭代與索引

迭代操做：

julia>  struct Squares
               count::Int
       end

julia> Base.iterate(S::Squares, state=1) = state > S.count ? nothing : (state*state, state+1)

julia> for i in Squares(7)
                  println(i)
       end
1
4
9
16
25
36
49

julia> 25 in Squares(10)
true

julia> using Statistics

julia> mean(Squares(100))
3383.5

julia> std(Squares(100))
3024.355854282583

julia> Base.eltype(::Type{Squares}) = Int

julia> Base.length(S::Squares) = S.count

julia> collect(Squares(4))
4-element Array{Int64,1}:
  1
  4
  9
 16

索引操做：

julia> function Base.getindex(S::Squares, i::Int)
               1 <= i <= S.count || throw(BoundsError(S, i))
               return i*i
       end

julia> Squares(100)[23]
529

julia> Base.firstindex(S::Squares) = 1

julia> Base.lastindex(S::Squares) = length(S)

julia> Squares(23)[end]
529

julia> Base.getindex(S::Squares, i::Number) = S[convert(Int, i)]

julia> Base.getindex(S::Squares, I) = [S[i] for i in I]

julia> Squares(10)[[3,4.,5]]
3-element Array{Int64,1}:
  9
 16
 25

基本的語言特性就體驗到這，剩餘的還有一些高級特性，包括：

• 模塊
• 元編程
• 並行計算
• 網絡和流
• 交互
• ......

不在此文一一贅述，詳細瞭解就去參考官方文檔吧。

---

後 記

因爲能力有限，如有錯誤或者不當之處，還請你們批評指正，一塊兒學習交流！

• My Personal Blog
• 個人半年技術博客之路