blocks|key|1159660|text|传统上，程序是编译的，脚本是解释的，但这已经不再重要了。如果您真的想要的话，您可以生成大多数脚本的编译版本，而其他像Java这样的“编译”语言实际上是被解释的(在字节码级别)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1159661|一个更现代的定义可能是，程序打算由客户使用(可能是内部的)，因此应该包括文档和支持，而脚本主要是供作者使用的。|1159662|网络是一个有趣的反例。我们都喜欢用谷歌搜索引擎来查找东西。创建它引用的“数据库”的大部分代码仅供其作者和维护人员使用。这就成了剧本吗？|1159663|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Traditionally a program is compiled and a script is interpreted, but that is not really important anymore. You can generate a compiled version of most scripts if you really want to, and other 'compiled' languages like Java are in fact interpreted (at the byte code level.)

A more modern definition might be that a program is intended to be used by a customer (perhaps an internal one) and thus should include documentation and support, while a script is primarily intended for the use of the author.

The web is an interesting counter example. We all enjoy looking things up with the Google search engine. The bulk of the code that goes into creating the 'database' it references is used only by its authors and maintainers. Does that make it a script?

blocks|key|842954|text|我要说的是，应用程序倾向于交互使用，其中脚本将运行其过程，适合批处理工作。我不认为这是一个具体的区别。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|842955|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would say that an application tends to be used interactively, where a script would run its course, suitable for batch work. I don't think it's a concrete distinction.

blocks|key|160820|text|通常，它是“脚本”和“程序”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|160821|我同意你的看法，这一区别主要是“汇编语言势利”，或者引用拉里·沃尔的话，把栅栏的另一边放在一边，“演员有剧本，给观众一个节目”。|160822|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Usually, it is "script" versus "program".

I am with you that this distinction is mostly "compiled language snobbery", or to quote Larry Wall and take the other side of the fence, "a script is what the actors have, a programme is given to the audience".

blocks|key|847271|text|这是一个有趣的话题，我不认为有很好的指南来区分“脚本”和“应用程序”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|847272|让我们来看看维基百科的一些文章，来感受一下两者的区别。|847273|脚本+(维基百科->脚本语言)：|offset|length|847274|脚本语言、脚本语言或扩展语言是控制软件应用程序的编程语言。“脚本”通常被视为与“程序”不同，后者独立于任何其他应用程序执行。同时，它们与应用程序的核心代码不同，后者通常是用不同的语言编写的，通过对最终用户进行访问，它们使应用程序的行为能够适应用户的需要。|blockquote|847275|应用程序+(维基百科->应用软件->术语)|847276|在计算机科学中，应用程序是为帮助人们完成某种类型的工作而设计的计算机程序。因此，应用程序不同于操作系统(运行计算机)、实用程序(执行维护或通用杂务)和编程语言(用于创建计算机程序)。根据设计的工作，应用程序可以操纵文本、数字、图形或这些元素的组合。|847277|阅读上述条目似乎表明，区别在于脚本是由另一段软件“托管”的，而应用程序则不是。我认为这是可以争辩的，例如控制shell行为的shell脚本，以及控制解释器行为以执行所需操作的perl脚本。(我觉得这可能有点牵强，所以我可能不完全同意。)|847278|说到这一点，我认为口语化的区别可以用程序的比例来区分。与应用程序相比，脚本的规模通常更小。|style|BOLD|847279|此外，就目的而言，脚本通常执行需要处理的任务，例如，构建脚本，为某一特定软件生成多个版本。另一方面，应用程序面向的是提供更精细和面向最终用户的功能。例如，记事本或Firefox。|847280|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Scripting_language|1|http://en.wikipedia.org/wiki/Application_software#Terminology^0|0|0|0|2|0|0|0|0|4|1|0|0|0|L|2|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@$F|19|G|1A|1|1B]]|A|$]]|$1|H|3|I|5|J|7|1C|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1D|8|@]|9|@$F|1E|G|1F|1|1G]]|A|$]]|$1|M|3|N|5|J|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@$F|1K|G|1L|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1M|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|X|$Y|$5|Z|10|11|A|$12|13]]|14|$5|Z|10|11|A|$12|15]]]]

