精华内容
下载资源
问答
  • 什么是强类型、弱类型语言以及动态类型、静态类型语言
    2020-02-23 21:11:26

    动态、静态语言

    类型检查

    类型检查时验证类型数据以及赋值是否合乎类型要求的一个过程,自然的方式认为类型检查就是查看 “变量” 和它们的类型,然后判断表达式是否合理。当编译器或解释器在编译阶段做类型检查还是在运行阶段做类型检查来定义编程语言是动态类型或静态类型。

    如果编程语言的类型检查发生在 “编译阶段”(Compile Time),则被定义为 “静态类型语言” (Statically Typed Languages)。

    常见的静态类型语言包括:

    • Java
    • C
    • C++
    • C#
    • Go

    静态语言可以分为两种:

    • 显示类型:类型是语言语法中定义
    • 隐式类型:类型通过编译时推导

    如果编程语言的类型检查发生在 “运行阶段”(Run Time),则被定义为 “动态类型语言” (Dynamically Typed Languages)。

    常见的动态类型语言包括:

    • Python
    • JavaScript
    • PHP

    强类型、弱类型语言

    强类型和弱类型主要是站在变量类型处理的角度进行分类的。这些概念未经过严格定义,它们并不是属于语言本身固有的属性,而是编译器或解释器的行为。主要用以描述编程语言对于混入不同数据类型的值进行运算时的处理方式。

    强类型语言是指无论在编译阶段还是运行阶段,一旦变量绑定某种类型后,此变量会持有该类型,并且不能与其他类型表达式进行混合运算。弱类型则相反。

    强类型不允许变量类型转换,弱类型则允许类型转换。无论是显式类型转换还是隐式类型转换。

    常见强类型语言包括:

    • Java
    • Python
    • C#
    • Go

    常见弱类型语言包括:

    • C
    • C++
    • PHP
    • JavaScript

    “强类型” 的一些要素:(引用自 强弱类型

    • 静态类型不同于动态类型。在静态类型系统中,类型是与变量相连系的名称(通常是在声明时),而不是值(通常是在初始化时)。类型也可借由编译器来推断。
    • 通过语言定义,对类型约束违规的编译时间检查的托管要求。就是说,编译器确保操作只发生在对这个运算有效的操作数上。
    • 类型安全;就是说,拒绝(在要么编译时间要么运行时间)尝试忽视数据类型的操作或函数调用。在更严格的设置下,通过证明进行性和藏存性来证明关于形式语言的类型安全。
    • 禁止类型转换。某个类型的值,不论是不是以显式或隐式的方式,都不可转换为另一个类型。
    • 但是某些作者,把“强类型语言”称呼保留给省略隐式类型转换(就是说编译器为了利益编程者而插入的转换)的语言。对于这些作者,编程语言是强类型的,如果类型必须通过通常叫做“强制”的显式符号来转换。
    • 无法规避类型系统。某些语言允许程序员获取值的表示法之下的东西(即位模式),这有可能规避类型系统。
    • 有复合类型的复杂而细致的类型系统。
    • 数据对象中固定且不变的类型。给定数据对象的类型在这个对象的生命期内不改变。例如,类实例不可以改变它们的类。
    • 在运行程序之前,强类型就保证了运行时期的程序行为,其以静态分析或其它的机制提供。
    更多相关内容
  • 主要介绍了动态语言、动态类型语言、静态类型语言、强类型语言、弱类型语言介绍,需要的朋友可以参考下
  • “ 阅读本文大概需要 3 分钟。 ”1、动静类型与强弱类型很多读者应该都熟悉动态类型与静态类型,但是很多人也会把它们跟强弱类型混为一谈,所以我们有必要先作一下概念上的澄清。这两组类型都是...

    阅读本文大概需要 3 分钟。

    1、动静类型与强弱类型

    很多读者应该都熟悉动态类型静态类型,但是很多人也会把它们跟强弱类型混为一谈,所以我们有必要先作一下概念上的澄清。

    这两组类型都是针对于编程语言而言的,但关注的核心问题不同。

    对于“动静类型”概念,它的核心问题是“什么时候知道一个变量是哪种类型”?

    一般而言,在编译期就确定变量类型的是静态类型语言,在运行期才确定变量类型的则是动态类型语言。

    例如,某些语言中定义函数“int func(int a){…}”,在编译时就能确定知道它的参数和返回值是 int 类型,所以是静态类型;而典型如 Python,定义函数时写“def func(a):…”,并不知道参数和返回值的类型,只有到运行时调用函数,才最终确定参数和返回值的类型,所以是动态类型

    对于“强弱类型”概念,它的核心问题是“不同类型的变量是否允许隐式转化”?

    一般而言,编译器有很少(合理)隐式类型转化的是强类型语言,有较多(过分)隐式类型转化的是弱类型语言。  

    例如,Javascript 中的 "1000"+1会得到字符串“10001”,而 "1000"-1则会得到数字 999,也就是说,编译器根据使用场合,对两种不同类型的对象分别做了隐式的类型转化,但是相似的写法,在强类型语言中则会报类型出错。(数字与字符串的转化属于过分的转化,下文会再提到一些合理的转化。)

    按照以上的定义,有人将常见的编程语言画了一张分类图:

    按强弱类型维度划分,可以归纳出:

    • 强类型:Java、C#、Python、Ruby、Erlang(再加GO、Rust)……

    • 弱类型:C、C++、Javascript、Perl、PHP、VB……

    2、过去的强弱类型概念

    动静类型的概念基本上被大家所认可,然而,强弱类型的概念在问答社区、技术论坛和学术讨论上却有很多的争议。此处就不作罗列了。

    为什么会有那么多争议呢?

    最主要的原因之一是有人把它与动静类型混用了。

    最明显的一个例子就是 Guido van Rossum 在 2003 年参加的一个访谈,它的话题恰好是关于强弱类型的(Strong versus Weak Typing):

    但是,他们谈论的明显只是动静类型的区别。

    访谈中还引述了 Java 之父 James Gosling 的话,从他的表述中也能看出,他说的“强弱类型”其实也是动静类型的区分。

    另外还有一个经典的例子,C 语言之父 Dennis Ritchie 曾经说 C 语言是一种“强类型但是弱检查”的语言。如果对照成前文的定义,那他其实指的是“静态类型弱类型”。

    为什么这些大佬们会有混淆呢?

    其实原因也很简单,那就是在当时还没有明确的动静类型与强弱类型的概念之分!或者说,那时候的强弱类型指的就是动静类型。

    维基百科上给出了 1970 年代对强类型的定义,基本可以还原成前文提到的静态类型:

    In 1974, Liskov and Zilles defined a strongly-typed language as one in which "whenever an object is passed from a calling function to a called function, its type must be compatible with the type declared in the called function."[3] In 1977, Jackson wrote, "In a strongly typed language each data area will have a distinct type and each process will state its communication requirements in terms of these types."[4]

    前面几位编程语言之父应该就是持有类似的观念。

    不过,大佬们也意识到了当时的“强弱类型”概念并不充分准确,所以 Dennis Ritchie 才会说成“强类型但是弱检查”,而且在访谈中,Guido 也特别强调了 Python 不应该被称为弱类型,而应该说是运行时类型(runtime typing)

    但是在那个早期年代,基本上强弱类型就等同于动静类型,而这样的想法至今仍在影响着很多人。

    3、现在的强弱类型概念

    早期对于编程语言的分类其实是混杂了动静与强弱两个维度,但是,它们并不是一一对应重合的关系,并不足以表达编程语言间的区别,因此就需要有更为明确/丰富的定义。

    有人提出了“type safety”、“memory safety”等区分维度,也出现了静态检查类型和动态检查类型,与强弱类型存在一定的交集。

    直到出现 2004 年的一篇集大成的学术论文《Type Systems》(出自微软研究院,作者 Luca Cardelli),专门研究编程语言的不同类型系统:

    论文中对于强弱检查(也即强弱类型)有一个简短的归纳如下:

    • Strongly checked language: A language where no forbidden errors can occur at run time (depending on the definition of forbidden error).

    • Weakly checked language: A language that is statically checked but provides no clear guarantee of absence of execution errors.

    其关键则是程序对于 untrapped errors 的检查强度,在某些实际已出错的地方,弱类型程序并不作捕获处理,例如 C 语言的一些指针计算和转换,而《C 程序员十诫》的前几个都是弱类型导致的问题。

    论文对于这些概念的定义还是比较抽象的,由于未捕获的错误(untrapped errors)大多是由于隐式类型转换所致,所以又演化出了第一节中的定义,以隐式类型转换作为判断标准。

    如今将“对隐式类型转换的容忍度”作为强弱类型的分类标准,已经是很多人的共识(虽然不够全面,而且有一些不同的声音)。

    例如,维基百科就把隐式类型转换作为弱类型的主要特点之一:

    A weakly typed language has looser typing rules and may produce unpredictable results or may perform implicit type conversion at runtime.

    例如,以 Python 为例,社区的主流看法认为它是强类型语言,而判断的标准也是看隐式类型转换。

    例子有很多,比如 Python 官方的 wiki,它专门回答了Why is Python a dynamic language and also a strongly typed language ,给出了 4 个答案,为 Python 的“动态强类型”定性:

    再比如,在《流畅的Python》第11章的杂谈中,也专门提到了强弱类型的分类。(它的用语是“很少隐式类型转换”,算是比较严谨的,但是也错误地把 C++ 归为了强类型。)

    4、Python 是不是强类型语言?

    关于“Python 是否属于强类型”话题,在主流观点之外,还存在着不少误解的看法。

    一方面的原因有些人混用了强弱类型与动静类型,这有历史的原因,前面已经分析了。

    另外还有一个同样重要的原因,即有人把弱类型等同于“完全没有隐式类型转换”了,这种想法并不对。

    事实上,强弱类型的概念中包含着部分相对主义的含义,强类型语言中也可能有隐式类型转换。

    比如,Rust 语言为了实现“内存安全”的设计哲学,设计了很强大的类型系统,但是它里面也有隐式类型转换(自动解引用)。

    问题在于:怎么样的隐式类型转换是在合理范围内的?以及,某些表面的隐式类型转换,是否真的是隐式类型转换?

    回到 Python 的例子,我们可以分析几种典型的用法。

    比如,"test"*3这种字符串“乘法”运算,虽然是两种类型的操作,但是并不涉及隐式类型转换转化。

    比如,x=10; x="test"先后给一个变量不同类型的赋值,表面上看 x 的类型变化了,用 type(x) 可以判断出不同,但是,Python 中的类型是跟值绑定的(右值绑定),并不是跟变量绑定的。

    变量 x 准确地说只是变量名,是绑定到实际变量上的一个标签,它没有类型。type(x) 判断出的并不是 x 本身的类型,而是 x 指向的对象的类型,就像内置函数 id(x) 算出的也不是 x 本身的地址,而是实际的对象的地址。

    比如,1 + True这种数字与布尔类型的加法运算,也没有发生隐式类型转换。因为 Python 中的布尔类型其实是整型的子类,是同一种类型!(如果有疑问,可查阅 PEP-285)

    再比如,整数/布尔值与浮点数相加,在 Python 中也不需要作显式类型转换。但是,它的实现过程其实是用了数字的__add__()方法,Python 中一切皆对象,数字对象也有自己的方法。(其它语言可不一定)

    也就是说,数字间的算术运算操作,其实是一个函数调用的过程,跟其它语言中的算术运算有着本质的区别。

    另外,不同的数字类型虽然在计算机存储层面有很大差异,但在人类眼中,它们是同一种类型(宽泛地分),所以就算发生了隐式类型转换,在逻辑上也是可以接受的。

    最后,还有一个例子,即 Python 在 if/while 之后的真值判断,我之前分析过它的实现原理,它会把其它类型的对象转化成布尔类型的值。

    但是,它实际上也只是函数调用的结果(__bool__() 和 __len__()),是通过计算而得出的合理结果,并不属于隐式的强制类型转换,不在 untrapped errors 的范畴里。

    所以,严格来说,前面 5 个例子中都没有发生类型转换。 浮点数和真值判断的例子,直观上看是发生了类型转换,但它们其实是 Python 的特性,是可控的、符合预期的、并没有对原有类型造成破坏。

    退一步讲,若放宽“隐式类型转换”的含义,认为后两个例子发生了隐式类型转换,但是,它们是通过严谨的函数调用过程实现的,也不会出现 forbidden errors,所以还是属于强检查类型。

    5、其它相关的问题

    前文对概念的含义以及 Python 中的表现,作了细致的分析。接下来,为了逻辑与话题的完整性,我们还需要回答几个小问题:

    (1)能否以“隐式类型转换”作为强弱类型的分类依据?

    明确的分类定义应该以《Type Systems》为准,它有一套针对不同 error 的分类,强弱类型其实是对于 forbidden errors 的处理分类。隐式类型转换是其明显的特征,但并不是全部,也不是唯一的判断依据。

    本文为了方便理解,使用这个主要特征来划分强弱类型,但是要强调,强类型不是没有隐式类型转换,而是可能有很少且合理的隐式类型转换。

    (2)假如有其它解释器令 Python 支持广泛的隐式类型转换,那 Python 还是强类型语言么?

    语言的标准规范就像是法律,而解释器是执法者。如果有错误的执法解释,那法律还是那个法律,应该改掉错误的执法行为;如果是法律本身有问题(造成了解释歧义和矛盾,或者该废弃),那就应该修改法律,保证它的确定性(要么是强类型,要么是弱类型)。

    (3)为什么说 Javascript 是弱类型?

    因为它的隐式类型转换非常多、非常复杂、非常过分!比如,Javascript 中123 + null结果为 123,123 + {}结果为字符串“123[object Object]”。

    另外,它的双等号“==”除了有基本的比较操作,还可能发生多重的隐式类型转换,例如true==['2']判断出的结果为 false,而true==['1']的结果是 true,还有[]==![][undefined]==false的结果都为 true……

    (4)C++ 是不是弱类型语言?

    前文提到《流畅的Python》中将 C++ 归为强类型,但实际上它应该被归为弱类型。C++ 的类型转换是个非常复杂的话题,@樱雨楼 小姐姐曾写过一个系列文章做了系统论述,文章地址:如何攻克 C++ 中复杂的类型转换?详解 C++ 的隐式类型转换与函数重载!谁说 C++ 的强制类型转换很难懂?

    6、小结

    强弱类型概念在网上有比较多的争议,不仅在 Python 是如此,在 C/C++ 之类的语言更甚。

    其实在学术上,这个概念早已有明确的定义,而且事实上也被很多人所接纳。

    那些反对的声音大多是因为概念混用,因为他们忽略了另一种对语言进行分类的维度;同时,还有一部分值得注意的原因,即不能认为强类型等于“完全无隐式类型转换”或“只要没有xxx隐式类型转换”。

    本文介绍了社区中对 Python 的主流分类,同时对几类疑似隐式类型转换的用法进行了分析,论证出它是一种强类型语言。

    文章体现了作者一贯的刨根问底精神,这是“Python为什么”系列文章的风格,如果你喜欢本文,欢迎订阅关注!

    相关链接

    [1] 谁告诉的你们Python是强类型语言!站出来,保证不打你!: https://blog.csdn.net/nokiaguy/article/details/108218260

    [2] Strong versus Weak Typing: https://www.artima.com/intv/strongweak.html

    [3] https://en.wikipedia.org/wiki/Strong_and_weak_typing#cite_note-2

    [4] https://en.wikipedia.org/wiki/Strong_and_weak_typing#cite_note-3

    [5] Type Systems: http://lucacardelli.name/Papers/TypeSystems.pdf

    [6] C 程序员十诫: http://doc.cat-v.org/henry_spencer/ten-commandments

    [7] Why is Python a dynamic language and also a strongly typed language: https://wiki.python.org/moin/Why%20is%20Python%20a%20dynamic%20language%20and%20also%20a%20str

    推荐阅读

    1

    真爱!微软宣布新开源网站,由 Jekyll 一键生成,代码所见即所得

    2

    Python 3.10 明年发布,看看都有哪些新特性?

    3

    Github 30000 Star 的免费 BI 工具:Superset

    4‍‍

    Python 中最好用的 6 个地图可视化库

    崔庆才

    静觅博客博主,《Python3网络爬虫开发实战》作者

    隐形字

    个人公众号:进击的Coder

    长按识别二维码关注

    好文和朋友一起看~

    展开全文
  • 弱类型是什么意思,本文可以给您一点概念!
  • 这是本人关于Typescript的第一篇笔记,之所以选择将“强类型语言和弱类型语言、静态语言和动态语言”作为第一个想要去总结的主题,是因为个人觉得它很重要。 如今这个年代,可以供我们选择的编程语言非常之多,我们...

    foreword(前言)
    这是本人关于Typescript的第一篇笔记,之所以选择将“强类型语言和弱类型语言、静态语言和动态语言”作为第一个想要去总结的主题,是因为个人觉得它很重要。

    如今这个年代,可以供我们选择的编程语言非常之多,我们也不能在我们的编程生涯中仅仅只使用一门语言(除非你能够不断钻研一门语言并达到业界先驱者的层次),所以当我们在使用不同的编程语言时,如果我们连各种语言的性质、区别都不知道的话,我们如何在正确的场合、领域去使用某一种语言并尽可能发挥其优势呢?

    所以,正因为如此,我觉得“强类型语言和弱类型语言、静态语言和动态语言”这个主题我有必要优先去理清它。

    Javascript是一门动态弱类型语言,相应的,也会有静态强类型语言。也就是说,语言可以分为强类型语言和弱类型语言、静态语言和动态语言。

    以下内容基本摘自“极客时间梁宵的视频教程——Typescript”,为了方便回顾,以笔记的方式进行记录。

    强类型语言和弱类型语言

    什么是强类型语言和弱类型语言?

    1.强类型语言

    在强类型语言中,当一个对象从调用函数传递到被调用函数时,其类型必须与被调用函数中声明的类型兼容。——Liskov, Zilles 1974

    这是1974年两位计算机科学家对强类型语言的定义,那我们如何去理解这句话呢?

    让我们来看一下下面的伪代码:

    A() {
      B(x)
    }
    
    B(y) {
      // x可以被赋值给x,且程序能够运行良好
    }
    

    上面伪代码中,A函数中调用B函数,并传入参数x,前面说到的定义就是说参数x能够被赋值给y,并保证函数B的正常运行。

    到目前为止,这个定义还是比较宽泛模糊的,所以后人给出了更加精确的定义:

    强类型语言不允许改变变量的数据类型,除非进行强制类型转换。

    即我们声明的变量,不能被赋值其他类型的变量,除非对赋值的变量先进行强制类型转换。

    2.弱类型语言

    与强类型语言相反,弱类型语言中,变量的值其类型是宽泛的,可以被赋值多种类型的值,比如我们使用的javascript,假如声明了一个变量a,a的值可以是数字1,可以是字符串“abcd”,也可以是对象、数组、函数。。。

    静态语言和动态语言

    首先,给出一个比较通俗的定义:

    • 静态类型语言:在编译阶段确定所有变量的类型;
    • 动态类型语言:在执行阶段确定所有变量的类型;

    首先看一段js代码:

    Javascript:
    
    class C {
    	constructor (x, y) {
    		this.x = x;
    		this.y = y;
        }
    }
    
    function add (a, b) {
    	return a.x + a.y + b.x + b.y;
    }
    

    上面代码在被编译时,完全不知道变量a和b是什么类型,只有当程序运行时,对a、b参数传入值时,才知道变量a和b是什么类型。

    接着,我们再看一段功能类似的C++代码:

    class C {
    	public:
    		int x;
    		int y;
    }
    
    int add (C a, C b) {
    	return a.x + a.y + b.x + b.y;
    }
    

    C++代码在编译的时候就已经能确定变量a和b的类型了。

    接下来,再从内存分配的角度进行对比:

    1.Javascript

    • 在程序运行时,动态计算属性偏移量(对象中的属性a、b相对于对象基地址的偏移量);
    • 需要额外的空间存储属性名;
    • 所有对象的偏移量信息各存一份;

    2.C++

    • 编译阶段确定属性偏移量
    • 用偏移量访问代替属性名访问
    • 偏移量信息共享;

    总结

    强类型语言弱类型语言
    强类型语言不允许改变变量的数据类型,除非进行强制类型转换弱类型语言中,变量的值其类型是宽泛的,可以被赋值多种类型的值
    静态类型语言动态类型语言
    对类型极度严格对类型非常宽松
    立即发现错误Bug可能隐藏数月甚至数年
    运行时性能好运行时性能差
    自文档化可读性差

    基于上面,我们多半会觉得静态语言明显好于动态语言啊,为什么JavaScript现在这么火呢?

    动态类型语言(JavaScript)的支持者认为:

    • 性能是可以改善的(V8引擎),而语言的灵活性更加重要;
    • 隐藏的错误可以通过单元测试发现;
    • 文档可以通过工具生成;

    所以,任何语言其都具有两面性,同时也是在不断发展与进化的,不能一概而论。

    最后给出一张象限图:

    在这里插入图片描述

    last(最后)
    非常感谢您能阅读完这篇文章,您的阅读是我不断前进的动力。

    对于上面所述,有什么新的观点或发现有什么错误,希望您能指出。

    最后,附上个人常逛的社交平台:
    知乎:https://www.zhihu.com/people/bi-an-yao-91/activities
    csdn:https://blog.csdn.net/YaoDeBiAn
    github: https://github.com/yaodebian

    个人目前能力有限,并没有自主构建一个社区的能力,如有任何问题或想法与我沟通,请通过上述某个平台联系我,谢谢!!!

    展开全文
  • 主要介绍了PHP弱类型语言中类型判断操作,结合实例形式分析了php中针对数据类型的转换、判断及函数使用技巧与注意事项,需要的朋友可以参考下
  • 了解 JavaScript 的同学都知道,它也是弱类型语言,声明变量时也不需要指定类型,但好歹我们还需要使用声明关键词的(虽然可以省去不用,但是非常不建议)。 而python 不管这些,老夫就是直接开干,别跟我扯那些...

    我们从第一个「hello world」开始。首先我们先进入电脑的控制台输入 python3 进入 python 解释器模式。

    例如我以 Mac 为例 在 iTerm 终端输入 python3 会进入解释器模式。Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 16:52:21)

    [Clang 6.0 (clang-600.0.57)] on darwin

    Type "help", "copyright", "credits" or "license" for more information.

    >>>

    此时我们输入 ```print("hello world’)````就可以打印出 「hello world」了。

    我们的第一个 python 程序就这么愉快的完成了。下面我们就开始来认识 python。

    弱类型

    首先 python 是弱类型语言,相对于强类型语言,它不需要声明变量的类型。甚至粗暴到连声明关键字都省略了。

    了解 JavaScript 的同学都知道,它也是弱类型语言,声明变量时也不需要指定类型,但好歹我们还需要使用声明关键词的(虽然可以省去不用,但是非常不建议)。

    而python 不管这些,老夫就是直接开干,别跟我扯那些没有用的。难怪大家都说「人生苦短,我用python」。光看变量声明,就让我感受到了。期待更加深入的学习。int age = 0; // java 声明一个整数型的变量

    var age = 0; //js 声明一个变量 age 不指定数据类型。

    age = 0; // python 直接声明

    解释执行

    第二个特点是它属于「解释执行」类型语言。就如开头我们所说会进入 python 解释器模式,而这个解释器就是用来解释 python 语言的。

    弄清楚之前,先简单了解下什么是「编译执行」与「解释执行」,以下都是大白话介绍可更好理解,如果不觉得严谨的可查阅相关资料。

    首先计算机只认识二进制这个大家都知道。所以编写的程序都要先转成二进制代码才可以运行。否则计算机不认识啥都百搭。

    但计算机认识的东西,人类看起来就很痛苦而且写起来简直生不如死。怎么办呢?这就是人类的聪明之处了,我先写认识的,然后通过一种方式在转成机器认识的不就完了吗。

    而在转换的过程中有两种实现方式:第一种就是:先编译好在执行。第二种就是:执行的过程中再编译,即:边执行边编译。

    所以先编译好再执行的对应的就是「编译执行」,边执行边编译的就是「解释执行」。

    例如 C、C++:这类语言就属于「编译执行」,它们的优点在于只编译一次,执行速度快。而缺点是不能夸平台。

    而像 Python、JavaScript 这类语言属于「解释执行」,它们的优点在于跨平台,不管在window 还是其他平台都可以执行。但缺点就是每次执行都会编译所以速度慢。

    python 代码的执行步骤大概是:

    开头说 python 的解释器,我们写的每一行 python 代码都是由它负责,解释器由一个编译器和一个虚拟机构成,编译器负责将源代码转换成字节码文件,而虚拟机负责执行字节码。

    python 代码在运行前每个 .py 文件将被换转成 .pyc 文件,.pyc 就是一种字节码文件。

    上下执行

    我们人类在读一篇文章的时候会从左至右,从上到下的顺序进行阅读。而机器也是如此,它在阅读代码的时候也是「从上而下」进行阅读。

    所以它的代码执行顺序就是「上下执行」,第一行没有执行完,就不会执行第二行。但如果只有「上下执行」好像并不能满足我们所有的需求。

    继续拿看书来说:

    比如你在书中看到一段看不懂的话,你会怎么做?我会去多看几遍,直到看懂为止。

    如果有很多我不想看的内容怎么办?我会把不想看的内容直接跳过去,选择我喜欢看的内容。

    那程序是如何做到这点的呢?下个章节我们来详细程序该如何执行。

    展开全文
  • 主要介绍了弱类型语言javascript中 a,b 的运算,结合实例形式总结分析了js闭包函数中布尔值与字符串的a,b运算相关操作技巧,需要的朋友可以参考下
  • 强类型语言和弱类型语言的区别

    千次阅读 2019-11-29 11:16:39
    强类型语言和弱类型语言主要是变量类型的处理方式 强类型语言不存在隐式转换,弱类型语言可以 强类型语言和弱类型语言的区别 弱类型语言主要有JS,PHP,这两类语言他可以进行隐式转换,隐式转换就是两个不同类型的...
  • C是强类型语言,但是事实真是如此吗? 首先关于强类型语言的定义 “一旦某一个变量被定义类型,如果不经过强制转换,则它永远就是该数据类型了” 在《C专家编程》一书中,明确的表明C是排斥强类型的,因为C语言最初的...
  • 强类型:不允许不同类型相加动态:不使用显示数据类型声明,且确定一个变量的类型是在第一次给它赋值的时候脚本语言:一般也是解释型语言,运行代码只需要一个解释器,不需要编译强类型语言和弱类型语言1....
  • 弱类型语言和强类型语言

    万次阅读 多人点赞 2018-03-06 22:05:27
    一、强类型语言 强类型语言是一种强制类型定义的语言,一旦某一个变量被定义类型,如果不经过强制转换,则它永远就是...二、弱类型语言 弱类型语言是一种弱类型定义的语言,某一个变量被定义类型,该变量可以根据...
  • Python到底是强类型语言,还是弱类型语言

    千次阅读 多人点赞 2020-08-30 20:58:19
    点击上方蓝字Python猫,设为星标,第一时间接收优质文章0、前言我在上一篇文章中分析了 为什么 Python 没有 void 类型 的话题,在文章发布后,有读者跟我讨论起了另一个关于类...
  • 文章目录Java强类型语言JavaScript弱类型语言 Java强类型语言 Java 的安全性、健壮性和严谨性是强类型语言的一重要体现。 Java强类型语言所以对数据类型兼容性的要求比任何语言都要严格. 每个变量有类型,每个...
  • 强类型语言和弱类型语言

    万次阅读 多人点赞 2014-11-03 16:30:01
    我们先看看编译型,其实它和汇编语言是一样的:也是有一个负责翻译的程序来对我们的源代码进行转换,生成相对应的可执行代码。这个过程说得专业一点,就称为编译(Compile),而负责编译的程序自然就称为编译器...
  • 在学习JavaScript的时候,说JavaScript是弱类型语言。那为什么JavaScript是弱类型语言呢。 但是在此之前我们需要了解一下弱类型语言,和强类型语言的区别。 强类型定义语言和弱类型定义语言 1)强类型定义语言: ...
  • 弱类型语言为何不堪大用

    千次阅读 2018-10-27 09:53:18
    弱类型语言为何不堪大用 最近一直用node.js python 其灵活性,库和包之多也让人惊喜万分。如此美好的东西不何不堪大用,原因也是他的优点,它的灵活性加上人的懒惰性就是它不堪大用的根本原因。 拿来主义向来是编程...
  • PHP作为一门简单而强大的语言,能够提供很多Web适用的语言特性,而从本期《问底》开始,王帅将从实践出发,带你弄清PHP内核中一些常用的部分,比如这里的“弱类型变量原理”。PHP是一门简单而强大的语言,提供了很多...
  • 主要介绍了弱类型语言javascript开发中的一些坑,结合实例形式总结分析了javascript开发中关于变量、函数、数组、对象、作用域等相关知识点常见易错问题,需要的朋友可以参考下
  • 首先要清楚静态类型语言和动态类型语言的判别的标准 定义:如果类型检查发生在编译阶段(compile time),那么是静态类型语言(statically typed languages)中,相反的,如果类型检查发生在运行阶段(run time),那么是...
  • 动态语言和静态语言 1.动态类型语言:是指在运行...2.静态类型语言:与动态类型语言刚好相反,它的数据类型检查发生在在编译阶段,也就是说在写程序时要声明变量的数据类型。C/C++、C#、Java都是静态类型语言的典型...
  • 为什么JavaScript是弱类型语言

    万次阅读 多人点赞 2018-03-08 12:48:06
    在学习JavaScript的时候,说JavaScript是弱类型语言。那为什么JavaScript是弱类型语言呢。 但是在此之前我们需要了解一下弱类型语言,和强类型语言的区别。 强类型定义语言和弱类型定义语言 1)强类型定义语言...
  • 1.强类型语言指的是一旦...弱类型语言指的是定义变量后,该变量可以根据不同的环境来调整自己的类型。如Javascript,3.总的来讲,弱类型语言更加便利,但是容易发生错误。而强类型语言可以很好的避免一些程序错误。...
  • python是强类型语言还是弱类型语言

    千次阅读 2018-08-18 20:17:36
    Python属于强类型的动态脚本语言类型:不予许不同类型相加 动态:不使用显示数据声明类型,且确定一个变量的类型是第一次给他赋值的时候 脚本语言:一般也是解释性语言,运行代码只需要一个解释器,不需要编译...
  • 如何理解PHP是弱类型语言

    千次阅读 2018-06-12 15:52:01
    1、php变量类型8种标量类型:布尔boolean,整形integer,浮点float,字符string复杂类型:数组array,对象object特殊类型:资源resource,空null
  • 先丢一下概念: * 强类型:在开辟变量存储空间时,定义了空间将来存储的数据的数据类型。...强类型语言也称为强制类型定义语言,例如java、.NET、Python,C#等都是强类型语言,以java为例, 创建了一个变量 St...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 135,422
精华内容 54,168
关键字:

弱类型语言

友情链接: an2557.zip