一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。
. D- n! u8 t0 [
" o+ s( {6 l0 i4 I/ |: @+ O    这听起来很棒，那它是如何工作的呢？
. z) D8 l" _5 @- x; b
% i! ~  a3 S( R4 i* L: Z    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。
' T# M: V9 v9 Z+ x! Q* \; M# A% X9 m7 c/ `; Q6 r# S
    我同时也建立了一个基于浏览器的版本3 P& V0 _* [4 }4 |0 @0 {

9 i" i1 v# B9 S. t4 G; i  c+ f* j    安装命令行工具
' L$ x6 ]0 }" x- l8 @- H, e5 q6 R/ G  [) g# V% A/ G! Y
    在此之前请先安装Node.js- d  f; l. u4 j7 D

1 Z) ~+ y) Q0 K) v1 D5 A    然后在你的命令行中运行以下指令：
- n( J( h: J$ o5 A
8 l7 N1 }  Q; w    npminstallblockchain-cli-g# p7 V) ?# s3 X" S; [

  e1 G4 A" e" M) c2 R4 p/ W4 G    blockchain7 W1 F- b. h+ \' m. T
# @6 T8 A9 M( P  i
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。% n4 c0 S! Y" G6 b3 r
; M! V9 n6 n- p
    区块长什么样？
$ E- L8 D- O* ?8 W# F7 f0 z- m' {  {8 q1 V
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。8 ~8 v/ Z5 G& j; s4 [

0 ~5 B, R5 ^9 {* C7 B    Index：是哪一个区块（创世块的索引是0）
! P6 p/ V7 C/ {
7 F2 W: B# v' s7 R4 z6 P4 d    Hash：块是否有效？; D0 U6 Y0 M( C* t% A1 f+ @: l5 Z; K

1 Y# Y) k! a  m+ B/ i( X    PreviousHash：前一个区块是否有效？
5 l, w! U2 U: \# e, |5 h8 l0 l
" v4 P! q. _9 n/ q3 W0 i    Timestamp：什么时候添加的区块？6 ^, x9 C; l: r: ^5 g
0 t7 O9 E3 p. w
    Data：什么信息存储在区块上？
+ P7 t$ y) c- R
- y) X4 u( O$ [" |* f, ^3 b/ o9 c    Nonce：在找到有效区块之前，我们进行了多少次迭代？
. d) V+ u; w4 m" Z5 x- s. w  F; C+ Y5 Z  R3 N& o8 \1 G  m
    创世块
/ Y+ c) P  W1 p7 w" ^: \
. b- e6 V& o7 Z  ~; D    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。  A) a" `( N, e/ Y: V, M  x

2 f& w. Z! I% s; i8 L    当一个新的区块被开采时会发生什么？# y- }( k- Y; x
: g5 P; V9 ^  A% n' n2 @2 G2 G( p9 C
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
$ _% x9 y0 c7 V
4 w4 `3 q; z' m    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。- R% g5 J/ J5 z0 ]
7 L  y, }* R, k0 d0 j
    Index：0+1=16 H( }6 N# a7 e! J( S

+ ?- m  [2 i  ?5 S3 f    PreviousHash：0000018035a828da0…& V" W  H5 I5 r9 Z( s7 L3 Y
1 _7 h5 X* G7 O* q7 T* H5 e! {' ~+ L: M
    Timestamp：区块被添加的时间
4 K- M% ]* K0 b/ r
) ]1 f  V4 ~9 \2 T9 s    Data：freeCodeCamp
2 x9 T, w' T7 g' U  {4 _& _: ]% A/ ?- G- @& [: U% O/ p, C. S4 l; a
    Hash：？？？0 }/ m- Y( ~! k! D3 b7 e, }

