一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。$ U9 _3 {0 P  ?, p# }$ Y

1 `; V$ \/ `1 j+ r5 E    这听起来很棒，那它是如何工作的呢？( g( q5 H7 e# B
1 x% U+ m  s7 f- U0 ]
    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。$ n+ L+ [9 r5 E, Y8 |
5 q6 I* I9 ^) E- P0 D
    我同时也建立了一个基于浏览器的版本
/ e) a1 Z; e2 z& R2 F
& y4 a% S. M2 n1 u    安装命令行工具3 i+ n" j) Q9 p' v
" {/ H" C0 r/ L. ?! l4 `; _9 W
    在此之前请先安装Node.js6 Q4 i, d0 e4 m) [

1 n/ t" x' m; w, M: o7 k    然后在你的命令行中运行以下指令：7 O9 K% U' N) |* o1 t' f4 m! Z- L

- W2 \0 t; d$ ]7 Y3 S4 \    npminstallblockchain-cli-g
4 E' M6 k- R; \
' G( I1 F& A0 x& s; {$ m* ]    blockchain- d* p/ D4 e+ i5 a6 G  N4 z
7 U1 t2 q. H7 U8 v: p5 J/ y
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。/ o! s' T. Q3 B

  B- W6 t5 p& v! y    区块长什么样？3 P; z" X/ U) v8 a( f) m3 o
) [$ K! q. e- `4 J
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
. W( U+ w) o1 O" W, \5 p& }# h  V5 f" Z/ n6 \
    Index：是哪一个区块（创世块的索引是0）: X. v* k% }) u- E
4 Y1 a; a$ W: q7 Y; N- G5 E/ O
    Hash：块是否有效？" d, u' m5 ^0 X7 ^6 }
- [9 B* u* \, X4 n
    PreviousHash：前一个区块是否有效？4 I, |1 J4 M$ {* T) v6 z8 E" Y

% D5 a  |) l' H& ~" P    Timestamp：什么时候添加的区块？
! m( o- B7 l( A, T& m2 L$ |- r9 k! D: X- @& k8 W' w6 w5 V/ V
    Data：什么信息存储在区块上？3 o8 H7 D) w/ I7 T6 L
; Y7 p3 u" U# M- `# H
    Nonce：在找到有效区块之前，我们进行了多少次迭代？/ T9 I$ F1 p5 b! I! `3 O5 K

- C' Q( k3 z2 c. q/ |    创世块
( s: v0 {5 q, `" z( \' z. a
8 o4 ^2 C& P6 P, A8 Y- h    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。5 t" \% B' `0 V% u

& X- ^* [: j' ^: t    当一个新的区块被开采时会发生什么？
$ {5 l- R( H! _0 Y7 |7 H1 K! j  V3 F, I- ]  J4 Z1 }6 R
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。5 a- |% @, r! o) |# l0 m# w' a  t
6 T- _, y- k, p9 }. p
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。! x6 W. w' I( g, s8 t8 b: {" }

3 k: U8 w# Z7 Y0 l+ x+ g2 ~    Index：0+1=1' m# X. ^+ N. q2 R
# e2 T# Y; N" f3 R, L: }/ j
    PreviousHash：0000018035a828da0…
! o3 w, q; S- ?5 e4 p: K( R  s
2 {9 d- a* s  a: {/ F! J- }0 ^    Timestamp：区块被添加的时间
$ B  Y9 B1 j, f  G+ _/ Z8 v7 G4 I
    Data：freeCodeCamp& E" S# q: H; T! a% t; k0 ^

; T  x) P6 o4 g; D5 A+ c    Hash：？？？
$ P7 q0 I5 c+ T2 c9 C$ }+ v8 A5 ~% j' C- O" ~% P
    Nonce：？？？
