十六种编程语言的环境配置2021版（建议收藏）

19年曾经总结过一些自己用过的编程语言环境，尽管类似gcc、javap这些经典工具变化不大，但像Scala、groovy、Q#这些发展迅速的语言变化剧烈，19年版已经不适用了。虽然目前很多语言我也不常使用，但还是更新了一下这些语言的环境配置方法，包括汇编、C&C++、Java、Scala、Groovy、.Net相关语言等。面向自学之人，以简单快捷为初衷，所以未必适合一些大的项目。

汇编

Step1 由于MASM与64位系统不兼容，故需下载DOSBox，若链接失效，请移步DOSBOx官网，下载完成后安装。

Step2 下载MASM工具包，可以在网上搜到，资源有很多。下载之后解压，得到MASM文件夹，内部文件包括

CREF.EXE	DEGUB.EXE	ERROUT.EXE	EXEMOD.EXE	EXEPACK.EXE
LIB.EXE	LINK.EXE	MAKE.EXE	MASM.EXE	SETENV.EXE

将该文件夹复制到某盘符的根目录下。

Setp3 安装DosBox。打开之后，弹出DOSBox Status Window,其内容为

...
Writing it to C:\Users\Laser\AppData\Local\DOSBox\dosbox-0.74.conf
CONFIG:Loading primary settings from config file C:\Users\Laser\AppData\Local\DOSBox\dosbox-0.74.conf
MIDI:Opened device:win32

根据提示，打开config file，在文档末尾加上一行mount D D:/MASM，mount后的内容为MASM的绝对路径。这行的意思可以理解为将D:/MASM设置为DOS环境的D盘。

step4 新建工作文件夹，并编写汇编程序。例如，在MASM文件夹下新建文件test.asm。

DSEG    SEGMENT
MESS    DB   'Hello,World!' ,0DH,0AH,24H
DSEG    ENDS

SSEG    SEGMENT PARA STACK 
        DW  256 DUP(?)
SSEG    ENDS

CSEG    SEGMENT
        ASSUME  CS:CSEG,DS:DSEG
BEGIN:  MOV AX,DSEG
        MOV DS,AX
        MOV DX,OFFSET MESS
        MOV AH,9

        INT 21H
        MOV AH,4CH
        INT 21H
CSEG    ENDS
        END  BEGIN

在命令行中输入masm，命令行会提示源码名等内容，依次输入，不需写后缀。

D:\>masm
Microsoft (R) Macro Assembler Version 5.00
Copyright (C) Microsoft Corp 1981-1985, 1987. All rights reserved.

Source filename [.ASM]: test
Object filename [test.OBJ]: test
Source listing [NUL.LST]: test
Cross-referene [NUL.CRF]: test

    50630 + 465914 Bytes symbol space free

        0 Warning Errors
        0 Severe Errors

此时文件夹中生成了相应的test.obj,test.lst,test.crf文件。

然后输入link，过程与刚刚大同小异，由于我们没有需要链接的库，所以Libraries为空。其实除了Object必须填写之外，其他值为空即生成默认文件。

D:\>link
Microsoft (R) Overlay Linker 3.60
Copyright (C) Microsoft Corp 1983-1987. All rights reserved.

Object Modules [.OBJ]: test
Run File [TEST.EXE]: test
List File [NUL.MAP]: test
Libraries [.LIB]:
Enter new file spec:

然后就生成了test.exe文件。运行一下

D:\>test.exe
Hello,World!

GCC(C&C++、Fortran)

安装GCC&G++

C语言IDE实在是比较多，例如Dev-Cpp, Code::Blocks, C-Free，甚至还有宇宙最强的VS。

在Linux下常用的编译器为GCC，所以对于常用Linux的人来说，windows上最好也装一款。

Step1 下载MinGW并运行。

Step2 将安装文件夹加入环境变量。右键我的电脑–>属性–>高级系统设置–>环境变量–>双击Path–>新建，填入MinGW的安装路径。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hCk9oZQs-1633997894357)(skills/envir.PNG)]

Step3 Win+R或在开始菜单中点击运行，输入cmd进入命令行，输入mingw-get，弹出MinGW Installation Manager窗口，说明环境变量设置正确。

Step4 安装gcc，有两种方法

