Variables: val vs. var, Byte, Short, Int, Long, Float, Double, Boolean, Char; String, Nullable variables

📖 Theory

જે તૂટવાનું અટકાવવા Kotlin બન્યું

BCA403 માં તમે Java ની સૌથી કુખ્યાત ભૂલ જોઈ હતી: NullPointerException, એટલે કે એવા variable પર method બોલાવવી જે નીકળ્યું null. એ ચાલવાના સમયે ત્રાટકે છે, અને ઘણી વાર વપરાશકર્તાની નજર સામે જ.

Kotlin ના રચનારાઓએ આ ભૂલને મારી નાખવાનું નક્કી કર્યું, અને લગભગ સફળ થયા. Kotlin માં તમે સ્પષ્ટ છૂટ ન આપો ત્યાં સુધી variable null રાખી શકતું નથી, અને compiler એ નિયમ પળાવે છે. આ પાઠ Kotlin નાં variables, એનો val અને var વચ્ચેનો ભેદ, અને એની ખાસ ઓળખ null safety સમજાવે છે, જે Java કરતાં Kotlin પસંદ કરવાનું સૌથી મોટું એકમાત્ર કારણ છે. FestConnect Mobile નો data રચનાથી જ તૂટવા સામે ટકે એવો બનશે.

📖 Theory

val, var અને types

Kotlin માં variable માટે બે keywords છે:

• val: ફક્ત વાંચી શકાય, એક જ વાર કિંમત મળે (Java ના final જેવું). મૂળભૂત રીતે આ જ પસંદ કરો
• var: બદલી શકાય, ફરીથી કિંમત આપી શકાય

val fest = "TechnoUtsav" (બદલી ન શકાય); var seats = 350 (બદલી શકાય). Types સામાન્ય રીતે અનુમાનથી નક્કી થાય છે (val x = 5 એ Int છે), અથવા સ્પષ્ટ રીતે જાહેર થાય છે (val x: Int = 5).

Types તમને Java માંથી જાણીતા છે: Byte, Short, Int, Long, Float (f પ્રત્યય સાથે), Double, Boolean, Char (એકવડા અવતરણમાં), String (બેવડા અવતરણમાં, $ વાળા templates સાથે). val પસંદ કરવાથી code વધુ સલામત અને સ્પષ્ટ બને છે: એ સંકેત આપે છે કે 'આ બદલાવાનું નથી', અને compiler એ પળાવે છે.

📖 Theory

Null safety: Kotlin ની ખાસ ઓળખ

Kotlin ને વ્યાખ્યાયિત કરતો વિચાર આ રહ્યો. મૂળભૂત રીતે કોઈ પણ type null રાખી શકતો નથી:

val name: String = null એ COMPILE ERROR છે.

Null ની છૂટ આપવા માટે તમે type ને ? વડે nullable બનાવો છો:

val name: String? = null ચાલે છે.

એનાથી તમારે શરૂઆતમાં જ નક્કી કરવું પડે છે કે કિંમત null હોઈ શકે કે નહીં, અને compiler તમારી પાસે nullable કિસ્સો સલામત રીતે સંભાળાવે છે. Nullable કિંમત વાપરવા માટે:

• safe call `?.`: name?.length લંબાઈ પાછી આપે છે, અથવા name null હોય તો null (કશું તૂટતું નથી)
• Elvis `?:`: name?.length ?: 0 null હોય ત્યારે મૂળભૂત કિંમત (0) આપે છે
• not-null assertion `!!`: name!!.length બળજબરીથી વાપરે છે, અને null હોય તો exception ફેંકે છે (ભાગ્યે જ વાપરો)

Nullability type નો જ ભાગ હોવાથી અને compile ના સમયે તપાસાતી હોવાથી, મોટા ભાગની NullPointerExceptions શક્ય જ રહેતી નથી.

⌨️ Practical

Null safety કામ કરતું જુઓ