This is an interesting topic, and I don't think there are very good guidelines for the differentiating a "script" and a "application."

Let's take a look at some Wikipedia articles to get a feel of the distinction.

<a href="http://en.wikipedia.org/wiki/Scripting_language" rel="noreferrer" title="Scripting language">Script</a> (Wikipedia -> Scripting language):

<blockquote>
 A scripting language, script language or extension language, is a programming language that controls a software application. "Scripts" are often treated as distinct from "programs", which execute independently from any other application. At the same time they are distinct from the core code of the application, which is usually written in a different language, and by being accessible to the end user they enable the behavior of the application to be adapted to the user's needs.
</blockquote>

<a href="http://en.wikipedia.org/wiki/Application_software#Terminology" rel="noreferrer" title="Application">Application</a> (Wikipedia -> Application software -> Terminology)

<blockquote>
 In computer science, an application is a computer program designed to help people perform a certain type of work. An application thus differs from an operating system (which runs a computer), a utility (which performs maintenance or general-purpose chores), and a programming language (with which computer programs are created). Depending on the work for which it was designed, an application can manipulate text, numbers, graphics, or a combination of these elements.
</blockquote>

Reading the above entries seems to suggest that the distinction is that a script is "hosted" by another piece of software, while an application is not. I suppose that can be argued, such as shell scripts controlling the behavior of the shell, and perl scripts controlling the behavior of the interpreter to perform desired operations. (I feel this may be a little bit of a stretch, so I may not completely agree with it.)

When it comes down to it, it is in my opinion that the colloquial distinction can be made in terms of the scale of the program. Scripts are generally smaller in scale when compared to applications. 

Also, in terms of the purpose, a script generally performs tasks that needs taken care of, say for example, build scripts that produce multiple release versions for a certain piece of software. On the otherhand, applications are geared toward providing functionality that is more refined and geared toward an end user. For example, Notepad or Firefox.

blocks|key|847295|text|John+(TCL的发明者)在http://www.tcl.tk/doc/scripting.html上有一篇很好的文章，他在文章中提出了系统编程语言(用于实现构建块、强调正确性、类型安全性)与脚本语言(用于组合构建块、强调对不断变化的环境和需求的响应性、易于在文本表示中转换)之间的区别。如果您使用这个分类系统，那么99%25的程序员所做的工作更适合脚本语言，而不是系统编程语言。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|847296|entityMap|0|LINK|mutability|MUTABLE|url|http://www.tcl.tk/doc/scripting.html^0|F|10|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

John Ousterhout (the inventor of TCL) has a good article at <a href="http://www.tcl.tk/doc/scripting.html" rel="nofollow noreferrer">http://www.tcl.tk/doc/scripting.html</a> where he proposes a distinction between system programming languages (for implementing building blocks, emphasis on correctness, type safety) vs scripting languages (for combining building blocks, emphasis on responsiveness to changing environments and requirements, easy conversion in and out of textual representations). If you go with that categorisation system, then 99% of programmers are doing jobs that are more appropriate to scripting languages than to system programming languages.

blocks|key|847120|text|脚本对我来说意味着代码的逐行解释。您可以打开脚本并查看其程序员可读的内容。应用程序意味着独立编译的可执行文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|847121|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Script to me implies line-by-line interpretation of the code. You can open a script and view its programmer-readable contents. An application implies a stand-alone compiled executable.

