一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。$ }0 N5 M; y# k6 t. j( g% ?

9 b* a8 D4 o. U6 ?    这听起来很棒，那它是如何工作的呢？  {" j2 O# Z$ R  N, c5 s
5 G: i5 _9 P% X% }7 d5 j) ?
    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。
; d, A! ^$ o" J6 l1 E
; F5 T8 P  }0 R2 |7 i/ Z# i1 m    我同时也建立了一个基于浏览器的版本) n4 V. z! c5 w+ u) l& @# J6 u
. a, Q! ^! D. `, g, u! z% d
    安装命令行工具& F1 X# C5 d% F9 x5 L$ J0 l" Q
+ e) ^; }; f- m0 ?# F
    在此之前请先安装Node.js- ^7 n' Q! y% b$ t

, b, J1 |& D8 X# k6 O    然后在你的命令行中运行以下指令：
) V# I+ [4 h0 S# M
' W( A, t+ B  {' i    npminstallblockchain-cli-g
5 [  s5 \( I) T- N  R" D2 S/ Z; P% e: x( M. U, m2 U: j
    blockchain
0 D" x* Q" B2 a- D/ t7 }- ?: I+ F! F5 [  r/ S& ]
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
% v% T& l/ i% H# M9 T1 J5 W# R+ i/ n7 n
    区块长什么样？: i) L( v8 [$ ^8 ^" f9 f5 h- B
  |) ^7 y9 {# @. z  y+ u/ D/ k+ @
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。' ~: z6 [' D1 y7 D/ x
; Z! G4 Y) e; `0 `& P$ m
    Index：是哪一个区块（创世块的索引是0）
" B' S4 M* A* M2 m( U2 a( i
( [6 E  d/ j6 I' e    Hash：块是否有效？! h5 B! G, @; c

$ l2 I  S6 n0 Q    PreviousHash：前一个区块是否有效？
& V9 j$ L' D0 ^- A
& Q5 F' H# c" [( X/ J1 M6 A2 d' ~    Timestamp：什么时候添加的区块？0 ]" Q+ d  S( K3 _9 k$ L$ T
* u/ c/ Z6 ^9 l" z7 x$ X
    Data：什么信息存储在区块上？& ]# g9 G- a  K9 y/ h
7 C* s$ z/ \' J3 Z
    Nonce：在找到有效区块之前，我们进行了多少次迭代？
& s& Y. Q9 W8 h5 v# C$ w$ I* h  d% {( _  v9 P! k! V; Y
    创世块+ x; J4 M1 p9 X% v+ I
0 x- O" V( H% ]8 E+ l0 b5 F: A
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。
( f; |5 C: w7 b9 n- W. u5 E* _, J2 T6 J9 y& ~' S% ~
    当一个新的区块被开采时会发生什么？
6 f  U6 [. S, n1 B5 T7 C0 O
. h- e8 |& T6 C& Y# B+ ^  _    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
" T! ^, `4 B' K/ Z: g" t+ ^4 f6 d3 h+ S+ ~) n' O
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
4 |/ C/ b" J, `* R: G
- g1 _( E, X* ]7 X7 @7 U    Index：0+1=1
* ]3 C2 _9 q8 Z7 l' g( v4 l4 i/ j
2 ?# x( F6 Q* ]    PreviousHash：0000018035a828da0…
2 T: [8 Z( g2 I8 }2 v1 I- }. z# V" D
; E1 }' q- n, S1 y" n/ F: N    Timestamp：区块被添加的时间
5 r) y; c8 D; E% {4 f, U4 L( U3 w- M$ C5 p& z
    Data：freeCodeCamp, r" q* N1 q4 d% V4 O3 ]

* Q6 a) m7 D( O, M    Hash：？？？
* j/ J- z7 L) S* ?3 n( |
; _. m" D- K% D5 C    Nonce：？？？
* B9 z& \: V% R+ ], x
" [( U9 r% b1 ?$ s3 G1 s    Hash是如何计算的？( C9 \) Y. [6 D1 i2 z0 h1 T& \! w
9 B; j$ I3 u& V6 N; X
    哈希值是唯一标识数据的固定长度的数值。
; h5 G' T7 S3 R' ?5 [  ]' u. ?( P( r" \* ~
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
3 I  i' f. L! N
) M7 r: S$ P- w/ u2 n* x    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
! @; G. l0 H, Z3 Y% H% ?+ i, f3 z+ o6 M7 k& C
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
$ y. \/ V0 \/ y" }! A6 e
% T1 H/ X  n. |1 m' @    你是否注意到区块Hash中的四个前导0？1 F& u0 D% `: K

