嗨，我是勾勾。今天想要和你分享的是如何区分强弱类型与JS自有类型系统的问题。

类型系统的区分

我们在区分不同编程语言时会有一些界定的标准。通常来讲，我们会从类型安全和类型检查上进行区分。

• 类型安全
• 强类型
• 弱类型
• 类型检查
• 静态类型
• 动态类型

类型安全-强类型

在语言层面限制函数的实参类型必须要和形参类型完全相同。这里以Java为例：

class Main {
  static void foo (int num) { 
    System.outprintln(num);    
  }    
  public static void main(String[]) {
    Main.foo(100);  // 100        
    Main.foo("100"); // error "100" is a string        
    Main.foo(Integer.parseInt("100")); // ok    
  }
}

类型安全-弱类型

在语言层面不会限制实参的类型。这里用我们最熟悉的JavaScript为例：

function foo (num) {
  console.log(num)
}
foo(100)    // ok
foo('100')  // ok
foo(pareseInt('100'))   // ok

由于这种强弱类型之分，根本不是某一个权威机构的定义，也没有一个具体的规则，所以对于这种界定方式的细节出现了不一样的理解。

但整体上界定方式都是在描述：

• 强类型有更强的类型约束
• 弱类型中几乎没有什么约束

我个人比较认同的一种说法是：

• 强类型语言中不允许任意的隐式类型转换
• 弱类型语言当中允许任意的隐式类型转换

console.log('100' - 50) // 50
console.log(Math.floor('foo'))  // NaN
console.log(Math.floor(true))   // 1

变量类型允许随时改变的特点不是强弱类型之间的差异。比如，python就是强类型的语言，但是它的变量类型可以随时改变。这点在很多资料当中可能都表示得有些不太妥当，大多都在说python是一门弱类型语言，事实上不是这样的。

类型检查-静态类型

一个变量声明时它的类型就是明确的，声明过后类型不允许修改。

类型检查-动态类型

运行阶段才能够明确一个类型，而且变量的类型随时可以改变。动态类型语言中，变量是没有类型的，变量中存放的值是有类型的。

var foo = 100 // number类型
foo = 'bar' // 字符串
console.log(foo) // bar

JS类型系统特征

• JS是一门弱类型且动态类型的语言。
• 语言本身的类型系统是很薄弱的，甚至我们也可以说JS就没有任何类型系统。
• 因为JS几乎没有任何的类型限制，所以JS这门语言特别灵活多变。
• 但是在这种表象的背后，丢失掉的就是类型系统的可靠性。在代码当中，每遇到一个变量，我们都需要去担心它到底是不是我想要的类型。

为什么JS不是强类型或者静态类型

这个问题其实与JS的背景有关。早前JS的应用就没想到会发展到今天这种规模，可能几十行代码或者一百多行代码就能完成此功能。在这种一眼就看到头的情况下，类型系统的限制就比较多余了，或者说很麻烦。

JS是一门脚本语言，脚本语言的特点就是：不需要编译就直接在运行环境中去运行。换句话说，JS没有编译环节，所以就算设计成了静态类型语言也没有什么意义，因为静态类型需要在编译阶段进行编译检查，而JS根本没有这样一个环节。

所以JS是一门更灵活更多变的弱类型动态语言。

这在当时没有问题，甚至也是一种优势。但是现在前端应用的规模已经完全不同了，遍地都是大规模应用，所以JS代码就越来越复杂，开发周期也越来越长，这种情况下，之前的优势也就逐渐成为了短板。

弱类型的问题

问题异常时要等到运行时才能发现。

const obj = {}
obj.foo()// TypeError: obj.foo is not a function
setTimeout(() => {    
  obj.foo()   //TypeError: obj.foo is not a function
}, 1000)

类型不明确，会造成函数功能有可能发生改变。

function sum (a, b) {
  return a + b
}
console.log(sum(100, 200)) // 300
console.log(sum(100, '200')) // 100200

对对象索引器的一种错误用法：

const obj = {}
obj[true] = 100
console.log(obj['true']) // 100

这些都只是弱类型问题的冰山一角。

弱类型语言的弊端是非常明显的，只是在代码量小的情况下可以通过约定的方式进行规避。而对于一些开发周期比较长的大型项目，这种君子约定还是有一定的隐患，只有在语法层面的强制要求才能够提供更可靠的保障。

强类型语言的代码在代码可靠程度上有明显优势，使用强类型语言就可以提前消灭一大批有可能存在的类型异常，而不必等到在运行过程中慢慢地debug。

强类型的优势

能够在编码阶段提前消灭一大部分类型异常。

代码也更智能，编码更准确。

function render (element) {    
  element.    // 这时智能提示不能提示出来很有用的内容；强类型语言，编译器时时刻刻都知道是哪一个类型，所以能够提供出来更准确的智能提示}

重构更牢靠。

const util = {    aaa: () => { 
  console.log('util func')    
	}
}// 这个对象的aaa方法如果在很多地方有使用的话，我们是不能随意修改的；强类型的语言，一但属性名发生了变化就会立即报出错误，这时候可以轻松定位所有使用到的地方，然后修改

减少不必要的类型判断。

function sum (a, b) {
  if (typeof a === 'number' || typeof b === 'number') {        
    throw new TypeError('arguments must be a number')    
  }    
  return a + b
}
// 强类型的语言在代码层面会减少一些我们类型判断

本文转载自公众号：勾勾的前端世界

获取更多前端技术， 欢迎来找勾勾交流