blocks|key|1159875|text|它通常只是一个语义论证，甚至是诋毁某些编程语言的一种方式。就我而言，“脚本”是一种程序类型，确切的定义有点模糊，并且随着上下文的不同而变化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1159876|我可能会用“脚本”这个术语来指一个程序，它主要是线性执行的，而不是有大量的顺序逻辑或子程序，就像好莱坞的“脚本”是演员执行的一个线性指令序列一样。我可以用它来表示一个程序，它是用嵌入在更大程序中的一种语言编写的，目的是驱动这个程序。例如，在旧的Mac下使用AppleScript自动执行任务，或者以某种方式驱动带有嵌入式TCL接口的程序。|1159877|但在所有这些情况下，脚本是一种程序类型。|1159878|“脚本语言”一词已被用于动态解释(有时是编译)语言，通常这些语言具有许多共同的特性，如非常高级的指令、以散列和任意长度列表构建的以及其他高级数据结构等。但是，这些语言具有非常大的、复杂的、模块化的、设计良好的程序，所以如果您认为“脚本”不是程序，那么这个术语可能会使您感到困惑。|1159879|另见它是一个Perl程序还是一个Perl脚本？+in+perlfaq1。|offset|length|1159880|entityMap|0|LINK|mutability|MUTABLE|url|http://search.cpan.org/~rgarcia/perl-5.10.0/pod/perlfaq1.pod#Is_it_a_Perl_program_or_a_Perl_script?^0|0|0|0|0|2|L|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|V|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@$J|Y|K|Z|1|10]]|A|$]]|$1|L|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|M|$N|$5|O|P|Q|A|$R|S]]]]

It's often just a semantic argument, or even a way of denigrating certain programming languages. As far as I'm concerned, a "script" is a type of program, and the exact definition is somewhat vague and varies with context.

I might use the term "script" to mean a program that primarily executes linearly, rather than with lots of sequential logic or subroutines, much like a "script" in Hollywood is a linear sequence of instructions for an actor to execute. I might use it to mean a program that is written in a language embedded inside a larger program, for the purpose of driving that program. For example, automating tasks under the old Mac OS with AppleScript, or driving a program that exposes itself in some way with an embedded TCL interface.

But in all those cases, a script is a type of program.

The term "scripting language" has been used for dynamically interpreted (sometimes compiled) languages, usually these have a lot of common features such as very high level instructions, built in hashes and arbitrary-length lists and other high level data structures, etc. But those languages are capable of very large, complicated, modular, well-designed programs, so if you think of a "script" as something other than a program, that term might confuse you.

See also <a href="http://search.cpan.org/~rgarcia/perl-5.10.0/pod/perlfaq1.pod#Is_it_a_Perl_program_or_a_Perl_script?" rel="nofollow noreferrer">Is it a Perl program or a Perl script?</a> in perlfaq1.

blocks|key|842995|text|脚本通常作为脚本引擎内较大应用程序的一部分运行，例如。JavaScript+->浏览器--这与传统的静态类型化编译语言和动态语言形成了对比，后者的代码旨在构成应用程序的主要部分。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|842996|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A script generally runs as part of a larger application inside a scripting engine
eg. JavaScript -> Browser
This is in contrast to both traditional static typed compiled languages and to dynamic languages, where the code is intended to form the main part of the application.

blocks|key|843129|text|应用程序是一组针对一组常见问题的脚本集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|843130|脚本是执行一项相当特定的任务的代码。|843131|海事组织，这种区别与所使用的语言无关。可以用bash编写复杂的应用程序，也可以用C%2B%2B编写简单的脚本。|843132|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

An application is a collection of scripts geared toward a common set of problems.

A script is a bit of code for performing one fairly specific task.

IMO, the difference has nothing whatsoever to do with the language that's used. It's possible to write a complex application with bash, and it's possible to write a simple script with C++.

