อ่านว่า Soilidity คืออะไร: ภาษาโปรแกรมระดับสูงสำหรับการดำเนินการตามสัญญาอัจฉริยะ

ChinaDeFi

特邀专栏作者

2021-12-03 09:30

บทความนี้มีประมาณ 5778 คำ การอ่านทั้งหมดใช้เวลาประมาณ 9 นาที

ภาษาการเขียนโปรแกรมระดับสูงที่เน้นสัญญาซึ่งออกแบบมาสำหรับ Ethereum Virtual Machine

สรุปโดย AI

ขยาย

ภาษาการเขียนโปรแกรมระดับสูงที่เน้นสัญญาซึ่งออกแบบมาสำหรับ Ethereum Virtual Machine

ชื่อระดับแรก

ความแข็งแกร่งคืออะไร?

Solidity เป็นภาษาการเขียนโปรแกรมระดับสูงที่มุ่งเน้นสัญญาสำหรับการดำเนินการตามสัญญาอัจฉริยะ Solidity ได้รับการออกแบบมาสำหรับ Ethereum Virtual Machine

ความแข็งแกร่ง = = = สัญญาที่ชาญฉลาด

pragma solidity >=0.5.0 <0.6.0;

contract HelloWorld {

}

ในโค้ดด้านบน เราจัดเตรียมเวอร์ชันต่างๆ โดยคำนึงถึงว่าโค้ดของเราเข้ากันได้กับทุกเวอร์ชัน b/w 0.5 ถึง 0.6 เรายังสร้างสัญญาชื่อ "HelloWorld"

ชื่อระดับแรก

สถานะตัวแปรและจำนวนเต็ม

contract Example {

// This will be stored permanently in the blockchain

uint myUnsignedInteger = 100;

string name = "vivek"

}

ชนิดข้อมูล Uint เป็นจำนวนเต็มที่ไม่ได้ลงนาม มันควรจะไม่เป็นลบ

ชื่อระดับแรก

ประเภทของข้อมูล

ประเภทค่า:

บูลีน(จริง/เท็จ), จำนวนเต็ม(int/uint), ที่อยู่(ขนาดของที่อยู่ Ethereum), สตริง, enum

ประเภทการอ้างอิง:

ชื่อระดับแรก

Addition: x + y

Subtraction: x — y,

Multiplication: x * y

Division: x / y

Modulus / remainder: x % y (for example, 13 % 5 is 3, because if you divide 5 into 13, 3 is the remainder)

Exponential Operation uint x = 5 ** 2; // equal to 5² = 25

โครงสร้าง

ชื่อระดับแรก

