一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。* c; R# U, i  w4 r' v
: e3 o! U! q' c! Z3 A$ m, [- D
    这听起来很棒，那它是如何工作的呢？
3 `' ~% }3 }% r; q; L; G5 y, p, F) c' o4 s; _; c/ \  K
    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。
6 `7 o# Y! G# c# w0 Y& c$ F$ Q
) _8 u% C9 ]( }: y+ u' r$ |    我同时也建立了一个基于浏览器的版本
$ x; a1 r9 W2 C2 O4 y2 U( F( P, k
    安装命令行工具) N; |. D% s) j6 H( M# ^8 B3 x
: N* C+ c9 G- X* D* t. ]1 A9 O
    在此之前请先安装Node.js, @3 T4 o" G  u- ?/ M* G

  \: _! Z9 t6 f/ v2 W  ^    然后在你的命令行中运行以下指令：+ h" |5 U1 g6 W+ t

* |' E0 Y0 q% ~! n+ i  _    npminstallblockchain-cli-g
  ^0 A+ m. q# B- v( ^9 R! Y% f
8 k, D' b, o+ w    blockchain- f+ g. J8 y5 e/ R0 I( A( d

: ^2 R. D. I$ x- ?0 H2 `: E. ]    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
! C6 j. v0 K/ m) o9 h  I, _9 R6 Z  u
    区块长什么样？$ w7 O3 \8 U+ l. D# e; D; R5 G
1 Q) n  w- G5 z1 U+ ~) g5 C* H
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
- _' i- ^. }# r7 ?1 f4 k6 _- J3 U" q, H7 x+ x" _
    Index：是哪一个区块（创世块的索引是0）/ ^' Y& Y5 G6 Z9 u1 w1 y8 i, g: _

: Y: y/ j/ b4 K$ e. O+ i    Hash：块是否有效？
$ `; T, l, N. X( p% B/ o+ W- {3 k. x! H
    PreviousHash：前一个区块是否有效？
( a8 f- J8 d4 b4 k/ }$ c$ v
  d' _& y" g: H    Timestamp：什么时候添加的区块？
! `) F( ?2 y1 X0 ?4 V; Z
" F# `9 z: l% x4 t, ~% _    Data：什么信息存储在区块上？6 |! h" U; \/ t& u8 N6 o, l
6 x7 l  {( R  K/ V) E2 e" x
    Nonce：在找到有效区块之前，我们进行了多少次迭代？- i1 r% B# l0 `/ K$ B. N
, G+ z& U; `! A) ]
    创世块; ^. w( y0 \3 s6 ~) H! o

1 L2 V9 \& i1 `3 e4 B& S* ]    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。
2 F& D: |/ u) ~" J
9 ^5 I0 p. M- O3 o, l    当一个新的区块被开采时会发生什么？% }* p+ C* j& |2 k

9 S% ?. s, n. R, `% G  X    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
% f$ q1 H) S' H- c
6 j! k9 M% [: x* V  y" o: L. j, z. W    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
7 x5 @7 {  P; a% V% X/ I, I1 b* v6 ^
& e% i- P+ S/ P; [- g; k- |  z    Index：0+1=1) y/ A* _$ \; P4 k. C# {

5 q  ]! \. `& |$ G! \3 X9 B    PreviousHash：0000018035a828da0…
: i- K' k+ w, I0 X0 i% N  C! g; m! ^: x
    Timestamp：区块被添加的时间
; n9 G* c9 M4 G. U
+ R! J# M& B4 ]7 b* d    Data：freeCodeCamp
9 T+ c$ i6 P6 G8 Y2 @, l
# x7 u; w! y; ]! M! N& s) ]! _    Hash：？？？
8 ?7 W# F  q' v# M! O* C; h; n5 e! g  O4 a
    Nonce：？？？3 c- G  W/ b+ m* i9 B