blocks|key|160965|text|就我个人而言，我认为这种分离是离实际实施倒退一步。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|160966|据我估计，一个应用程序已经计划好了。它有多个目标，有多个可实现的目标。在编写代码之前，有一些任务在设计时预留给应用程序必须满足。|160967|然而，一个脚本只是作为合适的组合在一起，很少涉及计划。|160968|然而，缺乏适当的计划并不会将您降级为脚本。它可能会使您的应用程序成为一个组织不良的脚本集合。|160969|此外，应用程序还可以包含聚集在一起的脚本。但是脚本只能引用应用程序。|160970|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Personally, I think the separation is a step back from the actual implementation.

In my estimation, an application is planned. It has multiple goals, it has multiple deliverables. There are tasks set aside at design time in advance of coding that the application must meet. 

A script however, is just thrown together as suits, and little planning is involved. 

Lack of proper planning does not however downgrade you to a script. Possibly, it makes your application a poorly organized collection of poorly planned scripts. 

Further more, an application can contain scripts that aggregated comprise the whole. But a script can only reference an application.

blocks|key|1159716|text|以perl为例，您可以编写perl脚本或perl应用程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1159717|一个脚本意味着一个文件或一个名称空间。(如updateFile.pl)。|1159718|应用程序将由一组文件或名称空间/类组成(例如，一个带有许多.pm模块文件的OO设计的perl应用程序)。|1159719|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Taking perl as an example, you can write perl scripts or perl applications.

A script would imply a single file or a single namespace. (e.g. updateFile.pl).

An application would be something made up of a collection of files or namespaces/classes (e.g. an OO-designed perl application with many .pm module files).

blocks|key|1160063|text|一个应用程序很大，会被人们一遍又一遍地使用，可能会卖给客户。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1160064|一个脚本从小到小，如果你幸运的话保持小，很少卖给客户，或者自动运行，或者被废弃。|1160065|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

An application is big and will be used over and over by people and maybe sold to a customer.

A script starts out small, stays small if you're lucky, is rarely sold to a customer, and might either be run automatically or fall into disuse.

blocks|key|1160067|text|首先，我想清楚地表明，--一个脚本--是一个程序。换句话说，脚本是一组指令。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1160068|计划：|1160069|要编译的一组指令称为程序。|1160070|脚本：|1160071|将被解释的一组指令称为脚本。|1160072|entityMap^0|B|D|0|0|3|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|Z|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|O|$]]

First of all, I would like to make it crystal clear that a script is a program. In other words, a script is a set of instructions.

Program:

A set of instructions which is going to be compiled is known as a Program.

Script:

A set of instructions which is going to be interpreted is known as a Script.

blocks|key|1160106|text|那麽：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1160107|脚本：|offset|length|style|BOLD|1160108|脚本是用一种语言编写的编程语句的文本文件(或文本文件集合)，该语言允许在执行之前直接将所编写的单个语句解释为机器可执行的代码，并以此为目的执行。|blockquote|1160109|Application:|1160110|应用程序是指其主要功能包括向人工角色提供服务的任何计算机程序。|1160111|因此，理论上讲，用脚本语言编写的基于脚本的程序在执行脚本时可以更改其文本语句(当然，这很有风险)。编译程序的类似情况是在内存中翻转位。|1160112|有学生吗？)|1160113|entityMap^0|0|0|3|0|0|2|12|M|1Q|A|0|0|C|0|0|V|0|0|1V|0|0|6|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@$D|Z|E|10|F|G]|$D|11|E|12|F|G]|$D|13|E|14|F|G]]|9|@]|A|$]]|$1|K|3|L|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|M|3|N|5|J|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1E|8|@$D|1F|E|1G|F|G]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|T|$]]

What about:

Script:

<blockquote>
 A script is text file (or collection of text files) of programming statements written in a language which allows individual statements written in it to be interpreted to machine executable code directly before each is executed and with the intention of this occurring.
</blockquote>

Application:

<blockquote>
 An application is any computer program whose primary functionality involves providing service to a human Actor.
</blockquote>

A script-based program written in a scripting language can therefore, theoretically, have its textual statements altered while the script is being executed (at great risk of , of course). The analogous situation for compiled programs is flipping bits in memory.

