一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。
' q9 @% _2 H6 L1 H4 J! q
# e+ Y' @9 c  f  ?    这听起来很棒，那它是如何工作的呢？
* h, t0 }) ]- S( X
" u. q% \: @& g5 Q) p    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。
: [, G& `: u7 Z  b  T% b5 p  w0 u$ O$ g8 m- H4 w
    我同时也建立了一个基于浏览器的版本  ]: }# n( {7 p+ h8 l8 w2 o

- |  X; _2 i1 W# ?% G: D    安装命令行工具
! L, T2 g3 F+ a. j! H! Y3 V& }; [- B: Z6 O$ V( L
    在此之前请先安装Node.js
& k5 Y4 W) a3 h) I" i* |4 A
# {* Y3 N! b: e! J* Q* Q4 ^    然后在你的命令行中运行以下指令：
9 I9 _/ a+ k7 t
. X/ x+ j5 k- `, n6 d0 q# m    npminstallblockchain-cli-g
7 ]3 k; r7 V0 l+ W
, ], p8 m$ W- P$ L( r    blockchain
  U# x% u8 S- V; i8 G7 b
9 V6 R( [/ \7 D; p" _8 @6 z    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
) _# e/ G" w3 h( J7 _% M. q; c# {
    区块长什么样？
3 t4 {7 j$ @1 U. F6 ]6 q1 U8 b
9 o+ x$ p4 g6 g% ]5 m    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
% p# i4 d' H! D# x2 j' O' U; g: |- \2 O, E
    Index：是哪一个区块（创世块的索引是0）
: e, H2 {' _7 D
" j" ~/ e( T! Y7 L    Hash：块是否有效？
8 d& R9 w% T% W* X, K
* g7 k3 e: Q* h  O4 g4 W. z    PreviousHash：前一个区块是否有效？
. x2 i, h7 h, s" C/ t1 M5 N7 ~1 e  B; S, t2 a
    Timestamp：什么时候添加的区块？
) i/ S/ X+ I% m7 u, s( z+ B/ z2 n7 a
    Data：什么信息存储在区块上？
# W$ [0 J' ^+ M! y7 T* I/ ]
% }; y" j$ X" F" K; N, M# X    Nonce：在找到有效区块之前，我们进行了多少次迭代？( z# _; y* s6 ?5 ^/ Y

/ ]9 L" {% O# @    创世块
% y9 r9 N  S. p- `7 D/ P# n* B! ~; A( W  @/ E9 [
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。7 H4 Q' ]  Y! B4 b; S" ^

7 w1 \8 W1 @( Q    当一个新的区块被开采时会发生什么？
; X4 V1 Q0 b& N& F, ?3 }; w' V* c0 n$ m7 D
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
' \/ j. s- z! a
$ \' t/ j* v/ O  X4 N2 M8 H- N    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
. S2 e! p) @) r# P. q( i+ ~) U+ Y* E
    Index：0+1=1" G  J* M9 X! y3 ?+ Y- G
$ X, Q% j$ c. ~4 v
    PreviousHash：0000018035a828da0…
2 |, K7 a% u- P9 i3 B! j  H% S" U2 b" v4 _3 F) J$ s8 v
    Timestamp：区块被添加的时间
' d7 |+ ~" {! L% e: H+ J+ J' Y- _" N# a! y, p7 e0 X0 w! ~
    Data：freeCodeCamp: ^# w' A0 i0 F5 }! S
. A. P; G9 k1 ?
    Hash：？？？
* d0 q8 Z' e2 B9 g7 U8 K9 f
9 U2 A( b* h% `2 J3 _' E    Nonce：？？？
# N/ P: c) k( @; V# F. b9 Y, y; s1 ?$ o8 S1 Z
    Hash是如何计算的？
# j# {: A8 t* L& X; y" E
% A5 l2 D' `, o( n; @2 G  {& C+ N    哈希值是唯一标识数据的固定长度的数值。+ b/ i( c" d: k. y* C4 Z- S

5 z" u3 U$ W( Y2 p    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
$ U( K7 V& `' x1 \' z; }$ N
1 `4 x% u4 M! S  Z4 U2 J+ ]. t- P: |    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)% s1 k: ?: D& ^( k2 ^5 W0 ^

6 U1 C2 l, X& @. N  H0 l    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
$ K. S/ Q: x  A" ~  ]6 `
* o, h1 s! i+ o% x    你是否注意到区块Hash中的四个前导0？
+ E% j8 g( i7 b# U, |/ T' b5 V- p) N3 f' Y  `
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
5 K0 ~# {3 ~% s# H1 Q7 U5 m  S8 W2 m' d+ ^& \
    functionisValidHashDifficulty(hash,difficulty){
9 N% s& I! Q2 Z
( K9 e& v' Z4 W    for(vari=0,b=hash.length;i=difficulty;+ I7 Y0 w4 h( D; O3 Q" Y
+ H: u" j) V1 O7 S, ?5 g
    }0 l$ g/ B7 Q- T; w9 W

" P8 ^- l" N& {) \: T    这也被称为工作证明系统
1 [" G/ L- {' |: K6 P* u
5 O+ i/ g, E7 l( f+ b. P  D  w& G    Nonce是什么？
& P% r3 \# O! @) h, S# M4 n. T% f6 F5 z  v1 D
    Nonce是用来查找一个有效Hash的次数。$ a/ c) S) y' ]. I7 D
1 o! w3 I6 t# N. J4 E5 a4 L; E
    letnonce=0;
/ G% Y' j% h3 a( H5 u2 R
% h7 d; B- |/ _- [/ D( o    lethash;
3 v8 e! R" |5 l, y) ~
5 z1 ?0 U6 m5 t# p' d& s    letinput;
! E2 V6 U! P$ q( y, W( `
3 m* C, j' b' L: e    while(!isValidHashDifficulty(hash)){
# ~& T. c7 {- ]5 Q! L. c; m0 ]; G; E+ q
    nonce=nonce+1;
5 A. e5 ~0 [& R  D. G9 P) Z- ^; [0 }2 Z5 [  Q3 Z
    input=index+previousHash+timestamp+data+nonce;$ K, Q3 R0 e1 K3 m! }

% H! h$ l6 t& o% y2 K- R; v# a& C$ W. M    hash=CryptoJS.SHA256(input)2 P- @; }9 f2 Z. k/ H4 ~

% g; ~1 W! S) n$ v    }( e" ]1 ^4 p! C* y' z! L0 P$ J
( X3 V# W' S$ ~' g
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。, e4 g' s3 Q9 z5 s) V9 r% ?* T

( F# C) g- T; F! E  l$ s3 S4 s    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。3 _! \/ U% J) x5 a

' Z  z( S0 Z  {. Z- g    为什么这么重要？
! r5 u6 J$ ^: C. C1 L5 S
$ B' }; N8 q8 x/ d" Q. f' i+ @& a4 _2 \! `    这些机制非常重要，它们使区块链不可变。. z  t( O, q& e9 l( f
( D8 V; s% Q* ~8 X. j: u* O* O5 E
    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？
! L# O4 A9 |& \' H3 s+ k) a4 |& N& s
  @2 \0 ^$ P$ [    区块A上的数据改变了。
" `+ X* ?6 n& \' d+ o: m5 u" i
0 R# p( r! p3 a* M; N! V    区块A的hash改变了，因为数据被用来计算hash。
5 p* p5 T5 N- {& d4 X3 ], z- ?6 y7 Y. m+ G: [7 r
    区块A失效了，因为它的hash不再有4个前导0。
+ w1 I4 H6 `+ R  n( Z# w
2 m# ?3 V% r7 l3 ]# R2 e- u, |    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。% Y, F7 W1 O% Y1 D2 _5 E) M+ c
& M# E! m- h$ j& D$ P
    区块B失效了，因为它的hash不再有4个前导0。
) K" b0 C7 l: K) y8 L
1 L% [$ {/ @4 p( o2 x  ]+ D! K    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。- y1 T3 n! o+ ~! v- V" x
( t4 M6 Z/ ]! n. T  n- c
    区块C失效了，因为它的hash不再有4个前导0。* `2 c6 g( U2 `5 S4 a/ G
. X+ x# P$ i& I% {
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
; g5 p0 Q) A$ G* p+ i2 D  J; r% a# K# C2 T
    我希望这个教程能够对您有所帮助！7 K% ~$ D" F! k* `* }5 o0 [

4 c4 X% p" m# ?# _' t( b0 k    安装命令行工具
9 J6 C' M( T9 G3 g5 [! f7 `0 _3 d  f2 @& t- Z6 O
    在此之前请先安装Node.js" u+ @% L" v9 @2 ]: r8 E
2 D: L! n) i: R) p+ e2 [
    然后在你的命令行中运行以下指令：; I: V" u$ u* [' M2 Z# [7 H, r

2 H# ]6 V- }2 E) n" `: w6 b    npminstallblockchain-cli-g4 W9 z) u5 [0 E5 [& l5 G

" q* H& Q2 a$ k; f/ q- P" X    blockchain* c& m6 x' f2 N+ E
2 e( a7 n6 Y3 f7 Y
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。3 d) H8 N) y8 h6 `
, D+ t$ f% L) ?0 p
    区块长什么样？
# R5 {9 H+ `3 X! V7 G2 |+ k6 P. p7 E5 i3 D# U( n" U& e/ ?: @) w/ s$ ?
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
. K& [9 G. r9 \+ n9 H- ^8 ~  w/ [0 ~; l! P: C4 V. o* v
    Index：是哪一个区块（创世块的索引是0）？
+ m6 c$ O4 U' w. _$ ~7 Z" \, ?
# E. Z: R" V' P# L: f, P    Hash：块是否有效？
6 T7 k* @7 A( Q+ |5 k6 D- Q: k6 J7 N9 U5 s5 |4 H
    PreviousHash：前一个区块是否有效？6 E9 ~, V% G2 p# {5 ?
8 A; T/ ?- C) H3 c6 l) J2 h( d
    Timestamp：什么时候添加的区块？; a6 k3 {8 w: I9 m; O/ Z4 z

2 W6 B- l9 p* {0 e    Data：什么信息存储在区块上？
/ g; g0 W% o' j7 G& H! K' ~" }1 q. _5 F4 u( V3 V
    Nonce：在找到有效区块之前，我们进行了多少次迭代？
! Z# U! w8 k9 n4 @) q8 E2 ^1 h1 o0 @# {* b6 i: P
    创世块3 e6 G0 U4 d( u  o( p

% F5 [# L. w( H8 S$ g/ E* m    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。5 o$ z0 x( c2 V9 ?3 p
$ x% d! O8 c1 O2 y( U" k+ W0 n- t
    当一个新的区块被开采时会发生什么？$ b+ J/ M% F9 \- B7 c* W

/ O% U3 _$ l4 l( ~0 k3 Z2 F6 f    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
- {) m5 V8 K" t
  G8 C: ]' @6 ^4 n! A. E+ l    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。+ o6 S& H" C/ d* s( j/ k% m9 O
/ I9 C  i# r) n7 I
    Index：0+1=1
# f! B! q: s- z. N% [: |0 o8 W3 k5 Y
    PreviousHash：0000018035a828da0…' o! v1 y: ?4 o3 P, M/ t
' v3 O6 a3 k, J" h
    Timestamp：区块被添加的时间
4 R4 T+ @8 c& }" _% \! v' n
2 @: g5 o/ A, A5 {; u. c    Data：freeCodeCamp( \/ B2 N& U, P- n; f/ n  d

1 y  {- Y% y) ]" h$ ^  j    Hash：？？？
' q  [0 `: A: x) g6 v, p% @% O; M9 p$ U, W! t/ m; K3 h+ ]
    Nonce：？？？/ @4 _, |% ~/ B) o8 U( T* a

8 t3 a5 n, ]; i4 s0 m% k$ b6 ?    Hash是如何计算的？5 @7 v( |6 [" P5 `% P3 N

5 R7 M# ~: ?& P8 B/ ~& i. P    哈希值是唯一标识数据的固定长度的数值。
# I  V) b; V1 D
# n4 H* ]3 v; S    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。* q$ Q" W2 j, @' h& Z2 k, n

. p1 g$ M" b! n' P9 R' e  x. m    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)' M, e9 A% X3 z0 u

6 A. V. E+ J/ X/ d4 U- Y    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
+ P# H0 s* [# S: A. [! V( p6 t
# R0 i' E& w1 E1 L2 r    你是否注意到区块Hash中的四个前导0？
. q, k! b1 L7 T' B( l7 w( y9 W" l) ?7 T0 z6 t  x- X
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度0 i7 j$ D% {# ]4 Z  V
: r! K9 r/ t. V0 R) h  h
    functionisValidHashDifficulty(hash,difficulty){/ J- Z1 e( I$ {$ Q  B5 D; E8 I. c

5 l# Y1 s; n9 w2 K& b+ w* k( Q5 y    for(vari=0,b=hash.length;i=difficulty;
9 G5 u- J, W$ l) x* q' X- h8 a% F# P0 |: d) \
    }3 O. A1 m2 j) p
, l8 r  Z. Y7 H7 N
    这也被称为工作证明系统
, [: ]& G! J6 u/ b+ P1 q( _
4 M3 B4 R' H1 t' B    Nonce是什么？& M* g+ _$ h6 v7 K
. p! ]$ @/ U$ Z
    Nonce是用来查找一个有效Hash的次数。
; O: E" q: j, b$ R3 p3 I; k1 e! U$ _+ A( Q9 }
    letnonce=0;. C* X3 t& Z9 F( k* i

* X/ V# z# V5 F1 K) d7 h5 K    lethash;- l. }3 e5 k, L  _  U8 P
) a: Y3 p3 [( D: N/ n& X. B
    letinput;6 U, h" P" |9 R
# p" c5 q& P$ B  K$ ~* y5 |% w
    while(!isValidHashDifficulty(hash)){
. X' v  c+ P3 q( t! z9 M7 t9 d. ?. q7 y' W
    nonce=nonce+1;" H) H1 d- p1 }) v  q8 F4 b

# M6 o2 }+ X7 M9 a. k    input=index+previousHash+timestamp+data+nonce;
5 o) Z( M- e2 B5 {6 L
+ g) s- Y5 v+ c: W    hash=CryptoJS.SHA256(input)! e9 K/ P& b& b: I
: A7 U# B; N. @# p7 L
    }
  |" v- z5 `3 H/ r: _" `) L
" U. x: w' J) r    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
; @, c" X; u; h
# }' f& t+ B5 Q! i, H  |3 v9 L0 A7 X    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。; M. r" r/ w; T! g6 p
: e% g, O6 I' b+ I3 F( A
    为什么这么重要？% I; K. R8 L8 @! I8 @

" Y; ]; X8 r# e7 k; L3 s$ a- |1 `    这些机制非常重要，它们使区块链不可变。
$ A0 f6 H3 \5 i) Y/ S
" y9 `) I7 g- y    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？. e$ h. P( v3 _8 [$ k4 n
. L7 s+ F9 Q6 T+ W0 }2 N+ t( W, \
    区块A上的数据改变了。
3 Z  f2 k' G8 Z4 H! p8 m
2 J- F" Z* m8 H9 O    区块A的hash改变了，因为数据被用来计算hash。
# w! ?- x! V0 m6 @% B: a5 J- M' V- v" g, L: C
    区块A失效了，因为它的hash不再有4个前导0。
2 P- z+ |) W. ?3 m1 r8 \- @$ C& F) O; d, M" \; d- k, j& ]
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。
2 t8 a, ~( B$ X8 ?& o+ k1 ^. Y
* `1 }( G0 H' g% F    区块B失效了，因为它的hash不再有4个前导0。
* {0 S4 |) L  W( C9 X' L7 ?- y! e+ E% z& e$ {) a1 b" g9 \
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。, ~- I$ O. i5 f" h7 t2 L

; p- p/ I6 n1 `    区块C失效了，因为它的hash不再有4个前导0。4 b! q8 l/ g- E+ J# T  U

# ^: @7 F9 s* l* I  ]9 c    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。5 T% @/ `* B1 K5 Q$ A