Scala for Backend Engineering & Functional Programming · บทเรียน

ไวยากรณ์และชนิดข้อมูลพื้นฐาน

ทำความเข้าใจไวยากรณ์พื้นฐานของ Scala การประกาศตัวแปร (val/var) ชนิดข้อมูลทั่วไป และตัวดำเนินการพื้นฐาน

ไวยากรณ์และชนิดข้อมูลพื้นฐาน เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

ไวยากรณ์ที่กระชับของสกาลา

ยินดีต้อนรับสู่ไวยากรณ์พื้นฐานของสกาลา! สกาลาได้รับการออกแบบให้กระชับและสื่อความหมายได้ดี จึงมักช่วยให้คุณเขียนโค้ดน้อยลงแต่ทำงานได้มากขึ้น

ต่างจากภาษาบางภาษา โดยทั่วไปไม่จำเป็นต้องใส่เครื่องหมายอัฒภาคท้ายบรรทัด หากมีคำสั่งเพียงรายการเดียว ซึ่งช่วยให้โค้ดดูสะอาดตา

นิพจน์คือหัวใจสำคัญ

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

แม้แต่การคำนวณง่าย ๆ หรือบล็อกเงื่อนไขก็สามารถส่งคืนค่าได้

ลองเรียกใช้ตัวอย่างนี้:

object Main {
  def main(args: Array[String]): Unit = {
    val x = 5 + 3
    println(s"The value of x is: $x")

    val message = if (x > 7) "Greater than 7" else "Not greater than 7"
    println(message)
  }
}

`val`: ค่าที่เปลี่ยนแปลงไม่ได้

เมื่อคุณประกาศตัวแปรโดยใช้ val คุณกำลังสร้างค่าที่เปลี่ยนแปลงไม่ได้ ซึ่งหมายความว่าเมื่อกำหนดค่าแล้ว ค่านั้นจะไม่สามารถเปลี่ยนแปลงได้

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

ลองดู:

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "Hello, Coddy!"
    println(greeting)
    // greeting = "New message" // This would cause a compile error!
  }
}

`var`: ตัวแปรที่เปลี่ยนแปลงได้

บางครั้งคุณต้องใช้ตัวแปรที่สามารถเปลี่ยนค่าได้ สำหรับกรณีนี้ สกาลามี var สำหรับตัวแปรที่เปลี่ยนแปลงได้

แม้จะมีประโยชน์ แต่แนวปฏิบัติที่ดีในสกาลาคือเลือกใช้ val แทน var เมื่อทำได้ เพื่อยึดแนวคิดค่าที่เปลี่ยนแปลงไม่ได้และรูปแบบเชิงฟังก์ชัน

ดูการทำงานของ `var`:

object Main {
  def main(args: Array[String]): Unit = {
    var counter = 0
    println(s"Initial counter: $counter")
    counter = counter + 1
    println(s"New counter: $counter")
  }
}

ตัวเลข: Int, Long, Double

สกาลารองรับชนิดข้อมูลตัวเลขทั่วไป โดยคอมไพเลอร์มักอนุมานชนิดข้อมูลให้ได้ แต่คุณสามารถระบุชนิดข้อมูลเองได้

Int: สำหรับจำนวนเต็ม (เช่น 10)
Long: สำหรับจำนวนเต็มขนาดใหญ่ (เติมท้ายด้วย L เช่น 10000000000L)
Double: สำหรับจำนวนทศนิยม (เช่น 3.14)

ตัวอย่างมีดังนี้:

object Main {
  def main(args: Array[String]): Unit = {
    val anInt = 42
    val aLong = 1234567890123L
    val aDouble = 3.14159

    println(s"Int: $anInt")
    println(s"Long: $aLong")
    println(s"Double: $aDouble")
  }
}

ชนิดข้อมูล Boolean และ Char

นอกเหนือจากตัวเลข สกาลายังมีชนิดข้อมูลสำหรับค่าความจริงและอักขระเดี่ยว:

Boolean: แทนค่าความจริง ซึ่งเป็น true หรือ false
Char: เก็บอักขระเดี่ยว โดยเขียนไว้ภายในเครื่องหมายอัญประกาศเดี่ยว (เช่น 'A')

ชนิดข้อมูลเหล่านี้เป็นพื้นฐานสำคัญสำหรับตรรกะและการประมวลผลข้อความ

ตัวอย่าง:

object Main {
  def main(args: Array[String]): Unit = {
    val isActive = true
    val initial = 'C'

    println(s"Is active? $isActive")
    println(s"Initial character: $initial")
  }
}

สตริงและข้อความ

ชนิดข้อมูล String ใช้สำหรับลำดับของอักขระหรือข้อความ สตริงในสกาลาไม่สามารถเปลี่ยนแปลงได้เช่นเดียวกับใน Java