Any takers? :)

blocks|key|1160136|text|@杰夫的回答是好的。我最喜欢的解释是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1160137|很多(大多数？)脚本语言被解释，很少有编译语言被认为是脚本语言，但是编译和解释的问题只是松散地与“脚本”和“严肃”语言的问题联系在一起。这里的许多问题是，“脚本”是一个相当模糊的名称--它意味着一种便于用脚本编写的语言，而不是编写“成熟的程序”(或应用程序)。但是如何区分复杂的脚本和简单的应用程序呢？这是一个本质上无法回答的问题。通常，脚本是应用于某一组数据的一系列命令，可能是以用户定义的顺序.但是，我们可以将这种描述扩展到Photoshop，这显然是一个主要的应用程序。脚本通常比应用程序小，做一些定义明确的事情，并且使用起来“更简单”，并且通常可以分解成一个清晰的子操作系列，但所有这些都是主观的。|blockquote|1160138|引用自这里。|offset|length|1160139|entityMap|0|LINK|mutability|MUTABLE|url|https://mail.python.org/pipermail/tutor/2003-June/022867.html^0|0|0|3|2|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|S|8|@]|9|@$G|T|H|U|1|V]]|A|$]]|$1|I|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|J|$K|$5|L|M|N|A|$O|P]]]]

@Jeff's answer is good. My favorite explanation is

<blockquote>
 Many (most?) scripting languages are interpreted, and few compiled 
 languages are considered to be scripting languages, but the question
 of compiled vs. interpreted is only loosely connected to the question
 of "scripting" vs. "serious" languages. 
 
 A lot of the problem here is that "scripting" is a pretty vague 
 designation -- it means a language that's convenient for writing
 scripts in, as opposed to writing "full-blown programs" (or
 applications). But how does one distinguish a complex script from a
 simple application? That's an essentially unanswerable question. 
 Generally, a script is a series of commands applied to some set of
 data, possibly in a user-defined order... but then, one could stretch
 that description to apply to Photoshop, which is clearly a major
 application. Scripts are generally smaller than applications, do
 some well-defined thing and are "simpler" to use, and typically can
 be decomposed into a clear series of sub-operations, but all of these
 things are subjective.
</blockquote>

Referenced from <a href="https://mail.python.org/pipermail/tutor/2003-June/022867.html" rel="nofollow">here</a>.

blocks|key|1160162|text|我认为，无论是编译代码还是解释代码，都是没有问题的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1160163|真正的区别在于代码的核心逻辑：|1160164|如果代码产生的新功能没有在系统中的其他程序中实现，那么它就是一个程序。它甚至可以被脚本操纵。|unordered-list-item|1160165|如果代码主要由其他程序的操作操作，而总体结果主要是被操纵程序的工作结果--这是一个脚本。字面上是一些程序的动作脚本。|1160166|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|J|$]]

I think that there is no matter at all whether code is compiled or interpreted.

The true difference is in core logic of code: 

<ul>
<li>If code makes new functionality that is not implemented in other programs in system - it's a program. It even can be manipulated by a script. </li>
<li>If code is MAINLY manipulates by actions of other programs and total result is MAINLY the results of work of manipulated programs - it's a script. Literally a script of actions for some programs.</li>
</ul>

blocks|key|1159819|text|实际上，脚本(或脚本语言)与应用程序之间的区别在于，脚本不需要将其编译成机器语言。使用解释器运行脚本的源代码。应用程序将源代码编译为机器代码，以便将其作为独立的应用程序运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1159820|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Actually the difference between a script ( or a scripting language) and an application is that a script don't require it to be compiled into machine language.. You run the source of the script with an interpreter.. A application compiles the source into machine code so that you can run it as a stand alone application.