6 v* @- F& R4 A  w" Y: b
$ _2 m8 O- p! F! H    Hash是如何计算的？( D7 Y* w0 Z* E$ S" |
7 n$ J$ T8 H# g. n
    哈希值是唯一标识数据的固定长度的数值。. t7 v" I  B+ Q
, i; _2 N; m! {; j' Y
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。; z8 D) N7 F# `1 c
* o; X) V6 K4 }5 G- a- M
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)+ ]1 L8 w; M9 T  \2 U- F  Y
. R. W7 Q. U8 Q7 w# G* C, o, f4 e) ?
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。9 W' l4 T- l( a+ E* ]

  V) ?& ^6 G: \. U    你是否注意到区块Hash中的四个前导0？+ ?8 }0 u4 }/ R/ K8 F* s& X

  o; q. F* f- Q8 |$ I    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
) i  s' p7 T6 |+ t7 g! R9 x( v
1 D1 R6 p! ]% }; {    functionisValidHashDifficulty(hash,difficulty){
9 ?) L& Q2 I) x7 s9 \1 @" V2 n0 Y$ v9 m! m; `; t
    for(vari=0,b=hash.length;i=difficulty;
- h/ s: ?5 I8 G" w6 P
$ l' R4 L' }9 h. [* l6 l; S    }
. B: x# ?* `) `# M+ _
& H3 H# e  J9 U9 z- l- z9 l) _    这也被称为工作证明系统
$ P) Q+ j# I9 g" S0 \8 c
. _! J' r; i; L2 h    Nonce是什么？; W$ g4 q: J6 Y+ i; i, ?7 e1 D
) ]( N" I* U* H9 y  @
    Nonce是用来查找一个有效Hash的次数。+ J" M0 W/ ]# D2 a6 Z! W3 E( b
+ b7 h( z& N3 s% Z! e, v
    letnonce=0;( i) I) U4 G# m8 ^( b
& Z5 L6 o' Y/ P5 u3 A9 F
    lethash;" K: T5 S( e0 s( c- r# B9 M
* x3 Z. Y/ X2 m. L" c
    letinput;; S, r6 z) Y) w
$ P2 l+ G, a# B5 n4 X
    while(!isValidHashDifficulty(hash)){+ D' t3 L6 U% c: K! ^

! f2 i/ A0 ^& D7 E( C% d' I8 D    nonce=nonce+1;
, h; Z3 S) n4 ^9 M6 D3 B
, Q- `$ `: w% G' H/ \2 U    input=index+previousHash+timestamp+data+nonce;
# S, J6 D5 b  S3 c2 H+ L5 F
% A8 A- H9 A) }  \$ s, o9 u& R- k; H    hash=CryptoJS.SHA256(input)3 _9 [! K9 q. W+ P
( s0 r/ Q! H/ N& W) b+ T5 ?
    }2 t+ x0 u' x; [- v: f4 o
! b. p1 D/ @: w
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。8 D: `- s. Q8 P2 Y4 K4 @" n

: c1 X. F$ n" [" q6 }/ i    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。8 u( M( ~) D* Y) v( Y. x. V& b4 Y
& Q" X  g3 m8 J4 P  \9 K( A8 |
    为什么这么重要？/ ?/ R% c. Q  H( t

! i* o$ H) P, p: `    这些机制非常重要，它们使区块链不可变。$ ~" z$ x' _( X" v

! T' }0 |7 H+ V    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？" L9 K9 }4 W+ o" t; R
: l% g0 a- x7 r, s) Z5 w
    区块A上的数据改变了。/ j7 H) O9 C8 ^4 v" O; k1 t

2 i" H. m  T+ |& q. u( E    区块A的hash改变了，因为数据被用来计算hash。
$ t2 Z( G' {) Z! |0 q2 O1 O* P" [
    区块A失效了，因为它的hash不再有4个前导0。+ c, T( C: {( `$ ~% f0 F

4 x# D) a# P1 b: I& y5 N- T8 t    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。* j9 L) @9 q" E7 _7 K# V. e! M1 ?+ T

# |4 a, j0 a( ?4 b$ s  F. i    区块B失效了，因为它的hash不再有4个前导0。3 a. `2 \  f' \- l
) O' j# i5 J% }( c8 U1 U# d
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
1 b) g' e% T; B
% ]3 [6 z, ]: L4 p8 l    区块C失效了，因为它的hash不再有4个前导0。% I5 g" @! l; C- v# ?4 U
* y& y1 Q$ B' v' W) _
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。9 Z/ K2 w+ m! n, z

