我是写 java 代码的，感觉后续的一些语法更补不是很让人满意，只是写习惯了，不过也萌生了对那种编程语言的美的思考，表现力强，整洁优美，但我自身接触的语言实在有限，所以想想问问大家，如果可以，也希望可以附上一段你喜欢的代码。

自己提下 python 吧，但只接触过一点，未实际项目，它有一种语法层面的整洁美，那个缩进。

个人感觉 Java 比较美，虽然较啰唆，但比较优雅。python 接触不多，觉得它太灵活了，各种语法，比较乱，不优雅。但如果现在二选一，我还是会选 python ，因为觉得实用大于语法优雅。

fn read_file(path: &str) -> Result<String, io::Error> {
let mut file = File::open(path)?; // 自动传播错误
let mut contents = String::new();
file.read_to_string(&mut contents)?; // 自动传播错误
Ok(contents)
}

rust 的错误处理吧，是我见过的最好的错误处理方式

不可以。讲不出来。自己脑补吧。

不可变数据结构, 无副作用函数, 消息驱动在多线程上下文, 异步, 和分布式场景拥有天然优势.

控制流语句, if-else, foreach, unit, try, 不再只是命令, 而是输入输出数据的操作符, 跟函数的作用是一样的.

可惜实现了这些思想的高级语言只能运行在指令式设计的处理器上.

所以底层实现还是内存块, 指针, 加操作指令.

Tomohiko Sakamoto 算法，来确定当前日期是星期几：
int dow(int y, int m, int d) {
static int t[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
y -= m < 3;
return (y + y/4 - y/100 + y/400 + t[m-1] + d) % 7;
}

快速平方根倒数算法：
float Q_rsqrt( float number )
{
long i;
float x2, y;
const float threehalfs = 1.5F;

x2 = number * 0.5F;
y = number;
i = ( long ) &y;
i = 0x5f3759df - ( i >> 1 );
y = ( float ) &i;
y = y ( threehalfs - ( x2 y * y ) );

return y;
}

2025 年了，AI 临门一脚的时代，我不认为程序员需要再把自己的追求放到这种事情上面。

准确说，所有受限于人类脑眼结构的 IO 带宽有限而做的优化都即将失去意义。
注释无误的情况下越啰嗦越好，编译结果一致的前提下代码越平庸越好，框架越大众越好。以往追求的美感，诸如逻辑单元的可复用性、「巧妙」的写法也很快会失去意义，因为几秒钟新写一个成本将远低于维护，不需要维护的代码的「美感」没有价值。

Person person = new Person(); // good old.
var person = new Person(); // cool. 较新一点的 Java 现在也能这样写, 不过 csharp 很早就有了
Person person = new(); // awesome. 我想不到比这更简洁的写法了

搞点怪的:

(loop repeat 10
 for x = (random 100)
 if (evenp x)
 collect x into evens
 else
 collect x into odds
 finally (return (values evens odds)))
;; =>
(92 44 58 68)
(95 5 97 43 99 37)

其它语言里很基础的循坏结构, 在 common lisp 里硬是弄出了一套 dsl. 有时候我讨厌它, 有时候我又喜欢它.

Java 还美, 疯了...

Y-Combinator

(define Y
 (λ (le)
 ((λ (f)
 (f f))
 (λ (f)
 (le (λ (x) ((f f) x)))))))

最美不过 C＃

函数式的语法我觉得都挺美

ocaml 实现的神经网络

美，当然是 Pascal

www.codewars.com/kata/tricky-kotlin-number-8-simple-for-comprehension

erlang/elixir 的 pattern match 是我见过的最优雅的

一个微软研究院的编程语言Koka，函数式强类型，用 algebraic effect 管理任意的副作用(可用来实现协程和 async/await 等等)，它非常漂亮和统一，在语法和语义上都非常优雅，体现在它有一个非常小的核心语言子集，其它语言构造都可以转化成核心语言； while 只是一个普通的标准库函数；所有圆括号永远先求值而所有花括号都会后续求值零次/一次/多次(作为匿名函数)；使用类似 Python 的缩进来省略 C 风格的花括号；和 Rust 一样函数块的最后一个表达式作为返回值；函数式语言标配的类型推导和模式匹配；所有 a.f 都等价于 f(a) ......
这个编程语言属于研究性质，可能对于缺少函数式编程背景的人来说有点难懂，而且资料较少，需要参考它的论文、文档、示例还有测试用例，一个例子如下：

// A custom generator effect (which is polymorphic)
effect yield<a>
 fun yield(x: a): ()

// Traverse a list and yield the elements (which is also polymorphic) with 'yield' effect
fun traverse(xs: list<a>): yield<a> ()
 match xs
 Cons(x,xx) -> { yield(x); traverse(xx) }
 Nil -> ()

fun main(): console ()
 with fun yield(i: int) // Handles the 'yield' effect
 println("yielded " ++ i.show) // Printing requires 'console' effect
 [1,2,3].traverse

注意这上面的缩进没了

你既然写 java 就搞点 kotlin 呗

github.com/mossr/BeautifulAlgorithms.jl

可以试试看比较 exotic 的语言，比较说 Forth 。

c sharp 的 lamda 表达式，java 一处编写 处处不能运行

OCaml 那种没有循环的语言

python 虽美，但是贴在 v2 上缩进全部崩溃🐶

img

my.oschina.net/joymufeng/blog/536184

Swift 有类似的处理：

// 从文件路径读取字符串，返回结果或错误
func readFile(path: String) -> Result<String, Error> {
 Result { try String(contentsOfFile: path, encoding: .utf8) }
}

// 处理结果或错误
switch readFile(path: "/test.txt") {
case .failure(let error):
 print("reading file failed: \(error)")
case .success(let contents):
 print("reading file contents: \(contents)")
}

几乎不用维护的代码最优雅，死代码才是好代码

美？那肯定是 Ruby 呀

说到美，那当然是我大 JavaScript
class Example {
＃privateField = 42;

getPrivateField() {
return this.＃privateField;
}
}

let x = (1, 2, 3);
console.log(x); // 3

['1', '2', '3'].map(parseInt); // [1, NaN, NaN]

还有这个字字珠玑：
console.log(0 == "0"); // true
console.log(0 == []); // true
console.log(0 == ""); // true
console.log("0" == []); // false
console.log([] == ![]); // true

还是觉得 C 最美：大道至简，大智若愚

int main() {
 printf("Hello, World!\n");
 return 0;
}

我认为一个编程语言如果是美的，那么它可以通过自己的代码，来描述关于用它写成的程序自身的几个问题：

1. 我（这个程序）要解决什么样的问题
2. 我（这个程序）要如何解决这个问题
3. 我（这个程序）如何证明这个问题被解决了

目前这三点都做得很好的，在我用过的编程语言（ C/C++, Java, C＃, F＃, Python, Haskell, Javascript, Rust ）里，

＃33 Rust 做得最好

＃6 反对这个说法：
“
注释无误的情况下越啰嗦越好，编译结果一致的前提下代码越平庸越好，框架越大众越好。以往追求的美感，诸如逻辑单元的可复用性、「巧妙」的写法也很快会失去意义，因为几秒钟新写一个成本将远低于维护，不需要维护的代码的「美感」没有价值。
”

编程世界存在一些不可动摇的基础，否则整个世界如同流沙上的城堡。
只不过这些东西都被隐藏得很深，所以我们以为不再需要它们。

简单是一种美。语法简单：C 语言。写出来的程序简短：Python 语言。

＃27 Scala 的 control-flow 演示的不错, 但是有些地方我认为还是处理的不好,
几处 if-else 的嵌套如果用 pattern-match 是不是就不用这么多行了,
errorhandling 的分支都是 Ok(XXX)不是很认同.

對我來說, 主要是各種 monospace 字體... IDE 各種 UI... 還有縮進...

应该没有啥美不美，我觉得更多的是取舍(trade off)
就比如 java vs python

java 明显更工业化，适合巨型项目，py 的话，脚本还可以，短小精悍
更多的是语言适配了某个场景，比如程序员水平，业务需求，开发场景，配合得当就挺美的。
go 代码看起来丑，但是编译玩用起来不用折腾依赖库也很优雅。

另外我见过最让我惊艳的大概是 prolog ，虽然有些人吹 functional ，oop ，啥的，但是 prolog 感觉完全是另一种思路，甚至有种前 gpt 的感觉。

依赖倒置 DIP 在概念层面
控制反转 IoC 在设计一个软件的时候的设计原则/设计模式方面
依赖注入 DI 在具体方法层面

www.zhihu.com/question/265433666/answer/337599960＃ 阿莱克西斯: 为什么有很多人说 Go 语言不需要依赖注入？ 依赖倒置原则与系统设计
www.zhihu.com/question/68611994/answer/298845862 在做程序员的道路上，你掌握了什么概念或技术使你感觉自我提升突飞猛进？

www.zhihu.com/question/22508677/answer/276595266 阿莱克西斯: 编程到底难在哪里？

C＃的 LINQ 遥遥领先，最美担当

这个和别的普通语言的函数式库有什么特殊优势吗？
比如 js 类的也是一行就行: R(scores).filter(s => s > 80).map(s => s)

Swift 的闭包挺美的。argument label 也挺好的，独一份。

用过 c＃ java typescript vb c++ php
c＃ 是最美的，尤其是 linq 和模式匹配，方便美丽又高效

在厂里打螺丝的工人会觉得螺丝刀美吗

暂时没有觉得美过

Python 是这样一行而已

scores = [97, 92, 81, 60]
scoreQuery = [s for s in scores if s > 80]
print(scoreQuery)

你只是看的少了
....觉得有些新鲜感
....文面上简洁，基本意味着语法或机制的复杂
....而语法简洁，基本意味着文面上有冗余
....美和美之间是有冲突和矛盾的
....所以大家说谁美谁不美，可能实际上实在争论 xp