بتل کد Battle Codeدارد باز می‌شود…

بازی، هوش مصنوعی و امنیت

پارادایم‌های برنامه‌نویسی: رویه‌ای، شیءگرا، تابعی و رویدادمحور

۱۳ دقیقه مطالعه · ۲۸ مهر ۱۴۰۵

فهرست مطالب
  1. پارادایم یعنی چه؟ دو خانواده‌ی بزرگ دستوری و اعلانی
  2. برنامه‌نویسی رویه‌ای (Procedural): دستورها و تابع‌ها
  3. برنامه‌نویسی شیءگرا (OOP): کلاس، شیء و چهار اصل مهم
  4. برنامه‌نویسی تابعی (Functional): تابع خالص، map و filter
  5. برنامه‌نویسی رویدادمحور (Event-Driven): کلیک، کلید و واکنش
  6. مدل‌های دیگر: منطقی، اعلانی و همروند
  7. کدام زبان از کدام پارادایم پشتیبانی می‌کند؟
  8. یک نوجوان اول کدام مدل برنامه‌نویسی را یاد بگیرد؟
  9. سؤال‌های پرتکرار

پارادایم برنامه‌نویسی (programming paradigm) یعنی یک سبک یا شیوه‌ی فکر کردن برای نوشتن و سازمان‌دادن کد. مهم‌ترین مدل‌های برنامه‌نویسی عبارت‌اند از رویه‌ای (برنامه به‌شکل دنباله‌ای از دستورها و تابع‌ها)، شیءگرا (برنامه به‌شکل شیءهایی که داده و رفتار خودشان را دارند)، تابعی (برنامه به‌شکل ترکیب تابع‌هایی بدون اثر جانبی) و رویدادمحور (برنامه‌ای که منتظر می‌ماند و به کلیک و کلید واکنش نشان می‌دهد).

پارادایم با زبان فرق دارد. زبان ابزار است و پارادایم روش استفاده از آن. بیشتر زبان‌های امروزی، از جمله پایتون و جاوااسکریپت، چندپارادایمی هستند؛ یعنی می‌توانید در یک برنامه، هم تابع ساده بنویسید، هم کلاس بسازید و هم به رویدادها واکنش نشان دهید. در این مقاله هر مدل را با مثال‌های کوتاه پایتون و جاوااسکریپت توضیح می‌دهیم و در پایان می‌گوییم یک نوجوان بهتر است از کدام شروع کند.

پارادایم یعنی چه؟ دو خانواده‌ی بزرگ دستوری و اعلانی

فرض کنید می‌خواهید یک ساندویچ داشته باشید. یک راه این است که قدم‌به‌قدم بگویید: «نان را بردار، از وسط ببُر، پنیر را بگذار، گوجه را حلقه کن…». راه دیگر این است که در ساندویچی بگویید: «یک ساندویچ پنیر و گوجه لطفاً». نتیجه یکی است، اما شیوه‌ی بیان فرق دارد. پارادایم‌های برنامه‌نویسی هم دقیقاً همین تفاوت را دارند.

برنامه‌نویسی دستوری (Imperative)

در سبک دستوری به کامپیوتر می‌گویید چطور کار را انجام دهد: دستورها را به ترتیب اجرا کن، این متغیر را عوض کن، این حلقه را تکرار کن. بیشتر کدهایی که تازه‌کارها می‌نویسند دستوری است. برنامه‌نویسی رویه‌ای و شیءگرا هر دو زیرمجموعه‌ی همین خانواده‌اند.

برنامه‌نویسی اعلانی (Declarative)

در سبک اعلانی می‌گویید چه می‌خواهید و تصمیم درباره‌ی چگونگی انجامش را به زبان یا سیستم می‌سپارید. SQL، HTML و برنامه‌نویسی تابعی و منطقی در این خانواده‌اند. به این دو روش برای جمع کردن یک لیست نگاه کنید:

nums = [4, 7, 1, 9]

# دستوری: قدم‌به‌قدم می‌گوییم چطور جمع کند
total = 0
for n in nums:
    total += n

# اعلانی‌تر: فقط می‌گوییم چه می‌خواهیم
total = sum(nums)
print(total)   # 21

هر دو روش جواب ۲۱ می‌دهند. در روش اول خودمان متغیر total را می‌سازیم و در هر دور حلقه به‌روز می‌کنیم. در روش دوم فقط می‌گوییم «مجموع این لیست» و جزئیات به عهده‌ی پایتون است.

برنامه‌نویسی رویه‌ای (Procedural): دستورها و تابع‌ها

برنامه‌نویسی رویه‌ای قدیمی‌ترین و ساده‌ترین سبک رایج است. برنامه دنباله‌ای از دستورهاست که از بالا به پایین اجرا می‌شود، و کارهای تکراری در قالب تابع (function) یا «رویه» بسته‌بندی می‌شوند تا بارها از آن‌ها استفاده شود. زبان C نمونه‌ی کلاسیک این سبک است و Pascal و Fortran هم از زبان‌های مشهور آن بودند.

def average(numbers):
    return sum(numbers) / len(numbers)

def report(name, numbers):
    avg = average(numbers)
    status = "pass" if avg >= 10 else "try again"
    print(f"{name}: {avg:.1f} ({status})")

report("Sara", [18, 17, 20])   # Sara: 18.3 (pass)
report("Reza", [9, 11, 8])     # Reza: 9.3 (try again)

اینجا مسئله به دو تابع کوچک شکسته شده است: average میانگین را حساب می‌کند و report نتیجه را چاپ می‌کند. هر تابع یک کار مشخص دارد و می‌شود آن را جداگانه آزمایش کرد. این همان فکری است که در جلسه‌های دستورهای خودم و تابع‌هایی که جواب می‌دهند در دوره‌ی پایتون تمرین می‌شود.

نقطه‌ی قوت سبک رویه‌ای سادگی است و برای برنامه‌های کوچک و متوسط عالی است. اما وقتی برنامه بزرگ می‌شود و ده‌ها تابع روی داده‌های مشترک کار می‌کنند، پیگیری این‌که چه کسی کدام داده را تغییر داده سخت می‌شود. اینجاست که شیءگرایی به کمک می‌آید.

برنامه‌نویسی شیءگرا (OOP): کلاس، شیء و چهار اصل مهم

در برنامه‌نویسی شیءگرا (Object-Oriented Programming) برنامه از شیء‌ها (objects) ساخته می‌شود. هر شیء هم داده دارد (ویژگی‌ها) و هم رفتار (متدها). در یک بازی، هر بازیکن، هر دشمن و هر سکه می‌تواند یک شیء باشد. زبان‌هایی مثل جاوا، C#، C++، پایتون و کاتلین از شیءگرایی پشتیبانی کامل دارند.

کلاس و شیء

کلاس (class) نقشه یا قالب ساختن شیء است و شیء نمونه‌ای واقعی که از روی آن ساخته می‌شود. مثل نقشه‌ی یک خانه و خانه‌هایی که از روی آن ساخته می‌شوند:

class Player:
    def __init__(self, name, hp=100):
        self.name = name     # ویژگی: نام
        self.hp = hp         # ویژگی: جان

    def take_damage(self, amount):
        self.hp = max(0, self.hp - amount)
        print(f"{self.name}: {self.hp} HP")

ali = Player("Ali")
sara = Player("Sara", 120)
ali.take_damage(30)    # Ali: 70 HP
sara.take_damage(50)   # Sara: 70 HP

Player کلاس است و ali و sara دو شیء جدا از آن. متد __init__ هنگام ساخته شدن هر شیء اجرا می‌شود و self به همان شیئی اشاره می‌کند که متد رویش صدا زده شده است. این مفهوم در جلسه‌ی کلاس و نمونه از دوره‌ی پایتون حرفه‌ای با جزئیات آموزش داده می‌شود.

کپسوله‌سازی (Encapsulation)

کپسوله‌سازی یعنی داده‌های درونی شیء را پنهان کنیم و فقط از راه متدهای مشخص اجازه‌ی تغییرشان را بدهیم. این‌طوری کسی نمی‌تواند به‌اشتباه مقدار نامعتبری در آن بگذارد:

class PiggyBank:
    def __init__(self):
        self._coins = 0    # «_» یعنی: از بیرون مستقیم دست نزن

    def add(self, amount):
        if amount <= 0:
            raise ValueError("amount must be positive")
        self._coins += amount

    @property
    def coins(self):
        return self._coins

bank = PiggyBank()
bank.add(50)
print(bank.coins)   # 50

