MoureDev 编程挑战路线图 02:函数与作用域(Funciones y Alcance)多语言实战解析

原创2026-10-13 19:35:201,935 阅读
文章标签:示例工程

MoureDev 编程挑战路线图 #02:函数与作用域(Funciones y Alcance)多语言实战解析

本指南围绕编程挑战路线图第二期「FUNCIONES Y ALCANCE」的练习展开,系统地梳理函数的基本形态、嵌套函数、内置函数、局部与全局变量的作用域规则,并以仓库中 Python、JavaScript、Java、Go、Rust、Kotlin、C++、Swift、PHP 等真实提交代码为实证,帮助读者掌握在任何语言中"写出符合惯例的函数"的核心能力,并完成带返回值的 FizzBuzz 变体挑战。

挑战背景与题目要求

该练习发布于 2024-01-08,难度为「Fácil(简单)」,是 MoureDev 路线图的基础环节。它不限定语言,要求参与者围绕以下五条主线编写示例,并将每个例子的结果打印到控制台(原文强调:"Debes hacer print por consola del resultado de todos los ejemplos"):

  1. 函数的基本形态:无参数无返回、带一个或多个参数、带返回值;
  2. 嵌套函数:验证语言是否支持在函数内部再定义函数;
  3. 内置函数:调用语言自带(或标准库提供)的函数;
  4. 局部与全局变量:通过实验理解作用域差异;
  5. 额外挑战:编写一个接收两个字符串参数、返回整数的函数,实现规则化的 FizzBuzz 变体。

原文档还特别提醒:"Cada lenguaje sigue unas convenciones que debes de respetar para que el código se entienda"——每个语言都有自己的语法惯例,需要尊重并遵守。完整参与指引见仓库根目录的 README.md。

一、函数的基本形态:从零参数到带返回值

无论哪种语言,函数都围绕"输入(参数)— 处理 — 输出(返回值/副作用)"展开。仓库提交中几乎覆盖了所有组合,以下是典型对照。

1.1 无参数、无返回值

这类函数只执行副作用(如打印),是最简单的形式:

def funcion1():
    var = "Una variable en la funcion"
    var2 = 3

funcion1()
public static void sinRetorno() {
    System.out.println("Función sin retorno ni parámetros");
}
fn saludar() {
    println!("Hola, Rust!");
}

1.2 带一个或多个参数

  • Python 多参数与返回:
def funcion2(num1, num2):
    return num1 + num2

print(funcion2(6, 3))
  • JavaScript 命名函数与参数打印(1Nonamed.js):
const sum = function sum(a, b) {
  console.log(`La suma de a + b es = ${a + b}`);
};
  • Java 支持参数类型与数量不同的重载(AFOXJONES.java):sinRetornoConParametro(String) 与 sinRetornoConParametros(String, int) 可同时存在。

1.3 带返回值的函数

  • Rust 中最后一个表达式即返回值,无需 return(Coshiloco.rs):
fn multiplicar(a: i32, b: i32) -> i32 {
    a * b
}
  • Go 的特色是多返回值与命名返回值(edalmava.go):
func swap(x, y int) (int, int) {
    return y, x
}

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return // 返回 x, y
}

Go 还常利用多返回值同时返回结果与错误(dividir(dividendo, divisor float64) (float64, error)),这是其惯用法。

1.4 语言的"额外形态":匿名函数与箭头函数

题目要求"列出语言的所有可能性",许多提交补充了匿名/箭头函数:

  • Python 的 lambda(13sauca13.py)可声明后立即调用:
multiplicacion = lambda a, b, c: a * b * c
print(multiplicacion(10, 3, 5))
print((lambda var1, var2: var1 ** var2)(2, 3))
  • JavaScript 的箭头函数、IIFE(立即执行函数表达式)与回调(1Nonamed.js):
const myArrowFn = () => console.log("Log from Arrow Function");
const myCallback = () => console.log("Log desde callback function");
const mainFunction = (cb) => cb();
  • Go 的匿名函数赋值给变量(edalmava.go):
restar := func(x, y int) int {
    return x - y
}
  • Kotlin 的高阶 lambda(Ancarlu.kt)将函数作为参数传递。

