Shell: 如何刪除無用的 Ubuntu modules ?

如何刪除無用的 Ubuntu modules ?

結論:

> dpkg -l linux-image-[0-9]*-generic | awk '/^ii/{ print $2}' | grep -v -e `uname -r` | sort -V | head -n -1 | xargs apt-get purge -y 
> dpkg -l linux-headers-[0-9]*-generic | awk '/^ii/{ print $2}' | grep -v -e `uname -r` | sort -V | head -n -1 | xargs apt-get purge -y 

廢話:

好意也時會帶來惡果.

正文:

當你安裝完 Ubuntu Server 後, 如果沒有關掉自動更新, ubuntu 會很貼心的將他每一次的 release 都放一份映象檔到你的 Server 上. 但可喜可賀的, 假如你從不需要關機(也沒有當機), 當然你用的還是你原先安裝的那個版本. 但不幸的事總是會伴隨好意來到. 雖然每個映象檔大約也不過 200M(目前, 誰都知道系統是會胖的), 但以每個月更新 1 到 2 次的頻率, 不到半年就佔去你 1G 的空間了, 因為自動更新雖然會幫你自動安裝, 但不會幫你自動清理用不著的檔案. 下載的檔案一般會放在 /lib/modules 目錄下.

> du -hd1 /lib/modules
du -hd1 /lib/modules
// 197M    /lib/modules/3.19.0-65-generic
// 197M    /lib/modules/3.19.0-64-generic
// 197M    /lib/modules/3.19.0-66-generic
// 197M    /lib/modules/3.19.0-61-generic
// 788M    /lib/modules

但更大的不幸是你非常有專業水準的為系統分割了磁區或限定了容量, 或本來你的硬碟就不怎麼大. 所以, 準備好你的杯子, 因為悲劇發生了.

> df -h
// Filesystem      Size  Used Avail Use% Mounted on
// /dev/sda1       9.9G  3.7G  5.7G  40% /

以三個月使用 1G 來計算, 悲劇將在一年後發生.

你可以選擇直接刪除 /lib/modules 下用不著的檔案. 但你最好還是先看看你目前使用的系統模組是哪個版本. 使用 uname -r. 記得到Ubuntu release 看一下你用的版本(version)跟核心(kernel)對照. 也可以順便看一下詳細有哪些分支.

>  uname -r
// 3.19.0-65-generic

以這個例子來說, 3.19.0-64-generic 和 3.19.0-61-generic 是舊的. 通常我們會保留前一個版本, 也不安裝最新的版本, 再加上目前使用的版本, 一共有三個版本.

雖然直接刪除 /lib/modules 下用不著的檔案不失為一個簡單的方法. 但還是有很多不需要的安裝檔在其他地方. 使用 apt-get remove是比較好的方式.

> sudo apt-get remove -y --purge 3.19.0-61-generic*
// or 
> sudo apt-get purge -y 3.19.0-61-generic*
// 簡化的參數

要移除前, 先找出目前安裝過的版本.

> dpkg --list | grep  linux-image-.*-generic | awk '{print $2}'
// or
> dpkg -l | grep  linux-image-.*-generic | awk '{print $2}'
linux-image-3.19.0-61-generic
linux-image-3.19.0-64-generic
linux-image-3.19.0-65-generic
linux-image-3.19.0-66-generic
linux-image-extra-3.19.0-61-generic
linux-image-extra-3.19.0-64-generic
linux-image-extra-3.19.0-65-generic
linux-image-extra-3.19.0-66-generic

再移除,

> apt-get purge -y 3.19.0-61-generic*
// 選擇要移除的
// 或
> dpkg -l linux-image-[0-9]*-generic | awk '/^ii/{ print $2}' | grep -v -e `uname -r` | sort -V | head -n -1 | xargs apt-get purge -y 
// 使用 grep -v -e `uname -r` 去掉"目前的版本"
// 使用 sort -V 依版本先後排序
// 使用 head -n -1 去掉"最後的版本"

如果不需要 “header”, 也可以移除

> dpkg -l linux-headers-[0-9]*-generic | awk '/^ii/{ print $2}' | grep -v -e `uname -r` | sort -V | head -n -1 | xargs apt-get purge -y 

要裝回來, 就用 apt-get install,

> apt-get install linux-image-3.19.0-61-generic

最後你可以將他寫成 script, 放到開機啟動或 crontab 去執行.

