碼上歡樂
相關內容    簡體    繁體

YAML文件簡介

本文轉載自   查看原文   2018-09-11 11:10   32691    Java/ C++/ JavaScript

編程免不了要寫配置文件，怎么寫配置也是一門學問。

YAML 是專門用來寫配置文件的語言，非常簡潔和強大，遠比 JSON 格式方便。

本文介紹 YAML 的語法，以 JS-YAML 的實現為例。你可以去在線 Demo 驗證下面的例子。

一、簡介

YAML 語言（發音 /ˈjæməl/ ）的設計目標，就是方便人類讀寫。它實質上是一種通用的數據串行化格式。

它的基本語法規則如下。

  • 大小寫敏感
  • 使用縮進表示層級關系
  • 縮進時不允許使用Tab鍵，只允許使用空格。
  • 縮進的空格數目不重要，只要相同層級的元素左側對齊即可

# 表示注釋，從這個字符一直到行尾，都會被解析器忽略。

YAML 支持的數據結構有三種。

  • 對象：鍵值對的集合，又稱為映射（mapping）/ 哈希（hashes） / 字典（dictionary）
  • 數組：一組按次序排列的值，又稱為序列（sequence） / 列表（list）
  • 純量（scalars）：單個的、不可再分的值

以下分別介紹這三種數據結構。

二、對象

對象的一組鍵值對，使用冒號結構表示。


animal: pets

轉為 JavaScript 如下。


{ animal: 'pets' }

Yaml 也允許另一種寫法，將所有鍵值對寫成一個行內對象。


hash: { name: Steve, foo: bar }

轉為 JavaScript 如下。


{ hash: { name: 'Steve', foo: 'bar' } }

三、數組

一組連詞線開頭的行，構成一個數組。


- Cat - Dog - Goldfish

轉為 JavaScript 如下。


[ 'Cat', 'Dog', 'Goldfish' ]

數據結構的子成員是一個數組，則可以在該項下面縮進一個空格。


- - Cat - Dog - Goldfish

轉為 JavaScript 如下。


[ [ 'Cat', 'Dog', 'Goldfish' ] ]

數組也可以采用行內表示法。


animal: [Cat, Dog]

轉為 JavaScript 如下。


{ animal: [ 'Cat', 'Dog' ] }

四、復合結構

對象和數組可以結合使用，形成復合結構。


languages: - Ruby - Perl - Python websites: YAML: yaml.org Ruby: ruby-lang.org Python: python.org Perl: use.perl.org

轉為 JavaScript 如下。


{ languages: [ 'Ruby', 'Perl', 'Python' ], websites: { YAML: 'yaml.org', Ruby: 'ruby-lang.org', Python: 'python.org', Perl: 'use.perl.org' } }

五、純量

純量是最基本的、不可再分的值。以下數據類型都屬於 JavaScript 的純量。

  • 字符串
  • 布爾值
  • 整數
  • 浮點數
  • Null
  • 時間
  • 日期

數值直接以字面量的形式表示。


number: 12.30

轉為 JavaScript 如下。


{ number: 12.30 }

布爾值用true和false表示。


isSet: true

轉為 JavaScript 如下。


{ isSet: true }

null用~表示。


parent: ~

轉為 JavaScript 如下。


{ parent: null }

時間采用 ISO8601 格式。


iso8601: 2001-12-14t21:59:43.10-05:00

轉為 JavaScript 如下。


{ iso8601: new Date('2001-12-14t21:59:43.10-05:00') }

日期采用復合 iso8601 格式的年、月、日表示。


date: 1976-07-31

轉為 JavaScript 如下。


{ date: new Date('1976-07-31') }

YAML 允許使用兩個感嘆號，強制轉換數據類型。


e: !!str 123 f: !!str true

轉為 JavaScript 如下。


{ e: '123', f: 'true' }

六、字符串

字符串是最常見，也是最復雜的一種數據類型。

字符串默認不使用引號表示。


str: 這是一行字符串

轉為 JavaScript 如下。


{ str: '這是一行字符串' }

如果字符串之中包含空格或特殊字符，需要放在引號之中。


str: '內容： 字符串'

轉為 JavaScript 如下。


{ str: '內容: 字符串' }

單引號和雙引號都可以使用，雙引號不會對特殊字符轉義。


s1: '內容\n字符串' s2: "內容\n字符串"

轉為 JavaScript 如下。


{ s1: '內容\\n字符串', s2: '內容\n字符串' }

單引號之中如果還有單引號，必須連續使用兩個單引號轉義。


str: 'labor''s day'

轉為 JavaScript 如下。


{ str: 'labor\'s day' }