struct Person {

uint age;

string name;

อาร์เรย์

การรวบรวมข้อมูลเรียกว่าอาร์เรย์ สองประเภท: อาร์เรย์คงที่และอาร์เรย์แบบไดนามิก

// Array with a fixed length of 2 elements:

uint[2] fixedArray;

// another fixed Array, can contain 5

strings: string[5] stringArray;

// a dynamic Array — has no fixed size, can keep growing:

uint[] dynamicArray;

เราสามารถรวมโครงสร้างและอาร์เรย์ สร้าง struct แล้วมีอาร์เรย์ของ struct มันเหมือนกับการมีวัตถุและอาร์เรย์ของวัตถุในกระบวนทัศน์เชิงวัตถุเช่น Java

pragma solidity >=0.5.0 <0.6.0;

contract StudentFactory {

struct student {

string name;

uint roll; } student[] public students; // creates an array named students of student type objects

ชื่อระดับแรก

function eatHamburgers(string memory _name, uint _amount) public { }

การประกาศฟังก์ชัน

ตามมูลค่าและอ้างอิง

eatHamburgers(“vitalik”, 100);

ชื่อระดับแรก

ฟังก์ชั่นส่วนตัว / สาธารณะ

function _eatHamburgers(string memory _name, uint _amount) private {

}

ตามแบบแผน ฟังก์ชันส่วนตัวเริ่มต้นด้วยเครื่องหมายขีดล่าง

คำหลักภายใน / ภายนอก

ข้อความ

ภายนอกคล้ายกับสาธารณะ ฟังก์ชันนี้สามารถเรียกใช้โดยสัญญาทั้งหมด ยกเว้นผู้ติดต่อที่ประกาศฟังก์ชันนี้

ชื่อระดับแรก

กลับมาทำหน้าที่

function sayHi() public view/pure returns (string memory) {

return “Hi”;

}

ฟังก์ชันเหล่านี้สามารถทำเครื่องหมายเป็นบริสุทธิ์/ดู เราทำเครื่องหมายฟังก์ชันว่าบริสุทธิ์เมื่อเราไม่สามารถเข้าถึงข้อมูลที่ส่งผ่านได้ หากฟังก์ชันไม่แก้ไขข้อมูล แต่ดูเฉพาะข้อมูล ฟังก์ชันนั้นจะถูกทำเครื่องหมายว่าดู

ชื่อระดับแรก

เหตุการณ์

uint8 a = 5;

uint b = 6;

// line below throws an error because a*b returns a uint, not uint8:

uint8 c = a * b;

// we have to typecast b as a uint8 to make it work:

uint8 c = a * uint8(b);

เหตุการณ์

ข้อความ

// declare the event

event NotifyOnFrontend(uint x);

function add(uint _x, uint _y) public returns (uint) {

uint result = _x + _y;

//fire an event to let the frontend know the function was called

emit NotifyOnFrontend(result);

return result;

}

ชื่อระดับแรก

YourContract.NotifyOnFrontend(function(error, result) {

// do something with result

})

แผนที่

mapping (address => uint) public accountBalance;

นี่เป็นอีกวิธีหนึ่งในการจัดเก็บข้อมูลที่มีการจัดระเบียบ เช่น อาร์เรย์และโครงสร้าง

สามารถใช้เพื่อจัดเก็บวัตถุ (ข้อมูล) หลายรายการในบล็อกเชน ตัวอย่างการตรวจสอบมีดังนี้:

ตัวอย่าง:

contract Example {

struct UserInfo {

unit age; string dob;

}

mapping(string => UserInfo) allusers;

function setUserInfo(string _name, uint _age, string _dob) public {
allusers[_name].age = _age;
allusers[_name].dob = _dob;
}

function getUserInfo(string name) public view returns(uint, string) {

return (allusers[name].age, allusers[_name].dob);

}

ตัวอย่าง:

setuserInfo("Vivek",26, 25/05/1995) setuserInfo("Supu", 23, 01/09/1998)

หากต้องการรับค่าเหล่านี้ ให้ป้อนชื่อ:

getUserInfo("Vivek"); // 26 25/05/1995

getuserInfo("Supu"); // 24 01/09/1998

ชื่อระดับแรก

ตัวแปรเหล่านี้ใช้ได้กับทุกฟังก์ชัน เช่น msg.sender โปรแกรม Solidity ใด ๆ ที่เราเขียนควรได้รับการเรียกใช้โดยเจ้าของ ที่อยู่ของผู้ส่งถูกเก็บไว้ในตัวแปรส่วนกลาง msg.sender

require

ชื่อระดับแรก

function sayHi(string memory name) public returns (string memory) { /Compares if _name equals “Vivek” Throws an error and exits if not true. Solidity doesn’t have native string comparison, so we compare their keccak256 hashes to see if the strings are equaq /

require(keccak256(abi.encodePacked(name)) == keccak256(abi.encodePacked(“Vivek”)));

// If it’s true, proceed with the function:

return “Hi!”;

}

sayHi(“Vivek”) // executes successfully

sayHi(“Supu”) // throws an error

ดังนั้น need จึงมีประโยชน์มากสำหรับการตรวจสอบว่าเงื่อนไขบางอย่างต้องเป็นจริงก่อนที่จะเรียกใช้ฟังก์ชัน

สืบทอด

บางครั้ง แทนที่จะทำสัญญาที่ยาวมาก การแยกตรรกะของโค้ดออกเป็นหลายๆ สัญญาเพื่อจัดระเบียบโค้ดจะดีกว่า

contract Animal {

function catchphrase() public returns (string memory) {

return “Animal”;

}

} contract Cat is Animal {

function anotherCatchphrase() public returns (string memory) {

return “Cat is an Animal”;

}

import

ชื่อระดับแรก

นี่คือระยะเวลาที่โค้ดเบสถูกจัดการในโครงการ Solidity

ชื่อระดับแรก

ที่เก็บข้อมูลหมายถึงตัวแปรที่เก็บไว้อย่างถาวรบนบล็อกเชน ตัวแปรหน่วยความจำเป็นแบบชั่วคราวและถูกลบระหว่างการเรียกฟังก์ชันภายนอกไปยังสัญญา คิดว่ามันเหมือนกับฮาร์ดไดรฟ์และหน่วยความจำของคอมพิวเตอร์

ชื่อระดับแรก

โต้ตอบกับสัญญาอื่น ๆ ในเครือข่ายบล็อกเชน

ฉันจะเขียนบทความแยกต่างหากเกี่ยวกับเรื่องนี้ ตอนนี้ให้สั้น:

contract GetNumber {

function getNum(uint _num) public returns(uint){

return _num;

}

ในการโต้ตอบกับสัญญาอื่น ๆ เราประกาศอินเทอร์เฟซแบบอ็อบเจกต์ เราสร้างสัญญาและภายในนั้นประกาศฟังก์ชั่นที่เราต้องการเรียกหรือใช้จากสัญญาอื่น ฟังก์ชั่นเป็นเพียงโครงกระดูก ไม่มีร่างกาย

contract NumberInterface {

function getNum(uint _num) public returns(uint);

}

สมมติว่ามีสัญญาและเราต้องการใช้ฟังก์ชัน getNum ข้างต้น ในการทำเช่นนี้ เราจะสร้างสัญญาในโครงการของเราและประกาศโครงร่างฟังก์ชัน getNum (ไม่มีเนื้อหาของฟังก์ชัน)

หลังจากปรับใช้สัญญากับ Ethereum แล้ว สัญญาจะไม่เปลี่ยนรูป หมายความว่าไม่สามารถแก้ไขได้ รหัสเริ่มต้นที่ใช้ในสัญญาจะอยู่บนบล็อกเชนตลอดไป นี่เป็นหนึ่งในเหตุผลที่ความปลอดภัยมีความสำคัญมากใน Solidity หากมีข้อบกพร่องในรหัสสัญญาของเรา จะไม่มีทางแก้ไขได้ในภายหลัง ต้องบอกผู้ใช้ของเราให้เริ่มใช้ที่อยู่สัญญาอัจฉริยะอื่นด้วยการแก้ไข

ชื่อระดับแรก

ตัวแก้ไขฟังก์ชัน

สิ่งนี้ช่วยในการอัปเดตส่วนที่สำคัญของ DApp ในขณะที่ป้องกันผู้ใช้รายอื่นไม่ให้ละเมิดสัญญาของเรา กรณีการใช้งานหนึ่งที่ฉันจัดการคือ - เมื่อเราต้องการตรวจสอบความถูกต้องของคำสั่งก่อนที่จะดำเนินการกรณีการใช้งานใดๆ

gas

ผู้ใช้จ่ายค่าน้ำมันเพื่อทำสัญญาบนเครือข่าย Ethereum ก๊าซคำนวณเป็นอีเธอร์ (สกุลเงินบน Ethereum) ต้นทุนก๊าซทั้งหมดของฟังก์ชันของเราเท่ากับต้นทุนก๊าซรวมของการดำเนินงานแต่ละอย่าง

ชื่อระดับแรก

เพิ่มเติมเกี่ยวกับการจัดเก็บ

หน่วยความจำเก็บข้อมูลถูกเขียนลงในบล็อกเชนอย่างถาวร โหนดนับพันทั่วโลกจำเป็นต้องจัดเก็บข้อมูลนี้ไว้ในฮาร์ดไดรฟ์ของตน และเมื่อบล็อกเชนเติบโตขึ้น ปริมาณข้อมูลนี้ก็จะเพิ่มขึ้นเมื่อเวลาผ่านไป ดังนั้นการทำเช่นนี้จึงมาในราคา

ดังนั้นแนะนำให้ใช้ประเภทหน่วยความจำให้มากที่สุดเพื่อไม่ให้ข้อมูลถูกเก็บไว้อย่างถาวรซึ่งจะช่วยประหยัดค่าใช้จ่าย ลูปจะมีราคาถูกกว่าใน Solidity มากกว่าการใช้ที่เก็บข้อมูล ดังนั้นให้ใช้หน่วยความจำในการวนซ้ำให้มากที่สุด สิ่งนี้ตรงกันข้ามกับสิ่งที่ทำในภาษาเช่น Java, Python และอื่น ๆ เนื่องจาก for loops มีราคาแพงกว่าในการคำนวณ

ชื่อระดับแรก

ไวยากรณ์คล้ายกับ Javascript

for (uint i = 1; i <= 10; i++) { // body }

รับมือกับตัวดัดแปลง

ข้อความ

ฟังก์ชันการชำระเงินเป็นส่วนหนึ่งของสิ่งที่ทำให้ Solidity และ Ethereum ยอดเยี่ยม -- เป็นฟังก์ชันประเภทพิเศษที่สามารถรับ Ether ได้ เมื่อเราเรียกใช้ฟังก์ชัน API บนเว็บเซิร์ฟเวอร์ทั่วไป เราไม่สามารถส่งเงินดอลลาร์ในเวลาเดียวกันกับที่เราเรียกใช้ฟังก์ชันนี้ และเราไม่สามารถส่งบิตคอยน์ได้

ซึ่งช่วยให้เกิดตรรกะที่น่าสนใจบางอย่าง เช่น การจ่ายค่าธรรมเนียมในสัญญาเพื่อดำเนินการตามฟังก์ชัน

สังเกต:

ชื่อระดับแรก

โทเค็น

โดยพื้นฐานแล้ว โทเค็นเป็นเพียงสัญญาที่บันทึกว่าใครเป็นเจ้าของจำนวนโทเค็น และฟังก์ชันบางอย่างเพื่อให้ผู้ใช้เหล่านั้นสามารถโอนโทเค็นของตนไปยังที่อยู่อื่นได้

ชื่อระดับแรก

ยืนยันจะคล้ายกับต้องการและโยนข้อผิดพลาดถ้าเป็นเท็จ ความแตกต่างระหว่างการยืนยันและความต้องการคือต้องมีการคืนเงินก๊าซที่เหลืออยู่ของผู้ใช้เมื่อฟังก์ชันล้มเหลว ในขณะที่การยืนยันไม่ได้

Metamask

นี่คือส่วนขยายเบราว์เซอร์สำหรับ Chrome และ Firefox ที่ช่วยให้ผู้ใช้สามารถจัดการบัญชี Ethereum และคีย์ส่วนตัวได้อย่างปลอดภัย และใช้บัญชีเหล่านี้เพื่อโต้ตอบกับเว็บไซต์โดยใช้ Web3.js