一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。: h3 Q/ Y1 |" m4 V1 x3 |% d* W9 C8 E

3 i$ E" x0 `: u6 w0 C8 I    这听起来很棒，那它是如何工作的呢？
) X3 }, l9 b7 {/ M; |# u2 q4 |
$ l" ?5 ^: @. }' B/ U, e$ {    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。
8 x0 i' F" N9 c4 S8 ]& B
+ h$ U. h7 ~, u; `+ o# q    我同时也建立了一个基于浏览器的版本
' D" n* Z7 M" h% K- e$ _/ E# e
( U% h+ F* p- N6 V    安装命令行工具0 }8 H: P3 J8 i5 c

( x8 Y  ]- h7 D    在此之前请先安装Node.js1 J' j/ t7 |) d& B7 W
2 @9 y! g+ o$ v1 n& S
    然后在你的命令行中运行以下指令：
- x$ e. r2 o) A$ E% \2 A! h; U! Q# a
' {+ e# G" W5 c; O) X    npminstallblockchain-cli-g
/ L* ]* h8 F" ~, K9 V: O- ~2 ]  G2 Z7 j
    blockchain
' b% A( @3 U' A9 w0 A; p% K9 H. U) n; A  Q- x
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。) D  J  s# W7 }  |9 m' G1 w
$ |1 O: b, ~8 j  b+ t! @1 K
    区块长什么样？  I; a* T( z+ h; U

8 n4 |$ q. q6 z& O: z    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
5 c; J( o6 \8 x
0 d3 S' A( s4 E& L    Index：是哪一个区块（创世块的索引是0）
2 C2 V, O) V( P# n3 A) N' _8 P' i! {5 {5 ?0 z5 d  P
    Hash：块是否有效？$ K/ _; Z' b6 S4 S8 l/ p& u5 N# t# S

. R/ Z4 c! z2 x7 G" k; y" ]3 B    PreviousHash：前一个区块是否有效？
: c/ s- P- R% V+ N& D0 ?5 R8 W/ S
( @, V* t/ Z9 E% r+ [; j; }    Timestamp：什么时候添加的区块？. ~1 |7 e, }3 H% u7 r) Y

3 ?1 o4 D2 ^! e9 q( u    Data：什么信息存储在区块上？7 d2 ^/ A, g3 W$ d

0 G4 z7 Q& Q5 n5 V: ?$ |    Nonce：在找到有效区块之前，我们进行了多少次迭代？' B# ?# t( x! i. K  o) x6 f0 D

; B+ T" S3 n( E    创世块
; z4 {4 w  {1 }# h1 P, j* Z/ e
! I- X  a+ y: ]: ]9 B% e* B  O    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。# I8 f# R& O" g; V

% f) J4 u' o/ d( O    当一个新的区块被开采时会发生什么？
+ v7 N$ s- ^. c6 F
! H% J4 Z) e' X) c    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。4 k" N& T0 I( D2 h1 j( r

- E$ Y! _* e3 ?( r- X' I4 B# l    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
9 R4 E0 g2 \, Y+ X$ P8 o: R& L1 {/ h; u
    Index：0+1=1
1 s* s/ J: ~0 p% V3 u0 b( h' d: S* o: D
    PreviousHash：0000018035a828da0…
+ t( P4 H) X! M' C7 a8 [2 a) D) Y* p
    Timestamp：区块被添加的时间6 \+ O7 a  H( z4 _$ R6 Y3 U7 a, a

+ b( Q3 U) v7 V, r7 o    Data：freeCodeCamp
6 d9 ?# A  S  L3 w" x  t- e: n! l3 @+ q
    Hash：？？？
- m! c+ X5 L" [' v: m& I  e$ ?$ \% Z9 A* o, f  v
    Nonce：？？？
  t1 f* @" O7 [# r
- G8 Q9 g3 _) U2 X! }) e9 c5 Y    Hash是如何计算的？
" W# ~1 {5 c( H% k/ p
/ O' \( i3 x+ h; M    哈希值是唯一标识数据的固定长度的数值。$ L9 s9 D( \! \! U  y8 Y

+ V% N& E+ M# O5 y+ _    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
; a- z0 Z! E' Q& ~5 M4 s  a* {) x& s8 i0 a" A( C& Q: W6 L' o2 ^
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
: u7 F, I7 v/ I8 b
* h" A' k$ a. ]1 p6 j; X+ F) \    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
  Z, K7 j- R- ^9 W: Q1 O6 d7 T/ ^! `3 T& R+ N* T
    你是否注意到区块Hash中的四个前导0？
* U# S' q2 U, u6 c& U8 U0 W( `2 Y4 z, j3 }; l; s5 m
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度) X1 ~9 o. `& G2 b  i& o1 ^& E4 u
- \9 Q; A) y! I" O- {
    functionisValidHashDifficulty(hash,difficulty){
0 O2 c/ F7 S) {+ F2 s  x% ?# r, J2 H* g! C) T
    for(vari=0,b=hash.length;i=difficulty;
+ c7 s9 b1 g8 S! W! D4 J/ m, l& O( T: S8 `' e- F6 p
    }
) S: P% v% S1 v& J3 _5 @( S# x+ i; |; f9 C4 Y# f% W) o+ `
    这也被称为工作证明系统
4 c! |' [5 }( f4 \7 z" E) e
! q! ]# o. J: l% `" Q9 K4 \    Nonce是什么？9 `3 s6 w, q1 ^2 v% L