字符串可以寫成多行，從第二行開始，必須有一個單空格縮進。換行符會被轉為空格。


str: 這是一段 多行 字符串

轉為 JavaScript 如下。


{ str: '這是一段 多行 字符串' }

多行字符串可以使用|保留換行符，也可以使用>折疊換行。


this: | Foo Bar that: > Foo Bar

轉為 JavaScript 代碼如下。


{ this: 'Foo\nBar\n', that: 'Foo Bar\n' }

+表示保留文字塊末尾的換行，-表示刪除字符串末尾的換行。


s1: | Foo s2: |+ Foo s3: |- Foo

轉為 JavaScript 代碼如下。


{ s1: 'Foo\n', s2: 'Foo\n\n\n', s3: 'Foo' }

字符串之中可以插入 HTML 標記。


message: | <p style="color: red"> 段落 </p>

轉為 JavaScript 如下。


{ message: '\n<p style="color: red">\n 段落\n</p>\n' }

七、引用

錨點&和別名*，可以用來引用。


defaults: &defaults adapter: postgres host: localhost development: database: myapp_development <<: *defaults test: database: myapp_test <<: *defaults

等同於下面的代碼。


defaults: adapter: postgres host: localhost development: database: myapp_development adapter: postgres host: localhost test: database: myapp_test adapter: postgres host: localhost

&用來建立錨點（defaults），<<表示合並到當前數據，*用來引用錨點。

下面是另一個例子。


- &showell Steve - Clark - Brian - Oren - *showell

轉為 JavaScript 代碼如下。


[ 'Steve', 'Clark', 'Brian', 'Oren', 'Steve' ]

八、函數和正則表達式的轉換

這是 JS-YAML 庫特有的功能，可以把函數和正則表達式轉為字符串。


# example.yml fn: function () { return 1 } reg: /test/

解析上面的 yml 文件的代碼如下。


var yaml = require('js-yaml'); var fs = require('fs'); try { var doc = yaml.load( fs.readFileSync('./example.yml', 'utf8') ); console.log(doc); } catch (e) { console.log(e); }

從 JavaScript 對象還原到 yaml 文件的代碼如下。


var yaml = require('js-yaml'); var fs = require('fs'); var obj = { fn: function () { return 1 }, reg: /test/ }; try { fs.writeFileSync( './example.yml', yaml.dump(obj), 'utf8' ); } catch (e) { console.log(e); }

九、參考鏈接

（完）

文檔信息

 作者： 阮一峰

 

 我們可能在spring配置文件里見到過.yml格式的東東，配置文件不都是.propertie或者.xml文件嗎？.yml是什么鬼，今天我帶你們來一探究竟。

 YAML（Yet Another Markup Language）（發音 /ˈjæməl/ ）
 一種基於Unicode容易閱讀，容易和腳本語言交互的，用來表達資料序列的編程語言。

 

適應場景

  1. 腳本語言：由於實現簡單，解析成本很低，YAML 特別適合在腳本語言中使用
  2. 序列化： YAML是由宿主語言數據類型直轉，的比較適合做序列化。
  3. 配置文件：寫 YAML 要比寫 XML 快得多(無需關注標簽或引號)，並且比 INI 文檔功能更強。由於兼容性問題，不同語言間的數據流轉建議不要用 YAML。

語言優點

  1. YAML易於人們閱讀。
  2. YAML數據在編程語言之間是可移植的。
  3. YAML匹配敏捷語言的本機數據結構。
  4. YAML具有一致的模型來支持通用工具。
  5. YAML支持單程處理。
  6. YAML具有表現力和可擴展性。
  7. YAML易於實現和使用。

YAML 語法

  1. 使用空格 Space 縮進表示分層，不同層次之間的縮進可以使用不同的空格數目，但是同層元素一定左對齊，即前面空格數目相同（不能使用 Tab，各個系統 Tab對應的 Space 數目可能不同，導致層次混亂）
  2. ‘#’表示注釋，只能單行注釋，從#開始處到行尾
  3. 破折號后面跟一個空格（a dash and space）表示列表
  4. 用冒號和空格表示鍵值對 key: value
  5. 簡單數據（scalars，標量數據）可以不使用引號括起來，包括字符串數據。用單引號或者雙引號括起來的被當作字符串數據，在單引號或雙引號中使用C風格的轉義字符

Sequence of Scalars  簡單數據列表

  1.  
    - Mark McGwire
  2.  
    - Sammy Sosa
  3.  
    - Ken Griffey

Mapping Scalars to Scalars 簡單數據鍵值對以及注釋

  1.  
    hr: 65 # Home runs
  2.  
    avg: 0.278 # Batting average
  3.  
    rbi: 147 # Runs Batted In