3 \; x: i2 p: b
    Hash是如何计算的？; u. \4 F  B- k3 {3 @: S
. g1 X0 O2 O: @6 W; W* ]1 Q
    哈希值是唯一标识数据的固定长度的数值。. f. N0 M5 W  B( H! [- a) S
7 }# O$ [: y4 P; T' b( `' V
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
6 b. `+ a% g1 v8 |  v, N2 U0 d3 d( X3 R, l, L
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)+ @% F- U/ W" o8 Z  N
; w* v8 R2 ^2 J5 f: u% M- x
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
$ X* b0 Z9 V+ K7 z3 d1 b: [6 d# `+ L& \
    你是否注意到区块Hash中的四个前导0？
" u0 ]! K# p& V6 K7 ]" p  B8 ~. ~3 u5 R4 F
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度1 O4 e( H1 c4 H! t- Y) g
5 |( Z2 j$ z0 e& g# S" l( L
    functionisValidHashDifficulty(hash,difficulty){3 n  L" Y* {1 }+ j

4 d& i- ?) h( T" @8 z* p    for(vari=0,b=hash.length;i=difficulty;5 X, ^3 x" ?( X( ^) d
2 K0 A$ _9 S% Y/ v- k
    }
6 F& p5 c8 g! J, I( h6 b* U6 D; |! `9 C8 b5 F( ?
    这也被称为工作证明系统
$ h6 M5 R8 t+ F5 N4 k" r
7 k0 u. @9 x4 c$ A3 f+ o; S5 P    Nonce是什么？
9 s+ h% m; W5 c7 N; n5 ]& d; x) H: Z, g+ f5 T4 ^% ~
    Nonce是用来查找一个有效Hash的次数。
4 h( x  R' V, |" a5 U8 d' p0 v5 P6 V/ H- V4 X  U# J8 l6 x4 ]8 L0 W4 L
    letnonce=0;0 N- ?  r2 ^" m! e8 t1 ^

- `! E2 N+ a( v. I+ M! `5 b5 G    lethash;
8 P$ U- f% K& T0 @  C: p3 D: b/ m4 a: L7 v
    letinput;
3 p1 I2 u2 [! n
% x% `  [5 N  N, s- G    while(!isValidHashDifficulty(hash)){+ C3 D/ }' r: i# m  t. a
* }; d  U; x+ Z: J! ^
    nonce=nonce+1;
3 `1 w- @' V, p' p+ s# o3 f
9 i* T/ ?" Q& P$ G. [4 E5 Q) s( P    input=index+previousHash+timestamp+data+nonce;( y# h9 r" N! U
0 A# b* g& {9 S5 c
    hash=CryptoJS.SHA256(input)9 u( ?' Y  |$ p; ~! b

9 L8 D2 `7 o' T- v0 B0 n' V    }: u5 D* W  V% y! G* S& i# c

- e: J) ]- C, T& ^    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。: ?/ E0 C( s. w: i7 ~2 E% p. h

  ]8 V$ I, e+ U9 q; ]6 B, Q$ A    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。
/ j; [5 Q3 G7 i
: h' a! x6 p" q* j" S' H# U    为什么这么重要？
; P+ n1 t. Y. G: H) W4 S1 a6 x1 L2 z/ l/ S
    这些机制非常重要，它们使区块链不可变。2 e8 `# l/ Y; ~% h# q7 q

4 K; x3 h9 J+ p: ~) ?2 i5 R    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？
( R: S; x3 b8 L* T" y, s. Z$ k) @( ]9 S7 [: ?7 g
    区块A上的数据改变了。
- [* |& \" O- k! r$ U& m' L( }+ V4 C3 C+ ~7 l) s
    区块A的hash改变了，因为数据被用来计算hash。+ ^* C. s: F( d" U. Y
9 \- K& S/ c! [& c2 h: m+ H' c
    区块A失效了，因为它的hash不再有4个前导0。
; E) z) D; O3 i! H2 s3 ^. `' d* @( Q
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。% E8 f# |% Z0 p: |* X' _

