一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。/ w( g8 y/ F7 C6 i$ n

% m8 S. F/ a" P- \    这听起来很棒，那它是如何工作的呢？
2 n* r* h7 ?9 A  Y1 h6 O
/ Q9 d, N! {4 B; v; z    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。7 u; H- Y  r; A# B& {0 ]* G/ ]
! J& E5 g9 k3 M" l
    我同时也建立了一个基于浏览器的版本+ P0 u: m5 {* J7 Q
6 x* x' F& y5 v4 x! s, G
    安装命令行工具
  P  T2 L4 _" t1 y/ s: y6 b/ x: F( }4 M  v8 O
    在此之前请先安装Node.js
7 ?" Z3 s' F3 E8 @% ]- m: J" e& @( O& E4 o, f
    然后在你的命令行中运行以下指令：
8 ?5 X$ X/ h* I2 B0 |4 h
5 `2 N! s5 D' i' U  t    npminstallblockchain-cli-g
1 b- Y  A: h% w3 g
+ {2 N0 l! C# ]    blockchain
0 K1 K  I$ q+ _7 k# `5 x
, ^. @) c7 w0 F1 O  H    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
' s. r/ k! F. X& O1 c
" U# t9 K, c8 k& f7 u2 C6 F    区块长什么样？
$ S5 l- B. O6 j# I5 V6 s9 K4 f9 u' b8 j: y. c$ t9 @
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
: T% k* l' t* ]+ C
. s$ b  w- A% @! T* ^" `    Index：是哪一个区块（创世块的索引是0）$ _- w$ M% N  R4 K  T
0 s6 y4 ], k/ C0 L$ w7 r2 W2 Q
    Hash：块是否有效？# j* [. {6 n  b7 s4 Y) k& |

/ s9 x2 d# T* o    PreviousHash：前一个区块是否有效？
5 g. u  d3 ?: g0 \1 R
9 ?0 @1 o1 G( D6 Y/ J, S0 L1 B    Timestamp：什么时候添加的区块？6 b0 f* `8 \) d7 Z3 L+ B! }2 H
5 I; }9 c6 ?& i, ?
    Data：什么信息存储在区块上？
' v- G# P5 y6 q; s6 T& g; @2 ]
8 S& x8 t2 X6 l/ r) q2 k1 m$ a    Nonce：在找到有效区块之前，我们进行了多少次迭代？
7 I  }3 S1 @7 H0 K5 W* l- N$ ~' M3 N: p1 h* z4 Q  e7 G5 _6 X. ?% n
    创世块
  U; N( U% r# r6 f1 k1 K! e0 t* w) V# E* F0 J# \3 s2 j" X" H3 b
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。
$ v( ]( i) k) o3 L1 U4 K% d, |. r; t8 H
    当一个新的区块被开采时会发生什么？
1 h* Y9 }5 L* R5 Q* r$ B5 I7 R( P- y1 A7 H' @% \
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
3 C; I, e3 G6 H$ s( H+ `3 K1 ~# j  d. V& l' D( a: U
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。% q+ W, t; I; g
! t1 g/ h' b/ ?  w
    Index：0+1=1) Y4 G& ]) E  A: w' i0 C; U. z
) X; n( c0 S  u0 |6 x
    PreviousHash：0000018035a828da0…7 j4 a% _! h- U7 z
. k  v7 D* _3 r% s8 R' g& E+ S; [( u
    Timestamp：区块被添加的时间; u% ^4 O5 U5 R3 J: r) t' ?4 u3 t, P
5 p7 z7 t% w7 q. G
    Data：freeCodeCamp
, Q+ \7 N- q7 B1 [; r
9 ]  w( w9 {+ p% y$ {# Q. E    Hash：？？？
% [: ^9 V* g+ X4 d' f% P; t/ O  k
* e; T$ F- ^: p    Nonce：？？？8 j) J7 G+ ~) V2 U2 f) J6 e

, O; m3 ?% W5 P% J9 N) J9 @/ \    Hash是如何计算的？4 K6 Y0 Q3 f  h& G  ]