Mapping Scalars to Sequences 簡單數據列表鍵值對

  1.  
    american:
  2.  
    - Boston Red Sox
  3.  
    - Detroit Tigers
  4.  
    - New York Yankees
  5.  
    national:
  6.  
    - New York Mets
  7.  
    - Chicago Cubs
  8.  
    - Atlanta Braves

Sequence of Mappings 鍵值對列表 

  1.  
    -
  2.  
    name: Mark McGwire
  3.  
    hr: 65
  4.  
    avg: 0.278
  5.  
    -
  6.  
    name: Sammy Sosa
  7.  
    hr: 63
  8.  
    avg: 0.288

YAML 還支持流類型，用中括號括起來表示列表，用逗號分隔元素；用大括號括起來表示鍵值對，用逗號分隔元素。

Sequence of Sequences 列表的列表 

  1.  
    - [name , hr, avg ]
  2.  
    - [Mark McGwire, 65, 0.278]
  3.  
    - [Sammy Sosa , 63, 0.288]

 Mapping of Mappings  鍵值對的鍵值對

  1.  
    Mark McGwire: {hr: 65, avg: 0.278}
  2.  
    Sammy Sosa: {
  3.  
    hr: 63,
  4.  
    avg: 0.288
  5.  
    }

yaml 官方網站：http://www.yaml.org
yaml 官方文檔：http://www.yaml.org/spec/1.2/spec.html
 

YAML Ain't Markup Language

和GNU一樣，YAML是一個遞歸着說“不”的名字。不同的是，GNU對UNIX說不，YAML說不的對象是XML。

YAML不是XML。

YAML LOGO

為什么不是XML呢？因為：

  • YAML的可讀性好。
  • YAML和腳本語言的交互性好。
  • YAML使用實現語言的數據類型。
  • YAML有一個一致的信息模型。
  • YAML易於實現。

上面5條也就是XML不足的地方。同時，YAML也有XML的下列優點：

  • YAML可以基於流來處理；
  • YAML表達能力強，擴展性好。

總之，YAML試圖用一種比XML更敏捷的方式，來完成XML所完成的任務。

更多的內容及規范參見http://www.yaml.org。

語法

Structure通過空格來展示。Sequence里的項用"-"來代表，Map里的鍵值對用":"分隔.

這幾乎就是所有的語法了.

比如……

一般YAML文件擴展名為.yaml。比如：John.yaml

1
2
3
4
5
6
7
8
9
10
name: John Smith
age: 37
spouse:
     name: Jane Smith
     age: 25
children:
     -   name: Jimmy Smith
         age: 15
     -   name: Jenny Smith
         age 12

John今年37歲，有一個幸福的四口之家。兩個孩子Jimmy 和Jenny活潑可愛。妻子Jane年輕美貌。

如果深入研究的話還可能發現一些社會問題。

可見YAML的可讀性是不錯。

JYaml——YAML的Java實現

YAML已經有了不少實現,詳細的實現列表參見http://www.yaml.org/download.html。

其中JYaml（http://jyaml.sourceforge.net）是YAML的Java實現。

JYaml簡介

YAML使用實現語言的數據類型。我們看一下一些JYaml支持的Java數據類型：

  • 原始數據和封裝類（比如int，java.lang.Integer）
  • JavaBean兼容對象（Structure支持）
  • Collection （sequence支持）
    • List
    • Set
  • Map （map支持）
  • Arrays （sequence支持）
  • BigInteger 和BigDecimal
  • Date

我們給出John.yaml的java描述：

1
2
3
4
5
6
7
public class Person {
     private String name;
     private int age;
     private Person sponse;
     private Person[] children;
     // setXXX, getXXX方法略.
}

現在讓我們裝配一個Jone：

1
2
3
4
5
6
7
8
9
10
11
12
13
Person john = new Person();
john.setAge(37);
john.setName("John Smith");
Person sponse = new Person();
sponse.setName("Jane Smith");
sponse.setAge(25);
john.setSponse(sponse);
Person[] children = {new Person(), new Person()};
children[0].setName("Jimmy Smith");
children[0].setAge(15);
children[1].setName("Jenny Smith");
children[1].setAge(12);
john.setChildren(children);

使用JYaml把Jone“Dump”出來：

1
2
File dumpfile = new File("John_dump.yaml");
Yaml.dump(john, dumpfile);

下面我們看看John_dump.yaml是什么樣子：