! C' x) R5 Q+ X3 c/ h; V" R: {    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度# J% n  A& Q3 K- c
3 O8 }. W- W: ~  V0 M2 x' l1 c
    functionisValidHashDifficulty(hash,difficulty){
( Q- Q  R$ ]1 b. o7 _
! t- I5 k6 z* i2 _9 D    for(vari=0,b=hash.length;i=difficulty;: E8 _( k1 C! W
4 J4 j' X% d' m7 H7 }
    }
& Z) \% k- l, g5 x* t
6 D: ?/ `' l% y7 `    这也被称为工作证明系统
, k( a: x. |! W; j
4 u, r+ R. g+ F6 P    Nonce是什么？6 l, B/ `) g  P2 l# t

4 s0 R0 y! {2 o1 D$ U4 z+ v    Nonce是用来查找一个有效Hash的次数。
. s8 S" l; a2 Z0 Q6 ^  e9 L
1 q( A$ O7 T* ]; N/ ?9 ^" T, o2 ]& M    letnonce=0;
8 N6 R- \3 m  R  u
# _( r! x, B6 k    lethash;
% Z! b# X# N4 H1 H+ X- k2 m0 q; f9 ]9 L& i
    letinput;7 g9 x$ b; O; \* U
9 E& u3 o0 b$ X) Z& P  r
    while(!isValidHashDifficulty(hash)){  n  [+ W9 N* U' s- C+ _
* `7 u4 M6 G0 \( B8 F
    nonce=nonce+1;% N- {; ]- P/ w( p( z. o

5 Q( G1 R3 A7 Q8 p1 x$ P4 _    input=index+previousHash+timestamp+data+nonce;# S( a2 _3 y$ A9 `6 R9 P6 a

( H- l6 q2 w' G& a& D3 s    hash=CryptoJS.SHA256(input)- e) N$ n" j% I; l$ h

8 ]; y) q9 ], t, U" ~    }
; y4 p2 ^" T7 ?. x" T
8 o, z6 L5 i6 E6 M0 U- @6 S    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
. m! n) o/ A9 }4 ?' m, b/ q3 W9 X6 K% s
    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。( ~5 t* [# b& s2 q- E: z

7 r4 O2 A  D4 Z  n4 Q0 z) J, z    为什么这么重要？7 m" z' F" {$ F' l
2 v2 g9 Q) b# Y6 ~$ m* s5 m0 Y
    这些机制非常重要，它们使区块链不可变。
: V4 ~0 w; r( a7 Q
0 k: `  U, o5 V3 l    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？
7 X! ~/ D  @; C! `$ q3 T- G
' |! R3 t+ c% `    区块A上的数据改变了。6 D6 |3 Y3 r! u% P5 z1 k5 {
' L) u  f+ b) N3 |/ {* Y$ C) u
    区块A的hash改变了，因为数据被用来计算hash。* E: ^2 d& g9 K- n; O7 F; x

4 U8 s4 A7 f7 \# u7 S    区块A失效了，因为它的hash不再有4个前导0。
" m  h/ ~' h" M, Y: J/ g1 y7 R1 f+ m1 B
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。& K. `' W1 G- R  d* S5 S' ^( x  ~
8 V- H7 Z9 J; g8 r
    区块B失效了，因为它的hash不再有4个前导0。( w, B/ q9 H, A" V
, e3 X9 l5 l* s2 N
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。6 e$ Y. R, r2 j! B  g
! F: @( `$ X: H6 Z3 |
    区块C失效了，因为它的hash不再有4个前导0。
% \1 K2 a/ d* _1 N4 j# k
/ d2 q3 G, U0 I. ?' R3 [+ {7 q    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
) S0 N& n/ P0 W1 M1 \
) t9 G6 O) O  y  S  M6 w& S    我希望这个教程能够对您有所帮助！9 Z/ i% B! w3 Z4 B& |3 t! M1 S4 ~
+ p8 h0 \% J+ v' e- q
    安装命令行工具: t% g% a3 R. V# \5 m( ?
/ M! d. s$ ]. d% A5 |2 v+ |8 w
    在此之前请先安装Node.js
# N& |: {( o6 l) v
2 i0 D9 G# S! f6 R    然后在你的命令行中运行以下指令：
6 j$ g! @& q/ w
$ `+ z1 H0 U0 \. G! O+ P    npminstallblockchain-cli-g$ @4 R( ^1 _+ u2 X  \

* d  @2 P6 M0 v3 ^8 i% ]    blockchain
. {* @2 N! R/ i  |% b; Y1 b# X+ _2 Z# J7 D
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。- s, n6 x7 ?) g: C) M/ o
9 f  |/ d. W5 B5 |+ F  _
    区块长什么样？
- H+ R; a( q4 ^4 g
! C  n1 H* [/ L2 ?4 D% F6 u    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。$ D0 w. g/ ?' b

+ ?4 j) N* Z; M. u# _8 Z) g    Index：是哪一个区块（创世块的索引是0）？" V- T7 c9 w; b/ [  z5 N

3 s3 s* q9 s0 Q  u9 `    Hash：块是否有效？* \, ^* g5 l# M

( i3 S/ e; b- a/ a; e' y    PreviousHash：前一个区块是否有效？1 m& _0 M2 h4 f2 c8 j0 u9 {! A: o

: i+ Q- j" w- L! I8 S) n, S    Timestamp：什么时候添加的区块？
8 G. x( g. g0 J$ c, `  m  o/ z0 F# v! Q$ G1 `2 l
    Data：什么信息存储在区块上？+ p# h5 L! M( m5 G5 |
/ V! O8 `, P; p5 V+ `- j; I
    Nonce：在找到有效区块之前，我们进行了多少次迭代？8 u$ I: |9 F% u) e

0 Z8 f. {" v- n0 \( |( [" F# V    创世块7 D- W* ?# S' e$ g3 x+ ~) z

/ h, m6 _; f) n/ {3 ^  {    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。8 U  B, |& ?, z$ e! M4 b: F
  D" a6 v" I" p3 C# W! J, W8 K
    当一个新的区块被开采时会发生什么？/ @/ C# B; i+ ?  A$ q* z: Z, Q& g

$ ^' Q0 p% s  a    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。. q+ W8 }: E# N
) h# |+ n1 ^2 A! P) o! n5 F
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。( t8 r# K9 E/ j' Q) r
- ~5 h' B% C$ u9 W& h
    Index：0+1=1
3 A5 `4 _! \8 B$ J; g8 d# f) P! t7 r. T! W/ Y
    PreviousHash：0000018035a828da0…
$ y! I1 @: [, L& y' H2 D% \: s% G' K4 |  H/ _4 T( `5 f5 T- [* ~2 q/ d
    Timestamp：区块被添加的时间
$ S8 {4 I+ Q" z( i! w, _! j, c1 {9 C8 L( E0 Z. f7 G+ ?
    Data：freeCodeCamp, X& h7 l$ F& I) r3 o, L

! _4 _+ ^5 t% f$ g, A2 D6 }" @    Hash：？？？
- B7 N0 d% h/ J; V) m( T+ x
' p! ?, X. C$ W3 }5 w' B* z    Nonce：？？？6 u: l$ U. B, t( u
# f3 }$ p, p& e( @  S
    Hash是如何计算的？( T' q; F' n% L* t6 ~& l
# \3 y/ ?/ ]2 U; L* p+ @8 g$ ~
    哈希值是唯一标识数据的固定长度的数值。
. s$ E3 o3 g0 d. H, i* C5 z
) C7 A' Z  D% x: V3 [    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。1 O9 E" Z$ T+ m$ n0 U( }& Q

' ]8 B8 d! R* b/ b- S1 g    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
! N$ N) d7 N' B# [9 K% b, F' Z' w2 u8 Z! I, c
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
. t5 `: T) w2 A$ K, U( Y
7 Y5 W) n2 K8 Q3 c% O9 Q' M    你是否注意到区块Hash中的四个前导0？
' c- g3 x3 j% J
7 E/ c7 G% e: c0 `8 W4 P. ]5 h' c    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度  `5 i5 Q7 ]3 y1 [  a, W  j

, T, F( z& b" R6 \) o3 H( G    functionisValidHashDifficulty(hash,difficulty){
8 u7 D' O0 a6 B. h: H4 v9 S) B% U9 Z7 E; f1 Y$ s* F5 t
    for(vari=0,b=hash.length;i=difficulty;* K1 h" w) `* w  k& p" W
1 O. ?. O8 _8 A3 e% Y
    }2 Q) s) Q0 p0 ?2 p

2 r' Q+ Y- ]  E5 h    这也被称为工作证明系统4 }1 d$ G7 j! W
! g  }7 f9 x; k0 u! y) Y
    Nonce是什么？
( K. A; m0 C: T! @$ |
: R4 B4 m. v  Y! _& X    Nonce是用来查找一个有效Hash的次数。
( M2 n& F; j  J. A/ p$ T5 m
/ B* i% }2 I* M( E; F! W: b( M    letnonce=0;. ^! U9 w* V. a, D

+ C! m7 R& I* r3 b    lethash;
3 p! g. J4 x; r0 d1 t# M$ l1 h6 B% Z9 S: P  u* J' y7 O8 j- `6 B1 u
    letinput;
& ?2 B. z* x' Z6 M+ @, K% N# U2 o% r) u1 D* A$ d
    while(!isValidHashDifficulty(hash)){6 M- E+ {) z9 h3 P

0 v' R' T8 q+ t1 _; G    nonce=nonce+1;
3 y2 L% R3 v$ S! S) Y7 S) F- j8 l! o" O9 J
    input=index+previousHash+timestamp+data+nonce;% O' i. ?" K" W
& K  N1 f: K* ^& Z1 h% S
    hash=CryptoJS.SHA256(input)
1 F! i  T# [6 i
$ u0 f8 Q2 s6 e" k( h; b2 X    }
2 b( Z0 U4 p+ |" N+ E/ }2 ^4 I; W
2 V( U5 G  d9 u% `8 a0 V    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
" _' L4 Q/ [. l
' }% P6 [$ a- d4 c: M  z$ x' Z    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。. \! F; N# ?8 u5 C- o: N3 [* c
2 B' x& @) z4 }% ^, z5 ~$ w4 A5 N) l/ p
    为什么这么重要？" f' T) `1 c/ I! D# h8 H' u: H

8 i1 \6 O- o) o) V5 }, W" b0 p5 y    这些机制非常重要，它们使区块链不可变。
8 D5 a% g9 T4 N6 u* a) T. t
! p8 t& {% Z- i$ i    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？
( b- W; A2 X; i2 M8 k# V1 o9 W, L3 v& C. r5 z* c3 U  p8 P/ J
    区块A上的数据改变了。4 F7 m- A1 ^# J
$ c2 M: u- j- y" q- x# A( ?
    区块A的hash改变了，因为数据被用来计算hash。
- G7 ^- V! K9 h6 A# r! b( c9 ]# u; [9 g: f
    区块A失效了，因为它的hash不再有4个前导0。
2 Q0 `' I9 i# w; E5 E2 n& K0 `& d1 [% F+ F8 d- D- ~# }  d
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。  N) b1 C6 D$ o$ w5 t
# i0 ~6 n6 O2 T6 Q5 N
    区块B失效了，因为它的hash不再有4个前导0。& l; [) v8 O6 q4 J7 R7 q6 O6 M& a

- r" Z- A2 ^' W9 _    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。& L" y& p, n. m8 W8 h

' u" _, c; u( Y2 |6 s    区块C失效了，因为它的hash不再有4个前导0。
) U* W0 R$ z1 y  V- c/ A( q: ]" Q
9 J* F' H+ f# Q5 q0 J% t3 P    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。6 T( @4 `& r" W. y% I