4 a8 J7 _7 E$ s$ ?$ K    Nonce是用来查找一个有效Hash的次数。
" @) U1 w3 r% U- S/ ]' f5 Y" X" M) }# I- o+ R( V5 ^* ?2 o
    letnonce=0;3 U7 |; T* I3 g/ L. c& c
) a2 W) T( j7 y' R: e" a
    lethash;1 e' t5 _; ~% S* ?
+ ?4 f* H; u) n3 ~  p2 R2 u* N
    letinput;. Y* Q) G  I9 L% h

8 ]6 w. m3 D( e& `5 _; u- E    while(!isValidHashDifficulty(hash)){' n; }( o1 |4 N- |4 P  ~! m" L' o

# A) U2 b5 x+ b6 |1 x! e    nonce=nonce+1;8 F7 W: J2 X9 x/ w
# x- B$ O* F) F6 t* N
    input=index+previousHash+timestamp+data+nonce;) I* h  F: f1 F' l; `$ I/ B
/ J* X6 Q) q' U6 y" x/ c
    hash=CryptoJS.SHA256(input)0 ~9 V- Y3 j; H. H! V2 d2 |2 N
2 e2 p$ r" r# E8 ~$ N
    }
9 p3 r# J- Q3 `% L+ A' Y0 l' M+ p" I1 R6 j- \$ z+ v
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
" X+ n! B: g& {3 _3 x4 f" i) p6 E5 J# G' p) T/ y
    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。$ I$ a- @# L$ q
* S5 m9 g+ K" D: F* g% @; N
    为什么这么重要？2 d; m0 S0 o6 f% N
4 s5 p  f; ]7 a8 s9 J. i
    这些机制非常重要，它们使区块链不可变。
) l3 ^: n/ S; H1 \
, }; I9 N9 v+ b" E    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？  {9 m4 a; q& s* K
& @7 [6 h0 z' }9 W7 j
    区块A上的数据改变了。
& G) I7 n0 ^, {# b: o; ^3 f  u/ t; V2 w) ?( d
    区块A的hash改变了，因为数据被用来计算hash。
( }! y8 S( v6 L9 [$ R5 b
9 {6 v; B; _; l4 f$ L    区块A失效了，因为它的hash不再有4个前导0。) w3 O: L0 s4 }% b7 d: Y: w
5 U! }0 z; t0 s, ]8 F
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。; T' {7 d/ a; \% f7 H9 z& Y