" L, T( m; S2 v& \    哈希值是唯一标识数据的固定长度的数值。5 l7 d& h$ G6 {! R5 o  g

* c) O- \% D$ P    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。, z- O& R+ e2 [2 R7 q0 \

1 k( J8 n# N3 Z    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce); H7 x& `$ _+ V$ k" N+ L7 B  T& J4 O
- C2 C% B' U) g# F! T
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。) W9 `$ Z6 L: w& ~# \6 j1 ^+ _
3 E' ~( D& r3 f8 M+ Y& f
    你是否注意到区块Hash中的四个前导0？
0 B' |3 I0 M# a, y
2 ^9 P% _2 {' m3 Q0 V" A; |    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
: T- N$ g3 r; x) ]! x
0 y$ T% e; o/ _& K7 Z. |. f    functionisValidHashDifficulty(hash,difficulty){
  E6 J6 J5 v! S8 ]3 y6 H3 o( n1 F! B5 I4 h9 }
    for(vari=0,b=hash.length;i=difficulty;" e5 R# g4 Y6 ^8 v0 g4 b: w, q+ C

% |3 Y9 s7 H$ n  ~- b0 M    }
( H2 h* |! ^* |4 U4 i) K# S/ l' l) O
    这也被称为工作证明系统1 o2 |* a, x3 B4 Y
2 Z0 G8 p' t2 L2 S7 a5 t/ F
    Nonce是什么？0 b7 n; o: ?4 g* l! v
: u0 Z/ P$ O+ U  G' J$ J
    Nonce是用来查找一个有效Hash的次数。
: v* \9 s4 H+ o' m, u% H" u
1 v, m) ^) r) h    letnonce=0;" ~0 H0 \( q, `+ k7 I4 |! w
+ Y5 _& r0 d- N5 ^# P
    lethash;4 r5 \5 Z$ b% }/ q

# C$ r2 G0 b: u    letinput;
+ x7 k6 c3 ^9 ^% U& G: W, `
. ]5 N  `3 P7 _3 V    while(!isValidHashDifficulty(hash)){
0 h) Q  o# v7 R2 S6 D, Z! I) P
+ T3 r1 D6 L) W! M" i; t    nonce=nonce+1;- g) K0 v3 m  D) m

& P% ]0 U: z$ `( _! T" d. l) }( P) v    input=index+previousHash+timestamp+data+nonce;- N  i' B4 Y/ [2 ^9 E4 W
- P  W5 ^' Y' O, e. Q- M
    hash=CryptoJS.SHA256(input)* w* m6 r) _" S7 A+ C/ f9 E$ H
  ?8 A8 O  h9 K
    }
6 W! N0 Y* w1 U. Z" y7 a3 g+ C, u7 o* l
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。0 B' Z' A( `5 A% G7 r7 e
" K: z0 w3 _8 \0 N  o4 g( z  Z
    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。# T. H- I' o' T1 ^: o! U
+ Q; K  @' J% O, J  |( P
    为什么这么重要？