. }/ r0 u5 v7 |$ p+ C0 o, k    Nonce：？？？
8 w' z. ~9 T$ @8 S! X6 h2 m7 K9 m+ X/ M/ {5 N( G
    Hash是如何计算的？" O* R" p& D7 C( P8 m0 S
: q# \2 r* l' @. v
    哈希值是唯一标识数据的固定长度的数值。2 r$ {5 G4 ?- {* g" a: ~

( ]0 M! C: n  N) j    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
! k! J  |, m: l3 j8 ^! f- j5 C/ v+ d6 k9 r) L. Y
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
: a; L  H/ g4 Y: F7 y
/ j) K2 N4 x# |/ W  O    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
; s5 n- ~* d3 n3 t! r' a
) l9 ?: u. `& W    你是否注意到区块Hash中的四个前导0？2 p9 H5 g$ D& \- f4 t9 B

* g. V4 |1 @* l) c    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
# |2 G+ ?6 D8 t4 ^0 E4 |& `9 V
    functionisValidHashDifficulty(hash,difficulty){% v5 _# r4 j- V( ?) [
( _: h" J' a, k
    for(vari=0,b=hash.length;i=difficulty;
$ U) K/ u7 a/ M$ R7 F9 o: q, v' J2 ?5 W2 N* g
    }
- H! i7 Y* c5 f) W
$ M; {9 _" z5 \2 n# p$ S    这也被称为工作证明系统
9 o% N8 w8 o* A  \6 }3 \
: g1 ~! d4 I7 V" J  a# S    Nonce是什么？2 K. P9 P2 T  C4 y# m" K

" e3 B1 Y: i: \5 f1 c1 ~" S4 G    Nonce是用来查找一个有效Hash的次数。
  x1 ~4 h) A9 T0 x! b4 d# z7 Z' r, u
) N& x) M/ h# m% g3 p% ]3 p    letnonce=0;1 x& [. Y0 ^9 K- ]' u* D
$ M' }* t% M: Q  O
    lethash;
4 L0 K% w4 V1 P; b+ ^  V! v0 e% ]$ K' {1 D. c/ E3 `8 B
    letinput;