. y- C0 k8 F0 P; L    区块B失效了，因为它的hash不再有4个前导0。
" e( |7 }1 n. E! Q% y$ ]( T' R3 c; i- v( {) Z) }% o
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
0 P  F" c* n9 a7 J6 `" |# @( J
& j0 k2 r4 C0 y6 o0 T$ Z    区块C失效了，因为它的hash不再有4个前导0。7 {1 ~5 i5 i% J9 N3 o

; e( Z1 ?- b7 W3 m    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。9 X5 J/ c$ d9 c* E5 X
# J9 q5 C* F% R. g
    我希望这个教程能够对您有所帮助！; a- K7 }2 J$ z0 K6 m
3 T6 X" `$ N+ ?2 k1 V8 d- ^! B
    安装命令行工具0 g" ^9 i% [+ a2 S' o8 w
  `$ ?3 \3 _. F' Z7 w9 _0 M
    在此之前请先安装Node.js3 {. C( f1 @9 B; {* M
1 b4 \6 S  i, O4 @* {' L* B
    然后在你的命令行中运行以下指令：
) z0 l4 \- b- p- y+ E9 h/ l
+ z) m9 l: B; k$ g    npminstallblockchain-cli-g
2 r3 H" C* H# |3 I" ?" n, q0 c: d9 D- v
    blockchain
; s5 m4 S2 O" y7 v' A, p3 r" S
/ W; M) Y% I: a% m6 j" G8 ^    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。0 u! W  h% h5 z: P; Z4 e

6 _8 \  j" k8 t! ]4 M# b    区块长什么样？  z; h# A5 [& B+ S3 [, ~

9 i! n$ S1 ~9 l' }1 Q    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
, P1 N% L% W! `, u( e2 l
2 I+ V. v9 F" L/ d/ B& c    Index：是哪一个区块（创世块的索引是0）？
& Q. b( ^* O4 v! @" `1 s/ F& P% l" |/ i& ^! @
    Hash：块是否有效？; _1 l: H; G# n6 v1 O

6 U* W/ n9 S/ S' x' k9 s$ K( z% F    PreviousHash：前一个区块是否有效？
( u3 V+ W" U" x- K7 \0 O
2 O5 s0 M# H7 I9 b% q: N0 J% K    Timestamp：什么时候添加的区块？
, v4 T, A7 q( h9 D# Y
% }3 \" @* a; ~; h: d; f+ L    Data：什么信息存储在区块上？
4 P$ y! `; [* F; Q1 b& N0 W
7 T4 W; D4 x; \% f    Nonce：在找到有效区块之前，我们进行了多少次迭代？# @+ v# S! _. I

8 g7 I& X% ?9 E. O2 s    创世块
! e2 V4 m: ^% q* u- z7 i2 M! g, b. z- P# _8 ]
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。1 {- p8 p+ W; Z4 b, h

4 P8 K6 A4 D0 m7 o0 Q  u$ J4 V    当一个新的区块被开采时会发生什么？4 A4 W/ c2 h# O# U! N3 j! f
2 _7 x/ z0 k  g& u' y
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
. V8 U( y2 a# U- D" M( M6 O
" c$ \3 g! p( b: w    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
! Q: \9 Z  `; h" @/ n# m' Q* B0 e) D# u7 \
    Index：0+1=1
8 J( Y$ f- m5 q8 _# \  ~: J. ?  ?. ~8 R5 j4 D# U! t/ B
    PreviousHash：0000018035a828da0…
- [& N' E* Z7 ?% }- s
7 m6 _4 H/ U7 n, z' P    Timestamp：区块被添加的时间3 X/ v6 f8 |$ E

1 b$ X( |. J9 u% O$ P( j! U    Data：freeCodeCamp
) N) d& x, Y: h1 F5 f1 @/ R( Z4 F* m% G7 r# n# G8 w$ w0 |+ A6 o
    Hash：？？？
; e$ `& V% w" r0 l3 X
9 J5 D! e: L7 J# h; o! Y/ M: M    Nonce：？？？. J+ |. a  C2 e$ a1 B
8 H, X, q) a' X; e
    Hash是如何计算的？
$ N. P* {' u2 t9 `) z9 K) z& U& r' k/ T: l  `4 ]" e% h; V
    哈希值是唯一标识数据的固定长度的数值。  A6 i2 T) W7 m$ f
% t2 p  C! X5 v* @6 W: O0 a. s% S2 F
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。: Y3 _. x" E" h* u' }

- r& a1 O2 k8 x( @$ P) v5 K3 f( j$ }    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)# a! U, z- n4 \9 K$ b1 L8 J$ ~
7 Z+ J: q5 T7 U
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
  M1 e6 X& S5 X. b% O& S9 M$ x  ]+ Q! Q; L' x$ U5 t
    你是否注意到区块Hash中的四个前导0？% W/ C! L# t4 a5 m  T& F  k
# {4 B$ h) P% R
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
7 \% C3 R1 w, @  \6 V) w  m# h/ [8 ]9 E
    functionisValidHashDifficulty(hash,difficulty){/ n8 Z1 V+ K( [: d

1 }& Y  ^1 ?0 x+ N  y' m9 _    for(vari=0,b=hash.length;i=difficulty;* Y  a/ @9 v% l' t# b; p

/ p3 i* \, D! M$ R+ V& J    }
; L/ a. `5 ]' x. z
) q( Q' _$ H0 ]& v  }+ J    这也被称为工作证明系统
6 Z$ d$ I" r9 t3 _$ _8 A1 ?1 U8 Z, q" Z' Z$ u
    Nonce是什么？
- ]8 K9 }3 @" L; e+ k
  `. Y& x1 n+ C7 i    Nonce是用来查找一个有效Hash的次数。
" ]* i* N$ I) @; \% y$ z( w/ U; l( j4 m; H% q, E4 g: z( P
    letnonce=0;
& P: U: J7 j/ J2 o9 E
  l5 l& |* E; U; t+ [    lethash;
: I* j" A& a/ |& ?3 f# Z+ p/ F6 @( C/ X# E3 ?
    letinput;
1 c3 _; [! C% E% j
8 y$ v  r/ `( o+ H( k; L+ c+ N& B    while(!isValidHashDifficulty(hash)){9 G/ z0 T4 h) l, S* w( `
( ~; R2 q0 a5 u4 Z- b0 E
    nonce=nonce+1;3 g9 t# w9 z3 @7 U& n/ {2 I

  |' v: [$ Q4 \$ \    input=index+previousHash+timestamp+data+nonce;1 X/ O! e. F  N9 v6 ~

/ @0 h1 O) |; s4 \  ]. `    hash=CryptoJS.SHA256(input)
. h* Y! }: O% @  w5 p. [' D4 x6 ~: \) D( I$ u! P; ]: G
    }
; B4 @: P; ]" ~: g: g% c: `- l; g1 y6 k
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
8 k  {. ?3 C5 C0 a$ H; Y) c5 g0 Z
2 v, y( [: P! z% t$ ^    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。/ O6 G+ H$ T7 Q' ~7 J9 w/ p' A

3 X5 ]3 ^  Z5 W3 p$ H( N$ A. w% d    为什么这么重要？
9 a' Y# q4 I1 p1 _# }8 ~- t5 ?3 [1 T( n) K
    这些机制非常重要，它们使区块链不可变。  f+ I$ j$ u9 Q: z- D5 ^

5 {5 N4 m- F3 Y0 h2 l6 I7 Q* Y    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？3 ^" p- F. t8 D5 j/ p2 w5 J! s$ W% _
4 S; e- m# u% f
    区块A上的数据改变了。( b) |4 {- K1 ]( j& v8 n
9 b/ q0 @( K+ H5 a8 `# U% T. }
    区块A的hash改变了，因为数据被用来计算hash。
' \0 w0 Q: m- I. X6 H) P" c+ R- T# P) w% f9 M  C
    区块A失效了，因为它的hash不再有4个前导0。
* J4 a% ]7 U- i  _0 _) \  ~9 F. @) x( f/ I/ b5 J
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。
8 C# B1 [1 R& ]4 m( R  y& m8 W( q; B
& ?/ o5 q$ F' V( b5 [    区块B失效了，因为它的hash不再有4个前导0。
7 t: E7 m4 q1 A( ~/ r, i5 H4 o% F6 }3 `* q' G  F( N6 o: o2 F
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
8 W+ C5 u& [, w- c( F# m% F( b% S: G
    区块C失效了，因为它的hash不再有4个前导0。0 S. c) Y6 Q5 Q. ?% J- d7 v
2 n! o+ [6 q  I9 }: A5 U' x' x
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
/ {! j. c- V+ l