در پایتون، خط زیرین (_) اول نام یک قرارداد بین برنامه‌نویس‌هاست، نه قفل واقعی؛ اما زبان‌هایی مثل جاوا و C# کلمه‌هایی مثل private دارند که دسترسی را واقعاً محدود می‌کنند. با @property می‌توانیم مقدار را بخوانیم، بی‌آن‌که اجازه‌ی تغییر مستقیمش را بدهیم. ادامه‌ی این موضوع در جلسه‌ی کپسوله‌سازی و property است.

وراثت (Inheritance) و چندریختی (Polymorphism)

وراثت یعنی یک کلاس می‌تواند ویژگی‌ها و رفتارهای کلاس دیگری را به ارث ببرد و فقط چیزهای تازه یا متفاوت را اضافه کند. چندریختی یعنی شیءهای مختلف می‌توانند به یک پیام یکسان، هر کدام به روش خودشان جواب بدهند:

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "..."

class Cat(Animal):
    def speak(self):
        return "Meow"

class Dog(Animal):
    def speak(self):
        return "Woof"

for pet in [Cat("Pishi"), Dog("Hapoo")]:
    print(pet.name, pet.speak())

Cat و Dog هر دو از Animal ارث می‌برند، پس ویژگی name را بدون نوشتن دوباره دارند. در حلقه‌ی آخر، برنامه فقط speak() را صدا می‌زند و لازم نیست بداند با گربه طرف است یا سگ؛ هر شیء جواب خودش را می‌دهد. این همان چندریختی است. یک نکته‌ی حرفه‌ای: وراثت زیاد کد را پیچیده می‌کند و برنامه‌نویس‌های باتجربه اغلب ترکیب (composition) را ترجیح می‌دهند؛ یعنی شیئی که شیء دیگری را درون خودش دارد. هر دو روش در جلسه‌ی وراثت و ترکیب مقایسه شده‌اند.

چهار اصل شیءگرایی معمولاً این‌ها شمرده می‌شوند: کپسوله‌سازی، وراثت، چندریختی و انتزاع (abstraction)، یعنی نشان دادن فقط چیزهای لازم و پنهان کردن جزئیات پیچیده.

برنامه‌نویسی تابعی (Functional): تابع خالص، map و filter

در برنامه‌نویسی تابعی برنامه از ترکیب تابع‌ها ساخته می‌شود، شبیه تابع‌های ریاضی. تابع‌ها مثل هر داده‌ی دیگری رفتار می‌کنند: می‌شود آن‌ها را در متغیر گذاشت، به تابع دیگری داد یا از تابعی برگرداند. زبان‌هایی مثل Haskell، Elixir، Clojure و F# بیشتر بر این سبک تکیه دارند، اما پایتون، جاوااسکریپت، کاتلین و Rust هم ابزارهای تابعی زیادی دارند.

تابع خالص (Pure Function)

تابع خالص دو ویژگی دارد: با ورودی یکسان همیشه خروجی یکسان می‌دهد، و هیچ اثر جانبی (side effect) ندارد؛ یعنی چیزی بیرون از خودش را تغییر نمی‌دهد:

# ناخالص: به متغیر بیرونی وابسته است و آن را تغییر می‌دهد
total = 0
def add_to_total(x):
    global total
    total += x
    return total

# خالص: فقط به ورودی‌هایش وابسته است
def add(a, b):
    return a + b

اگر add_to_total(5) را دو بار صدا بزنید، دو جواب متفاوت می‌گیرید (۵ و ۱۰)، اما add(2, 3) همیشه ۵ است. تابع‌های خالص را خیلی راحت‌تر می‌شود آزمایش کرد، فهمید و بدون ترس از تداخل، هم‌زمان اجرا کرد.

map، filter و lambda

دو ابزار کلاسیک تابعی map (یک تابع را روی همه‌ی عضوها اجرا کن) و filter (فقط عضوهایی را نگه دار که شرط را دارند) هستند. lambda هم راهی برای نوشتن یک تابع کوچک و بی‌نام در یک خط است:

scores = [12, 18, 9, 20, 15]

passed = list(filter(lambda s: s >= 10, scores))
bonus = list(map(lambda s: min(s + 1, 20), passed))
print(passed)   # [12, 18, 20, 15]
print(bonus)    # [13, 19, 20, 16]

# همین کار با comprehension، که در پایتون رایج‌تر است:
bonus2 = [min(s + 1, 20) for s in scores if s >= 10]