% k. k# @/ C7 Q+ b
; s4 S( H" @( C4 k3 f    这些机制非常重要，它们使区块链不可变。
( Q) P; ~3 e% S' [' p+ {$ ~& P" x' B( V1 f
    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？- }" A3 H4 G6 `2 O' a6 B3 X& l! H

" F3 Q) [" {8 p# M" q0 a    区块A上的数据改变了。- o" ]9 i( g$ N. U9 x( ~' M- E3 M
3 s% |  M' a0 h+ g2 f
    区块A的hash改变了，因为数据被用来计算hash。
; n4 Q* {4 H  J* B# H) M: c3 d* R, V& Y  y: U8 @
    区块A失效了，因为它的hash不再有4个前导0。9 ~8 d& c- N4 t+ J* Y
9 W& y7 x  e) ^
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。& k: N8 Z8 [" o
1 y' t$ {% U2 j1 `
    区块B失效了，因为它的hash不再有4个前导0。' ]7 ?3 {0 u5 b  L0 G( r

' N' w0 Z, z4 G, M5 z* X- G# H1 u    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。& _) o9 o7 P8 A

1 w8 j9 Y- U7 {  G1 @0 r9 Q5 K    区块C失效了，因为它的hash不再有4个前导0。8 R9 J/ Y) Q6 b" E7 Z, k

, }8 m$ b7 |9 x2 \    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。- ?0 g0 D$ ]! w' d/ d

6 C- K6 o' J, T# m( z: e% T" i    我希望这个教程能够对您有所帮助！& T  l# }0 x; K

+ ?: S( `; i2 z* ^0 w    安装命令行工具; E. R& A3 K! Q! a8 g
- b4 q! w: ]! e4 I7 O' A. r
    在此之前请先安装Node.js
4 e: e! \+ b5 y3 |7 z2 X, b# B  c5 G7 r6 s3 a" n
    然后在你的命令行中运行以下指令：2 U+ T3 ^( j! ~* Y# l- A

' |) P( S& A; u: N2 h9 w+ `    npminstallblockchain-cli-g! q. k# L+ }9 Y' |

9 J7 u% N' L1 o    blockchain
2 Q; h7 ~6 g! Y1 m& I- d( R- }" k- H% a. ?+ d
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
8 ^% h$ c% M! V" u9 y$ d+ N% O) [5 t! Z1 L: v
    区块长什么样？. N8 V0 h9 o4 k; E. I' n& J

1 M# T# \9 m3 s0 N" l( P  u/ ?* x. Q    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
% b" w' m: f; V' x
9 x. r, K- A$ A    Index：是哪一个区块（创世块的索引是0）？
5 ^: G4 b6 E4 P% _# c
6 A  W3 H: V$ U  g# K; }    Hash：块是否有效？' q/ m5 T2 w/ X

0 g1 b% O+ v- q8 s9 x/ B, o. b8 b    PreviousHash：前一个区块是否有效？, O0 I, H0 Y# i) j

+ L' n0 j+ B3 X- A1 Z4 k$ u    Timestamp：什么时候添加的区块？
! F) v; i7 _) h( A& t4 S$ K
7 W4 U" o# b* Y    Data：什么信息存储在区块上？
; }. m9 b+ ^; F- H
1 A8 ?! K9 u3 I! b) F, C    Nonce：在找到有效区块之前，我们进行了多少次迭代？0 h" y& p: l: C) N5 ~2 a: }( |% F* Y
5 K2 k3 g8 o3 j3 d- y* U; I
    创世块
$ `' D' O2 o% R
* e/ Q' A! @9 ?  y6 H1 [* d    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。
- \4 `, N, }! J8 a- f2 c+ B3 }5 R
; [$ ]+ d- I9 A" H5 c+ {    当一个新的区块被开采时会发生什么？# G  y+ t0 E, |