小结:声明函数语法因语言而异(def、function、fn、func、fun、public static void……),但"参数 + 返回 + 副作用"的抽象是共通的。动手前先确认语言惯用法,正是本题的考察点之一。

二、函数内的函数:嵌套与闭包

题目要求验证"能否在函数内创建函数"。各语言支持度不一:

  • JavaScript 天然支持嵌套函数,且内层函数形成闭包(Closure),可访问外层作用域(1Nonamed.js):
function squares(a, b) {
  function square(x) {
    return x * x; // 闭包:内层函数可访问外层参数
  }
  return square(a) + square(b);
}
  • Go 支持在函数内定义闭包并调用(Aldroide.go):
func operations(a, b int) (int, int) {
    add := func() int { return a + b }
    sub := func() int { return a - b }
    return add(), sub()
}
  • Rust 允许在 fn 内再声明 fn(Coshiloco.rs),kodenook.rs 中亦有 fn second() 内嵌于 fn first() 的示例。
  • Kotlin 称之为"嵌套函数"(Ancarlu.kt):
fun nested() {
    fun example() {
        val kotlin = "Kotlin"
        println("Estoy programando en $kotlin")
    }
    example()
}

从源码结构看,动态语言(Python/JS/PHP)与支持闭包的系统语言(Go/Rust/Swift)普遍允许嵌套;编写时注意:内层函数通常可以读取外层变量,但反向访问一般不成立——这正是作用域链与闭包的核心语义。

三、使用语言内置函数

题目要求调用"语言已创建的函数"。提交代码大量使用了标准库:

  • Python:print() 输出、len() 求长度(13sauca13.py)。
  • Java:字符串方法 compareToIgnoreCase、concat(AFOXJONES.java)。
  • Kotlin:String.length、String.uppercase()(Ancarlu.kt)。
  • Rust:标准库 cmp::max(Coshiloco.rs)。
  • C++:<math.h> 的 exp()(Aldroide.cpp)。
  • PHP:字符串函数 strtoupper、strlen、strrev、str_repeat、str_replace 与类型函数 gettype(CeciliaPorras01.php)。

练习建议:优先熟悉所在语言标准库中最常用的一组函数(字符串处理、集合操作、数学与类型转换),因为后续所有挑战都会频繁用到。

四、局部变量与全局变量的作用域

作用域是本题的另一核心。各语言的机制略有差异,但规则一致:全局变量处处可见,局部变量只在其声明处(函数/块内)有效。

  • Python 示例(13sauca13.py)中,funcion1 内部声明的 var 即为局部变量,离开函数即不可见。
  • JavaScript(1Nonamed.js):
let myGlobal = "Pedro"; // 全局
const myFn = () => {
  let myLocal = "David"; // 局部
  console.log(`** Esta es mi variable global: ${myGlobal}`);
  console.log(`** Esta es mi variable local dentro de myFn: ${myLocal}`);
};
  • TypeScript 提交(AChapeton.ts)用注释明确提示:localVar 在函数外不可访问,而 globalVar 在函数内外皆可用。
  • Java(AFOXJONES.java)以类级 private static final 定义全局、方法内 String variableLocal 定义局部;还示范了 private 方法仅类内可见的封装语义。
  • Rust 使用 static 声明全局常量(Coshiloco.rs、kodenook.rs)。
  • C++ 在函数外定义全局 int i = 10,main 内定义局部 int local = 90 分别打印验证(Aldroide.cpp)。
  • Swift 通过注释说明局部变量离开函数即失效(18miguelgalarza.swift),甚至直接写出 // print(variableLocal) 会产生错误。
  • PHP 需要显式 global $variable 才能在函数内访问全局变量(CeciliaPorras01.php),这是 PHP 与多数语言的明显差异。

实战要点:优先使用最小作用域(尽量局部、尽量不可变/const),减少全局共享状态,可显著降低代码耦合与调试成本。若语言有 static、const 或 global 关键字,请按语言惯例使用。

五、额外挑战:返回次数的 FizzBuzz 变体

原文档的附加练习(难度 EXTRA)是经典 FizzBuzz 的变体:

编写函数 extra(param1, param2):接收两个字符串,遍历 1~100;3 的倍数打印第一个字符串、5 的倍数打印第二个字符串、同时是 3 和 5 的倍数打印两者拼接;其余情况打印数字本身。函数返回数字被打印的次数。

这是一个把"函数定义、循环、条件、返回值、字符串拼接"串起来的综合练习。仓库中多种语言的实现逻辑一致,下面给出两个代表性版本。

5.1 Python 版本(13sauca13.py)

def ej_extra(a, b):
    for i in range(1, 101):
        if not i % 3 and not i % 5:
            print(a, b)
        elif not i % 3:
            print(a)
        elif not i % 5:
            print(b)
        else:
            print(i)

ej_extra("pen", "pineapple")

该版本遍历并打印,未显式计数;其他提交(如 [13sauca13.py] 之外的多数版本)补上了计数器与返回。

5.2 Java 完整版(AFOXJONES.java)

public static int extra(String text1, String text2) {
    int count = 0;
    for (int i = 1; i <= 100; i++) {
        if (i % 3 == 0 && i % 5 == 0) {
            System.out.println(text1 + text2);
        } else if (i % 3 == 0) {
            System.out.println(text1);
        } else if (i % 5 == 0) {
            System.out.println(text2);
        } else {
            System.out.println(i);
            count++; // 仅数字被打印时计数
        }
    }
    return count;
}

调用 extra("Fizz", "Buzz") 后返回"以数字形式打印的次数"。注意 判断顺序:必须把"同时是 3 和 5 的倍数"(即 15 的倍数)放在最前面,否则会被前两个分支提前拦截。

5.3 其他语言的实现差异

  • JavaScript/TypeScript(1Nonamed.js、AChapeton.ts)使用 i % 3 === 0 && i % 5 === 0 严格相等判断,并用 counter/count 计数后 return。
  • Go(Aldroide.go)以 var numImpreso = 0 计数并 return numImpreso。
  • Rust(kodenook.rs)用 count_numbers += 1 计数并返回;Coshiloco.rs 则额外打印了计数器最终值。
  • Kotlin(Ancarlu.kt)使用 for (i in 1..100) 与 1..100 闭区间遍历,x++ 计数返回。
  • Swift(18miguelgalarza.swift)给出两种写法,其中一种用 switch (i.isMultiple(of: 3), i.isMultiple(of: 5)) 对元组进行分支,展示标准库 isMultiple(of:) 的用法。
  • PHP(CeciliaPorras01.php)遍历时用 $count += 1 累积,最终 return $count 并由调用方打印结果。

自检清单:边界用 <= 100 或 1..=100(Rust);15 的倍数分支置顶;仅"打印数字"分支计数;所有分支务必打印输出。对照以上任一语言实现即可验证正确性。

六、如何验证与参与挑战

仓库以"每期一个 ejercicio.md + 按语言分目录的社区提交"组织挑战。本期目录为 Roadmap/02 - FUNCIONES Y ALCANCE,内含 30+ 种语言的实现,例如 python/、javascript/、java/、go/、rust/、kotlin/、c++/、swift/、php/、typescript/ 等子目录,既可作为学习对照,也可自测运行。

参与流程(详见 README.md 的「Instrucciones」):

  1. Fork 仓库并 git clone 到本地;
  2. 在对应语言的子目录中新建"以你的 GitHub 用户名命名"的代码文件;
  3. 提交 Pull Request,标题遵循 #[期数] - [语言] 格式(例如 #02 - Python)。

总结

本期挑战用最少的语法成本打通了"函数与作用域"这条编程主线:参数/返回值的多种组合、嵌套与闭包、内置函数复用、局部与全局变量的边界,并以带返回值的 FizzBuzz 变体完成综合演练。从仓库提交可以看出,无论选择哪种语言,遵守其声明语法与作用域惯例都是让代码可读、可维护的前提——这也是原文档反复强调"尊重每种语言的约定"的原因。完成本题后,即可继续路线图后续的数据结构、字符串处理等进阶挑战。

登录后查看全文
roadmap-retos-programacion