• 在cmd中输入mingw-get install gcc，g++，gdb同理。
• 在安装管理窗口安装，选中想要安装的包，右键Mark for Installation，选中之后点击菜单栏Installation->Update Catalogue。

基本用法

以代码

//test.c
#include
int main(){
     
    printf("hello world");
    return 0;
}

为例，在命令行中输入gcc .\test.c会自动生成可执行文件a.exe。

PS E:\Code\PL\all> gcc .\test.c
PS E:\Code\PL\all> .\a.exe
hello world

其正常的编译包括预处理、编译、汇编、链接等过程，

PS E:\Code\PL\all> gcc -E test.c -o test.i  #预处理
PS E:\Code\PL\all> gcc -S test.i -o test.s  #编译
PS E:\Code\PL\all> gcc -c test.s -o test.o  #汇编

gcc常用选项包括

选项	作用
o	生成目标
c	取消链接，编译源码，生成目标文件
E	预编译
S	生成汇编语言
g	嵌入调试信息
llib	即link lib，链接lib库
Idir	即include dir，增加include目录
LDir	增加lib目录

gdb调试

为了展示一些调试的细节，新建一个C语言文件

#include

int fac(int n){
     
    if(n<0){
     
        printf("input error");
        return 0;
    }
    return n>1 ? n*fac(n-1):1;
}

int main(){
     
    int a;
    scanf("%d",&a);
    printf("%d",fac(a));
    return 0;
}

首先在编译时选择-g从而保存调试信息，然后进入gdb。在gdb中，list或者l可以查看代码，+和-号可以调整查看代码位置。退出命令为quit。