7 `6 U' Q. s% Q0 G    我希望这个教程能够对您有所帮助！" k1 }- t. r/ ]' n3 Z/ {

2 u0 y5 F7 f, u% H3 m( t    安装命令行工具" {7 y& ?; M; `9 \2 {
  `2 \$ x0 n. k+ o& P6 j
    在此之前请先安装Node.js- ~) J6 @9 z: J8 w  T* H

' M* y: A$ a( t; I- T    然后在你的命令行中运行以下指令：
# m! ~; G2 y& L6 e* r+ {6 y9 r0 J4 P- g* ~+ x' r( y% |1 G
    npminstallblockchain-cli-g
0 {; J% p  M  z7 g9 V" G4 d; v. V! b% h
    blockchain
3 Q7 X0 I7 L/ n, W  K$ L! Z
8 E) |/ L: r" z8 E. Z* f8 c1 N    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。1 q' D5 f8 z! d* a
/ v+ k6 T" X8 ?: `" H8 g: S
    区块长什么样？
7 N  X0 P" y% K
3 \0 N8 q: g/ m7 A5 c- f9 b, o$ \    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。: K7 `/ M" z3 q8 F0 C

1 N; H- D2 C) h: `    Index：是哪一个区块（创世块的索引是0）？7 c5 ^" o7 d8 X. @) p
' F# g. O0 Z( s9 ~, F3 K
    Hash：块是否有效？$ J; Y/ {! u6 I' G$ i. {

0 R+ Q. o" y$ S) d2 W+ C    PreviousHash：前一个区块是否有效？  O4 B9 w; v! R& O6 `9 R( l- n4 A

* t+ c1 j& \6 ~  S: }! i2 U    Timestamp：什么时候添加的区块？
# @, c2 y8 r1 y1 u0 c( D6 |7 [0 t( B8 L0 c! Q  g* v2 ]! v
    Data：什么信息存储在区块上？2 Z' v) h! q; W$ j  x3 z( Q6 @

- w5 ~6 I( y4 g8 C8 B    Nonce：在找到有效区块之前，我们进行了多少次迭代？
" |7 A+ H! P$ ^4 u- z' L0 O& w7 m" P% k+ H* n
    创世块7 p3 M9 a6 ]# A' w: B8 n: |

. I% Q9 J) f* g* q, ]' j% Y" g2 B    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。6 l( j8 N5 o6 D, ?" Z% O
: e* @# t% I  x' x2 f
    当一个新的区块被开采时会发生什么？
9 y; H, I6 }- Q9 ?1 C3 l2 K8 z$ q! N$ A( ~. ]5 y. v
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
9 N" l0 E) ~  g# ]+ A. j- B' L) _6 }0 z0 O/ v% F" G! m
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。4 x2 B. o+ U4 b& {
5 G( p; ]. M- X. V: G6 D
    Index：0+1=1; g1 g9 g: C- p4 s
; k. \& j; r+ j2 _% w; p; |
    PreviousHash：0000018035a828da0…  K: @* M% _% a

4 Y0 Y6 F" h4 y& d    Timestamp：区块被添加的时间) e- X/ m1 V2 A% ?2 T# E
; f5 g* F- H" Y9 Z! h
    Data：freeCodeCamp
, z2 i4 M& x0 {
6 d2 |8 e- X' r: n* p3 Y    Hash：？？？
/ B+ U' X' y, }8 B7 H$ @" @- F- X# M( J
    Nonce：？？？
7 Y1 X3 ?3 P, J
) w# Q) z! V1 f+ o5 S' J: `5 d    Hash是如何计算的？- r2 {" _- `3 [% l# B