Shell:如何在 ps 中不要看見自己?

如何在 ps 中不要看見自己?

結論:

> ps -ef | grep -v grep | grep 

或, 利用將 PATTERN 字串改為第一個字以 [] 框起來的正規表達式來過濾.

> ps -ef | grep [P]ATTERN

廢話:

自己從來是一件麻煩的事.

正文:

在 linux 文字模式上工作, 有個指令不會少打, 頻率大概只會少於 ls. ls 會列出目前目錄下的所有檔案跟目錄; ps 則會列出目前執行的程序.

這是因為有太多程式在背景中執行, 而他們也不會因為你點了滑鼠就跳出來告訴你, “我在這裡!”. 他們總是默默工作, 直到你點名才會知道他們存在. 而用來點名的指令就是ps. 使用 ps 只是點了你自己執行的程序名, 想知道目前有哪些程序在這台電腦上執行你必須下 ps -ef 或ps aux.

通常點名, 我們也希望有效率一點, 所以我們會用 grep 來協助抽點. 例如, 想知道目前有沒有 node 程式在執行, 可以下 ps -ef | grep node. 但這樣的結果有時候不夠完美, 因為你剛剛下的指令也是程序之一, 其中也有"node"字串, grep 也會將他挑選出來, 而這通常不是我們要的結果.

還好, grep 提供 -v 這個參數, 他會將挑出不符合的結果. 利用這個, 將 ps -ef | grep node 的結果再過濾一遍, 使用 ps -ef | grep node | grep -v grep 就能得到我們真正希望的結果.

不過, 有些 shell 會幫你在 grep 中加上 --color=auto 來為傳回結果著色. 為避免失去這個效果, 可以將真的要過濾條件放在最後面. 在這個例子, 也就是 ps -ef | grep -v grep | grep node.

最後我們得到 ps -ef | grep -v grep | grep  這樣的命令模式.

在這樣的使用案例上, 透過一個小技巧利用 regexp 的邊際效應, 可以改寫, 如下

> ps -ef | grep [n]ode

這是因為 字串 “ps -ef | grep node” 是吻合 /node/ . 而 字串 “ps -ef | grep [n]ode” 並不吻合 /[n]ode/. /[n]ode/ 要求一個 “n” 後面接 “ode”, 而 grep 的字串模板是"n"後面接 “]ode”.

或許, 你認為這樣太麻煩, 用 眼睛 看, 不就能區分出來了? 但實際上, 這常常被應用在 shell script 中, 來去判斷某些程序是否在執行了.

Shell&JS: 簡單的集合運算

簡單的集合運算

結論:

// A 與 B 目錄下的檔案
> ls A B
// A:
// apple  book  can  cup  chair
// 
// B:
// book  cup  dog  hat  table
//

// 交集: A&B
> (ls A;ls B) | sort | uniq -d 
// book
// cup

// 聯集: A|B
> (ls A;ls B) | sort | uniq 
// apple
// book
// can
// cup
// chair
// dog
// hat
// table

//差集: A-B , 注意 `ls B` 重複兩次, 不是筆誤.
> (ls B;ls B;ls A) | sort | uniq -u
// apple
// can
// chair

//對稱差: A^B = (A-B)|(B-A), A^B = (A|B)-(A&B)
> (ls A;ls B) | sort | uniq -u
// apple
// can
// chair
// dog
// hat
// table

廢話:

集合在數學中占有很大的分量, 但基礎是簡單的. 在程式中也經常需要用到. 使用程式語言時, 只要使用 for 跟 if, 應該就能簡單的達成交集, 聯集和差集的運算. 但有時候特地去寫程式之類, 還是算了吧.

在 shell 中利用 sort 跟 uniq 也能達成簡單的集合運算. 以下分別舉例來說明如何達成集合最基本的運算.

正文:

• 交集: 兩個集合中相同的元素. 使用 JS 陣列時, 可以如下處理,

var A = ['apple', 'book', 'can', 'cup', 'chair'];
var B = ['book', 'cup', 'dog', 'hat', 'table'];
var S = [];

for (var i = 0; i < A.length; i++){
    var p = A[i];
    for (var j = 0; j < B.length; j++){
        var q = B[j];
        if (p == q) {           
            S.push(q);
            break;
        }
    }
}
console.log(S);
// [ 'book', 'cup' ]

