一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。
! r4 [3 m* l; l- C& V! b3 L% z
  C: f. ~5 [, Q. f  b/ N    这听起来很棒，那它是如何工作的呢？
& Y) @& g! G) [& z9 R( V% q( e4 o% [5 s+ L
    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。
/ ^4 ?# g) I* Y& z1 j# B; ^1 }
, M* e# S( d6 h+ ~1 V5 q5 ?6 b8 r    我同时也建立了一个基于浏览器的版本; |. r& j% T# V! ~0 c+ {
' F# e& Q/ Q. |! ^0 K2 G, w3 g: G/ C
    安装命令行工具* T5 q+ ^6 J- ~7 X

& |( V. Z% ^. O# J    在此之前请先安装Node.js, k6 c; s. e2 K. z# u4 c7 q

% S# Y, _( q: P# {4 r) d( k9 J3 s    然后在你的命令行中运行以下指令：
# j+ K8 H& L5 i+ u1 q' i6 X" {# I1 M
. m: S, N. i5 ?& s) i  P    npminstallblockchain-cli-g
6 I, i: B) P6 x& }2 u$ S. i
8 J: Y& \. J8 R  T" [  Z! T    blockchain! t$ l8 f3 A1 o1 k/ P
1 k* g% d$ \  E7 `' H7 ^0 u
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。# N) j! _% V. Z

- k3 {- a7 ?; e$ E- l7 t    区块长什么样？' u, n, d- D& Y% K3 ~# G/ ]

1 x9 s" [. l% N. M6 O+ P2 y    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。% f& g% U( Z9 C

% z. t3 |$ c- K# E: y. j& c    Index：是哪一个区块（创世块的索引是0）
' T" D$ a9 E5 E2 P0 F$ @; R
5 U2 b2 f! `: ~6 h3 z, `    Hash：块是否有效？
7 D( e5 x$ b0 x6 c6 _" d  ]
5 ]( _# d9 W2 X/ ?  P2 a2 f    PreviousHash：前一个区块是否有效？0 d, E* E7 b; O* {# x" N

" @7 C# z" `( T7 y: O    Timestamp：什么时候添加的区块？7 z. f1 h, u2 W% G/ m7 ~+ D$ J
9 A- U, h+ i0 b
    Data：什么信息存储在区块上？0 v$ B% A$ q. g7 ^7 t* |: b

+ l& L; Q5 F+ h' X) q& D* Y0 J    Nonce：在找到有效区块之前，我们进行了多少次迭代？$ f' o% S( a! |1 T: c/ h- E. i
' C" T' G3 E: d, r9 W* [& P
    创世块5 a0 D, d3 j+ o
% ?4 J* p0 g  E1 w
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。
/ E4 X, u2 Y$ A1 g+ f2 c  h) Q6 x% r7 A7 x$ v1 Y
    当一个新的区块被开采时会发生什么？  b4 A8 O2 \4 u) h, y
  c" Y& }' r3 K4 O* b! f
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。7 P2 H* e7 L  F4 x

/ r$ C$ c. I  N) }  x    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
+ W% v4 M$ k! t4 H5 g$ F& v7 l: n3 P6 Z- T3 P2 x; f
    Index：0+1=19 ]1 [9 l' u9 N6 z  G
- n/ i2 p2 F' |. ]/ X4 B
    PreviousHash：0000018035a828da0…
0 Q% B$ F* u& g; d# C5 e3 f5 b0 Q' C9 o6 r' b# {
    Timestamp：区块被添加的时间
4 Q6 y! w" F3 S3 Z- U
- `! b4 K7 r" O' W6 c    Data：freeCodeCamp8 b# N7 F1 H9 |& K

0 d# ~0 [! Q) f% @    Hash：？？？
( m$ L9 }% f1 v( y7 V, S# L- x- K4 {
    Nonce：？？？
5 d4 S, T6 |* [- h) M) e1 u1 u$ e6 P- O: t  p; r- u7 S# f5 X
    Hash是如何计算的？
' a  Q1 w# B2 A6 U) p" Z
% g7 o0 A: N) g9 y2 H    哈希值是唯一标识数据的固定长度的数值。
$ l& C2 H3 n( X& \1 \: h
& r$ g* Z' Z$ b8 z- }: g    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。# {2 G1 ~9 x  W4 A- Z0 ~

- R. G" x# a0 `- x- M6 g    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)4 s  c9 B3 _' g- h2 K' M

