Կառուցեք բլոկչեյն Գոլանգում զրոյից

Այս հոդվածում մենք կկենտրոնանանք Go blockchain-ի զարգացման վրա զրոյից: Այնուամենայնիվ, նախքան սկսելը, դուք պետք է համոզվեք, որ դուք ծանոթ եք Golang-ի հիմնական հասկացություններին: Եթե ​​ոչ, ապա խելամիտ կլինի, եթե դուք անցնեք նախնական հայեցակարգերը, ապա վերադառնաք բլոկչեյնին: 

Այսպիսով, եկեք անմիջապես անցնենք թեմային: 

Սկսած նոր գրացուցակով 

Սկսելու համար մենք կկառուցենք նոր գրացուցակ: Ենթադրենք, որ այս գրացուցակը ունի «բլոկչեյն» անվանումը։ Մենք մուտքագրելու ենք կոդը Command Prompt-ում (կամ եթե դուք օգտագործում եք macOS կամ Linux, դուք պետք է օգտագործեք Տերմինալը): Այսպիսով, մենք մուտքագրում ենք.

cd go-workspace 

mkdir բլոկչեյն 

cd blockchain 

ծածկագիր .

Երբ VS կոդը բացվի, մենք հրամանի տողում կստեղծենք Go մոդուլ: Ինչպե՞ս ենք մենք դա անում: Դե, մենք մուտքագրում ենք.

գնալ mod init github.com/golang-company/blockchain

Կոդավորում main.go-ում 

Հաջորդը, մենք կստեղծենք «main.go» անունով Go սկզբնաղբյուր ֆայլ և կմուտքագրենք դրա մեջ ծածկագիրը: Բայց նախ եկեք հասկանանք, թե ինչ է բլոկչեյնը: Ա blockchain կարող է սահմանվել որպես հանրային տվյալների բազա, որը ապակենտրոնացված է և բաշխված է մի քանի գործընկերների միջև: Blockchain-ը թույլ է տալիս տվյալների բազան ինքնուրույն շտկել, նույնիսկ եթե հանգույցը արտադրում է ոչ ճշգրիտ տվյալներ: 

Սովորաբար, բլոկչեյնի բլոկը բաղկացած է տվյալներից, որոնք մենք կիսում ենք տվյալների բազայում, հեշից և նախորդ բլոկի ծածկագրային հեշից: 

 Այսպիսով, պատրա՞ստ եք Գնացեք բլոկչեյնի զարգացում? Հիանալի Եկեք սկսենք. 

Ծրագրավորման մաս 

Այս բաժնում մենք կանդրադառնանք main.go ֆայլին: 

փաթեթի հիմնական

ներմուծում (

«բայթ»

«crypto/sha256» 

«fmt» 

)

տեսակ Cryptoblock struct {

Հաշ [] բայթ 

Տվյալներ [] բայթ 

PrevHash [] բայթ 

}

• Ինչպես տեսնում եք, կառուցվածքը միայն ստեղծվել է: 

func (c *Cryptoblock) BuildHash() {

մանրամասներ := bytes. Join ([][] byte{c.Data, c.PrevHash}, []byte{}) 

hash := sha256.Sum256 (մանրամասներ)

գ.Հաշ = հաշ[ :]

}

• Այժմ մենք կկառուցենք մի մեթոդ, որը մեզ հնարավորություն կտա ստեղծել հեշ՝ կախված տվյալներից և նախորդ հեշից: Մենք կներմուծենք «բայթերի» գրադարանը, քանի որ այն կօգտագործենք:
• Հաջորդ քայլը մանրամասներ կոչվող փոփոխականի ստեղծումն է և տվյալների տիպի բայթերի օգտագործումը: Մենք կօգտագործենք Join() բայթերի հատվածները միացնելու համար:

մանրամասներ := bytes. Join ([][] byte{c.Data, c.PrevHash}, []byte{}) 

Այստեղ մենք վերցնում ենք բայթերի 2D հատված, փոխանցում ենք c.Data-ն և նախորդ հեշը: Այնուհետև մենք կմիավորենք բայթերի դատարկ հատվածը։ 

• Դրանից հետո մենք ստեղծում ենք sum256 hashing ֆունկցիայի իրական հեշը մանրամասների վրա: Մենք կարող ենք օգտագործել սա, քանի որ ներմուծելու ենք sha256 գրադարանը: 
• Հաջորդը, մենք ստեղծված հեշը հրում ենք բլոկի համար Hash դաշտ: 

func BuildBlock (տվյալների տող, prevHash [] բայթ) *Cryptoblock {

արգելափակել := &Cryptoblock{[]byte{}, []byte(տվյալներ), prevHash}

block.BuildHash()

վերադարձի բլոկ

} 

• Այժմ մենք կկառուցենք մի գործառույթ, որը հնարավորություն է տալիս ստեղծել Block: Ֆունկցիան ընդունում է տվյալների տողը որպես մուտքագրում, prevHash-ը նախորդ բլոկից որպես մուտքագրում, այնուհետև թողարկում է հղում դեպի Cryptoblock: Մենք բլոկը կկառուցենք՝ օգտագործելով բլոկի կոնստրուկտորը: 
• &Cryptoblock-ը գործում է որպես բլոկի հղում: Hash դաշտի համար մենք ներառում ենք բայթերի դատարկ հատված: Տվյալների դաշտի համար մենք վերցնում ենք տվյալների տողը և այն վերածում բայթերի հատվածի: Եվ մենք prevHash-ը ներառում ենք PrevHash դաշտում: 
• Վերջապես, մենք զանգում ենք BuildHash() բլոկի վրա և վերադարձնում ենք բլոկը: 

