electronic_blue

用了 octopress 就沒理由再不寫 blog

Weak Typing Explained

|

常常聽到有些人誤解了 weak typing 的意義,或是對 C 語言同時是 static typed 與 weak typed 感到疑惑,因此提出一些我自己的想法。

我們先從 type checker 說起吧。

Type Checking

為了要讓人類容易理解並撰寫程式,幾乎所有的高階程式語言都有型別系統(type system)。變數的型別限制我們可以如何操作這個變數,比如說數字可以加減乘除、字串可以串接或截取部份等等。拿數字去做字串操作,或是拿字串去加減乘除1,都應該視為錯誤操作。2

在實作程式語言時,不管是 compiler 或是 interpreter,只要語言中包含型別系統,就會試圖阻止超出型別限制的變數操作,這個功能稱之為 type checking。

1
2
3
4
5
6
x = "foo";
y = "bar";

// 如果星號代表數字乘法,下面這行無法通過 type checking,
// compiler 或 interpreter 應該拒絕執行這行程式碼。
z = x * y;

Type checker 可以在 compile 的時候檢查變數的型別,也可以延遲到執行時才進行檢查,這就是 static type-checking 與 dynamic type-checking 的差別。

Static/Dynamic Type-Checking

這兩個名詞通常沒什麼爭議:static type-checking 意指程式中的變數在 compile time 時進行 type checking,而 dynamic type-checking 意指在 run time 才進行 type checking。

1
2
3
4
5
// Java code
String x = "foo";
String y = "bar";
String z = x * y;
          // ^ error: bad operand types for binary operator '*'
1
2
3
4
5
6
7
8
# Ruby code
def hello
    x = "foo"
    y = "bar"
    rerturn x * y # 不會發生 compile error
end

hello # 執行時產生 TypeError: can't convert String into Integer

Weak Typing

而所謂的 weak typing,一般會有兩種解釋方法:

  1. 語言在遇到 type error 時,會自動轉換型別以符合要求。
  2. 語言省略了部份的 type checking。

我個人比較傾向第二種解釋方法,以下將會說明為什麼我會選擇後者。

自動型別轉換

為了方便程式設計師,程式語言或多或少會進行自動型別轉換,比如說這個例子:

1
2
# Perl code
print "10" + 20; # print "30"

有些語言則認為這是不良習慣:

1
2
3
# Python code
print "10" + 20      # TypeError: cannot concatenate 'str' and 'int' objects
print int("10") + 20 # ok

有些人會藉此主張 Perl 與 C 屬於 weak typing,而 Python 與 Java 屬於 strong typing。然而實際上,自動型別轉換發生在各種地方:

1
2
# Python code
print 10 + 20.0      # 自動轉換成 float(10) + 20.0
1
2
// Java code
System.out.println("10" + 20); // 自動轉換成 "10" + Integer.toString(20)

大部份的主流語言 (Java、C#、Python、Ruby) 都會進行自動型別轉換,真要符合定義的話,大概要像 Haskell 這樣:

1
2
3
4
5
6
7
-- Haskell code
let x = 10 :: Float
let y = 20 :: Double
let z = x + y -- error: Couldn't match expected type `Float' with actual type `Double'

import GHC.Float
let z = float2Double(x) + y -- OK

OCaml 甚至區分了整數加法與浮點數加法:

1
2
3
4
(* OCaml code *)
1 + 2.0;;    (* type error *)
1.0 + 2.0;;  (* type error *) (* 加號只能用在整數 *)
1.0 +. 2.0;; (* OK *)

嚴格要求明確的型別轉換有好處也有壞處,不過大部份人恐怕都無法習慣 Haskell 或 OCaml 這麼嚴格的規則。即使是以 “Explicit is better than implicit” 為理念的 Python 也仍然在語言上允許相當多的自動(implicit)型別轉換。

我比較不傾向用自動型別轉換來區分程式語言屬於 strong typing 或 weak typing,因為大多數主流語言幾乎都做了自動型別轉換,你頂多只能說某個語言在型別上比另一個語言「強」3,而不是直接把語言劃分為 strong typing 與 weak typing 兩大塊。

省略 Type Checking

另一個 weak typing 的定義是語言在某些地方會省略 type checking,或是允許程式設計師用某種方法繞過 type checker 的限制。這件事在 C 裡面實在太常見了:

1
2
3
/* C code */
int x = 10;
printf("%s\n", x); /* undefined behavior */

printf 的函式宣告採用不定參數,因此 compiler 省略了對 x 的型別檢查,其結果為 undefined behavior。另一個例子是 union:

1
2
3
4
5
6
7
8
9
10
/* C code */
union {
    int x;
    char c[2];
} u;

u.c[0] = 10;
u.c[1] = 20;
printf("%d\n", u.x); /* undefined in C89              */
                     /* implementation-defined in C99 */

C 並不會在 union 結構中記錄上一個存入的成員為何,因此也無法在 run time 發出錯誤以阻止使用者取用 u.x

相較於自動型別轉型,我認為藉由是否省略 type checking 來區分 weak/strong typing 是比較明確的定義方法。在這個定義下,C 與 C++ 屬於 weak typing,而 Java、C#、Perl、Python、Ruby 屬於 strong typing。


  1. 有人可能認為字串加法就是串接的意思,但實際上只是許多語言用加號來同時代表數字加法與字串串接,我們還是不能對字串進行數字的加法。

  2. 承上,個人認為使用加號來進行字串串接是錯誤設計,既然串接與加法是不同概念,就應該使用不同的運算元,但不知為何一堆語言還是這麼做。

  3. 比較自動型別轉換的數量也很奇怪,C# 或 Java 的 integer promotion 規則可多了,甚至 Java 還有 auto boxing/unboxing,在這定義下實在很難稱它們為 strong typing。

迴響