( W! J' k, G9 k  F    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
; H0 M7 l9 ^- z2 \8 L  I! M3 d
8 \; l# X. p# m6 c+ u% G# a6 t    你是否注意到区块Hash中的四个前导0？# @. a# D5 k; S3 ?! {, u
3 N  @. o$ _% M0 N
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度) L5 E; C8 U" e/ a0 F  N

% \" J" @3 r3 d, a, A; [' U; D    functionisValidHashDifficulty(hash,difficulty){( t9 z2 a8 X" r5 C
! ~5 @! |- `$ V! |
    for(vari=0,b=hash.length;i=difficulty;
$ ]5 W* [* Z) r6 i% k1 |9 M- A
+ r5 O1 S( M+ w* |4 x) Q    }
2 p7 ?1 X( p, H( j
! w+ A6 l3 e. C% c3 e9 G    这也被称为工作证明系统
* L' Z: X& j4 k" I3 a- P( O7 U& ~
    Nonce是什么？
# s& V2 D# B8 W, g: F2 B& P, S0 o% w$ n/ O  E  P7 g
    Nonce是用来查找一个有效Hash的次数。3 m6 o4 I+ q9 B$ O6 U4 v" Y
! g- b) ?- `0 U# b6 P
    letnonce=0;
$ i, A7 s% J) f5 ]5 T  V/ Z: X  c: `: c# W# q" V  g4 h$ i
    lethash;/ e3 `5 L, i. {. Z1 a" E; {$ y# L) ]2 M
( r5 v, ]: ?4 c- W( g
    letinput;
2 ]8 S" U7 s8 q& x
6 {6 X  I. x& l1 v( A$ A" L, `    while(!isValidHashDifficulty(hash)){
! i; }. Q* {0 m% s% a
6 T. O, [2 [( r3 S+ Z- }& Y    nonce=nonce+1;
" m5 |2 l. Z% t/ i2 Z
! t; S9 y' o9 L, ^$ F: v    input=index+previousHash+timestamp+data+nonce;
% E3 B) m3 C1 V. j3 M( z' Y7 }. m, v# B( V
    hash=CryptoJS.SHA256(input)
! S. W8 [5 Y( ~+ E) _: Q7 H2 ^/ S8 e( b! \' U
    }
" o/ ?: e; t  _+ o1 E
9 e# s- ]3 ~) u" p  g2 \) T    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。; ^8 d. U/ X) f: Q4 ]/ k

. ?0 Y1 w# M+ a    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。) x8 |1 F/ q' g, d' m
! V6 X# ?+ U* Q: Y5 f+ d4 j
    为什么这么重要？
/ Y: K0 n  X+ D8 B+ v0 Q
) w* k& w- U1 ~9 m4 T4 F    这些机制非常重要，它们使区块链不可变。" M0 {( H, q2 ~' j

4 E6 R! l4 d$ m    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？! _0 E3 F/ @! @" Z7 h. M; T

+ ?; x; i' e7 B' k" u$ \    区块A上的数据改变了。( |  s8 X! S6 A- L% l
; Z; ^3 S4 p( a7 D, g
    区块A的hash改变了，因为数据被用来计算hash。
. Q2 X4 t: P" Z" M9 n
; S0 R, t# I! u2 c; Y8 o    区块A失效了，因为它的hash不再有4个前导0。
; z7 n" m/ r# T  I- `. v  U5 J; h3 U% N" k+ d1 B: r
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。  l' t9 H% U; X# U% F2 Z
2 z  F, n6 i7 w2 W. ~
    区块B失效了，因为它的hash不再有4个前导0。
9 m) O4 L% F4 g0 J/ B
1 C5 z, r. K: S8 p+ F. x3 e    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。! G: V( m; o5 H  ?" d( W/ }

/ Q' p0 L3 e* Q2 _% C9 s- Y    区块C失效了，因为它的hash不再有4个前导0。' I6 J5 n$ ^3 F; ~) G& [0 i
0 }. s" Z+ n8 a% u$ e* U3 |, c
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。% `0 x- ?% M% e/ w

9 A% D3 _( ~3 ?$ v    我希望这个教程能够对您有所帮助！; J2 f2 L: I6 t4 n% c. }  }
9 G8 t! a* U; |/ p6 G
    安装命令行工具
2 A/ S8 I% R  M4 k, m: }/ c) d! Y) J. p
    在此之前请先安装Node.js  ]+ P# }) ~4 L
; X4 b4 h* J- d, c1 i' ^+ D7 q, Q
    然后在你的命令行中运行以下指令：
& c$ j5 s5 C+ @. G
( c. n6 g9 W0 ~! z2 f% O    npminstallblockchain-cli-g
" Y/ V& F& B% }1 A3 Y3 a
. j5 l1 W1 B! U  A/ O5 V4 K    blockchain
$ T* }  l" e) k  t) k* M( L
6 s! u' [$ _4 J" U) r2 Y    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。8 W# a# A; X2 y
% `/ K# \1 k) k' J4 H
    区块长什么样？3 L3 i  Z  Z( f

3 R2 q& {; f( `* y    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。6 {8 j( e6 W* F$ n

( @1 Y( F# z" m: H1 q3 F/ P    Index：是哪一个区块（创世块的索引是0）？
! S) I4 ~2 \& q! ]1 J6 J. d2 b5 V1 P* N4 V. Y# ]& h& L
    Hash：块是否有效？3 |! _5 G9 x8 i  W8 ?/ N' M

: @5 R% e# ^8 S1 G! h    PreviousHash：前一个区块是否有效？5 R# N6 `# A! s9 ~$ I. H

$ |8 N; S6 D. y1 g& S0 m    Timestamp：什么时候添加的区块？& k0 Z- H" A! h1 S; s/ |
. U! y6 C/ E$ ^4 |
    Data：什么信息存储在区块上？" U- L2 f7 n/ Q* c

5 ~; d" o- d3 @3 l$ T- i    Nonce：在找到有效区块之前，我们进行了多少次迭代？
& z. m% N2 ]& J8 K& R  _6 R. t7 T* X; k4 W+ n
    创世块! G1 y! H8 |- o4 r5 j) H
* J' v  Z6 r: `( p7 N# \! r% V+ s
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。
+ o' a5 E" G9 h9 m. a! r) [5 Z/ a- `# c1 Z+ L6 g3 [
    当一个新的区块被开采时会发生什么？+ H' O# Q) ~4 p6 q$ g5 b& c

, p+ k' I  x1 d5 l7 S- N    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
9 j) q& N+ B, ?/ B" U9 I$ _9 b
; ^; {$ o. A7 p0 }& f    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
& h/ e" Q; K# s) t+ [# R( s0 d) W6 M: ], X/ K% t
    Index：0+1=1
7 g' E) u, \$ b; [1 G+ D! {0 L, m; @6 n* I  n% }1 ]" P
    PreviousHash：0000018035a828da0…, N# g3 F0 j* b
6 V, c& n6 o4 n2 u. o
    Timestamp：区块被添加的时间( L- W, Q, X/ c& V; H: Q1 p: u

3 W- L1 }$ Z2 A    Data：freeCodeCamp! H" _: _+ l; U. ^/ @2 J
3 |5 j' Q, b$ Q6 w# B3 M; x5 U
    Hash：？？？  S  L2 e  C2 y3 W

. x( f, m9 k! X, d6 O2 p    Nonce：？？？, a$ Z; t2 W% r* @% _9 O% x

  D5 J" A( q% h' O# J( I    Hash是如何计算的？* D8 n: O5 m& t4 q1 m& w) U- I
) y9 {# ]. J( Q( w$ b
    哈希值是唯一标识数据的固定长度的数值。
5 Y; Q7 J' h2 d* ]9 `7 z( Q: Z% A+ l9 \
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。  G( ~5 Z7 ^$ X, ~6 ]
+ ~" l' c- m; p& v6 O* f8 W. p
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)" L1 ]9 h3 p2 G& ~

9 W5 |/ [2 ^" ?$ c- z6 Z5 ]    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
- N% `& M4 ?7 X/ Z9 _5 E. O/ k. q* a" E, Y# `. e
    你是否注意到区块Hash中的四个前导0？" s+ c  @$ l" Q5 C; }: {" J9 Q  o* \
* O& G2 s3 F# y: d- P
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度3 U2 j( H8 F7 ]; Q# ~

2 |. G  h$ k. H8 V$ t# A  w    functionisValidHashDifficulty(hash,difficulty){
  e4 [8 `9 R7 J  H; L' q) L4 h6 [3 ]& X1 [, P' {
    for(vari=0,b=hash.length;i=difficulty;
3 g% U' H8 C! ~, j0 x
! ~- q, X6 N6 X9 E    }
; w4 C( ?6 }' B5 t: M( [# F
, Q( `: e& M( `! m) b, F    这也被称为工作证明系统
# [  ?3 r  ?3 Q: _4 z0 b
8 d  @0 C% P" `8 n/ K* b    Nonce是什么？: n1 z* t; |. [" M3 y

  ]) B& t7 h4 X& E7 q9 x    Nonce是用来查找一个有效Hash的次数。( ?; c: y' R/ J

- i8 U* N. {8 S  |: G2 b. x0 \    letnonce=0;2 x, C" S; I* E8 F: N: O
+ n/ j; m- h, h# g; w
    lethash;, A) ]% ^6 d9 ?' o9 O# h% m
3 z7 ]) X4 ~0 u9 `* ?. o# a" D
    letinput;
# S7 Z4 V2 X8 D( [! ]0 |- ~3 F
    while(!isValidHashDifficulty(hash)){& F; U# G: x! }* I- H# N, K3 J1 p1 {. w

5 N9 Z* d4 l9 o2 X    nonce=nonce+1;
; K0 C. h7 Q5 ]/ S  J% ^' q0 _* B7 z
    input=index+previousHash+timestamp+data+nonce;5 g* ~0 L7 R  n/ \; B1 l# i

9 f% }* X# ?; F8 l3 L    hash=CryptoJS.SHA256(input)9 o% Q0 f% b+ L
8 r2 u- |5 z2 h2 n
    }
$ w0 }4 e' L5 a- D& i$ c6 j- O
* X, Q3 e0 I; b* y7 x" E( T    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
: m- i! o7 y( O; g# M- T. K3 X- \0 s7 z8 p8 j' t6 F# K+ V& d
    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。! Y$ E' \, h. I5 u6 ]

4 h9 n% Y5 L! y    为什么这么重要？
+ I. R9 T6 ^3 r3 W( m. ~% l# E' Z! ?1 b$ i$ j
    这些机制非常重要，它们使区块链不可变。
3 D+ h  ]! j+ E/ z0 F7 e4 Z
4 f0 E. P8 p5 i! t/ P    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？  `* t- L( o2 A& x4 e# A

; N# f6 |7 Q. h  e$ w( n    区块A上的数据改变了。5 g' I5 b' K0 ^& Z9 m) E0 b

1 q4 n5 i# c8 k- A" n$ V    区块A的hash改变了，因为数据被用来计算hash。
; U3 t) L; K: [: c+ q; J: [; l
3 b3 R5 u4 j7 u& s; p$ B1 X    区块A失效了，因为它的hash不再有4个前导0。8 @* W6 C5 n1 O4 f9 I

! L3 h1 k/ I4 m2 x& h# H8 X6 o- q    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。. q9 _8 \) m( q3 c$ ~
3 o4 O) ~' A; ~2 ?) {1 m& o' L
    区块B失效了，因为它的hash不再有4个前导0。4 g' l" a' `: k" m3 ^, N5 @/ x6 e, c

3 n. A/ O0 }( [6 B6 N    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
+ x6 m; T, D& t* a' {4 q& F
  w# H1 }9 Y8 R/ |: B2 B    区块C失效了，因为它的hash不再有4个前导0。
7 }8 P2 M' u8 l( L$ n7 v
( [8 A6 |) m: b    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
: l6 q' ~4 t. X' ?! {