این کد هیچ حلقه‌ی صریح و هیچ متغیر شمارنده‌ای ندارد؛ فقط می‌گوید چه چیزی را از چه چیزی بسازد. تابع‌هایی که تابع دیگری را ورودی می‌گیرند، تابع مرتبه‌بالا (higher-order function) نام دارند و در جلسه‌های Comprehensionها و تابع‌های مرتبه‌بالا آموزش داده می‌شوند. در جاوااسکریپت هم همین کار با scores.filter(...) و scores.map(...) انجام می‌شود.

تغییرناپذیری (Immutability)

در سبک تابعی به جای تغییر دادن داده‌ی قبلی، داده‌ی تازه می‌سازیم. این کار جلوی خطاهایی را می‌گیرد که در آن بخشی از برنامه، داده‌ای را عوض می‌کند که بخش دیگر هنوز به آن نیاز داشت:

point = (3, 4)               # تاپل تغییرناپذیر است
moved = (point[0] + 1, point[1])

nums = [3, 1, 2]
ordered = sorted(nums)       # لیست تازه می‌سازد
print(nums, ordered)         # [3, 1, 2] [1, 2, 3]

تابع sorted لیست اصلی را دست نمی‌زند و نسخه‌ی مرتب‌شده‌ی تازه‌ای برمی‌گرداند، در حالی که متد nums.sort() خود لیست را تغییر می‌دهد. انتخاب آگاهانه بین این دو، یکی از نشانه‌های فکر تابعی است. بازگشت (recursion) هم ابزار مهم این سبک است که در جلسه‌ی بازگشت می‌بینید.

برنامه‌نویسی رویدادمحور (Event-Driven): کلیک، کلید و واکنش

در برنامه‌نویسی رویدادمحور برنامه از بالا به پایین اجرا نمی‌شود و تمام نمی‌شود؛ منتظر می‌ماند تا رویدادی (event) رخ دهد، مثل کلیک موس، فشردن کلید یا رسیدن یک پیام، و بعد تابعی را که برای آن رویداد تعیین شده اجرا می‌کند. به این تابع گرداننده‌ی رویداد (event handler) می‌گویند. تقریباً همه‌ی سایت‌ها، اپ‌های موبایل، بازی‌ها و برنامه‌های پنجره‌ای این‌طور کار می‌کنند.

کلیک روی دکمه در جاوااسکریپت

<button id="hello">Say hello</button>
<p id="out"></p>
<script>
  const btn = document.getElementById("hello");
  btn.addEventListener("click", () => {
    document.getElementById("out").textContent = "Hello!";
  });
</script>

با addEventListener به مرورگر می‌گوییم «هر وقت روی این دکمه کلیک شد، این تابع را اجرا کن». تا وقتی کسی کلیک نکند، آن تابع اجرا نمی‌شود. این دقیقاً موضوع جلسه‌ی دکمه‌هایی که کار می‌کنند در دوره‌ی وب است.

فشردن کلید در Pygame Zero

در بازی‌سازی با Pygame Zero هم همین ایده را می‌بینید. تابع‌هایی با نام‌های مشخص مثل draw و on_key_down را می‌نویسید و خود Pygame Zero در لحظه‌ی مناسب صدایشان می‌زند:

WIDTH = 400
HEIGHT = 300
x = 200

def draw():
    screen.clear()
    screen.draw.filled_circle((x, 150), 20, "orange")

def on_key_down(key):
    global x
    if key == keys.LEFT:
        x -= 20
    elif key == keys.RIGHT:
        x += 20

هیچ‌جای این کد on_key_down را خودمان صدا نزده‌ایم. هر بار که بازیکن کلیدی را فشار می‌دهد، Pygame Zero این تابع را با کلید فشرده‌شده اجرا می‌کند و دایره جابه‌جا می‌شود. کار با صفحه‌کلید در جلسه‌ی صفحه‌کلید و موس در جلسه‌ی موس از دوره‌ی بازی‌سازی آموزش داده می‌شود.

مدل‌های دیگر: منطقی، اعلانی و همروند

برنامه‌نویسی منطقی (Logic)

در برنامه‌نویسی منطقی به جای دستور، حقیقت‌ها و قاعده‌ها را می‌نویسید و از سیستم سؤال می‌پرسید تا خودش جواب را استنتاج کند. معروف‌ترین زبان این سبک Prolog است که آلن کولمروئر و همکارانش در فرانسه در سال ۱۹۷۲ ساختند:

