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

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

文章目录

  • 汇编
  • GCC(C&C++、Fortran)
    • 安装GCC&G++
    • 基本用法
    • gdb调试
    • Fortran
    • Makefile
    • CMake
  • 包管理用着很爽的语言
    • Python
      • 虚拟环境
      • 打包
    • Julia
    • Ruby
  • 基于JDK
    • JDK
    • javap
    • Scala
    • Groovy
    • Clojure
    • Android
    • Kotlin
  • .NET相关语言
    • C#
    • F#
    • Q#
      • Q# @VSCODE
      • Q# @Python
      • Q# @dotnet
  • 前端
    • NodeJs
    • TypeScript
    • react
    • vue.js
    • vue3

汇编

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:/MASMmount后的内容为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 gccg++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 notebooktensorflow的教程,不过目前应该没有必要了。

虚拟环境

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支持两个镜像,分别是ZJUUSTC

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.

安装完成之后如图所示

十六种编程语言的环境配置2021版(建议收藏)_第1张图片

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

十六种编程语言的环境配置2021版(建议收藏)_第2张图片

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

十六种编程语言的环境配置2021版(建议收藏)_第3张图片

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

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

十六种编程语言的环境配置2021版(建议收藏)_第4张图片

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

十六种编程语言的环境配置2021版(建议收藏)_第5张图片

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

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

十六种编程语言的环境配置2021版(建议收藏)_第6张图片

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

你可能感兴趣的