同樣的假設 A 和 B 目錄下各有數個檔案. 如下, A 有 ‘apple’, ‘book’, ‘can’, ‘cup’, ‘chair’ B 有 ‘book’, ‘cup’, ‘dog’, ‘hat’, ‘table’ 使用 shell 指令來處理,

> (ls A;ls B) | sort | uniq -d
// book
// cup

使用 sort 是因為 uniq 的輸入必須是已經被排序的. 如果給 uniq 一個不是排序的資料, 將會得到錯誤的結果. 且 uniq -d 是列出重複的資料. 整個命令的意思是說: 列出A目錄跟B目錄下的檔案, 把他們放在一起, 丟給sort排序, 然後再列出重複的資料.

利用同樣的思路, 改用 JS 來處理, 如下

var A = ['apple', 'book', 'can', 'cup', 'chair'];
var B = ['book', 'cup', 'dog', 'hat', 'table'];
var X = A.concat(B);
var S = {};

for (var i=0; i< X.length; i++){
    S[X[i]] = (S[X[i]] || 0) + 1;    
}
// 上面的 JS 以計算重複次數代替判斷重複, 需要遍歷整個陣列 X,
// 所以有無排序不影響結果.

for (obj in S){
    if (S[obj] > 1) {
        console.log(obj);
    }
}
// book
// cup

• 聯集: 有出現在兩個集合中元素.

var X = A.concat(B);
var S = {};

X.forEach(function(obj){
    S[obj] = (S[obj] || 0) + 1;
});
// 改用 Array 的 `forEach` 方法來計算重複次數

for (obj in S){
    console.log(obj);    
}
// 因在計算重複次數時, 已將相同的元素合併計算次數, 
// 所以只要將 S 的所有元素印出, 即可.
// apple
// book
// can
// cup
// chair
// dog
// hat
// table

而使用 shell 指令來處理, 就更簡單, 只要下 (ls A;ls B) | sort | uniq 就行了.

• 差集: 有出現在其中一個集合並不出現在另一個集合的元素. 下面是可用的 JS 程式碼,

var S = [];

for (var i = 0; i < A.length; i++){
    var p = A[i];
    S.push(p);
    for (var j = 0; j < B.length; j++){
        var q = B[j];
        if (p == q) {                       
            S.pop();
            break;
        }
    }
}
console.log(S);
// [ 'apple', 'can', 'chair' ]

實作上程式的邏輯有許多方式, 這裡採用先將 A 陣列的元素放入一個容器後, 再用迴圈判斷是否存在 B 陣列中, 如果存在就再將他移出的. 好處是可以省去使用判斷是否存在 B 陣列旗標.

在 Shell 中, 要達成差集必須要有一點巧思. 我們知道差集是 A 集合減去 B 集合剩下來的元素, 所以該差集 不會 包含 B 集合的元素. 而利用uniq -u 可以列出不重複的資料, 故 (ls B;ls B) | sort | uniq -u 應該不會傳回任何資料, 因為 B 目錄下的檔案全部被重複了兩遍. 同理, 當使用(ls B;ls B;ls A) | sort | uniq -u 時, 傳回的就會是 A 目錄中不與 B 重複的檔案. 因為 A 跟 B 重複的元素, 必定也是 B 的元素, 而已經重複兩次 B 元素再加 A 重複 B 的元素還是重複, 都會被 uniq -u 消除掉. 所以在這裡 ls B 要重複兩次. 如果只是單純的(ls B;ls A) | sort | uniq -u 則會列出 A 和 B 目錄下的不重複的檔案. 也就是 A 目錄下的檔案加上 B 目錄的下的檔案再減去 A 和 B 目錄下都有的檔案, 也就是 A 跟 B 的對稱差.

根據這個思路, 改寫 JS 如下,

var X = A.concat(B).concat(B);
var S = {};

X.forEach(function(obj){
    S[obj] = (S[obj] || 0) + 1;
});

for (obj in S){
    if (S[obj]==1) {
        console.log(obj);    
    }
}
// 印出只出現一次的元素
// apple
// can
// chair

其實, 集合的運算是可以類比如位元的運算. 重新整理上面的案例, 將資料整理, 賦予每一個元素一個數值, 如下,