0 p1 u* k; Y! T2 c    区块B失效了，因为它的hash不再有4个前导0。3 W' d) b* \9 h2 `
# Q: M$ y9 W; l! T' `; p
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
! ^3 ?: t3 h& R, C+ O5 E
/ |9 ^1 X/ {! L* |1 v    区块C失效了，因为它的hash不再有4个前导0。
9 u4 a5 v! z0 r$ a% n
- p+ r5 W4 Y$ G+ r; a    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。' Y3 W4 ]2 n9 |8 @6 i
- a. ]# x; Z, f& z! |9 g  D. X( J0 c
    我希望这个教程能够对您有所帮助！
$ m. Q' H3 K7 A0 ?7 u2 p% I7 O
# l/ {9 S3 k; T% F! ]: D    安装命令行工具# {0 K1 P  L- ]% g- d4 u
. e: o( ]5 P) _& d
    在此之前请先安装Node.js
3 l/ H* P7 {2 a6 t; Z% X# C6 U/ ?' j
    然后在你的命令行中运行以下指令：2 d8 z1 L- M1 v' w7 q$ v

, r* w+ B' {+ h8 t. @8 p/ c" J+ E    npminstallblockchain-cli-g/ [* X. ^: l: ?4 B  w
) a: V) f4 R) W8 v5 Q- g% B
    blockchain
5 g. M) U+ i9 Y5 y; t" Q3 o: N, L5 f0 X* v1 f3 c
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
" z  B5 p! t: H4 [" m- d' N4 }1 p9 R( P) E! O
    区块长什么样？0 E' S# u2 T1 M1 c