fun main() {
    val fest: String = "TechnoUtsav"   // non-null: cannot be null
    // val bad: String = null          // COMPILE ERROR

    var nickname: String? = null       // nullable: ? allows null

    // Safe call: returns null instead of crashing
    println(nickname?.length)          // null (nickname is null)

    nickname = "Techno"
    println(nickname?.length)          // 6

    // Elvis operator: a default when null
    val len = nickname?.length ?: 0    // 6 here; 0 if null
    println(len)
}

🧩 Quiz

Kotlin માં val name: String = null લખવાથી શું થાય છે?

1. એ ચાલે છે: name માં null રહે છે
2. COMPILE ERROR: non-nullable String માં null ન રહી શકે; null ની છૂટ આપવા એને String? જાહેર કરવો પડે
3. ચાલવાના સમયે NullPointerException
4. name ખાલી string બની જાય છે

💭 Think first

Kotlin NullPointerException ને કઈ રીતે મારી નાખે છે

Java માં (BCA403) તમે null પર method બોલાવો ત્યારે NullPointerException ચાલવાના સમયે ત્રાટકે છે. Kotlin ની રચના એને વપરાશકર્તા સુધી પહોંચતાં જ કઈ રીતે અટકાવે છે? વિચારીને પછી tap કરો.

⚠️ Watch out

Variable અને null safety ની જાળો

val ને ફરી કિંમત આપવી: val ફક્ત વાંચી શકાય એવું છે; બદલવું જ પડે તો var વાપરો.

!! નો અતિરેક: not-null assertion !! એ જ તૂટવાનું જોખમ પાછું લાવે છે જે Kotlin એ દૂર કર્યું હતું; એને બદલે ?. અને ?: પસંદ કરો.

ખરેખર nullable data માટે ? ભૂલી જવું: network કે form માંથી આવતો data null હોઈ શકે; એનો type nullable રાખો અને એને સંભાળો.

f વગરનું Float: 3.5 એ Double છે; Float માટે 3.5f જોઈએ.

મૂળભૂત રીતે var વાપરવું: ફરી કિંમત આપવાની જરૂર ન હોય ત્યાં સુધી val પસંદ કરો; એ વધુ સલામત અને વધુ સ્પષ્ટ છે.

📖 Theory

Data સલામત થયો; હવે નિર્ણયો

FestConnect Mobile નાં variables હવે type વાળાં અને null-safe છે. હવે app ને નિર્ણયો લેવા પડશે: Kotlin નું if અને, ખાસ કરીને, એનું શક્તિશાળી when expression (વધુ ધારદાર switch), સાથે ranges. Kotlin નો એક વળાંક તમને ગમશે: if અને when એ expressions છે જે કિંમત પાછી આપે છે, ફક્ત statements નથી. હવે પછી શરતો આવે છે, પછી arrays તથા lists અને loops Kotlin ની પાયાની વાતો પૂરી કરે છે.

✅ Summary

Key takeaways

• val ફક્ત વાંચી શકાય એવું છે (એક જ વાર કિંમત, Java ના final જેવું); var બદલી શકાય એવું છે; મૂળભૂત રીતે val પસંદ કરો.
• Types સામાન્ય રીતે અનુમાનથી નક્કી થાય (val x = 5 એ Int) કે જાહેર કરાય (val x: Int = 5); જાણીતો સમૂહ: Byte, Short, Int, Long, Float (f), Double, Boolean, Char, String.
• Null safety: મૂળભૂત રીતે કોઈ type null રાખી શકતો નથી; val name: String = null એ compile error છે.
• Type ને ? વડે nullable બનાવો: val name: String? = null માં null ચાલે છે.
• Nullable કિંમતો safe call ?. (તૂટવાને બદલે null), Elvis ?: (મૂળભૂત કિંમત) કે !! (બળજબરી, null હોય તો exception: ભાગ્યે જ) વડે સંભાળો.
• Nullability type નો ભાગ છે અને compile ના સમયે તપાસાય છે, જેથી મોટા ભાગની NullPointerExceptions (Java માં ચાલતી વખતે તૂટવું) નાબૂદ થાય છે.
• યાદ રાખવાની કડી: var કરતાં val, null ની છૂટ માટે ?, એને સલામત રીતે સંભાળવા ?. અને ?:, અને !! ફક્ત ખાતરી હોય ત્યારે.