ความสามารถที่มีประโยชน์มากคือ การแทรกค่าในสตริง ซึ่งช่วยให้คุณฝังนิพจน์ลงในค่าสตริงได้โดยตรง โดยใช้คำนำหน้า s และ $ สำหรับตัวแปร

ลองดู:

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Coddy"
    val age = 3

    val greeting = s"Hello, my name is $name and I am $age years old."
    println(greeting)

    val mathResult = s"Two plus two is ${2 + 2}"
    println(mathResult)
  }
}

ตัวดำเนินการเลขคณิตพื้นฐาน

สกาลามีตัวดำเนินการเลขคณิตมาตรฐานสำหรับคำนวณตัวเลข:

+ (การบวก)
- (การลบ)
* (การคูณ)
/ (การหาร)
% (มอดูโล - เศษจากการหาร)

ตัวดำเนินการเหล่านี้ทำงานตามที่คาดไว้ โดยส่งคืนค่าตัวเลขใหม่

มาลองคำนวณกัน:

object Main {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 3

    println(s"Addition: ${a + b}")
    println(s"Subtraction: ${a - b}")
    println(s"Multiplication: ${a * b}")
    println(s"Division: ${a / b} (integer division)")
    println(s"Modulo: ${a % b}")

    val c = 10.0
    val d = 3.0
    println(s"Float Division: ${c / d}")
  }
}

ตัวดำเนินการเปรียบเทียบ

ตัวดำเนินการเปรียบเทียบใช้เปรียบเทียบค่าสองค่า และจะส่งคืนค่า Boolean (true หรือ false) เสมอ

== (เท่ากับ)
!= (ไม่เท่ากับ)
< (น้อยกว่า)
> (มากกว่า)
<= (น้อยกว่าหรือเท่ากับ)
>= (มากกว่าหรือเท่ากับ)

ตัวดำเนินการเหล่านี้จำเป็นอย่างยิ่งสำหรับการควบคุมลำดับการทำงานและการตัดสินใจ

object Main {
  def main(args: Array[String]): Unit = {
    val x = 10
    val y = 5

    println(s"x == y: ${x == y}")
    println(s"x != y: ${x != y}")
    println(s"x > y: ${x > y}")
    println(s"x <= y: ${x <= y}")
  }
}

ตรวจสอบอย่างรวดเร็ว: ตัวแปรและตัวดำเนินการ

พิจารณาส่วนย่อยของโค้ดสกาลาต่อไปนี้:

object Main {
  def main(args: Array[String]): Unit = {
    val num1 = 7
    var num2 = 3
    num2 = num1 * 2
    val finalResult = num1 + num2 - 5
    println(finalResult)
  }
}

สรุป: ไวยากรณ์และชนิดข้อมูล

ทำได้ดีมาก! ในบทเรียนนี้ คุณได้เรียนรู้พื้นฐานไวยากรณ์ของสกาลา รวมถึงการใช้นิพจน์และลักษณะที่เครื่องหมายอัฒภาคเป็นตัวเลือก

เราได้เรียนรู้วิธีประกาศตัวแปรโดยใช้ val สำหรับค่าที่เปลี่ยนแปลงไม่ได้ และ var สำหรับค่าที่เปลี่ยนแปลงได้ นอกจากนี้ คุณยังคุ้นเคยกับชนิดข้อมูลทั่วไป เช่น Int, Long, Double, Boolean, Char และ String รวมถึงการแทรกค่าในสตริงที่มีประโยชน์

สุดท้าย คุณได้ฝึกใช้ตัวดำเนินการเลขคณิตและการเปรียบเทียบพื้นฐานเพื่อคำนวณและตรวจสอบทางตรรกะ หมั่นฝึกฝนพื้นฐานเหล่านี้ต่อไป เพราะเป็นรากฐานสำหรับโปรแกรมสกาลาที่ซับซ้อนยิ่งขึ้น!

คำถามที่พบบ่อย

บทเรียน “ไวยากรณ์และชนิดข้อมูลพื้นฐาน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ไวยากรณ์และชนิดข้อมูลพื้นฐาน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 3 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ไวยากรณ์และชนิดข้อมูลพื้นฐาน”

ทำความเข้าใจไวยากรณ์พื้นฐานของ Scala การประกาศตัวแปร (val/var) ชนิดข้อมูลทั่วไป และตัวดำเนินการพื้นฐาน คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 3 บทเรียน

บทเรียน “ไวยากรณ์และชนิดข้อมูลพื้นฐาน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

เริ่มต้นใช้งาน Scala
ไวยากรณ์และชนิดข้อมูลพื้นฐาน
โครงสร้างควบคุมและฟังก์ชัน

← กลับไปที่ Scala for Backend Engineering & Functional Programming