parent(ali, sara).
parent(sara, reza).
grandparent(X, Z) :- parent(X, Y), parent(Y, Z).

?- grandparent(ali, Who).
Who = reza.

دو خط اول حقیقت‌اند (علی پدر یا مادر ساراست و سارا پدر یا مادر رضا). خط سوم قاعده است: X پدربزرگ یا مادربزرگ Z است اگر یک Y وجود داشته باشد که فرزند X و والد Z باشد. Prolog خودش جست‌وجو می‌کند و به جواب reza می‌رسد.

SQL و HTML: اعلانی‌های روزمره

دو زبانی که هر روز با سبک اعلانی کار می‌کنند، SQL و HTML هستند. در SQL می‌نویسید SELECT name FROM students WHERE score > 17 و هیچ‌وقت نمی‌گویید پایگاه داده چطور جدول را بگردد؛ این کار خود سیستم است. در HTML هم با <h1> و <ul> می‌گویید صفحه چه دارد و مرورگر تصمیم می‌گیرد چطور آن را رسم کند. توضیح بیشتر را در مقاله‌های SQL و HTML و CSS ببینید.

برنامه‌نویسی همروند (Concurrent)

در برنامه‌نویسی همروند چند کار در یک بازه‌ی زمانی پیش می‌روند؛ مثلاً یک سرور هم‌زمان به هزاران کاربر جواب می‌دهد، یا اپ در حالی که فایلی را دانلود می‌کند، همچنان به لمس‌های شما واکنش نشان می‌دهد. زبان Go با goroutineها، جاوااسکریپت و پایتون با async و await، و Erlang و Elixir با مدل پیام‌رسانی میان فرایندها ابزارهای قوی برای این کار دارند. همروندی موضوعی پیشرفته است و بهتر است بعد از محکم شدن پایه‌ها سراغش بروید.

کدام زبان از کدام پارادایم پشتیبانی می‌کند؟

زبانپارادایم‌های اصلینکته
پایتونرویه‌ای، شیءگرا، تابعی (تا حدی)برای یادگیری همه‌ی سبک‌ها عالی است
جاوااسکریپترویدادمحور، تابعی، شیءگرا، رویه‌ایتابع‌ها در آن مثل داده رفتار می‌کنند
جاواشیءگرا، تابعی (تا حدی)از جاوا ۸ تابع‌های lambda اضافه شد
Cرویه‌اینمونه‌ی کلاسیک سبک رویه‌ای
C++رویه‌ای، شیءگرا، تابعی (تا حدی)آزادی زیاد، پیچیدگی زیاد
C#شیءگرا، رویدادمحور، تابعی (تا حدی)رویدادها جزو خود زبان‌اند
Goرویه‌ای، همروندکلاس و وراثت ندارد، اما متد و interface دارد
Rustرویه‌ای، تابعی، همروندمتغیرها به‌طور پیش‌فرض تغییرناپذیرند
Haskellتابعی خالصبرای فهم عمیق سبک تابعی
SQL و Prologاعلانی و منطقیمی‌گویید چه می‌خواهید، نه چطور

چرا زبان‌ها چندپارادایمی شده‌اند؟

چون هیچ پارادایمی برای همه‌ی مسئله‌ها بهترین نیست. شیءگرایی برای مدل کردن چیزهای واقعی مثل بازیکن، کالا یا حساب کاربری عالی است. سبک تابعی برای تبدیل و پردازش داده تمیزتر و کم‌خطاتر است. سبک رویدادمحور برای رابط کاربری و بازی ضروری است. برنامه‌نویس خوب این ابزارها را می‌شناسد و برای هر بخش از برنامه، مناسب‌ترین را انتخاب می‌کند. برای همین زبان‌های جدید معمولاً امکانات چند سبک را با هم دارند. برای آشنایی با خود زبان‌ها، مقاله‌ی زبان‌های برنامه‌نویسی را ببینید.

یک نوجوان اول کدام مدل برنامه‌نویسی را یاد بگیرد؟