PS E:\Code\PL\all> gcc -g test.c
PS E:\Code\PL\all> gdb .\a.exe  
GNU gdb (GDB) 7.6.1
...
Reading symbols from E:\Code\PL\all\a.exe...done.
(gdb) l         #或者输入list
7           }
8           if(n>1)
9               return n*fac(n-1);
10          else
11              return 1;
12      }
13
14      int main(){
     
15          int a;
16          scanf("%d",&a);
(gdb) 

gdb常用命令如下

命令	简写	功能	备注
quit	q	退出
list	l	查看源码	可加数字表示开始行
break	b	设置断点	可加数字表示行数，或者函数名称
info	i	现实断电信息
start	s	开始调试
run	r	运行程序	如果有断点，则运行至断点
continue	c	继续执行	直到下一个断点
step	s	单行调试	如为函数，则进入
next	n	单行调试	如为函数，则执行
print	p	打印变量	后接变量名

下面大致演示一下部分命令

(gdb) b 9       #设置断点
Breakpoint 1 at 0x401435: file test.c, line 9.
(gdb) run       #运行
Starting program: E:\Code\PL\all/.\a.exe 
[New Thread 15700.0x2ad0]
[New Thread 15700.0x2be8]
12              #输入

Breakpoint 1, fac (n=12) at test.c:9    #断点
9               return n*fac(n-1);
(gdb) print n   #显示n的值
$1 = 12
(gdb) n

Breakpoint 1, fac (n=11) at test.c:9
9               return n*fac(n-1);
(gdb) print n   #显示n的值
$2 = 11
(gdb)

Fortran

现在用Fortran的人貌似已经很少了，但还能在一些上古代码中看到，而且时不时的也会翻红一两次。MinGW中提供gfortran工具，包含在gcc-fortran中，安装方法与GCC相同。

安装完成后在命令行中输入

E:\Documents\00\0113>gfortran --version
GNU Fortran (MinGW.org GCC-8.2.0-5) 8.2.0
...

接下来就可以编译fortran代码了。

Makefile

对于稍微复杂一点的C语言程序，编译过程需要链接许多包，而每次调试几乎都在重复操作，费时费力。这时就需要通过Make file文件来及具体写出编译规则，然后运行make命令，从而自动化编译C和C++项目。

语法

目标...:依赖...
    命令1
    命令2
    ...

	常用变量
$@	表示规则中的目标
$<	规则中的第一个依赖条件
$>	所有的依赖条件

---

常用函数
wildcard	SRC = $(wildcard ./*.c)	匹配目录下所有.c文件
patsubst	OBJ = $(patsubst %.c, %.o, $(SRC))	SRC所有值中的.c替代为.o
$>	所有的依赖条件
ALL		指定生成的目标文件
clean		清理编译过程中产生的文件

示例

GCC = gcc
G++ = g++
RM = rm -f

BINS = readbmp
OBJS = readbmp.o bmp.o

all: $(BINS)

$(BINS): $(OBJS)
	$(GCC) -o $@ $(OBJS)

%:%.c
	$(GCC) -o $@ -g $<

%.o:%.c
	$(GCC) -c $<

clean:
	$(RM) $(OBJS) $(BINS)

CMake

CMake是比make更高级的编译工具，通过将CMakeLists.txt转化为makefile文件，从而生成目标程序。而CMakeLists.txt的基础语法为

cmake_minimum_required (VERSION 3.5)    #声明最低版本
set (CMAKE_CXX_FLAGS "-std=c++11")      #添加C++11标准的支持
PROJECT(rpt_main)                       #声明一个cmake工程
MESSAGE(STATUS "Project: SERVER")       #打印相关信息

#声明头文件的路径
include_directories(
${PROJECT_SOURCE_DIR}/../include/a
${PROJECT_SOURCE_DIR}/../include/b
)

#通过设定SRC变量，将源代码路径都传递给SRC
set(SRC
${PROJECT_SOURCE_DIR}/../include/a/a1.cpp
${PROJECT_SOURCE_DIR}/../include/a/a2.cpp
${PROJECT_SOURCE_DIR}/../include/b/b1.cpp
${PROJECT_SOURCE_DIR}/c1.cpp
)

# 创建静态库,设置路径，使生成的静态库在lib文件夹中
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/lib)
set(LIB_NAME abc_lib)                       #创建共享库

target_link_libraries(${LIB_NAME} pthred dl)#链接库文件

#编译主函数，首先设置路径，然后生成可执行文件
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/BIN)
add_executable(${PROJECT_NAME} ${SRC})      #生成可执行文件
# 声明可执行文件需要执行的库
target_link_libraries(${PROJECT_NAME} pthread dl ${LIB_NAME})

包管理用着很爽的语言

Python

选一个喜欢的Python版本，即可傻瓜式安装，注意安装过程中勾选加入环境变量。

python中几乎所有包都可以通过pip安装，但有的时候可能会因为网速或者某些玄学的原因发生意外，这时需要从pypi上找一个适合当前系统的安装包，然后在本地安装。

不过这种情况会越来越少，我记得17年的时候，网上还有windows下python安装jupyter notebook，tensorflow的教程，不过目前应该没有必要了。

虚拟环境

Anaconda是一个用于科学计算的 Python 发行版，包含很多流行的科学计算、数据分析的 Python 包。可以在清华镜像站下载。

一般通过Anaconda之后，会默认安装conda，除了可以取代pip作为包管理工具，同时可以进行虚拟环境的创建。执行conda activate命令可激活虚拟环境，默认虚拟环境为base；执行conda deactivate则能退出该环境；其创建环境的命令是create -n

E:\Documents\00\0430>conda activate
(base) E:\Documents\00\0430>conda deactivate
E:\Documents\00\0430>conda create -n test
Collecting package metadata (current_repodata.json): done
...
E:\Documents\00\0430>conda activate test
(test) E:\Documents\00\0430>

除了conda之外，还有virtualenv以及pipenv等虚拟环境工具。其安装、调用的基本方法为

• virtualenv

E:\Documents\00\0501>pip install virtualenv
E:\Documents\00\0501>virtualenv test
E:\Documents\00\0501>cd test\Scripts
E:\Documents\00\0501\test\Scripts>activate
(test) E:\Documents\00\0501\test\Scripts>

• pipenv

E:\Documents\00\0501>pip isntall pipenv
E:\Documents\00\0501>mkdir pipEnv
E:\Documents\00\0501>cd pipEnv
E:\Documents\00\0501\pipEnv>pipenv install
...
E:\Documents\00\0501\pipEnv>pipenv run

在Linux下也可以安装conda，以deepin为例

1. 下载miniconda
2. 切换到下载目录，为其赋予权限sudo chmod +x Miniconda3-latest-Linux-x86_64.sh。
3. 输入命令sudo bash Miniconda3-latest-Linux-x86_64.sh，然后会出现很多废话，不用管，直到询问Do you accept the license terms?，输入Yes。
4. 选择安装位置，
   1. 按下回车，会安装到默认位置/root/miniconda
   2. 按下ctrl+C会退出安装
   3. 输入其他路径，则安装位置会被更改。
5. 我这里直接选的回车，然后询问是否运行miniconda初始化命令，我这里选Yes。
6. 安装完成，但无法在命令行调用，故需要更改环境变量。在在~/.bashrc文件末尾加入export PATH=/opt/miniconda3/bin:$PATH。

打包

python可以通过pyinstaller对程序进行打包，比较重要的参数是-F -w，前者是打包成单文件，后者是屏蔽控制台。

通过这种方法得到的exe文件往往很大，打开速度很慢，这是因为pyinstaller在打包过程中将许多不必要的文件也添加了进去。

pyenv可以在一个设备上安装多个虚拟环境，从而大大缩减所需要的包的个数。在windows系统下，可以通过下面命令进行安装。

pip install pyenv-win --target "%USERPROFILE%\.pyenv"

安装结束之后，在命令行中输入pyenv之后会显示相应的版本信息。

Julia

选择一个能用得上的Julia安装，包管理工具为Pkg，按下]可直接进入pkg模式，然后通过add XXX添加XXX包。

Julia默认把包安装到C盘的用户目录下，可通过更改环境变量，来改变其默认位置。右键我的电脑->属性->高级系统设置->环境变量->新建。Julia安装包的环境变量名为JULIA_DEPOT_PATH，将其改为你的安装包路径，我的包目录设为D:\CS\Julia\packages\。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WT9TaVsp-1633997894365)(skills/envJulia.png)]

然后，进入Julia，输入DEPOT_PATH或者进入pkg模式查看安装包状态，可以看到设置成功。

julia> DEPOT_PATH
1-element Array{String,1}:
 "D:\\CS\\Julia\\packages"

(@v1.4) pkg> status
Status `D:\CS\Julia\packages\environments\v1.4\Project.toml`
  (empty environment)

此外，Julia默认下载源为Github，有的时候速度十分感人，故可选择设置国内的镜像。为此，需要先行安装PkgMirrors包。

(@v1.4) pkg> add PkgMirrors
    Cloning default registries into `D:\CS\Julia\packages`
    Cloning registry from "https://github.com/JuliaRegistries/General.git"
...

可见，安装包从Github下载到我们设置的目录中。目前，PkgMirrors支持两个镜像，分别是ZJU和USTC。

Ruby

在Ruby官网下载RubyInstaller，安装过程乏善可陈，注意添加环境变量，安装完成之后输入

PS E:\Code\PL\all\vueTest\demo> irb -v
irb 0.9.6(09/06/30)

Ruby中的包管理工具为gem,其命令行交互工具为irb，例如若想通过minimagick或者rimagick来处理图片，则其下载方法为

E:\Documents\00\1125>gem install mini_magick
E:\Documents\00\1125>irb
irb(main):001:0>

在通过gem install命令时，可能无法下载或安装失败，这可能是gem默认的官方镜像连接不顺利的原因，故需更改Ruby镜像。

gem sources可查看当前的镜像网站列表；gem help可以查看gem命令；gem add添加镜像，gem remove删除镜像。

目前比较好用的镜像网站为https://gems.ruby-china.com/.

E:\Documents\00\1125>gem sources
*** CURRENT SOURCES ***
https://rubygems.org/

E:\Documents\00\1125>gem sources --add https://gems.ruby-china.com/
https://gems.ruby-china.com/ added to sources

E:\Documents\00\1125>gem sources --remove https://rubygems.org/
https://rubygems.org/ removed from sources

E:\Documents\00\1125>gem sources
*** CURRENT SOURCES ***
https://gems.ruby-china.com/

基于JDK

JDK

下载JDK，安装。

目前最新版本为JDK17，安装过程已经配置好了环境变量，通过Win+R或在开始菜单中点击运行，输入cmd进入命令行，输入java -version以及javac -version来查看是否设置成功。

C:\Users\Laser>java -version
java version "17" 2021-09-14 LTS
Java(TM) SE Runtime Environment (build 17+35-LTS-2724)
Java HotSpot(TM) 64-Bit Server VM (build 17+35-LTS-2724, mixed mode, sharing)

C:\Users\laser>javac -version
javac 17

javap

装完JDK就可以愉快地使用Java了，新建一个java文件

//E:\Code\PL\all\test.java
public class test{
     
    public static void main(String[] args){
     
        System.out.println("Hello world");
    }
}

然后在命令行中输入

E:\Code\PL\all> javac test.java
E:\Code\PL\all> java test
Hello world

其中，javac用于编译.java文件，其完整格式为javac ，例如javac -d ，其中为目标路径，为源文件。

此外，javap是jdk自带的逆解析工具，可根据class字节码解析出当前类对应的汇编指令等。其使用方法为javap 。通过javap -help可以查看其支持的命令，列表如下

命令	简写	功能
-version		版本信息
-verbose	-v	输出附加信息
	-l	输出行号和本地变量表
-public		仅显示公共类和成员
-protected		显示受保护的/公共类和成员
-package		显示程序包/受保护的/公共类和成员
-private	-p	显示所有类和成员
	-c	对代码进行反汇编
	-s	输出内部类型签名
-sysinfo		显示正在处理的类的系统信息
-constants		显示最终常量
-classpath		指定查找用户类文件的位置
-cp		指定查找用户类文件的位置
-bootclasspath		覆盖引导类文件的位置

例如对于上述test，

PS E:\Code\PL\all> javap -p test
Compiled from "test.java"
public class test {
     
  public test();
  public static void main(java.lang.String[]);
}

便于说明javap的工作原理，将test.java改写如下

//test.java
public class test{
     
    private static int value = 10;
    public static int fac(int n){
     
        if(n>1)
            return n*fac(n-1);
        else
            return 1;
    }
    public static void main(String[] args){
     
        int v = fac(value);
        System.out.println(v);
    }
}

编译运行

PS E:\Code\PL\all> javac .\test.java
PS E:\Code\PL\all> java test        
3628800

使用javap -c命令查看其反汇编代码及其注释说明，注释参考java字节码指令。

PS E:\Code\PL\all> javap -c test
Compiled from "test.java"
public class test {
     
  public test();
    Code:
       0: aload_0               //将this压入栈中
       1: invokespecial #1      //初始化类
       4: return

  public static int fac(int);
    Code:
       0: iload_0           //将第一个int变量送入栈顶（即n)
       1: iconst_1          //取出int常量1，压入栈中
       2: if_icmple     14  //如果n<=1，则跳转至14
       5: iload_0           //将n送入栈顶
       6: iload_0           //将n送入栈顶，此时栈顶为n,n
       7: iconst_1          //将1压入栈中
       8: isub              //栈顶的两个值相减，此时栈顶为n-1,n
       9: invokestatic  #2  //调用静态方法fac:(I)I，此时栈顶为fac(n-1),n
      12: imul              //栈顶的两个值相乘
      13: ireturn           //返回int型常量
      14: iconst_1          //取出1
      15: ireturn           //返回1

  public static void main(java.lang.String[]);
    Code:
       0: getstatic     #3  //将静态域压入栈顶，即int v
       3: invokestatic  #2  //调用fac
       6: istore_1          //将int型值存入第二个本地变量
       7: getstatic     #4  //将静态方法压入栈顶，该方法为PrintStream;
      10: iload_1           //加载第二个本地变量，即v
      11: invokevirtual #5  //调用实例方法，即println将v输出
      14: return

  static {
     };
    Code:
       0: bipush        10  //将10压入栈中(即value)
       2: putstatic     #3  //为v赋值
       5: return
}

Scala

如果没装JDK，请先安装Java，然后进入Scala下载页面，下载scala3，目前版本为3.02；若想通过java调用，则下载coursier.jar，目前最新版本为2.0.6。

也可以通过命令行下载cs.exe。

> bitsadmin /transfer cs-cli https://git.io/coursier-cli-windows-exe "%cd%\cs.exe"

下载coursier.jar之后在命令行中通过java来调用，进入之后会提示是否把scala加入环境变量，选择y。由于安装过程需要从github下载一些东西，所以可能会玄学性地卡死，退出重新运行或者科学上网吧。

E:\Documents\00\1002\javaTest>java -jar coursier.jar

     ________ ___   / /  ___
    / __/ __// _ | / /  / _ |
  __\ \/ /__/ __ |/ /__/ __ |
 /____/\___/_/ |_/____/_/ | |
                          |/

Checking if a JVM is installed
Found a JVM installed under D:\CS\Java\jdk-17.

如果下载了cs.exe，则在命令行中运行

>cs install scala
>scala
Welcome to Scala 2.13.6 (Java HotSpot(TM) 64-Bit Server VM, Java 17).
Type in expressions for evaluation. Or try :help.

scala>

下载后安装，安装过程会自动将安装路径加入环境变量，安装完成后进入命令行，输入scala，进入scala的交互操作截面，则说明安装成功。

C:\Users\Laser>scala
Welcome to Scala 2.13.1 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_144).
Type in expressions for evaluation. Or try :help.
scala> println("Hello world")
Hello world
/*scala写一个阶乘*/
scala> def fac(n:Int):Int={
     
     | if(n>1)
     | return n*fac(n-1)
     | else
     | return 1}
def fac(n: Int): Int

scala> fac(10)
val res1: Int = 3628800

Groovy

直接在Groovy官网下载即可，格式为zip，直接解压即可使用。当然，也可以选择二进制文件，安装使用。

其最新版本为Groovy4.0，号称下一代版本，安装时自动配置环境变量，然后可直接在命令行中进入Groovy的交互式操作窗口

>groovysh
Groovy Shell (4.0.0-beta-1, JVM: 17)
Type ':help' or ':h' for help.
-------------------------------------------------------------------------------
groovy:000> test = "hello world"
===> hello world
groovy:000> println test
hello world
===> null
//实现一个阶乘函数
groovy:000> def int fac(int n){
     
groovy:001> if(n>1)
groovy:002> return n*fac(n-1)
groovy:003> else
groovy:004> return 1}
===> true
groovy:000> fac(10)
===> 3628800
groovy:000>

Clojure

Clojure是Lisp在JVM中运行的一种方言，所以可以预想其语言风格应该是括号之间的环环相扣。由于是在Java虚拟机中运行，所以应该事先下载JDK，然后安装Clojure。

在windows下有两种安装方法，其一是通过mvn对源码进行编译，

git clone https://github.com/clojure/clojure.git
cd clojure
mvn -Plocal -Dmaven.test.skip=true package

首先从github上下载下载器，然后在Powershell中运行。

由于powershell默认是不允许运行脚本的，所以第一次开启需要通过管理员模式打开power shell，然后输入set-executionpolicy Unrestricted，选择y。（当然这很危险，在装完之后记得改回 restricted模式，set-executionpolicy Restricted。

执行脚本之后会提示已经安装成功，然后可以尝试一下

nil
user=> (defn fac [x] (loop [n x f 1] (if (= n 1) f (recur (dec n) (* f n)))))
#'user/fac
user=> (fac 15)
1307674368000

clojure的函数defn默认不支持递归，故可通过recur来进行声明。

Android

首先也是安装JDK，然后下载安装Android Studio.

安装完成之后如图所示

点击开始新的安卓项目，AS提供了不同平台上的开发模板，初学者一般选择Basic Activity即可。

然后是项目配置窗口，项目名称、包名称、项目路径等按需选择即可，需要注意的是下面有一个语言选择选项，在此默认选择Kotlin，我们先选择Java。再下面则是最小API级别选项，所谓API等级，可以理解为版本号，一般来说向后兼容，在这里直接选最新的版本即可，然后点击Finish。

配置完成之后就进入了IDE界面，由于我们使用的是模板，所以直接点击运行即可。不过一般来说，这个时候AS会启动Gradle Daemon，然后Gradle sync启动，开始下载gradle，如果网速比较慢的话，可以选择手动下载最新版Gradle。

然后解压到相应的文件夹中，一般在项目的根目录下有.gradle文件夹，解压进去即可。

这时还不能运行，还需要配置虚拟机，点击No devices->Open AVD Manager。

然后在弹出的窗口中点击Create Vitual Device，随便选一个Phone下载即可，文件比较大，需要耐心等候。

下载完成之后点击next，然后点击Run App即可，就能看到模拟演示了。

Kotlin

Kotlin可以运行在Jupyter notebook中，如果已经安装了Python，命令行下输入pip install kotlin-jupyter-kernel便能进入。

.NET相关语言

.Net相关语言只要下载一个VS就足够了，不过考虑到.Net Core已经可以跨平台，日后说不定就要到Linux上写，所以脱离VS进行.Net编程还是有一定的意义的。

如果不想安装VS，则直接下载.net Core，不同版本的.net core存在很大差异，有时不得不安装多个版本。运行dotnet --list-sdks可以查看已经安装的dotnet版本。

C:\Users\Laser>dotnet --list-sdks
3.1.407 [C:\Program Files\dotnet\sdk]
5.0.202 [C:\Program Files\dotnet\sdk]

C#

大部分人可能一提到.Net马上想到的就是C#，所以装完.net Core之后自然需要创建C#程序尝试一下。

E:\Documents\00\0107>dotnet new console
...
Restore succeeded.
E:\Documents\00\0107>dotnet run
Hello World!

除了创建C#项目，dotnet命令也可以进行包管理。

>dotnet new console
>dotnet add package MathNet.Numerics
>dotnet list package
项目“dTest”具有以下包引用
   [netcoreapp3.1]:
   顶级包                     已请求      已解决
   > MathNet.Numerics      4.15.0   4.15.0

F#

F#的安装非常简单，只需要下载最新版的VisualStudio，安装时选中F#即可。创建项目也很简单，只要在VS中新建一个F#项目即可。快捷键F5启动程序，可以在命令行中查看输出。

当然，dotnet工具也可以快速创建F#项目

dotnet new sln -o test							//使用new命令新建一个项目
dotnet new classlib -lang F# -o src\Library		//创建一个由F#语言编写的classlib
dotnet sln test add src\Library\Library.fsproj	//将Library添加到test中的sln中

其目录结构为

E:\Documents\00\0107>tree /a /f
卷 工作 的文件夹 PATH 列表
卷序列号为 3895-5CDD
E:.
+---src
|   \---Library
|       |   Library.fs
|       |   Library.fsproj
\---test
        test.sln

其中，Library.fs为F#的源代码。

需要说明的是，vs中提供了一个交互式操作工具fsi.exe，可以通过dotnet fsi打开。其路径大致为

..\2019\Common7\IDE\CommonExtensions\Microsoft\FSharp\fsi.exe

加入环境变量后，可直接从命令行进入

C:\Users\Laser>fsi

Microsoft(R) F# 交互窗口版本 10.6.0.0 for F# 4.7
版权所有(C) Microsoft Corporation。保留所有权利。

若要获得帮助，请键入 #help;;

> let a = 1;;			//绑定a值为1
val a : int = 1

> let addOne x = x+1	//没有;;则不输出
- let addThree x = x|> addOne |> addOne |> addOne;;//管道操作
val addOne : x:int -> int
val addThree : x:int -> int

Q#

Q#是一款量子编程语言，目前，微软提供的QDK就可以作为一门独立语言运行，也可以嵌入Python或C#、F#等.NET语言进行工作。但无论在哪里工作，都必须安装.Net Core3.1。

Q# @VSCODE

如果使用VS Code，则在插件栏中搜索Microsoft Quantum Development Kit Preview，点击安装，下载Q#可能需要一点时间。

安装成功后，可以创建新项目：快捷键Ctrl+Shift+P，输入“Q#:Create New Project->选择Standalone console application->在弹出的对话框中输入项目名称test，然后创建。

在创建的test文件夹中有一个Program.qs文件，在终端中进入test文件夹，然后输入dotnet run，就可以运行这个Q#程序

PS E:\Code\test> dotnet run
Hello quantum world!

Q# @Python

若希望通过Python运行Q#，最便捷的方式是通过conda进行。

conda create -n qsharp -c microsoft qsharp notebook
conda activate qsharp
python -c "import qsharp"

create -n用于创建环境，activate用于激活环境，conda会自动下载需要的内容，进入环境之后，写一个示例程序Operation.qs：

namespace Qrng {
    open Microsoft.Quantum.Intrinsic;

    operation qGenerator() : Result {
        use q = Qubit(); // 设置一个Q比特
        H(q);            
        let r = M(q);    // 测量Q比特的值
        Reset(q);
        return r;
    }
}

在相同的文件夹下进入python，调用该文件

python
>>>import qsharp
>>>from Qrng import qGenerator()
>>> print(qGenerator.simulate())
0
>>> print(qGenerator.simulate())
0
>>> print(qGenerator.simulate())
1

Q# @dotnet

首先下载Qsharp的模板，然后通过dotnet命令创建新的Q#程序。

>dotnet new -i Microsoft.Quantum.ProjectTemplates
>dotnet new console -lang Q# -o runSayHello
>cd runsayHello
>dotnet run
Hello quantum world!

如果希望在C#等程序中调用Q#，则需要创建Q#库

>dotnet new classlib -lang Q# -o quantum
>dotnet new console -lang C# -o host
>cd host
>dotnet add refrence ../quantum/quantum.csproj
已将引用“..\quantum\quantum.csproj”添加到项目。

前端

NodeJs

NodeJs相当于Javascript的本地编译器，直接从官网选择Windows Installer (.msi)下载，安装过程除了安装地址之外，一路Next。

安装完成之后在命令行中输入node --version，如果有反馈说明已经被添入环境变量。输入node后面不加变量则进入了交互模式。

C:\Users\Laser>node --version
v12.6.0

C:\Users\Laser>node
Welcome to Node.js v12.6.0.
Type ".help" for more information.
> console.log("test")
test
undefined
> .exit
C:\Users\Laser>npm -v
6.9.0

在安装nodejs的过程中，也会顺便安装上npm，输入npm -v可以显示当前版本。有了npm就啥都有了。

如果感觉网速不够的话可以换源

npm install -g cnpm --registry=https://registry.npm.taobao.org

TypeScript

首先安装nodejs，从而通过npm进行全局安装。

npm install -g typescript

typescript是Javascript的一个超集，通过tsc可以将其翻译成javascript`。

例如ts文件为

//test.ts
function add(x:number, y:number=12, z?:number):number{
     
    if (z)
        return x+y+z;   //单行代码可以不用{}
    else
        z = 0;
        return x+y;
}
console.log(add(1));    //由于y默认为12，所以输出为13
console.log(add(1,2));  //如果在声明时，z不加?会报错。

在命令行中输入

tsc test.ts

即可在同目录下得到js文件

//test.js
function add(x, y, z) {
     
    if (y === void 0) {
      y = 12; }
    if (z)
        return x + y + z; //单行代码可以不用{}
    else
        z = 0;
    return x + y;
}
console.log(add(1)); //由于y默认为12，所以输出为13
console.log(add(1, 2)); //如果在声明时，z不加?会报错。

react

目前使用人数最多的前端框架，首先还是先下载nodejs，然后用npm下载crate-react-app。

npm install -g crate-react-app

下载成功之后输入

create-react-app test

下载时间较长，稍安勿躁，创建之后可直接运行

E:\Code\PL\all\react> cd test
E:\Code\PL\all\react\test> npm init
//各种回车
E:\Code\PL\all\react\test> npm start

命令行中会出现如下提示

Compiled successfully!

You can now view test in the browser.

  Local:            http://localhost:3000/       
  On Your Network:  http://192.168.183.1:3000/   

Note that the development build is not optimized.
To create a production build, use yarn build.    

说明模板创建成功。

vue.js

通过npm安装webpack，vue命令行工具vue-cli，

npm install webpack -g
npm install vue-cli -g

然后可以用vue命令创建一个vue项目

PS E:\Code\PL\all\vueTest> vue init webpack test

由于需要下载一些工具，所以请稍安勿躁。安装完成后，进入项目文件夹，安装项目依赖

E:\Code\PL\all\vueTest>cd test
E:\Code\PL\all\vueTest\test> npm install

vue3

npm install -g @vue/cli

安装之后查看版本，如果版本不够新的话可以进行更新。

vue --version
npm install -g @vue/cli     #可自动更新

然后创建项目

vue create vue3-1

然后命令行会弹出一些问题

1. 是否使用淘宝源：Y
2. 选择预选项：选Manually
3. 会有一系列选项，通过按下空格进行选择，选上Typescript
4. 选择版本：3.x
5. 是否使用class-style component syntax：不需要
6. 是否使用babel
7. 。。。

最后运行

npm run serve

vue3支持图形界面创建

vue ui
E:\Documents\00\1228\vue3Test>vue ui
  Starting GUI...
  Ready on http://localhost:8000