մուտքագրեք BlockChain struct {

բլոկներ []*Cryptoblock

}

• Պահանջվում է տեսակ, որը կօգնի արտահայտել բլոկչեյնը։ Եվ մենք իրականացրեցինք մի ստրուկտ՝ դա իրականացնելու համար: BlockChain կառուցվածքի տեսակը կազմված է Cryptoblock-ի ցուցիչների զանգվածից:

func (շղթա *BlockChain) AddBlock (տվյալների տող) {

prevBlock := chain.blocks[len(chain.blocks)-1]

նոր := BuildBlock (տվյալներ, prevBlock.Hash)

chain.blocks = հավելված (chain.blocks, նոր)

}

• Այստեղ մենք ստեղծում ենք մի մեթոդ, որը մեզ հնարավորություն է տալիս միացնել բլոկը շղթային: Մեթոդը վերականգնում է բլոկչեյնի ցուցիչը: Դրանից հետո այն ընդունում է տվյալների տողը: 
• Կանչելով chain.blocks՝ մենք հասնում ենք բլոկչեյնի նախորդ բլոկին: Հաջորդը, մենք անցանք բլոկչեյնի երկարությունը [len(chain.blocks)-1]:
• Նոր փոփոխականում մենք կանչում ենք BuildBlock ֆունկցիան և փոխանցում տվյալների տող և prevBlock.Hash:
• Օգտագործելով append ֆունկցիան՝ ավելացնելով այն chain.blocks-ին, այնուհետև մենք կցում ենք նոր բլոկը բլոկչեյնին:

func Inception() *Cryptoblock {

վերադարձնել BuildBlock («Inception», []byte{})

}

• Հաջորդ քայլը Inception կոչվող ֆունկցիայի ստեղծումն է, որը նկարագրելու է բլոկչեյնի առաջին բլոկը: Եվ մենք ֆունկցիայի մեջ կվերադարձնենք նոր BuildBlock՝ առաջին բլոկի տվյալների հետ միասին։ Այստեղ. Ես ներառել եմ «Inception» և բայթերի մի հատված, որը ներկայացնում է դատարկ նախորդ հեշը: 

func InitBlockChain() *BlockChain {

վերադարձ &BlockChain{[]*Cryptoblock{Inception()}}

}

• Առաջին բլոկչեյնը ստեղծելու համար ես ներկայացրել եմ InitBlockChain ֆունկցիան։ Այստեղ ես պարզապես վերադարձնում եմ կոնկրետ հղումը BlockChain-ին: Հաջորդը, մենք կառուցում ենք Cryptoblock-ի զանգված, որտեղ մենք զանգ ենք կատարում Inception ֆունկցիային: 

func main() {

շղթա := InitBlockChain()

chain.AddBlock («Առաջին բլոկ սկզբից հետո»)

chain.AddBlock («Երկրորդ բլոկ սկզբից հետո»)

chain.AddBlock («Երրորդ բլոկ սկզբից հետո»)

for _, block := range chain.blocks {

fmt.Printf («Նախորդ հեշ. %x\n», բլոկ. PrevHash)

fmt.Printf («Տվյալները բլոկում. %s\n», block. Data)

fmt.Printf(«Հաշ. %x\n», բլոկ.Հաշ)

}

}

• Վերջապես, մենք հասանք հիմնական գործառույթին: Ինչպես տեսնում եք, մենք կանչել ենք InitBlockChain() և այն վերագրել ենք շղթայի փոփոխականին: 
• Հաջորդը chain.AddBlock-ի միջոցով բլոկներ ենք ավելացնում շղթային և փոխանցում ենք անհրաժեշտ տվյալները։ 
• Դրանից հետո մենք գործարկում ենք for loop՝ բլոկչեյնը ստուգելու համար: Այնուհետև մենք առանձնացնում ենք յուրաքանչյուր բլոկ և տպում դաշտերը յուրաքանչյուր բլոկի ներսում։ Մենք պարզապես մուտքագրում ենք.

fmt.Printf («Նախորդ հեշ. %x\n», բլոկ. PrevHash)

fmt.Printf («Տվյալները բլոկում. %s\n», block. Data)

fmt.Printf(«Հաշ. %x\n», բլոկ.Հաշ)

Արդյունք: 

Այսպիսով, կարելի է ասել, որ ծրագիրը հաջողված է։ Հուսով եմ, որ դուք կարողացաք հասկանալ բլոկչեյնի հայեցակարգի իրականացումը Golang-ում: Պարզապես շարունակեք պրակտիկան, և դուք կկարողանաք գլուխ հանել բարդ նախագծերից: 

Ձեր կրիպտոն արժանի է լավագույն անվտանգությանը: Ստացեք ա Ledger ապարատային դրամապանակ ընդամենը 79 դոլարով: