eich-language-fundamentals

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Brendan Eich Style Guide

Brendan Eich风格指南

Overview

概述

Brendan Eich created JavaScript in 10 days at Netscape in 1995. Despite time constraints, he embedded powerful concepts: first-class functions, prototypal inheritance, and dynamic typing. Understanding his design choices unlocks JavaScript's true power.

Brendan Eich于1995年在Netscape仅用10天便创造了JavaScript。尽管时间紧迫，他仍嵌入了强大的概念：first-class functions、prototypal inheritance和动态类型。理解他的设计选择才能解锁JavaScript的真正威力。

Core Philosophy

核心理念

"Always bet on JavaScript."

"JavaScript has first-class functions and closures. That's a big deal."

Eich designed JavaScript to be accessible yet powerful, borrowing from Scheme (functions), Self (prototypes), and Java (syntax).

"永远押注JavaScript。"

"JavaScript拥有first-class functions和closures，这非常重要。"

Eich设计的JavaScript兼具易用性与强大功能，借鉴了Scheme（函数特性）、Self（原型特性）和Java（语法）的特点。

Design Principles

设计原则

First-Class Functions: Functions are values—pass them, return them, store them.
Prototypal Inheritance: Objects inherit directly from objects, not classes.
Dynamic Nature: Types are fluid; embrace duck typing.
Flexibility: The language adapts to many paradigms.

First-Class Functions：函数是值——可以传递、返回、存储它们。
Prototypal Inheritance：对象直接从其他对象继承，而非从类继承。
动态特性：类型是灵活的；拥抱鸭子类型。
灵活性：该语言适配多种编程范式。

When Writing Code

代码编写规范

Always

始终遵循

Leverage closures for encapsulation
Use functions as first-class citizens
Understand the prototype chain
Embrace JavaScript's multi-paradigm nature
Know that objects are just property bags

利用closures实现封装
将函数作为一等公民使用
理解原型链
拥抱JavaScript的多范式特性
明确对象只是属性集合

Never

切勿

Fight the language's dynamic nature
Ignore
```
undefined
```
and
```
null
```
semantics
Assume JavaScript is "Java-like"
Overlook the power of functions

抗拒语言的动态特性
忽略
```
undefined
```
和
```
null
```
的语义
假设JavaScript与“Java类似”
忽视函数的强大能力

Prefer

优先选择

Function expressions and closures
Object literals for simple objects
Prototype delegation over deep hierarchies
Dynamic features when they simplify code

函数表达式和closures
用对象字面量创建简单对象
原型委托而非深层继承层级
当动态特性可简化代码时加以利用

Code Patterns

代码模式

First-Class Functions

javascript

// Functions as values
const greet = function(name) {
    return 'Hello, ' + name;
};

// Functions as arguments
function map(array, transform) {
    const result = [];
    for (let i = 0; i < array.length; i++) {
        result.push(transform(array[i]));
    }
    return result;
}

const doubled = map([1, 2, 3], function(x) { return x * 2; });

// Functions returning functions
function multiplier(factor) {
    return function(number) {
        return number * factor;
    };
}

const double = multiplier(2);
const triple = multiplier(3);
double(5);  // 10
triple(5);  // 15

javascript

// Functions as values
const greet = function(name) {
    return 'Hello, ' + name;
};

// Functions as arguments
function map(array, transform) {
    const result = [];
    for (let i = 0; i < array.length; i++) {
        result.push(transform(array[i]));
    }
    return result;
}

const doubled = map([1, 2, 3], function(x) { return x * 2; });

// Functions returning functions
function multiplier(factor) {
    return function(number) {
        return number * factor;
    };
}

const double = multiplier(2);
const triple = multiplier(3);
double(5);  // 10
triple(5);  // 15

Closures

javascript

// Closures capture their lexical environment
function createCounter() {
    let count = 0;  // Private state
    
    return {
        increment: function() { return ++count; },
        decrement: function() { return --count; },
        value: function() { return count; }
    };
}

const counter = createCounter();
counter.increment();  // 1
counter.increment();  // 2
counter.value();      // 2
// count is not directly accessible

javascript

// Closures capture their lexical environment
function createCounter() {
    let count = 0;  // Private state
    
    return {
        increment: function() { return ++count; },
        decrement: function() { return --count; },
        value: function() { return count; }
    };
}

const counter = createCounter();
counter.increment();  // 1
counter.increment();  // 2
counter.value();      // 2
// count is not directly accessible

Prototypal Inheritance

javascript

// Objects inherit from objects
const animal = {
    speak: function() {
        return this.sound;
    }
};

const dog = Object.create(animal);
dog.sound = 'Woof!';
dog.speak();  // 'Woof!'

const cat = Object.create(animal);
cat.sound = 'Meow!';
cat.speak();  // 'Meow!'

// The prototype chain
dog.hasOwnProperty('sound');  // true
dog.hasOwnProperty('speak');  // false (inherited)

javascript

// Objects inherit from objects
const animal = {
    speak: function() {
        return this.sound;
    }
};

const dog = Object.create(animal);
dog.sound = 'Woof!';
dog.speak();  // 'Woof!'

const cat = Object.create(animal);
cat.sound = 'Meow!';
cat.speak();  // 'Meow!'

// The prototype chain
dog.hasOwnProperty('sound');  // true
dog.hasOwnProperty('speak');  // false (inherited)

Dynamic Objects

javascript

// Objects are dynamic property bags
const obj = {};

// Add properties anytime
obj.name = 'Dynamic';
obj['computed-key'] = 'Works too';

// Delete properties
delete obj.name;

// Check existence
'computed-key' in obj;  // true

// Iterate properties
for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
        console.log(key, obj[key]);
    }
}

javascript

// Objects are dynamic property bags
const obj = {};

// Add properties anytime
obj.name = 'Dynamic';
obj['computed-key'] = 'Works too';

// Delete properties
delete obj.name;

// Check existence
'computed-key' in obj;  // true

// Iterate properties
for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
        console.log(key, obj[key]);
    }
}

Mental Model

心智模型

Eich's JavaScript is built on:

Functions are fundamental — Not just procedures, but values
Objects are flexible — Dynamic bags of properties
Prototypes link objects — Delegation, not copying
Closures preserve scope — Functions remember their birth environment

Eich设计的JavaScript基于以下几点：

函数是基础 —— 不只是过程，更是值
对象具有灵活性 —— 动态的属性集合
原型链接对象 —— 委托而非复制
Closures保留作用域 —— 函数会记住其诞生环境

Signature Moves

标志性技巧

Closures for private state
Higher-order functions for abstraction
Prototype chain for shared behavior
Object literals for quick structures
Dynamic property access when needed

用Closures实现私有状态
用高阶函数实现抽象
用原型链实现共享行为
用对象字面量快速创建结构
必要时使用动态属性访问