// apple=1, book=2, can=4, cup=8, chair=16, dog=32, hat=64, table=128;
// A = ['apple', 'book', 'can', 'cup', 'chair'] => [1, 2, 4, 8, 16]
// B = ['book', 'cup', 'dog', 'hat', 'table'] => [2, 8, 32, 64, 128]

//將 A, B 改用數值表示
  var A = 1 + 2 + 4 + 8 + 16;
// A, 十進位:  31,  二進位: 1 1111

  var B = 2 + 8 + 32+ 64+ 128;
// B, 十進位: 234,  二進位: 1110 1010

// 交集: A&B
  var x = A & B;
// 10  
// 十進位:  10,  二進位: 1010
// 10 => 2 + 8 => book, cup

// 聯集: A|B
  var x = A | B;
// 255
// 十進位:  255,  二進位: 1111 1111
// 255 => 1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 
// => apple, book, can, cup, chair, dog, hat, table

// 差集: A-B?
  var x = (A|B) - B;  
// 21
// 十進位:  21,  二進位: 0001 0101
// 21 => 1 + 4 + 16 => apple, can, chair
// A集合去掉B集合的元素可表示為 A 與 B 的聯集(A|B)再去掉 B 集合, 
// 這樣就只會剩下沒有 B 集合元素的 A 集合元素.
// 這裡沒辦法直接 `A-B` 是因為若有一 B 集合元素不在 A 集合中, 
// 則會變成空集合減扣掉某一元素, 在這邊就沒辦法正確表示.

// 對稱差: A ^ B
  var x = A ^ B;
// 245 
// 十進位:  245,  二進位: 1111 0101 
// 245 = 1 + 4 + 16 + 32 + 64 + 128 =>apple, can, chair, dog, hat, table

不過 JS 的位元運算並不像 C 語言一樣有較高的效率. 雖說在運算上簡單不需要迴圈, 但要將結果轉回對映的元素, 仍要進行一串二進位運算. 總的來說, 程式碼也不算特別簡潔. 不過, 在一些特殊的運用場合仍有其用途.

所以集合運算可對應位元運算如下,

• 交集: A&B, and 運算.
• 聯集: A|B, or 運算.
• 差集: (A|B)-B, 特殊條件下的減法運算.
• 對稱差: A^B, xor 運算.

Linux: 如何找到有特定內容的檔案名稱?

如何找到有特定內容的檔案名稱?

結論:

> find ./ -type f | xargs -i grep -l 'target' {}

廢話:

大海撈針, 乾草堆裡找線頭. 絕對不要捲起袖子自己做.

現在還有人沒使用過 Google 的搜尋服務? 曾幾何時 不用說就是1998, Google誕生之前. 可憐的蓋世(GAIS)搜索, 還有人記得?, 各家網頁黃頁服務爭鳴, Yahoo 也因此崛起. 但如今還有幾人知曉蕃薯藤, 更不用說是其他小型入口網站. 而原本占據在瀏覽器 書籤 或 我的最愛 的各種網頁索引或目錄網站也早已消失不見. 取而代之的是 搜尋.

正文:

茫茫資訊海, 誰來搜尋? 一曰 find, 再者 grep.

find 功力強大, 能幫助你找到檔案, 但並不能幫助你找到檔案內有甚麼? 簡單的介紹用法, 如下.

根據檔名來找,

> find . -name "*.log" -print
//find  -name  -print
//find 後面接要搜尋的路徑, -name 後面接要比對的模式, 用 -print 將找到的檔案印出

接在 find 命令後的表達式, 主要可以區分 測試(Tests), 行動(Actions), 關聯操作(Operators) 等部分.