3 ?- u' B/ q  Q1 q5 I; M: Q2 ~, K5 F; w3 d2 _4 d
    while(!isValidHashDifficulty(hash)){
6 N  a$ C% u3 p( e! Y$ i% i6 [, W8 l- r8 ~7 p& ~- d7 s* q
    nonce=nonce+1;5 Y+ S0 @. h4 t! a+ `, M- ^) u" Z
9 l, q! V* @* d, H4 `  I
    input=index+previousHash+timestamp+data+nonce;& p. Y# \3 ~; f3 U4 u( c4 ?& @

$ c* b5 y2 @% s0 O3 m" \8 Q    hash=CryptoJS.SHA256(input)
; B' y, ]% P) l! D8 ?
, h6 F3 {& X$ F9 A3 b    }( B+ `! }: w1 B+ W3 f9 y
) r0 S5 q! o1 x4 q
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
% n, `! R) ]3 j. i; K; q. p% d% Z+ K3 f
7 P8 ~; b6 ~8 A6 l3 c' k6 R    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。
8 E0 y$ j. c8 t3 u+ K3 O
+ _$ |: c) V* a- \" B    为什么这么重要？% s& ~+ V' p: U9 j1 g5 J+ \. o
5 N; y: \' U: g, A$ k$ b
    这些机制非常重要，它们使区块链不可变。
' N: D$ {* S4 R' h( B$ L/ j. f4 Q, `* W: u4 J
    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？( u4 [6 u% q* L# d: r
, K$ M  M- S2 Y2 R$ T  T
    区块A上的数据改变了。- Q% c5 [' y( R2 F' `4 M

* T5 F6 G  t" a" C# y    区块A的hash改变了，因为数据被用来计算hash。
( E+ Y6 \, W9 m8 D
! P# h  X- a6 I, O& k( h9 k    区块A失效了，因为它的hash不再有4个前导0。- o/ h- O- \! B: V
% g  V# Z5 C9 A# Z* t4 Q1 Q# h; R
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。
( x0 \, I0 P! V9 k6 b! E6 a% X3 F8 J2 z) _# S& L
    区块B失效了，因为它的hash不再有4个前导0。  d' D6 S9 L5 H5 `0 c5 L- P
+ k& d  r+ q8 @" {& R% H; ~
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。: o! C" G$ M. ?3 F0 W0 P' D
# e' J3 K3 u- }6 D' M& H! T
    区块C失效了，因为它的hash不再有4个前导0。
9 U! u: m; A2 e) `: ]5 f+ G# f% Q( B( s
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。) k6 j+ p3 m: n2 F2 L: p/ R
/ d  k) R. W+ [/ ?# s$ p" v
    我希望这个教程能够对您有所帮助！+ i: |+ `0 L0 L, Q

; ^) j- n" T, P, H  I- `) I5 J    安装命令行工具
( {, u6 D' a- C' y' k* e  m! q6 f( P. c* e1 B6 V4 H1 N
    在此之前请先安装Node.js9 V( U7 b/ P3 O$ b& x
4 {! A, X) }9 {% ^* b
    然后在你的命令行中运行以下指令：
  a! |3 r) P7 Y/ s- U) A7 r) `7 B# b8 o' H/ t
    npminstallblockchain-cli-g5 i: @& m; A4 H% j( m, [, O% O
4 J$ I  h' S: y) q$ u3 W3 e, f' Y
    blockchain
; r% a  R2 V9 t7 h& e- D% J( U3 [) m0 X7 \) F* `/ _
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
. n8 V" X7 w3 f5 B. b& H0 q
0 U, V- t* F/ B& W3 n0 K2 B    区块长什么样？
$ N, J2 r( ?7 q
  n" F6 J( W( x# ^  Y3 w8 W1 i$ W8 i, `    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。0 l2 |- M8 W/ ~1 g4 z

8 Q9 y/ A: C0 j7 R2 W3 ]8 b$ g    Index：是哪一个区块（创世块的索引是0）？. @. B! d, \5 F5 W  K

$ Q) I* N0 X) i! j; d0 f    Hash：块是否有效？1 w' t& ^9 k8 O5 G3 @( I( E
0 A  s1 ^# E5 ^/ p) j
    PreviousHash：前一个区块是否有效？0 E! T* K/ `- h9 ~# k$ M9 M/ r3 c4 \
! K. Z' K2 m+ S. i+ c$ E
    Timestamp：什么时候添加的区块？$ y' W" T$ z* c3 N2 @
: h& v3 G! r1 g* u
    Data：什么信息存储在区块上？" Q& M; L3 a; [' y

$ X6 v/ a+ f6 P( Y& D; Z    Nonce：在找到有效区块之前，我们进行了多少次迭代？
" {; Y  b. G. A8 y0 n6 @9 R* t& D
2 |. t% \0 P5 ~/ y2 c9 |8 P& V    创世块% b) y1 ?0 l) H3 f' w
( V' d3 f3 a. v( ^8 H! k* `
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。7 a; C4 ^4 V% z: x1 a3 T! e
. G1 h6 `3 q* ^4 r
    当一个新的区块被开采时会发生什么？) T/ Q- }* P5 Q

, g* I( b5 R% b+ l    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。- Y& v! I: W$ C/ O
: d, [$ s  G4 ]& ^' }
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。. |8 b! J, V8 |9 U

' o: l' i: V+ F  g& C6 f. ?    Index：0+1=1# `  t& K7 k; z. v, O0 U
) W  m( j$ B8 @9 t+ y) P( L1 P1 V
    PreviousHash：0000018035a828da0…
4 L7 Q& z% i) Y: f% q& p
2 M4 W8 U" O- o  k    Timestamp：区块被添加的时间6 o0 Q  {2 [; S4 Z6 `& Z- b# p
- U( p# p8 q$ w3 M' F/ Q
    Data：freeCodeCamp
4 _( R& V5 g8 G5 T+ `
: U. r$ V9 N2 q! E1 A    Hash：？？？
7 x1 i7 [5 H/ b# j& l; Q& w3 M& y4 H( L; g4 B2 w# x
    Nonce：？？？* I3 R+ o5 G7 r4 }! z# f& A
; Y9 \' `# I  r  d; C+ r1 g" a; i
    Hash是如何计算的？
  Y6 C! y# P% ^% G' A1 }9 [# `$ I! O4 S+ Z- [( M. K6 i" m
    哈希值是唯一标识数据的固定长度的数值。+ g/ B; y3 Q7 e( c: o

; K1 v* S2 }4 w. z+ U5 J    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。! {+ z9 l; T- N

; E" Y1 `9 Z; z. R  f    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)7 r" K: U2 v3 \" N6 C
5 A7 l2 i$ c  }) l6 q* o
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
5 S8 H" U( p3 _. I# t8 o- o7 a* N. L5 |2 w
    你是否注意到区块Hash中的四个前导0？
( e( o6 B$ O; t3 d
  u+ _! l0 {5 M1 M5 Z9 E    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度) J8 d$ J  y. p5 u" M

! r- I, l  P' ~  F& y) q    functionisValidHashDifficulty(hash,difficulty){
5 l/ r. \& D0 V- p& n" R0 _3 r0 n9 ~, N
    for(vari=0,b=hash.length;i=difficulty;$ V: O, U* y5 l

! [; [0 x/ k3 k% `& U$ B    }
! x% k, F1 b4 s/ Y/ g
# I  \" O7 G" Y6 f    这也被称为工作证明系统
9 n9 e+ j3 T$ S" ~) a# t: }& u! D2 ~: s2 q/ `& ?6 x! a
    Nonce是什么？
; F3 k, |# n, G6 T) }$ R' I( m+ K9 T- r
    Nonce是用来查找一个有效Hash的次数。  U5 U2 G7 M! Q# r9 b

# X9 S+ w( g; }8 A    letnonce=0;
/ p. G$ X5 M" C  @' `/ q
  Z% x7 R% u# j6 Q; w1 V    lethash;/ |" S# c- G4 W' z. f7 w1 x' ^
: p" Y7 C2 q' o
    letinput;
; V  L+ M& ^* u# y
* r% O$ I' R6 F- o# f7 w0 x    while(!isValidHashDifficulty(hash)){
- e. Z) v& ~7 @/ {2 y+ i9 D2 e' A  s$ r, m+ Z+ {1 o6 h. \
    nonce=nonce+1;5 H* T. j' K; }( J: ^# Y, Y# a1 P

% A& Q2 g, w) ~' R3 E; y    input=index+previousHash+timestamp+data+nonce;
; v. L* `( T8 z
: S2 Z) p+ i" Q- i& H& P    hash=CryptoJS.SHA256(input)
" f6 Y+ i5 E5 i7 Q# l7 L/ r% J/ U( t% o  Z
    }4 r# J) D: d# j6 @8 o
7 A" x+ g! ]  V( e( L. E
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
5 N# i7 j& W7 A( X
0 x4 V$ u3 [" ?" P, e& m    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。+ T8 D5 B6 P3 n* |& m7 k1 w
) A! \4 W5 `  f5 {1 X
    为什么这么重要？3 n+ n6 B9 c% I% R! e
* h4 r! F) }: _- r. u8 D$ m
    这些机制非常重要，它们使区块链不可变。
% Z' ~: [- m8 |* d: j: Z! O; P7 R4 h# g3 q
    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？8 y0 m" {1 S# i6 V/ k

3 L! b6 U' U7 m6 e" W- }    区块A上的数据改变了。8 E( F( R, F3 j- z8 w

0 J( I) L# l0 P0 s3 G    区块A的hash改变了，因为数据被用来计算hash。
4 `. {8 c- A8 _; a. \' W6 X& i
6 q' ?0 c* d# A- x2 {, |: w    区块A失效了，因为它的hash不再有4个前导0。- v0 _/ S! @: S3 g
, d% K* W" L7 u/ b1 j, |* j( }' h# w
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。
+ _  [$ b9 B+ q- n  B- _* v" x# t9 K4 z: Q: R8 e
    区块B失效了，因为它的hash不再有4个前导0。6 U2 b9 l) U& [" X/ q- J, O
+ S$ @1 U( @( {4 j6 `
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。$ O" N9 S* `# v
1 ]; C: o* |; Z; d; n0 [5 P$ N
    区块C失效了，因为它的hash不再有4个前导0。
+ u9 F$ y" }. s( g" a. }+ @- X; S* a+ e% e( |
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
& F8 f9 t: L& L1 c