1 ?/ X. ]- E# q, S' j2 i    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。! j7 B: @+ y* w. n3 v
8 b" Q" C( `7 {8 m7 w
    Index：是哪一个区块（创世块的索引是0）？
) i) E' i, u: m' W
. M2 g; H5 T/ Y3 p( {" O0 i    Hash：块是否有效？
& P7 Z1 ?* ]% Q4 V4 n
1 d0 r8 W: l) Y) g+ M2 K9 F* d    PreviousHash：前一个区块是否有效？
: ]( o2 B7 K- Z! i% p1 k2 x
+ w0 g# d1 E& L3 F6 S9 c    Timestamp：什么时候添加的区块？0 `1 Z8 t9 j0 K0 w  B$ L& P
: N6 p; I' `. @( @
    Data：什么信息存储在区块上？' R0 t8 D0 t3 H" r( j
6 J9 g9 o: E* O3 q: v3 [
    Nonce：在找到有效区块之前，我们进行了多少次迭代？- G! f: }7 o* A9 {4 {8 z( N" D

3 X- P# I5 u% T7 _$ e$ H    创世块
- X( c* n! e" j/ B
" {! D1 P9 @+ R' d, ~' g    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。$ d8 L0 N! x7 V, W9 P

8 Z6 p% h! s- H+ d1 m    当一个新的区块被开采时会发生什么？- v) P. V: K) B4 U, X3 `
- U4 l4 x) e. F6 L$ r6 o: m0 ~
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
5 Y: @, E; ~$ Y. q
2 i9 Q' I; H. Q$ }; S, m% Q    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
  i. _$ b# s5 E& }0 \$ r! N9 Q
  Z( f, H; _% D5 S4 f6 N+ R    Index：0+1=1; ]6 w3 K. I( T% D/ q* x
, Y! a" s  I% }- C
    PreviousHash：0000018035a828da0…
& ]' c4 v% s' q4 o
$ T1 a" P, r" j4 s% I* `0 F0 E6 |    Timestamp：区块被添加的时间9 ~5 n/ a/ I( [: E  ?

) w' F' X# B+ v: E; C1 ~    Data：freeCodeCamp
4 ^8 o$ `# g5 t4 z: U1 N( f5 ~# k$ |, A' C' D
    Hash：？？？9 F1 Y' _# A2 ]
8 G3 G: Z3 _7 W: o# A
    Nonce：？？？+ Y1 z. A% q; p

0 k2 a' a* Y4 P* A0 ~    Hash是如何计算的？
, R7 |- ^( z: F, h& @; }) G8 ?0 z& Q
* q* e* W8 J% k  j    哈希值是唯一标识数据的固定长度的数值。! F: A( F. z3 s) @
( d$ q, D* q9 T' n" u' z' H
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。5 ~' n  E, Z( d1 F: e; }1 o. x

2 C* G' S" |: K) W    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)2 m6 }. r4 o- e( a( I2 }
- i1 |7 M% ~& J2 z4 d1 q
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
) l* v" v! a/ O5 A  @% G
. Q# O4 {  ~& i    你是否注意到区块Hash中的四个前导0？) K/ ^! G8 M- L  p5 T
. ^4 {* \* v" t0 [" b3 m
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
+ G% v' q( K! {6 y5 Y8 ?, G
2 b( }5 D. A! ~3 }    functionisValidHashDifficulty(hash,difficulty){
5 R& Q& _* T! N+ l. r: O+ f; W% ?% [. B. V- a7 M( ~
    for(vari=0,b=hash.length;i=difficulty;) P. m/ Z& y* H; ~6 S: P/ U" p, p
" u( T5 p6 K1 v" Z
    }4 D& l) q* b3 V# j% o* _: J
8 U( @. z8 Z5 y% d2 }8 M
    这也被称为工作证明系统
1 `4 {0 j% K* K' N9 D& g0 t. h3 @' |# h
    Nonce是什么？4 ]- |; f, V- B" G0 I, q

( x) Q) o7 I4 E' z, }$ \5 x    Nonce是用来查找一个有效Hash的次数。- V4 `" o4 [6 ]  m/ w1 m

7 b0 I# c8 p# A* m$ R6 @/ O    letnonce=0;
' o3 {" a2 k: R$ Z% D3 p% v6 H: u/ A+ a
    lethash;8 H# }1 Q7 F: \) N5 O4 a9 z

; |( B) K( ~- ^" Q* m4 Z    letinput;  Y# D9 |! w9 S; i' @7 h( F6 s. x3 N
2 E- f; Q6 n- \7 R
    while(!isValidHashDifficulty(hash)){
8 K: {+ s! Q+ ^- M, d+ G7 U" H  y
    nonce=nonce+1;* R# i+ |5 [7 q, p1 Z- u, _
. q8 c" p* U7 {) _- V% R7 W' m) @
    input=index+previousHash+timestamp+data+nonce;  m1 a! v% t9 G5 p
7 g9 E$ }+ @( W4 T' \
    hash=CryptoJS.SHA256(input)& H5 i" c0 }" A8 S) B. [9 \9 z2 y
( O6 a- B# W5 A1 F& d
    }! m+ A% p2 M! P

# G/ S  r! A2 _# R    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
, c3 G  @1 g1 J, j  t. p( b- `+ k/ g2 x/ j
    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。. l, X% N! e3 z( O6 L% S+ h* I
% k5 I5 ~2 Y" p% P$ V
    为什么这么重要？. m6 }! E- S( ?8 w4 N+ T9 w- w. L8 r

0 \9 r% t* g' S/ }. P    这些机制非常重要，它们使区块链不可变。  B/ g1 J5 x: f5 H

% U" h5 b3 f9 A0 a5 e9 J    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？
: Z9 E$ q3 e- h& s
) ~" e& s, ?6 t3 \    区块A上的数据改变了。
; K) C* Y, s( P% N! d
8 M0 Y: u; \. V4 q0 p    区块A的hash改变了，因为数据被用来计算hash。1 g6 @0 L* ~" z/ n# E" W" }  a
5 `, O+ c6 j6 j) E9 U) G8 l3 S$ @; w
    区块A失效了，因为它的hash不再有4个前导0。
: c' s/ q& x6 `% S
* a8 H  l0 d( P+ k. d6 u4 b- ?    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。" W5 X( B9 ^* @
$ D2 [& ]# o5 p4 l* O& m
    区块B失效了，因为它的hash不再有4个前导0。
+ K8 |* W4 L  v7 O+ D/ X, D. C, E: ?4 q2 n, N0 X3 X" J7 A; R( \
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
% I' O, G  D4 T& L  Z# D$ S
  b+ H3 D& j' o5 z( N$ Y    区块C失效了，因为它的hash不再有4个前导0。
" M. P( V0 |* b, E
2 k- N3 K" c% ^0 A( B# B    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。& j7 G. s4 N2 n: d