目录
概念定义
静态类型语言
优势
劣势
动态类型语言
优势
劣势
强类型语言
弱类型语言
如何选择
语言类型图


之前同事每次跟我提起他学习了某个语言，并介绍这个语言很棒时，开头都会跟我说这个语言是什么类型，动态还是静态，我总是比较尴尬的不知道怎么去接。在知乎上翻了一遍发现一个特别好的解释，因为是图片，我这里就整理出文字，如果有谁知道原文的出处麻烦留言告知我一下。知乎链接(比较靠后的一个回答，需要耐心翻一下)

概念定义
静态类型语言
指在编译变量时变量的数据类型即可确定的语言，比如C/C++/JAVA/C#，多数静态类型语言要求在使用变量之前必须声明数据类型，某些具有类型推导能力的现代语言则可以不这么做
优势

IDE可以智能提示。因为静态类型语言的类型是确定的，所以编辑器就可以知道当前的变量有哪些属性和方法
编译的时候能够发现类型不匹配的错误，而动态语言最多只能发现语法的错误

劣势

因为要定义数据类型，代码量也会随之变大，编程应该更专注于程序的本质，而不是把精力分散到数据类型定义上
缺乏灵活性，因为一个变量只能赋值某种类型，当程序需要扩展的时候，这就会成为枷锁，当然可以通过继承和接口实现，但这会陷入另一个深渊，需要更多的精力去纠结复杂的继承关系

动态类型语言
指在运行时确定数据类型的语言，变量使用之前不需要类型声明，通常变量的类型就是被赋值那个值的类型，比如VB/Python
优势

相反于静态类型，编程完全集中于程序的设计本质上，代码的简洁度也会提高，开发效率可能会数倍的提高
因为程序规模的降低，程序的可理解性也会提高。静态类型的拥护者可能会认为，少了类型信息，程序编的更不可读了。这个就属于仁者见仁了，有人会认为程序更集中于程序的本质上会更可读，也有人认为有了类型的辅助程序会更可读

劣势

程序执行速度慢，因为动态类型的语言，类型检查是在运行期做的，但随着计算及性能的提高，执行速度不是什么严重的问题
不执行就检测不出错误，当然要是增加类型检查插件那就另说了。

强类型语言
一旦变量的类型被确定，就不能转化的语言，比如java/Python。
弱类型语言
弱类型语言则反之，一个变量的类型是由其上下文确定的，比如VB/Perl/C
如何选择
套用一句流行的话就是：Static typing when possible, dynamic typing when needed。我的理解如下：

尽可能使用静态语言。类型判断可能帮助我们更早的发现问题，让代码更加规范化
在需要的时候使用动态语言。比如写一些脚本，肯定想要高效的实现，懒的去专门定义那些烦人的Interface。

语言类型图

前面探讨了一种推模式，是弱类型的DataSet的，这里我们接着讨论了一下如何进行强类型的DataSet实现显示报表数据。
那么这两种区别在哪里呢？我们来简单分析一下，
我们刚才通过弱类型的DataSet进行访问和绑定数据源，它是通过了简单的SQL查询命令语句进行的，然后返回的Dataset。当然我前面返回的是DataTable，其实还是一样，你也可以更改哦，前面好像已经说过啦。
这里所说的强类型的DataSet，无非就利用VS内置的数据集类型，然后形成数据字段的视图表，通过这样来绑定和显示，返回Dataset，其实是大同小异的。

类型化的DataSet与非类型化的DataSet的区别


类型化的DataSet


非类型化的DataSet


类型化的DataSet是先从基DataSet类派生，然后使用XML架构文件（.xsd）中的信息生成新类


非类型化的DataSet没有相应的内置架构，它与类型化的DataSet一样，也包含表、列和行等，但它们只作为集合公开


直接通过数据集名称引用表、列和行


需要Tables集合才能引用表、列和行



下面我们来分析和实现一下：
【1】首先建立一个DataSet。在项目中，单击右键>>选择【添加】>>【新建项】>>【数据】>>【数据集】