; Z* ?( q" z8 O, y  P% U    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。) p$ u( {) x$ Y/ S) w0 v7 V  O

4 n/ N! i0 Q3 a) _$ a( {% {    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
5 m/ C  s8 F1 W* ]" \  S( {# ~* Q- Z% K
    Index：0+1=16 h( K1 ~( M# d9 I0 J& \- G
5 Z+ n) h( k6 g3 q( u5 r# E: G1 j
    PreviousHash：0000018035a828da0…
7 h- t1 s; l# U9 D, q' L$ t) K+ w5 @7 v6 I0 `% @# F  O8 k
    Timestamp：区块被添加的时间
4 c/ x' j( d, {: y1 Z/ x2 |5 h
- {, @5 E# L0 ~    Data：freeCodeCamp7 K' l, n: g# i

; H5 U# r9 O# o9 a' f6 _    Hash：？？？" u  O. c- z! s. R+ I
8 Y! j2 l" ]8 H2 O( `- m) g
    Nonce：？？？
* W8 i3 P4 q5 v- s
7 O. K3 v/ L8 N( E+ l/ t    Hash是如何计算的？
% @% s# b# @6 T: O* s+ t' {0 A- v( e& X
    哈希值是唯一标识数据的固定长度的数值。8 N) m: O; W5 |* H

% l1 j  h8 j: V+ ]9 r; m    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。. I( g$ P) j$ L! O% m* b

* h; C: u9 b. p    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
/ j6 h; t/ }$ z4 {+ Q4 Q0 n
1 M- G& [0 i. q9 p- K, _    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。, P: @- u" t4 R
) f$ ^7 c/ f! h9 _: Y5 O! @- Z/ q
    你是否注意到区块Hash中的四个前导0？
- E+ d( E8 L6 f6 ]7 L7 w  g/ x) {0 C3 T  @& F" a$ m( y
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度/ l4 b3 l6 F/ u. X; G5 D- Y

* @% U9 a" I5 g: d8 t$ C    functionisValidHashDifficulty(hash,difficulty){9 I2 r& q1 [8 m
& I0 h0 B" e& h& G7 N1 D2 _. M
    for(vari=0,b=hash.length;i=difficulty;
# Y$ C; W% M! ^0 l+ F6 P9 J6 [7 C  ]* W; z1 b/ O3 ]# ?
    }
$ H. E6 @/ u+ S! \! H9 N/ ^
- h3 b, j8 ^1 L  k/ p    这也被称为工作证明系统/ p9 m7 u+ ?" _! |" `" }1 M

& Q! U- b: _) @    Nonce是什么？# b% n8 P1 a- m3 [7 m' E
9 Z) `% ?2 J8 P* w2 Q) J
    Nonce是用来查找一个有效Hash的次数。9 o6 _2 }& o) p- O

0 H9 N& N* B& z) |0 D1 R9 a) O    letnonce=0;
" j" w, y; O* V, u+ O. _! ?4 n$ g/ R$ O7 L) @+ f
    lethash;2 ^8 T" S+ Z' d3 u8 d

* X5 f+ }1 p' _9 W$ n    letinput;9 Y1 r" c  ]7 m- c5 B

, s+ [7 s* Z" ]7 m    while(!isValidHashDifficulty(hash)){, G% t# \" p- o" [0 p+ c2 [

: r7 e8 L. A% i5 g0 b+ C    nonce=nonce+1;8 \: a4 m/ a- N  s' j& q

8 P1 ?4 S- O3 u1 ~3 n    input=index+previousHash+timestamp+data+nonce;' i+ E( m* V$ Q' ~
  w/ Z0 b5 X) X% d* U4 y0 b( q+ n
    hash=CryptoJS.SHA256(input)
3 d* S+ |1 [2 i& }( y3 ]6 Z# H, Q
+ a! A% [  `- ~5 _    }0 c: V/ G; U) I! U) C, d

4 Y8 T( S2 e! u    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。5 d0 q; B. [2 a$ Z8 [% s9 V: I
8 l3 @5 I: {) A
    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。
6 l2 a; w  Y- M# F% n' `; K( K; Q* v, t
    为什么这么重要？
1 \! Q8 `4 E6 P6 V0 n$ k: U; `0 U) W
    这些机制非常重要，它们使区块链不可变。
6 h+ b" u* \! x  e' i& |+ E
4 b! ]* L1 {8 D    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？) g% D9 ~9 Y, m
: H8 S' F/ x/ \# R3 N9 k
    区块A上的数据改变了。
5 A% ?* r) U* ^2 S' D9 u
1 d! ^7 b4 G4 [5 d    区块A的hash改变了，因为数据被用来计算hash。8 v# T4 o( h2 k4 e( ?. q

2 A( @0 v7 P% |; O, E5 z    区块A失效了，因为它的hash不再有4个前导0。8 [6 f" j) t$ o! M3 F4 y
! v2 k* F, i0 B# u% Z
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。
8 d! c% C5 K8 |3 k! r5 N% C+ q5 ]  C' C( u( e1 c* K0 D
    区块B失效了，因为它的hash不再有4个前导0。1 {8 W7 Y  e8 H$ O# N" h& @& o

3 C7 P( V4 H4 q! H& l" A    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。" o* a: E9 `1 D2 O/ }
3 T" m) s3 E/ @4 C' F3 `
    区块C失效了，因为它的hash不再有4个前导0。
4 ^' Q* d+ A) S7 y  h1 x, l- N! T: A5 b4 {. u  x/ n
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。2 K+ \/ z# s. `) C/ P' M! g