blocks|key|161007|text|我想说的是，脚本通常是由托管应用程序(浏览器、命令解释器或shell，.)执行的以纯文本编写的命令或指令集。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|161008|这并不意味着它在实际执行时不强大或不以某种方式编译。但是脚本本身不能做任何事情，它只是纯文本。|161009|从本质上说，它只能是一个片段，需要组合起来构建一个程序或应用程序，但是扩展和充分开发的脚本或脚本集在主机执行时可以被视为程序或应用程序，就像一堆源文件一旦编译就可以成为应用程序一样。|161010|entityMap^0|I|Q|1B|7|0|0|1B|0|0|2J|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|K|$]]

I would say a script is usually a set of commands or instructions written in plain text that are executed by a hosting application (browser, command interpreter or shell,...). 

It does not mean it's not powerfull or not compiled in some way when it's actually executed. But a script cannot do anything by itself, it's just plain text. 
By nature it can be a fragment only, needing to be combined to build a program or an application, but extended and fully developed scripts or set of scripts can be considered programs or applications when executed by the host, just like a bunch of source files can become an application once compiled.

blocks|key|842968|text|脚本语言没有标准的库或平台(或者没有标准库或平台)。它体积小，重量轻，专为嵌入更大的应用程序而设计。Bash和Javascript是脚本语言的很好的例子，因为它们的功能完全依赖于其他程序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|842969|使用此定义，脚本是设计用来驱动更大的应用程序(套件)的代码。Javascript可能会调用Firefox打开窗口或操作DOM。Bash脚本执行现有程序或其他脚本，并将它们与管道连接在一起。|842970|您还会问为什么不使用脚本语言，所以：|842971|是否有任何用于脚本语言的单元测试工具？对于完全缺失的“真实”应用程序来说，这似乎是一个非常重要的工具。而且很少有真正的脚本语言库绑定。|842972|大多数情况下，脚本可以被一种真正的、轻量级的语言所取代，比如Python或Ruby。|842973|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

A scripting language doesn't have a standard library or platform (or not much of one). It's small and light, designed to be embedded into a larger application. Bash and Javascript are great examples of scripting languages because they rely absolutely on other programs for their functionality.

Using this definition, a script is code designed to drive a larger application (suite). A Javascript might call on Firefox to open windows or manipulate the DOM. A Bash script executes existing programs or other scripts and connects them together with pipes.

<hr>

You also ask why not scripting languages, so:

Are there even any unit-testing tools for scripting languages? That seems a very important tool for "real" applications that is completely missing. And there's rarely any real library bindings for scripting languages.

Most of the times, scripts could be replaced with a real, light language like Python or Ruby anyway.

I'm referring to distinctions such as in <a href="https://stackoverflow.com/questions/17231/why-shouldnt-i-bet-the-future-of-the-company-on-shell-scripts#92305">this answer</a>:

<blockquote>
 ...bash isn't for writing applications it's for, well, scripting. So sure, your application might have some housekeeping scripts but don't go writing <code>critical-business-logic.sh</code> because another language is probably better for stuff like that.
</blockquote>

As programmer who's worked in many languages, this seems to be C, Java and other compiled language snobbery. I'm not looking for reenforcement of my opinion or hand-wavy answers. Rather, I genuinely want to know what technical differences are being referred to.

(And I use C in my day job, so I'm not just being defensive.)

What's the difference between a "script" and an "application"?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我指的是像这样的区别...bash不是用来编写应用程序的，而是用来编写脚本的。因此，您的应用程序可能有一些内务脚本，但是不要编写critical-business-logic.sh，因为另一种语言可能更适合这样的东西。作为使用过多种语言的程序员，这似乎是C、Java和其他编译语言的势利。我并不是在寻求对我的意见或手摇式回答的重新执行。相反，我真的想知道所指的技术差异是什么。(我在日常工作中使用C，

问“脚本”和“应用程序”有什么区别？
EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“脚本”和“应用程序”有什么区别？EN

回答 19

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“脚本”和“应用程序”有什么区别？
EN