ترتیبی که برای بیشتر نوجوان‌ها جواب می‌دهد، همان ترتیبی است که برنامه‌نویسی در عمل از ساده به پیچیده پیش می‌رود:

  1. اول رویه‌ای: متغیر، شرط، حلقه و تابع. این پایه‌ی همه‌ی سبک‌های دیگر است. اگر هنوز تایپ برایتان سخت است یا سن کمی دارید، از دوره‌ی قدم اول و فکر الگوریتمی شروع کنید؛ در غیر این صورت دوره‌ی اصلی پایتون را از جلسه‌ی اول بروید.
  2. هم‌زمان رویدادمحور، با بازی یا سایت: ساختن بازی با Pygame Zero یا دکمه‌های جاوااسکریپت در دوره‌ی وب فکر رویدادمحور را به‌طور طبیعی و سرگرم‌کننده یاد می‌دهد.
  3. بعد شیءگرا: وقتی برنامه‌هایتان بزرگ‌تر شد و حس کردید تابع‌ها و متغیرها دارند شلوغ می‌شوند، وقت کلاس‌هاست. در دوره‌ی پایتون حرفه‌ای برای ۱۵ سال به بالا، جلسه‌های ۲۵ تا ۳۰ کاملاً به شیءگرایی اختصاص دارد.
  4. در کنار آن تابعی: comprehension، map و filter و تابع خالص را کم‌کم وارد کدتان کنید. این ابزارها کد را کوتاه‌تر و تمیزتر می‌کنند.

لازم نیست پارادایم‌ها را حفظ کنید. با ساختن پروژه‌های واقعی، مثل یک بازی یا یک دفترچه‌ی تلفن کوچک، خودتان به جایی می‌رسید که می‌فهمید هر سبک کجا به کار می‌آید.

برای تمرین روزانه‌ی مفاهیم پایه، تمرین‌های پایتون و تمرین روزانه را امتحان کنید و کدهای این مقاله را در ویرایشگر آنلاین پایتون اجرا کنید (کد Pygame Zero را در دوره‌ی بازی‌سازی امتحان کنید).

سؤال‌های پرتکرار

تفاوت برنامه‌نویسی رویه‌ای و شیءگرا چیست؟

در سبک رویه‌ای، داده‌ها و تابع‌ها از هم جدا هستند و برنامه دنباله‌ای از فراخوانی تابع‌هاست. در سبک شیءگرا، داده و تابع‌هایی که روی آن کار می‌کنند در کنار هم و درون یک شیء قرار می‌گیرند. برای برنامه‌های کوچک سبک رویه‌ای ساده‌تر است و در برنامه‌های بزرگ، شیءگرایی به نظم کد کمک می‌کند.

آیا پایتون یک زبان شیءگراست؟

پایتون زبانی چندپارادایمی است. از شیءگرایی پشتیبانی کامل دارد و در واقع همه‌چیز در پایتون، حتی عددها و تابع‌ها، شیء است. اما برخلاف جاوا مجبورتان نمی‌کند برای هر برنامه کلاس بنویسید، و می‌توانید با سبک رویه‌ای یا تابعی هم در آن کد بنویسید.

بهترین پارادایم برنامه‌نویسی کدام است؟

هیچ پارادایمی به‌طور مطلق بهترین نیست. هر سبک برای نوعی از مسئله مناسب‌تر است: شیءگرایی برای مدل کردن چیزهای واقعی، تابعی برای پردازش داده، رویدادمحور برای رابط کاربری و بازی. برنامه‌نویس‌های حرفه‌ای معمولاً در یک پروژه چند سبک را با هم ترکیب می‌کنند.

برنامه‌نویسی شیءگرا را از چه سنی یاد بگیریم؟

سن به‌تنهایی ملاک نیست؛ مهم این است که پایه‌ها محکم باشند. کسی که با متغیر، شرط، حلقه و تابع راحت است و چند پروژه‌ی کوچک ساخته، آماده‌ی یادگیری کلاس‌هاست. برای بیشتر نوجوان‌ها این آمادگی در دوره‌ی متوسطه‌ی دوم به دست می‌آید، هرچند بعضی‌ها زودتر به آن می‌رسند.

آیا برنامه‌نویسی تابعی برای نوجوان‌ها سخت است؟

ایده‌های اصلی آن، مثل تابع خالص و استفاده از map و filter، اصلاً سخت نیستند و در پایتون و جاوااسکریپت به‌راحتی قابل تمرین‌اند. زبان‌های کاملاً تابعی مثل Haskell چالش بیشتری دارند و بهتر است بعد از تسلط بر یک زبان چندپارادایمی سراغشان رفت.

همین حالا روی Battle Code تمرین کن

مقاله‌های دیگر

همه‌ی مقاله‌ها