1
2
3
4
5
6
7
8
9
10
11
12
13
--- !yaml.test.internal.Person
age: 37
children: !yaml.test.internal.Person[]
   - !yaml.test.internal.Person
     age: 15
     name: Jimmy Smith
   - !yaml.test.internal.Person
     age: 12
     name: Jenny Smith
name: John Smith
sponse: !yaml.test.internal.Person
   age: 25
   name: Jane Smith

其中!yaml.test.internal.Person是一些類型的信息。load的時候需要用。

現在用JYaml把Jone_dump.yaml load進來：

1
Person john2 = (Person) Yaml.loadType(dumpfile, Person.class);

還可以用下面的代碼dump出沒有類型信息的John.yaml：

1
Yaml.dump(john,dumpfile, true);

我們再來看看JYaml對流處理的支持。

為簡便起見，我們只是把同一個john寫10次：

1
2
3
4
5
6
7
YamlEncoder enc = new YamlEncoder(new FileOutputStream(dumpfile));
  for(int i=0; i<10; i++){
      john.setAge(37+i);
      enc.writeObject(john);
      enc.flush();
  }
enc.close();

下面再把這十個對象一個一個讀出來（注意while循環退出的方式）：

1
2
3
4
5
6
7
8
9
10
11
YamlDecoder dec = new YamlDecoder(new FileInputStream(dumpfile));
int age = 37;
while(true){
     try{
         john = (Person) dec.readObject();
         assertEquals(age, john.getAge());
         age++;
     }catch(EOFException eofe){
         break;
     }
}

JYaml對JDK14的支持

JYaml的源碼是基於JVM5的。也提供對JVM5功能的一些支持，比如對枚舉類型的支持。