【2】这里，有两种方法可以建立，我这里从【服务器资源管理器】直接建立，方法是，右键>>【添加链接】>>后面的步骤大家都懂的。
完成后， 将呀显示的表拖动过来到窗口。

【3】至此，便完成了DataSet强类型的数据集，保存一下。
【4】然后我们创建报表，方法我就不说了，相信大家都明白了报表模板rpt的创建过程了：右键【添加】>>【新建项】>>【Reporting】。这里我依然采用空白报表，美观自己搞去哈。注意了，此时我们选择的【数据库专家】中，因为我们在项目中已经建立了强类型DataSet，那么我们在【项目数据】中选择即可。有三种方式：


一种是【ADO.NET数据集】，另一种是【.NET Objects】，第三种是：在【创建新连接】>>选择【数据库文件】>>选择对应的.xsd类型文件。如图

【5】编辑，画报表模板，自己搞定了


【6】添加后台代码：
（1）引入命名空间
using WebApplication1.ReportDataSetTableAdapters;

//注意：此处得相应修改的命名空间哦： 由后面的RegionTableAdapter()确定。
其实就是数据集类型确定，不同的报表对应的名字不一样哦
（2）添加代码：
 public partial class WebForm2 : System.Web.UI.Page

    {

        protected void Page_Load(object sender, EventArgs e)

        {

            ReportDataSet.RegionDataTable dt = new ReportDataSet.RegionDataTable();


            new RegionTableAdapter().Fill(dt);

            CrystalReport3 rptDoc = new CrystalReport3();

            rptDoc.SetDataSource((System.Data.DataTable)dt);
           //SetDataSource有两种重载类型，包括ds和dt，因此，需要显式定义System.Data.DataTable。

            CrystalReportViewer1.ReportSource = rptDoc;

        }

    }

数据类型是任何语言的基础，无论是弱类型语言(如javascript)还是强类型语言(如java)，都有数据类型，掌握数据类型是必须的。
提纲     
整型      
浮点型      
C++的算术操作符      
类型转换
一、整型    
C++的基本整型是boolean,char、short、int和long，每种整型都分为无符号和有符号。经常使用的整型是int类型的。    
char类型就是字符类型，用于表示那些特殊字符。
#include <iostream>
/*
引入头文件climits,通过不同的编译器，打印出short,int,long的字节数是不同的。
climits文件由编译器厂商所提供，在vs2008中short,int,long都是4字节的。
*/
#include <climits>
int main()
{
	using namespace std;
	int n_int = INT_MAX;
	int n_short = SHRT_MAX;
	int n_long = LONG_MAX;
	int n_char = CHAR_MAX;
	cout<<"short is "<<sizeof(n_short)<<" bytes."<<endl;
	cout<<"int is "<<sizeof(n_int)<<" bytes."<<endl;
	cout<<"long is "<<sizeof(n_long)<<" bytes."<<endl;
	cout<<"char is "<<sizeof(n_char)<<" bytes."<<endl;
	cin.get();
} 
符号常量——预处理方式    
在climits中包含与下面类似的语句    
#define INT_MAX 2147483647    
#define和#include一样，也是一个预处理指令，在C语言中通过#define预处理指令来定义常量。如果有些头文件需要兼容C和C++，必须使用#define。
C++用const限定符来定义常量     
在C语言中用#define来定义常量，但是我并不清楚常量的类型。而在C++中用诸如const int SIZE = 26;的方式来定义常量。Java中用public final int SIZE = 26;这和const是差不多的。
二、浮点型    
C++的浮点型分为float,double和long double。double的精度更高，不过一般情况下不是特别精密的运算，我们常常和数学函数一起使用，比如四舍五入。    
下面一个简单的例子是说明float和double精度的，setf()是ostream的方法，防止程序把较大的值改为E表示法，并使数值显示到小数点后6位，参数ios_base::fixed和ios::floatfield是iostream的常量。
#include <iostream>
int main()
{
	using namespace std;
	cout.setf(ios_base::fixed,ios::floatfield);
	float tub = 10.0/3.0;
	double mint = 10.0/3.0;
	const float million = 1.0e6;
	cout<<"tub= "<<tub<<endl;
	cout<<"a million tubs = "<<million*tub<<endl;
	cout<<"10 million tube = "<<10*million*tub<<endl;

	cout<<"mint = "<<mint<<endl;
	cout<<"a million mints"<<million*mint<<endl;
	cin.get();

	return 0;
}
运算结果：
 