; ^" h7 J6 C& P9 h6 M    哈希值是唯一标识数据的固定长度的数值。3 g8 P+ {! n8 n2 z* |
$ M1 m: i/ N$ O7 g' ]" T
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。$ d- H9 P- a4 ~2 S, `6 z/ Q

/ w* q# N3 b, [' J  V    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)$ \/ ]# J0 l7 L9 o. y9 W

# E( O; s) E9 w( s/ F  y    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
4 p8 T2 P: M2 _% Q: A  N0 V; o; `3 r9 B% H8 P) U8 \: g1 m
    你是否注意到区块Hash中的四个前导0？! K: X( V5 k3 G( F& u
9 v1 J; l; Z) q7 b/ Y' _
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度/ z3 `  h4 k& H8 g
" a) R* f& C3 v+ ?
    functionisValidHashDifficulty(hash,difficulty){; q, `& i4 c. M! A3 ^
3 I. k1 g( ^. [9 [
    for(vari=0,b=hash.length;i=difficulty;7 ?# D  k& E! {3 V
  x, }+ p; z& j. f, U/ l$ B
    }7 N6 H5 G1 Z+ W! ^+ V) q' K/ w3 G' o

6 W+ W1 Y! l! |    这也被称为工作证明系统4 q7 K' ^2 [' S8 r; y

' a9 m9 u3 X6 b    Nonce是什么？% J7 a7 u! d) Q9 a. S
2 e" v( G' s% D1 \; w2 t' w
    Nonce是用来查找一个有效Hash的次数。# L  q) E- @" R# K( a
. |0 C) I2 l% d' l0 S$ }
    letnonce=0;
! _6 r) I# s1 u* p& _
% A7 W% I/ c0 E; a$ U    lethash;0 c, k0 U- H$ y5 a
$ i+ @0 w% z" C. \+ D0 ?- ]
    letinput;
4 ?' w8 p, }- j0 I0 l, u, B0 C' g0 \0 o, }6 p$ J, Y/ x# ]
    while(!isValidHashDifficulty(hash)){
+ C# v1 z1 N7 q# C& W$ f8 R- S4 w, u7 w4 V1 @4 _# z
    nonce=nonce+1;
) Z( E7 d$ t4 p3 f! Y3 V
) P# g+ O4 Z( k4 |+ _    input=index+previousHash+timestamp+data+nonce;2 \0 I9 _- M! `- `7 d
' {& k) K+ @! m: U7 F
    hash=CryptoJS.SHA256(input)& Y" j4 Z1 `9 C  A9 W# k7 P) z2 {  m
, z1 j6 A$ K8 D. i  t" f
    }& y; i! C: Y' n* j
5 P) K4 U' f$ t  c1 K8 G
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。3 c; n9 m  r' \8 w) Z" D" r9 g, C( m

9 y; d" m) I+ i7 ~7 p    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。
% k7 [  Z! r  p  F/ q& j0 L) U7 _7 s5 k1 q* D" |
    为什么这么重要？
7 d$ X; |& E7 d0 i7 D2 A) K
. ?1 V2 K$ `2 D    这些机制非常重要，它们使区块链不可变。& x- ?4 S: w; }

6 ^% F7 \. N4 ^* Y: W5 O; h+ `6 z5 I    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？6 H' z* T7 R+ f8 H9 I% D
- k$ ]+ i( C5 v2 P: y( O
    区块A上的数据改变了。0 G# x3 [5 K  l9 C1 D6 {1 L

$ j- Z1 b; G/ l1 Y    区块A的hash改变了，因为数据被用来计算hash。
4 e  q3 u# J* n8 S2 V% r8 W3 ?! L1 Y- K
    区块A失效了，因为它的hash不再有4个前导0。* i1 Y& o- R  ^8 A' |

" F" w5 D. ^9 Y5 |% F3 ~    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。2 l/ S8 c( f" n

6 J! ~& Z2 R( T0 V9 g) J- c6 Z    区块B失效了，因为它的hash不再有4个前导0。2 Q" {3 @* ~) l. W$ p) |8 k2 t

  l# C) t* B4 ?) I    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
& o0 N* d. N1 m' g; x# \. u  Q3 x
    区块C失效了，因为它的hash不再有4个前导0。8 z3 g. _+ F( L8 [9 P

4 l/ E% I$ W( k* ]9 a    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
; ~, V% q- e4 E) \4 L