Ruby-ல் variables மற்றும் basic types எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Ruby **dynamically typed** — variables-ஆனது type declare செய்யாது மற்றும் எந்த மதிப்பையும் வைத்திருக்கலாம். Ruby-ல் பல basic types உள்ளன (அனைத்தும் objects), மற்றும் **naming conventions** (sigils)-ஐ variable scope-ஐ குறிக்க பயன்படுத்துகிறது.

## Variables மற்றும் dynamic typing

```ruby
count = 42           # no type declaration — inferred
name = "Ann"
count = "now a string"   # dynamically typed — can change type
```

## Basic types (அனைத்தும் objects)

```ruby
42              # Integer
3.14            # Float
"hello"         # String
:symbol         # Symbol (an immutable, interned identifier)
true / false    # Boolean (TrueClass / FalseClass)
nil             # NilClass — "nothing" (Ruby's null)
[1, 2, 3]       # Array
{ a: 1 }        # Hash (key-value)
1..10           # Range
```

## Variable naming conventions scope-ஐ குறிக்கிறது

```ruby
name        = "local"      # local variable (lowercase)
@instance   = "instance"   # @ → INSTANCE variable (per object)
@@class_var = "class"      # @@ → CLASS variable (shared across instances)
$global     = "global"     # $ → global variable (avoid)
CONSTANT    = "constant"   # Uppercase start → CONSTANT (convention; can change with warning)
```

Ruby **sigils** (prefixes)-ஐ variable scope-ஐ குறிக்க பயன்படுத்துகிறது: plain names local ஆகும், `@` instance variables-க்கு, `@@` class variables-க்கு, `$` globals-க்கு (discouraged), மற்றும் uppercase constants-க்கு. இது distinctive — prefix-ஆனது ஒரு பார்வையில் scope-ஐ உங்களுக்கு சொல்கிறது.

## Truthiness (ஒரு Ruby quirk)

```ruby
# in Ruby, ONLY false and nil are falsy — EVERYTHING else is truthy
puts "truthy" if 0        # prints — 0 is TRUTHY in Ruby! (unlike many languages)
puts "truthy" if ""        # prints — empty string is truthy too
puts "falsy" unless nil    # nil is falsy
```

**Ruby-ல் `false` மற்றும் `nil` மட்டுமே falsy** — `0`, `""`, மற்றும் `[]` அனைத்தும் truthy (பல மொழிகளில் போல் அல்ல, அங்கு 0/empty falsy ஆகும்). ஒரு பொதுவான gotcha.

## இது ஏன் முக்கியமானது

Ruby-ல் variables மற்றும் basic types-ஐ புரிந்துகொள்வது அடிப்படை அன்றாட ஞ்ஞான.

Ruby dynamically typed (variables எந்த மதிப்பையும் வைத்திருக்கலாம், type declarations இல்லை), மற்றும் distinctive feature-ஆனது variable scope-ஐ குறிக்க **naming conventions (sigils)-ஐ பயன்படுத்துதல்** — `@` instance variables-க்கு, `@@` class variables-க்கு, `$` globals-க்கு, uppercase constants-க்கு — எனவே variable-ஆனது prefix-ஆனது ஒரு பார்வையில் scope-ஐ உங்களுக்கு சொல்கிறது, இது Ruby-ஐ சரியாக படித்தல் மற்றும் எழுதுவதற்கு முக்கியமானது (குறிப்பாக `@instance` variables, classes-ல் தொடர்ந்து பயன்படுத்தப்படுகிறது).

Basic types-ஐ தெரிந்துகொள்வது (அனைத்தும் Ruby-ல் pure object-oriented model-ல் objects ஆகும்) — distinctive **Symbol** type உட்பட — data-ஆனது செயல்பட அவசியம்.

Ruby-ல் **truthiness**-ஐ புரிந்துகொள்வது குறிப்பாக முக்கியமான quirk ஆகும்: **`false` மற்றும் `nil` மட்டுமே falsy**, மற்றும் அனைத்தும் (including `0`, `""`, மற்றும் `[]`) truthy — இது பல மொழிகளிலிருந்து வேறுபட்டு (0 அல்லது empty values falsy ஆகும்) மற்றும் மற்ற மொழிகளிலிருந்து வரும் developers-க்கு bugs-ஆனது பொதுவான source ஆகும்.

Dynamic typing, scope-indicating naming conventions, basic types, மற்றும் குறிப்பாக false-and-nil-only truthiness rule-ஐ புரிந்துகொள்வது correct Ruby-ஐ எழுதுவதற்கும் பொதுவான pitfalls-ஐ தவிர்ப்பதற்கும் foundational ஆகும், இது language-க்கு essential, must-know knowledge ஆகிறது.