三、算术操作符
”+”,”-”,”*”,”/”,”%”
四、类型转换
  
分为隐式转换和显示转换（强制转换）。
  
隐式转换一般发生在不同类型的数在进行运算时或者在函数传递参数时。
  
显示转换：int a = 5; double b = (double)a;像这种类似的方式。
  

最近在准备面试，感觉好些东西了解，但是了解的深度有限。自己就总结了几个模块，打算强化一下。如果你感觉我的文章对你有帮助，请点赞。如果感觉有哪些不足之处，可以留言。让我们一同进步，学习！！！

最后在说明一下，这个系列我会一直写下去。如果，你有什么好的方向，也可以提出来。

我们都知道JS是一个弱类型的语言。在过去仅仅是var代替了所有，ES6之后又引入了let，const。

虽然在写的时候，没有那么多是区别，但是实际计算的时候，该是什么还是什么。
基本类型，引用类型
总体来说，JS分为基本类型，引用类型。

基本类型：string，number，boolean，null，undefined，Symbol

引用类型：Object，Function,Array
类型转换
强调说明一下，类型转换仅仅发生在基本类型中
字符
let x = "1"    // "string"
let y = "1"    // "string"
x + y          // "11" "string"
x + ‘1’        // "11" "string"
x + 1          // "11" "string"
x + true       // "1true" "string"
x + false      // "1false" "string"
x + undefined  // "1undefined" "string"
x + null       // "1null" "string"

x - y          // NaN "number"
x - 1          // 0 "number"
x - true       // 0 "number"
x - false      // 1 "number"
x - undefined  // NaN "number"
x - null       // 1 "number"


布尔
let x = true     // true "boolean"
x + true         // 2 "number"
x + null         // 1 "number"
x + undefined    // NaN "number"


null,undefined
let x = null     // null  "null"
x + null         // 0   "number"
x - null         // 0   "number"

x - undefined    // NaN "number"
x + undefined    // NaN "number"


**总结：**对于字符类型来说，可以与任何类型直接相加（字符串拼接）。其他类型在做操作时，包括字符串的减法操作，会按照 true 为 1，false 为 0 ，null 为 0，undefined  转化为NaN 的方法进行类型转换。针对不能进行类型转换的字符串，则直接报错。Uncaught TypeError。
tips：以上测试以及总结不针对 Symbol 类型，后续会有一篇专门针对 Symbol 的文章
类型检测
常规检测方法

typeof

instanceof

Object.prototype.toString
typeof
区分基本类型，引用类型。但是null特殊，是Object
instanceof
这一块利用了原型，原型链的知识。

可以查看我之前的文章 前端面试之原型链那些事（七）那里面写的比较详细
Object.prototype.toString
所有的数据类型都可以用 Object.prototype.toString 来检测,而且非常的精准。
    var a = 123;
    console.log(Object.prototype.toString.call(a));    
    // [object Number]

    var b = "string";
    console.log(Object.prototype.toString.call(b));    
    // [object String]

    var c = [];
    console.log(Object.prototype.toString.call(c));   
     // [object Array]

    var d = {};
    console.log(Object.prototype.toString.call(d));    
    // [object Object]

    var e = true;
    console.log(Object.prototype.toString.call(e));    
    // [object Boolean]

    var f =  null;
    console.log(Object.prototype.toString.call(f));    
    // [object Null]

    var g;
    console.log(Object.prototype.toString.call(g));    
    // [object Undefined]

    var h = function () {};
    console.log(Object.prototype.toString.call(h));    
    // [object Function]

    var A = new Number();
    console.log(Object.prototype.toString.call(A));    
    // [object Number]