悟透一个小窍门，你就能举一反三掌握所有编程语言-51CTO.COM

当你程序员当久了，你会慢慢了解到，许多真 . 大佬都是编程语言通。他们在彻底掌握了一门语言之后，就能够很自信的觉得自己能够轻松掌握别的语言。这种能力可把许多人馋哭了，到底是怎么回事？为什么别人能够轻松驾驭所有语言，而我不行？

有的人甚至会怀疑大佬们在吹牛，怎么可能会有这样厉害的人。

事实上，这种能力是真实存在的，因为我，一个小小的前端开发，就已经具备这个能力了。今天我跟大家分享一个小诀窍，让你也能逐步拥有这个能力。

首先我们要明确一个前提，大多数编程语言都是非常相似的，因此我们才能够做到快速掌握别的语言，只是你可能还没有感受到而已。

所以这个窍门说穿了其实就非常简单，要成为编程语言通，我们只需要找到他们的相似性，就可以了。

我们可以把常用的编程语言分为两个大类。

先以我们最熟悉的 JavaScript 为代表，来观察一下类似语言的语法。

首先是 JavaScript。

let a = 10

function foo() {}

for (let i = 0; i <= 10; i++) {}

然后是你可能没学过的 go 语言。

var a string = 'hello world'
var b c int = 1, 2

func main() {}

这个时候，如果你对 JS/TS 比较熟悉的话，你会发现神奇的事情，你居然看懂了没有学过的语言。

我们再来看一下 dart 语言，哎呀，糟糕，又看懂了。

var x = 1;
var hex = 0xDEADBEEF;

var message = StringBuffer('Dart is fun');
for (var i = 0; i < 5; i++) {
  message.write('!');
}

再来看看 Swift，哦豁，还能看得懂？

/* 我的第一个 Swift 程序 */
var myString = "Hello, World!"
 
print(myString)

let decimalInteger = 17           // 17 - 十进制表示
let binaryInteger = 0b10001       // 17 - 二进制表示
let octalInteger = 0o21           // 17 - 八进制表示
let hexadecimalInteger = 0x11     // 17 - 十六进制表示

func runoob(site: String) -> String {
  return (site)
}

import Cocoa

var someInts:[Int] = [10, 20, 30]

for var index = 0; index < 3; ++index {
   print( "索引 [\(index)] 对应的值为 \(someInts[index])")
}

这里有一个很有意思的事情就是，你轻松的发现了这些语言居然跟你学过的 JavaScript 拥有如此相似之处。

所以 JavaScript 虽然在某种程度上被吐槽得非常多，各种缺点，但是很显然，后来的许多语言的语法设计都参考了 JavaScript，学会了 JavaScript，实际上就代表你已经具备轻松掌握别的语言的能力。

但是很多前端依然没有这个自信，为什么呢？

因为 JavaScript 是一个弱类型语言，它缺乏类型系统。

因此，我们只需要进一步掌握 TS，就能成为某一类语言的语言通！

这里我们要明确一个非常关键的信息，那就是以 TS 为代表的这一类语言，有一个非常明确的特征：类型后置。

这类语言的语法设计通常会在声明的前面给一个关键词来表示当前我正在声明一个变量，然后在变量后面明确该变量的类型。

var a: string = 10

包括最近比较火热的 rust 也是一门典型的类型后置的语言，不要骗我，你一定能读懂下面这行代码。

fn main() {
  let x = 5;
  println!("The value of x is: {x}");
  x = 6;
  println!("The value of x is: {x}");
}

而另外一类以 C 语言为代表的语言，它也有一个非常明确的特征：类型前置。

int x = 10;         // 整型变量 x 初始化为 10
float pi = 3.14;    // 浮点型变量 pi 初始化为 3.14
char ch = 'A';      // 字符型变量 ch 初始化为字符 'A'
extern int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;           // 定义并初始化 d 和 f
byte z = 22;                // 定义并初始化 z

int max(int num1, int num2) {
  /* 局部变量声明 */
  int result;

  if (num1 > num2) {
    result = num1;
  } else {
    result = num2;
  }
  return result; 
}