JYaml的JVM14的支持是通過retrotranslator(http://retrotranslator.sourceforge.net）. retrotranslator使用ASM（http://asm.objectweb.org ）動態修改JVM5字節碼成JVM14，使JYaml在JVM14下可用。會犧牲一些效率。Debug時也會失真。

我修改了JYaml作者Toby Ho的一些源碼（基於Beta2.2），使之與JVM14兼容。當然，為此也去掉了對JVM5才有的類型的支持（比如枚舉類型）. 這個犧牲應該是值得的。需要的人可以來信索取。

YAML和SDO（只討論雙方的java實現）

如果讀者想了解更多SDO的概念， 請參見http://www.ibm.com/developerworks/library/specification/j-commonj-sdowmt/index.html 。這里我們只討論SDO的java實現。

SDO里有一個很重要的概念，DataObject。從DataObject的接口里，可以看出有兩類的數據類型，一類是JYaml支持的，諸如String, List之類，一類是DataObject。因此我們只需要增加一種支持DataObject的類型，就可以完成對SDO DataObject的支持。

不妨叫YamlDataObject。下面是它的數據結構。

1
2
3
4
5
public class YamlDataObject {
     private String uRI;
     private String name;
     private Map attributes;
}

YamlDataObject里用到的類型，都是JYaml能夠支持的。其中，uRI和name用來描述DataObject自身。attributes來描述DataObject里的值。這些值可能為DataObject，也可能是JYaml所支持的其他類型。我們希望用YamlDataObject來擔當DataObject的角色，因此YamlDataObject和DataObject要能互相轉化。增加兩個API：

1
2
private static YamlDataObject newInstance(DataObject dataobject){...
private DataObject toDataObject() {...

上面兩個之所以是private的，是因為我們打算遵照JYaml的習慣，增加兩個接口，dump和load，這樣newInstance和toDataObject只在內部使用了。下面是dump和load的定義：

1
2
3
4
public static void dump(DataObject dataobject, File dumpfile)
                   throws FileNotFoundException{...
public static Object load(File file)
                   throws FileNotFoundException{...

下面是一小段測試代碼：

1
2
3
4
5
6
7
8
9
10
// ... create dataobject ...
File bodump=new File("bodump.yaml");
YamlDataObject.dump(dataobject,bodump);
assertTrue(bodump.exists());
DataObject dataobject2 = (DataObject) YamlDataObject.load(bodump);
  // check result
assertNotNull(dataobject2);
for(int i=0; i<5; i++){
    assertEquals(dataobject.get(i),dataobject2.get(i));
}

具體的實現細節就不談了。讀者可以作為練習題，熟悉一下這兩個數據整合方案。

YAML和Ruby

Ruby和YAML的聯系，甚至比Java與XML的聯系還要緊密。Ruby把YAML用到了和數據相關的方方面面。配置文件的約定格式是YAML。同時YAML還是Ruby的文本序列化格式，就像XML是SDO的文本序列化格式一樣。

不誇張的說，YAML是Ruby中流動的血液。

那，Ruby為什么不選XML呢?

其一，XML對Ruby這樣的腳本語言而言，解析起來比較困難。效率肯定是會有問題。Ruby的XML解析沒有完全實現，走的是實用主義的路線，可能也緣於此。而YAML要輕快很多。

另外，XML使用自定義類型。就算解析出來，也不能直接用，還要再轉一次。而YAML不定義自己的類型，直接使用宿主語言本身類型，直截了當。

下面給一個Ruby YAML的簡介。

我們使用Ruby寫一個Person類：

1
2
3
4
5
6
7
8
9
class Person
   attr_accessor :name, :age, :sponse, :children
   def initialize(name, age, sponse=nil, children=nil)
     @name = name
     @age  = age
     @sponse = sponse
     @children = children
   end
end

把John裝配起來：

1
2
3
jane = Person.new("Jane Smith", 25)
children = [Person.new("Jimmy Smith", 15), Person.new("Jenny Smith", 12)]
john = Person.new("John Smith", 37, jane, children)

Dump出John到John.yaml：

1
2
3
File.open('John_ruby.yaml', 'w') do |os|
   YAML::dump(john, os)
end

我們看看Dump的結果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
--- !ruby/object:Person
age: 37
children:
- !ruby/object:Person
   age: 15
   children:
   name: Jimmy Smith
   sponse:
- !ruby/object:Person
   age: 12
   children:
   name: Jenny Smith
   sponse:
name: John Smith
sponse: !ruby/object:Person
   age: 25
   children:
   name: Jane Smith
   sponse:

仔細觀察會發現和JYaml Dump出來的還是有些區別的。

首先類型信息不一樣。這還好說，雖然Ruby load Java的不太可能，但Java加載Ruby的應該沒問題。

還有就是一些實現上細微的區別。比如Ruby::Yaml的"spone:"，JYaml認為是不合法的。還有children的不縮行。盡管Ruby::Yaml很流行，但JYaml認為這是Ruby的Bug。網上有相應的爭論。

不過在一個語言里使用還是沒問題的。下面是load John的代碼：

1
john2 = File.open('John.yaml') { |is|  YAML::load(is) }

YAML的Ruby實現出現的很早。但由於某些原因，YAML的Ruby實現是不嚴格的。隨着其他語言的YAML實現慢慢出現，這個問題日益明顯了。

畢竟每個實現語言的類型不一樣的，不同語言文化也不同。因此不同實現的YAML的交互是個問題。兼容性需要YAML規范來保證。而具體的實施還有很長的道路要走。

但YAML在單一語言中，YAML的應用是沒有問題的。

YAML在Ruby On Rails中經常用作配置文件。比如數據庫信息的配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
test:
   adapter: mysql
   database: weblog_test
   username: root
   password:
   host: localhost
 
production:
   adapter: mysql
   database: weblog_production
   username: root
   password:
   host: localhost

熟悉ROR的讀者應該能看出這是`config/database.yml'文件。

YAML的適用范圍

由於實現簡單，解析成本很低，YAML特別適合在腳本語言中使用。列一下現有的語言實現：Ruby，Java，Perl，Python，PHP，OCaml，JavaScript。除了Java，其他都是腳本語言.

YAML比較適合做序列化。因為它是宿主語言數據類型直轉的。

YAML做配置文件也不錯。比如Ruby on Rails的配置就選用的YAML。對ROR而言，這很自然，也很省事.

由於兼容性問題，不同語言間的數據流轉建議現在不要用YAML.

YAML存在的意義

無論多么完美的事物，都需要有對立面，有說“NO”的聲音。XML也不例外。當然，站在主流的對立面，需要勇氣和智慧。

YAML和XML不同，沒有自己的數據類型的定義，而是使用實現語言的數據類型。這一點，有可能是出奇制勝的地方，也可能是一個敗筆。如果兼容性保證的不好的話，YAML數據在不同語言間流轉會有問題。如果兼容性好的話，YAML就會成為不同語言間數據流通的橋梁。建議yaml.org設立兼容認證機制，每個語言的實現必須通過認證。

假如兼容性沒問題的話，YAML就太完美了。輕巧，敏捷，高效，簡便，通用。這才是理想中的數據模型。當然就現在而言，這還只是個理想。

 


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 .yaml 文件格式簡介 YAML文件格式簡介 .yaml 文件格式簡介 .yml文件格式（YAML/yaml源文件）總結簡介 【SpringBoot】SpringBoot配置文件及YAML簡介（三） YAML - 簡介 yaml簡介以及在python上的應用 jackson dataformat yaml簡介及使用 yaml文件解析詳解 python 操作yaml文件
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM