一个用于维护不断增长的记录列表的分布式数据库，我们称之为区块链。4 ~% |8 [# d' U5 J% M5 {

- v& ~+ H/ `1 a, [. U) x0 M! @% G    这听起来很棒，那它是如何工作的呢？
' b* J- o( z# L+ t
* i+ b( R$ g6 x& S* h9 m; ?! ]8 e    为了说明区块链，我们将会使用一个名为BlockchainCLI的开源命令行工具。$ V  \+ e+ W; A0 d3 w1 K4 D$ O6 S. Y
+ I3 r, F# d  A# B/ x  ?# E
    我同时也建立了一个基于浏览器的版本7 U5 Q7 }6 J4 p4 o
8 j/ H8 \5 u% ~- ?& u. B. @  @$ o, g
    安装命令行工具/ w9 m* p3 W, a/ x' x; Y2 j: X7 X! ?

) \2 A5 e9 H# H* b) g1 @    在此之前请先安装Node.js, @4 C( C" C" d- ~) J
% t+ z* {$ V: {) F# x
    然后在你的命令行中运行以下指令：
2 T0 v, ^3 Q- E3 A8 J3 c% ~) B$ ^8 Q( @
    npminstallblockchain-cli-g  v6 A8 q. W/ I/ r/ D

. b; x0 Q7 ?* K% j  g5 e* F: Z    blockchain0 c! u2 u2 k# L3 h( ^
2 y5 V) F3 A; B, w: N# l6 L2 |0 H6 X
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。% E7 l! v8 a# b( ^
  S2 \7 S+ ?) k/ o4 l
    区块长什么样？
5 ^0 R- y7 G; }  \3 ]( l7 @  x" T: q/ s5 }  H
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。
  L# E  `1 c9 F$ _4 e# @: n0 a- F; z; D9 _# @
    Index：是哪一个区块（创世块的索引是0）( R7 i0 `$ x% T

$ h& o% r% e, r; A( B* y2 q    Hash：块是否有效？
8 T2 e  d. D1 e5 [4 \6 u& ^7 T- o0 q8 S( `6 x
    PreviousHash：前一个区块是否有效？% O! m7 o& M# B' v

/ O( j3 Q* G6 Q0 x8 z5 b    Timestamp：什么时候添加的区块？) A; s6 c4 H+ h. I5 ?) b
% X. c5 h; |4 T3 p# q& ~0 D& |
    Data：什么信息存储在区块上？# Y/ m  {+ }& r: ?/ G
4 Z8 `8 c; P- R- J
    Nonce：在找到有效区块之前，我们进行了多少次迭代？5 j/ f1 R# O8 n6 `7 ^8 q: R
2 F. r5 [6 h8 F# U' O
    创世块/ A4 d" S( z2 \- |# l4 X& U" ~$ n

& y7 D" d8 ]9 Z4 m$ t    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。6 _! d7 Z5 |" d1 t1 k. e9 \
/ \5 _& C6 Z( g# G1 o: |- B! h* v
    当一个新的区块被开采时会发生什么？
0 _* J! O3 R4 f# V& J# {' [  n( g# M6 r
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。
. L3 S% U4 d/ J* d$ ~9 h) ]9 [' G3 t4 F( d6 I/ v
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
- w0 j/ X: F, f8 X* H1 E% A! }$ b6 e5 `8 [* \( a5 |# s
    Index：0+1=12 N. E( R0 f% Z& ]0 E$ L. C5 Q

  s' q  a$ t4 O/ t( H+ \# H    PreviousHash：0000018035a828da0…
7 e2 L; _, s- w& i! g) h+ h
+ z) @5 j4 k0 _* v    Timestamp：区块被添加的时间
: G! U/ m0 O# z+ w' ~) l, Y) z4 I! `; ?9 L+ J& A  |0 G
    Data：freeCodeCamp- \3 E3 w5 Q  U  z( H+ V

8 w4 q& a% z2 m    Hash：？？？
4 {, t# J- }+ o' I" {4 ?: H" S! ~4 u
    Nonce：？？？
8 I4 t0 B# U7 T. c0 h! K* o* G4 G( g* {: T- t4 U# Y
    Hash是如何计算的？; v) b$ Z8 K2 t# N& L
# b: o- H6 @4 }1 R. L# x4 M
    哈希值是唯一标识数据的固定长度的数值。
) v- w) J) a% O
% c0 D9 q* D6 u+ b9 q% j$ W0 z    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
3 X! Y9 D5 Z. R) a7 K3 e7 e+ D( a, J) R) A% T9 K
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
' B& B; F2 z) ?5 V7 i* p6 z! W
$ T- G% k% M* c( r    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
7 K. a- ~& \# b8 n2 u/ j) P' h9 n2 M- j% }. ?
    你是否注意到区块Hash中的四个前导0？
2 F3 q1 k' i3 F2 c9 L2 b' @$ b3 E2 S# M$ G
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
) ]+ o3 v9 v( h8 a! \. v! w& J
  V2 P( n6 H, n  Q) w+ r    functionisValidHashDifficulty(hash,difficulty){
% ?& ~" e3 h& H- Y. g" X
1 ?5 a- J; V7 y% j1 O    for(vari=0,b=hash.length;i=difficulty;  ]1 \; l' D. T! V, U. L/ Z5 g7 @

" j# `# {: h/ f% h% {6 V$ |* s2 A    }
+ F6 N0 t+ v( A* A* ]/ R3 a/ [5 U8 J# L, \9 U* b7 p
    这也被称为工作证明系统+ C' u2 A. m4 q' E' f5 c
+ ~5 T' _+ c5 l5 C! v( w
    Nonce是什么？$ X/ F0 B% m4 |0 C

; E: O3 I' n4 n  m: M" B. {1 k( o    Nonce是用来查找一个有效Hash的次数。
( {. h/ G6 Q; j, b7 C3 o$ H) B0 ^
    letnonce=0;
8 F; J, k. L) E' }
6 w, b7 A( J2 ?5 Z) l    lethash;* o. {. n, K& Z$ @6 y- J
% l0 }7 I+ i( A* T
    letinput;8 x, B( i$ c# h# [2 w, D; P( h

1 {6 a, o6 T  [! }0 w" F  U    while(!isValidHashDifficulty(hash)){
3 I# V+ u  T* P- a; ~6 p, w3 H* n% y7 ?; A, C. b6 K
    nonce=nonce+1;8 o9 E7 n# ]1 g) Q9 i! G: |
; [: E% m( S* K% @
    input=index+previousHash+timestamp+data+nonce;7 \: m, J. g6 K: H: h
1 m+ h9 d0 s& V5 H
    hash=CryptoJS.SHA256(input)1 o) ~' R+ I8 ?% q" {8 C' f
; Z) I7 M6 I+ C3 R3 {- `: k( O: H
    }
) J+ c& G- F% d" x
3 `! C- F: I, _' }# H: \; q" F# o0 r    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。! J! r5 Y2 ~0 b' Z, P( j; ]

1 l8 i4 {4 u1 |; m* P7 c    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。
+ {$ [% k6 h6 f8 F
# R6 Q, I; F1 d5 ^. u    为什么这么重要？. O$ K; \! X/ I) _9 z+ s

9 n* Y  }& ^# a    这些机制非常重要，它们使区块链不可变。9 G0 @$ X, p# {& _4 W

) G- ?0 }6 k8 f) C; r; _3 j2 U    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？5 J1 c  t, O7 p* {4 V! b5 x

1 l- k0 F9 j- c" H5 |    区块A上的数据改变了。
) {( Y' F: l) A) H5 t; i5 m6 _) V+ b) `8 n& [% W0 ^+ j0 ?
    区块A的hash改变了，因为数据被用来计算hash。7 ]$ s2 I, e0 G7 w' ?

3 y, X% g) t! m8 ~$ {# N  r: l    区块A失效了，因为它的hash不再有4个前导0。0 C( d! w- D6 |7 O$ I3 f8 G6 e
* ^4 C- x" |' _7 L
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。, R5 g, G; v9 ~" s

" F, A) b& j' N, h4 D    区块B失效了，因为它的hash不再有4个前导0。
9 {' p  ^+ q7 ~3 G# n& ~1 Z
: f: `; W5 I7 O; c* n1 h+ C, b* ?    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
6 c% S. X6 {$ x5 x5 M0 h6 w; K$ q1 t7 E( S
    区块C失效了，因为它的hash不再有4个前导0。
6 K5 O. V2 z  U9 [: ]
# u, V( b) I* \2 R( m- J/ I1 G    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
, z4 P" P- p" [4 ^
2 u* D: ]1 o5 N0 w1 v; P9 x4 J" |    我希望这个教程能够对您有所帮助！: y( @5 B* O2 U8 o
, G1 x; k( X* _* E$ S
    安装命令行工具' v& D* m; F0 b' n

& b" Z$ ]( ]. [; ]    在此之前请先安装Node.js
: n) I" [; }$ J( z) s$ k. t
$ o+ [2 S/ `  a- v# P$ P% J    然后在你的命令行中运行以下指令：
5 T6 z, `" S+ n0 e5 t( d9 t( ^# t2 U  [" |% {
    npminstallblockchain-cli-g4 [. s2 v# C, ?1 X/ m

! j! _; x5 a7 P7 Q    blockchain
1 j; N7 I! i* U% I7 H, I0 |" {* K  o' D/ O+ T; l0 @
    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
9 I  c: ~3 d; O1 K$ D' n
* H( H# A' i) {/ ]1 `    区块长什么样？
, v; I  X" b6 A5 ^& \" @/ V7 G8 F9 U3 V* H  {
    想要查看当前的区块链，你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。! D! r0 }; b- u

, K9 \4 Y; |5 Y8 `/ ]    Index：是哪一个区块（创世块的索引是0）？8 r5 R) s+ M7 m, V/ u

# u2 `7 W; _+ t2 W% L* A    Hash：块是否有效？
* w# i+ {( n3 F' W- p( g/ B7 j3 F/ L1 ]$ |: ?( y" {) p
    PreviousHash：前一个区块是否有效？
# \8 H5 g8 w, D* I# u9 o1 v6 p  R& H3 Z9 h6 D) w$ D
    Timestamp：什么时候添加的区块？7 e/ J! I/ v' j9 a
, ]" C& ^0 A1 v5 v3 V! ]6 Q0 Z
    Data：什么信息存储在区块上？  b$ y3 v0 ~5 v0 \/ u" F

0 z. J$ d) C1 y1 y/ W    Nonce：在找到有效区块之前，我们进行了多少次迭代？
* `3 ]7 m5 K( x" \2 c' [; c% z/ I4 v5 Z( }' E
    创世块
. P# q$ f. `! J4 c9 E5 d" T8 a  C/ q6 }# R0 l  Y; y7 W
    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的，区块链上的每一个区块都依赖于前一个区块。所以，需要创世块来挖出我们的第一个区块。( @$ Q- x' f$ @. |: s4 k) g
. ^( O8 a  }: v6 {5 X
    当一个新的区块被开采时会发生什么？
" `* H9 ^3 q, n  t
& f1 q9 K6 [, ~2 C; x7 ]. G5 x& q    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。) R' V: s6 x% G( ]7 \3 I4 C
' u4 @: C5 h1 m. m
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。: o, \8 o; k; I4 S. c+ P
4 _. G1 [" ^; J* g6 V4 [7 U$ V1 u
    Index：0+1=1( Y  y1 {* b( Z) I; a3 i" Q

2 h. V8 }, w* G" L! x% E9 E7 h    PreviousHash：0000018035a828da0…( `7 y( T+ _$ }4 T& T7 o
+ p2 c- m( Y8 M. N) K
    Timestamp：区块被添加的时间* v1 q. {+ f5 w, U* q( {1 R& L! e

1 U+ |: M9 {" ]6 V    Data：freeCodeCamp5 ]0 A% x, R0 x) ]% z
! Y7 n8 S8 P: U7 V
    Hash：？？？
: {7 ]* g- ^8 G, v+ W% ~+ i9 \; g! Z- L9 k4 V
    Nonce：？？？
2 @( \: O4 x0 s3 s
6 c& L- ?! d3 z  I& [% Y# f+ ]    Hash是如何计算的？7 @& _2 _3 P1 y4 F8 F7 `5 ?
5 A# b5 s% C4 b1 {2 u4 o
    哈希值是唯一标识数据的固定长度的数值。
0 q4 J. i3 n( _. ]7 L1 g- ], J% x: t$ G- @# y9 n, B' D1 h
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。
& ^8 o; S  E; r! i5 A1 ?$ J% G! G3 z, m* [7 R# s1 l
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
( w- ~7 w  A0 z+ E4 J7 E; i( A. u5 ]+ e8 R4 p8 A
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
$ x* ?, f4 n, p" k! r
$ e% M' L9 `5 f. T7 d4 c3 i    你是否注意到区块Hash中的四个前导0？
% L4 y2 n: n+ |4 f1 c, G, F- l# I/ x7 _. T( M
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度) x+ n- w9 v, C4 C' _

& _* [6 u1 M1 }2 ~1 X# U2 y    functionisValidHashDifficulty(hash,difficulty){1 }% {3 Q* `; |% \. e
  U& g- u& q  }, C$ K: @  @. W
    for(vari=0,b=hash.length;i=difficulty;/ b$ e* Y8 K: n& Q8 s) T
2 x" D% |2 C+ T
    }7 {2 i1 T" Y% \& c7 q7 R6 W' Y: _
$ y* i. |9 a) s7 ^9 e( m# m
    这也被称为工作证明系统, _1 k9 H0 X9 _, o* L

; h8 z1 _& O( ?* D# I! _    Nonce是什么？( o$ h: ~2 d9 d

  N; e( U& A1 S5 ]' Z5 s    Nonce是用来查找一个有效Hash的次数。1 ?0 s4 J8 l, C# [9 M

! O/ `' v+ v9 I! S1 U6 k( P+ @4 K    letnonce=0;
. G3 Q% Z+ }3 U( t! g) v0 B& ?$ f8 d0 O
    lethash;, s1 a' O4 ^) n; m9 P1 Y% x
: s% c* x; X. e9 U7 q- L/ A, Z" k
    letinput;
+ E& }' J: \5 K1 m* y2 t6 `4 f" Y; p( a& v4 b2 o% _2 Y
    while(!isValidHashDifficulty(hash)){
: k- J8 S/ B6 G4 I# v: G: j- s1 H( b' T
    nonce=nonce+1;. t- O! F. _# w6 w5 P9 o% H

- n' f  u) g- E9 D    input=index+previousHash+timestamp+data+nonce;+ k9 v7 ~% k( W) Z+ Z+ S4 A9 L
2 I7 j1 ^+ v3 z+ p
    hash=CryptoJS.SHA256(input)- S3 W1 O$ }* W% N# g8 P2 {
* R7 j! h3 Z" M. J
    }
, t7 m8 G- }8 R& O" x7 [+ j* z% g6 V* f/ }4 g) }: `5 |
    Nonce迭代到直到Hash有效。在我们的案例中，一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
" J' U6 B2 R% [
% Y+ R# E8 D9 a3 B    随着难度的增加，可能的有效Hash数量就会减少。伴随着有效Hash的减少，我们需要更强的算力来查找有效Hash。
( x" [5 }0 j- r6 P; w4 H
% y7 e8 `) W( L( ]    为什么这么重要？
# t% @8 }# R3 m$ ?% s6 h$ [1 U+ t
; G* {, D& h4 B2 ^    这些机制非常重要，它们使区块链不可变。
7 A3 r  X# X0 q. d; H  i8 k: s4 r0 f/ G& R2 p; r/ P
    如果我们有这么一个区块链“A->B->C”，而且有一个人想要改变区块A上的数据。那么会发生什么呢？: i3 j% \7 C$ L6 D

  L/ R  X. s. r    区块A上的数据改变了。5 F) `+ k! {  s9 [; V7 W

: I5 M; Y" V) `* u; V6 k    区块A的hash改变了，因为数据被用来计算hash。
# R6 U  q( O1 O  u2 i9 B3 U; x4 x6 [0 P' F- ^- W
    区块A失效了，因为它的hash不再有4个前导0。* R# g* L4 m4 q7 l7 ]$ [
7 B9 p1 P6 i) Y" v
    区块B的hash改变了，因为区块A的hash被用来计算区块B的hash。6 A: P/ q4 X" h, B/ M- X7 \

; N) x( o1 G8 g. R. \- f* e# R    区块B失效了，因为它的hash不再有4个前导0。% ?8 e+ v4 o0 X3 R% L
/ `. a0 F+ R, `, `: d. X
    区块B的hash改变了，因为区块C的hash被用来计算区块B的hash。
- I9 n, @- _8 _& C. n
8 |, Y/ W- M* B( s( i2 t    区块C失效了，因为它的hash不再有4个前导0。4 c9 s, x5 ]3 C3 l* `' R9 i' ^: V
* T& P2 O5 ?2 R1 k- L, x9 t
    改变一个区块的唯一方法就是将这个区块重新挖一遍，接下来是所有的区块。由于总是有新的区块被添加，因此改变区块几乎是一件不可能的事。
9 c2 p. J  H  b( t4 B: m: R& ?