如果你没有学过 C 语言的话，你会觉得 C 语言的代码读起来理解难度会高一点。这是正常的。因为类型前置的理解成本会高很多。我们需要阅读到后面才能知道这一行代码在干什么。

因此新出的语言都是采用类型后置的设计方式，JavaScript 能够流行起来，很大一部分原因是因为在 C 系语言称霸的时候，找到了学习成本更低的语法设计。

著名的 Java 也是一门典型的类型前置的语言。类型前置理解困难还在于面向对象中，经常会出现自定义的类型，例如在 Java 代码中这种类型的句式非常常见。

Puppy myPuppy = new Puppy( "tommy" );

对比一在 js 中的理解难度。

var myPuppy = new Puppy( "tommy" )

我们会发现，同样的代码用 js 理解起来要简单得多。

语言通的大佬们，敏锐的发现了这个区别：类型前置与类型后置。除此之外，所有的语言都具备高度的相似性。

当你没有发现这个区别，只会 JS 的你，去学习 C++ 你会特别痛苦，因为你感觉差异太大了。但是当你悟透了类型前置与后置的区别之后，学习难度就会神奇的降低特别多。来感受一下这段代码，看能搞得懂不。

#include <iostream>

using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      // 成员函数声明
      double get(void);
      void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{
    return length * breadth * height;
}
 
void Box::set( double len, double bre, double hei)
{
    length = len;
    breadth = bre;
    height = hei;
}
int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   Box Box3;        // 声明 Box3，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
 
 
   // box 3 详述
   Box3.set(16.0, 8.0, 12.0); 
   volume = Box3.get(); 
   cout << "Box3 的体积：" << volume <<endl;
   return 0;
}

有没有感觉其实你是看得懂的？是不是变简单了？

一、类型与类型推导

在不同的语言中，对类型的设计有细微的差异，例如数字有的语言是 int ，有的语言是 number，有的语言还有 bigInt，字符串有的语言直接就是 string，有的语言里还有 char。因此我们学习的时候要花一点点时间去区分不同的类型细节，在 rust 语言中，因为对内存分配敏感，因此光是整型，都有好几种类型。

let x: u8 = 2
let y: u16 = 15

你还需要了解有符号整型，无符号整型，浮点型等细节，学习成本非常低。

除此之外呢，许多前端没把类型编程掌握好。例如在 TS 中，我们引入了类型机制，并且开始有泛型。很多人就懵掉了。不过没关系，我们只需要几分钟就能掌握它。

在现代语言中，由于类型自动推导开始越来越成熟，因此许多语言会在声明的时候巧妙利用类型推导机制省略具体类型的声明，所以你单看下面的代码，你都不敢说我到底写的是哪门语言。

var a = 10

因此我们在学习 TS 的时候，一定要把类型推导彻底掌握透彻，他是你成为语言通的关键。

二、两种不同的开发范式

目前有两种主流的开发范式，函数式编程与面向对象编程。由于各自的特殊原因，就导致了许多前端可能会对面向对象编程非常的陌生，对函数式编程会稍微亲近一些

但是作为一个语言通，不懂面向对象编程肯定是严重偏科的，这会极大的影响你的进步，比如许多前端可能就不懂重载，多态等基础概念。

不过这个时候，我们也能发现前端有一个天然的优势，那就是后端其实需要函数式编程的场景到目前为止来看并不多，许多后端开发并没有机会接触函数式编程，因此大多数后端也是偏科的

三、TS 的先进性

在类型编程中，纵观整个编程语言界，TS 的类型推导都算的上是最强大和最先进的。我们搞前端的要有这种技术自信，这非常关键。

之所以会出现这种局面是因为前端面临的类型问题更为复杂。当然现在由于发展得太过头了，类型体操反而成为了许多人厌弃 TS 的原因。我们只需要在使用的时候自己稍微克制一下，就能很好的发挥 TS 的长处。他的优秀毋容置疑。

四、总结

我们可以将编程语言分为类型前置与类型后置，除此之外，编程语言其实就长得差不多了。

在类型后置语言中，JavaScript 是一门经得起时间考验的设计语言，他先进的语法设计引领了整个编程语言界，因此，深入掌握 JS + TS ，结合本文的小窍门，我们搞前端的就能够轻松成为编程界的语言通。