• 測試(Tests)會根據參數或描述傳回 true 或 false.
• 行動(Actions)指示找到檔案後要做的事, 例如:-print`指示將找到的路徑列印出來.
• 關聯操作(Operators)則是用來連接不同的參數或描述.-o 意指 OR, -a 意指 AND. 沒指定就是-a.

根據名稱來找,

> find . -name "*.log" -print

上述範例是要"印出所有當前目錄下, 名字以 .log 結尾的".

根據類型來找, find -type

> find . -type f -name "*.log" -print

上述範例是要"印出所有當前路徑下, 類型是"檔案", 且名字以 .log 結尾的. -type 常用的參數, 如下,

`d`    目錄
`p`    具名的 pipe
`f`    一般檔案
`l`    連結檔
`s`    socket

排除特定路徑,

> find . -path "./test" -prune -o -print
//印出所有當前目錄下, 除了在路徑./test 下的檔案.

這是因為 -prune 條件成立時, 總是傳回 true, 且條件是目錄時不會往下處理, 故可以利用 -o 來造成判斷的捷徑.
舉上例來說, 當比對到 “./test” 時, 傳回 true. 而後面是邏輯 OR 運算, 不管後面是 true 或 false , 結果都會是 true, 所以就不用再判斷, 也不用做下去. 因此, -o之後的 -print 不會被執行到. 但當比對的不吻合 “./test”, 傳回 false, 而可繼續執行其後的條件判斷.

如果不使用 -prune, 則只有路徑完全一樣的, 才會被排除掉.

> find . -path "./test" -o -print
//印出所有當前目錄下, 除了路徑是 "./test", 
//所以如果檔案路徑是"./test/a.txt" 則會被印出, 
//但路徑 "./test" 不會被印出.

所以, 以下與使用 -prune 約略等效,

> find . -path "./test/*" -o -print
//印出所有當前目錄下, 除了路徑吻合 "./test/" 檔案(注意, 最後有斜線).
//但 "./test"(注意, 最後沒有斜線) 本身會印出來

依檔案的時間來找, 可用的參數, 如下

-mtime n    檔案的最後修改時間, 單位是天.
-mmin  n    檔案的最後修改時間, 單位是分鐘.
-atime n    檔案的最後存取時間, 單位是天.
-amin  n    檔案的最後存取時間, 單位是分鐘
-ctime n    檔案狀態相關資訊最後修改的時間, 單位是天.
-cmin  n    檔案狀態相關資訊最後修改的時間, 單位是分鐘.

簡單來說, 後面接"time"的單位是天, 接"min"的是分鐘. 時間都是從現在開始往前(過去)推的. 然後, 從推定的時間點, 之前就用+, 之後用 -. 例如, 如果現在是 2016-07-06 12:00:00 則 -mtime +1 就是說距現在 1天的時間點, 也就是 2016-07-05 12:00:00 之前被修改過的檔案.而 -mtime -1 是指 2016-07-05 12:00:00 之後到現在被修改過的檔案. 簡言之, -mtime +1 可以翻譯成 1 天前被修改過的檔案. -mtime -1 可以翻譯成 1 天內被修改過的檔案.

前面接"m"的是指被修改過. 接"a"是指被存取過(一般而言有被修改當然就有被存取, 但也有不先讀取資料就直接改變檔案內容的方法). 接"c"是指雖然沒被存取, 但有改變權限, 群組, 所有人或修改時間之類的(修改算狀態變動, 但存取不算).

依檔案的大小來找,

> find . -size 30M -print
//印出所有當前目錄下, 檔案大小等於 30M 的檔案.
// -size n[cwbkMG]
`b`    blocks 一般為 512-byte 
`c`    bytes
`w`    1 個 word 等於 2 個 bytes
`k`    Kilobytes (等於 1024 bytes)
`M`    Megabytes (等於 1048576 bytes)
`G`    for Gigabytes (等於 1073741824 bytes)

+ 是大於, -是小於, 例如: -size +30M 檔案大於 30M 的檔案.

找檔案用 find, 找內容用 grep. 接下來介紹 grep, 大誤 要會熟用 grep 要學會正規表達式(regex), 但沒打算在這一併介紹. 目前只要知道 grep 命令的參數格式, Usage: grep [OPTION]... PATTERN [FILE]...

簡單說明, grep -l 能讓你只印出檔名, 而不是內容比對吻合的文字. xargs -i 來幫你填入參數, 用{}指定位置.

利用 find 過濾要找的檔案範圍, 利用管道 | 將找到的檔名交給 grep 分析內容. 然後印出有吻合 grep 指令所給定 PATTERN 內容的檔名.

> find ./ -type f | xargs -i grep -l 'target' {}
// 利用 `xargs` 把 `find` 找到的檔名填入"{}"處

現在, 你也可以自製一個桌面板的 Google 搜尋了. :P

Linux: 如何在上使用 ISO 時間格式表示 UTC 時間 ?

如何在 Linux 上使用 ISO 時間格式表示 UTC 時間 ?

這是一個關於時間, 時區的問題. 並作為第一篇網誌向其網誌名稱出處致敬.   (當然, 我不會告訴你 :P)

而如同網誌子標題所暗示的, 這是一系列記錄程式設計上的問題解答.

• 首先, 為了節省大家的時間, “結論” 會放在前面.
• 再者, 為了浪費大家的時間, 中間會加入 “廢話”.
• 然後, 為了避內容農場嫌疑, 附上冗長的 “正文”.

結論:

使用 ls 查詢檔案時,

> TZ=utc ls -l --time-style=+%Y-%m-%dT%H:%M:%S%z

使用 date 查詢時間時,

> date -uIsec

廢話:

好, 正文之前先說明一下兩個詞彙.

• UTC
• ISO 8601

當然你一定知道這是甚麼, 不然你也不太可能看到這篇文章. 但請容許我為不小心誤入的讀者說明.

UTC 就是所謂的"世界協調時間", 又稱世界標準時間.  (只看中文還以為這世界一直在吵架. 不過, 也不算錯, 因為這名稱就是吵完架的結果 :P) 使用格里曆也就是西元紀年, 以英國格林尼治皇家天文台的當地 平太陽時 為準, 午夜零時為一天的起點. 以當地為本初子午線(0度經線), 往東為東經, 往西為西經. 東經 7.5 度到西經 7.5 度為 零時區 , 由零時區開始, 每隔 15 度劃為同一個時區(原則上). 向東每跨 1 個時區加 1 小時, 反之向西每跨 1 時區減 1 小時. 全球共分為 24個時區. 例如台灣就是 UTC+8 . 而鄰近東經或西經 180 度處畫有一條 國際換日線 . 由東經跨越國際換日線到西經, 必須將日期減掉 1 天; 反之, 由西經跨到東經去, 必須在時間上加 24 個小時.

ISO 就是"國際標準化組織", 他們訂的一連串標準, 就是所謂的 ISO 標準. 而 ISO 8601 就是"日期和時間的表示方法"的標準. 日期以 4 位的西元年, 2位月跟日, 中間以-連接, 時間以 2 位數的時分秒表示, 其中時須以 24 小時制表示, 中間以:連接. 日期與時間以T連接. 如果是 UTC 時間可以大寫字母 Z 結尾, 或+0表示. 其他時區則以當地時間加時差表示. 例: 2016-06-21T16:42:51+0800.

ISO 在計算周數上有特別的規定. 以大寫字母W後加上 2 位數表示一年內的第幾周. 以 1 位數表示一周內的第幾天. 第一天為星期一, 星期日為最後一天. 中間以-連接. 而一年的第一周指的是一年中第一個 星期四 所在的那一周, 表示為 W01. 或說, 若一年的最後一天若不是在一周的前4天中, 下一年的前幾天要計入該年的最後一周. 而下一年的第一周由當年 1 月 4 日所在的那一周開始起算. 也就是說, 若一周中有不同年份, 該周則歸屬於在一周中佔的天數多的那一年.

正文:

在 linux 文字模式中工作時, 每當想知道時間就偶而會令人煩躁.
但如果你總是在視窗環境下作業, 對這個說法應會感到困惑. 畢竟, 滑鼠一點, 就有一堆精美的日曆或時鐘.

而在 linux 中要知道時間, 需要鍵入date. 例如,

> date
//但這時候, 他會回應出甚麼卻要看你的環境設定了. 他也可能是
//Tue Jun 21 16:42:51 CST 2016
// 或
//Tue Jun 21 08:42:51 UTC 2016
// 或
//二  6月 21 16:42:51 CST 2016

也就是在不同的主機上, 同樣鍵入date, 很有可能會得到完全不同日期時間格式的字串.

這在要比較時間時, 你必須腦補成一樣的格式. 這或許不是難事, 但很煩. 尤其在寫程式判斷時.

然而, 託 linux 的設計理念是隨心所欲的福. 幸好, 不管 date 或 ls 都允許定義輸出的日期時間格式. 所以, 我們只要這樣做就好了. 但另一個問題是, 要輸出甚麼樣子的格式? 既然要統一格式, 當然要選一個全世界所有人都不會誤解的. 這也不用我們煩惱, ISO 已經幫我們做完這件事了, 就是 ISO 8601.

首先是 date, 根據說明,

date [OPTION]... [+FORMAT]

只要在其後加上+號, 再給出格式, 即可. 但

  %%   文字的 %
  %a   本地化簡短的周名稱 (e.g., Sun)
  %A   本地化完整的周名稱 (e.g., Sunday)
  %b   本地化簡短的月份名稱 (e.g., Jan)
  %B   本地化完整的月份名稱 (e.g., January)
  %c   本地化日期和時間 (e.g., Thu Mar  3 23:05:25 2005)
  %C   世紀; 像 %Y, 省略最後兩位數 (e.g., 20)
  %d   月份中的日 (e.g., 01)
  %D   日期; 等效於 %m/%d/%y
  %e   月份中的日, 填充空白; 等效於 %_d
  %F   完整的日期; 等效於 %Y-%m-%d
  %g   以 ISO 周數為準的年份的最後兩位數,  (見 %G)
  %G   以 ISO 周數為準年份, (見 %V); 通常跟著 %V 使用
  %h   等效於 %b
  %H   時 (00..23)
  %I   時 (01..12)
  %j   day of year (001..366)
  %k   時, 填充空白 ( 0..23); 等效於 %_H
  %l   時, 填充空白 ( 1..12); 等效於 %_I
  %m   月份 (01..12)
  %M   分 (00..59)
  %n   換行
  %N   奈秒 (000000000..999999999)
  %p   等效的本地化 AM 或 PM; 未知則空白
  %P   像 %p, 但小寫
  %r   本地化 12-小時制 時鐘的時間 (e.g., 11:11:04 PM)
  %R   24-小時制的 時 和 分; 等效於 %H:%M
  %s   從 1970-01-01 00:00:00 UTC 的秒數
  %S   秒 (00..60)
  %t   跳格
  %T   時間; 等效於 %H:%M:%S
  %u   一周中的日數 (1..7); 1 是星期一
  %U   一年中中的周數, 以星期天為一周的第一天 (00..53)
  %V   ISO 的周數, 以星期一為一周的第一天 (01..53)
  %w   一周中的日數 (0..6); 0 是星期天
  %W   一年中中的周數, 星期一是一周的第一天 (00..53)
  %x   本地化的日期表示法 (e.g., 12/31/99)
  %X   本地化的時間表示法 (e.g., 23:13:48)
  %y   年份的最後兩位數 (00..99)
  %Y   年
  %z   以 +hhmm 數字化的時區 (e.g., -0400)
  %:z  以 +hh:mm 數字化的時區 (e.g., -04:00)
  %::z  以 +hh:mm:ss 數字化的時區 (e.g., -04:00:00)
  %:::z  以必要的精準度表示的數字化時區 (e.g., -04, +05:30)
  %Z   縮寫的文字化時區 (e.g., EDT)

可以使用的格式太多, 簡言之

> date +%Y-%m-%dT%H:%M:%S%z
// 或, 可用
> date -uIsec

-u 是使用 UTC 時間
-I 是使用 ISO 8601 格式, sec 是修飾 -I 指示時間要精準到秒

再來是常用的ls, 使用 --time-style 修飾 -l, 而格式可參考 date.

> ls -l --time-style=+%Y-%m-%dT%H:%M:%S%z

但這樣出現的是本地時間. 為了要讓位在世界各地的伺服器表示的時間基準都一樣. 而不用自己腦補時區的加減, 這必須將環境變數 TZ, 也就是 TIMEZONE 設成 utc. 當然, 每次下 ls 就要去改一次環境變數也太麻煩了. 合併指令如下,

> TZ=utc ls -l --time-style=+%Y-%m-%dT%H:%M:%S%z
// 2016-06-21T16:42:51+8000
// 如果, 不堅持要完全符合 ISO 8601, 則可簡化用
> ls --full-time
// 或, 可用
> ls -l --time-style=full-iso
// 2016-06-21 16:42:51.955353135 +8000

而每次要下 ls 就要打這麼多字, 也是很累. 將他設成指令別名吧.

> vi ~/.profile
// 修改 ~/.profile , 在最下面增加如下一行
alias ll='TZ=utc ls -l --time-style=+%Y-%m-%dT%H:%M:%S%z'

之後, 只要打 ll 即可.

對我而言, 在下 ls 時用標準的 ISO 格式, 會因為日期跟時間連在一起, 反而, 不容易看. 改用

alias ll='TZ=utc ls -l --time-style="+%Y-%m-%d %H:%M:%S %:::z"'
// 2016-06-21 08:42:51 +00
// 因為格式中有空白, 所以 --time-style 的參數值要用 `"` 括起來